1073 files changed, 502155 insertions, 0 deletions

diff --git a/private/tapi/dev/align/align.c b/private/tapi/dev/align/align.c
new file mode 100644
index 000000000..0d14303bb
--- /dev/null
+++ b/private/tapi/dev/align/align.c
@@ -0,0 +1,55 @@
+#include <stdio.h>
+
+void main()
+{
+  long int y;
+  char s1[8] = { 0,1,2,3,4,5,6,7 };
+  long int x;
+  char *s = s1;
+
+
+  printf("hello world0\r\n");
+  x = (long int)s[0];
+  printf("hello world1\r\n");
+  x = (long int)s[1];
+  printf("hello world2\r\n");
+  x = (long int)s[2];
+  printf("hello world3\r\n");
+  x = (long int)s[3];
+
+printf ("\r\n");
+
+  printf ("x%08lx, x%x\r\n", *((long*) (s+0)), (long*)s+0);
+  printf ("x%08lx, x%x\r\n", *((long*) (s+1)), (long*)s+1);
+  printf ("x%08lx, x%x\r\n", *((long*) (s+2)), (long*)s+2);
+  printf ("x%08lx, x%x\r\n", *((long*) (s+3)), (long*)s+3);
+
+printf ("\r\n");
+
+  printf ("x%08lx, x%x\r\n", (long)*(s+0), (long)(s+0) );
+  printf ("x%08lx, x%x\r\n", (long)*(s+1), (long)(s+1) );
+  printf ("x%08lx, x%x\r\n", (long)*(s+2), (long)(s+2) );
+  printf ("x%08lx, x%x\r\n", (long)*(s+3), (long)(s+3) );
+
+printf ("\r\n");
+
+  printf ("x%x\r\n", *((long*) s+0));
+  printf ("x%x\r\n", *((long*) s+1));
+  printf ("x%x\r\n", *((long*) s+2));
+  printf ("x%x\r\n", *((long*) s+3));
+
+printf ("\r\n");
+
+printf ("s@ 0x%08lx   x@ 0x%08lx", (long)&s, (long)&x );
+
+printf ("\r\n");
+
+  if ( (long)&x > (long)&s )
+     x = (char *)&x-(char*)&y;
+  else
+     x = (char *)&y-(char*)&x;
+
+  printf ("size %08lx\r\n", x);
+
+
+}
diff --git a/private/tapi/dev/align/makefile b/private/tapi/dev/align/makefile
new file mode 100644
index 000000000..68867704a
--- /dev/null
+++ b/private/tapi/dev/align/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/align/sources b/private/tapi/dev/align/sources
new file mode 100644
index 000000000..0faddffcd
--- /dev/null
+++ b/private/tapi/dev/align/sources
@@ -0,0 +1,22 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=align
+TARGETPATH=.
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+USE_CRTDLL=1
+
+SOURCES=align.c
+
+UMTYPE=console
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
+
diff --git a/private/tapi/dev/apps/acd/acdsmpl.c b/private/tapi/dev/apps/acd/acdsmpl.c
new file mode 100644
index 000000000..8601bf63f
--- /dev/null
+++ b/private/tapi/dev/apps/acd/acdsmpl.c
@@ -0,0 +1,2495 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  ACDSMPL.C
+//
+//  Handles all the UI for ACDSample
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <windows.h>
+#include <commctrl.h>
+#include <commdlg.h>
+#include <tapi.h>
+#include <stdlib.h>
+#include "resource.h"
+#include "acdsmpl.h"
+
+
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+static LRESULT CALLBACK MainDlgProc (HWND   hwnd,
+                                     UINT   uMsg,
+                                     WPARAM wParam,
+                                     LPARAM lParam);
+void MySetWindow(HWND, int);
+void MySaveWindow(HWND);
+BOOL ResizeWindows(BOOL bSizeBar, DWORD dwBarLocation);
+HTREEITEM AddItemToTree(HTREEITEM hParent,
+                        LPTSTR lpszName,
+                        LPARAM lParam,
+                        HTREEITEM * phItem);
+BOOL DoPopupMenu(HTREEITEM hItem, POINT pt);
+BOOL DeleteLeafAndStruct(HTREEITEM hItem);
+BOOL CALLBACK ChangeGroupDlgProc(HWND   hWnd,
+                            UINT   uMsg,
+                            WPARAM wParam,
+                            LPARAM lParam);
+BOOL CALLBACK ChangeAgentDlgProc(HWND   hWnd,
+                            UINT   uMsg,
+                            WPARAM wParam,
+                            LPARAM lParam);
+BOOL CALLBACK AddGroupDlgProc(HWND   hWnd,
+                         UINT   uMsg,
+                         WPARAM wParam,
+                         LPARAM lParam);
+BOOL CALLBACK AddAgentDlgProc(HWND   hWnd,
+                         UINT   uMsg,
+                         WPARAM wParam,
+                         LPARAM lParam);
+LRESULT DoCommand(WPARAM wParam, LPARAM lParam);
+void AddGroupsToMenu(HTREEITEM hItem,
+                     HMENU hMenu);
+BOOL CALLBACK GroupAddToListProc(HWND   hWnd,
+                            UINT   uMsg,
+                            WPARAM wParam,
+                            LPARAM lParam);
+BOOL CALLBACK AgentAddToListProc(HWND   hWnd,
+                            UINT   uMsg,
+                            WPARAM wParam,
+                            LPARAM lParam);
+BOOL BuildLineList(HWND hWnd,
+                   DWORD dwDeviceID);
+BOOL BuildAddressList(HWND hWnd,
+                      HWND hParentWnd,
+                      DWORD dwDeviceID);
+BOOL InitializeTapi();
+BOOL CleanUp();
+BOOL UpdateGroupLeaf(PGROUP pGroup);
+BOOL DoAgentView();
+BOOL DoGroupView();
+BOOL ReadInFile();
+BOOL WriteToDisk();
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//  GLOBALS
+//////////////////////////////////////////////////////////////////////////////
+ACDGLOBALS      g;
+
+TCHAR gszACDSampleKey[]     = TEXT("Software\\Microsoft\\ACDSample");
+TCHAR gszPlacementValue[]   = TEXT("WindowPlacement");
+TCHAR gszBarLocation[]      = TEXT("BarLocation");
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+int WINAPI WinMain (HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow)
+{
+    MSG msg;
+
+    // initialize global variables
+    g.hInstance = hInstance;
+    g.pAgents = NULL;
+    g.pGroups = NULL;
+
+    // init tapi stuff
+    if (!InitializeTapi())
+    {
+        MessageBox(NULL,
+                   TEXT("TAPI could not be initialized.\nVerify that")
+                   TEXT("your machine has TAPI devices installed"),
+                   TEXT("Cannot start ACDSMPL"),
+                   MB_OK);
+    }
+
+    if (!CreateMainWindow(nCmdShow))
+    {
+        return 0;
+    }
+
+    // main message loop
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        if (!IsDialogMessage(g.hMainWnd,
+                             &msg))
+        {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+    }
+
+    return 1;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  CreateMainWindow()
+//
+//////////////////////////////////////////////////////////////////////////////
+BOOL CreateMainWindow (int nCmdShow)
+{
+
+    // InitCommonControls for TreeView control
+    InitCommonControls();
+
+    // Create the main window
+    g.hMainWnd = CreateDialog(g.hInstance,
+                             MAKEINTRESOURCE(IDD_MAINDLG),
+                             NULL,
+                             MainDlgProc);
+
+    if (g.hMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+    // restore default location
+    MySetWindow(g.hMainWnd, nCmdShow);
+    
+    // store global hwnds
+    g.hTreeWnd = GetDlgItem(g.hMainWnd,
+                            IDC_TREEWND);
+
+    g.hLogWnd = GetDlgItem(g.hMainWnd,
+                           IDC_EDITWND);
+
+    if ((g.hTreeWnd == FALSE) || (g.hLogWnd == FALSE))
+    {
+        return FALSE;
+    }
+
+    ResizeWindows(FALSE, 0);
+
+    return TRUE;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  MainDlgProc()
+//
+//////////////////////////////////////////////////////////////////////////////
+LRESULT CALLBACK MainDlgProc (HWND   hWnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    static BOOL     bButtonDown = FALSE;
+    
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+            return TRUE;
+
+        case WM_COMMAND:
+        {
+            LRESULT lResult;
+            
+            lResult = DoCommand(wParam, lParam);
+            return lResult;
+        }
+
+        // button and mousemove messages tracked to move
+        // the bar between the treeview control and the
+        // edit control
+        case WM_LBUTTONDOWN:
+        {
+            bButtonDown = TRUE;
+            SetCapture(hWnd);
+            return 0;
+        }
+
+        case WM_LBUTTONUP:
+        {
+            bButtonDown = FALSE;
+            ReleaseCapture();
+            return 0;
+        }
+
+        case WM_MOUSEMOVE:
+        {
+            if (bButtonDown)
+            {
+                ResizeWindows(TRUE, (DWORD)LOWORD(lParam));
+                return 1;
+            }
+            break;
+        }
+
+        case WM_SIZE:
+        {
+            ResizeWindows(FALSE, 0);
+            return 1;
+        }
+
+        // catch right click in tree view to make
+        // popup menu
+        case WM_NOTIFY:
+        {
+            LPNMHDR     pnmhdr;
+            POINT       pt;
+            HTREEITEM   hItem;
+            TV_HITTESTINFO  hittestinfo;
+            RECT        rc;
+
+            pnmhdr = (LPNMHDR)lParam;
+
+            // make sure it's a right click and it's in the treeview
+            if ((pnmhdr->code != NM_RCLICK) || (pnmhdr->hwndFrom != g.hTreeWnd))
+            {
+                break;
+            }
+
+            GetCursorPos(&pt);
+            GetWindowRect(g.hTreeWnd,
+                          &rc);
+            
+            hittestinfo.pt.x = pt.x - rc.left;
+            hittestinfo.pt.y = pt.y - rc.top;
+
+            // hittest to get the tree view item
+            hItem = TreeView_HitTest(g.hTreeWnd,
+                                     &hittestinfo);
+
+            // only display a menu if the mouse is actually
+            // over the item (TVHT_ONITEM)
+            if (hItem == NULL || (!(hittestinfo.flags & TVHT_ONITEM)) )
+            {
+                return TRUE;
+            }
+
+            // select that item (right clicking will not select
+            // by default
+            TreeView_Select(g.hTreeWnd,
+                            hItem,
+                            TVGN_CARET);
+
+            // create the menu
+            DoPopupMenu(hItem, pt);
+
+            return TRUE;
+                           
+            
+        }
+        
+        case WM_CLOSE:
+
+            // save the current window location
+            WriteToDisk();
+            CleanUp();
+            MySaveWindow(hWnd);
+            PostQuitMessage(0);
+            return 1;
+
+        default:
+            break;
+    }
+    return 0;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  ResizeWindows - Handles resizing the two child windows of the
+//      main window.  If bSizeBar is true, then the sizing is happening
+//      because the user is moving the bar.  if bSizeBar is false, the sizing
+//      is happening because of the WM_SIZE or something like that.
+//
+////////////////////////////////////////////////////////////////////////////////
+BOOL ResizeWindows(BOOL bSizeBar, DWORD dwBarLocation)
+{
+    RECT            rc, rc2;
+    int             x;
+
+    // is the user moving the bar?
+    if (!bSizeBar)
+    {
+        dwBarLocation = g.dwBarLocation;
+    }
+
+    GetClientRect(g.hMainWnd, &rc);
+
+    // make sure the bar is in a OK location
+    if (bSizeBar)
+    {
+        if ((LONG)dwBarLocation < GetSystemMetrics(SM_CXSCREEN)/WINDOWSCALEFACTOR)
+            return FALSE;
+
+        if ((LONG)(rc.right - dwBarLocation) < GetSystemMetrics(SM_CXSCREEN)/WINDOWSCALEFACTOR)
+            return FALSE;
+    }
+
+    // save the bar location
+    g.dwBarLocation = dwBarLocation;
+
+    // get the size of the frame
+    x = GetSystemMetrics(SM_CXFRAME);
+
+    // move tree windows
+    MoveWindow(g.hTreeWnd,
+               0,
+               0,
+               dwBarLocation,
+               rc.bottom,
+               TRUE);
+
+    // get the size of the window (in case move window failed
+    GetClientRect(g.hTreeWnd, &rc2);
+
+    // move the edit window with respect to the tree window
+    MoveWindow(g.hLogWnd,
+               rc2.right-rc2.left+x+SIZEBAR,
+               0,
+               rc.right-(rc2.right-rc2.left)-x-SIZEBAR,
+               rc.bottom,
+               TRUE);
+
+    return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  MySetWindow - reads in the window placement from registry
+//  and sets the window and bar.
+//
+//////////////////////////////////////////////////////////////////////////////
+void MySetWindow(HWND hWnd, int nCmdShow)
+{
+    WINDOWPLACEMENT     pwp;
+    HKEY                hKey;
+    DWORD               dwDataSize;
+    DWORD               dwDataType;
+    RECT                rc;
+
+    pwp.length = sizeof(WINDOWPLACEMENT);
+
+    // open the key and read in the WINDOWPLACEMENT structure
+    RegOpenKeyEx(HKEY_CURRENT_USER,
+                 gszACDSampleKey,
+                 0,
+                 KEY_ALL_ACCESS,
+                 &hKey);
+
+    dwDataSize = sizeof(pwp);
+    
+    if ( RegQueryValueEx(hKey,
+                         gszPlacementValue,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)&pwp,
+                         &dwDataSize) )
+    {
+        // if it fails, default
+        ShowWindow(g.hMainWnd, nCmdShow);
+        GetWindowRect(g.hMainWnd, &rc);
+        g.dwBarLocation = (rc.right - rc.left) / 2;
+    }
+    else
+    {
+        // if it succeeds, set the window and bar
+        dwDataSize = sizeof(DWORD);
+        
+        if (RegQueryValueEx(hKey,
+                            gszBarLocation,
+                            0,
+                            &dwDataType,
+                            (LPBYTE)&g.dwBarLocation,
+                            &dwDataSize))
+        {
+            g.dwBarLocation = (pwp.rcNormalPosition.right - pwp.rcNormalPosition.left) / 2;
+        }
+
+        SetWindowPlacement(g.hMainWnd, &pwp);
+    }
+
+
+    RegCloseKey( hKey );
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  MySaveWindow() - save the current window placement and bar
+//
+//////////////////////////////////////////////////////////////////////////////
+void MySaveWindow(HWND hWnd)
+{
+    WINDOWPLACEMENT     pwp;
+    HKEY                hKey;
+    DWORD               dwDisposition;
+
+
+    pwp.length = sizeof(WINDOWPLACEMENT);
+
+    // get and save
+    GetWindowPlacement(hWnd, &pwp);
+
+    RegCreateKeyEx(HKEY_CURRENT_USER,
+                   gszACDSampleKey,
+                   0,
+                   TEXT(""),
+                   REG_OPTION_NON_VOLATILE,
+                   KEY_ALL_ACCESS,
+                   0,
+                   &hKey,
+                   &dwDisposition);
+
+    RegSetValueEx(hKey,
+                  gszPlacementValue,
+                  0,
+                  REG_BINARY,
+                  (LPBYTE)&pwp,
+                  sizeof(WINDOWPLACEMENT));
+
+    RegSetValueEx(hKey,
+                  gszBarLocation,
+                  0,
+                  REG_DWORD,
+                  (LPBYTE)&g.dwBarLocation,
+                  sizeof(DWORD));
+
+    RegCloseKey( hKey );
+
+}
+
+ 
+//////////////////////////////////////////////////////////////////////////////
+//
+//  AddItemToTree
+//
+//    add a new leaf to the tree
+//
+//////////////////////////////////////////////////////////////////////////////
+HTREEITEM AddItemToTree(HTREEITEM hParent,
+                        LPTSTR lpszName,
+                        LPARAM lParam,
+                        HTREEITEM * phItem)
+{ 
+    TV_ITEM         tvi; 
+    TV_INSERTSTRUCT tvins; 
+    HTREEITEM       hti; 
+ 
+    tvi.mask = TVIF_TEXT | TVIF_PARAM;
+ 
+    // Set the text of the item. 
+    tvi.pszText = lpszName; 
+    tvi.cchTextMax = lstrlen(lpszName) * sizeof(TCHAR);
+
+    // Save the pointer to the buffer
+    tvi.lParam = lParam;
+ 
+    tvins.item = tvi; 
+    tvins.hInsertAfter = TVI_SORT;
+ 
+    // Set the parent item
+    tvins.hParent = hParent;
+    
+    // Add the item to the tree-view control. 
+    hti = (HTREEITEM) SendMessage(g.hTreeWnd,
+                                  TVM_INSERTITEM,
+                                  0, 
+                                  (LPARAM) (LPTV_INSERTSTRUCT) &tvins);
+
+    // save hitem
+    if (phItem)
+    {
+        *phItem = hti;
+    }
+
+    // select the item so it has focus
+    TreeView_Select(g.hTreeWnd,
+                    hti,
+                    TVGN_CARET);
+ 
+    return hti;
+} 
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  DoPopupMenu(HTREEITEM hItem,
+//              POINT pt)
+//
+//      hItem - item to create menu for
+//      pt - location of mouse so we can create menu where it is
+//
+//   creates a popup menu, depending on what kind of item is selected 
+//
+//////////////////////////////////////////////////////////////////////////////
+BOOL DoPopupMenu(HTREEITEM hItem, POINT pt)
+{
+
+    HMENU       hMenu;
+    TV_ITEM     tvi;
+    TCHAR       szNewGroup[]        = TEXT("&New Group...");
+    TCHAR       szNewAgent[]        = TEXT("New &Agent...");
+    TCHAR       szAddAgent[]        = TEXT("A&dd Agent...");
+    TCHAR       szGroupProperties[] = TEXT("&Group Properties...");
+    TCHAR       szAgentStatus[]     = TEXT("Agent Status...");
+    TCHAR       szAddGroup[]        = TEXT("Add Group...");
+    TCHAR       szAgentProperties[] = TEXT("Agent Properties...");
+    TCHAR       szGroupDelete[]     = TEXT("Group Delete");
+    TCHAR       szAgentDelete[]     = TEXT("Agent Delete");
+    TCHAR       szSignIn[]          = TEXT("Agent Sign In");
+    TCHAR       szSignOut[]         = TEXT("Agent Sign Out");    
+
+    // get the selected item
+    g.hTreeItemWithMenu = hItem;
+
+    // create the menu
+    hMenu = CreatePopupMenu();
+
+    // get the lParam, which is a pointer to the item
+    tvi.mask = TVIF_HANDLE | TVIF_PARAM;
+    tvi.hItem = hItem;
+
+    TreeView_GetItem(g.hTreeWnd,
+                     &tvi);
+
+    if (!tvi.lParam)
+    {
+        return TRUE;
+    }
+    
+    switch (((PGROUP)tvi.lParam)->dwKey)
+    {
+        // root item
+        case GROUPROOTKEY:
+            
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       IDM_NEWGROUP,
+                       szNewGroup);
+            break;
+
+        // root item
+        case AGENTROOTKEY:
+            
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       IDM_NEWAGENT,
+                       szNewAgent);
+            break;
+        // group leaf
+        case GROUPKEY:
+            
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       (UINT)IDM_GROUPADDTOLIST,
+                       szAddAgent);
+            
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       (UINT)IDM_GROUPAGENTSTATUS,
+                       szAgentStatus);
+
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       IDM_GROUPPROPERTIES,
+                       szGroupProperties);
+
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       IDM_GROUPDELETE,
+                       szGroupDelete);
+
+            break;
+        // agent leaf    
+        case AGENTKEY:
+
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       (UINT)IDM_AGENTADDTOLIST,
+                       szAddGroup);
+            
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       IDM_AGENTPROPERTIES,
+                       szAgentProperties);
+
+            AppendMenu(hMenu,
+                       MF_ENABLED | MF_STRING,
+                       IDM_AGENTDELETE,
+                       szAgentDelete);
+
+            break;
+            
+        default:
+            break;
+    }
+
+    // actually show menu
+    TrackPopupMenu(hMenu,
+                   TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
+                   pt.x,
+                   pt.y,
+                   0,
+                   g.hMainWnd,
+                   NULL);
+    
+    return TRUE;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT DoCommand(WPARAM wParam, LPARAM lParam)
+//      handle WM_COMMAND messages for MainDlgProc
+//
+///////////////////////////////////////////////////////////////////////////////
+LRESULT DoCommand(WPARAM wParam, LPARAM lParam)
+{
+    switch (LOWORD(wParam))
+    {
+        // New - create a new tree, so just init
+        // the items and return
+        case ID_FILE_NEW:
+            DoGroupView();
+            return 1;
+
+        // Open - read in a file
+        case ID_FILE_OPEN:
+            ReadInFile();
+            return 1;
+        
+        case ID_FILE_EXIT:
+            // save the current window location
+            WriteToDisk();
+            CleanUp();
+            MySaveWindow(g.hMainWnd);
+            PostQuitMessage(0);
+            return 1;
+
+        // new group
+        case ID_EDIT_ADDGROUP:
+        case IDM_NEWGROUP:
+            DialogBox(g.hInstance,
+                      MAKEINTRESOURCE(IDD_ADD),
+                      g.hTreeWnd,
+                      AddGroupDlgProc);
+
+            return 1;
+
+        // new agent    
+        case ID_EDIT_ADDAGENT:
+        case IDM_NEWAGENT:
+            DialogBox(g.hInstance,
+                      MAKEINTRESOURCE(IDD_ADDAGENT),
+                      g.hTreeWnd,
+                      AddAgentDlgProc);
+            return 1;
+
+        // properties
+        case IDM_GROUPPROPERTIES:
+            DialogBox(g.hInstance,
+                      MAKEINTRESOURCE(IDD_ADD),
+                      g.hMainWnd,
+                      ChangeGroupDlgProc);
+
+            return 1;
+
+        // properties            
+        case IDM_AGENTPROPERTIES:
+            DialogBox(g.hInstance,
+                      MAKEINTRESOURCE(IDD_ADDAGENT),
+                      g.hMainWnd,
+                      ChangeAgentDlgProc);
+
+            return 1;
+
+        // delete            
+        case IDM_GROUPDELETE:            
+        case IDM_AGENTDELETE:
+        {
+            DeleteLeafAndStruct(g.hTreeItemWithMenu);
+            
+            return 1;
+        }
+
+
+        // add to list
+        case IDM_GROUPADDTOLIST:
+            DialogBoxParam(g.hInstance,
+                           MAKEINTRESOURCE(IDD_ADDTOLIST),
+                           g.hMainWnd,
+                           GroupAddToListProc,
+                           TRUE);
+            
+            return 1;
+                     
+        // add to list
+        case IDM_AGENTADDTOLIST:
+            DialogBoxParam(g.hInstance,
+                           MAKEINTRESOURCE(IDD_ADDTOLIST),
+                           g.hMainWnd,
+                           AgentAddToListProc,
+                           FALSE);
+
+            return 1;
+
+        case ID_VIEW_GROUP:
+            DoGroupView();
+            return 1;
+            
+        case ID_VIEW_AGENT:
+            DoAgentView();
+            return 1;
+
+        default:
+            break;
+            
+    }
+
+    return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  AddGroupDlgProc - Window proc for the add agent/group dialog box
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+BOOL CALLBACK AddGroupDlgProc(HWND   hWnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            // set text appropriately
+            SetWindowText(hWnd,
+                          TEXT("Add Group"));
+
+            BuildLineList(GetDlgItem(hWnd,
+                                     IDC_LINECOMBO),
+                          0);
+
+            BuildAddressList(GetDlgItem(hWnd,
+                                        IDC_ADDRESSCOMBO),
+                             hWnd,
+                             0);
+                          
+            // set focus on first control
+            SetFocus(GetDlgItem(hWnd,
+                                IDC_NAME));
+
+            return 0;
+
+        case WM_COMMAND:
+
+            switch (LOWORD(wParam))
+            {
+                case IDC_LINECOMBO:
+                {
+                    if (HIWORD(wParam) == CBN_SELENDOK)
+                    {
+                        // need to redo addresses
+                        BuildAddressList(GetDlgItem(hWnd,
+                                                    IDC_ADDRESSCOMBO),
+                                         hWnd,
+                                         0);
+
+                        return 1;
+                    }
+                    
+                    return 0;
+                }
+                case IDOK:
+                {
+                    TCHAR       szName[128];
+                    PGROUP      pGroup;
+                    DWORD       dwLine, dwAddress;
+                    int         item;
+
+                    // get info
+                    SendDlgItemMessage(hWnd,
+                                       IDC_NAME,
+                                       WM_GETTEXT,
+                                       128,
+                                       (LPARAM)szName);
+
+                    item = SendDlgItemMessage(hWnd,
+                                              IDC_LINECOMBO,
+                                              CB_GETCURSEL,
+                                              0,
+                                              0);
+                    
+                    dwLine = (DWORD)SendDlgItemMessage(hWnd,
+                                                       IDC_LINECOMBO,
+                                                       CB_GETITEMDATA,
+                                                       item,
+                                                       0);
+
+                    dwAddress = (DWORD)SendDlgItemMessage(hWnd,
+                                                          IDC_ADDRESSCOMBO,
+                                                          CB_GETCURSEL,
+                                                          0,
+                                                          0);
+                    
+                    // create a structure
+                    pGroup = AddGroup(szName,
+                                      dwLine,
+                                      dwAddress);
+
+                    if (!pGroup)
+                    {
+                        return 1;
+                    }
+
+                    if (g.bGroupView)
+                    {
+                        // add it to the tree
+                        AddItemToTree(g.hGroupParent,
+                                      pGroup->lpszName,
+                                      (LPARAM)pGroup,
+                                      &pGroup->hItem);
+                    }
+
+                    EndDialog(hWnd, 1);
+                    return 1;
+                }
+
+                case IDCANCEL:
+                {
+                    EndDialog(hWnd, 0);
+                    return 1;
+                }
+
+                default:
+                    return 0;
+
+            }
+
+    }
+
+    return 0;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  AddAgentDlgProc - Window proc for the add agent/group dialog box
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+BOOL CALLBACK AddAgentDlgProc(HWND   hWnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            BuildLineList(GetDlgItem(hWnd,
+                                     IDC_LINECOMBO),
+                          0);
+
+            // set focus on first control
+            SetFocus(GetDlgItem(hWnd,
+                                IDC_NAME));
+
+            return 0;
+
+        case WM_COMMAND:
+
+            switch (LOWORD(wParam))
+            {
+                case IDOK:
+                {
+                    TCHAR       szName[128];
+                    TCHAR       szNumber[128];
+                    PAGENT      pAgent;
+                    DWORD       dwLine;
+                    int         item;
+
+                    // get info
+                    SendDlgItemMessage(hWnd,
+                                       IDC_NAME,
+                                       WM_GETTEXT,
+                                       128,
+                                       (LPARAM)szName);
+
+                    SendDlgItemMessage(hWnd,
+                                       IDC_DESTADDRESS,
+                                       WM_GETTEXT,
+                                       128,
+                                       (LPARAM)szNumber);
+
+                    item = SendDlgItemMessage(hWnd,
+                                              IDC_LINECOMBO,
+                                              CB_GETCURSEL,
+                                              0,
+                                              0);
+                    
+                    dwLine = (DWORD)SendDlgItemMessage(hWnd,
+                                                       IDC_LINECOMBO,
+                                                       CB_GETITEMDATA,
+                                                       item,
+                                                       0);
+
+                    // create a structure
+                    pAgent = AddAgent(szName,
+                                      szNumber,
+                                      dwLine);
+
+                    if (!pAgent)
+                    {
+                        return 1;
+                    }
+
+
+                    if (!g.bGroupView)
+                    {
+                    // add it to the tree
+                        AddItemToTree(g.hAgentParent,
+                                      pAgent->lpszName,
+                                      (LPARAM)pAgent,
+                                      &pAgent->hItem);
+                    }
+
+                    EndDialog(hWnd, 1);
+                    return 1;
+                }
+
+                case IDCANCEL:
+                {
+                    EndDialog(hWnd, 0);
+                    return 1;
+                }
+
+                default:
+                    return 0;
+
+            }
+    }
+    return 0;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+//
+//  ChangeGroupDlgProc - Window proc for the change (properties) dialog box
+//     for agents/groups
+//
+//////////////////////////////////////////////////////////////////////////////////
+BOOL CALLBACK ChangeGroupDlgProc(HWND   hWnd,
+                                 UINT   uMsg,
+                                 WPARAM wParam,
+                                 LPARAM lParam)
+{
+    static TV_ITEM      tvi;
+    
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            // set text appropriately
+            SetWindowText(hWnd,
+                          TEXT("Change Group"));
+
+            // get PGROUP and set edit controls
+            tvi.mask    = TVIF_HANDLE | TVIF_PARAM;
+            tvi.hItem   = g.hTreeItemWithMenu;
+
+            TreeView_GetItem(g.hTreeWnd,
+                             &tvi);
+
+            SendDlgItemMessage(hWnd,
+                               IDC_NAME,
+                               WM_SETTEXT,
+                               0,
+                               (LPARAM)((PGROUP)tvi.lParam)->lpszName);
+
+            BuildLineList(GetDlgItem(hWnd,
+                                     IDC_LINECOMBO),
+                          (((PGROUP)tvi.lParam)->dwDeviceID));
+
+            
+            BuildAddressList(GetDlgItem(hWnd,
+                                        IDC_ADDRESSCOMBO),
+                             hWnd,
+                             (((PGROUP)tvi.lParam)->dwAddress));
+
+            SetFocus(GetDlgItem(hWnd,
+                                IDC_NAME));
+
+            return 0;
+
+        case WM_COMMAND:
+
+            switch (LOWORD(wParam))
+            {
+                case IDC_LINECOMBO:
+                {
+                    if (HIWORD(wParam) == CBN_SELENDOK)
+                    {
+                        // need to redo addresses
+                        BuildAddressList(GetDlgItem(hWnd,
+                                                    IDC_ADDRESSCOMBO),
+                                         hWnd,
+                                         0);
+
+                        return 1;
+                    }
+                    
+                    return 0;
+                }
+                case IDOK:
+                {
+                    TCHAR       szName[128];
+                    PGROUP      pGroup;
+
+                    // get info
+                    SendDlgItemMessage(hWnd,
+                                       IDC_NAME,
+                                       WM_GETTEXT,
+                                       128,
+                                       (LPARAM)szName);
+
+                    // get struct
+                    pGroup = (PGROUP)tvi.lParam;
+
+                    /// get device and address
+                    pGroup->dwDeviceID = SendDlgItemMessage(hWnd,
+                                            IDC_LINECOMBO,
+                                            CB_GETCURSEL,
+                                            0,
+                                            0);
+
+                    pGroup->dwDeviceID = SendDlgItemMessage(hWnd,
+                                                            IDC_LINECOMBO,
+                                                            CB_GETITEMDATA,
+                                                            (WPARAM)pGroup->dwDeviceID,
+                                                            0);
+
+                    pGroup->dwAddress = SendDlgItemMessage(hWnd,
+                                                           IDC_ADDRESSCOMBO,
+                                                           CB_GETCURSEL,
+                                                           0,
+                                                           0);
+
+                    // save new info and free old info
+                    ACDFree(pGroup->lpszName);
+                    pGroup->lpszName = ACDAlloc((lstrlen(szName) + 1) * sizeof(TCHAR));
+                    lstrcpy(pGroup->lpszName, szName);
+
+                    // update item name
+                    tvi.mask = TVIF_TEXT;
+                    tvi.pszText = szName;
+                    tvi.cchTextMax = lstrlen(szName) * sizeof(TCHAR);
+                    TreeView_SetItem(g.hTreeWnd,
+                                     &tvi);
+                    
+                    EndDialog(hWnd, 1);
+                    return 1;
+                }
+
+                case IDCANCEL:
+                {
+                    EndDialog(hWnd, 0);
+                    return 1;
+                }
+
+                default:
+                    return 0;
+
+            }
+    }
+    return 0;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////
+//
+//  ChangeGroupDlgProc - Window proc for the change (properties) dialog box
+//     for agents/groups
+//
+//////////////////////////////////////////////////////////////////////////////////
+BOOL CALLBACK ChangeAgentDlgProc(HWND   hWnd,
+                                 UINT   uMsg,
+                                 WPARAM wParam,
+                                 LPARAM lParam)
+{
+    static TV_ITEM      tvi;
+    
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            // set text appropriately
+            SetWindowText(hWnd,
+                          TEXT("Change Agent"));
+
+            // get PGROUP and set edit controls
+            tvi.mask    = TVIF_HANDLE | TVIF_PARAM;
+            tvi.hItem   = g.hTreeItemWithMenu;
+
+            TreeView_GetItem(g.hTreeWnd,
+                             &tvi);
+
+            SendDlgItemMessage(hWnd,
+                               IDC_NAME,
+                               WM_SETTEXT,
+                               0,
+                               (LPARAM)((PAGENT)tvi.lParam)->lpszName);
+
+            SendDlgItemMessage(hWnd,
+                               IDC_DESTADDRESS,
+                               WM_SETTEXT,
+                               0,
+                               (LPARAM)((PAGENT)tvi.lParam)->lpszNumber);
+
+            BuildLineList(GetDlgItem(hWnd,
+                                     IDC_LINECOMBO),
+                          (((PAGENT)tvi.lParam)->dwDeviceID));
+
+            SetFocus(GetDlgItem(hWnd,
+                                IDC_NAME));
+
+            return 0;
+
+        case WM_COMMAND:
+
+            switch (LOWORD(wParam))
+            {
+                case IDOK:
+                {
+                    TCHAR       szName[128];
+                    TCHAR       szNumber[128];
+                    PAGENT      pAgent;
+
+                    // get info
+                    SendDlgItemMessage(hWnd,
+                                       IDC_NAME,
+                                       WM_GETTEXT,
+                                       128,
+                                       (LPARAM)szName);
+
+                    SendDlgItemMessage(hWnd,
+                                       IDC_DESTADDRESS,
+                                       WM_GETTEXT,
+                                       128,
+                                       (LPARAM)szNumber);
+
+                    // get struct
+                    pAgent = (PAGENT)tvi.lParam;
+
+                    /// get device and address
+                    pAgent->dwDeviceID = SendDlgItemMessage(hWnd,
+                                            IDC_LINECOMBO,
+                                            CB_GETCURSEL,
+                                            0,
+                                            0);
+
+                    pAgent->dwDeviceID = SendDlgItemMessage(hWnd,
+                                                            IDC_LINECOMBO,
+                                                            CB_GETITEMDATA,
+                                                            (WPARAM)pAgent->dwDeviceID,
+                                                            0);
+
+                    // save new info and free old info
+                    ACDFree(pAgent->lpszName);
+                    pAgent->lpszName = ACDAlloc((lstrlen(szName) + 1) * sizeof(TCHAR));
+                    lstrcpy(pAgent->lpszName, szName);
+
+
+                    ACDFree(pAgent->lpszNumber);
+                    pAgent->lpszNumber = ACDAlloc((lstrlen(szNumber) + 1) * sizeof(TCHAR));
+                    lstrcpy(pAgent->lpszNumber, szNumber);
+
+                    // update item name
+                    tvi.mask = TVIF_TEXT;
+                    tvi.pszText = szName;
+                    tvi.cchTextMax = lstrlen(szName) * sizeof(TCHAR);
+                    TreeView_SetItem(g.hTreeWnd,
+                                     &tvi);
+                    
+                    EndDialog(hWnd, 1);
+                    return 1;
+                }
+
+                case IDCANCEL:
+                {
+                    EndDialog(hWnd, 0);
+                    return 1;
+                }
+
+                default:
+                    return 0;
+
+            }
+    }
+    return 0;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//
+//  AddToList() - Window proc for Add Agent To Group and Add Group To Agent
+//    dialog box
+//
+//////////////////////////////////////////////////////////////////////////////////////
+BOOL CALLBACK GroupAddToListProc(HWND   hWnd,
+                                 UINT   uMsg,
+                                 WPARAM wParam,
+                                 LPARAM lParam)
+{
+    static PGROUP           pGroup;
+    PAGENT                  pAgent;
+    PLISTITEM               pList;
+    TV_ITEM                 tvi;
+    DWORD                   dwListBox;
+    BOOL                    bFound;
+    int                     item;
+    TCHAR                   szBuffer[128];
+    
+    
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            // get the item in question
+            tvi.mask    = TVIF_HANDLE | TVIF_PARAM;
+            tvi.hItem   = g.hTreeItemWithMenu;
+
+            TreeView_GetItem(g.hTreeWnd,
+                             &tvi);
+
+            pGroup = (PGROUP)tvi.lParam;
+
+            // init lists
+            if (pGroup)
+            {
+                // initialize text in dialog
+                wsprintf(szBuffer, TEXT("Add To %s"), pGroup->lpszName);
+
+                SetWindowText(hWnd,
+                              TEXT("Add To Group"));
+
+                SetDlgItemText(hWnd,
+                               IDC_STATICNOTINLIST,
+                               TEXT("Not in Group"));
+                SetDlgItemText(hWnd,
+                               IDC_STATICINLIST,
+                               TEXT("Group Members"));
+
+                pAgent = g.pAgents;
+
+                // walk list and initialize list boxes
+                while (pAgent)
+                {
+                    pList = pGroup->pAgentList;
+
+                    bFound = FALSE;
+                
+                    while (pList)
+                    {
+                        if (pList->pAgent == pAgent)
+                        {
+                            bFound = TRUE;
+                            break;
+                        }
+
+                        pList = pList->pNext;
+                    }
+
+                    // if it was found, it is already a member of
+                    // the group
+                    if (bFound)
+                    {
+                        dwListBox = IDC_LIST2;
+                    }
+                    else
+                    {
+                        dwListBox = IDC_LIST1;
+                    }
+
+                    // add to correct list box
+                    item = SendDlgItemMessage(hWnd,
+                                              dwListBox,
+                                              LB_ADDSTRING,
+                                              0,
+                                              (LPARAM)pAgent->lpszName);
+
+                    // set the item data to be the item so we can get back it.
+                    if (item != LB_ERR)
+                    {
+                        SendDlgItemMessage(hWnd,
+                                           dwListBox,
+                                           LB_SETITEMDATA,
+                                           (WPARAM)item,
+                                           (LPARAM)pAgent);
+                    }
+
+                    pAgent = pAgent->pNext;
+                }
+            }
+
+            
+            
+            return 1;
+
+        case WM_COMMAND:
+
+            switch (LOWORD(wParam))
+            {
+                case IDC_ADD:
+                {
+                    // get the item
+                    item = SendDlgItemMessage(hWnd,
+                                              IDC_LIST1,
+                                              LB_GETCURSEL,
+                                              0,
+                                              0);
+
+                    if (item == 0)
+                    {
+                        if (!SendDlgItemMessage(hWnd,
+                                                IDC_LIST1,
+                                                LB_GETSEL,
+                                                (WPARAM)item,
+                                                0))
+                        {
+                            item == -1;
+                        }
+                    }
+
+                    if (item != -1)
+                    {
+                        // get the PAGENT associated with it
+                        pAgent = (PAGENT)SendDlgItemMessage(hWnd,
+                                                            IDC_LIST1,
+                                                            LB_GETITEMDATA,
+                                                            (WPARAM)item,
+                                                            0);
+
+                        // delete it from this listbox
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST1,
+                                           LB_DELETESTRING,
+                                           (WPARAM)item,
+                                           0);
+
+                        // add it to this list box
+                        item = SendDlgItemMessage(hWnd,
+                                                  IDC_LIST2,
+                                                  LB_ADDSTRING,
+                                                  0,
+                                                  (LPARAM)pAgent->lpszName);
+
+                        // set the item data again
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST2,
+                                           LB_SETITEMDATA,
+                                           item,
+                                           (WPARAM)pAgent);
+
+                        // add it to the group's list
+                        InsertIntoGroupList(pGroup,
+                                            pAgent);
+                        
+                        return 1;
+                        
+                    }
+                }
+                break;
+                
+                case IDC_REMOVE:
+                {
+                    // get the item
+                    item = SendDlgItemMessage(hWnd,
+                                              IDC_LIST2,
+                                              LB_GETCURSEL,
+                                              0,
+                                              0);
+
+                    if (item == 0)
+                    {
+                        if (!SendDlgItemMessage(hWnd,
+                                                IDC_LIST2,
+                                                LB_GETSEL,
+                                                (WPARAM)item,
+                                                0))
+                        {
+                            item == -1;
+                        }
+                    }
+
+                    if (item != -1)
+                    {
+                        // get the struct associated with it
+                        pAgent = (PAGENT)SendDlgItemMessage(hWnd,
+                                                                IDC_LIST2,
+                                                                LB_GETITEMDATA,
+                                                                (WPARAM)item,
+                                                                0);
+
+                        // delete it from this list
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST2,
+                                           LB_DELETESTRING,
+                                           (WPARAM)item,
+                                           0);
+
+                        // add it to this list
+                        item = SendDlgItemMessage(hWnd,
+                                                  IDC_LIST1,
+                                                  LB_ADDSTRING,
+                                                  0,
+                                                  (LPARAM)pAgent->lpszName);
+
+                        // set the item data
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST1,
+                                           LB_SETITEMDATA,
+                                           item,
+                                           (WPARAM)pAgent);
+
+                        // remove it from the lists
+                        RemoveFromGroupList(pGroup,
+                                            pAgent);
+                        
+                        return 1;
+                        
+                    }
+                    
+                }
+                break;
+
+
+                // bug idcancel doesn't cancel
+                case IDOK:
+                case IDCANCEL:
+                {
+                    UpdateGroupLeaf(pGroup);
+
+                    EndDialog(hWnd, 1);
+                    return 1;
+                }
+
+                default:
+                    return 0;
+
+            }
+
+    }
+
+    return 0;
+}
+
+
+BOOL CALLBACK AgentAddToListProc(HWND   hWnd,
+                                 UINT   uMsg,
+                                 WPARAM wParam,
+                                 LPARAM lParam)
+{
+    static PAGENT           pAgent;
+    PGROUP                  pGroup;
+    PLISTITEM               pList;
+    TV_ITEM                 tvi;
+    DWORD                   dwListBox;
+    BOOL                    bFound;
+    int                     item;
+    TCHAR                   szBuffer[128];
+    
+    
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            // get the item in question
+            tvi.mask    = TVIF_HANDLE | TVIF_PARAM;
+            tvi.hItem   = g.hTreeItemWithMenu;
+
+            TreeView_GetItem(g.hTreeWnd,
+                             &tvi);
+
+            pAgent = (PAGENT)tvi.lParam;
+
+            // init lists
+            if (pAgent)
+            {
+                // initialize text in dialog
+                wsprintf(szBuffer, TEXT("Add To %s"), pAgent->lpszName);
+
+                SetWindowText(hWnd,
+                              TEXT("Add To Agent"));
+
+                SetDlgItemText(hWnd,
+                               IDC_STATICNOTINLIST,
+                               TEXT("Not Member Of"));
+                SetDlgItemText(hWnd,
+                               IDC_STATICINLIST,
+                               TEXT("Member Of"));
+
+                pGroup = g.pGroups;
+
+                // walk list and initialize list boxes
+                while (pGroup)
+                {
+                    pList = pGroup->pAgentList;
+
+                    bFound = FALSE;
+                
+                    while (pList)
+                    {
+                        if (pList->pAgent == pAgent)
+                        {
+                            bFound = TRUE;
+                            break;
+                        }
+
+                        pList = pList->pNext;
+                    }
+
+                    // if it was found, it is already a member of
+                    // the group
+                    if (bFound)
+                    {
+                        dwListBox = IDC_LIST2;
+                    }
+                    else
+                    {
+                        dwListBox = IDC_LIST1;
+                    }
+
+                    // add to correct list box
+                    item = SendDlgItemMessage(hWnd,
+                                              dwListBox,
+                                              LB_ADDSTRING,
+                                              0,
+                                              (LPARAM)pGroup->lpszName);
+
+                    // set the item data to be the item so we can get back it.
+                    if (item != LB_ERR)
+                    {
+                        SendDlgItemMessage(hWnd,
+                                           dwListBox,
+                                           LB_SETITEMDATA,
+                                           (WPARAM)item,
+                                           (LPARAM)pGroup);
+                    }
+
+                    pGroup = pGroup->pNext;
+                }
+            }
+
+            
+            
+            return 1;
+
+        case WM_COMMAND:
+
+            switch (LOWORD(wParam))
+            {
+                case IDC_ADD:
+                {
+                    // get the item
+                    item = SendDlgItemMessage(hWnd,
+                                              IDC_LIST1,
+                                              LB_GETCURSEL,
+                                              0,
+                                              0);
+
+                    if (item == 0)
+                    {
+                        if (!SendDlgItemMessage(hWnd,
+                                                IDC_LIST1,
+                                                LB_GETSEL,
+                                                (WPARAM)item,
+                                                0))
+                        {
+                            item == -1;
+                        }
+                    }
+
+                    if (item != -1)
+                    {
+                        // get the PGROUP associated with it
+                        pGroup = (PGROUP)SendDlgItemMessage(hWnd,
+                                                                IDC_LIST1,
+                                                                LB_GETITEMDATA,
+                                                                (WPARAM)item,
+                                                                0);
+
+                        // delete it from this listbox
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST1,
+                                           LB_DELETESTRING,
+                                           (WPARAM)item,
+                                           0);
+
+                        // add it to this list box
+                        item = SendDlgItemMessage(hWnd,
+                                                  IDC_LIST2,
+                                                  LB_ADDSTRING,
+                                                  0,
+                                                  (LPARAM)pGroup->lpszName);
+
+                        // set the item data again
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST2,
+                                           LB_SETITEMDATA,
+                                           item,
+                                           (WPARAM)pGroup);
+
+                        // add it to the item's list
+                        InsertIntoGroupList(pGroup,
+                                            pAgent);
+                        
+                        return 1;
+                        
+                    }
+                }
+                break;
+                
+                case IDC_REMOVE:
+                {
+                    // get the item
+                    item = SendDlgItemMessage(hWnd,
+                                              IDC_LIST2,
+                                              LB_GETCURSEL,
+                                              0,
+                                              0);
+
+                    if (item == 0)
+                    {
+                        if (!SendDlgItemMessage(hWnd,
+                                                IDC_LIST2,
+                                                LB_GETSEL,
+                                                (WPARAM)item,
+                                                0))
+                        {
+                            item == -1;
+                        }
+                    }
+
+                    if (item != -1)
+                    {
+                        // get the struct associated with it
+                        pGroup = (PGROUP)SendDlgItemMessage(hWnd,
+                                                                IDC_LIST2,
+                                                                LB_GETITEMDATA,
+                                                                (WPARAM)item,
+                                                                0);
+
+                        // delete it from this list
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST2,
+                                           LB_DELETESTRING,
+                                           (WPARAM)item,
+                                           0);
+
+                        // add it to this list
+                        item = SendDlgItemMessage(hWnd,
+                                                  IDC_LIST1,
+                                                  LB_ADDSTRING,
+                                                  0,
+                                                  (LPARAM)pGroup->lpszName);
+
+                        // set the item data
+                        SendDlgItemMessage(hWnd,
+                                           IDC_LIST1,
+                                           LB_SETITEMDATA,
+                                           item,
+                                           (WPARAM)pGroup);
+
+                        // remove it from the lists
+                        RemoveFromGroupList(pGroup,
+                                            pAgent);
+                        
+                        return 1;
+                        
+                    }
+                    
+                }
+                break;
+
+
+                // bug idcancel doesn't cancel
+                case IDOK:
+                case IDCANCEL:
+                {
+                    EndDialog(hWnd, 1);
+                    return 1;
+                }
+
+                default:
+                    return 0;
+            }
+    }
+    return 0;
+}
+
+//////////////////////////////////////////////////////////////
+//
+//  BOOL DeleteLeafAndStruct(HTREEITEM hItem)
+//    delete hItem from the tree and deleted associated
+//    structure
+//
+//////////////////////////////////////////////////////////////
+BOOL DeleteLeafAndStruct(HTREEITEM hItem)
+{
+    TV_ITEM     tvi;
+
+    // get the item
+    tvi.mask = TVIF_PARAM;
+    tvi.hItem = hItem;
+
+    TreeView_GetItem(g.hTreeWnd,
+                     &tvi);
+
+    // delete the structure
+    if (((PGENERICSTRUCT)tvi.lParam)->dwKey == GROUPKEY)
+    {
+        DeleteGroup((PGROUP)tvi.lParam);
+    }
+    else
+    {
+        DeleteAgent((PAGENT)tvi.lParam);
+    }
+
+    // remove it from the tree
+    TreeView_DeleteItem(g.hTreeWnd,
+                        hItem);
+
+    return TRUE;
+}
+
+
+////////////////////////////////////////////////////////////////////
+//
+//  BOOL BuildLineList(HWND hWnd,
+//                     DWORD dwDeviceID)
+//
+//  Fill in ComboBox with names of all available TAPI
+//  devices
+//
+////////////////////////////////////////////////////////////////////
+BOOL BuildLineList(HWND hWnd,
+                   DWORD dwDeviceID)
+{
+    DWORD               dwDev;
+    LPLINEDEVCAPS       pLineDevCaps;
+    int                 item;
+    BOOL                bSet = FALSE;
+
+    // clear dropdown box
+    SendMessage(hWnd,
+                CB_RESETCONTENT,
+                0,
+                0);
+
+    // loop through all devices
+    for (dwDev = 0; dwDev < g.dwNumDevs; dwDev++)
+    {
+        pLineDevCaps = LineGetDevCaps(g.hLineApp,
+                                      dwDev);
+
+        // add the string to to list
+        if (pLineDevCaps == NULL || pLineDevCaps->dwLineNameSize == 0)
+        {
+            item = SendMessage(hWnd,
+                               CB_ADDSTRING,
+                               0,
+                               (LPARAM)TEXT("NoName"));
+        }
+        else
+        {
+            item = SendMessage(hWnd,
+                               CB_ADDSTRING,
+                               0,
+                               (LPARAM)((LPTSTR)((LPBYTE)pLineDevCaps + pLineDevCaps->dwLineNameOffset)));
+        }
+
+        // save the device ID
+        SendMessage(hWnd,
+                    CB_SETITEMDATA,
+                    item,
+                    dwDev);
+
+        // if this is the device we are looking for
+        // set it to be selected
+        if (dwDev == dwDeviceID)
+        {
+            SendMessage(hWnd,
+                        CB_SETCURSEL,
+                        (WPARAM)item,
+                        0);
+
+            bSet = TRUE;
+        }
+        
+        if (pLineDevCaps != NULL)
+        {
+            ACDFree((HLOCAL)pLineDevCaps);
+        }
+    }
+
+    // if we didn't set the selection, default
+    if (!bSet)
+    {
+        SendMessage(hWnd,
+                    CB_SETCURSEL,
+                    0,
+                    0);
+    }
+
+    return TRUE;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL BuildAddressList()
+//
+//  Fill combo box with list of addresses on selected device ID
+//
+///////////////////////////////////////////////////////////////////////////////
+BOOL BuildAddressList(HWND hWnd,
+                      HWND hParentWnd,
+                      DWORD dwAddress)
+{
+    TCHAR               szBuffer[32];
+    LPLINEDEVCAPS       pLineDevCaps;
+    LPLINEADDRESSCAPS   pLineAddressCaps;
+    DWORD               dwCurAddress, dwDeviceID;
+    int                 iCurSel;
+
+    // clear box
+    SendMessage(hWnd,
+                CB_RESETCONTENT,
+                0,
+                0);
+
+    // get the current selected device
+    iCurSel = SendDlgItemMessage(hParentWnd,
+                                 IDC_LINECOMBO,
+                                 CB_GETCURSEL,
+                                 0,
+                                 0);
+
+    // get associated deviceid
+    dwDeviceID = (DWORD)SendDlgItemMessage(hParentWnd,
+                                           IDC_LINECOMBO,
+                                           CB_GETITEMDATA,
+                                           (WPARAM)iCurSel,
+                                           0);
+    
+    pLineDevCaps = LineGetDevCaps(g.hLineApp,
+                                  dwDeviceID);
+
+    // loop through all addresses
+    for (dwCurAddress = 0; dwCurAddress < pLineDevCaps->dwNumAddresses; dwCurAddress++)
+    {
+        pLineAddressCaps = LineGetAddressCaps(g.hLineApp,
+                                              dwDeviceID,
+                                              dwCurAddress);
+
+        // add name to list box
+        if (pLineAddressCaps == NULL || pLineAddressCaps->dwAddressSize == 0)
+        {
+            wsprintf(szBuffer, TEXT("Address %d"), dwCurAddress);
+            
+            SendMessage(hWnd,
+                        CB_ADDSTRING,
+                        0,
+                        (LPARAM)szBuffer);
+        }
+        else
+        {
+            SendMessage(hWnd,
+                        CB_ADDSTRING,
+                        0,
+                        (LPARAM)((LPTSTR)((LPBYTE)pLineAddressCaps + pLineAddressCaps->dwAddressOffset)));
+        }
+        
+        ACDFree((HLOCAL)pLineAddressCaps);
+    }
+
+    SendMessage(hWnd,
+                CB_SETCURSEL,
+                (WPARAM)dwAddress,
+                0);
+
+    ACDFree(pLineDevCaps);
+    
+    return TRUE;
+}
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  BOOL UpdateGroupLeaf(PGROUP pStruct)
+//
+//  Updates a group in the tree view when a new agent is added to that
+//  group
+//
+///////////////////////////////////////////////////////////////////////////
+BOOL UpdateGroupLeaf(PGROUP pStruct)
+{
+    HTREEITEM   hItem;
+    PLISTITEM   pItem;
+    TV_ITEM     tvi;
+
+    // get the item's first child
+    hItem = TreeView_GetChild(g.hTreeWnd,
+                              pStruct->hItem);
+
+    
+    while (hItem)
+    {
+        // delete all childre
+        TreeView_DeleteItem(g.hTreeWnd,
+                            hItem);
+        hItem = TreeView_GetChild(g.hTreeWnd,
+                                  pStruct->hItem);
+    
+    }
+
+    pItem = pStruct->pAgentList;
+
+    // walk the agent list
+    while (pItem)
+    {
+        // add all the agents
+        hItem = AddItemToTree(pStruct->hItem,
+                              ((PAGENT)pItem->pAgent)->lpszName,
+                              (LPARAM)NULL,
+                              (HTREEITEM *)NULL);
+
+
+        // if currently logged into that group
+        /// bold that item
+        if (pItem->bLoggedIn)
+        {
+            tvi.mask = TVIF_STATE | TVIF_HANDLE;
+            tvi.hItem = hItem;
+            tvi.state = TVIS_BOLD;
+            tvi.stateMask = TVIS_BOLD;
+
+            TreeView_SetItem(g.hTreeWnd,
+                             &tvi);
+        }
+ 
+        pItem = pItem->pNext;
+    }
+
+    
+    return TRUE;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//
+//  BOOL DoGroupView()
+//
+//  Display the tree in a "group view" (show groups, and under the
+//  group, the agents that can log into that group)
+//
+///////////////////////////////////////////////////////////////////////
+BOOL DoGroupView()
+{
+    PGROUP      pGroupParent, pGroup;
+    TCHAR       szGroupParentName[] = TEXT("Groups");
+    HTREEITEM   hItem;
+    TV_ITEM     tvi;
+
+    g.bGroupView = TRUE;
+
+    // get the root
+    hItem = TreeView_GetRoot(g.hTreeWnd);
+
+    // free resources allocated for root
+    if (hItem)
+    {
+        tvi.mask = TVIF_PARAM | TVIF_HANDLE;
+        tvi.hItem = hItem;
+        TreeView_GetItem(g.hTreeWnd,
+                         &tvi);
+
+        ACDFree((PAGENT)tvi.lParam);
+    }
+
+    // clear tree
+    TreeView_DeleteAllItems(g.hTreeWnd);
+
+    // alloc memory for the structure for the Group parent
+    pGroupParent = (PGROUP)ACDAlloc(sizeof(GROUP));
+
+    // alloc memory and copy the fixed name
+    pGroupParent->lpszName = (LPTSTR)ACDAlloc((lstrlen(szGroupParentName) + 1) * sizeof(TCHAR));
+    pGroupParent->dwKey = GROUPROOTKEY;
+    
+    lstrcpy(pGroupParent->lpszName, szGroupParentName);
+
+    // add it to the tree
+    g.hGroupParent = AddItemToTree(TVI_ROOT,
+                                   pGroupParent->lpszName,
+                                   (LPARAM)pGroupParent,
+                                   &pGroupParent->hItem);
+
+    pGroup = g.pGroups;
+
+    // walk groups and add them to tree
+    while (pGroup)
+    {
+        AddItemToTree(g.hGroupParent,
+                      pGroup->lpszName,
+                      (LPARAM)pGroup,
+                      &pGroup->hItem);
+
+        UpdateGroupLeaf(pGroup);
+
+        pGroup = pGroup->pNext;
+    }
+    
+    return TRUE;
+}
+
+
+////////////////////////////////////////////////////////////////////
+//
+//  BOOL DoAgentView()
+//
+//  Displays the tree in an "agent view"
+//
+////////////////////////////////////////////////////////////////////
+BOOL DoAgentView()
+{
+    PAGENT      pAgentParent,pAgent;
+    TCHAR       szAgentParentName[] = TEXT("Agents");
+    HTREEITEM   hItem;
+    TV_ITEM     tvi;
+
+    g.bGroupView = TRUE;
+
+    // get root, free resources
+    // and clear tree
+    hItem = TreeView_GetRoot(g.hTreeWnd);
+
+    if (hItem)
+    {
+        tvi.mask = TVIF_PARAM | TVIF_HANDLE;
+        tvi.hItem = hItem;
+        TreeView_GetItem(g.hTreeWnd,
+                         &tvi);
+
+        ACDFree((PGROUP)tvi.lParam);
+    }
+    
+    TreeView_DeleteAllItems(g.hTreeWnd);
+
+    // alloc memory for the structure for the Agent parent
+    pAgentParent = (PAGENT)ACDAlloc(sizeof(AGENT));
+
+    // alloc memory and copy the fixed name
+    pAgentParent->lpszName = (LPTSTR)ACDAlloc((lstrlen(szAgentParentName) + 1) * sizeof(TCHAR));
+    pAgentParent->dwKey = GROUPROOTKEY;
+    
+    lstrcpy(pAgentParent->lpszName, szAgentParentName);
+
+    // add it to the tree
+    g.hAgentParent = AddItemToTree(TVI_ROOT,
+                                   pAgentParent->lpszName,
+                                   (LPARAM)pAgentParent,
+                                   &pAgentParent->hItem);
+
+    pAgent = g.pAgents;
+
+    // walk agents and add all of them
+    while (pAgent)
+    {
+        AddItemToTree(g.hAgentParent,
+                      pAgent->lpszName,
+                      (LPARAM)pAgent,
+                      &pAgent->hItem);
+
+        pAgent = pAgent->pNext;
+    }
+    
+    return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//
+// FOLLOWING ARE ROUTINES TO SAVE AND RESTORE GROUP / AGENT INFORMATION
+//
+// An INI file has been used for this implementation.
+//
+// This format is used to make it easy for users to create an INI file that can be
+// read in
+//
+// However, a real implementation
+// may want to use the registry, or a private data file to store more detailed and/or
+// secure information
+//
+//
+
+#define SZGROUPS        TEXT("Groups")
+#define SZAGENTS        TEXT("Agents")
+#define SZGROUP         TEXT("GROUP")
+#define SZAGENT         TEXT("AGENT")
+#define SZINIFILE       TEXT("ACDSMPL.INI")
+#define SZGENERAL       TEXT("General")
+#define SZNUMAGENTS     TEXT("NumAgents")
+#define SZNUMGROUPS     TEXT("NumGroups")
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  void MakeAgentIndex(PAGENT * ppAgents)
+//
+//  creates an array of pagents
+//
+//////////////////////////////////////////////////////////////////////////////
+void MakeAgentIndex(PAGENT * ppAgents)
+{
+    PAGENT pAgent;
+
+    pAgent = g.pAgents;
+    
+    while (pAgent)
+    {
+        *ppAgents = pAgent;
+        pAgent = pAgent->pNext;
+        ppAgents++;
+    }
+                
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// int GetAgentIndex()
+//
+// retreives agent index
+//
+///////////////////////////////////////////////////////////////////////////////
+int GetAgentIndex(PAGENT * ppAgents,
+                  PAGENT pAgent)
+{
+    DWORD   dwCount;
+
+    for (dwCount = 0; dwCount < g.dwNumAgents; dwCount++)
+    {
+        if (ppAgents[dwCount] == pAgent)
+        {
+            return dwCount;
+        }
+    }
+
+    return -1;
+
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL WriteToDisk()
+//
+//  save current group/agent config to acdsmpl.ini
+//
+///////////////////////////////////////////////////////////////////////////////
+BOOL WriteToDisk()
+{
+    int         i;
+    PGROUP      pGroup;
+    PAGENT      pAgent;
+    PLISTITEM   pEntry;
+    TCHAR       szGroupName[32], szAgentName[32], szLineBuffer[512];
+    PAGENT *    ppAgents;
+
+    // create an index of agents
+    ppAgents = (PAGENT *)ACDAlloc(sizeof(PAGENT) * g.dwNumAgents);
+    MakeAgentIndex(ppAgents);
+    
+    pGroup = g.pGroups;
+
+    i = 0;
+
+    // walk groups
+    while (pGroup)
+    {
+        wsprintf(szGroupName,
+                 TEXT("%s%d"),
+                 SZGROUP,
+                 i);
+
+        wsprintf(szLineBuffer,
+                 TEXT("%s,%d,%d"),
+                 pGroup->lpszName,
+                 g.pdwPermIDs[pGroup->dwDeviceID],
+                 pGroup->dwAddress);
+
+        // add group to [groups] section
+        WritePrivateProfileString(SZGROUPS,
+                                  szGroupName,
+                                  szLineBuffer,
+                                  SZINIFILE);
+
+        pEntry = pGroup->pAgentList;
+
+        // walk agents in group
+        while (pEntry)
+        {
+            wsprintf(szAgentName,
+                     TEXT("%s%d"),
+                     SZAGENT,
+                     GetAgentIndex(ppAgents,
+                                   pEntry->pAgent));
+
+            // write agent index to [groupx] section
+            WritePrivateProfileString(szGroupName,
+                                      szAgentName,
+                                      TEXT("1"),
+                                      SZINIFILE);
+
+            pEntry = pEntry->pNext;
+        }
+
+        pGroup = pGroup->pNext;
+
+        i++;
+    }
+
+    pAgent = g.pAgents;
+
+    i = 0;
+
+    //walk agents
+    while (pAgent)
+    {
+        wsprintf(szAgentName,
+                 TEXT("%s%d"),
+                 SZAGENT,
+                 i);
+
+        wsprintf(szLineBuffer,
+                 TEXT("%s,%s,%lu"),
+                 pAgent->lpszName,
+                 pAgent->lpszNumber,
+                 g.pdwPermIDs[pAgent->dwDeviceID]);
+
+        // write agent to [agents] section
+        WritePrivateProfileString(SZAGENTS,
+                                  szAgentName,
+                                  szLineBuffer,
+                                  SZINIFILE);
+
+        pAgent = pAgent->pNext;
+
+        i++;
+                 
+    }
+
+    // save # of agents and groups
+    wsprintf(szLineBuffer,
+             TEXT("%lu"),
+             g.dwNumGroups);
+    
+    WritePrivateProfileString(SZGENERAL,
+                              SZNUMGROUPS,
+                              szLineBuffer,
+                              SZINIFILE);
+    
+    wsprintf(szLineBuffer,
+             TEXT("%lu"),
+             g.dwNumAgents);
+
+    WritePrivateProfileString(SZGENERAL,
+                              SZNUMAGENTS,
+                              szLineBuffer,
+                              SZINIFILE);
+
+    ACDFree(ppAgents);
+    
+    return TRUE;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL ReadInFile()
+//
+//   Read in ACDSMPL.INI
+//
+////////////////////////////////////////////////////////////////////////////////////
+BOOL ReadInFile()
+{
+    TCHAR       szAgentLabel[32],
+                szGroupLabel[32];
+    DWORD       dwID, dwAddress, dwNumAgents, dwNumGroups;
+    DWORD       dwCount, dwCount2;
+    PAGENT *    ppAgents = NULL;
+    LPTSTR      lpszName, lpszNumber, lpszDeviceID;
+    LPTSTR      lpszHold, szLineBuffer = NULL;
+    PGROUP      pGroup;
+    
+    dwNumAgents = GetPrivateProfileInt(SZGENERAL,
+                                         SZNUMAGENTS,
+                                         0,
+                                         SZINIFILE);
+
+    dwNumGroups = GetPrivateProfileInt(SZGENERAL,
+                                         SZNUMGROUPS,
+                                         0,
+                                         SZINIFILE);
+
+    ppAgents = (PAGENT *)ACDAlloc(sizeof(PAGENT) * dwNumAgents);
+    szLineBuffer = (LPTSTR)ACDAlloc(512 * sizeof(WCHAR));
+
+    if (!ppAgents || !szLineBuffer)
+    {
+        ACDFree(ppAgents);
+        ACDFree(szLineBuffer);
+        return FALSE;
+    }
+
+    lpszHold = szLineBuffer;
+
+    for (dwCount = 0; dwCount < dwNumAgents; dwCount++)
+    {
+        wsprintf(szAgentLabel,
+                 TEXT("%s%lu"),
+                 SZAGENT,
+                 dwCount);
+
+        GetPrivateProfileString(SZAGENTS,
+                                szAgentLabel,
+                                TEXT(""),
+                                szLineBuffer,
+                                512,
+                                SZINIFILE);
+
+        lpszName = (LPTSTR)szLineBuffer;
+        
+        while (szLineBuffer && *szLineBuffer)
+        {
+            if (*szLineBuffer == TEXT(','))
+            {
+                *szLineBuffer = TEXT('\0');
+                szLineBuffer++;
+                break;
+            }
+
+            szLineBuffer++;
+        }
+
+        lpszNumber = (LPTSTR)szLineBuffer;
+        
+        while (szLineBuffer && *szLineBuffer)
+        {
+            if (*szLineBuffer == TEXT(','))
+            {
+                *szLineBuffer = TEXT('\0');
+                szLineBuffer++;
+                dwID = _wtol(szLineBuffer);
+                dwID = GetDeviceID(dwID);
+                
+                ppAgents[dwCount] = AddAgent(lpszName,
+                                             lpszNumber,
+                                             dwID);
+
+                break;
+            }
+
+            szLineBuffer++;
+        }
+
+    }
+
+    for (dwCount = 0; dwCount < dwNumGroups; dwCount++)
+    {
+        wsprintf(szGroupLabel,
+                 TEXT("%s%lu"),
+                 SZGROUP,
+                 dwCount);
+
+        GetPrivateProfileString(SZGROUPS,
+                                szGroupLabel,
+                                TEXT(""),
+                                szLineBuffer,
+                                512,
+                                SZINIFILE);
+
+        lpszName = (LPTSTR)szLineBuffer;
+
+        while (szLineBuffer && *szLineBuffer)
+        {
+            if (*szLineBuffer == TEXT(','))
+            {
+                *szLineBuffer = TEXT('\0');
+                szLineBuffer++;
+                lpszDeviceID = szLineBuffer;
+                break;
+            }
+
+            szLineBuffer++;
+        }
+
+        while (szLineBuffer && *szLineBuffer)
+        {
+            if (*szLineBuffer == TEXT(','))
+            {
+                *szLineBuffer = TEXT('\0');
+                szLineBuffer++;
+
+                dwAddress = _wtol(szLineBuffer);
+
+                break;
+            }
+
+            szLineBuffer++;
+        }
+
+        dwID = _wtol(lpszDeviceID);
+        dwID = GetDeviceID(dwID);
+
+
+        pGroup = AddGroup(lpszName,
+                          dwID,
+                          dwAddress);
+
+        if (!pGroup)
+        {
+            continue;
+        }
+        
+        for (dwCount2 = 0; dwCount2 < dwNumAgents; dwCount2++)
+        {
+            wsprintf(szAgentLabel,
+                     TEXT("%s%lu"),
+                     SZAGENT,
+                     dwCount2);
+            
+            if (GetPrivateProfileString(szGroupLabel,
+                                        szAgentLabel,
+                                        TEXT(""),
+                                        szLineBuffer,
+                                        512,
+                                        SZINIFILE) != 0)
+            {
+                InsertIntoGroupList(pGroup,
+                                    ppAgents[dwCount2]);
+            }
+            
+        }  // for dwcount2
+
+    }  // for dwcount
+
+    ACDFree(ppAgents);
+    ACDFree(lpszHold);
+
+    DoGroupView();
+    
+    return TRUE;
+}
+
+
+          
diff --git a/private/tapi/dev/apps/acd/acdsmpl.h b/private/tapi/dev/apps/acd/acdsmpl.h
new file mode 100644
index 000000000..10e93dbbe
--- /dev/null
+++ b/private/tapi/dev/apps/acd/acdsmpl.h
@@ -0,0 +1,192 @@
+#ifndef _ACDSMPL_
+#define _ACDSMPL_
+
+#include <windows.h>
+#include <commdlg.h>
+#include <commctrl.h>
+#include <tapi.h>
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  STRUCTURES
+//
+///////////////////////////////////////////////////////////////////////////
+
+typedef struct _tagLISTITEM;
+
+typedef struct
+{
+    DWORD                   dwState;
+    DWORD                   dwNextState;
+    DWORD                   dwActivity;
+    
+} ADDRESSINFO, * PADDRESSINFO;
+
+typedef struct _tagAGENT
+{
+    DWORD                   dwKey;
+    DWORD                   dwSize;
+    struct _tagAGENT *      pNext;
+    struct _tagAGENT *      pPrev;
+    LPTSTR                  lpszName;
+    LPTSTR                  lpszNumber;
+    HTREEITEM               hItem;
+    DWORD                   dwDeviceID;
+    DWORD                   dwPermID;
+    HLINE                   hLine;
+    DWORD                   dwNumAddresses;
+    PADDRESSINFO            pAddressInfo;
+    
+}   AGENT, * PAGENT;
+
+typedef struct _tagGROUP
+{
+    DWORD                   dwKey;
+    DWORD                   dwSize;
+    struct _tagGROUP *      pNext;
+    struct _tagGROUP *      pPrev;
+    LPTSTR                  lpszName;
+    HTREEITEM               hItem;
+    HLINE                   hLine;
+    DWORD                   dwDeviceID;
+    DWORD                   dwAddress;
+    struct _tagLISTITEM *   pAgentList;
+    
+}   GROUP, * PGROUP;
+
+typedef struct _tagGENERICSTRUCT
+{
+    DWORD                       dwKey;
+    DWORD                       dwSize;
+    struct _tagGENERICSTRUCT *  pNext;
+    struct _tagGENERICSTRUCT *  pPrev;
+    
+}  GENERICSTRUCT, * PGENERICSTRUCT;
+
+typedef struct _tagLISTITEM
+{
+    DWORD                   dwKey;
+    DWORD                   dwSize;
+    struct _tagLISTITEM *   pNext;
+    struct _tagLISTITEM *   pPrev;
+    PAGENT                  pAgent;
+    BOOL                    bLoggedIn;
+    DWORD                   dwAddress;
+    
+}   LISTITEM, * PLISTITEM;
+
+
+typedef struct _tagACDGLOBALS
+{
+    PAGENT         pAgents;
+    PGROUP         pGroups;
+    DWORD          dwNumAgents;
+    DWORD          dwNumGroups;
+    LPDWORD        pdwPermIDs;
+    HINSTANCE      hInstance;
+    HLINEAPP       hLineApp;
+    DWORD          dwNumDevs;
+    HWND           hMainWnd;
+    HWND           hTreeWnd;
+    HWND           hLogWnd;
+    BOOL           bGroupView;
+    DWORD          dwBarLocation;
+    HTREEITEM      hAgentParent;
+    HTREEITEM      hGroupParent;
+    HTREEITEM      hTreeItemWithMenu;
+    
+} ACDGLOBALS, * LPACDGLOBALS;
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  PROTOTYPES
+//
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+// memory
+LPVOID ACDAlloc(DWORD dwSize);
+
+void ACDFree(LPVOID pBuf);
+
+LPVOID ACDReAlloc(LPVOID pBuf,
+                  DWORD dwSize);
+
+// tapi utils
+LINEADDRESSCAPS * LineGetAddressCaps (HLINEAPP hLineApp,
+                                      DWORD    dwDeviceID,
+                                      DWORD    dwAddressID);
+
+LINECALLINFO * LineGetCallInfo (HCALL hCall);
+
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID);
+
+VARSTRING * LineGetID (HLINE  hLine,
+                       DWORD  dwAddressID,
+                       HCALL  hCall,
+                       DWORD  dwSelect,
+                       LPCTSTR lpszDeviceClass);
+
+LINECALLSTATUS * LineGetCallStatus (HCALL hCall);
+
+// list utils
+BOOL InsertStruct(PGENERICSTRUCT * ppRoot,
+                  PGENERICSTRUCT pStruct);
+
+BOOL DeleteStruct(PGENERICSTRUCT * ppRoot,
+                  PGENERICSTRUCT pStruct);
+
+PGROUP AddGroup(LPTSTR lpszName,
+                 DWORD dwDeviceID,
+                 DWORD dwAddress);
+
+PAGENT AddAgent(LPTSTR lpszName,
+                LPTSTR lpszNumber,
+                DWORD dwDeviceID);
+
+BOOL DeleteAgent(PAGENT pAgent);
+
+BOOL DeleteGroup(PGROUP pGroup);
+
+BOOL InsertIntoGroupList(PGROUP pGroup,
+                         PAGENT pAgent);
+
+BOOL RemoveFromGroupList(PGROUP pGroup,
+                         PAGENT pAgent);
+
+DWORD GetDeviceID(DWORD dwPermID);
+
+PAGENT GetAgentFromhLine(HLINE hLine);
+
+PAGENT GetAgentFromName(LPTSTR lpszName);
+
+PLISTITEM IsAgentInList(PLISTITEM pList,
+                        PAGENT pAgent);
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  DEFINES
+//
+///////////////////////////////////////////////////////////////////////////
+
+#define TOTALACTIVITIES     10
+#define NUMGROUPENTRIES     10
+#define NAMESIZE            128
+
+// structure keys
+#define GROUPROOTKEY        'GRRT'
+#define AGENTROOTKEY        'AGRT'
+#define AGENTKEY            'AGNT'
+#define GROUPKEY            'GROU'
+#define LISTKEY             'LIST'
+
+
+// window control defines
+#define SIZEBAR             3
+#define WINDOWSCALEFACTOR   15
+
+#define SZAPPNAME           TEXT("ACD Sample")
+
+#endif
+
diff --git a/private/tapi/dev/apps/acd/acdsmpl.rc b/private/tapi/dev/apps/acd/acdsmpl.rc
new file mode 100644
index 000000000..f3cc9d10e
--- /dev/null
+++ b/private/tapi/dev/apps/acd/acdsmpl.rc
@@ -0,0 +1,158 @@
+#include <windows.h>
+#include <commctrl.h>
+#include "resource.h"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_MAINDLG DIALOGEX 0, 0, 420, 230
+STYLE DS_3DLOOK | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CAPTION | 
+    WS_SYSMENU | WS_THICKFRAME
+CAPTION "ACD Sample"
+MENU IDR_MAINMENU
+FONT 8, "MS Sans Serif"
+BEGIN
+    CONTROL         "",IDC_TREEWND,"SysTreeView32",TVS_HASBUTTONS | TVS_HASLINES | 
+                    WS_BORDER | WS_TABSTOP | TVS_DISABLEDRAGDROP ,7,7,125,216,
+                    WS_EX_CLIENTEDGE
+    EDITTEXT        IDC_EDITWND,139,7,274,216,ES_AUTOHSCROLL | ES_READONLY | 
+                    ES_WANTRETURN
+END
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_ADD DIALOG DISCARDABLE  0, 0, 148, 134
+STYLE WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME
+CAPTION "Add Group"
+FONT 8, "MS Sans Serif"
+BEGIN
+    EDITTEXT        IDC_NAME,7,17,134,14,ES_AUTOHSCROLL
+    COMBOBOX        IDC_LINECOMBO,7,50,134,54,CBS_DROPDOWNLIST |  
+                    WS_VSCROLL | WS_TABSTOP
+    COMBOBOX        IDC_ADDRESSCOMBO,7,85,134,51,CBS_DROPDOWNLIST | 
+                    WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,7,113,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,91,113,50,14
+    LTEXT           "&Name",IDC_STATIC,7,7,20,8
+    LTEXT           "Line",IDC_STATIC,7,39,14,8
+    LTEXT           "Address",IDC_STATIC,7,74,26,8
+END
+
+IDD_ADDAGENT DIALOG DISCARDABLE  0, 0, 146, 137
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Add Agent"
+FONT 8, "MS Sans Serif"
+BEGIN
+    EDITTEXT        IDC_NAME,7,20,132,14,ES_AUTOHSCROLL
+    COMBOBOX        IDC_LINECOMBO,7,54,132,83,CBS_DROPDOWNLIST |
+                    WS_VSCROLL | WS_TABSTOP
+    EDITTEXT        IDC_DESTADDRESS,7,90,132,14,ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "OK",IDOK,7,116,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,89,116,50,14
+    LTEXT           "Agent Name",IDC_STATIC,7,8,82,8
+    LTEXT           "Line",IDC_STATIC,7,42,14,8
+    LTEXT           "Transfer Number",IDC_STATIC,7,75,54,8
+END
+
+
+IDD_ADDTOLIST DIALOG DISCARDABLE  0, 0, 222, 142
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Add To"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,41,121,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,127,121,50,14
+    LISTBOX         IDC_LIST1,7,23,68,87,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    WS_VSCROLL | WS_TABSTOP
+    LISTBOX         IDC_LIST2,147,23,68,87,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    WS_VSCROLL | WS_TABSTOP
+    PUSHBUTTON      "&Add >>>",IDC_ADD,84,41,50,14
+    PUSHBUTTON      "<<< &Remove",IDC_REMOVE,84,78,50,14
+    LTEXT           "Static",IDC_STATICNOTINLIST,7,7,98,8
+    LTEXT           "Static",IDC_STATICINLIST,147,7,68,8
+END
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MAINMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Open",                       ID_FILE_OPEN
+        MENUITEM "&New",                        ID_FILE_NEW
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       ID_FILE_EXIT
+    END
+    POPUP "&Edit"
+    BEGIN
+        MENUITEM "Add &Agent",                  ID_EDIT_ADDAGENT
+        MENUITEM "Add &Group",                  ID_EDIT_ADDGROUP
+    END
+    POPUP "&View"
+    BEGIN
+        MENUITEM "&Group View",                 ID_VIEW_GROUP
+        MENUITEM "&Agent View",                 ID_VIEW_AGENT
+    END
+END
+
+////////////////////////////////////////////////////////////////////
+//
+//  Version Info
+//
+
+//#if WINNT
+//#include <ntverp.h>
+//#else
+//#include <version.h>
+//#endif
+#include <winver.h>
+
+
+#ifdef RC_INVOKED
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION     4,00,01,001
+PRODUCTVERSION  4,00,01,001
+FILEFLAGSMASK   VS_FFI_FILEFLAGSMASK
+FILEFLAGS       (VS_FF_PRERELEASE|VS_FF_DEBUG)
+FILEOS          VOS_NT_WINDOWS32
+FILETYPE        VFT_APP
+FILESUBTYPE     VFT2_UNKNOWN
+
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904B0"   /* LANG_ENGLISH/SUBLANG_ENGLISH_US, Unicode CP */
+        BEGIN
+            VALUE "CompanyName",     "Microsoft Corporation\0"
+            VALUE "FileDescription", "TAPI ACD Sample Application\0"
+            VALUE "FileVersion",     "1.0\0"
+            VALUE "InternalName",    "ACDSmple\0"
+            VALUE "LegalCopyright",  "Copyright (C) Microsoft Corp. 1996\0"
+            VALUE "LegalTrademarks", "Microsoft(R) is a registered trademark of Microsoft Corporation. Windows(TM) is a trademark of Microsoft Corporation\0"
+            VALUE "ProductName",     "ACDSmpl\0"
+            VALUE "ProductVersion",  "1.0\0"
+
+        END
+
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x0409, 0x04B0
+    END
+END
+
+#endif
+
+
diff --git a/private/tapi/dev/apps/acd/acdtapi.c b/private/tapi/dev/apps/acd/acdtapi.c
new file mode 100644
index 000000000..1a03899d5
--- /dev/null
+++ b/private/tapi/dev/apps/acd/acdtapi.c
@@ -0,0 +1,1208 @@
+///////////////////////////////////////////////////////////////////////////////////
+//
+//  ACDTAPI.C
+//
+//  This file handles all tapi functionality in the ACD sample
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+#include <tapi.h>
+#include "acdsmpl.h"
+
+VOID CALLBACK LineCallback (DWORD hDevice,
+                            DWORD dwMsg,
+                            DWORD dwCallbackInstance, 
+                            DWORD dwParam1,
+                            DWORD dwParam2, 
+                            DWORD dwParam3);
+
+
+#define LogTapiError(__lResult__, __szString__)
+#define LogError(__szString__)
+
+extern ACDGLOBALS       g;
+
+
+////////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL InitializeTapi()
+//
+//    Whatever is needed to init TAPI for the application.  This is called
+//    before the main window is created.
+//
+////////////////////////////////////////////////////////////////////////////////////
+BOOL InitializeTapi()
+{
+    DWORD                       dwAPIVersion;
+    LINEINITIALIZEEXPARAMS      exparams;
+    LONG                        lResult;
+    DWORD                       i;
+    LPLINEDEVCAPS               pLDC;
+
+
+    // fill in lineinitex parameters
+    exparams.dwTotalSize             = sizeof(LINEINITIALIZEEXPARAMS);
+    exparams.dwOptions               = LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    
+    dwAPIVersion = TAPI_CURRENT_VERSION;
+
+    // line init
+    if ((lResult = lineInitializeEx(&g.hLineApp,
+                                    g.hInstance,
+                                    LineCallback,
+                                    SZAPPNAME,
+                                    &g.dwNumDevs,
+                                    &dwAPIVersion,
+                                    &exparams)) < 0)
+    {
+        LogTapiError(lResult, "lineInitializeEx");
+        return FALSE;
+    }
+
+    // if there are no tapi devices, should probably
+    // not continue
+    if (g.dwNumDevs == 0)
+    {
+        LogError("No TAPI devices installed");
+        lineShutdown(g.hLineApp);
+        return FALSE;
+    }
+
+    // need to get the permanent device IDs to map from
+    // an .ini file being read in
+    g.pdwPermIDs = (LPDWORD)ACDAlloc(g.dwNumDevs * sizeof(DWORD));
+
+    if (!g.pdwPermIDs)
+    {
+        return FALSE;
+    }
+    
+    for (i = 0; i < g.dwNumDevs; i++)
+    {
+        pLDC = LineGetDevCaps(g.hLineApp,
+                              i);
+
+        if (pLDC)
+        {
+            g.pdwPermIDs[i] = pLDC->dwPermanentLineID;
+            ACDFree(pLDC);
+        }
+    }
+
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//
+//  BOOL CleanUp()
+//
+//  Called while shutting down.  free memory, close down tapi
+//
+//////////////////////////////////////////////////////////////////////
+BOOL CleanUp()
+{
+    PAGENT      pAgent, pAgentNext;
+    PGROUP      pGroup, pGroupNext;
+
+    // remove agents
+    pAgent = g.pAgents;
+    while(pAgent)
+    {
+        pAgentNext = pAgent->pNext;
+        DeleteAgent(pAgent);
+        pAgent = pAgentNext;
+    }
+
+    // remove groups
+    pGroup = g.pGroups;
+    while (pGroup)
+    {
+        pGroupNext = pGroup->pNext;
+        DeleteGroup(pGroup);
+        pGroup = pGroupNext;
+    }
+
+    // free id array
+    ACDFree(g.pdwPermIDs);
+
+    // shutdown
+    lineShutdown(g.hLineApp);
+
+    return TRUE;
+    
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT MakeGroupList(PAGENT pAgent,
+//                        LPLINEAGENTGROUPLIST pGroupList)
+//
+//    Creates a LINEAGENTGROUPLIST for pAgent - group that the agent
+//      is allowed to log into
+//    Assumption:  don't care about address for group list
+//
+////////////////////////////////////////////////////////////////////////////////
+LRESULT MakeGroupList(PAGENT pAgent,
+                      LPLINEAGENTGROUPLIST pGroupList)
+{
+    PGROUP                  pGroup;
+    DWORD                   dwTotalSizeNeeded, dwNameOffset, dwNumEntries;
+    LPLINEAGENTGROUPENTRY   pEntry;
+    LPTSTR                  pName;
+
+
+    pGroup = g.pGroups;
+    dwTotalSizeNeeded = sizeof(LINEAGENTGROUPLIST);
+    pGroupList->dwNumEntries = 0;
+    dwNumEntries = 0;
+
+    // walk list of groups
+    while (pGroup)
+    {
+        if (IsAgentInList(pGroup->pAgentList,
+                          pAgent))
+        // if found the agent, add the group to the group list
+        {
+            // incrememt number of entries
+            dwNumEntries++;
+
+            // add to total size needed
+            dwTotalSizeNeeded += sizeof(LINEAGENTGROUPENTRY);
+            dwTotalSizeNeeded += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);
+        }
+
+        pGroup = pGroup->pNext;
+    }
+
+    pGroupList->dwNeededSize = dwTotalSizeNeeded;
+    
+    if (pGroupList->dwTotalSize < dwTotalSizeNeeded)
+    {
+        pGroupList->dwUsedSize = sizeof(LINEAGENTGROUPLIST);
+
+        return 0;
+//        return LINEERR_STRUCTURETOOSMALL;
+    }
+
+    pGroupList->dwNumEntries = dwNumEntries;
+
+    // set the list info
+    pGroupList->dwListSize = sizeof(LINEAGENTGROUPENTRY) * pGroupList->dwNumEntries;
+    pGroupList->dwListOffset = sizeof(LINEAGENTGROUPLIST);
+
+    // get the first agentgroup entry struct
+    pEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pGroupList) + pGroupList->dwListOffset);
+
+    dwNameOffset = pGroupList->dwListOffset + pGroupList->dwListSize;
+    pGroup = g.pGroups;
+
+    // loop through the groups again, and fill in the structure
+    while (pGroup)
+    {
+        if (IsAgentInList(pGroup->pAgentList,
+                          pAgent))
+        {
+            // ID is just PGROUP
+            pEntry->GroupID.dwGroupID1 = (DWORD)pGroup;
+            pEntry->GroupID.dwGroupID2 = 0;
+            pEntry->GroupID.dwGroupID3 = 0;
+            pEntry->GroupID.dwGroupID4 = 0;
+
+            // set name of group
+            pName = (LPTSTR)(((LPBYTE)pGroupList) + dwNameOffset);
+                
+            pEntry->dwNameSize = (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);
+            pEntry->dwNameOffset = dwNameOffset;
+            lstrcpy(pName,
+                    pGroup->lpszName);
+
+            dwNameOffset += pEntry->dwNameSize;
+
+            // get next entry
+            pEntry++;
+        }
+
+        pGroup = pGroup->pNext;
+    }
+
+    pGroupList->dwUsedSize = dwTotalSizeNeeded;
+    
+    return 0;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT SetGroupList()
+//
+//   Sets the groups that the agent is logged into.
+//     This does not change the groups that the agent _can_ log into
+//
+////////////////////////////////////////////////////////////////////////////
+LRESULT SetGroupList(PAGENT pAgent,
+                     DWORD dwAddress,
+                     LPLINEAGENTGROUPLIST pGroupList)
+{
+    LPLINEAGENTGROUPENTRY   pGroupEntry;
+    PLISTITEM               pListEntry;
+    DWORD                   i;
+    PGROUP  *               ppGroups = NULL;
+    PGROUP                  pGroup;
+
+    ppGroups = (PGROUP*)ACDAlloc(sizeof(PGROUP) * pGroupList->dwNumEntries);
+    
+    // get to the group entry struct
+    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pGroupList) + pGroupList->dwListOffset);
+
+    // loop through all entries
+    for (i = 0; i < pGroupList->dwNumEntries; i++)
+    {
+        // get the group in entry
+        // NOTE! NOTE! NOTE!
+        // should protect here against bad pointers !!!
+        pGroup = (PGROUP)pGroupEntry->GroupID.dwGroupID1;
+
+        if (pGroup->dwKey != GROUPKEY)
+        {
+            return LINEERR_INVALAGENTGROUP;
+        }
+        
+        pListEntry = pGroup->pAgentList;
+
+        // walk list of agents in that group
+        if (!IsAgentInList(pGroup->pAgentList,
+                           pAgent))
+        {
+            ACDFree(ppGroups);
+            return LINEERR_INVALAGENTGROUP;
+        }
+
+        // save group for easy access
+        ppGroups[i] = pGroup;
+        
+        // get the next entry (after the variable portion of
+        // the previous entry struct)
+        pGroupEntry++;
+    }
+
+    // now we know that the groups to be set are valid
+    // walk through the list of groups again, and
+    // set the status to logged in/ not logged in
+    // for every group that the agent is a member of
+
+    pGroup = g.pGroups;
+    
+    // walk list of all groups
+    while (pGroup)
+    {
+        if (pListEntry = IsAgentInList(pGroup->pAgentList,
+                                       pAgent))
+        {
+            // default to not logged in
+            pListEntry->bLoggedIn = FALSE;
+
+            // loop through groups being set
+            for (i = 0; i < pGroupList->dwNumEntries; i++)
+            {
+                // if this group is in list, set agent to logged in
+                if (pGroup == ppGroups[i])
+                {
+                    pListEntry->bLoggedIn = TRUE;
+                    // assumption:  agent can only log into a group on one address.
+                    pListEntry->dwAddress = dwAddress;
+                    break;
+                }
+                
+            } // for
+            
+        }  // agent in list
+
+        // next group
+        pGroup = pGroup->pNext;
+        
+    } // while
+
+
+    ACDFree(ppGroups);
+    
+    return 0;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+//  BOOL MakeAgentActivityList()
+//
+//    Creates a LINEAGENTACTIVITYLIST for pAgent
+//
+//    for the sample, just generic names are used
+//    "Activity 1", "Activity 2"....
+//
+/////////////////////////////////////////////////////////////////////////
+LRESULT MakeAgentActivityList(PAGENT pAgent,
+                              LPLINEAGENTACTIVITYLIST pActivityList)
+{
+    TCHAR                       szBuffer[64];
+    DWORD                       dwTotalSize, dwNameOffset, i, dwNumEntries;
+    LPTSTR                      pName;
+    LPLINEAGENTACTIVITYENTRY    pEntry;
+
+    // init
+    dwTotalSize = sizeof(LINEAGENTACTIVITYLIST);
+    pActivityList->dwNumEntries = 0;
+    dwNumEntries = 0;
+    
+    // just a static list of activities
+    for (i = 0; i < TOTALACTIVITIES; i++)
+    {
+        dwNumEntries++;
+
+        // create a name
+        wsprintf(szBuffer, TEXT("Activity %lu"), i);
+
+        // determine size of this entry
+        dwTotalSize += sizeof(LINEAGENTACTIVITYENTRY);
+        dwTotalSize += (lstrlen(szBuffer) + 1) * sizeof(TCHAR);
+    }
+
+    pActivityList->dwNeededSize = dwTotalSize;
+    
+    // verify size
+    if (pActivityList->dwTotalSize < dwTotalSize)
+    {
+        pActivityList->dwUsedSize = sizeof(LINEAGENTACTIVITYLIST);
+
+        return 0;
+//        return LINEERR_STRUCTURETOOSMALL;
+    }
+
+    pActivityList->dwNumEntries = dwNumEntries;
+    
+    // set list stuff
+    pActivityList->dwListSize = sizeof(LINEAGENTACTIVITYENTRY) * pActivityList->dwNumEntries;
+    pActivityList->dwListOffset = sizeof(LINEAGENTACTIVITYLIST);
+
+    // get first activityentry
+    pEntry = (LPLINEAGENTACTIVITYENTRY)(((LPBYTE)pActivityList) + pActivityList->dwListOffset);
+    dwNameOffset = pActivityList->dwListOffset + pActivityList->dwListSize;
+
+    // loop through activities again
+    for (i = 0; i < TOTALACTIVITIES; i++)
+    {
+        // fill in members
+        pEntry->dwID = i;
+
+        // create a name
+        wsprintf(szBuffer, TEXT("Activity %lu"), i);
+
+        pName = (LPTSTR)(((LPBYTE)pActivityList) + dwNameOffset);
+        
+        pEntry->dwNameSize = (lstrlen(szBuffer) + 1) * sizeof(TCHAR);
+        pEntry->dwNameOffset = dwNameOffset;
+        lstrcpy(pName,
+                szBuffer);
+
+        dwNameOffset += pEntry->dwNameSize;
+        
+        pEntry++;
+
+    } // for
+
+    // fill in used size
+    pActivityList->dwUsedSize = dwTotalSize;
+    
+    return 0;
+}
+
+
+#define DWAGENTFEATURES         LINEAGENTFEATURE_SETAGENTGROUP | \
+                                LINEAGENTFEATURE_SETAGENTSTATE | \
+                                LINEAGENTFEATURE_SETAGENTACTIVITY | \
+                                LINEAGENTFEATURE_GETAGENTACTIVITYLIST | \
+                                LINEAGENTFEATURE_GETAGENTGROUP
+
+#define DWSTATES                LINEAGENTSTATE_LOGGEDOFF | \
+                                LINEAGENTSTATE_NOTREADY | \
+                                LINEAGENTSTATE_READY | \
+                                LINEAGENTSTATE_BUSYACD | \
+                                LINEAGENTSTATE_BUSYINCOMING | \
+                                LINEAGENTSTATE_BUSYOUTBOUND | \
+                                LINEAGENTSTATE_BUSYOTHER | \
+                                LINEAGENTSTATE_WORKINGAFTERCALL | \
+                                LINEAGENTSTATE_UNKNOWN | \
+                                LINEAGENTSTATE_UNAVAIL
+
+#define DWNEXTSTATES            LINEAGENTSTATE_LOGGEDOFF | \
+                                LINEAGENTSTATE_NOTREADY | \
+                                LINEAGENTSTATE_READY | \
+                                LINEAGENTSTATE_BUSYACD | \
+                                LINEAGENTSTATE_BUSYINCOMING | \
+                                LINEAGENTSTATE_BUSYOUTBOUND | \
+                                LINEAGENTSTATE_BUSYOTHER | \
+                                LINEAGENTSTATE_WORKINGAFTERCALL | \
+                                LINEAGENTSTATE_UNKNOWN | \
+                                LINEAGENTSTATE_UNAVAIL
+
+#define DWSTATUSMESSAGES        LINEAGENTSTATUS_GROUP | \
+                                LINEAGENTSTATUS_STATE | \
+                                LINEAGENTSTATUS_NEXTSTATE | \
+                                LINEAGENTSTATUS_ACTIVITY | \
+                                LINEAGENTSTATUS_ACTIVITYLIST | \
+                                LINEAGENTSTATUS_GROUPLIST | \
+                                LINEAGENTSTATUS_CAPSCHANGE | \
+                                LINEAGENTSTATUS_VALIDSTATES | \
+                                LINEAGENTSTATUS_VALIDNEXTSTATES
+
+
+////////////////////////////////////////////////////////////////////
+//
+//  BOOL IsValidState(DWORD dwState)
+//
+////////////////////////////////////////////////////////////////////
+BOOL IsValidState(DWORD dwState)
+{
+    if (!dwState)
+    {
+        return TRUE;
+    }
+
+    if ((dwState) & (dwState - 1))
+    {
+        // more than one bit set
+        return FALSE;
+    }
+
+    // make sure it's one of the valid states
+    return (dwState & DWSTATES);
+
+}
+
+
+////////////////////////////////////////////////////////////////////
+//
+//  BOOL IsValidNextState(DWORD dwState)
+//
+////////////////////////////////////////////////////////////////////
+BOOL IsValidNextState(DWORD dwState)
+{
+    if (!dwState)
+    {
+        return TRUE;
+    }
+
+    if ((dwState) & (dwState - 1))
+    {
+        // more than one bit set
+        return FALSE;
+    }
+
+    // make sure it's one of the valid states
+    return (dwState & DWNEXTSTATES);
+
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//
+//  BOOL IsValidActivityID(DWORD dwActivityID)
+//
+///////////////////////////////////////////////////////////////////////
+BOOL IsValidActivityID(DWORD dwActivityID)
+{
+    return (dwActivityID <= TOTALACTIVITIES);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT MakeAgentCaps(PAGENT pAgent,
+//                        LPLINEAGENTCAPS pAgentCaps)
+//
+//    Creates a LINEAGENTCAPS for pAgent
+//    Features/states/messages are hardcoded
+//     for this example
+//
+////////////////////////////////////////////////////////////////////////
+LRESULT MakeAgentCaps(PAGENT pAgent,
+                      LPLINEAGENTCAPS pAgentCaps)
+{
+    DWORD       dwStringSize;
+    
+    dwStringSize = (lstrlen(SZAPPNAME) + 1) * sizeof(TCHAR);
+
+    pAgentCaps->dwNeededSize = sizeof(LINEAGENTCAPS) + dwStringSize;
+
+    if (pAgentCaps->dwTotalSize < pAgentCaps->dwNeededSize)
+    {
+        pAgentCaps->dwUsedSize = sizeof(LINEAGENTCAPS);
+        return 0;
+//        return LINEERR_STRUCTURETOOSMALL;
+    }
+
+    
+    pAgentCaps->dwAgentHandlerInfoSize = dwStringSize;
+    pAgentCaps->dwAgentHandlerInfoOffset = sizeof(LINEAGENTCAPS);
+
+    pAgentCaps->dwCapsVersion = TAPI_CURRENT_VERSION;
+
+    // these features are hardcoded here.
+    // a real implementation may set specific features
+    // per agent or line or address
+    pAgentCaps->dwFeatures              = DWAGENTFEATURES;
+    pAgentCaps->dwStates                = DWSTATES;
+    pAgentCaps->dwNextStates            = DWNEXTSTATES;
+    pAgentCaps->dwMaxNumGroupEntries    = NUMGROUPENTRIES;
+    pAgentCaps->dwAgentStatusMessages   = DWSTATUSMESSAGES;
+
+    // no extensions
+    pAgentCaps->dwNumAgentExtensionIDs = 0;
+    pAgentCaps->dwAgentExtensionIDListSize = 0;
+    pAgentCaps->dwAgentExtensionIDListOffset = 0;
+
+
+    pAgentCaps->dwUsedSize = pAgentCaps->dwNeededSize;
+    
+    return 0;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT GetAgentStatus()
+//
+//  Creates a LINEAGENTSTATUS for pAgent
+//
+//////////////////////////////////////////////////////////////////////////
+LRESULT GetAgentStatus(PAGENT pAgent,
+                       DWORD dwAddress,
+                       LPLINEAGENTSTATUS pAgentStatus)
+{
+    PGROUP                  pGroup;
+    LPLINEAGENTGROUPENTRY   pGroupEntry;
+    DWORD                   dwTotalSize, dwNameOffset, dwCount;
+    TCHAR                   szActivityName[NAMESIZE];
+    PGROUP *                ppGroups;
+    PLISTITEM               pEntry;
+
+    // init total size
+    dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    if (dwAddress >= pAgent->dwNumAddresses)
+    {
+        return LINEERR_INVALADDRESSID;
+    }
+    
+    // set know members
+    // for valid states / next states / agent features, just setting it to
+    // generic stuff.  a real implementation may want to set these
+    // field depending on current state / agent / hline
+    pAgentStatus->dwState           = pAgent->pAddressInfo[dwAddress].dwState;
+    pAgentStatus->dwNextState       = pAgent->pAddressInfo[dwAddress].dwNextState;
+    pAgentStatus->dwActivityID      = pAgent->pAddressInfo[dwAddress].dwActivity;
+    pAgentStatus->dwAgentFeatures   = DWAGENTFEATURES;
+    pAgentStatus->dwValidStates     = DWSTATES;
+    pAgentStatus->dwValidNextStates = DWNEXTSTATES;
+
+    // create the activity name
+    wsprintf(szActivityName, TEXT("Activity %lu"), pAgent->pAddressInfo[dwAddress].dwActivity);
+    dwTotalSize += (lstrlen(szActivityName) + 1) * sizeof(TCHAR);
+
+    ppGroups = (PGROUP *)ACDAlloc(sizeof(PGROUP) * g.dwNumGroups);
+
+    pGroup = g.pGroups;
+
+    pAgentStatus->dwNumEntries = 0;
+
+    // walk list of groups
+    while (pGroup)
+    {
+        pEntry = pGroup->pAgentList;
+
+        // walk each agent in each group
+        while (pEntry)
+        {
+            if (pEntry->pAgent == pAgent)
+            {
+                if ((!pEntry->bLoggedIn) ||
+                    (pEntry->dwAddress != dwAddress))
+                {
+                    break;
+                }
+
+                // save group
+                ppGroups[pAgentStatus->dwNumEntries] = pGroup;
+
+                // adjust total size / entries
+                pAgentStatus->dwNumEntries++;
+                dwTotalSize += sizeof(LINEAGENTGROUPENTRY);
+                dwTotalSize += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);
+
+                break;
+            }
+
+            pEntry = pEntry->pNext;
+            
+        }  // while (pEntry)
+
+        pGroup = pGroup->pNext;
+        
+    } // while (pGroup)
+
+    // set needed size
+    pAgentStatus->dwNeededSize = dwTotalSize;
+
+    // do we have enough room?
+    if (pAgentStatus->dwTotalSize < dwTotalSize)
+    {
+        // if not, return
+        pAgentStatus->dwUsedSize = sizeof(LINEAGENTSTATUS);
+        ACDFree(ppGroups);
+
+        return 0;
+//        return LINEERR_STRUCTURETOOSMALL;
+    }
+
+
+    // set the group entries...
+
+    // first get the offset to the first entry
+    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pAgentStatus) + sizeof(LINEAGENTSTATUS));
+    pAgentStatus->dwGroupListOffset = sizeof(LINEAGENTSTATUS);
+
+    // figure out where the names can go (after all the fixed structures)
+    dwNameOffset = sizeof(LINEAGENTSTATUS) +
+                   sizeof(LINEAGENTGROUPENTRY) * pAgentStatus->dwNumEntries;
+
+    // loop through all the group that the agent is logged into
+    for (dwCount = 0; dwCount < pAgentStatus->dwNumEntries; dwCount++)
+    {
+        // set the it (just the pGroup)
+        pGroupEntry->GroupID.dwGroupID1 = (DWORD)ppGroups[dwCount];
+        pGroupEntry->GroupID.dwGroupID2 = 0;
+        pGroupEntry->GroupID.dwGroupID3 = 0;
+        pGroupEntry->GroupID.dwGroupID4 = 0;
+
+        // set name size and offset
+        pGroupEntry->dwNameSize = (lstrlen(ppGroups[dwCount]->lpszName) + 1) * sizeof(TCHAR);
+        pGroupEntry->dwNameOffset = dwNameOffset;
+
+        // copy name
+        lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset),
+                ppGroups[dwCount]->lpszName);
+
+        // fix the name offset
+        dwNameOffset += pGroupEntry->dwNameSize;
+
+        // next entry
+        pGroupEntry++;
+        
+    }
+
+    pAgentStatus->dwGroupListSize = dwNameOffset - pAgentStatus->dwGroupListOffset;
+    
+    // put the activity name at the end
+    pAgentStatus->dwActivitySize = (lstrlen(szActivityName) + 1) * sizeof(TCHAR);
+    pAgentStatus->dwActivityOffset = dwNameOffset;
+
+    lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset),
+            szActivityName);
+
+    
+    ACDFree(ppGroups);
+
+    pAgentStatus->dwUsedSize = pAgentStatus->dwNeededSize;
+    // return success
+    return 0;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+//
+//  LRESULT SetAgentState()
+//
+//    Sets the current and next state for pAgent
+//    on that specific address
+//
+//
+/////////////////////////////////////////////////////////////////////
+LRESULT SetAgentState(PAGENT pAgent,
+                      DWORD dwAddress,
+                      DWORD dwState,
+                      DWORD dwNextState)
+{
+    // make sure valid
+    if ((!IsValidState(dwState)) ||
+        (!IsValidNextState(dwNextState)))
+    {
+        return LINEERR_INVALAGENTSTATE;
+    }
+
+    // check address
+    if (dwAddress >= pAgent->dwNumAddresses)
+    {
+        return LINEERR_INVALADDRESSID;
+    }
+
+    // set the state if specified
+    if (dwState)
+    {
+        pAgent->pAddressInfo[dwAddress].dwState = dwState;
+    }
+
+    if (dwNextState)
+    {
+        pAgent->pAddressInfo[dwAddress].dwNextState = dwNextState;
+    }
+    
+    return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT SetAgentActivity()
+//
+//   Sets the activity for pAgent
+//
+///////////////////////////////////////////////////////////////////////////////
+LRESULT SetAgentActivity(PAGENT pAgent,
+                         DWORD dwAddress,
+                         DWORD dwActivityID)
+{
+    if (dwAddress >= pAgent->dwNumAddresses)
+    {
+        return LINEERR_INVALADDRESSID;
+    }
+
+    if (!IsValidActivityID(dwActivityID))
+    {
+        return LINEERR_INVALAGENTACTIVITY;
+    }
+
+    pAgent->pAddressInfo[dwAddress].dwActivity = dwActivityID;
+    
+    return 0;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL HandleOffering(HCALL hCall)
+//
+//    Handles a LINECALLSTATE_OFFERING message
+//      Determines the group associated with the address
+//      that the call came in on, finds an available
+//      agent in that group, and transfers the call to that
+//      agent.
+//
+////////////////////////////////////////////////////////////////////////////////
+BOOL HandleOffering(HCALL hCall)
+{
+    LPLINECALLINFO      pLCI;
+    PGROUP              pGroup;
+    PLISTITEM           pEntry;
+    LONG                lResult;
+    
+    pLCI = LineGetCallInfo(hCall);
+
+    if (!pLCI)
+    {
+        return FALSE;
+    }
+
+    pGroup = g.pGroups;
+
+    // find the group that this call came in on
+    // walk all the groups
+    while (pGroup)
+    {
+        // if the line and address match, it's the
+        // correct address
+        if ((pGroup->hLine == pLCI->hLine) &&
+            (pGroup->dwAddress == pLCI->dwAddressID))
+        {
+            break;
+        }
+
+        pGroup = pGroup->pNext;
+    }
+
+    // couldn't find the group
+    if (!pGroup)
+    {
+        // error!
+        ACDFree(pLCI);
+        return FALSE;
+    }
+
+    // OK - found the group that this call is for.  Now transfer to
+    // an agent that is available.
+    pEntry = pGroup->pAgentList;
+
+    while (pEntry)
+    {
+        if (pEntry->bLoggedIn &&
+            (pEntry->pAgent->pAddressInfo[pEntry->dwAddress].dwState ==
+                LINEAGENTSTATE_READY))
+        {
+            // found someone
+            // doing a blind transfer here
+            // other implementations may need to
+            // do lineSetupTransfer / lineDial / lineCompleteTransfer
+            if (lResult = lineBlindTransfer(hCall,
+                                            (LPCWSTR)pEntry->pAgent->lpszNumber,
+                                            0))
+            {
+                //LogTapiError(TEXT("lineBlindTransfer"), lResult);
+                // don't break - try the next agent
+            }
+            else
+            {
+                // set the state to reflect that
+                // a call is being handled
+                SetAgentState(pEntry->pAgent,
+                              pEntry->dwAddress,
+                              LINEAGENTSTATE_BUSYACD,
+                              LINEAGENTSTATE_READY);
+
+                break;
+            }
+
+        }
+        
+        pEntry = pEntry->pNext;
+    }
+
+    if (!pEntry)
+    {
+        // couldn't find an available agent
+
+        // NOTE! NOTE! NOTE! NOTE! NOTE!
+        // something should be done here with this call.  put into
+        // a queue on hold or something.  For this sample, we are just
+        // ignoring it
+    }
+
+    ACDFree(pLCI);
+
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+//  BOOL HandleIdle(HCALL hCall)
+//
+//    Handles LINECALLSTATE_IDLE
+//     Should always always always deallocate when
+//     getting an IDLE message.  Also, determine if this is a call
+//     that we know about and set the agent state appropriatly
+//
+//////////////////////////////////////////////////////////////////////////
+BOOL HandleIdle(HCALL hCall)
+{
+    LPLINECALLINFO      pLCI;
+    PAGENT              pAgent;
+
+    pLCI = LineGetCallInfo(hCall);
+
+    // always deallocate the call
+    lineDeallocateCall(hCall);
+
+    if (!pLCI)
+    {
+        return FALSE;
+    }
+
+    // get the agent associated with the line
+    pAgent = GetAgentFromhLine(pLCI->hLine);
+
+    if (!pAgent)
+    {
+        ACDFree(pLCI);
+        return FALSE;
+    }
+              
+
+    // set that agent to their next state
+    // Assumption:  only calls that the ACD app know about
+    // occur.  For example, if an agent made an outgoing call
+    // and it transitioned to idle, this code would still be executed.
+    // May make more sense to not handle NextState in the ACD app, and let
+    // the client app handle it.
+    SetAgentState(pAgent,
+                  pLCI->dwAddressID,
+                  pAgent->pAddressInfo[pLCI->dwAddressID].dwNextState,
+                  0);
+
+    ACDFree(pLCI);
+    
+    return TRUE;
+    
+}
+
+
+////////////////////////////////////////////////////////////////////////////
+//
+//  void HandleLineProxyRequest(HLINE hLine,
+//                              LPLINEPROXYREQUEST pProxyRequest)
+//
+//    Handles LINE_PROXYREQUEST message
+//     Just dispatches to appropriate functions
+//
+////////////////////////////////////////////////////////////////////////////
+void HandleLineProxyRequest(HLINE hLine,
+                            LPLINEPROXYREQUEST pProxyRequest)
+{
+    PAGENT       pAgent;
+    LRESULT      lResult;
+
+    pAgent = GetAgentFromName((LPTSTR)(((LPBYTE)pProxyRequest) +
+                                       pProxyRequest->dwClientUserNameOffset));
+    
+    if (!pAgent)
+    {
+        lineProxyResponse(hLine,
+                          pProxyRequest,
+                          LINEERR_INVALAGENTID);
+
+        return;
+    }
+    
+    switch (pProxyRequest->dwRequestType)
+    {
+        case LINEPROXYREQUEST_SETAGENTGROUP:
+
+            lResult = SetGroupList(pAgent,
+                                   pProxyRequest->SetAgentGroup.dwAddressID,
+                                   &pProxyRequest->SetAgentGroup.GroupList);
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+
+            return;
+            
+        case LINEPROXYREQUEST_SETAGENTSTATE:
+
+            lResult = SetAgentState(pAgent,
+                                    pProxyRequest->SetAgentState.dwAddressID,
+                                    pProxyRequest->SetAgentState.dwAgentState,
+                                    pProxyRequest->SetAgentState.dwNextAgentState);
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+            
+            break;
+            
+        case LINEPROXYREQUEST_SETAGENTACTIVITY:
+
+            lResult = SetAgentActivity(pAgent,
+                                       pProxyRequest->SetAgentActivity.dwAddressID,
+                                       pProxyRequest->SetAgentActivity.dwActivityID);
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+            
+            break;
+            
+        case LINEPROXYREQUEST_GETAGENTSTATUS:
+
+            lResult = GetAgentStatus(pAgent,
+                                     pProxyRequest->GetAgentStatus.dwAddressID,
+                                     &pProxyRequest->GetAgentStatus.AgentStatus);
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+            
+            break;
+            
+        case LINEPROXYREQUEST_GETAGENTCAPS:
+
+            if ((hLine == pAgent->hLine) &&
+                (pProxyRequest->GetAgentCaps.dwAddressID < pAgent->dwNumAddresses))
+            {
+                lResult = MakeAgentCaps(pAgent,
+                                        &pProxyRequest->GetAgentCaps.AgentCaps);
+            }
+            else
+            {
+                lResult = LINEERR_BADDEVICEID;
+            }
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+            break;
+            
+        case LINEPROXYREQUEST_GETAGENTACTIVITYLIST:
+
+            lResult = MakeAgentActivityList(pAgent,
+                                            &pProxyRequest->GetAgentActivityList.ActivityList);
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+            
+            break;
+            
+        case LINEPROXYREQUEST_GETAGENTGROUPLIST:
+
+            lResult = MakeGroupList(pAgent,
+                                    &pProxyRequest->GetAgentGroupList.GroupList);
+
+            lineProxyResponse(hLine,
+                              pProxyRequest,
+                              lResult);
+            return;
+            
+
+    }
+    return;
+}
+
+/////////////////////////////////////////////////////////////
+//
+//  void HandleLineCallState(DWORD dwDevice,
+//
+//  Handles callstate messages we are interested in
+//
+/////////////////////////////////////////////////////////////
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3)
+{
+    switch (dwParam1)
+    {
+    case LINECALLSTATE_OFFERING:
+    {
+        LPLINECALLSTATUS        pLCS;
+
+        // get the call privilege.
+        // NOTE:  the new LINE_APPNEWCALL message notifies applications
+        // of their priv for new calls not created by app
+        pLCS = LineGetCallStatus((HCALL)dwDevice);
+        if (!pLCS)
+        {
+            break;
+        }
+        
+        if (pLCS->dwCallPrivilege & LINECALLPRIVILEGE_OWNER)
+        {
+            HandleOffering((HCALL)dwDevice);
+        }
+
+        ACDFree(pLCS);
+        
+        break;
+    }
+    case LINECALLSTATE_CONNECTED:
+        break;
+
+    case LINECALLSTATE_DISCONNECTED:
+        break;
+
+    case LINECALLSTATE_IDLE:
+
+        HandleIdle((HCALL)dwDevice);
+        
+        break;
+
+    case LINECALLSTATE_BUSY:
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////
+// TAPI message handlers.  For this sample, they don't
+// do anything
+///////////////////////////////////////////////////////////////////////
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3)
+{
+}
+
+
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3)
+{
+}
+void HandleLineCallInfo(DWORD dwParam1,
+                             DWORD dwParam2,
+                             DWORD dwParam3)
+{
+}
+
+void HandleLineClose(DWORD dwParam1,
+                          DWORD dwParam2,
+                          DWORD dwParam3)
+{
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////
+//
+// LineCallback() - TAPI callback function
+//
+//////////////////////////////////////////////////////////////////////////////////
+VOID CALLBACK LineCallback (DWORD hDevice,
+                            DWORD dwMsg,
+                            DWORD dwCallbackInstance, 
+                            DWORD dwParam1,
+                            DWORD dwParam2, 
+                            DWORD dwParam3)
+{
+    switch(dwMsg)
+    {
+      case LINE_PROXYREQUEST:
+           HandleLineProxyRequest((HLINE) hDevice,
+                                  (LPLINEPROXYREQUEST)dwParam1);
+           return;
+           
+      case LINE_LINEDEVSTATE:
+          HandleLineDevState(dwParam1,
+                             dwParam2,
+                             dwParam3);
+          return;
+      case LINE_REPLY:
+          HandleLineReply(dwParam1,
+                          dwParam2,
+                          dwParam3);
+          return;
+      case LINE_CALLSTATE:
+          HandleLineCallState(hDevice,
+                              dwParam1,
+                              dwParam2,
+                              dwParam3);
+          return; 
+      case LINE_CALLINFO:
+          HandleLineCallInfo(dwParam1,
+                             dwParam2,
+                             dwParam3);
+          return;
+      case LINE_CLOSE:
+          HandleLineClose(dwParam1,
+                          dwParam2,
+                          dwParam3);
+          return;
+
+      default:
+          return;
+   }
+}
+
+   
diff --git a/private/tapi/dev/apps/acd/acdutils.c b/private/tapi/dev/apps/acd/acdutils.c
new file mode 100644
index 000000000..4406c554e
--- /dev/null
+++ b/private/tapi/dev/apps/acd/acdutils.c
@@ -0,0 +1,817 @@
+//////////////////////////////////////////////////////////////////
+//
+//  ACDUTILS.C
+//
+//  Some utility functions used in ACDSMPL
+//
+//////////////////////////////////////////////////////////////////
+
+
+
+#include <windows.h>
+#include "acdsmpl.h"
+
+extern ACDGLOBALS   g;
+
+//////////////////////////////////////////////////////////////////
+//
+//  LPVOID ACDAlloc(DWORD dwSize)
+//
+//////////////////////////////////////////////////////////////////
+LPVOID ACDAlloc(DWORD dwSize)
+{
+    LPVOID  pBuf;
+
+    pBuf = GlobalAlloc(GPTR, dwSize);
+
+    return pBuf;
+}
+
+///////////////////////////////////////////////////////////////////
+//
+//  void ACDFree(LPVOID pBuf)
+//
+///////////////////////////////////////////////////////////////////
+void ACDFree(LPVOID pBuf)
+{
+    if (pBuf)
+        GlobalFree(pBuf);
+}
+
+///////////////////////////////////////////////////////////////////
+//
+// LPVOID ACDReAlloc()
+//
+///////////////////////////////////////////////////////////////////
+LPVOID ACDReAlloc(LPVOID pBuf,
+                  DWORD dwSize)
+{
+    if (pBuf)
+    {
+        pBuf = GlobalReAlloc(pBuf,
+                             dwSize,
+                             GMEM_MOVEABLE);
+    }
+
+    return pBuf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL InsertStruct(PGENERICSTRUCT * ppRoot,
+//                    PGENERICSTRUCT pStruct)
+//
+//    Adds a structure to the end of a linked list
+//
+///////////////////////////////////////////////////////////////////////////////
+BOOL InsertStruct(PGENERICSTRUCT * ppRoot,
+                  PGENERICSTRUCT pStruct)
+{
+    PGENERICSTRUCT      pHold = NULL;
+    
+    if (!*ppRoot)
+    {
+        *ppRoot = pStruct;
+    }
+    else
+    {
+        pHold = *ppRoot;
+    }
+
+    if (pHold)
+    {
+        while (pHold->pNext)
+        {
+            pHold = pHold->pNext;
+        }
+
+        pHold->pNext = pStruct;
+        pStruct->pPrev = pHold;
+    }
+
+    return TRUE;
+}
+
+//////////////////////////////////////////////////////////////
+//
+//  BOOL DeleteStruct
+//      Delete structure
+//
+//   Delete a structure from a linked list and
+//   frees memory associated with it.
+//
+//////////////////////////////////////////////////////////////
+BOOL DeleteStruct(PGENERICSTRUCT * ppRoot,
+                  PGENERICSTRUCT pStruct)
+{
+    if (pStruct->pPrev)
+    {
+        pStruct->pPrev->pNext = pStruct->pNext;
+    }
+    else
+    {
+        *ppRoot = pStruct->pNext;
+    }
+    
+    if (pStruct->pNext)
+    {
+        pStruct->pNext->pPrev = pStruct->pPrev;
+    }
+
+    ACDFree(pStruct);
+
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////
+//
+//  PGROUP AddGroup
+//
+//  Adds a group to the global group list
+// 
+//////////////////////////////////////////////////////////////
+PGROUP AddGroup(LPTSTR lpszName,
+                 DWORD dwDeviceID,
+                 DWORD dwAddress)
+{
+    PGROUP                  pGroup, pHold = NULL;
+    LONG                    lResult;
+    
+    // alloc memory
+    pGroup = (PGROUP)ACDAlloc(sizeof(GROUP));
+
+    if (!pGroup)
+    {
+        return NULL;
+    }
+
+    pGroup->lpszName = (LPTSTR)ACDAlloc((lstrlen(lpszName) + 1) * sizeof(TCHAR));
+
+    // bail if there is a problem
+    if (!pGroup->lpszName)
+    {
+        ACDFree(pGroup);
+        return NULL;
+    }
+
+    // init stuff
+    lstrcpy(pGroup->lpszName, lpszName);
+    
+    pGroup->dwKey = GROUPKEY;
+    pGroup->dwSize = sizeof(GROUP);
+    pGroup->dwDeviceID = dwDeviceID;
+
+
+    // open the line in owner mode, so we can
+    // get the incoming calls
+    lResult = lineOpen(g.hLineApp,
+                       dwDeviceID,
+                       &pGroup->hLine,
+                       TAPI_CURRENT_VERSION,
+                       0,
+                       0,
+                       LINECALLPRIVILEGE_OWNER,
+                       LINEMEDIAMODE_INTERACTIVEVOICE,
+                       NULL);
+    
+    if (lResult < 0)
+    {
+//      LogTapiError(lResult, "lineOpen line %lu", dwDeviceID);
+        ACDFree(pGroup->lpszName);
+        ACDFree(pGroup);
+
+        return NULL;
+    }
+
+    // insert into global list
+    InsertStruct((PGENERICSTRUCT *)&g.pGroups,
+                 (PGENERICSTRUCT)pGroup);
+
+    // increment
+    g.dwNumGroups++;
+
+    return pGroup;
+}
+
+//////////////////////////////////////////////////////////////
+//
+// PAGENT AddAgent
+//
+//  Adds an agent to the global agent list
+//
+//  NOTE:  There is a ton of verification type stuff that can
+//  be put in here for a real implementation.   For example,
+//  might want to restrict a user to a single line, or restrict
+//  a single line to have one person.
+//   
+//////////////////////////////////////////////////////////////
+PAGENT AddAgent(LPTSTR lpszName,
+                LPTSTR lpszNumber,
+                DWORD dwDeviceID)
+{
+    PAGENT              pAgent, pHold = NULL;
+    LPLINEDEVCAPS       pLDC;
+    LPLINECALLPARAMS    pLCP;
+    LONG                lResult;
+    LPDWORD             pdwProxyRequests;
+
+    // alloc memory
+    pAgent = (PAGENT)ACDAlloc(sizeof(AGENT));
+
+    if (!pAgent)
+    {
+        return NULL;
+    }
+
+    pAgent->lpszName = (LPTSTR)ACDAlloc((lstrlen(lpszName) + 1) * sizeof(TCHAR));
+    pAgent->lpszNumber = (LPTSTR)ACDAlloc((lstrlen(lpszNumber) + 1) * sizeof(TCHAR));    
+
+    // bail if there is a problem
+    if (!pAgent->lpszName || !pAgent->lpszNumber)
+    {
+        ACDFree(pAgent);
+        return NULL;
+    }
+
+
+    // init stuff
+    lstrcpy(pAgent->lpszName, lpszName);
+    lstrcpy(pAgent->lpszNumber, lpszNumber);
+    
+    pAgent->dwKey       = AGENTKEY;
+    pAgent->dwSize      = sizeof(AGENT);
+    pAgent->dwDeviceID  = dwDeviceID;
+    pAgent->dwPermID    = g.pdwPermIDs[dwDeviceID];
+
+    // insert into global agent list
+    InsertStruct((PGENERICSTRUCT *)&g.pAgents,
+                 (PGENERICSTRUCT)pAgent);
+
+    // lineOpen is where the application lets TAPI know that it is a Proxy Request handler
+    // for this line.  The LINEOPENOPTION_PROXY is added to the privileges.  Also,
+    // the dev specific portion of LINECALLPARAMS contains the proxy request constants
+    // that indicate which requests this app can handle
+
+    // This sample handles 7 types of proxy requests - all the ones that are defined
+    // except for AGENTSPECIFIC
+    pLCP = (LPLINECALLPARAMS)ACDAlloc(sizeof(LINECALLPARAMS) + 7*sizeof(DWORD));
+
+    pLCP->dwTotalSize           = sizeof(LINECALLPARAMS) + 7*sizeof(DWORD);
+    pLCP->dwDevSpecificOffset   = sizeof(LINECALLPARAMS);
+    pLCP->dwDevSpecificSize     = sizeof(DWORD) * 7;
+
+    pdwProxyRequests = (LPDWORD)((LPBYTE)pLCP + sizeof(LINECALLPARAMS));
+    // each constant is in a DWORD at the end of LINECALLPARAMS
+    *pdwProxyRequests++ = LINEPROXYREQUEST_SETAGENTGROUP;
+    *pdwProxyRequests++ = LINEPROXYREQUEST_SETAGENTSTATE;
+    *pdwProxyRequests++ = LINEPROXYREQUEST_SETAGENTACTIVITY;
+    *pdwProxyRequests++ = LINEPROXYREQUEST_GETAGENTSTATUS;
+    *pdwProxyRequests++ = LINEPROXYREQUEST_GETAGENTCAPS;
+    *pdwProxyRequests++ = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+    *pdwProxyRequests   = LINEPROXYREQUEST_GETAGENTGROUPLIST;        
+        
+    lResult = lineOpen(g.hLineApp,
+                       dwDeviceID,
+                       &pAgent->hLine,
+                       TAPI_CURRENT_VERSION,
+                       0,
+                       0,
+                       LINEOPENOPTION_PROXY | LINECALLPRIVILEGE_MONITOR,
+                       LINEMEDIAMODE_INTERACTIVEVOICE,
+                       pLCP);
+    
+    ACDFree(pLCP);
+    
+    if (lResult)
+    {
+        //
+        ACDFree(pAgent->lpszName);
+        ACDFree(pAgent);
+        
+    }
+
+    pLDC = LineGetDevCaps(g.hLineApp,
+                          pAgent->dwDeviceID);
+
+    if (!pLDC)
+    {
+        return FALSE;
+    }
+
+    // alloc memory for address specific info
+    pAgent->pAddressInfo = (PADDRESSINFO)ACDAlloc(sizeof(ADDRESSINFO) * pLDC->dwNumAddresses);
+    pAgent->dwNumAddresses = pLDC->dwNumAddresses;
+
+    ACDFree(pLDC);
+
+    // increment number of agents
+    g.dwNumAgents++;
+
+    return pAgent;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+// BOOL DeleteAgent(PAGENT pAgent)
+//
+//  Frees all memory associated with pAgent, removes
+//  agent from group lists, and remove pAgent from
+//  global agent list
+//
+//////////////////////////////////////////////////////////////////////////
+BOOL DeleteAgent(PAGENT pAgent)
+{
+    PGROUP      pGroup;
+
+    
+    lineClose(pAgent->hLine);
+    
+    // free name
+    ACDFree(pAgent->lpszName);
+    ACDFree(pAgent->lpszNumber);
+
+    // free address info
+    ACDFree(pAgent->pAddressInfo);
+
+    pGroup = g.pGroups;
+
+    // walk through groups and remove from
+    // group list if in group list
+    while (pGroup)
+    {
+        if (IsAgentInList(pGroup->pAgentList,
+                          pAgent))
+        {
+            RemoveFromGroupList(pGroup,
+                                pAgent);
+        }
+
+        pGroup = pGroup->pNext;
+        
+    }
+
+    // finally, remove pAgent from global list
+    DeleteStruct((PGENERICSTRUCT *)&g.pAgents,
+                 (PGENERICSTRUCT)pAgent);
+
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+// BOOL DeleteGroup(PGROUP pGroup)
+//
+//  Frees memory assocated with pGroup, and removes the structure from
+//  the global list
+//
+//////////////////////////////////////////////////////////////////////////
+BOOL DeleteGroup(PGROUP pGroup)
+{
+    PLISTITEM       pList, pListNext;
+
+    lineClose(pGroup->hLine);
+    
+    ACDFree(pGroup->lpszName);
+
+    pList = pGroup->pAgentList;
+
+    while (pList)
+    {
+        pListNext = pList->pNext;
+        ACDFree(pList);
+        pList = pListNext;
+    }
+
+    DeleteStruct((PGENERICSTRUCT *)&g.pGroups,
+                 (PGENERICSTRUCT)pGroup);
+
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+// BOOL InsertIntoGroupList(PGROUP pGroup,
+//                          PAGENT pAgent)
+//
+//  Insert an agent in a group
+//
+//////////////////////////////////////////////////////////////////////////
+BOOL InsertIntoGroupList(PGROUP pGroup,
+                         PAGENT pAgent)
+{
+    PLISTITEM       pListItem;
+
+    pListItem = (PLISTITEM)ACDAlloc(sizeof(LISTITEM));
+
+    pListItem->dwKey = LISTKEY;
+    pListItem->dwSize = sizeof(LISTITEM);
+    pListItem->pAgent = pAgent;
+
+    InsertStruct((PGENERICSTRUCT *)&pGroup->pAgentList,
+                 (PGENERICSTRUCT)pListItem);
+    
+    return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////////
+//
+// BOOL RemoveFromGroupList(PGROUP pGroup,
+//
+//  remove an agent from a group's list
+//
+//////////////////////////////////////////////////////////////////////////
+BOOL RemoveFromGroupList(PGROUP pGroup,
+                         PAGENT pAgent)
+{
+    PLISTITEM       pList;
+
+    pList = pGroup->pAgentList;
+
+    while (pList)
+    {
+        if (pList->pAgent == pAgent)
+        {
+            break;
+        }
+
+        pList = pList->pNext;
+    }
+
+    if (!pList)
+    {
+        return FALSE;
+    }
+    
+    DeleteStruct((PGENERICSTRUCT *)&pGroup->pAgentList,
+                 (PGENERICSTRUCT)pList);
+
+    return TRUE;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//PLISTITEM IsAgentInList(PLISTITEM pList,
+//                        PAGENT pAgent)
+//
+////////////////////////////////////////////////////////////////////////////////
+PLISTITEM IsAgentInList(PLISTITEM pList,
+                        PAGENT pAgent)
+{
+    while (pList)
+    {
+        if (pList->pAgent == pAgent)
+        {
+            return pList;
+        }
+
+        pList = pList->pNext;
+    }
+
+    return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// PAGENT GetAgentFromName(LPTSTR lpszName)
+//
+////////////////////////////////////////////////////////////////////////////////
+PAGENT GetAgentFromName(LPTSTR lpszName)
+{
+    PAGENT   pHold;
+
+    pHold = g.pAgents;
+
+    while (pHold)
+    {
+        if (!lstrcmpi(pHold->lpszName,
+                     lpszName))
+        {
+            return pHold;
+        }
+
+        pHold = pHold->pNext;
+    }
+
+    return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// PAGENT GetAgentFromhLine(HLINE hLine)
+//
+///////////////////////////////////////////////////////////////////////////////
+PAGENT GetAgentFromhLine(HLINE hLine)
+{
+    PAGENT pAgent;
+
+    pAgent = g.pAgents;
+
+    while (pAgent)
+    {
+        if (pAgent->hLine == hLine)
+        {
+            return pAgent;
+        }
+        
+        pAgent = pAgent->pNext;
+    }
+
+    return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  DWORD GetDeviceID(DWORD dwPermID)
+//
+///////////////////////////////////////////////////////////////////////////////
+DWORD GetDeviceID(DWORD dwPermID)
+{
+    DWORD   dwCount;
+
+    for (dwCount = 0; dwCount < g.dwNumDevs; dwCount++)
+    {
+        if (g.pdwPermIDs[dwCount] == dwPermID)
+        {
+            return dwCount;
+        }
+    }
+
+    return (DWORD)-1;
+}
+    
+///////////////////////////////////////////////////////////////////////////////
+//
+//      **************TAPI WRAPPER FUNCTIONS**************
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetAddressCaps()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEADDRESSCAPS * LineGetAddressCaps (HLINEAPP hLineApp,
+                                      DWORD    dwDeviceID,
+                                      DWORD    dwAddressID)
+{
+    LONG              lRetVal;
+    LINEADDRESSCAPS * pLineAddressCaps;
+    static DWORD      dwMaxNeededSize = sizeof(LINEADDRESSCAPS);
+
+    // Allocate an initial block of memory for the LINEADDRESSCAPS structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineAddressCaps = ACDAlloc(dwMaxNeededSize);
+
+    for (;;)
+    {
+        if (pLineAddressCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineAddressCaps->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINEADDRESSCAPS information
+        //
+        lRetVal = lineGetAddressCaps(hLineApp,
+                                     dwDeviceID,
+                                     dwAddressID,
+                                     TAPI_CURRENT_VERSION,
+                                     0,
+                                     pLineAddressCaps);
+        if (lRetVal < 0)
+        {
+            ACDFree((HLOCAL)pLineAddressCaps);
+            return NULL;
+        }
+
+        // If the currently allocated LINEADDRESSCAPS memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineAddressCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineAddressCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineAddressCaps->dwNeededSize;
+            pLineAddressCaps = ACDReAlloc((HLOCAL)pLineAddressCaps,
+                                            dwMaxNeededSize);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetCallInfo()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINECALLINFO * LineGetCallInfo (HCALL hCall)
+{
+    LONG           lRetVal;
+    LINECALLINFO * pLineCallInfo;
+    static DWORD   dwMaxNeededSize = sizeof(LINECALLINFO);
+
+    // Allocate an initial block of memory for the LINECALLINFO structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineCallInfo = ACDAlloc(dwMaxNeededSize);
+
+    for (;;)
+    {
+        if (pLineCallInfo == NULL)
+        {
+            return NULL;
+        }
+        pLineCallInfo->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINECALLINFO information
+        //
+        lRetVal = lineGetCallInfo(hCall,
+                                  pLineCallInfo);
+        if (lRetVal < 0)
+        {
+            ACDFree((HLOCAL)pLineCallInfo);
+            return NULL;
+        }
+
+        // If the currently allocated LINECALLINFO memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineCallInfo->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineCallInfo;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineCallInfo->dwNeededSize;
+            pLineCallInfo = ACDReAlloc((HLOCAL)pLineCallInfo,
+                                         dwMaxNeededSize);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetDevCaps()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID)
+{
+    LONG           lRetVal;
+    LINEDEVCAPS  * pLineDevCaps;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVCAPS);
+
+    pLineDevCaps = ACDAlloc(dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineDevCaps->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetDevCaps(hLineApp,
+                                 dwDeviceID,
+                                 TAPI_CURRENT_VERSION,
+                                 0,
+                                 pLineDevCaps);
+        if (lRetVal < 0)
+        {
+            ACDFree((HLOCAL)pLineDevCaps);
+            return NULL;
+        }
+        if (pLineDevCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevCaps->dwNeededSize;
+            pLineDevCaps = ACDReAlloc((HLOCAL)pLineDevCaps,
+                                        dwMaxNeededSize);
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetID()
+//
+///////////////////////////////////////////////////////////////////////////////
+VARSTRING * LineGetID (HLINE  hLine,
+                       DWORD  dwAddressID,
+                       HCALL  hCall,
+                       DWORD  dwSelect,
+                       LPCTSTR lpszDeviceClass)
+{
+    LONG           lRetVal;
+    VARSTRING    * pVarString;
+    static DWORD   dwMaxNeededSize = sizeof(VARSTRING);
+
+    // Allocate an initial block of memory for the VARSTRING structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pVarString = ACDAlloc(dwMaxNeededSize);
+
+    for (;;)
+    {
+        if (pVarString == NULL)
+        {
+            return NULL;
+        }
+        pVarString->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the VARSTRING information
+        //
+        lRetVal = lineGetID(hLine,
+                            dwAddressID,
+                            hCall,
+                            dwSelect,
+                            pVarString,
+                            lpszDeviceClass);
+        if (lRetVal < 0)
+        {
+            ACDFree(pVarString);
+            return NULL;
+        }
+
+        // If the currently allocated VARSTRING memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pVarString->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pVarString;
+        }
+        else
+        {
+            dwMaxNeededSize = pVarString->dwNeededSize;
+            pVarString = ACDReAlloc((HLOCAL)pVarString,
+                                      dwMaxNeededSize);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetCallStatus()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINECALLSTATUS * LineGetCallStatus (HCALL hCall)
+{
+    LONG                lRetVal;
+    LINECALLSTATUS    * pLineCallStatus;
+    static DWORD        dwMaxNeededSize = sizeof(LINECALLSTATUS);
+
+    // Allocate an initial block of memory for the LINECALLSTATUS structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineCallStatus = ACDAlloc(dwMaxNeededSize);
+
+    while (TRUE)
+    {
+        if (pLineCallStatus == NULL)
+        {
+            return NULL;
+        }
+        pLineCallStatus->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINECALLSTATUS information
+        //
+        lRetVal = lineGetCallStatus(hCall,
+                                    pLineCallStatus);
+        if (lRetVal < 0)
+        {
+            ACDFree((HLOCAL)pLineCallStatus);
+            return NULL;
+        }
+
+        // If the currently allocated LINECALLSTATUS memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineCallStatus->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineCallStatus;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineCallStatus->dwNeededSize;
+            pLineCallStatus = ACDReAlloc((HLOCAL)pLineCallStatus,
+                                         dwMaxNeededSize);
+        }
+    }
+}
+
diff --git a/private/tapi/dev/apps/acd/clntapp.cpp b/private/tapi/dev/apps/acd/clntapp.cpp
new file mode 100644
index 000000000..7f1732750
--- /dev/null
+++ b/private/tapi/dev/apps/acd/clntapp.cpp
@@ -0,0 +1,123 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+static LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                                     UINT   uMsg,
+                                     WPARAM wParam,
+                                     LPARAM lParam);
+
+//////////////////////////////////////////////////////////////////////////////
+//  GLOBALS
+//////////////////////////////////////////////////////////////////////////////
+HINSTANCE       ghInstance;
+HWND            ghMainWnd;
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+
+int WINAPI WinMain (HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow)
+{
+    MSG msg;
+
+    ghInstance = hInstance;
+
+    if (!CreateMainWindow(nCmdShow))
+    {
+        return 0;
+    }
+
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    return 1;
+}
+
+
+//*****************************************************************************
+// CreateMainWindow()
+//*****************************************************************************
+
+BOOL CreateMainWindow (int nCmdShow)
+{
+    WNDCLASS wc;
+    static char szClassName[] = "TapiClientWndClass";
+
+    wc.style         = 0;
+    wc.lpfnWndProc   = MainWndProc;
+    wc.cbClsExtra    = 0;
+    wc.cbWndExtra    = 0;
+    wc.hInstance     = ghInstance;
+    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wc.lpszMenuName  = NULL;
+    wc.lpszClassName = szClassName;
+
+
+    if (!RegisterClass(&wc))
+    {
+        return FALSE;
+    }
+
+    ghMainWnd = CreateWindow(szClassName, 
+                             "Tapi Client App",
+                             WS_OVERLAPPEDWINDOW,
+                             0,
+                             0,
+                             GetSystemMetrics(SM_CXSCREEN)/2,
+                             GetSystemMetrics(SM_CYSCREEN)/2,
+                             NULL, 
+                             NULL, 
+                             ghInstance, 
+                             NULL);
+
+    if (ghMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+    ShowWindow(ghMainWnd, nCmdShow);
+    UpdateWindow(ghMainWnd);
+    return TRUE;
+}
+
+
+//*****************************************************************************
+// MainWndProc()
+//*****************************************************************************
+
+LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            break;
+
+        default:
+            return DefWindowProc(hwnd, uMsg, wParam, lParam);
+    }
+    return 0;
+}
+
diff --git a/private/tapi/dev/apps/acd/makefile b/private/tapi/dev/apps/acd/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/acd/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/acd/makefile.sdk b/private/tapi/dev/apps/acd/makefile.sdk
new file mode 100644
index 000000000..0d3c5a56e
--- /dev/null
+++ b/private/tapi/dev/apps/acd/makefile.sdk
@@ -0,0 +1,35 @@
+# Define NODEBUG to build ACDSMPL without debugging information.
+# Define UNICODE to build ACDSMPL with UNICODE characters.
+
+TARGETOS=WINNT
+
+!include <ntwin32.mak>
+
+unicode = -DUNICODE
+
+cflags=$(cflags) -DWIN32_LEAN_AND_MEAN
+
+all: acdsmpl.exe
+
+# Update the resource if necessary
+
+acdsmpl.res: acdsmpl.rc resource.h
+    $(rc) $(rcvars) -r acdsmpl.rc
+
+# Update the object files if necessary
+
+acdsmpl.obj: acdsmpl.c resource.h acdsmpl.h
+    $(cc) $(cdebug) $(cflags) $(cvars) $(unicode) acdsmpl.c
+
+acdtapi.obj: acdtapi.c resource.h acdsmpl.h
+    $(cc) $(cdebug) $(cflags) $(cvars) $(unicode) acdtapi.c
+
+acdutils.obj: acdutils.c resource.h acdsmpl.h
+    $(cc) $(cdebug) $(cflags) $(cvars) $(unicode) acdutils.c
+
+# Update the executable file if necessary, and if so, add the resource back in.
+
+acdsmpl.exe: acdsmpl.obj acdtapi.obj acdutils.obj acdsmpl.res makefile.sdk
+    $(link) $(linkdebug)  $(guiflags) -out:acdsmpl.exe\
+    acdsmpl.obj acdtapi.obj acdutils.obj acdsmpl.res\
+    version.lib tapi32.lib comctl32.lib $(guilibsmt)
diff --git a/private/tapi/dev/apps/acd/resource.h b/private/tapi/dev/apps/acd/resource.h
new file mode 100644
index 000000000..5499d6d80
--- /dev/null
+++ b/private/tapi/dev/apps/acd/resource.h
@@ -0,0 +1,43 @@
+////////////////////////////////////////////////////////////////////////
+//
+//  resource.h
+//
+////////////////////////////////////////////////////////////////////////
+#define IDD_MAINDLG                     101
+#define IDD_ADD                         102
+#define IDD_ADDTOLIST                   103
+#define IDD_ADDAGENT                    104
+#define IDC_TREEWND                     1000
+#define IDC_EDITWND                     1001
+#define IDM_NEWGROUP                    1002
+#define IDM_NEWAGENT                    1003
+#define IDM_GROUPPROPERTIES             1004
+#define IDM_GROUPDELETE                 1005
+#define IDM_AGENTPROPERTIES             1006
+#define IDM_AGENTDELETE                 1007
+#define IDM_SIGNIN                      1008
+#define IDC_NAME                        1009
+#define IDC_NUMBER                      1010
+#define IDC_LIST1                       1011
+#define IDC_LIST2                       1012
+#define IDC_ADD                         1013
+#define IDC_REMOVE                      1014
+#define IDM_GROUPADDTOLIST              1015
+#define IDM_AGENTADDTOLIST              1016
+#define IDC_STATICNOTINLIST             1017
+#define IDC_STATICINLIST                1018
+#define IDR_MAINMENU                    1019
+#define ID_FILE_OPEN                    1020
+#define ID_FILE_EXIT                    1021
+#define ID_FILE_NEW                     1022
+#define ID_EDIT_ADDAGENT                1023
+#define ID_EDIT_ADDGROUP                1024
+#define IDC_LINECOMBO                   1025
+#define IDC_ADDRESSCOMBO                1026
+#define IDM_GROUPAGENTSTATUS            1027
+#define ID_VIEW_GROUP                   1028
+#define ID_VIEW_AGENT                   1029
+#define IDC_DESTADDRESS                 1030
+
+#define IDC_STATIC                      -1
+
diff --git a/private/tapi/dev/apps/acd/sources b/private/tapi/dev/apps/acd/sources
new file mode 100644
index 000000000..9412ca2ac
--- /dev/null
+++ b/private/tapi/dev/apps/acd/sources
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=acdsmpl
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib 
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=acdsmpl.c \
+        acdtapi.c \
+        acdutils.c \
+        acdsmpl.rc
+
+C_DEFINES=-DWINVER=0x0400 -DUNICODE
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/acdclnt/acdclnt.c b/private/tapi/dev/apps/acdclnt/acdclnt.c
new file mode 100644
index 000000000..6a1cf1e3c
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/acdclnt.c
@@ -0,0 +1,1948 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  ACDCLNT.C
+//
+//  ACDClient app
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+#include <tapi.h>
+#include "acdclnt.h"
+#include "resource.h"
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+static LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                                     UINT   uMsg,
+                                     WPARAM wParam,
+                                     LPARAM lParam);
+
+LRESULT CALLBACK AgentStateDlgProc (HWND   hwnd,
+                                    UINT   uMsg,
+                                    WPARAM wParam,
+                                    LPARAM lParam);
+
+VOID CALLBACK LineCallback (DWORD hDevice,
+                            DWORD dwMsg,
+                            DWORD dwCallbackInstance, 
+                            DWORD dwParam1,
+                            DWORD dwParam2, 
+                            DWORD dwParam3);
+BOOL InitTapi();
+
+BOOL CloseTapi();
+
+BOOL RedoWindow();
+
+BOOL SetStatusMessage(LPTSTR lpszMessage);
+
+BOOL SetButton(DWORD dwAddress,
+               BOOL bAnswer,
+               BOOL bEnable);
+
+LRESULT WaitForLineReply();
+
+LONG ThreadRoutine(LPVOID lpv);
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  GLOBALS
+//
+//////////////////////////////////////////////////////////////////////////////
+HINSTANCE       ghInstance;                 // main instance
+HWND            ghMainWnd;                  // main window
+PADDRESSINFO    pAddressInfo = NULL;        // array of info about each address
+HLINEAPP        ghLineApp;                  // hlineapp
+DWORD           gdwAddresses;               // number of addresses on our line
+DWORD           gdwDeviceID;                // our device
+HLINE           ghLine;                     // our line
+
+HANDLE          ghCompletionPort;           // tapi message completionport
+CRITICAL_SECTION csLineReply;
+   
+// using global variables to keep track of line
+// replies, since the main thread will only have at most one outstanding
+// line reply at a time
+BOOL            gbReply;
+LONG            glResult;
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+int WINAPI WinMain (HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow)
+{
+    MSG msg;
+
+    ghInstance = hInstance;
+
+    if(!InitTapi())
+    {
+        MessageBox(NULL,
+                   TEXT("Failed to initialize TAPI"),
+                   TEXT("Cannot start ACDClient"),
+                   MB_OK);
+
+        return 0;
+    }
+
+    if (!CreateMainWindow(nCmdShow))
+    {
+        return 0;
+    }
+
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    return 1;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// CreateMainWindow()
+//
+///////////////////////////////////////////////////////////////////////////////
+BOOL CreateMainWindow (int nCmdShow)
+{
+
+    // main window
+    ghMainWnd = CreateDialog(ghInstance,
+                             MAKEINTRESOURCE(IDD_MAINDLG),
+                             NULL,
+                             MainWndProc);
+
+    if (ghMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+    SetStatusMessage(TEXT("Waiting for call"));
+
+    // create buttons
+    RedoWindow();
+
+    ShowWindow(ghMainWnd, nCmdShow);
+
+    UpdateWindow(ghMainWnd);
+    
+    return TRUE;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL SetStatusMessage(LPTSTR lpszMessage)
+//
+//  Sets text in the static control at the bottom of the main window to
+//  lpszMessage
+//
+/////////////////////////////////////////////////////////////////////////////////
+BOOL SetStatusMessage(LPTSTR lpszMessage)
+{
+    return (SetWindowText(GetDlgItem(ghMainWnd,
+                                     IDC_STATIC1),
+                          lpszMessage));
+
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL ClearCall(HCALL hCall)
+//
+//  Called when a CALLSTATE_IDLE message is recieved.  Looks for the call in the
+//  global pAddressInfo array.  If it finds it, is clears the appropriate members
+//  of the structure
+//
+/////////////////////////////////////////////////////////////////////////////////
+BOOL ClearCall(HCALL hCall)
+{
+    DWORD       dwCount;
+
+    for (dwCount = 0; dwCount < gdwAddresses; dwCount++)
+    {
+        if (pAddressInfo[dwCount].hCall == hCall)
+        {
+            pAddressInfo[dwCount].hCall = NULL;
+            pAddressInfo[dwCount].bCall = FALSE;
+            SetButton(dwCount,
+                      TRUE,
+                      FALSE);
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL SetButton()
+//
+//  Sets the status and text of the answer/drop button for a specific address
+//
+//////////////////////////////////////////////////////////////////////////////////
+BOOL SetButton(DWORD dwAddress,
+               BOOL bAnswer,
+               BOOL bEnable)
+{
+    if (dwAddress >= gdwAddresses)
+        return FALSE;
+    
+    if (bAnswer)
+    {
+        SetWindowText(pAddressInfo[dwAddress].hAnswer,
+                      TEXT("Answer"));
+    }
+    else
+    {
+        SetWindowText(pAddressInfo[dwAddress].hAnswer,
+                      TEXT("Hang Up"));
+    }
+
+    EnableWindow(pAddressInfo[dwAddress].hAnswer,
+                 bEnable);
+
+    return TRUE;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  VOID CALLBACK LineCallback ()
+//
+//  TAPI callback function.  Handles all tapi messages
+//
+///////////////////////////////////////////////////////////////////////////////
+VOID CALLBACK LineCallback (DWORD hDevice,
+                            DWORD dwMsg,
+                            DWORD dwCallbackInstance, 
+                            DWORD dwParam1,
+                            DWORD dwParam2, 
+                            DWORD dwParam3)
+{
+    LPLINECALLINFO          pLCI;
+    LPLINECALLSTATUS        pLCS;
+    TCHAR                   szBuffer[64];
+    
+    switch (dwMsg)
+    {
+        case LINE_REPLY:
+        {
+            EnterCriticalSection(&csLineReply);
+            if (dwParam1 == (DWORD)glResult)
+            {
+                gbReply = TRUE;
+                glResult = dwParam2;
+            }
+            LeaveCriticalSection(&csLineReply);
+        }
+        break;
+
+        case LINE_CALLSTATE:
+        {
+            if (dwParam1 == LINECALLSTATE_OFFERING)
+            {
+                // get the call privilege
+                // note note note the new LINE_APPNEWCALL
+                // give call privilege
+                pLCS = LineGetCallStatus((HCALL)hDevice);
+
+                if (!pLCS)
+                    return;
+
+                if (!(pLCS->dwCallPrivilege & LINECALLPRIVILEGE_OWNER))
+                {
+                    // not our call
+                    GlobalFree(pLCS);
+                    return;
+                }
+
+                GlobalFree(pLCS);
+                
+                // we're getting offered a call
+                // first get the address
+                pLCI = LineGetCallInfo((HCALL)hDevice);
+
+                if (!pLCI)
+                {
+                    // error
+                    return;
+                }
+
+                // set the status message text
+                wsprintf(szBuffer,
+                         TEXT("Incoming call on address %lu"),
+                         pLCI->dwAddressID);
+
+                pAddressInfo[pLCI->dwAddressID].hCall = (HCALL)hDevice;
+                
+                SetStatusMessage(szBuffer);
+
+                // set the button to answer
+                SetButton(pLCI->dwAddressID,
+                          TRUE,
+                          TRUE);
+
+                GlobalFree(pLCI);
+
+                break;
+            }
+
+            if (dwParam1 == LINECALLSTATE_IDLE)
+            {
+                // see if we have this call
+                ClearCall((HCALL)hDevice);
+                // dealloc no matter what
+                lineDeallocateCall((HCALL)hDevice);
+                
+                break;
+            }
+        }
+        
+        break;
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL GetAddressFromhWnd()
+//
+///////////////////////////////////////////////////////////////////////////////
+BOOL GetAddressFromhWnd(HWND hWnd,
+                        LPDWORD pdwAddress,
+                        LPBOOL pbStatus)
+{
+    DWORD       dwAddress;
+
+    // go through the array of addressinfo and see
+    // if the hwnd matches
+    for (dwAddress = 0; dwAddress < gdwAddresses; dwAddress++)
+    {
+        if (pAddressInfo[dwAddress].hStatus == hWnd)
+        {
+            *pdwAddress = dwAddress;
+            *pbStatus = TRUE;
+
+            return TRUE;
+        }
+        if (pAddressInfo[dwAddress].hAnswer == hWnd)
+        {
+            *pdwAddress = dwAddress;
+            *pbStatus = FALSE;
+
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL DoLineAnswerDrop(DWORD dwAddress)
+//
+//  Handles what happens when the answer/drop button is pressed
+//
+/////////////////////////////////////////////////////////////////////////////
+BOOL DoLineAnswerDrop(DWORD dwAddress)
+{
+    // if we have a call, then we want to drop it
+    if (pAddressInfo[dwAddress].bCall)
+    {
+
+        SetStatusMessage(TEXT("Hanging up call ..."));
+
+        EnterCriticalSection(&csLineReply);
+        glResult = lineDrop(pAddressInfo[dwAddress].hCall,
+                           NULL,
+                           0);
+
+        if (glResult < 0)
+        {
+            LeaveCriticalSection(&csLineReply);
+            // error
+        }
+
+        else if (WaitForLineReply())
+        {
+            // error
+        }
+
+        // error or not, deallocate and set button
+        lineDeallocateCall(pAddressInfo[dwAddress].hCall);
+        
+        SetButton(dwAddress,
+                  TRUE,
+                  FALSE);
+        
+        pAddressInfo[dwAddress].hCall = NULL;
+        pAddressInfo[dwAddress].bCall = FALSE;
+        
+        SetStatusMessage(TEXT("Waiting for a call"));
+
+    }
+    else
+    {
+        BOOL bError = FALSE;
+
+        
+        // answer
+        SetStatusMessage(TEXT("Answering call..."));
+
+        EnterCriticalSection(&csLineReply);
+        glResult = lineAnswer(pAddressInfo[dwAddress].hCall,
+                             NULL,
+                             0);
+
+        if (glResult < 0)
+        {
+            LeaveCriticalSection(&csLineReply);
+            bError = TRUE;
+            //error
+        }
+        else if (WaitForLineReply())
+        {
+            bError = TRUE;
+            // error
+        }
+
+        if (bError)
+        {
+            SetStatusMessage(TEXT("Hanging up call ..."));
+            lineDeallocateCall(pAddressInfo[dwAddress].hCall);
+            pAddressInfo[dwAddress].hCall = NULL;
+            SetButton(dwAddress,
+                      TRUE,
+                      FALSE);
+
+            SetStatusMessage(TEXT("Waiting for a call"));
+            return FALSE;
+        }
+
+        SetStatusMessage(TEXT("On a call"));
+        
+        pAddressInfo[dwAddress].bCall = TRUE;
+
+        SetButton(dwAddress,
+                  FALSE,
+                  TRUE);
+    }
+    
+    return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////
+//
+//  LRESULT DoCommand(WPARAM wParam,
+//                    LPARAM lParam)
+//
+//  Handles WM_COMMAND messages for the main window
+//
+//////////////////////////////////////////////////////////////////////
+LRESULT DoCommand(WPARAM wParam,
+                  LPARAM lParam)
+{
+    DWORD       dwAddress;
+    BOOL        bStatus;
+
+    // check to see if a button is being clicked
+    if (HIWORD(wParam) == BN_CLICKED)
+    {
+        // check to see if it is a button we care about
+        if (GetAddressFromhWnd((HWND)lParam,
+                               &dwAddress,
+                               &bStatus))
+        {
+
+            // if it's the status button, display the status
+            // dialog
+            if (bStatus)
+            {
+                DialogBoxParam(ghInstance,
+                               MAKEINTRESOURCE(IDD_AGENTSTATE),
+                               ghMainWnd,
+                               AgentStateDlgProc,
+                               (LPARAM)dwAddress);
+            }
+            // else it's the answer/drop button
+            else
+            {
+                DoLineAnswerDrop(dwAddress);
+            }
+        }
+
+        return 1;
+                  
+    }
+
+
+    return 0;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// MainWndProc()
+//
+////////////////////////////////////////////////////////////////////////////////
+LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+    case WM_INITDIALOG:
+
+        return 1;
+
+    case WM_COMMAND:
+
+        return DoCommand(wParam,
+                         lParam);
+
+        break;
+
+    case WM_CLOSE:
+    case WM_DESTROY:
+        CloseTapi();
+        PostQuitMessage(0);
+        return 1;
+    }
+    
+    return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//
+//  BOOL InitTapi()
+//
+//  Initializes TAPI.  For this sample, we assume that the "agent" (the person
+//  logged on) can only have access to _one_ hLine.  Also, they have access to
+//  every address on that line.  This may not be true for many ACD situations.
+//
+//  As soon as we find a device that the agent has access to, we quit
+//  looking, and use that device
+//
+///////////////////////////////////////////////////////////////////////
+BOOL InitTapi()
+{
+    LONG                    lResult;
+    LINEINITIALIZEEXPARAMS  exparams;
+    LPLINEAGENTCAPS         pLAC;
+    LPLINEDEVCAPS           pLDC;
+    DWORD                   dwDeviceID, dwNumDevs, dwAPIVersion, dwThreadID;
+
+    // initialize completion port to receive TAPI notifications
+    ghCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,
+                                               NULL,
+                                               0,
+                                               0);
+
+    InitializeCriticalSection(&csLineReply);
+
+    // fill in lineinitex parameters
+    exparams.dwTotalSize             = sizeof(LINEINITIALIZEEXPARAMS);
+    exparams.dwOptions               = LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    exparams.Handles.hCompletionPort = ghCompletionPort;
+
+    dwAPIVersion = TAPI_CURRENT_VERSION;
+    
+    lResult = lineInitializeEx(&ghLineApp,
+                               ghInstance,
+                               NULL,
+                               SZAPPNAME,
+                               &dwNumDevs,
+                               &dwAPIVersion,
+                               &exparams);
+
+    if (lResult)
+    {
+        return FALSE;
+    }
+
+    // if no devices, don't continue
+    if (dwNumDevs == 0)
+    {
+        lineShutdown(ghLineApp);
+        return FALSE;
+    }
+
+    // kick off completion port thread
+    CreateThread(NULL,
+                 0,
+                 (LPTHREAD_START_ROUTINE)ThreadRoutine,
+                 NULL,
+                 0,
+                 &dwThreadID);
+
+    
+    // loop through all devices
+    for (dwDeviceID = 0; dwDeviceID < dwNumDevs; dwDeviceID++)
+    {
+        // Get the Agent Caps.  If this succeedes, this is
+        // a device we can use
+        pLAC = LineGetAgentCaps(ghLineApp,
+                                dwDeviceID,
+                                0);
+
+        if (pLAC)
+        {
+            // this is a device we can use
+            gdwDeviceID = dwDeviceID;
+
+            // get the number of addresses
+            pLDC = LineGetDevCaps(ghLineApp,
+                                  dwDeviceID);
+
+            if (pLDC)
+            {
+                gdwAddresses = pLDC->dwNumAddresses;
+                GlobalFree(pLDC);
+            }
+            
+            GlobalFree(pLAC);
+            break;
+        }
+    }
+
+    // open the line in owner mode
+    lResult = lineOpen(ghLineApp,
+                       gdwDeviceID,
+                       &ghLine,
+                       TAPI_CURRENT_VERSION,
+                       0,
+                       0,
+                       LINECALLPRIVILEGE_OWNER,
+                       LINEMEDIAMODE_INTERACTIVEVOICE,
+                       NULL);
+
+    // if line failed, don't continue
+    if (lResult)
+    {
+        lineShutdown(ghLineApp);
+        return FALSE;
+    }
+
+    
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//
+//  ThreadRoutine
+//
+//  Thread dedicated to checking completion port for TAPI events
+//
+//////////////////////////////////////////////////////////////////////
+LONG ThreadRoutine(LPVOID lpv)
+{
+    LPLINEMESSAGE       pMsg;
+    DWORD               dwNumBytesTransfered, dwCompletionKey;
+
+
+    // just wait for tapi notifications
+    while (GetQueuedCompletionStatus(ghCompletionPort,
+                                     &dwNumBytesTransfered,
+                                     &dwCompletionKey,
+                                     (LPOVERLAPPED *) &pMsg,
+                                     INFINITE))
+    {
+        if (pMsg)
+        {
+            // when we get one, call the handling function
+            LineCallback(pMsg->hDevice,
+                         pMsg->dwMessageID,
+                         pMsg->dwCallbackInstance,
+                         pMsg->dwParam1,
+                         pMsg->dwParam2,
+                         pMsg->dwParam3);
+
+            LocalFree (pMsg);
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    ExitThread(0);
+    return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  BOOL CloseTapi()
+//
+//  Close tapi and free resources
+//
+///////////////////////////////////////////////////////////////////////////
+BOOL CloseTapi()
+{
+    GlobalFree(pAddressInfo);
+
+    CloseHandle(ghCompletionPort);
+    
+    lineClose(ghLine);
+    lineShutdown(ghLineApp);
+    
+    return TRUE;
+}
+
+// static information for the status dialog
+static DWORD dwAgentStates[] =
+        {
+            LINEAGENTSTATE_LOGGEDOFF,
+            LINEAGENTSTATE_NOTREADY,
+            LINEAGENTSTATE_READY,
+            LINEAGENTSTATE_BUSYACD,
+            LINEAGENTSTATE_BUSYINCOMING,
+            LINEAGENTSTATE_BUSYOUTBOUND,
+            LINEAGENTSTATE_BUSYOTHER,
+            LINEAGENTSTATE_WORKINGAFTERCALL,
+            LINEAGENTSTATE_UNKNOWN,
+            LINEAGENTSTATE_UNAVAIL,
+            0
+        };
+
+static LPTSTR lpszStates[] =
+        {
+            TEXT("Logged Off"),
+            TEXT("Not Ready"),
+            TEXT("Ready"),
+            TEXT("Busy ACD"),
+            TEXT("Busy Incoming"),
+            TEXT("Busy Outbound"),
+            TEXT("Busy Other"),
+            TEXT("Working after call"),
+            TEXT("Unknown"),
+            TEXT("Unavail"),
+            NULL
+        };
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  BOOL InitAgentDlg()
+//
+//  Handles initialization of the status dialog
+//
+//  Gets the group list and puts groups in multiselect list box
+//      these are the groups that the agent _can_ log into
+//      the groups they are logged into will be selected
+//  Creates comboboxes of states and nextstates, and select
+//      the agent's current state/nextstate
+//  Gets the activity list and puts each item into a combobox
+//      the current activity will be selected
+//
+///////////////////////////////////////////////////////////////////////////
+BOOL InitAgentDlg(HWND hwnd,
+                  DWORD dwAddress,
+                  LPLINEAGENTGROUPLIST * ppLAG)
+{
+    LPLINEAGENTCAPS         pLAC;
+    LPLINEAGENTSTATUS       pLAS;
+    LPLINEAGENTACTIVITYLIST pLAA;
+    LPLINEAGENTGROUPENTRY   pEntry, pLoggedInEntry;
+    LPLINEAGENTACTIVITYENTRY     pActivityEntry;
+    DWORD                   dwEntries, dwCount;
+    LONG                    item;
+
+    // first, get the status
+    // this information will be used to know which items to select
+    // in each of the listbox/comboboxes
+    pLAS = LineGetAgentStatus(ghLine,
+                              dwAddress);
+
+    if (!pLAS)
+    {
+        return FALSE;
+    }
+
+    // get the group list
+    if (!(*ppLAG = LineGetAgentGroupList(ghLine,
+                                         dwAddress)))
+    {
+        return FALSE;
+    }
+
+    // get the first groupentry
+    pEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)*ppLAG)+(*ppLAG)->dwListOffset);
+
+    // loop through the group entries
+    for (dwEntries = 0; dwEntries < (*ppLAG)->dwNumEntries; dwEntries++)
+    {
+        // add group to list box
+        item = SendDlgItemMessage(hwnd,
+                                  IDC_GROUPS,
+                                  LB_ADDSTRING,
+                                  0,
+                                  (LPARAM)(LPTSTR)(((LPBYTE)*ppLAG) + pEntry->dwNameOffset));
+
+        // save the entry
+        SendDlgItemMessage(hwnd,
+                           IDC_GROUPS,
+                           LB_SETITEMDATA,
+                           (WPARAM)item,
+                           (LPARAM)pEntry);
+
+        // now get list of groups currently logged into from the agent status structure
+        // loop through them.  if any of them match the group we are currently adding
+        // select that group
+        pLoggedInEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pLAS) + pLAS->dwGroupListOffset);
+        for (dwCount = 0; dwCount < pLAS->dwNumEntries; dwCount++)
+        {
+            if ((pLoggedInEntry->GroupID.dwGroupID1 == pEntry->GroupID.dwGroupID1) &&
+                (pLoggedInEntry->GroupID.dwGroupID2 == pEntry->GroupID.dwGroupID2) &&
+                (pLoggedInEntry->GroupID.dwGroupID3 == pEntry->GroupID.dwGroupID3) &&
+                (pLoggedInEntry->GroupID.dwGroupID4 == pEntry->GroupID.dwGroupID4))
+            {
+                SendDlgItemMessage(hwnd,
+                                   IDC_GROUPS,
+                                   LB_SETSEL,
+                                   (WPARAM)TRUE,
+                                   (LPARAM)item);
+            }
+            
+            pLoggedInEntry++;
+        }
+
+        pEntry++;
+    }
+
+    // get the agent caps
+    if (pLAC = LineGetAgentCaps(ghLineApp,
+                                gdwDeviceID,
+                                dwAddress))
+    {
+        dwCount = 0;
+        // loop through all possbile agent states.  if the agent state
+        // is selected in the agent caps, add that state to the list box
+        while (dwAgentStates[dwCount])
+        {
+            if (dwAgentStates[dwCount] & pLAC->dwStates)
+            {
+                item = SendDlgItemMessage(hwnd,
+                                   IDC_STATE,
+                                   CB_ADDSTRING,
+                                   0,
+                                   (LPARAM)lpszStates[dwCount]);
+                SendDlgItemMessage(hwnd,
+                                   IDC_STATE,
+                                   CB_SETITEMDATA,
+                                   (WPARAM)item,
+                                   (LPARAM)dwAgentStates[dwCount]);
+
+                // if the state matches the current one from the agent status
+                // select it
+                if (pLAS->dwState == dwAgentStates[dwCount])
+                {
+                    SendDlgItemMessage(hwnd,
+                                       IDC_STATE,
+                                       CB_SETCURSEL,
+                                       (WPARAM)item,
+                                       0);
+                }
+            }
+            
+            dwCount ++;
+        }
+
+        dwCount = 0;
+        // now do the same for the next states
+        while (dwAgentStates[dwCount])
+        {
+            if (dwAgentStates[dwCount] & pLAC->dwNextStates)
+            {
+                item = SendDlgItemMessage(hwnd,
+                                          IDC_NEXTSTATE,
+                                          CB_ADDSTRING,
+                                          0,
+                                          (LPARAM)lpszStates[dwCount]);
+                SendDlgItemMessage(hwnd,
+                                   IDC_NEXTSTATE,
+                                   CB_SETITEMDATA,
+                                   (WPARAM)item,
+                                   dwAgentStates[dwCount]);
+
+                if (pLAS->dwNextState == dwAgentStates[dwCount])
+                {
+                    SendDlgItemMessage(hwnd,
+                                       IDC_NEXTSTATE,
+                                       CB_SETCURSEL,
+                                       (WPARAM)item,
+                                       0);
+                }
+            }
+
+            dwCount++;
+        }
+
+        GlobalFree(pLAC);
+    }
+
+    // get the activity list
+    pLAA = LineGetAgentActivityList(ghLine,
+                                    gdwDeviceID,
+                                    dwAddress);
+    if (pLAA)
+    {
+        dwCount = pLAA->dwNumEntries;
+        pActivityEntry = (LPLINEAGENTACTIVITYENTRY)(((LPBYTE)pLAA) + pLAA->dwListOffset);
+
+        // go through all the possible activities and add them to the list
+        while (dwCount)
+        {
+            item = SendDlgItemMessage(hwnd,
+                                      IDC_ACTIVITY,
+                                      CB_ADDSTRING,
+                                      0,
+                                      (LPARAM)(LPTSTR)(((LPBYTE)pLAA) + pActivityEntry->dwNameOffset));
+
+            SendDlgItemMessage(hwnd,
+                               IDC_ACTIVITY,
+                               CB_SETITEMDATA,
+                               (WPARAM)item,
+                               (LPARAM)pActivityEntry->dwID);
+
+            // if this is the current activity (from agent status)
+            // select it
+            if (pLAS->dwActivityID == pActivityEntry->dwID)
+            {
+                SendDlgItemMessage(hwnd,
+                                   IDC_ACTIVITY,
+                                   CB_SETCURSEL,
+                                   (WPARAM)item,
+                                   0);
+            }
+
+            dwCount--;
+            pActivityEntry++;
+        }
+
+        GlobalFree(pLAA);
+            
+    }
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL SaveAgentStatus(HWND hwnd)
+//
+//  Saves information from the status dialog
+//
+//////////////////////////////////////////////////////////////////////////////////////////////
+BOOL SaveAgentStatus(HWND hwnd,
+                     DWORD dwAddress)
+{
+    LPLINEAGENTGROUPENTRY              pGroupEntry, pNewGroupEntry;
+    LPLINEAGENTGROUPLIST               pNewLAG;
+    DWORD                              dwCount;
+    LPINT                              pItems;
+    DWORD                              item;
+    DWORD                              dwState, dwNextState, dwActivity;
+
+    // get the number of groups selected in the group
+    // list box.  each selected group is a group this
+    // agent will be logged into
+    dwCount = SendDlgItemMessage(hwnd,
+                                 IDC_GROUPS,
+                                 LB_GETSELCOUNT,
+                                 0,
+                                 0);
+
+    // allocate an array to hold the selected item's indexes
+    pItems = (LPINT)GlobalAlloc(GPTR, sizeof(int) * dwCount);
+
+    // get the item's indexes
+    SendDlgItemMessage(hwnd,
+                       IDC_GROUPS,
+                       LB_GETSELITEMS,
+                       dwCount,
+                       (LPARAM)pItems);
+
+    // alloc a LINEAGENTGROUP array for groups
+    pNewLAG = (LPLINEAGENTGROUPLIST)GlobalAlloc(GPTR,
+                                                sizeof(LINEAGENTGROUPLIST) +
+                                                dwCount * sizeof(LINEAGENTGROUPENTRY));
+
+    // fill in sizes
+    pNewLAG->dwTotalSize = sizeof(LINEAGENTGROUPLIST) + dwCount * sizeof(LINEAGENTGROUPENTRY);
+    pNewLAG->dwUsedSize = pNewLAG->dwTotalSize;
+    pNewLAG->dwNeededSize = pNewLAG->dwTotalSize;
+    pNewLAG->dwListSize = sizeof(LINEAGENTGROUPENTRY) * dwCount;
+    pNewLAG->dwListOffset = sizeof(LINEAGENTGROUPLIST);
+
+    // count
+    pNewLAG->dwNumEntries = dwCount;
+
+    // get pointer to first entry in array
+    pNewGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pNewLAG) + pNewLAG->dwListOffset);
+    // loop though all selected item
+    while (dwCount)
+    {
+        // get the item data associated with the item.  this data
+        // is a group entry struct
+        pGroupEntry = (LPLINEAGENTGROUPENTRY)SendDlgItemMessage(hwnd,
+            IDC_GROUPS,
+            LB_GETITEMDATA,
+            (WPARAM)pItems[dwCount-1],
+            0);
+
+        // copy the GroupID to the new array
+        CopyMemory(&pNewGroupEntry->GroupID,
+                   &pGroupEntry->GroupID,
+                   sizeof(pGroupEntry->GroupID));
+
+        // these fields are not used
+        pNewGroupEntry->dwNameSize = 0;
+        pNewGroupEntry->dwNameOffset = 0;
+
+        // next entry
+        pNewGroupEntry++;
+
+        dwCount--;
+    }
+
+    // now that we've created the AGENTGROUPLIST, set it
+    EnterCriticalSection(&csLineReply);
+    glResult = lineSetAgentGroup(ghLine,
+                                dwAddress,
+                                pNewLAG);
+
+    if (glResult < 0)
+    {
+        LeaveCriticalSection(&csLineReply);
+        //error
+    }
+    else if (WaitForLineReply())
+    {
+        //error
+    }
+
+    GlobalFree(pNewLAG);
+
+    // now get the current state
+    item = SendDlgItemMessage(hwnd,
+                              IDC_STATE,
+                              CB_GETCURSEL,
+                              0,
+                              0);
+
+    // get item data.  this is the state flag
+    dwState = SendDlgItemMessage(hwnd,
+                                 IDC_STATE,
+                                 CB_GETITEMDATA,
+                                 (WPARAM)item,
+                                 0);
+
+    // same for next state
+    item = SendDlgItemMessage(hwnd,
+                              IDC_NEXTSTATE,
+                              CB_GETCURSEL,
+                              0,
+                              0);
+
+    dwNextState = SendDlgItemMessage(hwnd,
+                                     IDC_NEXTSTATE,
+                                     CB_GETITEMDATA,
+                                     (WPARAM)item,
+                                     0);
+
+    // set it
+    EnterCriticalSection(&csLineReply);
+    glResult = lineSetAgentState(ghLine,
+                                dwAddress,
+                                dwState,
+                                dwNextState);
+
+    if (glResult < 0)
+    {
+        LeaveCriticalSection(&csLineReply);
+        //error
+    }
+    else if (WaitForLineReply())
+    {
+        //error
+    }
+
+    // get the activity selected
+    item = SendDlgItemMessage(hwnd,
+                              IDC_ACTIVITY,
+                              CB_GETCURSEL,
+                              0,
+                              0);
+
+    // get the item data.  this is the activity ID
+    dwActivity = SendDlgItemMessage(hwnd,
+                                    IDC_ACTIVITY,
+                                    CB_GETITEMDATA,
+                                    (WPARAM)item,
+                                    0);
+
+    // set it
+    EnterCriticalSection(&csLineReply);
+    glResult = lineSetAgentActivity(ghLine,
+                                   dwAddress,
+                                   dwActivity);
+
+
+    
+    if (glResult < 0)
+    {
+        LeaveCriticalSection(&csLineReply);
+        //error
+    }
+    else if (WaitForLineReply())
+    {
+        //error
+    }
+
+    return TRUE;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT WaitForLineReply()
+//
+//  waiting for a line reply.
+//
+//  2 issues:
+//      - using global variables for line reply information.  only recommended
+//        in the most simple situations
+//
+//      - using completion ports to demonstrate the completion port mechanism.
+//        since this app has ui, the wait loop has a message loop and a sleep()!!
+//
+///////////////////////////////////////////////////////////////////////////////
+LRESULT WaitForLineReply()
+{
+    MSG     msg;
+    
+    gbReply = FALSE;
+
+    LeaveCriticalSection(&csLineReply);
+    
+    while (!gbReply)
+    {
+        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+        {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+        
+        Sleep(5);
+    }
+
+    return glResult;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+//
+//  LRESULT CALLBACK AgentStateDlgProc ()
+//
+//  Dialog proc for the agent status dialog
+//
+///////////////////////////////////////////////////////////////////////////////////
+LRESULT CALLBACK AgentStateDlgProc (HWND   hwnd,
+                                    UINT   uMsg,
+                                    WPARAM wParam,
+                                    LPARAM lParam)
+{
+    static DWORD                   dwAddress;
+    static LPLINEAGENTGROUPLIST    pLAG;
+    
+    switch (uMsg)
+    {
+        case WM_INITDIALOG:
+
+            dwAddress = (DWORD)lParam;
+            
+            InitAgentDlg(hwnd,
+                         dwAddress,
+                         &pLAG);
+
+            SetFocus(GetDlgItem(hwnd,
+                                IDC_GROUPS));
+            return 1;
+
+        case WM_COMMAND:
+            if (LOWORD(wParam) == IDOK)
+            {
+                SaveAgentStatus(hwnd,
+                                dwAddress);
+                GlobalFree(pLAG);
+                EndDialog(hwnd,
+                          1);
+                return 1;
+            }
+            
+            if (LOWORD(wParam) == IDCANCEL)
+            {
+                GlobalFree(pLAG);
+                EndDialog(hwnd,
+                         1);
+
+                return 1;
+            }
+    }
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//      **************TAPI WRAPPER FUNCTIONS**************
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetAgentGroupList()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEAGENTGROUPLIST * LineGetAgentGroupList (HLINE    hLine,
+                                            DWORD    dwAddressID)
+{
+    LINEAGENTGROUPLIST *    pLineAgentGroupList;
+    static DWORD            dwMaxNeededSize = sizeof(LINEAGENTGROUPLIST);
+
+    // Allocate an initial block of memory for the LINEAGENTGROUPLIST structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineAgentGroupList = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    while (TRUE)
+    {
+        BOOL        bError = FALSE;
+
+        
+        if (pLineAgentGroupList == NULL)
+        {
+            return NULL;
+        }
+        pLineAgentGroupList->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINEAGENTGROUPLIST information
+        //
+        EnterCriticalSection(&csLineReply);        
+        glResult = lineGetAgentGroupList(hLine,
+                                        dwAddressID,
+                                        pLineAgentGroupList);
+
+        if (glResult < 0)
+        {
+            LeaveCriticalSection(&csLineReply);
+            bError = TRUE;
+            //error
+        }
+        else if (WaitForLineReply())
+        {
+            bError = TRUE;
+            //error
+        }
+
+
+        if (bError)
+        {
+            GlobalFree((HLOCAL)pLineAgentGroupList);
+            return NULL;
+        }
+        
+        // If the currently allocated LINEAGENTGROUPLIST memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineAgentGroupList->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineAgentGroupList;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineAgentGroupList->dwNeededSize;
+            pLineAgentGroupList = GlobalReAlloc((HLOCAL)pLineAgentGroupList,
+                                           dwMaxNeededSize,
+                                           GMEM_MOVEABLE);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetAgentStatus()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEAGENTSTATUS * LineGetAgentStatus (HLINE    hLine,
+                                      DWORD    dwAddressID)
+{
+    LINEAGENTSTATUS *   pLineAgentStatus;
+    static DWORD        dwMaxNeededSize = sizeof(LINEAGENTSTATUS);
+
+    // Allocate an initial block of memory for the LINEAGENTSTATUS structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineAgentStatus = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    while (TRUE)
+    {
+        BOOL        bError = FALSE;
+        if (pLineAgentStatus == NULL)
+        {
+            return NULL;
+        }
+        pLineAgentStatus->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINEAGENTSTATUS information
+        //
+        EnterCriticalSection(&csLineReply);        
+        glResult = lineGetAgentStatus(hLine,
+                                     dwAddressID,
+                                     pLineAgentStatus);
+
+        if (glResult < 0)
+        {
+            LeaveCriticalSection(&csLineReply);
+            bError = TRUE;
+            //error
+        }
+        else if (WaitForLineReply())
+        {
+            bError = TRUE;
+            //error
+        }
+
+        if (bError)
+        {
+            GlobalFree((HLOCAL)pLineAgentStatus);
+            return NULL;
+        }
+
+        // If the currently allocated LINEAGENTSTATUS memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineAgentStatus->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineAgentStatus;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineAgentStatus->dwNeededSize;
+            pLineAgentStatus = GlobalReAlloc((HLOCAL)pLineAgentStatus,
+                                           dwMaxNeededSize,
+                                           GMEM_MOVEABLE);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetAgentCaps()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEAGENTCAPS * LineGetAgentCaps (HLINEAPP hLineApp,
+                                  DWORD    dwDeviceID,
+                                  DWORD    dwAddressID)
+{
+    LINEAGENTCAPS *   pLineAgentCaps;
+    static DWORD      dwMaxNeededSize = sizeof(LINEAGENTCAPS);
+
+    // Allocate an initial block of memory for the LINEAGENTCAPS structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineAgentCaps = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    while (TRUE)
+    {
+        BOOL            bError = FALSE;
+        
+        if (pLineAgentCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineAgentCaps->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINEAGENTCAPS information
+        //
+        EnterCriticalSection(&csLineReply);        
+        glResult = lineGetAgentCaps(hLineApp,
+                                   dwDeviceID,
+                                   dwAddressID,
+                                   TAPI_CURRENT_VERSION,
+                                   pLineAgentCaps);
+
+        if (glResult < 0)
+        {
+            bError = TRUE;
+            LeaveCriticalSection(&csLineReply);
+            //error
+        }
+        else if (WaitForLineReply())
+        {
+            bError = TRUE;
+            //error
+        }
+
+
+        if (bError)
+        {
+            GlobalFree((HLOCAL)pLineAgentCaps);
+            return NULL;
+        }
+
+        // If the currently allocated LINEAGENTCAPS memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineAgentCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineAgentCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineAgentCaps->dwNeededSize;
+            pLineAgentCaps = GlobalReAlloc((HLOCAL)pLineAgentCaps,
+                                           dwMaxNeededSize,
+                                           GMEM_MOVEABLE);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetAgentActivityList()
+//
+///////////////////////////////////////////////////////////////////////////////
+LPLINEAGENTACTIVITYLIST LineGetAgentActivityList (HLINE    hLine,
+                                                  DWORD    dwDeviceID,
+                                                  DWORD    dwAddressID)
+{
+    LINEAGENTACTIVITYLIST * pLineAgentActivityList;
+    static DWORD            dwMaxNeededSize = sizeof(LINEAGENTACTIVITYLIST);
+
+    // Allocate an initial block of memory for the LINEAGENTACTIVITYLIST structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineAgentActivityList = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    for (;;)
+    {
+        BOOL        bError = FALSE;
+        if (pLineAgentActivityList == NULL)
+        {
+            return NULL;
+        }
+        pLineAgentActivityList->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINEAGENTACTIVITYLIST information
+        //
+        EnterCriticalSection(&csLineReply);        
+        glResult = lineGetAgentActivityList(hLine,
+                                           dwAddressID,
+                                           pLineAgentActivityList);
+
+        if (glResult < 0)
+        {
+            LeaveCriticalSection(&csLineReply);
+            bError = TRUE;
+            //error
+        }
+        else if (WaitForLineReply())
+        {
+            bError = TRUE;
+            //error
+        }
+
+
+        if (bError)
+        {
+            GlobalFree((HLOCAL)pLineAgentActivityList);
+            return NULL;
+        }
+
+
+        // If the currently allocated LINEAGENTACTIVITYLIST memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineAgentActivityList->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineAgentActivityList;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineAgentActivityList->dwNeededSize;
+            pLineAgentActivityList = GlobalReAlloc((HLOCAL)pLineAgentActivityList,
+                                            dwMaxNeededSize,
+                                            GMEM_MOVEABLE);
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetAddressCaps()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEADDRESSCAPS * LineGetAddressCaps (HLINEAPP hLineApp,
+                                      DWORD    dwDeviceID,
+                                      DWORD    dwAddressID)
+{
+    LONG              lRetVal;
+    LINEADDRESSCAPS * pLineAddressCaps;
+    static DWORD      dwMaxNeededSize = sizeof(LINEADDRESSCAPS);
+
+    // Allocate an initial block of memory for the LINEADDRESSCAPS structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineAddressCaps = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    for (;;)
+    {
+        if (pLineAddressCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineAddressCaps->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINEADDRESSCAPS information
+        //
+        lRetVal = lineGetAddressCaps(hLineApp,
+                                     dwDeviceID,
+                                     dwAddressID,
+                                     TAPI_CURRENT_VERSION,
+                                     0,
+                                     pLineAddressCaps);
+        if (lRetVal < 0)
+        {
+            GlobalFree((HLOCAL)pLineAddressCaps);
+            return NULL;
+        }
+
+        // If the currently allocated LINEADDRESSCAPS memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineAddressCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineAddressCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineAddressCaps->dwNeededSize;
+            pLineAddressCaps = GlobalReAlloc((HLOCAL)pLineAddressCaps,
+                                             dwMaxNeededSize,
+                                             GMEM_MOVEABLE);
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetCallInfo()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINECALLINFO * LineGetCallInfo (HCALL hCall)
+{
+    LONG           lRetVal;
+    LINECALLINFO * pLineCallInfo;
+    static DWORD   dwMaxNeededSize = sizeof(LINECALLINFO);
+
+    // Allocate an initial block of memory for the LINECALLINFO structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineCallInfo = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    for (;;)
+    {
+        if (pLineCallInfo == NULL)
+        {
+            return NULL;
+        }
+        pLineCallInfo->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINECALLINFO information
+        //
+        lRetVal = lineGetCallInfo(hCall,
+                                  pLineCallInfo);
+        if (lRetVal < 0)
+        {
+            GlobalFree((HLOCAL)pLineCallInfo);
+            return NULL;
+        }
+
+        // If the currently allocated LINECALLINFO memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineCallInfo->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineCallInfo;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineCallInfo->dwNeededSize;
+            pLineCallInfo = GlobalReAlloc((HLOCAL)pLineCallInfo,
+                                         dwMaxNeededSize,
+                                         GMEM_MOVEABLE);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetDevCaps()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID)
+{
+    LONG           lRetVal;
+    LINEDEVCAPS  * pLineDevCaps;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVCAPS);
+
+    pLineDevCaps = GlobalAlloc(GPTR, dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineDevCaps->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetDevCaps(hLineApp,
+                                 dwDeviceID,
+                                 TAPI_CURRENT_VERSION,
+                                 0,
+                                 pLineDevCaps);
+        if (lRetVal < 0)
+        {
+            GlobalFree((HLOCAL)pLineDevCaps);
+            return NULL;
+        }
+        if (pLineDevCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevCaps->dwNeededSize;
+            pLineDevCaps = GlobalReAlloc((HLOCAL)pLineDevCaps,
+                                        dwMaxNeededSize,
+                                        GMEM_MOVEABLE);
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetID()
+//
+///////////////////////////////////////////////////////////////////////////////
+VARSTRING * LineGetID (HLINE  hLine,
+                       DWORD  dwAddressID,
+                       HCALL  hCall,
+                       DWORD  dwSelect,
+                       LPCTSTR lpszDeviceClass)
+{
+    LONG           lRetVal;
+    VARSTRING    * pVarString;
+    static DWORD   dwMaxNeededSize = sizeof(VARSTRING);
+
+    // Allocate an initial block of memory for the VARSTRING structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pVarString = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    for (;;)
+    {
+        if (pVarString == NULL)
+        {
+            return NULL;
+        }
+        pVarString->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the VARSTRING information
+        //
+        lRetVal = lineGetID(hLine,
+                            dwAddressID,
+                            hCall,
+                            dwSelect,
+                            pVarString,
+                            lpszDeviceClass);
+        if (lRetVal < 0)
+        {
+            GlobalFree((HLOCAL)pVarString);
+            return NULL;
+        }
+
+        // If the currently allocated VARSTRING memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pVarString->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pVarString;
+        }
+        else
+        {
+            dwMaxNeededSize = pVarString->dwNeededSize;
+            pVarString = GlobalReAlloc((HLOCAL)pVarString,
+                                      dwMaxNeededSize,
+                                      GMEM_MOVEABLE);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LineGetCallStatus()
+//
+///////////////////////////////////////////////////////////////////////////////
+LINECALLSTATUS * LineGetCallStatus (HCALL hCall)
+{
+    LONG                lRetVal;
+    LINECALLSTATUS    * pLineCallStatus;
+    static DWORD        dwMaxNeededSize = sizeof(LINECALLSTATUS);
+
+    // Allocate an initial block of memory for the LINECALLSTATUS structure,
+    // which may or may not be big enough to hold all of the information.
+    //
+    pLineCallStatus = GlobalAlloc(GPTR, dwMaxNeededSize);
+
+    while (TRUE)
+    {
+        if (pLineCallStatus == NULL)
+        {
+            return NULL;
+        }
+        pLineCallStatus->dwTotalSize = dwMaxNeededSize;
+
+        // Try (or retry) to get the LINECALLSTATUS information
+        //
+        lRetVal = lineGetCallStatus(hCall,
+                                    pLineCallStatus);
+        if (lRetVal < 0)
+        {
+            GlobalFree((HLOCAL)pLineCallStatus);
+            return NULL;
+        }
+
+        // If the currently allocated LINECALLSTATUS memory block was big
+        // enough, we're all done, else we need to realloc the memory block
+        // and try again.
+        //
+        if (pLineCallStatus->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineCallStatus;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineCallStatus->dwNeededSize;
+            pLineCallStatus = GlobalReAlloc((HLOCAL)pLineCallStatus,
+                                            dwMaxNeededSize,
+                                            GMEM_MOVEABLE);
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////
+//
+//
+// constants for creating buttons in the main window
+//
+#define YSTART              8
+#define XSTART              8
+#define STATICX             57
+#define BUTTONX             50
+#define BUTTONGAP           20
+#define BUTTONY             14
+#define LINEGAP             8
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  BOOL RedoWindow()
+//
+//  Creates the buttons and static controls in the main window
+//  For each address on the line, create a static control with the name off
+//  the address, a button to get/set status, and a button to answer/drop
+//
+//  Right now, this should only be done when the app is starting.  It does
+//  not check to see if pAddressInfo has already been allocated
+//
+/////////////////////////////////////////////////////////////////////////////
+BOOL RedoWindow()
+{
+    DWORD                   dwAddress;
+    LPLINEADDRESSCAPS       pLAC;
+    TCHAR                   szBuffer[64];
+    LONG                    lBaseUnits, lxbase, lybase;
+    HFONT                   hFont;
+    HWND                    hWnd;
+
+    int         x,y,w,h,xstart,ystart,buttonx,buttony,staticx,buttongap,linegap;
+
+
+    // alloc for address info
+    pAddressInfo = (PADDRESSINFO)GlobalAlloc(GPTR, sizeof(ADDRESSINFO) * gdwAddresses);
+
+    if (!pAddressInfo)
+    {
+        return FALSE;
+    }
+
+    // get conversions
+    lBaseUnits = GetDialogBaseUnits();
+    lxbase = (LONG)LOWORD(lBaseUnits);
+    lybase = (LONG)HIWORD(lBaseUnits);
+
+    // convert dialog units to pixels
+    xstart = (XSTART * lxbase) / 4;
+    ystart = (YSTART * lybase) / 8;
+    buttonx = (BUTTONX * lxbase) / 4;
+    buttony = (BUTTONY * lybase) / 8;
+    staticx = (STATICX * lxbase) / 4;
+    buttongap = (BUTTONGAP * lxbase) / 4;
+    linegap = (LINEGAP * lybase) / 8;
+
+    // init
+    x = xstart;
+    y = ystart;
+    w = buttonx;
+    h = buttony;
+
+    // get the font used by the static control 
+    hFont = (HFONT)SendDlgItemMessage(ghMainWnd,
+                                      IDC_STATIC1,
+                                      WM_GETFONT,
+                                      0,
+                                      0);
+
+    // loop through all addressed
+    for (dwAddress = 0; dwAddress < gdwAddresses; dwAddress++)
+    {
+        // get the name of the address
+        pLAC = LineGetAddressCaps(ghLineApp,
+                                  gdwDeviceID,
+                                  dwAddress);
+
+        if (!pLAC || !pLAC->dwAddressSize)
+        {
+            wsprintf(szBuffer,
+                     TEXT("Address %lu"),
+                     dwAddress);
+        }
+        else
+        {
+            lstrcpy(szBuffer,
+                    (LPTSTR)(((LPBYTE)pLAC)+pLAC->dwAddressOffset));
+        }
+
+        if (pLAC)
+        {
+            GlobalFree(pLAC);
+        }
+
+        w = staticx;
+        x = xstart;
+        // create the static control
+        hWnd = CreateWindow(TEXT("STATIC"),
+                     szBuffer,
+                     WS_CHILD | SS_LEFT | WS_VISIBLE,
+                     x,y+(buttony/3),w,h,
+                     ghMainWnd,
+                     NULL,
+                     ghInstance,
+                     NULL);
+
+        // set the font
+        SendMessage(hWnd,
+                    WM_SETFONT,
+                    (WPARAM)hFont,
+                    0);
+
+        x += staticx;
+        w = buttonx;
+        // create the status button
+        pAddressInfo[dwAddress].hStatus = CreateWindow(TEXT("BUTTON"),
+                     TEXT("Set Status..."),
+                     WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE,
+                     x,y,w,h,
+                     ghMainWnd,
+                     NULL,
+                     ghInstance,
+                     NULL);
+
+        // set the font
+        SendMessage(pAddressInfo[dwAddress].hStatus,
+                    WM_SETFONT,
+                    (WPARAM)hFont,
+                    0);
+
+        x += buttonx + buttongap;
+
+        // create the answer/drop button
+        pAddressInfo[dwAddress].hAnswer = CreateWindow(TEXT("BUTTON"),
+                     TEXT("Answer"),
+                     WS_CHILD | WS_DISABLED | BS_PUSHBUTTON  | WS_VISIBLE,
+                     x,y,w,h,
+                     ghMainWnd,
+                     NULL,
+                     ghInstance,
+                     NULL);
+
+        // set the font
+        SendMessage(pAddressInfo[dwAddress].hAnswer,
+                    WM_SETFONT,
+                    (WPARAM)hFont,
+                    0);
+
+        y += buttony + linegap;
+    }
+
+
+    // adjust position of message static control
+    SetWindowPos(GetDlgItem(ghMainWnd,
+                            IDC_STATIC1),
+                  NULL,
+                  xstart,y,0,0,
+                  SWP_NOZORDER | SWP_NOSIZE);
+
+    // adjust the size of th main window
+    SetWindowPos(ghMainWnd,
+                 NULL,
+                 0,0,xstart+staticx+buttonx+buttonx+buttongap+50,y+50,
+                 SWP_NOZORDER | SWP_NOMOVE);
+
+    return TRUE;
+               
+}
diff --git a/private/tapi/dev/apps/acdclnt/acdclnt.h b/private/tapi/dev/apps/acdclnt/acdclnt.h
new file mode 100644
index 000000000..122fc0cc4
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/acdclnt.h
@@ -0,0 +1,51 @@
+/////////////////////////////////////////////////////////////////////////
+//
+//  ACDCLNT.H
+//
+/////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+#include <tapi.h>
+
+#define SZAPPNAME       TEXT("ACDClient")
+
+typedef struct _tagADDRESSINFO
+{
+    HWND        hStatus;
+    HWND        hAnswer;
+    HCALL       hCall;
+    BOOL        bCall;
+    
+} ADDRESSINFO, * PADDRESSINFO;
+
+
+LINEAGENTGROUPLIST * LineGetAgentGroupList (HLINE    hLine,
+                                            DWORD    dwAddressID);
+
+LINEAGENTSTATUS * LineGetAgentStatus (HLINE    hLine,
+                                      DWORD    dwAddressID);
+
+LINEAGENTCAPS * LineGetAgentCaps (HLINEAPP hLineApp,
+                                  DWORD    dwDeviceID,
+                                  DWORD    dwAddressID);
+
+LPLINEAGENTACTIVITYLIST LineGetAgentActivityList (HLINE    hLine,
+                                                  DWORD    dwDeviceID,
+                                                  DWORD    dwAddressID);
+
+LINEADDRESSCAPS * LineGetAddressCaps (HLINEAPP hLineApp,
+                                      DWORD    dwDeviceID,
+                                      DWORD    dwAddressID);
+
+LINECALLINFO * LineGetCallInfo (HCALL hCall);
+
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID);
+
+VARSTRING * LineGetID (HLINE  hLine,
+                       DWORD  dwAddressID,
+                       HCALL  hCall,
+                       DWORD  dwSelect,
+                       LPCTSTR lpszDeviceClass);
+
+LINECALLSTATUS * LineGetCallStatus (HCALL hCall);
+
diff --git a/private/tapi/dev/apps/acdclnt/acdclnt.rc b/private/tapi/dev/apps/acdclnt/acdclnt.rc
new file mode 100644
index 000000000..fd4243e41
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/acdclnt.rc
@@ -0,0 +1,95 @@
+#include <windows.h>
+#include "resource.h"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_MAINDLG DIALOGEX 0, 0, 204, 46
+STYLE DS_3DLOOK | WS_MINIMIZEBOX  | WS_POPUP | WS_CAPTION | 
+    WS_SYSMENU | WS_THICKFRAME  | WS_SYSMENU
+EXSTYLE WS_EX_CLIENTEDGE
+CAPTION "ACD Client"
+FONT 8, "MS Sans Serif"
+BEGIN
+//    LTEXT           "Address 1",IDC_STATIC1,7,9,55,8
+//    PUSHBUTTON      "Answer",IDC_ANSWER1,147,7,50,14,WS_DISABLED
+//    PUSHBUTTON      "Set Status...",IDC_STATUS1,64,7,50,14
+    LTEXT           "Incoming call on Address 1",IDC_STATIC1,7,31,190,8
+END
+
+IDD_AGENTSTATE DIALOG DISCARDABLE  0, 0, 278, 161
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Agent State"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,49,140,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,150,140,50,14
+    LTEXT           "State",IDC_STATIC,153,7,18,8
+    COMBOBOX        IDC_STATE,152,17,119,61,CBS_DROPDOWN | CBS_SORT | 
+                    WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Groups",IDC_STATIC,7,7,24,8
+    LISTBOX         IDC_GROUPS,7,17,119,116,LBS_SORT | LBS_MULTIPLESEL | 
+                    LBS_USETABSTOPS | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    COMBOBOX        IDC_ACTIVITY,152,95,119,53,CBS_DROPDOWN | CBS_SORT | 
+                    WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Activity",IDC_STATIC,153,83,24,8
+    COMBOBOX        IDC_NEXTSTATE,152,56,119,59,CBS_DROPDOWN | CBS_SORT | 
+                    WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Next State",IDC_STATIC,153,45,34,8
+END
+
+
+////////////////////////////////////////////////////////////////////
+//
+//  Version Info
+//
+
+//#if WINNT
+//#include <ntverp.h>
+//#else
+//#include <version.h>
+//#endif
+#include <winver.h>
+
+
+#ifdef RC_INVOKED
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION     4,00,01,001
+PRODUCTVERSION  4,00,01,001
+FILEFLAGSMASK   VS_FFI_FILEFLAGSMASK
+FILEFLAGS       (VS_FF_PRERELEASE|VS_FF_DEBUG)
+FILEOS          VOS_NT_WINDOWS32
+FILETYPE        VFT_APP
+FILESUBTYPE     VFT2_UNKNOWN
+
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904B0"   /* LANG_ENGLISH/SUBLANG_ENGLISH_US, Unicode CP */
+        BEGIN
+            VALUE "CompanyName",     "Microsoft Corporation\0"
+            VALUE "FileDescription", "TAPI ACD Client Sample Application\0"
+            VALUE "FileVersion",     "1.0\0"
+            VALUE "InternalName",    "ACDCLNT\0"
+            VALUE "LegalCopyright",  "Copyright (C) Microsoft Corp. 1996\0"
+            VALUE "LegalTrademarks", "Microsoft(R) is a registered trademark of Microsoft Corporation. Windows(TM) is a trademark of Microsoft Corporation\0"
+            VALUE "ProductName",     "ACDClient\0"
+            VALUE "ProductVersion",  "1.0\0"
+
+        END
+
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x0409, 0x04B0
+    END
+END
+
+#endif
+
+
diff --git a/private/tapi/dev/apps/acdclnt/makefile b/private/tapi/dev/apps/acdclnt/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/acdclnt/makefile.sdk b/private/tapi/dev/apps/acdclnt/makefile.sdk
new file mode 100644
index 000000000..f58046d2c
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/makefile.sdk
@@ -0,0 +1,33 @@
+# Define NODEBUG to build ACDSMPL without debugging information.
+# Define UNICODE to build ACDSMPL with UNICODE characters.
+
+TARGETOS=WINNT
+
+!include <ntwin32.mak>
+
+!ifdef UNICODE
+unicode = -DUNICODE
+!else
+unicode =
+!endif
+
+cflags=$(cflags) -DWIN32_LEAN_AND_MEAN
+
+all: acdclnt.exe
+
+# Update the resource if necessary
+
+acdclnt.res: acdclnt.rc resource.h
+    $(rc) $(rcvars) -r acdclnt.rc
+
+# Update the object files if necessary
+
+acdclnt.obj: acdclnt.c resource.h acdclnt.h
+    $(cc) $(cdebug) $(cflags) $(cvars) $(unicode) acdclnt.c
+
+# Update the executable file if necessary, and if so, add the resource back in.
+
+acdclnt.exe: acdclnt.obj acdclnt.res makefile.sdk
+    $(link) $(linkdebug)  $(guiflags) -out:acdclnt.exe\
+    acdclnt.obj acdclnt.res\
+    version.lib tapi32.lib comctl32.lib $(guilibsmt)
diff --git a/private/tapi/dev/apps/acdclnt/resource.h b/private/tapi/dev/apps/acdclnt/resource.h
new file mode 100644
index 000000000..cf8f61dcd
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/resource.h
@@ -0,0 +1,22 @@
+//
+#define IDD_MAINDLG                     101
+#define IDD_AGENTSTATE                  102
+#define IDC_ANSWER1                     1012
+#define IDC_STATUS1                     1016
+#define IDC_STATE                       1018
+#define IDC_GROUPS                      1019
+#define IDC_ACTIVITY                    1020
+#define IDC_NEXTSTATE                   1021
+#define IDC_STATIC1                     1022
+#define IDC_STATIC                      -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        103
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1022
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/apps/acdclnt/sources b/private/tapi/dev/apps/acdclnt/sources
new file mode 100644
index 000000000..1c1963210
--- /dev/null
+++ b/private/tapi/dev/apps/acdclnt/sources
@@ -0,0 +1,58 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=acdclnt
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib 
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=acdclnt.c \
+        acdclnt.rc
+
+#C_DEFINES=-DWINVER=0x0400 -DUNICODE
+C_DEFINES=-DWINVER=0x0400
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/dialer/depend.mk b/private/tapi/dev/apps/dialer/depend.mk
new file mode 100644
index 000000000..506be7029
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/depend.mk
@@ -0,0 +1,4 @@
+.\dialer.obj: ..\dialer.c ..\dialer.h ..\dialhelp.h ..\resource.h
+
+.\dialer.res: ..\dialer.rc ..\version.rc ..\resource.h
+
diff --git a/private/tapi/dev/apps/dialer/dialer.c b/private/tapi/dev/apps/dialer/dialer.c
new file mode 100644
index 000000000..a517a9a89
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialer.c
@@ -0,0 +1,4345 @@
+/*++ 
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    dialer.c
+
+--*/
+
+
+#include "dialer.h"
+#include "string.h"
+#include "stdlib.h"
+#include "shellapi.h"
+
+
+#define	ISDIGIT(x)			(((x) - '0') >= 0) && (((x) - '0') <= 9)
+enum NumberTypes 
+{
+	LOCAL_NUMBER = 7,
+	EXTENDED_LOCAL_NUMBER,
+	LONG_DISTANCE_NUMBER = 10,
+	EXTENDED_LONG_DISTANCE_NUMBER
+};
+
+
+// structs
+typedef struct tagLINEINFO
+{
+    DWORD nAddr;                    // Number of avail. addresses on the line
+    BOOL  fVoiceLine;               // Is this a voice line?
+    DWORD dwAPIVersion;             // API version which the line supports
+    HLINE hLine;                    // line handle returned by lineOpen
+    DWORD dwPermanentLineID;        // Permanent line ID retreived from devcaps
+    char  szLineName[MAXBUFSIZE];   // the line's name
+
+} LINEINFO, *LPLINEINFO;
+
+
+// Global variables
+
+// window/instance variables
+HWND        ghWndMain;
+HWND        ghWndDialing = NULL;
+HINSTANCE   ghInst = 0;
+
+// file name vars.
+static TCHAR gszAppName[64];
+static TCHAR gszINIfilename [] = "DIALER.INI";
+static TCHAR gszHELPfilename [] = "DIALER.HLP";
+static TCHAR gszDialerClassName[] = "DialerClass";
+TCHAR const gszNULL[] = "";
+
+// window item variables
+HFONT       ghFontBtn;               // handle to 1, 2, ..., 0's font
+HFONT       ghFontBtnText;           // handle to number button's text font
+HFONT       ghFontBtnStar;           // handle to * and # button's font
+HLINEAPP    ghLineApp = NULL;        // Dialer's usage handle (regist. w/TAPI)
+HCALL       ghCall = NULL;           // call handle for Dialer's call
+
+LPSTR       gszCurrentNumber = NULL; // number of destination of current call
+LPSTR       gszCurrentName = NULL;	 // name of destination of current call
+
+BOOL        gfRegistered;            // was lineRegisterRequestRecipient()
+                                     // successful?
+
+//BOOL        gfDropping = FALSE;      // is Dialer currently dropping a call?
+BOOL        gfNeedToReinit = FALSE;  // does Dialer need to re-initialize?
+
+BOOL        gfCallRequest = FALSE;   // Does a Simple TAPI app want a call?
+BOOL        gfCurrentLineAvail = TRUE; // Simple TAPI requests are only carried
+                                       // out if the current chosen line is avail.
+BOOL		gfMakeCallReplyPending = FALSE;
+
+LONG        gMakeCallRequestID = 0;      // request ID returned by async TAPI fns.
+LONG        gDropCallRequestID = 0;      // request ID returned by async TAPI fns.
+
+DWORD       gnAvailDevices = 0;      // # of line devices avail. to Dialer
+LINEINFO    gCurrentLineInfo;
+DWORD       * gnAddr;
+
+// global to remember where the cursor is in the edit control
+DWORD       gdwStartSel;
+DWORD       gdwEndSel;
+
+DWORD       * gdwPLID;               // current line's permanent line ID
+DWORD       giCurrentLine = (DWORD)-1;       // the line selected by the user
+DWORD       giCurrentAddress = 0;    // the address selected by the user
+
+// + 1 so we can work 1-based rather than 0-based (for convenience only)
+// global varibles to hold the names and address of the 
+TCHAR       gszSDNumber[ NSPEEDDIALS + 1 ][ TAPIMAXDESTADDRESSSIZE ];
+
+
+// Function declarations
+
+// button related functions
+VOID ButtonFontSetup(VOID);
+VOID DrawButton(HDC hdc, RECT rcBtn, BOOL fHighlighted);
+VOID DrawButtonText(HDC hdc, RECT rcBtn, BOOL fHighlighted, UINT IDD_Btn);
+VOID DisableDialButtons(BOOL fDisable);
+VOID FitTextToButton( HWND, INT, LPSTR );
+
+// Callback functions
+BOOL CALLBACK MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK DialingProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK AboutProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK ConnectUsingProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK LineInUseProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK SpeedDial1Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK SpeedDial2Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+VOID CALLBACK tapiCallback ( 
+							DWORD hDevice, DWORD dwMsg,
+							DWORD dwCallbackInstance, 
+							DWORD dwParam1, DWORD dwParam2, 
+							DWORD dwParam3
+						    );
+
+// tapi related functions
+VOID ManageAssistedTelephony(VOID);
+VOID InitiateCall(LPCSTR szNumber, LPCSTR szName);
+
+VOID DialerLineClose(VOID); 
+VOID DialerCleanup(VOID);
+VOID CloseTAPI(VOID);
+
+DWORD GetLineInfo(DWORD iLine, LPLINEINFO lpLineInfo);
+VOID GetLineInfoFailed (
+						DWORD iLine, LPLINEDEVCAPS lpDevCaps, 
+						LPLINEINFO lpLineInfo
+					    );
+LPSTR GetAddressName(DWORD iLine, DWORD iAddress);
+BOOL MakeCanonicalNumber( LPCSTR szName, LPSTR szCanNumber );
+
+// misc. helper functions
+VOID ReadINI(VOID);
+int errString(HWND hWnd, UINT errCode, UINT uFlags);
+VOID AddToRedialList(LPCSTR szNumber);
+BOOL InitializeLineBox(HWND hwndLineBox);
+BOOL InitializeAddressBox(HWND hwndLineBox, HWND hwndAddressBox);
+BOOL Is911 ( LPLINETRANSLATEOUTPUT lpTransOut );
+VOID AmpersandCompensate( LPCSTR lpszSrc, LPSTR lpszDst );
+VOID AmpersandDeCompensate( LPCSTR lpszSrc, LPSTR lpszDst );
+
+// Dialer memory management functions
+LPVOID DialerAlloc(size_t cbToAlloc);
+LPVOID DialerFree(LPVOID lpMem);
+
+
+// Function definitions
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+DWORD InitializeTAPI (VOID)
+{
+	INT cvLine;
+
+	DWORD iLine;
+	DWORD dwPreferredPLID, dwID = (DWORD) -1;
+
+	MSG msg;
+
+	LPLINEINFO lpLineInfo = NULL;	// LINEINFO for each available line
+
+    DWORD errCode;
+    DWORD tc = GetTickCount();
+    DWORD dwReturn = ERR_NONE;
+
+	char szBuffer[MAXBUFSIZE];		// to read in dwPreferredPLID as a string first
+
+
+
+	errCode = lineInitialize (
+								&ghLineApp,
+								ghInst,
+								(LINECALLBACK) tapiCallback,
+								gszAppName,
+								&gnAvailDevices
+							 );
+	if ( errCode == LINEERR_REINIT )
+	{
+		// take away dialer functionality
+		EnableWindow( ghWndMain, FALSE );
+		DisableDialButtons(TRUE);
+
+		// keep trying until the user cancels
+		// or we stop getting LINEERR_REINIT
+		while ( ( errCode = lineInitialize ( 
+											&ghLineApp,              
+											ghInst,
+											(LINECALLBACK)tapiCallback,
+											gszAppName,
+											&gnAvailDevices
+										    ) ) 
+				 == LINEERR_REINIT )
+		{
+			// flush queue & yield
+			while ( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) ) 
+			{
+				TranslateMessage( &msg );
+				DispatchMessage( &msg );
+			}
+
+			// bring up the box if 5 seconds have passed since
+			if(GetTickCount() > 5000 + tc)
+			{
+				if ( errString( ghWndMain, ikszWarningTapiReInit, MB_RETRYCANCEL )
+					 == IDCANCEL )
+				{
+					break;
+				}
+				// reset the relative counter
+				tc = GetTickCount(); 
+			}            
+		}
+
+		// give back dialer functionality
+		DisableDialButtons( FALSE );
+		EnableWindow( ghWndMain, TRUE );
+	}
+
+	if ( errCode )
+    {
+        dwReturn = errCode;
+        goto tapiinit_exit;
+    }
+
+	// retrieve preferred line info from INI file
+	GetPrivateProfileString (
+								"Preference",
+								"Preferred Line",
+								gszNULL, 
+								szBuffer,
+								MAXBUFSIZE,
+								gszINIfilename
+							);
+
+	// if szBuffer is not empty.
+	if ( lstrcmp ( gszNULL, szBuffer ) )
+	{
+		dwPreferredPLID = (DWORD) atoi( szBuffer );	
+	}
+	else	
+	{
+		dwPreferredPLID = (DWORD) -1;
+	}
+										
+	// -1 default - tells us if it ever gets set
+	giCurrentLine = (DWORD) -1;			
+
+	// allocate buffer for storing LINEINFO for all of the available lines
+	// always allocate space for at least one line
+	if ( gnAvailDevices == 0 )
+	{
+		gnAddr = (DWORD *) DialerAlloc( sizeof( DWORD ) );
+		gdwPLID = (DWORD *) DialerAlloc( sizeof( DWORD ) );
+		lpLineInfo = (LPLINEINFO) DialerAlloc( sizeof( LINEINFO ) );
+	}
+	else
+	{
+		gnAddr = (DWORD *) DialerAlloc( sizeof( DWORD ) * (int)gnAvailDevices);
+		gdwPLID = (DWORD *) DialerAlloc( sizeof( DWORD ) * (int)gnAvailDevices);
+		lpLineInfo = (LPLINEINFO) DialerAlloc( sizeof( LINEINFO ) * (int)gnAvailDevices );
+	}
+
+	// if no space was set aside...
+	if ( lpLineInfo == NULL || gnAddr == NULL )
+    {
+        dwReturn = LINEERR_NOMEM;
+        goto tapiinit_exit;
+    }
+
+	// fill lpLineInfo[] and open each line
+	for ( iLine = 0, cvLine = 0; iLine < gnAvailDevices; ++iLine )
+	{
+		// skip remaining processing for this if it didn't open
+		if ( GetLineInfo( iLine, &lpLineInfo[iLine] ) != ERR_NONE )
+			continue; 
+
+		gnAddr [ iLine ] = lpLineInfo[iLine].nAddr;
+		gdwPLID[ iLine ] = lpLineInfo[iLine].dwPermanentLineID;
+
+		if ( lpLineInfo[iLine].dwPermanentLineID == dwPreferredPLID )
+			giCurrentLine = iLine;
+
+		// note number of lines with Interactive voice caps.
+		// used to select a preferred line by default
+		if ( lpLineInfo [ iLine ].fVoiceLine )
+		{
+			cvLine++;
+			dwID = iLine;
+		}
+	}
+
+	// if we couldn't find the preferred line, 
+	// try and assign one by default 
+	// else bring up connect using dialog
+	if (  giCurrentLine == (DWORD)-1 ) 
+	{
+		// check if there is only one line
+		// that has interactive voice caps, 
+		// make it default line
+		if ( cvLine == 1 ) 
+		{
+			giCurrentLine = dwID;
+
+			// if the preferred address read from the INI file
+			// was different i.e we are changing setting, inform
+			// the user
+			if ( dwPreferredPLID != -1 )
+			{
+				errString( ghWndMain, ERR_NEWDEFAULT, MB_ICONEXCLAMATION | MB_OK );
+			}
+		}
+		else
+		{
+			gCurrentLineInfo = lpLineInfo[0];
+			if ( DialogBoxParam (
+									ghInst,
+									MAKEINTRESOURCE(IDD_CONNECTUSING),
+									ghWndMain,
+									(DLGPROC)ConnectUsingProc,
+									INVALID_LINE
+								)
+				 == -1)
+			{
+                dwReturn = (DWORD) -1;
+			}
+			else
+			{
+                dwReturn = ERR_NONE;
+			}
+
+            goto tapiinit_exit;
+		}
+	}
+	gCurrentLineInfo = lpLineInfo[ giCurrentLine ];
+
+
+	// select default address
+	giCurrentAddress = 0;
+
+	// get the name of the preferred address from ini file
+	GetPrivateProfileString (
+								"Preference",
+								"Preferred Address",
+								gszNULL, 
+								szBuffer,
+								MAXBUFSIZE,
+								gszINIfilename
+							);
+
+	// if preferred address read from INI file
+	if ( lstrcmp( gszNULL, szBuffer ) )
+	{
+		giCurrentAddress = (DWORD) atoi( szBuffer );
+		
+		// if the address is invalid, set default
+		if ( giCurrentAddress >= gCurrentLineInfo.nAddr )
+			giCurrentAddress = 0;
+	}
+	
+
+tapiinit_exit:
+    
+    if (lpLineInfo)
+    {
+        DialerFree(lpLineInfo);
+    }
+    
+	return dwReturn;;
+}
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+int WINAPI WinMain (
+					HINSTANCE hInstance,
+					HINSTANCE hPrevInstance,
+					LPSTR lpCmdLine,
+					int nCmdShow
+				   )
+{
+	HACCEL hAccel;
+	MSG msg;
+	DWORD errCode;
+	HANDLE hImHere;
+
+
+	ghInst = GetModuleHandle( NULL );
+	LoadString( ghInst, ikszAppFriendlyName, gszAppName, sizeof(gszAppName)/sizeof(TCHAR) );
+
+	//
+	// Now, let's see if we've already got an instance of ourself
+	hImHere = CreateMutex(NULL, TRUE, "DialersIveBeenStartedMutex");
+
+	//
+	// Is there another one of us already here?
+	if ( ERROR_ALREADY_EXISTS == GetLastError() )
+	{
+        HWND        hDialerWnd;
+
+        hDialerWnd = FindWindow(gszDialerClassName,
+                                NULL);
+
+        SetForegroundWindow(hDialerWnd);
+        
+	   CloseHandle( hImHere );
+	   return 0;
+	}
+
+
+	{
+		WNDCLASS wc;
+		wc.style = CS_DBLCLKS | CS_SAVEBITS | CS_BYTEALIGNWINDOW;
+		wc.lpfnWndProc = DefDlgProc;
+		wc.cbClsExtra = 0;
+		wc.cbWndExtra = DLGWINDOWEXTRA;
+		wc.hInstance = ghInst;
+		wc.hIcon = LoadIcon(ghInst, MAKEINTRESOURCE(IDI_DIALER) );
+		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+		wc.hbrBackground = GetStockObject (COLOR_WINDOW + 1);
+		wc.lpszMenuName = NULL;
+		wc.lpszClassName = gszDialerClassName;
+		RegisterClass(&wc);
+	}
+
+
+	// create the dialog box and set it with info
+	// from the .INI file
+	ghWndMain = CreateDialog (
+								ghInst,
+								(LPCSTR)MAKEINTRESOURCE(IDD_DIALER),
+								(HWND)NULL,
+								MainWndProc
+							 );
+
+	ReadINI();
+	ButtonFontSetup();
+
+	ShowWindow(ghWndMain, SW_SHOW);
+	UpdateWindow(ghWndMain);
+
+	// limit text in Number field to TAPIMAXDESTADDRESSSIZE
+	SendDlgItemMessage (
+						ghWndMain,
+						IDD_DCOMBO,
+						CB_LIMITTEXT,
+						(WPARAM)TAPIMAXDESTADDRESSSIZE,
+						0
+					   );
+
+	// 0 (ERR_NONE) error code registers success - otherwise terminate
+	errCode = InitializeTAPI();
+	if(errCode)
+	{
+		errString(ghWndMain, errCode, MB_APPLMODAL | MB_ICONEXCLAMATION );
+
+		DialerCleanup();
+		return errCode;
+	}
+
+	errCode = lineRegisterRequestRecipient (
+											ghLineApp,
+											0, // registration instance
+											LINEREQUESTMODE_MAKECALL,
+											TRUE
+										   );
+
+	if(errCode)
+	{
+		gfRegistered = FALSE;
+		errString(ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+	}
+	else
+	{
+		gfRegistered = TRUE;
+	}
+
+
+	hAccel = LoadAccelerators(ghInst, gszAppName);
+
+	while ( GetMessage( &msg, NULL, 0, 0 ) )
+	{
+		if ( ghWndMain == NULL || !IsDialogMessage( ghWndMain, &msg ) )
+		{
+			if(!TranslateAccelerator(ghWndMain, hAccel, &msg))
+			{
+				TranslateMessage(&msg);
+				DispatchMessage(&msg);
+			}
+		}
+
+		// If: 1) Dialer is a call manager (if not, ignore requests)
+		//     2) the currently chosen line is available
+		//     3) there is a Simple TAPI request
+		// Then: process the request
+		if ( gfCurrentLineAvail && gfCallRequest )
+		{
+			ManageAssistedTelephony();
+		}
+	}
+
+
+    
+	DialerCleanup();
+
+	CloseHandle( hImHere );
+
+	return msg.wParam;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LPVOID DialerAlloc(size_t cbToAlloc)
+{
+	return LocalAlloc(LPTR, cbToAlloc);
+}
+
+
+LPVOID DialerFree(LPVOID lpMem)
+{
+	return LocalFree( lpMem );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID ReadINI( VOID ) 
+{
+    WORD cSDEntry, cLastDialed;
+    DWORD cComma; 
+
+    POINT ptLeftTop;
+
+    char szName[ TAPIMAXCALLEDPARTYSIZE ];
+    char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+
+    char szNum[MAXBUFSIZE];
+    char szFieldName[MAXBUFSIZE];
+    char szPt[MAXBUFSIZE];
+                  
+
+    // get speed dial settings from INI file
+    for(cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry)
+    {
+		
+        wsprintf(szFieldName, "Name%d", cSDEntry);
+        GetPrivateProfileString (
+									"Speed Dial Settings",
+									szFieldName,
+									gszNULL,
+									szName,
+									TAPIMAXCALLEDPARTYSIZE - 1,
+									gszINIfilename
+								);
+
+        wsprintf(szFieldName, "Number%d", cSDEntry);
+        GetPrivateProfileString ( 
+									"Speed Dial Settings",
+									szFieldName,
+									gszNULL,
+									gszSDNumber[cSDEntry],
+									TAPIMAXDESTADDRESSSIZE - 1,
+									gszINIfilename
+								);        
+
+		if ( !lstrcmp( gszNULL, szName ) )
+		{
+			lstrcpy( szName, gszSDNumber[ cSDEntry ] );
+		}
+
+		FitTextToButton( ghWndMain, IDD_DSPEEDDIAL1 + cSDEntry - 1, szName );
+
+		AmpersandCompensate( szName, szTemp );
+		SetDlgItemText (
+						ghWndMain,
+						IDD_DSPEEDDIAL1 + cSDEntry - 1,
+						(LPCSTR)szTemp
+					   ); // Label the speed dial button
+	}
+
+    
+	// set up last dialed numbers in combo box (read from INI)
+	for(cLastDialed = 1; cLastDialed <= NLASTDIALED; ++cLastDialed)
+	{
+		wsprintf(szFieldName, "Last dialed %d", cLastDialed);
+		GetPrivateProfileString (
+									"Last dialed numbers",
+									szFieldName,
+									gszNULL,
+									szNum,
+									MAXBUFSIZE - 1,
+									gszINIfilename
+								);
+		if ( szNum[0] ) // i.e. if szNum isn't simply "" - if we read something
+						// from the INI - put it in the combo box
+			SendDlgItemMessage(
+								ghWndMain,
+								IDD_DCOMBO,
+								CB_ADDSTRING,
+								0,
+								(LPARAM)(LPCSTR)szNum
+							  );
+	}
+
+	// set defaults
+	ptLeftTop.x = 100; 
+	ptLeftTop.y = 100;
+
+	// set the window position based on the INI data
+	GetPrivateProfileString (
+								"Preference",
+								"Main Window Left/Top",
+								gszNULL,
+								szPt,
+								MAXBUFSIZE - 1,
+								gszINIfilename
+							);
+
+	if ( szPt[0] ) 
+	{
+		cComma = strcspn(szPt, ",");
+		szPt[cComma] = 0;
+		ptLeftTop.x = atoi(szPt);
+		
+		// a possibly absurd check to see that the string
+		// wasn't akin to "320," with no second entry
+		if ( *(szPt + cComma + 1 ) ) 
+			ptLeftTop.y = atoi( szPt + cComma + 1 );
+
+		// check to see that the box is on the screen - the upper left
+		// must be on the screen, along with a 50x50 box below and to
+		// the right of it
+		if ( ptLeftTop.x < 0
+			|| ptLeftTop.x + 50 >= GetSystemMetrics(SM_CXSCREEN)
+			|| ptLeftTop.y < 0
+			|| ptLeftTop.y + 50 >= GetSystemMetrics(SM_CYSCREEN)            
+		   )
+		{
+			ptLeftTop.x = 100; // set defaults if the box is off of the screen
+			ptLeftTop.y = 100; // set defaults if the box is off of the screen
+		}
+	}
+
+	SetWindowPos (
+					ghWndMain,
+					NULL,
+					ptLeftTop.x,
+					ptLeftTop.y,
+					0,
+					0,
+					SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOZORDER
+				 );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID ButtonFontSetup(VOID)
+    {
+    HDC hdc;
+    int IDD;
+
+    // define the fonts for the buttons
+    hdc = GetDC(GetDesktopWindow());
+
+    ghFontBtn = CreateFont(
+        (-10)*GetDeviceCaps(hdc, LOGPIXELSY)/72,
+        0,
+        0,
+        0,
+        FW_BOLD,
+        FALSE,
+        FALSE,
+        FALSE,
+        ANSI_CHARSET,
+        OUT_DEFAULT_PRECIS,
+        CLIP_DEFAULT_PRECIS,
+        PROOF_QUALITY,
+        VARIABLE_PITCH | FF_SWISS,
+        (LPSTR)"Arial"
+        );
+
+    ghFontBtnText = CreateFont(
+        (-6)*GetDeviceCaps(hdc, LOGPIXELSY)/72,
+        0,
+        0,
+        0,
+        FW_NORMAL,
+        FALSE,
+        FALSE,
+        FALSE,
+        ANSI_CHARSET,
+        OUT_DEFAULT_PRECIS,
+        CLIP_DEFAULT_PRECIS,
+        PROOF_QUALITY,
+        VARIABLE_PITCH | FF_SWISS,
+        NULL
+        );
+
+    ghFontBtnStar = CreateFont(
+        (-18)*GetDeviceCaps(hdc, LOGPIXELSY)/72,
+        0,
+        0,
+        0,
+        FW_BOLD,
+        FALSE,
+        FALSE,
+        FALSE,
+        SYMBOL_CHARSET,
+        OUT_TT_PRECIS,
+        CLIP_DEFAULT_PRECIS,
+        PROOF_QUALITY,
+        VARIABLE_PITCH | FF_DONTCARE,
+        (LPSTR)"Symbol"
+        );
+
+    ReleaseDC(GetDesktopWindow(), hdc);
+
+
+    // set the fonts for the buttons
+    if(ghFontBtn)
+        {
+        // set fonts on number buttons
+            for(IDD = IDD_DBUTTON1; IDD <= IDD_DBUTTON0; ++IDD)
+            // the order is IDD_DBUTTON1, 2, 3, ..., 0 (thus from 1 to 0)
+            SendMessage(
+                GetDlgItem(ghWndMain, IDD),
+                WM_SETFONT,
+                (WPARAM)ghFontBtn,
+                0L
+                );
+        
+        // set fonts on * and # buttons
+        SendMessage(
+            GetDlgItem(ghWndMain, IDD_DBUTTONSTAR),
+            WM_SETFONT,
+            (WPARAM)ghFontBtnStar,
+            0L
+            );
+        SendMessage(
+                    GetDlgItem(ghWndMain, IDD_DBUTTONPOUND),
+            WM_SETFONT,
+            (WPARAM)ghFontBtnStar,
+            0L
+            );
+        }
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+// Draws a 3D button within rcBtn on hDC
+VOID DrawButton(HDC hDC, RECT rcBtn, BOOL fHighlighted)
+    {
+    HPEN hPenPrev, hPenShadow, hPenHighlight, hPenBlack;
+    HBRUSH hBrushPrev, hBrushFace;
+    int RopPrev;
+
+    --rcBtn.right;
+    --rcBtn.bottom;
+
+    // set up pens/brush
+    hPenShadow = CreatePen(PS_SOLID,0,GetSysColor(COLOR_3DSHADOW));
+    hPenHighlight = CreatePen(PS_SOLID,0,GetSysColor(COLOR_3DHILIGHT));
+    hPenBlack = GetStockObject(BLACK_PEN);
+    hBrushFace = GetSysColorBrush(COLOR_3DFACE);
+    
+    // get current state so we can put it back at the end of DrawButton
+    hPenPrev = SelectObject(hDC, hPenBlack);
+    RopPrev = SetROP2(hDC, R2_COPYPEN);
+    hBrushPrev = SelectObject(hDC, hBrushFace);
+
+    PatBlt(
+        hDC,
+        rcBtn.left + 1,
+        rcBtn.top + 1,
+        rcBtn.right - rcBtn.left - 1,
+        rcBtn.bottom - rcBtn.top - 1,
+        PATCOPY
+        );
+    
+    if(fHighlighted)
+        {
+        SelectObject(hDC, hPenBlack);
+        MoveToEx(hDC, rcBtn.left, rcBtn.bottom - 1, NULL);
+        LineTo(hDC, rcBtn.left, rcBtn.top);  //  _
+        LineTo(hDC, rcBtn.right, rcBtn.top); // |
+
+        SelectObject(hDC, hPenHighlight);
+        MoveToEx(hDC, rcBtn.right, rcBtn.top, NULL);
+        LineTo(hDC, rcBtn.right, rcBtn.bottom);
+        LineTo(hDC, rcBtn.left - 1, rcBtn.bottom); // _|
+
+        SelectObject(hDC, hPenShadow);
+        MoveToEx(hDC, rcBtn.left + 1, rcBtn.bottom - 2, NULL);
+        LineTo(hDC, rcBtn.left + 1, rcBtn.top + 1);
+        LineTo(hDC, rcBtn.right - 1, rcBtn.top + 1);
+        }
+    else
+        {
+        SelectObject(hDC, hPenHighlight);
+        MoveToEx(hDC, rcBtn.left, rcBtn.bottom - 1, NULL);
+        LineTo(hDC, rcBtn.left, rcBtn.top);  //  _
+        LineTo(hDC, rcBtn.right, rcBtn.top); // |
+
+        SelectObject(hDC, hPenBlack);
+        MoveToEx(hDC, rcBtn.right, rcBtn.top, NULL);
+        LineTo(hDC, rcBtn.right, rcBtn.bottom);
+        LineTo(hDC, rcBtn.left - 1, rcBtn.bottom); // _|
+
+        SelectObject(hDC, hPenShadow);
+        MoveToEx(hDC, rcBtn.left + 1, rcBtn.bottom - 1, NULL);
+        LineTo(hDC, rcBtn.right - 1, rcBtn.bottom - 1);
+        LineTo(hDC, rcBtn.right - 1, rcBtn.top);
+        }
+
+    // put everything back how it was
+    SetROP2(hDC, RopPrev);
+    SelectObject(hDC, hBrushPrev);
+    SelectObject(hDC, hPenPrev);
+
+    DeleteObject(hPenBlack);
+    DeleteObject(hPenShadow);
+    DeleteObject(hPenHighlight);    
+    DeleteObject(hBrushFace);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DrawButtonText(HDC hDC, RECT rcBtn, BOOL fHighlighted, UINT IDD_Btn)
+    {    
+    char szLine1[MAXBUFSIZE]; // text in button up to '\n'
+    LPSTR pszLine2; // text in button after '\n'
+    int BkModePrev;
+    HFONT hFontPrev = NULL;
+    TEXTMETRIC tm;
+    RECT rcText = rcBtn;
+           
+    BkModePrev = SetBkMode(hDC, TRANSPARENT);
+
+    GetDlgItemText(ghWndMain, IDD_Btn, szLine1, MAXBUFSIZE);
+    pszLine2 = strstr(szLine1, "\n");
+    if(pszLine2)
+        {
+        *pszLine2 = 0; // 1 -> "TEST1 \n TEST2" becomes "TEST 1 \0"
+        ++pszLine2; // now 2 -> " TEST 2"
+        }
+
+    // now szLine1 points to the null terminated first string and
+    // pszLine2 points to either the null terminated second string or NULL
+    // if there was no second string
+
+    if(szLine1[0])
+        {
+        if(ghFontBtnText && pszLine2)
+            hFontPrev = SelectObject(hDC, ghFontBtnText);
+        
+        GetTextMetrics(hDC, &tm);
+        rcText.bottom = (rcBtn.bottom + rcBtn.top)/2 - 2;
+        rcText.top = rcText.bottom - (tm.tmHeight - 1);
+
+        if(pszLine2 == NULL)
+            OffsetRect(&rcText, 0, (rcText.bottom - rcText.top)/2);
+
+        if(fHighlighted)
+            OffsetRect(&rcText, 1, 1);
+
+        DrawText(hDC, szLine1, -1, &rcText, DT_SINGLELINE | DT_CENTER);
+
+        if(hFontPrev)
+            SelectObject(hDC, hFontPrev);
+        }
+    if(pszLine2) // recall that pszLine2 == NULL to represent no second string
+        {
+        GetTextMetrics(hDC, &tm);
+        if(IDD_Btn == IDD_DBUTTONSTAR || IDD_Btn == IDD_DBUTTONPOUND)
+            rcText.top = (rcBtn.bottom + rcBtn.top)/2 - (tm.tmHeight)/2;
+        else
+            rcText.top = (rcBtn.bottom + rcBtn.top)/2 - 2;
+        rcText.bottom = rcText.top + tm.tmHeight;
+
+        if(fHighlighted)
+            OffsetRect(&rcText, 1, 1);
+
+        DrawText(hDC, pszLine2, -1, &rcText, DT_SINGLELINE | DT_CENTER);
+        }
+
+    SetBkMode(hDC, BkModePrev);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DisableDialButtons(BOOL fDisable)
+{
+	int IDD;
+
+	// Disable/enable Dial button
+	EnableWindow( GetDlgItem( ghWndMain, IDD_DDIAL ),!fDisable) ;
+
+	// Disable/enable Speed dial buttons
+	for ( IDD = IDD_DSPEEDDIAL1; IDD <= IDD_DSPEEDDIAL8; ++IDD )
+	{
+		EnableWindow(GetDlgItem(ghWndMain, IDD),!fDisable);
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DialerCleanup(VOID)
+    {
+    RECT rc;
+    WORD cItem; // count of numbers in combo box
+    DWORD cLastDialed;
+    char szPt[MAXBUFSIZE];
+    char szNumber[TAPIMAXDESTADDRESSSIZE];
+    char szFieldName[MAXBUFSIZE];
+
+    CloseTAPI(); // unregister and line close
+
+    if(!IsIconic(ghWndMain)) // if the window is not minimized, record position
+        {
+        GetWindowRect(ghWndMain, &rc);
+        wsprintf(szPt, "%ld, %ld", rc.left, rc.top);
+        WritePrivateProfileString(
+            "Preference",
+            "Main Window Left/Top",
+            szPt,
+            gszINIfilename
+            );
+        }
+
+    cItem = (WORD)SendDlgItemMessage(ghWndMain, IDD_DCOMBO, CB_GETCOUNT, 0, 0);
+
+    // write out last dialed numbers from combo box (write to INI)
+    for(cLastDialed = 1; cLastDialed <= NLASTDIALED; ++cLastDialed)
+        {
+        if(cLastDialed <= cItem)
+            SendDlgItemMessage(
+                ghWndMain,
+                IDD_DCOMBO,
+                CB_GETLBTEXT,
+                cLastDialed - 1, // it's a zero-based count
+                (LPARAM)(LPCSTR)szNumber);
+
+        else
+            szNumber[0] = 0;
+
+        wsprintf(szFieldName, "Last dialed %d", cLastDialed);
+        WritePrivateProfileString(
+            "Last dialed numbers",
+            szFieldName,
+            szNumber,            
+            gszINIfilename
+            );
+
+        }
+
+    WinHelp(ghWndMain, gszHELPfilename, HELP_QUIT, 0); // unload help
+
+    DestroyWindow(ghWndMain);
+    ghWndMain = NULL;
+
+    DeleteObject(ghFontBtn);
+    DeleteObject(ghFontBtnText);
+    DeleteObject(ghFontBtnStar);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+// unregister and line close
+VOID CloseTAPI(VOID) 
+{
+
+	// unregister as call manager
+	lineRegisterRequestRecipient (
+									ghLineApp,
+									0, // registration instance
+									LINEREQUESTMODE_MAKECALL,
+									FALSE
+								 );
+
+	if ( gCurrentLineInfo.hLine )
+	{
+		lineClose ( gCurrentLineInfo.hLine );
+		gfCurrentLineAvail = FALSE;
+		gCurrentLineInfo.hLine = NULL;
+	}
+
+	lineShutdown(ghLineApp);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static HICON hIcon;
+	static const DWORD aMenuHelpIDs[] = 
+	{
+        IDD_DSPEEDDIALGRP,   (DWORD)-1,
+		IDD_DNUMTODIAL,      IDH_DIALER_DIAL_NUMBER,
+		IDD_DCOMBO,          IDH_DIALER_DIAL_NUMBER,
+		IDD_DDIAL,           IDH_DIALER_DIAL_BUTTON,
+		IDD_DSPEEDDIAL1,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL2,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL3,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL4,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL5,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL6,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL7,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL8,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT1, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT2, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT3, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT4, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT5, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT6, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT7, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT8, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DBUTTON1,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON2,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON3,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON4,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON5,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON6,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON7,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON8,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON9,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTONSTAR,     IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON0,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTONPOUND,    IDH_DIALER_DIAL_KEYPAD,
+		0,                   0
+	};
+
+        switch (msg)
+        {
+            case WM_INITDIALOG:
+                hIcon = LoadIcon( ghInst, (LPCSTR) MAKEINTRESOURCE( IDI_DIALER ) );
+                return TRUE;
+
+            case WM_SYSCOMMAND:
+                switch( (DWORD) wParam )
+                {
+                    case SC_CLOSE:                    
+                        PostQuitMessage(0);
+                }
+                break;
+
+                // processes clicks on controls when
+                // context mode help is selected
+            case WM_HELP: 
+                WinHelp (
+                         ( (LPHELPINFO) lParam)->hItemHandle,
+                         gszHELPfilename,
+                         HELP_WM_HELP,
+                         (DWORD)(LPVOID) aMenuHelpIDs
+                        );
+                return TRUE;
+
+                // processes right-clicks on controls
+            case WM_CONTEXTMENU:
+                WinHelp (
+                         (HWND)wParam,
+                         gszHELPfilename,
+                         HELP_CONTEXTMENU,
+                         (DWORD)(LPVOID)aMenuHelpIDs
+                        );
+                return TRUE;
+
+            case WM_INITMENUPOPUP:
+                // if edit menu
+                if ( LOWORD(lParam) == 1 ) 
+                {
+                    UINT wEnable;
+
+                    if ( GetParent( GetFocus() ) != GetDlgItem( ghWndMain, IDD_DCOMBO ) )
+                    {
+                        wEnable = MF_GRAYED;
+                    }
+                    else
+                    {
+                        LONG lSelect = SendDlgItemMessage (
+                            ghWndMain,
+                            IDD_DCOMBO,
+                            CB_GETEDITSEL,
+                            0,
+                            0
+                            );
+
+                        if ( HIWORD( lSelect ) != LOWORD( lSelect ) )
+                            wEnable = MF_ENABLED;
+                        else
+                            wEnable = MF_GRAYED;
+                    }
+
+                    EnableMenuItem((HMENU)wParam, IDM_EDIT_CUT, wEnable);
+                    EnableMenuItem((HMENU)wParam, IDM_EDIT_COPY, wEnable);
+                    EnableMenuItem((HMENU)wParam, IDM_EDIT_DELETE, wEnable);
+
+                    // enable paste option is there is data 
+                    // in the clipboard
+                    if ( IsClipboardFormatAvailable( CF_TEXT ) )
+                    {
+                        if ( GetClipboardData ( CF_TEXT ) )
+                        {
+                            wEnable = MF_ENABLED;
+                        }
+                        else
+                        {
+                            wEnable = MF_GRAYED;
+                        }
+                    }
+                    else
+                    {
+                        wEnable = MF_GRAYED;	
+                    }
+
+                }
+                break;
+
+
+            case WM_COMMAND:
+            {
+                char szName[TAPIMAXCALLEDPARTYSIZE] = {'\0'};
+                char szNumber[TAPIMAXDESTADDRESSSIZE] = {'\0'};
+
+                switch( LOWORD( (DWORD)wParam ) )
+                {
+                    // FILE menu
+                    case IDM_EXIT:
+                        PostQuitMessage(0);                    
+                        return TRUE;
+
+
+                        // EDIT menu
+                    case IDM_EDIT_CUT:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_CUT, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_COPY:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_COPY, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_PASTE:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_PASTE, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_DELETE:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_CLEAR, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_SPEEDDIAL:
+                        DialogBoxParam (
+                                        ghInst,
+                                        MAKEINTRESOURCE(IDD_SD1),
+                                        ghWndMain,
+                                        (DLGPROC)SpeedDial1Proc,
+                                        0
+                                       );
+                        SetFocus(GetDlgItem(ghWndMain, IDD_DDIAL));
+                        return TRUE;
+
+                        // TOOLS menu
+                    case IDM_CONNECTUSING:
+                        DialogBoxParam (
+                                        ghInst,
+                                        MAKEINTRESOURCE(IDD_CONNECTUSING),
+                                        ghWndMain,
+                                        (DLGPROC)ConnectUsingProc,
+                                        MENU_CHOICE
+                                       );
+                        return TRUE;
+
+                    case IDM_LOCATION:
+                    {
+                        char szCanNumber[ TAPIMAXDESTADDRESSSIZE ] = "";
+
+                        // fetch the number to be dialed
+                        if ( GetDlgItemText ( 
+                                              ghWndMain,
+                                              IDD_DCOMBO,
+                                              szNumber,
+                                              TAPIMAXDESTADDRESSSIZE
+                                            )
+                           )
+                        {
+                            // if a number exists, convert it to 
+                            // its canonical form.
+                            if ( !MakeCanonicalNumber ( szNumber, szCanNumber ) )
+                            {
+                                lstrcpy( szCanNumber, szNumber );
+                            }
+                        }
+
+                        lineTranslateDialog (
+                                             ghLineApp,
+                                             0,
+                                             TAPI_CURRENT_VERSION,
+                                             ghWndMain,
+                                             szCanNumber
+                                            );
+                        return TRUE;
+
+                    }
+                    // HELP menu
+                    case IDM_HELP_CONTENTS:
+                        WinHelp(ghWndMain, gszHELPfilename, HELP_CONTENTS, 0);
+                        return TRUE;
+
+                    case IDM_HELP_WHATSTHIS:
+                        PostMessage(ghWndMain, WM_SYSCOMMAND, SC_CONTEXTHELP, 0);
+                        return TRUE;
+
+                    case IDM_ABOUT:
+#ifdef SDKRELEASE
+                        DialogBoxParam(
+                                       ghInst,
+                                       MAKEINTRESOURCE(IDD_ABOUT),
+                                       ghWndMain,
+                                       (DLGPROC)AboutProc,
+                                       0
+                                      );
+#else
+                        ShellAbout(
+                                   ghWndMain,
+                                   gszAppName,
+                                   gszNULL,
+                                   LoadIcon(ghInst, (LPCSTR)IDI_DIALER)
+                                  );
+#endif
+                        return TRUE;
+
+
+                        // Accelerator processing
+                    case IDM_ACCEL_NUMTODIAL:
+                        if(GetActiveWindow() == ghWndMain)
+                            SetFocus(GetDlgItem(ghWndMain, IDD_DCOMBO));
+                        return TRUE;
+
+
+                        // Buttons
+                    case IDD_DDIAL:
+
+                    {
+                        DWORD cSDEntry;
+                        char szSDNumber[TAPIMAXDESTADDRESSSIZE];
+                        char szFieldName[MAXBUFSIZE];
+
+                        // check if number entered is dialable
+                        if ( SendMessage (
+                                          GetDlgItem(ghWndMain, IDD_DCOMBO),
+                                          WM_GETTEXTLENGTH,
+                                          0,
+                                          0
+                                         ) > 0 
+                           )
+                        {
+                            // get the number to be dialed
+                            GetDlgItemText (
+                                            ghWndMain,
+                                            IDD_DCOMBO,
+                                            (LPSTR)szNumber,
+                                            TAPIMAXDESTADDRESSSIZE
+                                           );
+
+                            // check if it is a speed dial number.  
+                            // If so choose the name to be displayed.
+                            for( cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry)
+                            {
+                                wsprintf(szFieldName, "Number%d", cSDEntry);
+                                GetPrivateProfileString (
+                                    "Speed Dial Settings",
+                                    szFieldName,
+                                    gszNULL,
+                                    szSDNumber,
+                                    TAPIMAXCALLEDPARTYSIZE - 1,
+                                    gszINIfilename
+                                    );
+
+                                // if the number matches, get the name
+                                if ( lstrcmp(szSDNumber, szNumber) == 0 )
+                                {
+                                    wsprintf( szFieldName, "Name%d", cSDEntry);
+                                    GetPrivateProfileString (
+                                        "Speed Dial Settings",
+                                        szFieldName,
+                                        gszNULL,
+                                        szName,
+                                        TAPIMAXCALLEDPARTYSIZE - 1,
+                                        gszINIfilename
+                                        );
+                                    break;
+                                }
+                            }
+
+                            SetFocus( GetDlgItem( ghWndMain, IDD_DDIAL ) );
+
+                            // once the currentline has been set
+                            // using the connect proc
+                            // the user must hit dial again 
+                            if ( giCurrentLine == (DWORD)-1 )
+                            {
+                                DialogBoxParam (
+                                                ghInst,
+                                                MAKEINTRESOURCE(IDD_CONNECTUSING),
+                                                ghWndMain,
+                                                (DLGPROC)ConnectUsingProc,
+                                                INVALID_LINE
+                                               );
+                            }
+                            else
+                            {
+                                AddToRedialList(szNumber);
+                                InitiateCall(szNumber, szName);
+                            }
+                        }
+                        return TRUE;
+                    }
+
+
+                    case IDD_DBUTTON1:
+                    case IDD_DBUTTON2:
+                    case IDD_DBUTTON3:
+                    case IDD_DBUTTON4:
+                    case IDD_DBUTTON5:
+                    case IDD_DBUTTON6:
+                    case IDD_DBUTTON7:
+                    case IDD_DBUTTON8:
+                    case IDD_DBUTTON9:
+                    case IDD_DBUTTON0:
+                    case IDD_DBUTTONSTAR:
+                    case IDD_DBUTTONPOUND:
+                    {
+                        int     i;
+                        TCHAR   szBuffer[TAPIMAXDESTADDRESSSIZE+1];
+
+                        static const char digits[] = { '1', '2', '3', '4',
+                        '5', '6', '7', '8',
+                        '9', '0', '*', '#' };
+
+                        i = SendDlgItemMessage(ghWndMain,
+                                               IDD_DCOMBO,
+                                               WM_GETTEXT,
+                                               (WPARAM)TAPIMAXDESTADDRESSSIZE+1,
+                                               (LPARAM)szBuffer);
+
+                        if (i < TAPIMAXDESTADDRESSSIZE)
+                        {
+                            MoveMemory(szBuffer+gdwStartSel+1,
+                                       szBuffer+gdwEndSel,
+                                       i - ( gdwEndSel ) + 1 );
+
+                            szBuffer[gdwStartSel] = digits[LOWORD(wParam) - IDD_DBUTTON1];
+
+                            SendDlgItemMessage(ghWndMain,
+                                               IDD_DCOMBO,
+                                               WM_SETTEXT,
+                                               0,
+                                               (LPARAM)szBuffer);
+
+                            gdwStartSel++;
+                            gdwEndSel = gdwStartSel;
+                        }
+
+                        SetFocus(GetDlgItem(ghWndMain, IDD_DDIAL));
+                        EnableWindow(GetDlgItem(ghWndMain, IDD_DDIAL), TRUE);
+
+                        return TRUE;
+                    }
+
+
+                    case IDD_DCOMBO:
+
+                        if (HIWORD(wParam) == CBN_SELENDOK)
+                        {
+                            EnableWindow( GetDlgItem(ghWndMain, IDD_DDIAL), TRUE );
+                        }
+
+                        if ((HIWORD(wParam) == CBN_SELENDOK) ||
+                            (HIWORD(wParam) == CBN_SELENDCANCEL))
+                        {
+
+                            (DWORD)SendDlgItemMessage(ghWndMain,
+                                IDD_DCOMBO,
+                                CB_GETEDITSEL,
+                                (WPARAM)&gdwStartSel,
+                                (LPARAM)&gdwEndSel);
+                            return FALSE;
+                        }
+
+                        if ( HIWORD( wParam ) == CBN_EDITCHANGE )
+                        {
+                            EnableWindow (
+                                          GetDlgItem( ghWndMain, IDD_DDIAL ),
+                                          (BOOL) GetWindowTextLength (
+                                GetDlgItem (
+                                            ghWndMain,
+                                            IDD_DCOMBO
+                                           )
+                                )
+                                         );
+                            return TRUE;
+                        }
+
+                        break;
+
+                    case IDD_DSPEEDDIAL1:
+                    case IDD_DSPEEDDIAL2:
+                    case IDD_DSPEEDDIAL3:
+                    case IDD_DSPEEDDIAL4:
+                    case IDD_DSPEEDDIAL5:
+                    case IDD_DSPEEDDIAL6:
+                    case IDD_DSPEEDDIAL7:
+                    case IDD_DSPEEDDIAL8:
+                    {
+                        DWORD cSDEntry = LOWORD( (DWORD) wParam)  - IDD_DSPEEDDIAL1 + 1;
+                        char szFieldName [MAXBUFSIZE];
+
+                        // get information for the speed dial button
+                        // from the INI file
+                        wsprintf(szFieldName, "Name%d", cSDEntry);                    
+                        GetPrivateProfileString (
+                            "Speed Dial Settings",
+                            szFieldName,
+                            gszNULL,
+                            szName,
+                            TAPIMAXCALLEDPARTYSIZE - 1,
+                            gszINIfilename
+                                                );
+
+                        wsprintf(szFieldName, "%s%d", "Number", cSDEntry);
+                        GetPrivateProfileString (
+                            "Speed Dial Settings",
+                            szFieldName,
+                            gszNULL,
+                            gszSDNumber[cSDEntry],
+                            TAPIMAXDESTADDRESSSIZE - 1,
+                            gszINIfilename
+                                                );
+
+                        // entry not set yet
+                        if( gszSDNumber[cSDEntry][0] == 0 )
+                        {
+                            DialogBoxParam (
+                                            ghInst,
+                                            MAKEINTRESOURCE(IDD_SD2),
+                                            ghWndMain,
+                                            (DLGPROC)SpeedDial2Proc,
+                                            MAKELPARAM(wParam,0)
+                                           );
+                        }
+                        
+                        // no line open
+                        // once the currentline has been set
+                        // using the connect proc
+                        // the user must hit dial again 
+                        else if ( giCurrentLine == (DWORD)-1)
+                        {
+                            DialogBoxParam (
+                                            ghInst,
+                                            MAKEINTRESOURCE(IDD_CONNECTUSING),
+                                            ghWndMain,
+                                            (DLGPROC)ConnectUsingProc,
+                                            INVALID_LINE
+                                           );
+                        }
+                        // entry is set and valid voice line is open
+                        else
+                        {
+                            // add number to list box combo.
+                            AddToRedialList( gszSDNumber[cSDEntry] );
+                            InitiateCall( gszSDNumber[cSDEntry], szName );
+                        }
+                        break;
+                    }
+                           } // end switch (LOWORD((DWORD)wParam)) { ... }
+
+                            break; // end case WM_COMMAND
+                            }
+
+
+                                            case WM_PAINT:
+                                            {
+                                                PAINTSTRUCT ps;
+
+
+                                                BeginPaint(ghWndMain, &ps);
+
+                                                if(IsIconic(ghWndMain))
+                                                    DrawIcon(ps.hdc, 0, 0, hIcon);
+                                                else
+                                                {
+                                                    HBRUSH hBrush;
+
+                                                    hBrush = GetSysColorBrush( COLOR_3DFACE );
+                                                    //                FillRect(ps.hdc, &ps.rcPaint, GetStockObject(LTGRAY_BRUSH));
+                                                    FillRect(ps.hdc, &ps.rcPaint, hBrush);
+                                                }
+
+                                                EndPaint(ghWndMain, &ps);
+
+                                                return TRUE;
+                                            }
+
+
+                                            case WM_DRAWITEM:
+                                            {
+                                                LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
+                                                BOOL fHighlighted = (SendDlgItemMessage(
+                                                    ghWndMain,
+                                                    lpdis->CtlID,
+                                                    BM_GETSTATE,
+                                                    0,
+                                                    0
+                                                    ) & 0x0004);
+
+                                                DrawButton(lpdis->hDC, lpdis->rcItem, fHighlighted);
+                                                DrawButtonText(
+                                                    lpdis->hDC,
+                                                    lpdis->rcItem,
+                                                    fHighlighted,
+                                                    lpdis->CtlID
+                                                    );
+                                                return TRUE;
+                                            }
+
+
+                                            case WM_CTLCOLORLISTBOX:
+                                            case WM_CTLCOLORBTN:
+                                            case WM_CTLCOLORSTATIC:
+                                                SetBkColor((HDC)wParam, GetSysColor(COLOR_BTNFACE));
+                                                return (BOOL)GetSysColorBrush( COLOR_3DFACE );
+
+
+                                            default:
+                                                ;
+                                                //            return DefDlgProc( hwnd, msg, wParam, lParam );
+                                                //            return DefWindowProc( hwnd, msg, wParam, lParam );
+
+
+                    } // switch (msg) { ... }
+
+	return FALSE;
+	}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID AddToRedialList( LPCSTR szNumber )
+{
+	// NLASTDIALED == 10
+	WORD cNum;
+	HWND hWndCombo = GetDlgItem(ghWndMain, IDD_DCOMBO);
+	DWORD nMatch;
+
+	// if valid number
+	if ( szNumber[0] ) 
+	{
+		// if list box has entries, check if this number
+		// is already present.  If so delete old entry
+		cNum = (WORD) SendMessage(hWndCombo, CB_GETCOUNT, 0, 0);
+		if ( cNum != 0 )
+		{
+			nMatch = SendMessage ( hWndCombo, CB_FINDSTRING, 0, (LPARAM)szNumber );
+			if ( nMatch != CB_ERR )
+			{
+				SendMessage(hWndCombo, CB_DELETESTRING, nMatch, 0);
+			}
+			else 
+			{
+				// if the list is full, remove oldest
+				if ( cNum == NLASTDIALED )
+				{
+					SendMessage( hWndCombo, CB_DELETESTRING, NLASTDIALED - 1, 0 );
+				}
+			}
+		}
+		SendMessage(hWndCombo, CB_INSERTSTRING, 0, (LPARAM)szNumber);
+		SendMessage(hWndCombo, CB_SETCURSEL, 0, 0L);
+		EnableWindow ( GetDlgItem( ghWndMain, IDD_DDIAL ), TRUE ); 
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID InitiateCall ( LPCSTR szNumber, LPCSTR szName )
+{
+	HLINE hLine = NULL;
+
+	DWORD errCode;
+
+	// struct size info
+	DWORD dwLTPSize	= sizeof ( LINETRANSLATEOUTPUT );
+	DWORD dwNameLen	= lstrlen( szName ) + 1;
+	DWORD dwLCPSize	= sizeof( LINECALLPARAMS );
+
+	LPLINETRANSLATEOUTPUT lpTransOut = NULL;
+	LPLINECALLPARAMS lpLineCallParams = NULL;
+
+	char szCanNumber[ TAPIMAXDESTADDRESSSIZE ];
+
+	// Open a line
+	errCode = lineOpen (
+						ghLineApp,
+						giCurrentLine,
+						&hLine,
+						gCurrentLineInfo.dwAPIVersion,
+						0,
+						0, 
+						LINECALLPRIVILEGE_NONE,
+						0,
+						NULL
+					   );
+	if (errCode)
+	{
+		errString ( ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+		goto error;
+	}
+
+	
+	// call translate address before dialing
+	do
+	{
+		lpTransOut = (LPLINETRANSLATEOUTPUT) DialerAlloc( dwLTPSize );
+		if ( !lpTransOut )
+		{
+			errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+			goto error;
+		}
+		lpTransOut-> dwTotalSize = dwLTPSize;
+
+
+		if ( !MakeCanonicalNumber( szNumber, szCanNumber ) )
+		{
+			lstrcpy( szCanNumber, szNumber );
+		}
+
+		errCode = lineTranslateAddress (
+										ghLineApp,
+										giCurrentLine,
+										gCurrentLineInfo.dwAPIVersion,
+										szCanNumber,
+										0,
+										0,
+										lpTransOut
+									   );
+		if ( ((LONG)errCode) < 0 )
+		{
+			errString( ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+			goto error;
+		}
+		
+		if ( lpTransOut-> dwNeededSize <= lpTransOut->dwTotalSize  )
+		{
+			// ok we are done
+			break;
+		}
+		else
+		{
+			dwLTPSize = lpTransOut-> dwNeededSize;
+			DialerFree ( lpTransOut );
+			lpTransOut = NULL;
+		}
+
+	} while ( TRUE );
+
+	
+	// if number dialed is 911, bring up a warning
+	if ( Is911( lpTransOut) )
+	{
+		INT nRes = errString ( ghWndMain, ERR_911WARN, MB_ICONSTOP | MB_YESNO );
+		if ( nRes == IDNO )
+		{
+			goto error;
+		}
+	}
+
+	
+	// set call parameters
+	dwLCPSize += dwNameLen + lpTransOut-> dwDisplayableStringSize;
+
+	lpLineCallParams = (LPLINECALLPARAMS) DialerAlloc( dwLCPSize );
+	if ( !lpLineCallParams )
+	{
+		errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+		goto error;
+	}
+
+	lpLineCallParams->dwTotalSize = dwLCPSize;
+	lpLineCallParams->dwBearerMode = LINEBEARERMODE_VOICE;
+	lpLineCallParams->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+	lpLineCallParams->dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
+	lpLineCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+	lpLineCallParams->dwAddressID = giCurrentAddress;
+
+	if ( szName[ 0 ] )
+	{
+		lpLineCallParams->dwCalledPartySize = dwNameLen;
+		lpLineCallParams->dwCalledPartyOffset = sizeof( LINECALLPARAMS );
+		lstrcpy ( 
+					(LPSTR) lpLineCallParams + sizeof(LINECALLPARAMS), 
+					szName 
+			    );
+	}
+
+	lpLineCallParams-> dwDisplayableAddressSize = lpTransOut-> dwDisplayableStringSize;
+	lpLineCallParams-> dwDisplayableAddressOffset = sizeof( LINECALLPARAMS ) + dwNameLen;
+		
+	lstrcpy (
+				(LPSTR) lpLineCallParams + sizeof(LINECALLPARAMS) + dwNameLen,
+				(LPSTR) lpTransOut + lpTransOut-> dwDisplayableStringOffset
+			);
+
+
+	// save dialing information
+	// Free old allocs.
+	if ( gszCurrentName )
+	{
+		DialerFree ( gszCurrentName );
+	}
+
+	if ( gszCurrentNumber )
+	{
+		DialerFree ( gszCurrentNumber );
+	}
+
+	// save new stuff
+	gszCurrentName = (LPSTR) DialerAlloc( dwNameLen );
+	if ( !gszCurrentName )
+	{
+		errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+		goto error;
+	}
+	lstrcpy ( gszCurrentName, szName ); 
+
+	gszCurrentNumber = (LPSTR) DialerAlloc( lpTransOut-> dwDisplayableStringSize );
+	if ( !gszCurrentNumber )
+	{
+		errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+		goto error;
+	}
+	lstrcpy ( 
+			 gszCurrentNumber, 
+			 (LPSTR) lpTransOut + lpTransOut-> dwDisplayableStringOffset  
+			);
+
+	gCurrentLineInfo.hLine = hLine;
+	ghCall = NULL;
+
+
+	// finally make the call.
+	gMakeCallRequestID = 0;
+
+	gMakeCallRequestID = lineMakeCall ( 
+										hLine, 
+										&ghCall, 
+										(LPSTR) lpTransOut + lpTransOut-> dwDialableStringOffset, 
+										0, 
+										lpLineCallParams 
+									  );
+
+	// async request ID 
+	// - the call is going out
+	if ( (LONG) gMakeCallRequestID > 0 ) 
+	{
+		gfCurrentLineAvail = FALSE;
+		gfMakeCallReplyPending = TRUE;
+		DialogBoxParam (
+						ghInst,
+						MAKEINTRESOURCE(IDD_DIALING),
+						ghWndMain,
+						(DLGPROC)DialingProc,
+						0
+					   );
+
+	}
+
+	else 
+	{
+		if ( gMakeCallRequestID == LINEERR_CALLUNAVAIL ) 
+		{
+			DialogBoxParam (
+							ghInst,
+							MAKEINTRESOURCE(IDD_CALLFAILED),
+							ghWndMain,
+							(DLGPROC)LineInUseProc,
+							0
+						   );
+		}
+
+		else
+		{
+			errString( ghWndMain, gMakeCallRequestID, MB_ICONEXCLAMATION | MB_OK );
+		}
+
+		DialerLineClose();
+		gfCurrentLineAvail = TRUE;
+	}
+
+error :
+	if ( lpLineCallParams )
+	{
+		DialerFree( lpLineCallParams );
+	}
+
+	if ( lpTransOut )
+	{
+		DialerFree( lpTransOut );
+	}
+
+	// if makecall did not succeed but line
+	// was opened, close it.
+	if ( ( gMakeCallRequestID <= 0 ) && ( gCurrentLineInfo.hLine ) )
+	{
+		DialerLineClose ();
+		gfCurrentLineAvail = TRUE;
+	}
+
+	SetFocus( GetDlgItem( ghWndMain, IDD_DCOMBO ) );
+
+	return;
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+DWORD GetLineInfo ( DWORD iLine, LPLINEINFO lpLineInfo )
+{
+	DWORD errCode = 0;
+	DWORD dwNeededSize = 0; 
+	LINEEXTENSIONID ExtensionID;
+
+	LPSTR pszLineName = NULL; 
+	LPLINEDEVCAPS lpDevCaps = NULL;
+
+
+	errCode = lineNegotiateAPIVersion (
+										ghLineApp,
+										iLine,
+										TAPI_VERSION_1_0,
+										TAPI_CURRENT_VERSION,
+										&( lpLineInfo->dwAPIVersion ),
+										&ExtensionID
+									  );
+	if ( errCode )
+	{
+		GetLineInfoFailed( iLine, lpDevCaps, lpLineInfo );
+		goto error;
+	}
+
+	dwNeededSize = sizeof( LINEDEVCAPS );
+	do
+	{
+		lpDevCaps = ( LPLINEDEVCAPS ) DialerAlloc( dwNeededSize );
+		if ( !lpDevCaps )
+		{
+			GetLineInfoFailed( iLine, lpDevCaps, lpLineInfo );
+			errCode = LINEERR_NOMEM;
+			goto error;
+		}
+
+		lpDevCaps->dwTotalSize = dwNeededSize;
+		errCode = lineGetDevCaps (
+									ghLineApp,
+									iLine,
+									lpLineInfo->dwAPIVersion,
+									0,
+									lpDevCaps
+								 );
+		if ( errCode )
+		{
+			GetLineInfoFailed( iLine, lpDevCaps, lpLineInfo );
+			goto error;
+		}
+
+		if ( lpDevCaps-> dwNeededSize <= lpDevCaps-> dwTotalSize )
+		{
+			break;
+		}
+
+		dwNeededSize = lpDevCaps->dwNeededSize;
+		DialerFree( lpDevCaps );
+		lpDevCaps = NULL;
+
+	} while ( TRUE );
+
+
+	lpLineInfo->nAddr = lpDevCaps->dwNumAddresses;
+	lpLineInfo->fVoiceLine =
+		( (lpDevCaps->dwMediaModes & LINEMEDIAMODE_INTERACTIVEVOICE) != 0 );
+
+	pszLineName = (LPSTR) DialerAlloc( MAXBUFSIZE );
+	if ( !pszLineName )
+	{
+		errCode = LINEERR_NOMEM;
+		goto error;
+	}
+
+	if ( lpDevCaps->dwLineNameSize > 0 )
+	{
+		if ( lpDevCaps-> dwLineNameSize > (MAXBUFSIZE - 1) )
+		{
+			strncpy ( 
+					 pszLineName, 
+					 (LPSTR) lpDevCaps + lpDevCaps->dwLineNameOffset,
+					 MAXBUFSIZE - 1
+					);
+			pszLineName[ MAXBUFSIZE - 1 ] = '\0';
+		}
+		else
+		{
+			lstrcpy( pszLineName, (LPSTR) lpDevCaps + lpDevCaps-> dwLineNameOffset );
+		}
+	}
+	else 
+	{
+		wsprintf ( pszLineName, "Line %d", iLine );
+	}
+
+
+	lstrcpy( lpLineInfo->szLineName, pszLineName );
+	lpLineInfo->dwPermanentLineID = lpDevCaps->dwPermanentLineID;
+
+	
+error:
+	if ( lpDevCaps )
+		DialerFree( lpDevCaps );
+
+	if ( pszLineName )
+		DialerFree( pszLineName );
+
+	return errCode; 
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID GetLineInfoFailed ( DWORD iLine, LPLINEDEVCAPS lpDevCaps, LPLINEINFO lpLineInfo )
+{
+	if ( lpDevCaps ) 
+		DialerFree(lpDevCaps);
+
+	lpLineInfo->nAddr = 0;
+	lpLineInfo->fVoiceLine = FALSE;
+	lpLineInfo->dwAPIVersion = 0; 
+	lpLineInfo->hLine = (HLINE)0;
+	lpLineInfo->dwPermanentLineID = 0;
+	lpLineInfo->szLineName[0] = 0;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LPSTR GetAddressName(DWORD iLine, DWORD iAddress)
+{
+	DWORD errCode = 0;
+	DWORD dwNeededSize = 0;       
+	LPSTR pszAddressName = NULL;
+	LPLINEADDRESSCAPS lpAddressCaps = NULL;
+
+	// allocate space for lineGetAddressCaps data
+	dwNeededSize = sizeof( LINEADDRESSCAPS );
+	
+	do
+	{
+		lpAddressCaps = ( LPLINEADDRESSCAPS )DialerAlloc( dwNeededSize );
+		if ( !lpAddressCaps )
+		{
+			goto error;
+		}
+
+		lpAddressCaps->dwTotalSize = dwNeededSize;
+		errCode = lineGetAddressCaps (
+										ghLineApp,
+										iLine,
+										iAddress,
+										gCurrentLineInfo.dwAPIVersion,
+										0,
+										lpAddressCaps
+									 );
+		if ( errCode )
+		{
+			errString( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+			goto error;
+		}
+
+		if ( lpAddressCaps-> dwNeededSize <= lpAddressCaps-> dwTotalSize )
+		{
+			break;
+		}
+
+		dwNeededSize = lpAddressCaps->dwNeededSize;
+		DialerFree( lpAddressCaps );
+		lpAddressCaps = NULL;
+
+	} while( TRUE );
+
+
+	// get the address name
+	pszAddressName = DialerAlloc( MAXBUFSIZE );
+	if ( !pszAddressName )
+	{
+		goto error;
+	}
+
+	if ( lpAddressCaps-> dwAddressSize > 0 )
+	{
+		// keep string length bounded
+		if ( lpAddressCaps-> dwAddressSize > (MAXBUFSIZE - 1 ) )
+		{
+			strncpy( 
+					pszAddressName, 
+					(LPSTR) lpAddressCaps + lpAddressCaps->dwAddressOffset,
+					MAXBUFSIZE - 1
+				   );
+			pszAddressName[ MAXBUFSIZE - 1] = '\0';
+		}
+		else
+		{
+			lstrcpy ( 
+					 pszAddressName,
+					 (LPSTR) lpAddressCaps + lpAddressCaps->dwAddressOffset
+				    );
+		}
+	}
+	else 
+	// use default name
+	{
+		wsprintf(pszAddressName, "Address %d", iAddress);
+	}
+
+error:
+	if ( lpAddressCaps )
+	{
+		DialerFree( lpAddressCaps );
+	}
+
+	return pszAddressName;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK DialingProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+
+	switch(msg)
+	{
+		char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+
+		case WM_INITDIALOG:
+			// set global handle to window
+			ghWndDialing = hwnd;
+
+			AmpersandCompensate( gszCurrentName, szTemp );
+            
+			SetDlgItemText(hwnd, IDD_DGNUMBERTEXT, gszCurrentNumber);
+			SetDlgItemText(hwnd, IDD_DGNAMETEXT, szTemp );
+			break;
+
+		case WM_COMMAND:
+			switch ( LOWORD( (DWORD)wParam ) )
+			{
+				// hang up
+				case IDCANCEL: 
+					//gfDropping = TRUE;
+					
+					// if lineMakeCall has completed
+					// only then drop call.
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						if ( ( gDropCallRequestID = lineDrop ( ghCall, NULL, 0 ) ) < 0 )
+						{
+							errString ( ghWndDialing, gDropCallRequestID, MB_ICONSTOP | MB_OK );
+						}
+					}
+					else
+					{
+						DialerLineClose();
+						gfCurrentLineAvail = TRUE;
+						gfMakeCallReplyPending = FALSE;
+					}
+
+					ghWndDialing = NULL;
+					EndDialog(hwnd, FALSE);
+
+					return TRUE;
+
+
+				// something else terminated the call
+				// all we have to do is terminate this dialog box
+				case IDOK: 
+					ghWndDialing = NULL;
+					EndDialog(hwnd, TRUE);
+
+					return TRUE;
+			}
+			break;
+
+		default:
+		  ;
+	}
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK AboutProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+    {
+    switch(msg)
+        {
+        case WM_INITDIALOG:
+            {
+            char sz[MAXBUFSIZE];
+            char szLabel[MAXBUFSIZE];
+
+            // sets up the version number for Windows
+            GetDlgItemText(hwnd, IDD_ATEXTTITLE, sz, MAXBUFSIZE);
+            wsprintf(
+                szLabel,
+                sz,
+                LOWORD(GetVersion()) & 0xFF,
+                HIBYTE(LOWORD(GetVersion)) == 10 ? 1 : 0
+                );
+            SetDlgItemText(hwnd, IDD_ATEXTTITLE, szLabel);
+
+/*            // sets up version number for Dialer
+            GetDlgItemText(hwnd, IDD_ATEXTVERSION, sz, MAXBUFSIZE);
+            wsprintf(szLabel, sz, VER_MAJOR, VER_MINOR, VER_BUILD);
+
+
+            { // strip off build number for release copies
+            DWORD i;
+            LPSTR ch = szLabel;
+
+            for (i = 0; i < 2 && *ch; ++ch)
+                {
+                if(*ch == '.')
+                    ++i;
+                if(i == 2)
+                    *ch = 0;
+                }
+
+            SetDlgItemText(hwnd ,IDD_ATEXTVERSION, szLabel);
+            } */
+
+
+/*            // get free memory information
+            GetDlgItemText(hwnd, IDD_ATEXTFREEMEM, sz, MAXBUFSIZE);
+            wsprintf(szLabel, sz, GetFreeSpace(0)>>10);
+            SetDlgItemText(hwnd, IDD_ATEXTFREEMEM, szLabel);
+
+            // get free resources information
+            GetDlgItemText(hwnd, IDD_ATEXTRESOURCE, sz,MAXBUFSIZE);
+            wsprintf(szLabel, sz, GetFreeSystemResources(0));
+            SetDlgItemText(hwnd, IDD_ATEXTRESOURCE, szLabel); */
+
+            return TRUE;
+            }
+
+        case WM_COMMAND:
+            if(LOWORD((DWORD)wParam) == IDOK)
+                {
+                EndDialog(hwnd, TRUE);
+                return TRUE;
+                }
+            break;
+        }
+    return FALSE;
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK ConnectUsingProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
+{
+	static const DWORD aMenuHelpIDs[] = 
+	{
+		IDD_CUTEXTLINE,         IDH_DIALER_OPTIONS_LINE,
+		IDD_CULISTLINE,         IDH_DIALER_OPTIONS_LINE,
+		IDD_CUTEXTADDRESS,      IDH_DIALER_OPTIONS_ADDRESS,
+		IDD_CULISTADDRESS,      IDH_DIALER_OPTIONS_ADDRESS,
+		IDD_CUSIMPLETAPICHKBOX, IDH_DIALER_OPTIONS_VOICE,
+		IDD_CUPROPERTIES,       IDH_DIALER_OPTIONS_PROPERTIES,
+		0,                      0
+	};
+
+	switch(msg)
+	{
+		case WM_HELP: 
+			// processes clicks on controls when
+			// context mode help is selected
+			WinHelp (
+						((LPHELPINFO)lParam)->hItemHandle,
+						gszHELPfilename,
+						HELP_WM_HELP,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_CONTEXTMENU:
+			// processes right-clicks on controls
+			WinHelp (
+						(HWND)wParam,
+						gszHELPfilename,
+						HELP_CONTEXTMENU,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_INITDIALOG:
+		{
+			BOOL fEnable;
+			DWORD dwPriority;
+
+			//
+			// Is there any point in even showing this dialog box?
+			if ( gnAvailDevices == 0 )
+			{
+				// Nope.  Let's tell the user what we don't like.
+				errString ( ghWndMain, ERR_NOLINES, MB_ICONEXCLAMATION | MB_OK );
+
+				EndDialog(hwnd, FALSE);
+				return TRUE;
+			}
+
+			// if not brought up by InitializeTAPI()
+			if ( lParam != INVALID_LINE ) 
+			{
+				// hide error text
+				EnableWindow( GetDlgItem( hwnd, IDD_CUERRORTEXT ), FALSE );
+			}
+
+			// get list of lines into the line list box.
+			fEnable = InitializeLineBox( GetDlgItem(hwnd, IDD_CULISTLINE) );
+			EnableWindow( GetDlgItem( hwnd, IDD_CULISTLINE ), fEnable);
+
+			// get list of addresses into the address list box.
+			fEnable =	fEnable && 
+						InitializeAddressBox (
+												GetDlgItem(hwnd, IDD_CULISTLINE),
+												GetDlgItem(hwnd, IDD_CULISTADDRESS)
+											 );
+			EnableWindow( GetDlgItem( hwnd, IDD_CULISTADDRESS ), fEnable );
+			EnableWindow( GetDlgItem( hwnd, IDOK ), fEnable );
+
+			EnableWindow( GetDlgItem( hwnd, IDD_CUPROPERTIES ), fEnable );
+
+			lineGetAppPriority (
+								"DIALER.EXE",
+								0, // checking app priority for Assisted Telephony requests
+								NULL,
+								LINEREQUESTMODE_MAKECALL,
+								NULL,
+								&dwPriority
+							   );
+			CheckDlgButton(hwnd, IDD_CUSIMPLETAPICHKBOX, (dwPriority == 1));
+
+			// if dwPriority == 1, we're supporting Assisted Telephony AND
+			// have the highest priority.
+			EnableWindow (
+							GetDlgItem(hwnd, IDD_CUSIMPLETAPICHKBOX),
+							gfRegistered
+						 );
+
+			return FALSE;
+		}
+
+		case WM_COMMAND:
+		{
+			switch ( LOWORD( (DWORD)wParam ) )
+			{
+				case IDD_CULISTLINE:
+					if ( HIWORD( wParam ) == CBN_SELENDOK )
+						// update address box
+						InitializeAddressBox (
+												GetDlgItem(hwnd, IDD_CULISTLINE),
+												GetDlgItem(hwnd, IDD_CULISTADDRESS)
+											 ); 
+					break;
+
+				case IDD_CUPROPERTIES:
+				{
+					HWND hW = GetDlgItem(hwnd, IDD_CULISTLINE);
+
+					lineConfigDialog (	
+										// device ID
+										(DWORD) SendMessage (
+																hW,
+																CB_GETITEMDATA,
+																(WORD) SendMessage(hW, CB_GETCURSEL, 0, 0),
+																0
+														    ), 
+										hwnd,
+										NULL
+									 );
+					break;
+				}
+
+				case IDOK:
+				{
+					HWND hwndBox;
+					char szBuffer[MAXBUFSIZE];
+					DWORD dwPriority;
+
+					// Update line
+					hwndBox = GetDlgItem( hwnd, IDD_CULISTLINE );
+					giCurrentLine = SendMessage (
+													hwndBox,
+													CB_GETITEMDATA,
+													SendMessage( hwndBox, CB_GETCURSEL, 0, 0 ),
+													0
+												);
+
+					// base 10
+					itoa( gdwPLID[giCurrentLine], szBuffer, 10 ); 
+					WritePrivateProfileString (  
+												"Preference",
+												"Preferred Line",
+												szBuffer,
+												gszINIfilename
+											  );
+
+
+					// Update address
+					hwndBox = GetDlgItem( hwnd, IDD_CULISTADDRESS );
+					giCurrentAddress = SendMessage (
+													hwndBox,
+													CB_GETITEMDATA,
+													SendMessage(hwndBox, CB_GETCURSEL, 0, 0),
+													0
+												   );
+
+					itoa( giCurrentAddress, szBuffer, 10 ); 
+					WritePrivateProfileString ( 
+												"Preference",
+												"Preferred Address",
+												szBuffer,
+												gszINIfilename
+											  );
+
+
+					// Update application priority
+					if ( SendDlgItemMessage (
+												hwnd,
+												IDD_CUSIMPLETAPICHKBOX,
+												BM_GETCHECK,
+												0,
+												0L
+											)
+						  == 0)
+					{
+						dwPriority = 0;
+					}
+					else   
+					{
+						dwPriority = 1;
+					}
+
+					lineSetAppPriority (
+										"DIALER.EXE",
+										0,
+										NULL,
+										LINEREQUESTMODE_MAKECALL,
+										NULL,
+										dwPriority
+									   );
+
+					EndDialog(hwnd, TRUE);
+					return TRUE;
+				}
+
+				case IDCANCEL:
+					EndDialog(hwnd, FALSE);
+					return TRUE;
+			}
+		}
+
+		default:
+			  ;
+
+	}
+
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK LineInUseProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+    {
+    LPARAM lNewParam = lParam;
+    PTSTR  ptStr;
+
+
+    switch(msg)
+        {
+        case WM_INITDIALOG:
+            {
+            switch(lParam)
+                {
+                case LINEDISCONNECTMODE_REJECT:
+                    lNewParam = ikszDisconnectedReject;
+                    break;
+
+                case LINEDISCONNECTMODE_BUSY:
+                    lNewParam = ikszDisconnectedBusy;
+                    break;
+
+                case LINEDISCONNECTMODE_NOANSWER:
+                    lNewParam = ikszDisconnectedNoAnswer;
+                    break;
+
+                case LINEDISCONNECTMODE_CONGESTION:
+                    lNewParam = ikszDisconnectedNetwork;
+                    break;
+
+                case LINEDISCONNECTMODE_INCOMPATIBLE:
+                    lNewParam = ikszDisconnectedIncompatible;
+                    break;
+
+                case LINEDISCONNECTMODE_NODIALTONE:
+                    lNewParam = ikszDisconnectedNoDialTone;
+                    break;
+
+                default:
+                    lNewParam = ikszDisconnectedCantDo;
+                    break;
+                }
+            return TRUE;
+            }
+
+        case WM_COMMAND:
+            if(LOWORD((DWORD)wParam) == IDOK)
+                {
+                EndDialog(hwnd, TRUE);
+                return TRUE;
+                }
+            break;
+
+        default:
+              ;
+//            return DefDlgProc( hwnd, msg, wParam, lParam );
+
+        }    
+
+
+    ptStr = DialerAlloc( MAXBUFSIZE );
+
+    LoadString( ghInst, lNewParam, ptStr, MAXBUFSIZE );
+
+    SetDlgItemText(
+        hwnd,
+        IDD_CFTEXT,
+        ptStr
+        );
+
+    DialerFree( ptStr );
+
+
+    return FALSE;
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK SpeedDial1Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static DWORD nCurrentSpeedDial;
+
+	static const DWORD aMenuHelpIDs[] = 
+	{
+		IDOK,                   IDH_DIALER_SPEED_SAVE,
+		IDD_SD1SPEEDDIAL1,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL2,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL3,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL4,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL5,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL6,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL7,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL8,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT1,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT2,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT3,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT4,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT5,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT6,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT7,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT8,  IDH_DIALER_BUTTONS,
+		IDD_SD1TEXTNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD1EDITNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD1TEXTNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		IDD_SD1EDITNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		IDD_SD1TEXTCHOOSE,      (DWORD)-1,
+		IDD_SD1TEXTENTER,       (DWORD)-1,
+		0,                      0
+	};
+
+	// buffer to store speed dial names till they are saved.
+	static TCHAR szSDName[NSPEEDDIALS + 1][TAPIMAXDESTADDRESSSIZE];
+
+	switch(msg)
+	{
+		case WM_HELP:
+			// processes clicks on controls when
+			// context mode help is selected
+			WinHelp(
+				((LPHELPINFO)lParam)->hItemHandle,
+				gszHELPfilename,
+				HELP_WM_HELP,
+				(DWORD)(LPVOID)aMenuHelpIDs
+				);
+			return TRUE;
+
+		case WM_CONTEXTMENU: // processes right-clicks on controls
+			WinHelp(
+				(HWND)wParam,
+				gszHELPfilename,
+				HELP_CONTEXTMENU,
+				(DWORD)(LPVOID)aMenuHelpIDs
+				);
+			return TRUE;
+
+		case WM_INITDIALOG:
+		{
+			DWORD cSDEntry;
+			DWORD idFirstEmpty = (DWORD) -1;
+
+			char szName[TAPIMAXCALLEDPARTYSIZE];
+			char szTemp[TAPIMAXCALLEDPARTYSIZE];
+			char szFieldName[MAXBUFSIZE];
+
+			// Retrieve speed dial info from INI file
+			for(cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry)
+			{
+				wsprintf(szFieldName, "Name%d", cSDEntry);        
+				GetPrivateProfileString (
+											"Speed Dial Settings",
+											szFieldName,
+											gszNULL,
+											szSDName[ cSDEntry ],
+											TAPIMAXCALLEDPARTYSIZE - 1,
+											gszINIfilename
+										);
+
+				// set the first empty speed dial button
+				if ( idFirstEmpty == -1 && 
+					 szSDName[ cSDEntry ][0] == '\0' &&
+					 gszSDNumber[ cSDEntry ][ 0 ] == '\0' )
+					idFirstEmpty = cSDEntry;
+
+				wsprintf(szFieldName, "Number%d", cSDEntry);
+				GetPrivateProfileString (
+											"Speed Dial Settings",
+											szFieldName,
+											gszNULL,
+											gszSDNumber[cSDEntry],
+											MAXBUFSIZE - 1,
+											gszINIfilename
+										);
+
+				// get a copy of the name for editing
+				// if name is empty, use the number as the
+				// name.
+				if ( lstrcmp( gszNULL, szSDName[ cSDEntry ] ) )
+				{			
+					lstrcpy( szName, szSDName[ cSDEntry] );
+				}
+				else
+				{
+					lstrcpy( szName, gszSDNumber[ cSDEntry ] );
+				}
+			
+				FitTextToButton( hwnd, IDD_SD1SPEEDDIAL1 + cSDEntry - 1, szName );
+				AmpersandCompensate( szName, szTemp );
+
+				SetDlgItemText (
+								hwnd,
+								IDD_SD1SPEEDDIAL1 + cSDEntry - 1,
+								(LPCSTR) szTemp
+							   ); 
+
+			}
+
+			// for the edit speed dial dialog
+			// limit the lengths of text
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD1EDITNAME,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXCALLEDPARTYSIZE - 1),
+								0
+							   );
+
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD1EDITNUMBER,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXDESTADDRESSSIZE - 1),
+								0
+							   );
+
+			// select the first empty button
+			// nothing empty, then edit #1
+			if ( -1 == idFirstEmpty ) 
+			{
+				nCurrentSpeedDial = 1;
+				SetDlgItemText(
+								hwnd,
+								IDD_SD1EDITNAME,
+								(LPCSTR) szSDName[ 1 ]
+							  );
+
+				SetDlgItemText(
+								hwnd,
+								IDD_SD1EDITNUMBER,
+								(LPCSTR) gszSDNumber[ 1 ]
+							  );
+			}
+			else
+			{
+				nCurrentSpeedDial = idFirstEmpty;
+			}
+
+			SetFocus( GetDlgItem( hwnd, IDD_SD1EDITNAME ) );
+			return FALSE;
+		}
+
+		case WM_COMMAND:
+		{
+			char szName[TAPIMAXCALLEDPARTYSIZE];
+			char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+
+			switch( LOWORD( (DWORD) wParam ) )
+			{
+				case IDOK:
+				{
+					DWORD cSDEntry;
+					char szFieldName[MAXBUFSIZE];
+
+					// save new speed dial settings
+					for ( cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry )
+					{
+						wsprintf(szFieldName, "Name%d", cSDEntry);
+						WritePrivateProfileString ( 
+													"Speed Dial Settings",
+													szFieldName,
+													szSDName [cSDEntry],
+													gszINIfilename
+												  );
+
+						wsprintf(szFieldName, "Number%d", cSDEntry);
+						WritePrivateProfileString ( 
+													"Speed Dial Settings",
+													szFieldName,
+													gszSDNumber[cSDEntry],
+													gszINIfilename
+												  );
+
+						// set the text for the corresponding 
+						// main window button
+						if ( szSDName[ cSDEntry ][ 0 ] == '\0' )
+						{
+							lstrcpy( szName, gszSDNumber[ cSDEntry ] );
+						}
+						else
+						{
+							lstrcpy( szName, szSDName[ cSDEntry ] );
+						}
+
+						FitTextToButton( 
+										ghWndMain, 
+										IDD_DSPEEDDIAL1 + cSDEntry - 1, 
+										szName 
+									   );
+
+						AmpersandCompensate( szName, szTemp );
+						SetDlgItemText ( 
+										ghWndMain,
+										IDD_DSPEEDDIAL1 + cSDEntry - 1,
+										(LPCSTR) szTemp
+									   );
+					}
+
+					EndDialog(hwnd, TRUE);
+					return TRUE;
+				}
+
+				case IDCANCEL:
+					EndDialog(hwnd, FALSE);
+					return TRUE;
+
+				case IDD_SD1SPEEDDIAL1:
+				case IDD_SD1SPEEDDIAL2:
+				case IDD_SD1SPEEDDIAL3:
+				case IDD_SD1SPEEDDIAL4:
+				case IDD_SD1SPEEDDIAL5:
+				case IDD_SD1SPEEDDIAL6:
+				case IDD_SD1SPEEDDIAL7:
+				case IDD_SD1SPEEDDIAL8:
+
+					nCurrentSpeedDial =	LOWORD( (DWORD) wParam ) - IDD_SD1SPEEDDIAL1 + 1;
+
+					SetDlgItemText (
+									hwnd,
+									IDD_SD1EDITNAME,
+									szSDName [ nCurrentSpeedDial ]
+								   );
+					SetDlgItemText (
+									hwnd,
+									IDD_SD1EDITNUMBER,
+									gszSDNumber[nCurrentSpeedDial]
+								   );
+
+					SetFocus( GetDlgItem( hwnd, IDD_SD1EDITNAME ) );
+					SendDlgItemMessage(
+										hwnd,
+										IDD_SD1EDITNAME,
+										EM_SETSEL,
+										0,
+										MAKELPARAM(0, -1)
+									);
+					break;
+
+				case IDD_SD1EDITNAME:
+					if ( HIWORD( wParam ) == EN_CHANGE )
+					{
+
+						GetDlgItemText (
+										hwnd,
+										IDD_SD1EDITNAME,
+										szName,
+										TAPIMAXCALLEDPARTYSIZE
+									   );
+
+						// if there is no name, label the button with
+						// the number
+						if ( szName[ 0 ] == '\0' )
+						{
+							szSDName[ nCurrentSpeedDial ][ 0 ] = '\0';
+							lstrcpy( szName, gszSDNumber[ nCurrentSpeedDial ] );
+						}
+						else
+						{
+							lstrcpy( szSDName[ nCurrentSpeedDial ], szName );
+						}
+
+						FitTextToButton ( 
+											hwnd, 
+											IDD_SD1SPEEDDIAL1 + nCurrentSpeedDial - 1,
+											szName
+										);
+						AmpersandCompensate( szName, szTemp );
+
+						SetDlgItemText (
+										hwnd,
+										IDD_SD1SPEEDDIAL1 + nCurrentSpeedDial - 1,
+										szTemp
+									   );
+					}
+					break;
+
+				case IDD_SD1EDITNUMBER:
+					if ( HIWORD( wParam ) == EN_CHANGE )
+					{
+						GetDlgItemText (
+										hwnd,
+										IDD_SD1EDITNUMBER,
+										gszSDNumber[nCurrentSpeedDial],
+										TAPIMAXDESTADDRESSSIZE
+									   );
+
+						if ( gszSDNumber[ nCurrentSpeedDial ][ 0 ] == '\0' )
+						{
+							GetDlgItemText (
+											hwnd,
+											IDD_SD1EDITNAME,
+											szName,
+											TAPIMAXDESTADDRESSSIZE
+										   );
+
+							if ( szName[ 0 ] == '\0' )
+							{
+								SetDlgItemText ( 
+												hwnd,
+												IDD_SD1SPEEDDIAL1 + nCurrentSpeedDial - 1,
+												szName
+											   );
+
+							}
+						}
+					}
+					break;
+				} // switch(LOWORD((DWORD)wParam))
+			break;
+
+		} // case WM_COMMAND:
+
+		default:
+			  ;
+
+	} // switch(msg)
+
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK SpeedDial2Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static DWORD nCurrentSpeedDial;
+
+	static const DWORD aMenuHelpIDs[] = 
+	{
+		IDOK,                   IDH_DIALER_SPEED_SAVE,
+		IDD_SD2SAVEANDDIAL,     IDH_DIALER_SPEED_SAVE_DIAL,
+		IDD_SD2TEXTNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD2EDITNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD2TEXTNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		IDD_SD2EDITNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		0,                      0
+	};
+
+	switch(msg)
+	{
+		case WM_HELP: 
+			// processes clicks on controls when
+			// context mode help is selected
+			WinHelp (
+						((LPHELPINFO)lParam)->hItemHandle,
+						gszHELPfilename,
+						HELP_WM_HELP,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_CONTEXTMENU: 
+			// processes right-clicks on controls
+			WinHelp (
+						(HWND)wParam,
+						gszHELPfilename,
+						HELP_CONTEXTMENU,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_INITDIALOG:
+		{
+			char szFieldName [MAXBUFSIZE];
+			char szName [TAPIMAXCALLEDPARTYSIZE];
+
+			nCurrentSpeedDial = LOWORD( lParam ) - IDD_DSPEEDDIAL1 + 1;
+
+			// retrieve speed dial button info
+			wsprintf(szFieldName, "Name%d", nCurrentSpeedDial);
+			GetPrivateProfileString (
+										"Speed Dial Settings",
+										szFieldName,
+										gszNULL,
+										szName,
+										TAPIMAXCALLEDPARTYSIZE - 1,
+										gszINIfilename
+									);
+			SetDlgItemText (
+							hwnd,
+							IDD_SD2EDITNAME,
+							szName
+						   );
+
+			SetDlgItemText (
+							hwnd,
+							IDD_SD2EDITNUMBER,
+							gszSDNumber[nCurrentSpeedDial]
+						   );
+
+			// limit the lengths of the texts
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD2EDITNAME,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXCALLEDPARTYSIZE - 1),
+								0
+							   );
+
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD2EDITNUMBER,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXDESTADDRESSSIZE - 1),
+								0
+							   );
+
+
+			SetFocus( GetDlgItem( hwnd, IDD_SD2EDITNAME ) );
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD2EDITNAME,
+								EM_SETSEL,
+								0,
+								MAKELPARAM(0, -1)
+							   );
+
+			return FALSE;
+		}
+
+		case WM_COMMAND:
+		{
+			char szName[ TAPIMAXCALLEDPARTYSIZE ];
+			char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+			char szFieldName[MAXBUFSIZE];
+
+			switch ( LOWORD( (DWORD) wParam ) )
+			{
+				case IDOK:
+				case IDD_SD2SAVEANDDIAL:
+				{
+					GetDlgItemText (
+									hwnd,
+									IDD_SD2EDITNAME,
+									(LPTSTR) szName,
+									TAPIMAXCALLEDPARTYSIZE
+								   );
+
+					GetDlgItemText (
+									hwnd,
+									IDD_SD2EDITNUMBER,
+									(LPTSTR) gszSDNumber[nCurrentSpeedDial],
+									TAPIMAXCALLEDPARTYSIZE
+								   );
+
+					wsprintf ( szFieldName, "Name%d", nCurrentSpeedDial );
+
+					WritePrivateProfileString ( 
+												"Speed Dial Settings",
+												szFieldName,
+												szName,
+												gszINIfilename
+											  );
+	
+					wsprintf ( szFieldName, "Number%d", nCurrentSpeedDial );
+					WritePrivateProfileString ( 
+												"Speed Dial Settings",
+												szFieldName,
+												gszSDNumber[nCurrentSpeedDial],
+												gszINIfilename
+											  );
+
+					// update main window buttons
+					// is only number has been entered, label button with it.
+					if ( szName[ 0 ] == '\0' )
+					{
+						lstrcpy( szName, gszSDNumber[ nCurrentSpeedDial ] );
+					}
+
+					FitTextToButton ( 
+										ghWndMain, 
+										IDD_DSPEEDDIAL1 + nCurrentSpeedDial - 1, 
+										(LPSTR) szName
+									);
+
+					AmpersandCompensate( szName, szTemp );
+					
+					SetDlgItemText ( 
+									ghWndMain,
+									IDD_DSPEEDDIAL1 + nCurrentSpeedDial - 1,
+									(LPCSTR)szTemp
+								   );
+
+					// if save and dial, then post dial message to main window
+					if ( LOWORD( (DWORD) wParam ) == IDD_SD2SAVEANDDIAL )
+					{
+						PostMessage (
+										ghWndMain,
+										WM_COMMAND,
+										MAKEWPARAM (
+													nCurrentSpeedDial + IDD_DSPEEDDIAL1 - 1,
+													BN_CLICKED
+												   ),
+										(LPARAM) GetDlgItem (
+																ghWndMain,
+																nCurrentSpeedDial + IDD_DSPEEDDIAL1 - 1
+															)
+									);
+					}
+					EndDialog(hwnd, TRUE);
+					return TRUE;
+				}
+
+				case IDCANCEL:
+					EndDialog(hwnd, FALSE);
+					return TRUE;
+
+				case IDD_SD2EDITNAME:
+				case IDD_SD2EDITNUMBER:
+					if ( HIWORD( wParam ) == EN_CHANGE)
+					{
+						EnableWindow (
+										GetDlgItem( hwnd, IDD_SD2SAVEANDDIAL ),
+										GetWindowTextLength ( GetDlgItem( hwnd, IDD_SD2EDITNUMBER ) ) > 0
+									 );
+					}
+					break;
+
+			} // switch(LOWORD((DWORD)wParam))
+			break;
+		}
+
+
+		default:
+			  ;
+
+	} // switch(msg)
+
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID CALLBACK
+tapiCallback (
+				DWORD   hDevice,
+				DWORD   dwMsg,
+				DWORD   dwCBInstance,
+				DWORD   dwParam1,
+				DWORD   dwParam2,
+				DWORD   dwParam3
+		    )
+{
+	switch (dwMsg)
+	{
+		INT errCode;
+
+		case LINE_ADDRESSSTATE:
+			break;
+
+		case LINE_CALLINFO:
+			break;
+
+		case LINE_CALLSTATE:
+			if ( (HCALL)hDevice != ghCall )
+				return;
+
+			switch ( dwParam1 ) // new state
+			{
+				case LINECALLSTATE_IDLE:
+
+					// tell "Dialing" window to terminate
+					if ( ghWndDialing )
+					{
+						SendMessage ( 
+										ghWndDialing,
+										WM_COMMAND,
+										MAKEWPARAM( IDOK, 0 ),
+										0
+									);
+					}
+
+					// tapi call cleanup
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						if ( ( errCode = lineDeallocateCall( ghCall ) ) < 0 )
+						{
+							errString ( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+						}
+						ghCall = NULL;
+					}
+					DialerLineClose();
+					gfCurrentLineAvail = TRUE;
+
+					// update main window
+					DisableDialButtons( FALSE );
+					break;
+
+				case LINECALLSTATE_BUSY:
+					tapiCallback (
+									hDevice,
+									dwMsg,
+									dwCBInstance,
+									LINECALLSTATE_DISCONNECTED,
+									LINEDISCONNECTMODE_BUSY,
+									dwParam3
+								 );
+					break;
+
+				case LINECALLSTATE_SPECIALINFO:
+					tapiCallback (
+									hDevice,
+									dwMsg,
+									dwCBInstance,
+									LINECALLSTATE_DISCONNECTED,
+									LINEDISCONNECTMODE_UNREACHABLE,
+									dwParam3
+								 );
+					break;
+
+				case LINECALLSTATE_DISCONNECTED:
+				{
+					BOOL fCallOK;
+					DWORD LineDisconnectMode;
+
+
+					if ( dwParam2 == 0 )
+						LineDisconnectMode = LINEDISCONNECTMODE_NORMAL;
+					else
+						LineDisconnectMode = dwParam2;
+
+					fCallOK = ( LineDisconnectMode == LINEDISCONNECTMODE_NORMAL		||
+								LineDisconnectMode == LINEDISCONNECTMODE_UNKNOWN	||
+								LineDisconnectMode == LINEDISCONNECTMODE_PICKUP		||
+								LineDisconnectMode == LINEDISCONNECTMODE_FORWARDED	||
+								LineDisconnectMode == LINEDISCONNECTMODE_UNAVAIL
+							  );
+
+					
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						//gfDropping = TRUE;
+						if ( ( gDropCallRequestID = lineDrop ( ghCall, NULL, 0 ) ) < 0 )
+						{
+							errString ( ghWndMain, gDropCallRequestID, MB_ICONSTOP | MB_OK );
+						}
+					}
+
+					if ( !fCallOK )
+						DialogBoxParam (
+										ghInst,
+										MAKEINTRESOURCE(IDD_CALLFAILED),
+										ghWndMain,
+										(DLGPROC)LineInUseProc,
+										LineDisconnectMode
+									   );
+					break;
+				}
+			}
+			break;
+
+
+		case LINE_CLOSE:
+			if ( gCurrentLineInfo.hLine == (HLINE)hDevice )
+			{
+				errString(ghWndMain, ERR_LINECLOSE, MB_ICONEXCLAMATION | MB_OK );
+				gCurrentLineInfo.hLine = NULL;
+				gfCurrentLineAvail = FALSE;
+				DisableDialButtons(FALSE);                
+			}
+			break;
+
+		case LINE_CREATE:
+			// dwParam1 is the new device's ID
+			if ( dwParam1 >= gnAvailDevices ) 
+			{
+				DWORD* gnAddrTemp;
+				DWORD iLine;
+				LINEINFO LineInfo;
+
+				// we record new device's address count.
+
+                // we are assuming here that we're just adding a new
+                // line and it's sequential and it's the last one
+
+                gnAvailDevices = dwParam1 + 1;
+                
+				gnAddrTemp = (DWORD *) DialerAlloc ( sizeof(DWORD) * (int)(gnAvailDevices) );
+
+				for ( iLine = 0; iLine < (gnAvailDevices-1); ++iLine )
+					gnAddrTemp[iLine] = gnAddr[iLine];
+
+				DialerFree( gnAddr );
+
+				// we have effectively added one more
+				// space in the gnAddr array
+				gnAddr = gnAddrTemp; 
+
+				if ( GetLineInfo( dwParam1, &LineInfo ) != ERR_NONE )
+					break;
+
+ 				gnAddr[dwParam1] = LineInfo.nAddr;
+			}
+			break;
+
+		case LINE_DEVSPECIFIC:
+			break;
+
+		case LINE_DEVSPECIFICFEATURE:
+			break;
+
+		case LINE_GATHERDIGITS:
+			break;
+
+		case LINE_GENERATE:
+			break;
+
+		case LINE_LINEDEVSTATE:
+			if ( dwParam1 & LINEDEVSTATE_REINIT )
+			{
+				if(dwParam2 != 0) 
+				{
+					// this is another msg translated into REINIT
+					tapiCallback( hDevice, dwParam2, dwCBInstance, dwParam3, 0, 0 );
+				}
+				else 
+				{
+					// Re-initialize TAPI
+					gfNeedToReinit = TRUE;
+				}
+			}
+
+			if ( dwParam1 & LINEDEVSTATE_REMOVED )
+			{
+				DialerLineClose();
+				tapiCallback(hDevice, LINE_CLOSE, dwCBInstance, 0, 0, 0); // is this needed?
+			}
+			break;
+
+		case LINE_MONITORDIGITS:
+			break;
+
+		case LINE_MONITORMEDIA:
+			break;
+
+		case LINE_MONITORTONE:
+			break;
+
+		// async reply from lineMakeCall() or lineDrop()
+		case LINE_REPLY:
+
+			// reply for lineMakeCall 
+			if ( (LONG) dwParam1 == gMakeCallRequestID )
+			{
+				// error on make call
+				if ( dwParam2 != ERR_NONE )
+				{
+					// Get rid of the Dialing Dialog box if it's up
+					if ( ghWndDialing )
+					{
+					   SendMessage(
+									ghWndDialing,
+									WM_COMMAND,
+									MAKEWPARAM(IDOK,0),
+									0
+								  );
+					}
+
+					if ( dwParam2 == LINEERR_CALLUNAVAIL )
+					{
+						DialogBoxParam (
+										ghInst,
+										MAKEINTRESOURCE(IDD_CALLFAILED),
+										ghWndMain,
+										(DLGPROC)LineInUseProc,
+										0
+									   );
+					}
+					else
+					{
+						errString ( ghWndMain, dwParam2, MB_ICONEXCLAMATION | MB_OK );
+					}
+
+					ghCall = NULL;
+					DialerLineClose();
+					gfCurrentLineAvail = TRUE;
+				}
+
+				gfMakeCallReplyPending = FALSE;
+			}
+
+			// reply from lineDrop()
+			if ( (LONG) dwParam1 == gDropCallRequestID )
+			{
+				//gfDropping = FALSE;
+
+				// tell "Dialing" window to terminate
+				if ( ghWndDialing )
+				{
+					SendMessage ( 
+									ghWndDialing,
+									WM_COMMAND,
+									MAKEWPARAM( IDOK,0 ),
+									0
+								);
+				}
+				
+				// tapi call cleanup
+				if ( dwParam2 == ERR_NONE )
+				{
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						if ( ( errCode = lineDeallocateCall( ghCall ) ) < 0 )
+						{
+							errString ( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+						}
+						ghCall = NULL;
+					}
+				}
+				DialerLineClose ();
+				gfCurrentLineAvail = TRUE;
+			}
+
+			break;
+
+		case LINE_REQUEST:
+			// Simple TAPI request
+			if ( dwParam1 == LINEREQUESTMODE_MAKECALL )
+			{
+				gfCallRequest = TRUE;
+			}
+			break;
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL InitializeLineBox(HWND hwndLineBox)
+{
+
+	DWORD iLine, iItem, iItemCurrent = (DWORD)-1;
+	DWORD errCode;
+
+	LPLINEINFO lpLineInfo = NULL;
+
+	// allocate buffer for storing LINEINFO for all of 
+	// the available lines.  Always allocate space for 
+	// at least one line
+	if ( gnAvailDevices == 0 )
+	{
+		lpLineInfo = (LPLINEINFO) DialerAlloc( sizeof(LINEINFO) );
+	}
+	else
+	{
+		lpLineInfo = (LPLINEINFO) DialerAlloc ( sizeof(LINEINFO) * (int)gnAvailDevices );
+	}
+
+	// if no space was set aside...
+	if ( lpLineInfo == NULL ) 
+		return LINEERR_NOMEM;
+
+	// fill lpLineInfo[] and open each line
+	for ( iLine = 0; iLine < gnAvailDevices; ++iLine )
+	{
+		// skip remaining processing for this line if it didn't open
+		if ( GetLineInfo( iLine, &lpLineInfo[iLine] ) != ERR_NONE )
+		{
+			continue;
+		}
+
+		iItem = SendMessage (
+								hwndLineBox,
+								CB_ADDSTRING,
+								0,
+								(LPARAM)(LPCSTR)(lpLineInfo[iLine].szLineName)
+							);
+
+		// error, bail out.
+		if ( iItem == CB_ERR || iItem == CB_ERRSPACE )
+		{
+            if (lpLineInfo)
+            {
+                DialerFree(lpLineInfo);
+            }
+            
+			return FALSE; 
+		}
+
+		errCode = SendMessage (
+								hwndLineBox,
+								CB_SETITEMDATA,
+								(WPARAM)iItem,
+								(LPARAM)iLine
+							  );
+
+		if ( iLine == giCurrentLine )
+		{
+			iItemCurrent = iItem;
+		}
+		else if ( iItemCurrent != -1 && iItem <= iItemCurrent )
+		{
+			// if the item we are putting is before the
+			// "current" item, we must increment iItemCurrent
+			// to reflect that something is being placed before
+			// it, due to sorting
+			++iItemCurrent;
+		}
+	}
+
+	if ( iItemCurrent == (DWORD)-1 )
+		iItemCurrent = 0;
+
+	if ( SendMessage( hwndLineBox, CB_GETCOUNT, 0, 0) != 0 )
+	{
+		SendMessage( hwndLineBox, CB_SETCURSEL, (WPARAM)iItemCurrent, 0 );
+		return TRUE;
+	}
+
+    DialerFree(lpLineInfo);
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL InitializeAddressBox( HWND hwndLineBox, HWND hwndAddressBox )
+{
+	DWORD errCode;
+	DWORD iAddress, iItem, iItemCurrent = (DWORD)-1;
+	DWORD iLineBoxCurrent;
+	LPSTR pszAddressName;
+
+	if ( SendMessage( hwndLineBox, CB_GETCOUNT, 0, 0 ) == 0 )
+	{
+		return FALSE;
+	}
+
+	// select current entry in line box
+	iLineBoxCurrent = SendMessage ( 
+									hwndLineBox,
+									CB_GETITEMDATA,
+									SendMessage( hwndLineBox, CB_GETCURSEL, 0, 0 ),
+									0
+								  );
+	// empty address list box
+	SendMessage ( hwndAddressBox, CB_RESETCONTENT, 0, 0); 
+
+	// get all the address for this line
+	for ( iAddress = 0; iAddress < gnAddr[iLineBoxCurrent]; ++iAddress )
+	{
+		pszAddressName = GetAddressName( iLineBoxCurrent, iAddress );
+
+		// if this address if fails, try the next one
+		if ( !pszAddressName )
+			continue; 
+
+		iItem = SendMessage (
+								hwndAddressBox,
+								CB_ADDSTRING,
+								0,
+								(LPARAM) (LPCSTR) (pszAddressName)
+							);
+
+		// error, bail out
+		if ( iItem == CB_ERR || iItem == CB_ERRSPACE )
+			return FALSE; 
+
+		errCode = SendMessage (
+								hwndAddressBox,
+								CB_SETITEMDATA,
+								(WPARAM) iItem,
+								(LPARAM) iAddress
+							  );
+
+		if ( iLineBoxCurrent == giCurrentLine )
+		{
+			if(iAddress == giCurrentAddress)
+			{
+				iItemCurrent = iItem;
+			}
+			else 
+			{
+				// if the item we are putting is before the
+				// "current" item, we must increment iItemCur
+				// to reflect that something is being placed
+				// before it, due to sorting
+				if ( iItemCurrent != -1 && iItem <= iItemCurrent )
+				{
+					++iItemCurrent; 
+				}
+			}
+		}
+
+		DialerFree( pszAddressName );
+	}
+	
+	if ( iLineBoxCurrent != giCurrentLine )
+	{	
+		// if we're not looking at the current line
+		// then highlight address 0
+		iItemCurrent = 0;
+	}
+
+	SendMessage (
+					hwndAddressBox,
+					CB_SETCURSEL,
+					iItemCurrent,
+					0
+				);
+	return TRUE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID ManageAssistedTelephony(VOID)
+{
+	DWORD errCode;
+	LPLINEREQMAKECALL lpRequestBuffer;
+
+	lpRequestBuffer = (LPLINEREQMAKECALL) DialerAlloc( sizeof( LINEREQMAKECALL ) );
+	if ( !lpRequestBuffer ) 
+	{
+		goto error;
+	}
+
+    // bring window to front
+    SetForegroundWindow(ghWndMain);
+    
+	// get next queued request.
+	errCode = lineGetRequest (
+								ghLineApp,
+								LINEREQUESTMODE_MAKECALL,
+								lpRequestBuffer
+	
+							 );
+	if ( errCode )
+	{
+		// if no more call requests pending, reset flag.
+		if ( errCode == LINEERR_NOREQUEST )
+		{
+			gfCallRequest = FALSE;
+		}
+		else
+		{
+			errString ( ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+		}
+		goto error;
+	}
+
+	
+	// if a line has not been selected
+	if ( giCurrentLine == (DWORD)-1 )
+	{
+		if (!DialogBoxParam (
+						ghInst,
+						MAKEINTRESOURCE(IDD_CONNECTUSING),
+						ghWndMain,
+						(DLGPROC) ConnectUsingProc,
+						INVALID_LINE
+					  ))
+        {
+            // failed to get a line
+            goto error;
+        }
+	}
+
+	// make the reuested call.
+	InitiateCall (
+					lpRequestBuffer->szDestAddress,
+					lpRequestBuffer->szCalledParty
+				 );
+
+error :
+	if ( lpRequestBuffer )
+	{
+		DialerFree( lpRequestBuffer );
+	}
+	return;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DialerLineClose()
+{
+	DWORD errCode;
+
+	if ( gCurrentLineInfo.hLine )
+	{
+		if ( errCode = lineClose ( gCurrentLineInfo.hLine ) )
+		{
+			errString ( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+		}
+		gCurrentLineInfo.hLine = NULL;
+	}
+
+
+	// re-initialize TAPI if it needs to be re-initialized
+	if ( gfNeedToReinit ) 
+	{
+		CloseTAPI();
+
+		errCode = InitializeTAPI();
+		if(errCode)
+		{
+			errString(ghWndMain, errCode, MB_APPLMODAL | MB_ICONEXCLAMATION );
+			DialerCleanup(); // terminate program if we can't init
+			return;
+		}
+
+		errCode = lineRegisterRequestRecipient (
+												ghLineApp,
+												0, 
+												LINEREQUESTMODE_MAKECALL,
+												TRUE
+											   );
+		if (errCode)
+		{
+			errString(ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+		}
+
+		gfNeedToReinit = FALSE;
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+int errString( HWND hWndOwner, UINT errCode, UINT uFlags )
+{
+	PTSTR ptStrTitle;
+	PTSTR ptStrError;
+	int   nResult;
+    BOOL  bDefault = FALSE;
+
+	ptStrTitle = DialerAlloc( MAXBUFSIZE );
+	if ( NULL == ptStrTitle )
+	{
+	   // Now, _this_ is a problem.
+	   return 0;
+	}
+
+	ptStrError = DialerAlloc( MAXBUFSIZE );
+	if ( NULL == ptStrError )
+	{
+	   // Now, _this_ is a problem.
+	   DialerFree( ptStrTitle);
+	   return 0;
+	}
+
+	switch(errCode)
+	{
+		case ERR_NOLINES:
+			errCode = ikszErrNoVoiceLine;
+			break;
+
+		case ERR_NOVOICELINE:
+			errCode = ikszErrNoVoiceLine;
+			break;
+    
+		case ERR_LINECLOSE:
+			errCode = ikszErrLineClose;
+			break;
+
+		case ERR_911WARN:
+			errCode = ikszWarningFor911;
+			break;
+    
+		case ERR_NEWDEFAULT:
+			errCode = ikszWarningNewDefault;
+			break;
+
+		case LINEERR_NODRIVER:
+			errCode = ikszErrLineInitNoDriver;
+			break;
+    
+		case LINEERR_NODEVICE:
+			errCode = ikszErrLineInitNoDevice;
+			break;
+    
+		case LINEERR_INIFILECORRUPT:
+			errCode = ikszErrLineInitBadIniFile ;
+			break;
+    
+		case LINEERR_NOMEM:
+			errCode = ikszErrOOM;
+			break;
+    
+		case LINEERR_INCOMPATIBLEAPIVERSION:
+			errCode = ikszErrLineInitWrongDrivers ;
+			break;
+    
+		case LINEERR_OPERATIONFAILED:
+			errCode = ikszErrTAPI;
+			break;
+    
+		case LINEERR_INVALADDRESS:
+			errCode = ikszErrInvalAddress;
+			break;
+    
+		case LINEERR_ADDRESSBLOCKED:
+			errCode = ikszErrAddrBlocked;
+			break;
+    
+		case LINEERR_BILLINGREJECTED:
+			errCode = ikszErrBillingRejected;
+			break;
+    
+		case LINEERR_RESOURCEUNAVAIL:
+		case LINEERR_ALLOCATED:
+		case LINEERR_INUSE:
+			errCode = ikszErrResUnavail;
+			break;
+    
+		case LINEERR_NOMULTIPLEINSTANCE:
+			errCode = ikszErrNoMultipleInstance;
+			break;
+    
+		case LINEERR_INVALCALLSTATE:
+			errCode = ikszErrInvalCallState;
+			break;
+
+        case LINEERR_INVALCOUNTRYCODE:
+            errCode = ikszErrInvalidCountryCode;
+            break;
+    
+		default:
+            bDefault = TRUE;
+            break;
+
+	}
+
+
+    if (bDefault)
+    {
+        // if using default error, get TAPI's
+        // error message from FormatError()
+        if (!FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+                           (LPCVOID)GetModuleHandle(TEXT("TAPI32.DLL")),
+                           (DWORD)TAPIERROR_FORMATMESSAGE(errCode),
+                           0,
+                           (LPTSTR)ptStrError,
+                           MAXBUFSIZE,
+                           NULL))
+        {
+            // if this fails, fall back on default
+            LoadString( ghInst, ikszErrDefault, ptStrError, MAXBUFSIZE);
+        }
+
+    }
+    else    // not the default error message
+    {
+
+        if ( 0 == LoadString( ghInst, errCode, ptStrError, MAXBUFSIZE ) )
+        {
+#if DBG
+            TCHAR buf[200];
+            wsprintf( buf, "Cannot load string: hinst:0x%08lx errcode: %ld", (DWORD)ghInst,(DWORD)errCode);
+            OutputDebugString( buf );
+            MessageBox( NULL, buf, "Dialer", MB_OK);
+#endif
+
+            LoadString( ghInst, ikszErrDefault, ptStrError, MAXBUFSIZE );
+        }
+    }
+
+    LoadString( ghInst, ikszWarningTitle, ptStrTitle, MAXBUFSIZE );
+
+	nResult = MessageBox( hWndOwner, ptStrError, ptStrTitle, uFlags );
+
+
+	DialerFree( ptStrTitle );
+	DialerFree( ptStrError );
+
+
+	return nResult;
+}
+
+
+/*
+ *	Name :
+ *		FitTextToButton 
+ *
+ *	Arguements :
+ *		hDlg 		handle for the dialog in which this button is embedded
+ *		nButtonID 	button id of this button
+ *		szName		Name to fit on the button. Max size TAPIMAXCALLEDPARTYSIZE
+ *
+ *	Return :
+ *		None
+ *
+ *	Comments :
+ *		Function first checks to see if the button text specified fits in the
+ *		button.  If it does not it truncates it appropriately and adds trailing
+ *		ellipses.  
+ */
+VOID FitTextToButton ( HWND hDlg, INT nButtonID, LPSTR szName )
+{
+
+	HDC hDC;
+	HFONT hFont, hOldFont;
+	HWND hWnd;
+
+	do
+	{
+		// calculate number of chars. that can fit on 
+		// the button
+		int	nLen;
+		RECT rect;
+		SIZE size;
+		POINT pt;
+		char buf [TAPIMAXCALLEDPARTYSIZE + 1];
+
+		// get button dimensions
+		hWnd = GetDlgItem( hDlg, nButtonID );
+		if ( hWnd == NULL )
+			break;
+
+		if ( !GetClientRect( hWnd, &rect ) )
+			break;
+		
+		// get character dimensions
+		hDC = GetDC( hWnd );
+		if ( hDC == NULL )
+			break;
+
+		hFont = (HFONT) SendMessage( hWnd, WM_GETFONT, 0, 0 );
+		if ( hFont == NULL )
+			hOldFont = SelectObject( hDC, GetStockObject( SYSTEM_FONT ) );
+		else
+			hOldFont = SelectObject( hDC, hFont );
+
+		// add an extra char at the end to compensate for
+		// leading space,
+		lstrcpy ( buf, szName );
+		nLen = lstrlen( buf );
+		buf [ nLen ] = 'X';
+		buf [ nLen + 1 ] = '\0';
+
+		if ( !GetTextExtentPoint32( hDC, buf, nLen + 1, &size ) )
+			break;
+
+		pt.x = size.cx;
+		if ( !LPtoDP( hDC, &pt, 1 ) )
+			break;
+
+		// check if name fits on button
+		if (  pt.x > rect.right )
+		{
+			// find how much of the name fits 
+			int i = 0;
+
+			nLen = lstrlen( szName );
+			for ( i = 0; i < nLen; i++ )
+			{
+				buf[ i ] = szName[ i ];
+				// an extra char is stuffed to compensate for the
+				// leading space left by the left alignment
+				buf [ i + 1 ] = 'X';
+				buf [ i + 2 ] = '\0';
+
+				// break out in cases of error condition
+				if ( !GetTextExtentPoint32( hDC, buf, i + 2, &size ) )
+				{
+					i = nLen;
+					break;
+				}
+
+				pt.x = size.cx;
+				if ( !LPtoDP( hDC, &pt, 1 ) )
+				{
+					i = nLen;
+					break;
+				}
+					
+				if ( pt.x > rect.right ) 
+					break;
+			}
+
+            // error
+			if ( i >= nLen )
+				break;
+
+			// name is too long. truncate and add ellipses
+			szName [i - 3] = '\0';
+			lstrcat( szName, "..." );
+		}
+
+	} while( FALSE );
+
+	if ( hDC )
+	{
+		SelectObject( hDC, hOldFont );
+		ReleaseDC( hWnd, hDC );
+	}
+
+	return;
+}
+
+
+
+/*
+ *	Name :
+ *		Is911
+ *
+ *	Arguements :
+ *		lpTransOut -		Translated address contained the dialable string
+ *
+ *	Returns
+ *		TRUE -				If number to be dialed (in the US) is prefixed by 911 
+ *		FALSE -				Otherwise
+ *
+ * Comments
+ *
+ */
+BOOL Is911 ( LPLINETRANSLATEOUTPUT lpTransOut )
+{
+
+	DWORD i = 0, j = 0;	
+	LPSTR lpDialDigits = (LPSTR)lpTransOut + lpTransOut-> dwDialableStringOffset;
+	char sz3Pref [ 4 ] = "";
+
+
+	// if this is not the US
+	if ( lpTransOut-> dwCurrentCountry != 1 )
+		return FALSE;
+
+	// skip non digit characters and extract
+	// the first 3 digits in the dialable number
+	for ( i = 0, j = 0; i < lpTransOut-> dwDialableStringSize ; i++ )
+	{
+		if ( ISDIGIT( lpDialDigits[i] ) )
+		{
+			sz3Pref[ j++ ] = lpDialDigits [ i ];
+			sz3Pref[ j ] = '\0'; 
+			if ( j == 3 )
+				break;
+		}
+	}
+
+	if ( !lstrcmp( sz3Pref, "911" ) )
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+/*
+ *	Name :
+ *		MakeCanonicalNumber
+ *
+ *	Arguements :
+ *		szNumber 		Number to convert into canonical form. Max size TAPIMAXDESTADDRESSSIZE
+ *		szCanNumber		Canonical representation of number specified in szNumber
+ *
+ *	Return :
+ *		TRUE			If the conversion was successful.
+ *		FALSE			otherwise
+ *
+ *	Comments :
+ *		Function first checks if given number is already in canonical form.
+ *		If it is, it returns.  If it is not, then it performs the conversion.
+ */
+ 
+BOOL MakeCanonicalNumber ( LPCSTR szNumber, LPSTR szCanNumber )
+{
+	char szDigits [ TAPIMAXDESTADDRESSSIZE ];
+	char szPref [ TAPIMAXDESTADDRESSSIZE ];
+
+	BOOL bRes = FALSE;
+
+	INT errCode = -1;
+	INT nLenPref, nLenDigits, cPos, i;
+
+	DWORD dwSize = 0;
+	DWORD dwInd = 0;
+
+	LPLINETRANSLATEOUTPUT lpTransOut = NULL;
+	LPLINETRANSLATECAPS lpTransCaps = NULL;
+
+
+	dwSize = sizeof ( LINETRANSLATEOUTPUT );
+	do
+	{
+		lpTransOut = ( LPLINETRANSLATEOUTPUT ) DialerAlloc ( dwSize );
+		if ( !lpTransOut )
+		{
+			errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+			goto error;
+		}
+			
+		lpTransOut-> dwTotalSize = dwSize;
+		errCode = lineTranslateAddress (
+											ghLineApp,
+											giCurrentLine,
+											gCurrentLineInfo.dwAPIVersion,
+											szNumber,
+											0,
+											0,
+											lpTransOut
+									   );
+		if ( errCode )
+		{
+			goto error;
+		}
+
+		if ( lpTransOut-> dwNeededSize <= lpTransOut-> dwTotalSize )
+			break;
+
+		dwSize = lpTransOut-> dwNeededSize;
+		DialerFree( lpTransOut );
+
+	} while( TRUE );
+
+	
+	// check if input number is already in 
+	// canonical form.
+	if ( lpTransOut-> dwTranslateResults & LINETRANSLATERESULT_CANONICAL )
+		goto error;
+
+	// ensure country is the USA.
+	if ( lpTransOut-> dwCurrentCountry != 1 )
+		goto error;
+
+
+	// Extract the digits from given string
+	// allowed formatting characters that are ignored are
+	// space, (, ), -, . 
+	// presence of other characters will render the string invalid.
+	
+	// find the prefix of the address upto the | mark.
+	// the rest of the string can be ignored
+	nLenPref = strcspn ( szNumber, "|" );
+	strncpy( szPref, szNumber, nLenPref );
+	szPref[ nLenPref ] = '\0';
+
+	// if string is not composed entirely of digits
+	// and allowable formating characters, quit conversion
+	if ( strspn( szPref, " 0123456789()-." ) != (size_t) nLenPref )
+		goto error;
+
+	// collect digits ignoring formating characters.
+	szDigits[ 0 ] = '\0';
+	for ( i = 0, nLenDigits = 0; i < nLenPref; i++ )
+	{
+		if ( ISDIGIT( szNumber[ i ] ) )
+		{
+			szDigits[ nLenDigits++ ] = szNumber[ i ];
+		}
+	}
+	szDigits[ nLenDigits ] = '\0';
+
+	// if "internal" number
+	if ( nLenDigits < LOCAL_NUMBER )
+		goto error;
+
+	switch ( nLenDigits )
+	{
+		// Local number ( 7 digits) preceeded by a 0/1
+		// Strip leading 0/1 and treat as a local number
+		case EXTENDED_LOCAL_NUMBER:
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' )
+			{
+				nLenDigits--;
+				memmove( szDigits, &(szDigits[1]), nLenDigits );
+				szDigits[ nLenDigits ] = '\0';
+
+				cPos = strcspn( szPref, "01" );
+				nLenPref--;
+				memmove( &(szPref[ cPos ]), &(szPref[ cPos + 1 ]), nLenPref - cPos );
+				szPref[ nLenPref ] = '\0';
+			}
+			else
+			{
+				goto error;
+			}
+
+		case LOCAL_NUMBER :
+		{
+			LPLINELOCATIONENTRY lpLocLst;
+
+			// if leading digit is 0 or 1, it is 
+			// illegal in the US
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' )
+			{
+				goto error;
+			}
+
+			// get area code nformation for local number
+			dwSize = sizeof( LINETRANSLATECAPS );
+			do
+			{
+				lpTransCaps = (LPLINETRANSLATECAPS) DialerAlloc( dwSize );
+				if ( !lpTransCaps )
+				{
+					errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+					goto error;
+				}
+
+				lpTransCaps-> dwTotalSize = dwSize;
+				errCode = lineGetTranslateCaps (
+												ghLineApp,
+												gCurrentLineInfo.dwAPIVersion,
+												lpTransCaps
+											   );
+				if ( errCode )
+				{
+					errString( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+					goto error;
+				}
+
+				if ( lpTransCaps-> dwNeededSize <= lpTransCaps-> dwTotalSize )
+				{
+					break;
+				}
+
+				dwSize = lpTransCaps-> dwNeededSize;
+				DialerFree( lpTransCaps );
+
+			} while ( TRUE );
+
+			// skip entries till you locate information for current location
+			dwSize = sizeof( LINELOCATIONENTRY );
+			lpLocLst = (LPLINELOCATIONENTRY) ( (LPSTR) lpTransCaps + 
+												lpTransCaps-> dwLocationListOffset );
+
+			for ( dwInd = 0; dwInd < lpTransCaps-> dwNumLocations ; dwInd++ )
+			{
+				if ( lpLocLst[ dwInd ].dwPermanentLocationID == lpTransCaps-> dwCurrentLocationID )
+					break;
+			}
+			
+			// current location no found ?????
+			// login error
+			if ( dwInd == lpTransCaps-> dwNumLocations )
+			{
+				goto error;
+			}
+
+			// construct canonical form as
+			szCanNumber[ 0 ]= '\0';
+			lstrcat( szCanNumber, "+1 (" );
+			lstrcat( szCanNumber, (LPSTR) lpTransCaps + lpLocLst[ dwInd ].dwCityCodeOffset );
+			lstrcat( szCanNumber, ") " );
+			lstrcat( szCanNumber, szDigits );
+
+			cPos = strcspn( szNumber, "|" );
+			if ( cPos != lstrlen( szNumber ) )
+			{
+				lstrcat( szCanNumber, &(szNumber[ cPos ]) );
+			}
+
+			bRes = TRUE;
+			break;
+		}
+
+		case EXTENDED_LONG_DISTANCE_NUMBER:
+		{
+			// Long distance number ( 10 digits) preceeded by a 0/1
+			// Strip leading 0/1 and treat as a long distance number
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' )
+			{
+				nLenDigits--;
+				memmove( szDigits, &(szDigits[1]), nLenDigits );
+				szDigits[ nLenDigits ] = '\0';
+
+				cPos = strcspn( szPref, "01" );
+				nLenPref--;
+				memmove( &(szPref[ cPos ]), &(szPref[ cPos + 1 ]), nLenPref - cPos );
+				szPref[ nLenPref ] = '\0';
+			}
+			else
+			{
+				goto error;
+			}
+
+		}
+
+		case LONG_DISTANCE_NUMBER:
+		{
+			// if first or fourth digit is 0/1, illegal number
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' ||
+				 szDigits[ 3 ] == '0' || szDigits[ 3 ] == '1' )
+			{
+				goto error;
+			}
+			
+			szCanNumber[ 0 ] = '\0';
+			lstrcat( szCanNumber, "+1 (" );
+			strncat( szCanNumber, szDigits, 3 );
+			lstrcat( szCanNumber, ") " );
+
+			lstrcat( szCanNumber, &(szDigits[ 3 ]) );
+		
+			bRes = TRUE;
+		}
+		break;
+
+		default :
+			goto error;
+	}
+
+error:
+	if ( lpTransOut )
+		DialerFree( lpTransOut );
+
+	if ( lpTransCaps )
+		DialerFree( lpTransCaps );
+
+	return bRes;
+}
+
+
+/*
+ *	Name :
+ *		AmpersandCompensate
+ *
+ *	Arguements :
+ *		lpszSrc		:	Src string containing &s
+ *		lpszDst		:	Dest string   
+ *
+ *	Return :
+ *
+ *	Comments :
+ *		Copies string pointed to by lpszSrc to lpszDst character by
+ *		character.  If an & is encountered in this process in lpszSrc
+ *		it is copied as && into lpszDst.
+ *		Assumes lpszDst and lpszSrc are of size TAPIMAXCALLEDPARTYSIZE
+ */
+VOID AmpersandCompensate ( LPCSTR lpszSrc, LPSTR lpszDst )
+{
+	// check if the name has an & in it.  If so replace
+	// it with &&.
+	INT cCnt, cInd;
+
+	for ( cCnt = 0, cInd = 0; 
+		  cInd < TAPIMAXCALLEDPARTYSIZE; 
+		  cInd++, cCnt++ )
+	{
+		if ( lpszSrc[ cCnt ] == '&' )
+		{
+			lpszDst[ cInd++ ] = '&';
+		}
+		lpszDst[ cInd ] = lpszSrc[ cCnt ];
+
+		if ( lpszSrc[ cCnt ] == '\0' )
+			break;
+	}
+
+	// make sure string is null terminated.
+	lpszDst[ TAPIMAXCALLEDPARTYSIZE - 1 ] = '\0';
+
+	return;
+}
+
+
+ /*
+ *	Name :
+ *		AmpersandDeCompensate
+ *
+ *	Arguements :
+ *		lpszSrc		:	Src string containing &s
+ *		lpszDst		:	Dest string   
+ *
+ *	Return :
+ *
+ *	Comments :
+ *		Copies string pointed to by lpszSrc to lpszDst character by
+ *		character.  If an && is encountered in this process in lpszSrc
+ *		it is copied as & into lpszDst.
+ *		Assumes lpszDst and lpszSrc are of size TAPIMAXCALLEDPARTYSIZE
+ */
+ VOID AmpersandDeCompensate ( LPCSTR lpszSrc, LPSTR lpszDst )
+ {
+	// check if the name has an & in it.  If so replace
+	// it with &&.
+	INT cCnt, cInd;
+
+	for ( cCnt = 0, cInd = 0; 
+		  cInd < TAPIMAXCALLEDPARTYSIZE; 
+		  cInd++, cCnt++ )
+	{
+		if  ( ( lpszSrc[ cInd ] == '&' ) &&
+			  ( lpszSrc[ cInd + 1 ] == '&' ) )
+		{
+			cInd++;
+		}
+		lpszDst[ cCnt ] = lpszSrc[ cInd ] ;
+
+		if ( lpszSrc [ cInd ] == '\0' )
+		{
+			break;
+		}
+	}
+
+	lpszDst[ TAPIMAXCALLEDPARTYSIZE - 1 ] = '\0';
+
+	return;
+ }
diff --git a/private/tapi/dev/apps/dialer/dialer.def b/private/tapi/dev/apps/dialer/dialer.def
new file mode 100644
index 000000000..b40ab0af1
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialer.def
@@ -0,0 +1,9 @@
+NAME         DIALER
+;STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD   MOVEABLE MULTIPLE
+HEAPSIZE     2048
+STACKSIZE    8192
+
+EXPORTS
+    MainWndProc
diff --git a/private/tapi/dev/apps/dialer/dialer.h b/private/tapi/dev/apps/dialer/dialer.h
new file mode 100644
index 000000000..6f5832862
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialer.h
@@ -0,0 +1,51 @@
+/*++ BUILD Version: 0001    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    dialer.h
+
+Abstract:
+
+    Header file for dialer
+
+Author:
+
+    Dan Knudson (DanKn)        05-Apr-1995
+
+Revision History:
+
+    Jeremy Horwitz (t-jereh)   30-May-1995
+
+--*/
+
+
+#define TAPI_VERSION_1_0 0x00010003
+#define TAPI_VERSION_1_4 0x00010004
+#define TAPI_VERSION_2_0 0x00020000
+#define TAPI_CURRENT_VERSION TAPI_VERSION_2_0
+
+#include <windows.h>
+#include "tapi.h"
+#include "resource.h"
+#include "dialhelp.h"
+
+
+#define MENU_CHOICE         1 // for Connect Using dialog...
+#define INVALID_LINE        2 // if INVALID_LINE, turn off CANCEL
+                              // button and add extra text...
+
+#define MAXNUMLENGTH    64
+#define MAXBUFSIZE      256
+#define NSPEEDDIALS     8 // Dialer supports 8 configurable speed dial entries.
+#define NLASTDIALED     20 // Dialer keeps track of the 20 last dialed numbers.
+
+#define ERR_NONE        0
+#define ERR_NOVOICELINE 1
+#define ERR_LINECLOSE   2
+#define ERR_NOLINES     3
+#define	ERR_911WARN		4
+#define ERR_NEWDEFAULT	5
+
+#define itoa(x,y,z) _itoa(x,y,z)
diff --git a/private/tapi/dev/apps/dialer/dialer.ico b/private/tapi/dev/apps/dialer/dialer.ico
new file mode 100644
index 000000000..44ccbca29
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialer.ico
diff --git a/private/tapi/dev/apps/dialer/dialer.mak b/private/tapi/dev/apps/dialer/dialer.mak
new file mode 100644
index 000000000..3c4a04bea
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialer.mak
@@ -0,0 +1,389 @@
+# Microsoft Visual C++ Generated NMAKE File, Format Version 2.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+# TARGTYPE "Win32 (MIPS) Application" 0x0501
+
+!IF "$(CFG)" == ""
+CFG=Win32 (80x86) Debug
+!MESSAGE No configuration specified.  Defaulting to Win32 (80x86) Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "Win32 (80x86) Release" && "$(CFG)" != "Win32 (80x86) Debug" &&\
+ "$(CFG)" != "Win32 (MIPS) Debug" && "$(CFG)" != "Win32 (MIPS) Release"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "dialer.mak" CFG="Win32 (80x86) Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Win32 (80x86) Release" (based on "Win32 (x86) Application")
+!MESSAGE "Win32 (80x86) Debug" (based on "Win32 (x86) Application")
+!MESSAGE "Win32 (MIPS) Debug" (based on "Win32 (MIPS) Application")
+!MESSAGE "Win32 (MIPS) Release" (based on "Win32 (MIPS) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "Win32 (MIPS) Debug"
+
+!IF  "$(CFG)" == "Win32 (80x86) Release"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "WinRel"
+# PROP BASE Intermediate_Dir "WinRel"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "WinRel"
+# PROP Intermediate_Dir "WinRel"
+OUTDIR=.\WinRel
+INTDIR=.\WinRel
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /W3 /GX /YX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /FR /c
+CPP_PROJ=/nologo /W3 /GX /YX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "_MBCS" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/ /c 
+CPP_OBJS=.\WinRel/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"DIALER.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+	$(INTDIR)/DIALER.SBR
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib mfc30.lib mfco30.lib mfcd30.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:I386
+# ADD LINK32 tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:I386
+LINK32_FLAGS=tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /INCREMENTAL:no\
+ /PDB:$(OUTDIR)/"dialer.pdb" /MACHINE:I386 /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+	$(INTDIR)/DIALER.res \
+	$(INTDIR)/DIALER.OBJ
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 (80x86) Debug"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "WinDebug"
+# PROP BASE Intermediate_Dir "WinDebug"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "WinDebug"
+# PROP Intermediate_Dir "WinDebug"
+OUTDIR=.\WinDebug
+INTDIR=.\WinDebug
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /FR /c
+CPP_PROJ=/nologo /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "_MBCS" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/\
+ /Fd$(OUTDIR)/"dialer.pdb" /c 
+CPP_OBJS=.\WinDebug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"DIALER.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+	$(INTDIR)/DIALER.SBR
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib mfc30d.lib mfco30d.lib mfcd30d.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:I386
+# ADD LINK32 tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:I386
+LINK32_FLAGS=tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /INCREMENTAL:yes\
+ /PDB:$(OUTDIR)/"dialer.pdb" /DEBUG /MACHINE:I386 /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+	$(INTDIR)/DIALER.res \
+	$(INTDIR)/DIALER.OBJ
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Debug"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 1
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "WinDebug"
+# PROP Intermediate_Dir "WinDebug"
+OUTDIR=.\WinDebug
+INTDIR=.\WinDebug
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32  
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /Gt0 /QMOb2000 /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /Gt0 /QMOb2000 /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "WIN32" /FR /c
+CPP_PROJ=/nologo /Gt0 /QMOb2000 /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS"\
+ /D "_MBCS" /D "WIN32" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/\
+ /Fd$(OUTDIR)/"dialer.pdb" /c 
+CPP_OBJS=.\WinDebug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"dialer.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+        $(INTDIR)/dialer.sbr
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib odbc32.lib mfc30d.lib mfco30d.lib mfcd30d.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:MIPS
+# ADD LINK32 version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:MIPS
+LINK32_FLAGS=version.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO\
+ /SUBSYSTEM:windows /PDB:$(OUTDIR)/"dialer.pdb" /DEBUG /MACHINE:MIPS\
+ /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+        $(INTDIR)/dialer.res \
+        $(INTDIR)/dialer.obj
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Release"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 0
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "WinRel"
+# PROP Intermediate_Dir "WinRel"
+OUTDIR=.\WinRel
+INTDIR=.\WinRel
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /Gt0 /QMOb2000 /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /Gt0 /QMOb2000 /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "WIN32" /FR /c
+CPP_PROJ=/nologo /Gt0 /QMOb2000 /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D\
+ "_MBCS" /D "WIN32" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/ /c 
+CPP_OBJS=.\WinRel/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"dialer.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+        $(INTDIR)/dialer.sbr
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib odbc32.lib mfc30.lib mfco30.lib mfcd30.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:MIPS
+# ADD LINK32 version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:MIPS
+LINK32_FLAGS=version.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO\
+ /SUBSYSTEM:windows /PDB:$(OUTDIR)/"dialer.pdb" /MACHINE:MIPS\
+ /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+        $(INTDIR)/dialer.res \
+        $(INTDIR)/dialer.obj
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+################################################################################
+# Begin Group "Source Files"
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\DIALER.RC
+DEP_DIALE=\
+	.\dialer.ico
+
+!IF  "$(CFG)" == "Win32 (80x86) Release"
+
+$(INTDIR)/DIALER.res :  $(SOURCE)  $(DEP_DIALE) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ELSEIF  "$(CFG)" == "Win32 (80x86) Debug"
+
+$(INTDIR)/DIALER.res :  $(SOURCE)  $(DEP_DIALE) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Debug"
+
+$(INTDIR)/dialer.res :  $(SOURCE)  $(DEP_GENER) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Release"
+
+$(INTDIR)/dialer.res :  $(SOURCE)  $(DEP_GENER) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\DIALER.C
+DEP_DIALER=\
+	.\DIALER.H\
+        ..\..\INC\TAPI.H\
+	.\dialhelp.h
+
+!IF  "$(CFG)" == "Win32 (80x86) Release"
+
+$(INTDIR)/DIALER.OBJ :  $(SOURCE)  $(DEP_DIALER) $(INTDIR)
+
+!ELSEIF  "$(CFG)" == "Win32 (80x86) Debug"
+
+$(INTDIR)/DIALER.OBJ :  $(SOURCE)  $(DEP_DIALER) $(INTDIR)
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Debug"
+
+$(INTDIR)/dialer.obj :  $(SOURCE)  $(DEP_GENERI) $(INTDIR)
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Release"
+
+$(INTDIR)/dialer.obj :  $(SOURCE)  $(DEP_GENERI) $(INTDIR)
+
+!ENDIF 
+
+# End Source File
+# End Group
+# End Project
+################################################################################
diff --git a/private/tapi/dev/apps/dialer/dialer.rc b/private/tapi/dev/apps/dialer/dialer.rc
new file mode 100644
index 000000000..d1e73947e
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialer.rc
@@ -0,0 +1,452 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "windows.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""windows.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALER DIALOG PRELOAD DISCARDABLE  50, 50, 194, 168
+STYLE DS_3DLOOK | WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU
+CAPTION "Phone Dialer"
+MENU IDM_MENU
+CLASS "DialerClass"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    CONTROL         "",IDD_DRECTSEPARATOR,"Static",SS_ETCHEDHORZ | 
+                    WS_DISABLED,0,0,194,1
+    LTEXT           "&Number to dial:",IDD_DNUMTODIAL,7,7,90,10
+    COMBOBOX        IDD_DCOMBO,7,21,90,104,CBS_DROPDOWN | CBS_AUTOHSCROLL | 
+                    WS_VSCROLL | WS_GROUP | WS_TABSTOP | ES_NOHIDESEL
+    DEFPUSHBUTTON   "&Dial",IDD_DDIAL,7,38,90,14,WS_DISABLED | WS_GROUP
+    CONTROL         "\n1",IDD_DBUTTON1,"Button",BS_OWNERDRAW,14,62,23,20
+    CONTROL         "ABC\n2",IDD_DBUTTON2,"Button",BS_OWNERDRAW,40,62,23,20
+    CONTROL         "DEF\n3",IDD_DBUTTON3,"Button",BS_OWNERDRAW,66,62,23,20
+    CONTROL         "GHI\n4",IDD_DBUTTON4,"Button",BS_OWNERDRAW,14,86,23,20
+    CONTROL         "JKL\n5",IDD_DBUTTON5,"Button",BS_OWNERDRAW,40,86,23,20
+    CONTROL         "MNO\n6",IDD_DBUTTON6,"Button",BS_OWNERDRAW,66,86,23,20
+    CONTROL         "PQRS\n7",IDD_DBUTTON7,"Button",BS_OWNERDRAW,14,110,23,
+                    20
+    CONTROL         "TUV\n8",IDD_DBUTTON8,"Button",BS_OWNERDRAW,40,110,23,20
+    CONTROL         "WXYZ\n9",IDD_DBUTTON9,"Button",BS_OWNERDRAW,66,110,23,
+                    20
+    CONTROL         "\n*",IDD_DBUTTONSTAR,"Button",BS_OWNERDRAW,14,134,23,20
+    CONTROL         "\n0",IDD_DBUTTON0,"Button",BS_OWNERDRAW,40,134,23,20
+    CONTROL         "\n#",IDD_DBUTTONPOUND,"Button",BS_OWNERDRAW,66,134,23,
+                    20
+    GROUPBOX        "Speed dial",IDD_DSPEEDDIALGRP,103,7,84,154
+    LTEXT           "&1",IDD_DSPEEDDIALTEXT1,109,24,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL1,117,21,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&2",IDD_DSPEEDDIALTEXT2,109,41,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL2,117,38,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&3",IDD_DSPEEDDIALTEXT3,109,58,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL3,117,55,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&4",IDD_DSPEEDDIALTEXT4,109,75,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL4,117,72,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&5",IDD_DSPEEDDIALTEXT5,109,92,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL5,117,89,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&6",IDD_DSPEEDDIALTEXT6,109,109,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL6,117,106,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&7",IDD_DSPEEDDIALTEXT7,109,126,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL7,117,123,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&8",IDD_DSPEEDDIALTEXT8,109,143,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL8,117,140,63,14,BS_LEFT | WS_GROUP
+END
+
+IDD_SD1 DIALOG DISCARDABLE  12, 29, 165, 173
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Edit Speed Dial"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Choose a button from the group below.",
+                    IDD_SD1TEXTCHOOSE,7,7,140,10
+    LTEXT           "1",IDD_SD1SPEEDDIALTEXT1,7,27,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL1,16,24,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "2",IDD_SD1SPEEDDIALTEXT2,7,44,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL2,16,41,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "3",IDD_SD1SPEEDDIALTEXT3,7,61,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL3,16,58,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "4",IDD_SD1SPEEDDIALTEXT4,7,78,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL4,16,75,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "5",IDD_SD1SPEEDDIALTEXT5,86,27,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL5,95,24,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "6",IDD_SD1SPEEDDIALTEXT6,86,44,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL6,95,41,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "7",IDD_SD1SPEEDDIALTEXT7,86,61,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL7,95,58,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "8",IDD_SD1SPEEDDIALTEXT8,86,78,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL8,95,75,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "",IDD_SD1RECTSEPARATOR,7,96,151,8,WS_DISABLED | NOT 
+                    WS_GROUP
+    LTEXT           "Enter a name and number for the selected button.",
+                    IDD_SD1TEXTENTER,7,104,160,10
+    LTEXT           "&Name:",IDD_SD1TEXTNAME,16,119,29,10
+    EDITTEXT        IDD_SD1EDITNAME,16,130,63,14,ES_AUTOHSCROLL
+    LTEXT           "N&umber to dial:",IDD_SD1TEXTNUMBER,95,119,53,10
+    EDITTEXT        IDD_SD1EDITNUMBER,95,130,63,14,ES_AUTOHSCROLL
+    PUSHBUTTON      "&Save",IDOK,55,152,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,108,152,50,14
+END
+
+IDD_SD2 DIALOG DISCARDABLE  12, 29, 158, 91
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Program Speed Dial"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Enter a name and number to save on this button.",
+                    IDD_SD2TEXTENTER,7,7,85,21
+    DEFPUSHBUTTON   "&Save",IDOK,98,7,53,14,WS_GROUP
+    PUSHBUTTON      "Save and &Dial",IDD_SD2SAVEANDDIAL,98,24,53,14,
+                    WS_DISABLED | WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,98,41,53,14
+    LTEXT           "&Name:",IDD_SD2TEXTNAME,7,30,29,10
+    EDITTEXT        IDD_SD2EDITNAME,7,41,63,14,ES_AUTOHSCROLL
+    LTEXT           "N&umber to dial:",IDD_SD2TEXTNUMBER,7,59,53,10
+    EDITTEXT        IDD_SD2EDITNUMBER,7,70,63,14,ES_AUTOHSCROLL
+END
+
+IDD_CONNECTUSING DIALOG PRELOAD DISCARDABLE  50, 50, 260, 105
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Connect Using"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Line:",IDD_CUTEXTLINE,7,16,79,10,NOT WS_GROUP
+    COMBOBOX        IDD_CULISTLINE,7,27,173,97,CBS_DROPDOWNLIST | CBS_SORT | 
+                    WS_GROUP | WS_TABSTOP | WS_VSCROLL
+    LTEXT           "&Address:",IDD_CUTEXTADDRESS,7,43,79,10,NOT WS_GROUP
+    COMBOBOX        IDD_CULISTADDRESS,7,53,173,82,CBS_DROPDOWNLIST | 
+                    CBS_SORT | WS_GROUP | WS_TABSTOP | WS_VSCROLL
+    CONTROL         "Use Phone Dialer to handle &voice call requests from other programs",
+                    IDD_CUSIMPLETAPICHKBOX,"Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,7,72,230,10
+    PUSHBUTTON      "Line &Properties...",IDD_CUPROPERTIES,190,26,63,14
+    DEFPUSHBUTTON   "OK",IDOK,146,84,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,203,84,50,14,WS_GROUP
+END
+
+IDD_ABOUT DIALOG DISCARDABLE  22, 38, 227, 100
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "About Phone Dialer"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    ICON            IDI_DIALER,IDD_AICON,10,5,18,20
+    LTEXT           "",IDD_ATEXTTITLE,38,5,127,10,SS_NOPREFIX | NOT WS_GROUP
+    LTEXT           "Copyright © 1993-1995  Microsoft.  All Rights Reserved.",
+                    IDD_ATEXTCOPYRIGHT,38,35,179,20,SS_NOPREFIX | NOT 
+                    WS_GROUP
+    LTEXT           "",-1,38,60,172,1,NOT WS_GROUP
+    LTEXT           "Memory:",-1,38,75,70,10,SS_NOPREFIX | NOT WS_GROUP
+    LTEXT           "%lu KB Free",IDD_ATEXTFREEMEM,120,75,74,10,SS_NOPREFIX | 
+                    NOT WS_GROUP
+    DEFPUSHBUTTON   "OK",IDOK,177,5,40,14
+    LTEXT           "System resources:",-1,38,85,70,10,SS_NOPREFIX | NOT 
+                    WS_GROUP
+    LTEXT           "%d%%",IDD_ATEXTRESOURCE,120,85,74,10,SS_NOPREFIX | NOT 
+                    WS_GROUP
+END
+
+IDD_INUSE DIALOG DISCARDABLE  22, 38, 199, 81
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Line In Use"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,36,58,53,16
+    ICON            IDI_LINEBUSY,IDD_IUICON,10,5,18,20
+    LTEXT           "The selected line or address is in use by another program or device on the line. Your call can not be placed at this time.",
+                    IDD_IUTEXT1,45,5,144,27,SS_NOPREFIX | NOT WS_GROUP
+    LTEXT           "Try your call again later.",IDD_IUTEXT2,45,40,114,12,
+                    SS_NOPREFIX | NOT WS_GROUP
+END
+
+IDD_CALLFAILED DIALOG DISCARDABLE  22, 38, 199, 73
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Call Failed"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,72,50,53,16
+    ICON            IDI_LINEBUSY,IDD_IUICON,10,5,18,20
+    LTEXT           "",IDD_CFTEXT,45,5,144,40,SS_NOPREFIX | NOT WS_GROUP
+END
+
+IDD_DIALING DIALOG DISCARDABLE  0, 0, 172, 62
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION
+CAPTION "Dialing"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    PUSHBUTTON      "&Hang Up",IDCANCEL,9,37,50,14
+    RTEXT           "Currently dialing:",IDD_DGNUMBER,9,9,52,9
+    LTEXT           "",IDD_DGNUMBERTEXT,63,9,100,9
+    LTEXT           "",IDD_DGNAMETEXT,63,23,100,9
+END
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDM_MENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "E&xit",                       IDM_EXIT
+    END
+    POPUP "&Edit"
+    BEGIN
+        MENUITEM "Cu&t\tCtrl+X",                IDM_EDIT_CUT
+        MENUITEM "&Copy\tCtrl+C",               IDM_EDIT_COPY
+        MENUITEM "&Paste\tCtrl+V",              IDM_EDIT_PASTE
+        MENUITEM "&Delete\tDel",                IDM_EDIT_DELETE
+        MENUITEM SEPARATOR
+        MENUITEM "&Speed Dial...",              IDM_EDIT_SPEEDDIAL
+    END
+    POPUP "&Tools"
+    BEGIN
+        MENUITEM "&Connect Using...",           IDM_CONNECTUSING
+        MENUITEM "&Dialing Properties...",      IDM_LOCATION
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Help Topics",                IDM_HELP_CONTENTS
+        MENUITEM "&What's This?",               IDM_HELP_WHATSTHIS
+        MENUITEM SEPARATOR
+        MENUITEM "&About Phone Dialer",         IDM_ABOUT
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+#if WINNT
+IDI_DIALER              ICON    DISCARDABLE     "DIALER.ICO"
+IDI_LINEBUSY            ICON    DISCARDABLE     "LINEBUSY.ICO"
+#else
+IDI_DIALER              ICON    DISCARDABLE     "..\\DIALER.ICO"
+IDI_LINEBUSY            ICON    DISCARDABLE     "..\\LINEBUSY.ICO"
+#endif
+/////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDA_DIALER ACCELERATORS DISCARDABLE 
+BEGIN
+    "1",            IDD_DSPEEDDIAL1,        VIRTKEY, ALT, NOINVERT
+    "2",            IDD_DSPEEDDIAL2,        VIRTKEY, ALT, NOINVERT
+    "3",            IDD_DSPEEDDIAL3,        VIRTKEY, ALT, NOINVERT
+    "4",            IDD_DSPEEDDIAL4,        VIRTKEY, ALT, NOINVERT
+    "5",            IDD_DSPEEDDIAL5,        VIRTKEY, ALT, NOINVERT
+    "6",            IDD_DSPEEDDIAL6,        VIRTKEY, ALT, NOINVERT
+    "7",            IDD_DSPEEDDIAL7,        VIRTKEY, ALT, NOINVERT
+    "8",            IDD_DSPEEDDIAL8,        VIRTKEY, ALT, NOINVERT
+    "C",            IDM_EDIT_COPY,          VIRTKEY, CONTROL, NOINVERT
+    "D",            IDD_DDIAL,              VIRTKEY, ALT, NOINVERT
+    "N",            IDM_ACCEL_NUMTODIAL,    VIRTKEY, ALT, NOINVERT
+    "V",            IDM_EDIT_PASTE,         VIRTKEY, CONTROL, NOINVERT
+    VK_INSERT,      IDM_EDIT_PASTE,         VIRTKEY, SHIFT, NOINVERT
+    "X",            IDM_EDIT_CUT,           VIRTKEY, CONTROL, NOINVERT
+END
+
+
+#ifndef _MAC
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+
+
+#ifdef SDKRELEASE
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 4,0,1259,1
+ PRODUCTVERSION 4,0,1259,1
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904B0"
+        BEGIN
+            VALUE "CompanyName", "Microsoft Corporation\0"
+            VALUE "FileDescription", "Microsoft® Windows(TM) Phone Dialer\0"
+            VALUE "FileVersion", "4.00\0"
+            VALUE "InternalName", "Phone Dialer\0"
+            VALUE "LegalCopyright", "Copyright © Microsoft Corporation 1996.  All Rights Reserved.\0"
+            VALUE "OriginalFilename", "dialer.exe\0"
+            VALUE "ProductName", "Microsoft(R) Windows NT(TM) Operating System\0"
+            VALUE "ProductVersion", "4.00\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+
+#else
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Phone Dialer"
+#define VER_INTERNALNAME_STR        "Dialer"
+#define VER_ORIGINALFILENAME_STR    "DIALER.EXE"
+//#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1996.  All Rights Reserved."
+#define VER_LEGALCOPYRIGHT_YEARS    "1996"
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+
+#endif
+
+
+#endif    // !_MAC
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszAppName             "Dialer"
+    ikszAppFriendlyName     "Phone Dialer"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszErrDefault          "An internal error occurred in Phone Dialer.\nQuit and restart Phone Dialer."
+    ikszErrOOM              "There was not enough memory to continue.\nQuit one or more programs, and then try again."
+    ikszErrTAPI             "Windows Telephony was unable to complete an operation requested by Phone Dialer.\nQuit and restart Phone Dialer."
+    ikszErrNoVoiceLine      "Phone Dialer was unable to find a telephone device or modem to use to dial voice calls.\nIn Control Panel, double-click the Modems icon to install a modem, or install another telephone device to use for dialing calls."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszWarningTapiReInit   "Phone Dialer cannot successfully start.\nQuit all other telephony programs, and then try again."
+    ikszErrLineClose        "Your call was cancelled because the Telephony device driver closed the line."
+    ikszDisconnectedNoDialTone 
+                            "A dial tone was not detected. Please check your telephone cable connections, and be sure the line is not in use by someone else."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszErrLineInitBadIniFile 
+                            "Configuration information relating to Telephony services appears to be corrupt.\nPlease check the configuration of telephone devices in the control panel."
+    ikszErrLineInitNoDriver "One of the components of the Telephony device driver is missing.\nUse the Control Panel to set up the driver properly."
+    ikszErrLineInitNoDevice "The selected device has been removed from your computer. Please select a different device for dialing."
+    ikszErrNoMultipleInstance 
+                            "You have two copies of the same Telephony driver installed.\nUse the Control Panel to remove one of the copies."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszErrInvalAddress     "The specified phone number either contains invalid characters, or is incorrectly formatted.\nClick on the number box with the right mouse button to see more information."
+    ikszErrLineInitWrongDrivers 
+                            "One or more telephone device drivers are incompatible with TAPI.DLL.\nInstall an updated version."
+    ikszErrAddrBlocked      "The specified phone number cannot be dialed on the selected line device because it is blocked at the telephone switch."
+    ikszErrBillingRejected  "The billing information specified as part of the phone number has been rejected.\nCheck to make sure you've entered it correctly, and then try again."
+    ikszErrResUnavail       "Another program is using the selected Telephony device.\nTry again after the other program completes."
+    ikszErrInvalidCountryCode   "The country code you entered is invalid.\nPlease check the phone number again."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszDisconnectedReject  "The call was rejected by the called party."
+    ikszDisconnectedBusy    "The called number is busy."
+    ikszDisconnectedNoAnswer "There was no answer."
+    ikszDisconnectedCantDo  "The call cannot be completed as dialed."
+    ikszDisconnectedNetwork "The call failed due to network congestion."
+    ikszDisconnectedIncompatible 
+                            "Equipment at the called number is incompatible with your equipment."
+    ikszErrInvalCallState   "The Telephony device driver is unable to respond to your request at this time."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszWarningTitle        "Warning"
+    ikszWarningFor911       "Using your current location and calling card selection, dialing this number could result in a emergency services call to 911.  Are you sure you want to dial this call ?"
+    ikszWarningNewDefault   "Your preferred device selection is not available.  A new device has been selected by default.  If you wish to change the selection use the 'Connect Using' option under the 'Tools' menu"
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/private/tapi/dev/apps/dialer/dialhelp.h b/private/tapi/dev/apps/dialer/dialhelp.h
new file mode 100644
index 000000000..54084e44c
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/dialhelp.h
@@ -0,0 +1,29 @@
+//
+// (c) 1995 Microsoft Corporation.  All Rights Reserved.
+//
+#define IDH_DIALER_CHANGE_DIAL_HELPER    1000
+#define IDH_DIALER_CHANGE_DIGITS         1001
+#define IDH_DIALER_CHANGE_OPTIONS        1002
+#define IDH_DIALER_CHANGE_REDIAL_BUTTON  1003
+#define IDH_DIALER_DIALING_LOGNAME       1004
+#define IDH_DIALER_DIALING_STATUS        1005
+#define IDH_DIALER_HANGUP                1006
+#define IDH_DIALER_LOG_IN                1007
+#define IDH_DIALER_LOG_OUT               1008
+#define IDH_DIALER_OPTIONS_ADDRESS       1009
+#define IDH_DIALER_OPTIONS_LINE          1010
+#define IDH_DIALER_OPTIONS_NONVOICE      1011
+#define IDH_DIALER_OPTIONS_VOICE         1012
+#define IDH_DIALER_PAUSE_CONTINUE        1013
+#define IDH_DIALER_SPEED_CHOOSE          1014
+#define IDH_DIALER_SPEED_NAME            1015
+#define IDH_DIALER_SPEED_NUMBER          1016
+#define IDH_DIALER_SPEED_SAVE            1017
+#define IDH_DIALER_SPEED_SAVE_DIAL       1018
+#define IDH_DIALER_DIAL_NUMBER           1019
+#define IDH_DIALER_DIAL_SPEED_CHOOSE     1020
+#define IDH_DIALER_DIAL_BUTTON           1021
+#define IDH_DIALER_DIAL_KEYPAD           1022
+#define IDH_DIALER_LOG                   1023
+#define IDH_DIALER_OPTIONS_PROPERTIES    1024
+#define IDH_DIALER_BUTTONS               1025
diff --git a/private/tapi/dev/apps/dialer/linebusy.ico b/private/tapi/dev/apps/dialer/linebusy.ico
new file mode 100644
index 000000000..589f2671b
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/linebusy.ico
diff --git a/private/tapi/dev/apps/dialer/makefile b/private/tapi/dev/apps/dialer/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/dialer/makefile.def b/private/tapi/dev/apps/dialer/makefile.def
new file mode 100644
index 000000000..1eb194df8
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/makefile.def
@@ -0,0 +1,50 @@
+##############################################################################
+#
+#   Dialer Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+IS_OEM=1
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=dialer
+TARGETS=dialer.exe
+
+DEFENTRY = WinMain
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+L32EXE=dialer.exe		# Name of exe.
+L32DEF=..\dialer.def              # Our def file.
+L32MAP=dialer.map		# Our map file.
+L32SYM=dialer.sym		# Our sym file.
+L32LIBS= \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\gdi32.lib                   \
+        $(W32LIBID)\kernel32.lib                \
+        $(DEVROOT)\sdk\lib\tapi32.lib           \
+        $(DEVROOT)\tools\c932\lib\oldnames.lib  \
+        $(DEVROOT)\tools\c932\lib\msvcrt.lib  \
+        $(DEVROOT)\sdk\lib\shell32.lib
+
+L32RES=dialer.res	# Resource file.
+L32OBJS = dialer.obj
+
+!include $(ROOT)\dev\master.mk
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Og
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/apps/dialer/nextver/depend.mk b/private/tapi/dev/apps/dialer/nextver/depend.mk
new file mode 100644
index 000000000..506be7029
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/depend.mk
@@ -0,0 +1,4 @@
+.\dialer.obj: ..\dialer.c ..\dialer.h ..\dialhelp.h ..\resource.h
+
+.\dialer.res: ..\dialer.rc ..\version.rc ..\resource.h
+
diff --git a/private/tapi/dev/apps/dialer/nextver/dialer.c b/private/tapi/dev/apps/dialer/nextver/dialer.c
new file mode 100644
index 000000000..3a6d8918b
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialer.c
@@ -0,0 +1,4300 @@
+/*++ 
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    dialer.c
+
+--*/
+
+
+#include "dialer.h"
+#include "string.h"
+#include "stdlib.h"
+#include "shellapi.h"
+
+
+#define	ISDIGIT(x)			(((x) - '0') >= 0) && (((x) - '0') <= 9)
+enum NumberTypes 
+{
+	LOCAL_NUMBER = 7,
+	EXTENDED_LOCAL_NUMBER,
+	LONG_DISTANCE_NUMBER = 10,
+	EXTENDED_LONG_DISTANCE_NUMBER
+};
+
+
+// structs
+typedef struct tagLINEINFO
+{
+    DWORD nAddr;                    // Number of avail. addresses on the line
+    BOOL  fVoiceLine;               // Is this a voice line?
+    DWORD dwAPIVersion;             // API version which the line supports
+    HLINE hLine;                    // line handle returned by lineOpen
+    DWORD dwPermanentLineID;        // Permanent line ID retreived from devcaps
+    char  szLineName[MAXBUFSIZE];   // the line's name
+
+} LINEINFO, *LPLINEINFO;
+
+
+// Global variables
+
+// window/instance variables
+HWND        ghWndMain;
+HWND        ghWndDialing = NULL;
+HINSTANCE   ghInst = 0;
+
+// file name vars.
+static TCHAR gszAppName[64];
+static TCHAR gszINIfilename [] = "DIALER.INI";
+static TCHAR gszHELPfilename [] = "DIALER.HLP";
+static TCHAR gszDialerClassName[] = "DialerClass";
+TCHAR const gszNULL[] = "";
+
+// window item variables
+HFONT       ghFontBtn;               // handle to 1, 2, ..., 0's font
+HFONT       ghFontBtnText;           // handle to number button's text font
+HFONT       ghFontBtnStar;           // handle to * and # button's font
+HLINEAPP    ghLineApp = NULL;        // Dialer's usage handle (regist. w/TAPI)
+HCALL       ghCall = NULL;           // call handle for Dialer's call
+
+LPSTR       gszCurrentNumber = NULL; // number of destination of current call
+LPSTR       gszCurrentName = NULL;	 // name of destination of current call
+
+BOOL        gfRegistered;            // was lineRegisterRequestRecipient()
+                                     // successful?
+
+//BOOL        gfDropping = FALSE;      // is Dialer currently dropping a call?
+BOOL        gfNeedToReinit = FALSE;  // does Dialer need to re-initialize?
+
+BOOL        gfCallRequest = FALSE;   // Does a Simple TAPI app want a call?
+BOOL        gfCurrentLineAvail = TRUE; // Simple TAPI requests are only carried
+                                       // out if the current chosen line is avail.
+BOOL		gfMakeCallReplyPending = FALSE;
+
+LONG        gMakeCallRequestID = 0;      // request ID returned by async TAPI fns.
+LONG        gDropCallRequestID = 0;      // request ID returned by async TAPI fns.
+
+DWORD       gnAvailDevices = 0;      // # of line devices avail. to Dialer
+LINEINFO    gCurrentLineInfo;
+DWORD       * gnAddr;
+
+// global to remember where the cursor is in the edit control
+DWORD       gdwStartSel;
+DWORD       gdwEndSel;
+
+DWORD       * gdwPLID;               // current line's permanent line ID
+DWORD       giCurrentLine = (DWORD)-1;       // the line selected by the user
+DWORD       giCurrentAddress = 0;    // the address selected by the user
+
+// + 1 so we can work 1-based rather than 0-based (for convenience only)
+// global varibles to hold the names and address of the 
+TCHAR       gszSDNumber[ NSPEEDDIALS + 1 ][ TAPIMAXDESTADDRESSSIZE ];
+
+
+// Function declarations
+
+// button related functions
+VOID ButtonFontSetup(VOID);
+VOID DrawButton(HDC hdc, RECT rcBtn, BOOL fHighlighted);
+VOID DrawButtonText(HDC hdc, RECT rcBtn, BOOL fHighlighted, UINT IDD_Btn);
+VOID DisableDialButtons(BOOL fDisable);
+VOID FitTextToButton( HWND, INT, LPSTR );
+
+// Callback functions
+BOOL CALLBACK MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK DialingProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK AboutProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK ConnectUsingProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK LineInUseProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK SpeedDial1Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+BOOL CALLBACK SpeedDial2Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+VOID CALLBACK tapiCallback ( 
+							DWORD hDevice, DWORD dwMsg,
+							DWORD dwCallbackInstance, 
+							DWORD dwParam1, DWORD dwParam2, 
+							DWORD dwParam3
+						    );
+
+// tapi related functions
+VOID ManageAssistedTelephony(VOID);
+VOID InitiateCall(LPCSTR szNumber, LPCSTR szName);
+
+VOID DialerLineClose(VOID); 
+VOID DialerCleanup(VOID);
+VOID CloseTAPI(VOID);
+
+DWORD GetLineInfo(DWORD iLine, LPLINEINFO lpLineInfo);
+VOID GetLineInfoFailed (
+						DWORD iLine, LPLINEDEVCAPS lpDevCaps, 
+						LPLINEINFO lpLineInfo
+					    );
+LPSTR GetAddressName(DWORD iLine, DWORD iAddress);
+BOOL MakeCanonicalNumber( LPCSTR szName, LPSTR szCanNumber );
+
+// misc. helper functions
+VOID ReadINI(VOID);
+int errString(HWND hWnd, UINT errCode, UINT uFlags);
+VOID AddToRedialList(LPCSTR szNumber);
+BOOL InitializeLineBox(HWND hwndLineBox);
+BOOL InitializeAddressBox(HWND hwndLineBox, HWND hwndAddressBox);
+BOOL Is911 ( LPLINETRANSLATEOUTPUT lpTransOut );
+VOID AmpersandCompensate( LPCSTR lpszSrc, LPSTR lpszDst );
+VOID AmpersandDeCompensate( LPCSTR lpszSrc, LPSTR lpszDst );
+
+// Dialer memory management functions
+LPVOID DialerAlloc(size_t cbToAlloc);
+LPVOID DialerFree(LPVOID lpMem);
+
+
+// Function definitions
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+DWORD InitializeTAPI (VOID)
+{
+	INT cvLine;
+
+	DWORD iLine;
+	DWORD dwPreferredPLID, dwID = (DWORD) -1;
+
+	MSG msg;
+
+	LPLINEINFO lpLineInfo = NULL;	// LINEINFO for each available line
+
+    DWORD errCode;
+    DWORD tc = GetTickCount();
+    DWORD dwReturn = ERR_NONE;
+
+	char szBuffer[MAXBUFSIZE];		// to read in dwPreferredPLID as a string first
+
+
+
+	errCode = lineInitialize (
+								&ghLineApp,
+								ghInst,
+								(LINECALLBACK) tapiCallback,
+								gszAppName,
+								&gnAvailDevices
+							 );
+	if ( errCode == LINEERR_REINIT )
+	{
+		// take away dialer functionality
+		EnableWindow( ghWndMain, FALSE );
+		DisableDialButtons(TRUE);
+
+		// keep trying until the user cancels
+		// or we stop getting LINEERR_REINIT
+		while ( ( errCode = lineInitialize ( 
+											&ghLineApp,              
+											ghInst,
+											(LINECALLBACK)tapiCallback,
+											gszAppName,
+											&gnAvailDevices
+										    ) ) 
+				 == LINEERR_REINIT )
+		{
+			// flush queue & yield
+			while ( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) ) 
+			{
+				TranslateMessage( &msg );
+				DispatchMessage( &msg );
+			}
+
+			// bring up the box if 5 seconds have passed since
+			if(GetTickCount() > 5000 + tc)
+			{
+				if ( errString( ghWndMain, ikszWarningTapiReInit, MB_RETRYCANCEL )
+					 == IDCANCEL )
+				{
+					break;
+				}
+				// reset the relative counter
+				tc = GetTickCount(); 
+			}            
+		}
+
+		// give back dialer functionality
+		DisableDialButtons( FALSE );
+		EnableWindow( ghWndMain, TRUE );
+	}
+
+	if ( errCode )
+    {
+        dwReturn = errCode;
+        goto tapiinit_exit;
+    }
+
+	// retrieve preferred line info from INI file
+	GetPrivateProfileString (
+								"Preference",
+								"Preferred Line",
+								gszNULL, 
+								szBuffer,
+								MAXBUFSIZE,
+								gszINIfilename
+							);
+
+	// if szBuffer is not empty.
+	if ( lstrcmp ( gszNULL, szBuffer ) )
+	{
+		dwPreferredPLID = (DWORD) atoi( szBuffer );	
+	}
+	else	
+	{
+		dwPreferredPLID = (DWORD) -1;
+	}
+										
+	// -1 default - tells us if it ever gets set
+	giCurrentLine = (DWORD) -1;			
+
+	// allocate buffer for storing LINEINFO for all of the available lines
+	// always allocate space for at least one line
+	if ( gnAvailDevices == 0 )
+	{
+		gnAddr = (DWORD *) DialerAlloc( sizeof( DWORD ) );
+		gdwPLID = (DWORD *) DialerAlloc( sizeof( DWORD ) );
+		lpLineInfo = (LPLINEINFO) DialerAlloc( sizeof( LINEINFO ) );
+	}
+	else
+	{
+		gnAddr = (DWORD *) DialerAlloc( sizeof( DWORD ) * (int)gnAvailDevices);
+		gdwPLID = (DWORD *) DialerAlloc( sizeof( DWORD ) * (int)gnAvailDevices);
+		lpLineInfo = (LPLINEINFO) DialerAlloc( sizeof( LINEINFO ) * (int)gnAvailDevices );
+	}
+
+	// if no space was set aside...
+	if ( lpLineInfo == NULL || gnAddr == NULL )
+    {
+        dwReturn = LINEERR_NOMEM;
+        goto tapiinit_exit;
+    }
+
+	// fill lpLineInfo[] and open each line
+	for ( iLine = 0, cvLine = 0; iLine < gnAvailDevices; ++iLine )
+	{
+		// skip remaining processing for this if it didn't open
+		if ( GetLineInfo( iLine, &lpLineInfo[iLine] ) != ERR_NONE )
+			continue; 
+
+		gnAddr [ iLine ] = lpLineInfo[iLine].nAddr;
+		gdwPLID[ iLine ] = lpLineInfo[iLine].dwPermanentLineID;
+
+		if ( lpLineInfo[iLine].dwPermanentLineID == dwPreferredPLID )
+			giCurrentLine = iLine;
+
+		// note number of lines with Interactive voice caps.
+		// used to select a preferred line by default
+		if ( lpLineInfo [ iLine ].fVoiceLine )
+		{
+			cvLine++;
+			dwID = iLine;
+		}
+	}
+
+	// if we couldn't find the preferred line, 
+	// try and assign one by default 
+	// else bring up connect using dialog
+	if (  giCurrentLine == (DWORD)-1 ) 
+	{
+		// check if there is only one line
+		// that has interactive voice caps, 
+		// make it default line
+		if ( cvLine == 1 ) 
+		{
+			giCurrentLine = dwID;
+
+			// if the preferred address read from the INI file
+			// was different i.e we are changing setting, inform
+			// the user
+			if ( dwPreferredPLID != -1 )
+			{
+				errString( ghWndMain, ERR_NEWDEFAULT, MB_ICONEXCLAMATION | MB_OK );
+			}
+		}
+		else
+		{
+			gCurrentLineInfo = lpLineInfo[0];
+			if ( DialogBoxParam (
+									ghInst,
+									MAKEINTRESOURCE(IDD_CONNECTUSING),
+									ghWndMain,
+									(DLGPROC)ConnectUsingProc,
+									INVALID_LINE
+								)
+				 == -1)
+			{
+                dwReturn = (DWORD) -1;
+			}
+			else
+			{
+                dwReturn = ERR_NONE;
+			}
+
+            goto tapiinit_exit;
+		}
+	}
+	gCurrentLineInfo = lpLineInfo[ giCurrentLine ];
+
+
+	// select default address
+	giCurrentAddress = 0;
+
+	// get the name of the preferred address from ini file
+	GetPrivateProfileString (
+								"Preference",
+								"Preferred Address",
+								gszNULL, 
+								szBuffer,
+								MAXBUFSIZE,
+								gszINIfilename
+							);
+
+	// if preferred address read from INI file
+	if ( lstrcmp( gszNULL, szBuffer ) )
+	{
+		giCurrentAddress = (DWORD) atoi( szBuffer );
+		
+		// if the address is invalid, set default
+		if ( giCurrentAddress >= gCurrentLineInfo.nAddr )
+			giCurrentAddress = 0;
+	}
+	
+
+tapiinit_exit:
+    
+    if (lpLineInfo)
+    {
+        DialerFree(lpLineInfo);
+    }
+    
+	return dwReturn;;
+}
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+int WINAPI WinMain (
+					HINSTANCE hInstance,
+					HINSTANCE hPrevInstance,
+					LPSTR lpCmdLine,
+					int nCmdShow
+				   )
+{
+	HACCEL hAccel;
+	MSG msg;
+	DWORD errCode;
+	HANDLE hImHere;
+
+
+	ghInst = GetModuleHandle( NULL );
+	LoadString( ghInst, ikszAppFriendlyName, gszAppName, sizeof(gszAppName)/sizeof(TCHAR) );
+
+	//
+	// Now, let's see if we've already got an instance of ourself
+	hImHere = CreateMutex(NULL, TRUE, "DialersIveBeenStartedMutex");
+
+	//
+	// Is there another one of us already here?
+	if ( ERROR_ALREADY_EXISTS == GetLastError() )
+	{
+        HWND        hDialerWnd;
+
+        hDialerWnd = FindWindow(gszDialerClassName,
+                                NULL);
+
+        SetForegroundWindow(hDialerWnd);
+        
+	   CloseHandle( hImHere );
+	   return 0;
+	}
+
+
+	{
+		WNDCLASS wc;
+		wc.style = CS_DBLCLKS | CS_SAVEBITS | CS_BYTEALIGNWINDOW;
+		wc.lpfnWndProc = DefDlgProc;
+		wc.cbClsExtra = 0;
+		wc.cbWndExtra = DLGWINDOWEXTRA;
+		wc.hInstance = ghInst;
+		wc.hIcon = LoadIcon(ghInst, MAKEINTRESOURCE(IDI_DIALER) );
+		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+		wc.hbrBackground = GetStockObject (COLOR_WINDOW + 1);
+		wc.lpszMenuName = NULL;
+		wc.lpszClassName = gszDialerClassName;
+		RegisterClass(&wc);
+	}
+
+
+	// create the dialog box and set it with info
+	// from the .INI file
+	ghWndMain = CreateDialog (
+								ghInst,
+								(LPCSTR)MAKEINTRESOURCE(IDD_DIALER),
+								(HWND)NULL,
+								MainWndProc
+							 );
+
+	ReadINI();
+	ButtonFontSetup();
+
+	ShowWindow(ghWndMain, SW_SHOW);
+	UpdateWindow(ghWndMain);
+
+	// limit text in Number field to TAPIMAXDESTADDRESSSIZE
+	SendDlgItemMessage (
+						ghWndMain,
+						IDD_DCOMBO,
+						CB_LIMITTEXT,
+						(WPARAM)TAPIMAXDESTADDRESSSIZE,
+						0
+					   );
+
+	// 0 (ERR_NONE) error code registers success - otherwise terminate
+	errCode = InitializeTAPI();
+	if(errCode)
+	{
+		errString(ghWndMain, errCode, MB_APPLMODAL | MB_ICONEXCLAMATION );
+
+		DialerCleanup();
+		return errCode;
+	}
+
+	errCode = lineRegisterRequestRecipient (
+											ghLineApp,
+											0, // registration instance
+											LINEREQUESTMODE_MAKECALL,
+											TRUE
+										   );
+
+	if(errCode)
+	{
+		gfRegistered = FALSE;
+		errString(ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+	}
+	else
+	{
+		gfRegistered = TRUE;
+	}
+
+
+	hAccel = LoadAccelerators(ghInst, gszAppName);
+
+	while ( GetMessage( &msg, NULL, 0, 0 ) )
+	{
+		if ( ghWndMain == NULL || !IsDialogMessage( ghWndMain, &msg ) )
+		{
+			if(!TranslateAccelerator(ghWndMain, hAccel, &msg))
+			{
+				TranslateMessage(&msg);
+				DispatchMessage(&msg);
+			}
+		}
+
+		// If: 1) Dialer is a call manager (if not, ignore requests)
+		//     2) the currently chosen line is available
+		//     3) there is a Simple TAPI request
+		// Then: process the request
+		if ( gfCurrentLineAvail && gfCallRequest )
+		{
+			ManageAssistedTelephony();
+		}
+	}
+
+
+    
+	DialerCleanup();
+
+	CloseHandle( hImHere );
+
+	return msg.wParam;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LPVOID DialerAlloc(size_t cbToAlloc)
+{
+	return LocalAlloc(LPTR, cbToAlloc);
+}
+
+
+LPVOID DialerFree(LPVOID lpMem)
+{
+	return LocalFree( lpMem );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID ReadINI( VOID ) 
+{
+    WORD cSDEntry, cLastDialed;
+    DWORD cComma; 
+
+    POINT ptLeftTop;
+
+    char szName[ TAPIMAXCALLEDPARTYSIZE ];
+    char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+
+    char szNum[MAXBUFSIZE];
+    char szFieldName[MAXBUFSIZE];
+    char szPt[MAXBUFSIZE];
+                  
+
+    // get speed dial settings from INI file
+    for(cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry)
+    {
+		
+        wsprintf(szFieldName, "Name%d", cSDEntry);
+        GetPrivateProfileString (
+									"Speed Dial Settings",
+									szFieldName,
+									gszNULL,
+									szName,
+									TAPIMAXCALLEDPARTYSIZE - 1,
+									gszINIfilename
+								);
+
+        wsprintf(szFieldName, "Number%d", cSDEntry);
+        GetPrivateProfileString ( 
+									"Speed Dial Settings",
+									szFieldName,
+									gszNULL,
+									gszSDNumber[cSDEntry],
+									TAPIMAXDESTADDRESSSIZE - 1,
+									gszINIfilename
+								);        
+
+		if ( !lstrcmp( gszNULL, szName ) )
+		{
+			lstrcpy( szName, gszSDNumber[ cSDEntry ] );
+		}
+
+		FitTextToButton( ghWndMain, IDD_DSPEEDDIAL1 + cSDEntry - 1, szName );
+
+		AmpersandCompensate( szName, szTemp );
+		SetDlgItemText (
+						ghWndMain,
+						IDD_DSPEEDDIAL1 + cSDEntry - 1,
+						(LPCSTR)szTemp
+					   ); // Label the speed dial button
+	}
+
+    
+	// set up last dialed numbers in combo box (read from INI)
+	for(cLastDialed = 1; cLastDialed <= NLASTDIALED; ++cLastDialed)
+	{
+		wsprintf(szFieldName, "Last dialed %d", cLastDialed);
+		GetPrivateProfileString (
+									"Last dialed numbers",
+									szFieldName,
+									gszNULL,
+									szNum,
+									MAXBUFSIZE - 1,
+									gszINIfilename
+								);
+		if ( szNum[0] ) // i.e. if szNum isn't simply "" - if we read something
+						// from the INI - put it in the combo box
+			SendDlgItemMessage(
+								ghWndMain,
+								IDD_DCOMBO,
+								CB_ADDSTRING,
+								0,
+								(LPARAM)(LPCSTR)szNum
+							  );
+	}
+
+	// set defaults
+	ptLeftTop.x = 100; 
+	ptLeftTop.y = 100;
+
+	// set the window position based on the INI data
+	GetPrivateProfileString (
+								"Preference",
+								"Main Window Left/Top",
+								gszNULL,
+								szPt,
+								MAXBUFSIZE - 1,
+								gszINIfilename
+							);
+
+	if ( szPt[0] ) 
+	{
+		cComma = strcspn(szPt, ",");
+		szPt[cComma] = 0;
+		ptLeftTop.x = atoi(szPt);
+		
+		// a possibly absurd check to see that the string
+		// wasn't akin to "320," with no second entry
+		if ( *(szPt + cComma + 1 ) ) 
+			ptLeftTop.y = atoi( szPt + cComma + 1 );
+
+		// check to see that the box is on the screen - the upper left
+		// must be on the screen, along with a 50x50 box below and to
+		// the right of it
+		if ( ptLeftTop.x < 0
+			|| ptLeftTop.x + 50 >= GetSystemMetrics(SM_CXSCREEN)
+			|| ptLeftTop.y < 0
+			|| ptLeftTop.y + 50 >= GetSystemMetrics(SM_CYSCREEN)            
+		   )
+		{
+			ptLeftTop.x = 100; // set defaults if the box is off of the screen
+			ptLeftTop.y = 100; // set defaults if the box is off of the screen
+		}
+	}
+
+	SetWindowPos (
+					ghWndMain,
+					NULL,
+					ptLeftTop.x,
+					ptLeftTop.y,
+					0,
+					0,
+					SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOZORDER
+				 );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID ButtonFontSetup(VOID)
+    {
+    HDC hdc;
+    int IDD;
+
+    // define the fonts for the buttons
+    hdc = GetDC(GetDesktopWindow());
+
+    ghFontBtn = CreateFont(
+        (-10)*GetDeviceCaps(hdc, LOGPIXELSY)/72,
+        0,
+        0,
+        0,
+        FW_BOLD,
+        FALSE,
+        FALSE,
+        FALSE,
+        ANSI_CHARSET,
+        OUT_DEFAULT_PRECIS,
+        CLIP_DEFAULT_PRECIS,
+        PROOF_QUALITY,
+        VARIABLE_PITCH | FF_SWISS,
+        (LPSTR)"Arial"
+        );
+
+    ghFontBtnText = CreateFont(
+        (-6)*GetDeviceCaps(hdc, LOGPIXELSY)/72,
+        0,
+        0,
+        0,
+        FW_NORMAL,
+        FALSE,
+        FALSE,
+        FALSE,
+        ANSI_CHARSET,
+        OUT_DEFAULT_PRECIS,
+        CLIP_DEFAULT_PRECIS,
+        PROOF_QUALITY,
+        VARIABLE_PITCH | FF_SWISS,
+        NULL
+        );
+
+    ghFontBtnStar = CreateFont(
+        (-18)*GetDeviceCaps(hdc, LOGPIXELSY)/72,
+        0,
+        0,
+        0,
+        FW_BOLD,
+        FALSE,
+        FALSE,
+        FALSE,
+        SYMBOL_CHARSET,
+        OUT_TT_PRECIS,
+        CLIP_DEFAULT_PRECIS,
+        PROOF_QUALITY,
+        VARIABLE_PITCH | FF_DONTCARE,
+        (LPSTR)"Symbol"
+        );
+
+    ReleaseDC(GetDesktopWindow(), hdc);
+
+
+    // set the fonts for the buttons
+    if(ghFontBtn)
+        {
+        // set fonts on number buttons
+            for(IDD = IDD_DBUTTON1; IDD <= IDD_DBUTTON0; ++IDD)
+            // the order is IDD_DBUTTON1, 2, 3, ..., 0 (thus from 1 to 0)
+            SendMessage(
+                GetDlgItem(ghWndMain, IDD),
+                WM_SETFONT,
+                (WPARAM)ghFontBtn,
+                0L
+                );
+        
+        // set fonts on * and # buttons
+        SendMessage(
+            GetDlgItem(ghWndMain, IDD_DBUTTONSTAR),
+            WM_SETFONT,
+            (WPARAM)ghFontBtnStar,
+            0L
+            );
+        SendMessage(
+                    GetDlgItem(ghWndMain, IDD_DBUTTONPOUND),
+            WM_SETFONT,
+            (WPARAM)ghFontBtnStar,
+            0L
+            );
+        }
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+// Draws a 3D button within rcBtn on hDC
+VOID DrawButton(HDC hDC, RECT rcBtn, BOOL fHighlighted)
+    {
+    HPEN hPenPrev, hPenShadow, hPenHighlight, hPenBlack;
+    HBRUSH hBrushPrev, hBrushFace;
+    int RopPrev;
+
+    --rcBtn.right;
+    --rcBtn.bottom;
+
+    // set up pens/brush
+    hPenShadow = CreatePen(PS_SOLID,0,GetSysColor(COLOR_3DSHADOW));
+    hPenHighlight = CreatePen(PS_SOLID,0,GetSysColor(COLOR_3DHILIGHT));
+    hPenBlack = GetStockObject(BLACK_PEN);
+    hBrushFace = GetSysColorBrush(COLOR_3DFACE);
+    
+    // get current state so we can put it back at the end of DrawButton
+    hPenPrev = SelectObject(hDC, hPenBlack);
+    RopPrev = SetROP2(hDC, R2_COPYPEN);
+    hBrushPrev = SelectObject(hDC, hBrushFace);
+
+    PatBlt(
+        hDC,
+        rcBtn.left + 1,
+        rcBtn.top + 1,
+        rcBtn.right - rcBtn.left - 1,
+        rcBtn.bottom - rcBtn.top - 1,
+        PATCOPY
+        );
+    
+    if(fHighlighted)
+        {
+        SelectObject(hDC, hPenBlack);
+        MoveToEx(hDC, rcBtn.left, rcBtn.bottom - 1, NULL);
+        LineTo(hDC, rcBtn.left, rcBtn.top);  //  _
+        LineTo(hDC, rcBtn.right, rcBtn.top); // |
+
+        SelectObject(hDC, hPenHighlight);
+        MoveToEx(hDC, rcBtn.right, rcBtn.top, NULL);
+        LineTo(hDC, rcBtn.right, rcBtn.bottom);
+        LineTo(hDC, rcBtn.left - 1, rcBtn.bottom); // _|
+
+        SelectObject(hDC, hPenShadow);
+        MoveToEx(hDC, rcBtn.left + 1, rcBtn.bottom - 2, NULL);
+        LineTo(hDC, rcBtn.left + 1, rcBtn.top + 1);
+        LineTo(hDC, rcBtn.right - 1, rcBtn.top + 1);
+        }
+    else
+        {
+        SelectObject(hDC, hPenHighlight);
+        MoveToEx(hDC, rcBtn.left, rcBtn.bottom - 1, NULL);
+        LineTo(hDC, rcBtn.left, rcBtn.top);  //  _
+        LineTo(hDC, rcBtn.right, rcBtn.top); // |
+
+        SelectObject(hDC, hPenBlack);
+        MoveToEx(hDC, rcBtn.right, rcBtn.top, NULL);
+        LineTo(hDC, rcBtn.right, rcBtn.bottom);
+        LineTo(hDC, rcBtn.left - 1, rcBtn.bottom); // _|
+
+        SelectObject(hDC, hPenShadow);
+        MoveToEx(hDC, rcBtn.left + 1, rcBtn.bottom - 1, NULL);
+        LineTo(hDC, rcBtn.right - 1, rcBtn.bottom - 1);
+        LineTo(hDC, rcBtn.right - 1, rcBtn.top);
+        }
+
+    // put everything back how it was
+    SetROP2(hDC, RopPrev);
+    SelectObject(hDC, hBrushPrev);
+    SelectObject(hDC, hPenPrev);
+
+    DeleteObject(hPenBlack);
+    DeleteObject(hPenShadow);
+    DeleteObject(hPenHighlight);    
+    DeleteObject(hBrushFace);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DrawButtonText(HDC hDC, RECT rcBtn, BOOL fHighlighted, UINT IDD_Btn)
+    {    
+    char szLine1[MAXBUFSIZE]; // text in button up to '\n'
+    LPSTR pszLine2; // text in button after '\n'
+    int BkModePrev;
+    HFONT hFontPrev = NULL;
+    TEXTMETRIC tm;
+    RECT rcText = rcBtn;
+           
+    BkModePrev = SetBkMode(hDC, TRANSPARENT);
+
+    GetDlgItemText(ghWndMain, IDD_Btn, szLine1, MAXBUFSIZE);
+    pszLine2 = strstr(szLine1, "\n");
+    if(pszLine2)
+        {
+        *pszLine2 = 0; // 1 -> "TEST1 \n TEST2" becomes "TEST 1 \0"
+        ++pszLine2; // now 2 -> " TEST 2"
+        }
+
+    // now szLine1 points to the null terminated first string and
+    // pszLine2 points to either the null terminated second string or NULL
+    // if there was no second string
+
+    if(szLine1[0])
+        {
+        if(ghFontBtnText && pszLine2)
+            hFontPrev = SelectObject(hDC, ghFontBtnText);
+        
+        GetTextMetrics(hDC, &tm);
+        rcText.bottom = (rcBtn.bottom + rcBtn.top)/2 - 2;
+        rcText.top = rcText.bottom - (tm.tmHeight - 1);
+
+        if(pszLine2 == NULL)
+            OffsetRect(&rcText, 0, (rcText.bottom - rcText.top)/2);
+
+        if(fHighlighted)
+            OffsetRect(&rcText, 1, 1);
+
+        DrawText(hDC, szLine1, -1, &rcText, DT_SINGLELINE | DT_CENTER);
+
+        if(hFontPrev)
+            SelectObject(hDC, hFontPrev);
+        }
+    if(pszLine2) // recall that pszLine2 == NULL to represent no second string
+        {
+        GetTextMetrics(hDC, &tm);
+        if(IDD_Btn == IDD_DBUTTONSTAR || IDD_Btn == IDD_DBUTTONPOUND)
+            rcText.top = (rcBtn.bottom + rcBtn.top)/2 - (tm.tmHeight)/2;
+        else
+            rcText.top = (rcBtn.bottom + rcBtn.top)/2 - 2;
+        rcText.bottom = rcText.top + tm.tmHeight;
+
+        if(fHighlighted)
+            OffsetRect(&rcText, 1, 1);
+
+        DrawText(hDC, pszLine2, -1, &rcText, DT_SINGLELINE | DT_CENTER);
+        }
+
+    SetBkMode(hDC, BkModePrev);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DisableDialButtons(BOOL fDisable)
+{
+	int IDD;
+
+	// Disable/enable Dial button
+	EnableWindow( GetDlgItem( ghWndMain, IDD_DDIAL ),!fDisable) ;
+
+	// Disable/enable Speed dial buttons
+	for ( IDD = IDD_DSPEEDDIAL1; IDD <= IDD_DSPEEDDIAL8; ++IDD )
+	{
+		EnableWindow(GetDlgItem(ghWndMain, IDD),!fDisable);
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DialerCleanup(VOID)
+    {
+    RECT rc;
+    WORD cItem; // count of numbers in combo box
+    DWORD cLastDialed;
+    char szPt[MAXBUFSIZE];
+    char szNumber[TAPIMAXDESTADDRESSSIZE];
+    char szFieldName[MAXBUFSIZE];
+
+    CloseTAPI(); // unregister and line close
+
+    if(!IsIconic(ghWndMain)) // if the window is not minimized, record position
+        {
+        GetWindowRect(ghWndMain, &rc);
+        wsprintf(szPt, "%ld, %ld", rc.left, rc.top);
+        WritePrivateProfileString(
+            "Preference",
+            "Main Window Left/Top",
+            szPt,
+            gszINIfilename
+            );
+        }
+
+    cItem = (WORD)SendDlgItemMessage(ghWndMain, IDD_DCOMBO, CB_GETCOUNT, 0, 0);
+
+    // write out last dialed numbers from combo box (write to INI)
+    for(cLastDialed = 1; cLastDialed <= NLASTDIALED; ++cLastDialed)
+        {
+        if(cLastDialed <= cItem)
+            SendDlgItemMessage(
+                ghWndMain,
+                IDD_DCOMBO,
+                CB_GETLBTEXT,
+                cLastDialed - 1, // it's a zero-based count
+                (LPARAM)(LPCSTR)szNumber);
+
+        else
+            szNumber[0] = 0;
+
+        wsprintf(szFieldName, "Last dialed %d", cLastDialed);
+        WritePrivateProfileString(
+            "Last dialed numbers",
+            szFieldName,
+            szNumber,            
+            gszINIfilename
+            );
+
+        }
+
+    WinHelp(ghWndMain, gszHELPfilename, HELP_QUIT, 0); // unload help
+
+    DestroyWindow(ghWndMain);
+    ghWndMain = NULL;
+
+    DeleteObject(ghFontBtn);
+    DeleteObject(ghFontBtnText);
+    DeleteObject(ghFontBtnStar);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+// unregister and line close
+VOID CloseTAPI(VOID) 
+{
+
+	// unregister as call manager
+	lineRegisterRequestRecipient (
+									ghLineApp,
+									0, // registration instance
+									LINEREQUESTMODE_MAKECALL,
+									FALSE
+								 );
+
+	if ( gCurrentLineInfo.hLine )
+	{
+		lineClose ( gCurrentLineInfo.hLine );
+		gfCurrentLineAvail = FALSE;
+		gCurrentLineInfo.hLine = NULL;
+	}
+
+	lineShutdown(ghLineApp);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static HICON hIcon;
+	static const DWORD aMenuHelpIDs[] = 
+	{
+        IDD_DSPEEDDIALGRP,   (DWORD)-1,
+		IDD_DNUMTODIAL,      IDH_DIALER_DIAL_NUMBER,
+		IDD_DCOMBO,          IDH_DIALER_DIAL_NUMBER,
+		IDD_DDIAL,           IDH_DIALER_DIAL_BUTTON,
+		IDD_DSPEEDDIAL1,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL2,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL3,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL4,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL5,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL6,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL7,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIAL8,     IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT1, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT2, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT3, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT4, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT5, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT6, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT7, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DSPEEDDIALTEXT8, IDH_DIALER_DIAL_SPEED_CHOOSE,
+		IDD_DBUTTON1,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON2,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON3,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON4,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON5,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON6,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON7,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON8,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON9,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTONSTAR,     IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTON0,        IDH_DIALER_DIAL_KEYPAD,
+		IDD_DBUTTONPOUND,    IDH_DIALER_DIAL_KEYPAD,
+		0,                   0
+	};
+
+        switch (msg)
+        {
+            case WM_INITDIALOG:
+                hIcon = LoadIcon( ghInst, (LPCSTR) MAKEINTRESOURCE( IDI_DIALER ) );
+                return TRUE;
+
+            case WM_SYSCOMMAND:
+                switch( (DWORD) wParam )
+                {
+                    case SC_CLOSE:                    
+                        PostQuitMessage(0);
+                }
+                break;
+
+                // processes clicks on controls when
+                // context mode help is selected
+            case WM_HELP: 
+                WinHelp (
+                         ( (LPHELPINFO) lParam)->hItemHandle,
+                         gszHELPfilename,
+                         HELP_WM_HELP,
+                         (DWORD)(LPVOID) aMenuHelpIDs
+                        );
+                return TRUE;
+
+                // processes right-clicks on controls
+            case WM_CONTEXTMENU:
+                WinHelp (
+                         (HWND)wParam,
+                         gszHELPfilename,
+                         HELP_CONTEXTMENU,
+                         (DWORD)(LPVOID)aMenuHelpIDs
+                        );
+                return TRUE;
+
+            case WM_INITMENUPOPUP:
+                // if edit menu
+                if ( LOWORD(lParam) == 1 ) 
+                {
+                    UINT wEnable;
+
+                    if ( GetParent( GetFocus() ) != GetDlgItem( ghWndMain, IDD_DCOMBO ) )
+                    {
+                        wEnable = MF_GRAYED;
+                    }
+                    else
+                    {
+                        LONG lSelect = SendDlgItemMessage (
+                            ghWndMain,
+                            IDD_DCOMBO,
+                            CB_GETEDITSEL,
+                            0,
+                            0
+                            );
+
+                        if ( HIWORD( lSelect ) != LOWORD( lSelect ) )
+                            wEnable = MF_ENABLED;
+                        else
+                            wEnable = MF_GRAYED;
+                    }
+
+                    EnableMenuItem((HMENU)wParam, IDM_EDIT_CUT, wEnable);
+                    EnableMenuItem((HMENU)wParam, IDM_EDIT_COPY, wEnable);
+                    EnableMenuItem((HMENU)wParam, IDM_EDIT_DELETE, wEnable);
+
+                    // enable paste option is there is data 
+                    // in the clipboard
+                    if ( IsClipboardFormatAvailable( CF_TEXT ) )
+                    {
+                        if ( GetClipboardData ( CF_TEXT ) )
+                        {
+                            wEnable = MF_ENABLED;
+                        }
+                        else
+                        {
+                            wEnable = MF_GRAYED;
+                        }
+                    }
+                    else
+                    {
+                        wEnable = MF_GRAYED;	
+                    }
+
+                }
+                break;
+
+
+            case WM_COMMAND:
+            {
+                char szName[TAPIMAXCALLEDPARTYSIZE] = {'\0'};
+                char szNumber[TAPIMAXDESTADDRESSSIZE] = {'\0'};
+
+                switch( LOWORD( (DWORD)wParam ) )
+                {
+                    // FILE menu
+                    case IDM_EXIT:
+                        PostQuitMessage(0);                    
+                        return TRUE;
+
+
+                        // EDIT menu
+                    case IDM_EDIT_CUT:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_CUT, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_COPY:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_COPY, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_PASTE:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_PASTE, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_DELETE:
+                        SendDlgItemMessage(ghWndMain, IDD_DCOMBO, WM_CLEAR, 0, 0);
+                        return TRUE;
+
+                    case IDM_EDIT_SPEEDDIAL:
+                        DialogBoxParam (
+                                        ghInst,
+                                        MAKEINTRESOURCE(IDD_SD1),
+                                        ghWndMain,
+                                        (DLGPROC)SpeedDial1Proc,
+                                        0
+                                       );
+                        SetFocus(GetDlgItem(ghWndMain, IDD_DDIAL));
+                        return TRUE;
+
+                        // TOOLS menu
+                    case IDM_CONNECTUSING:
+                        DialogBoxParam (
+                                        ghInst,
+                                        MAKEINTRESOURCE(IDD_CONNECTUSING),
+                                        ghWndMain,
+                                        (DLGPROC)ConnectUsingProc,
+                                        MENU_CHOICE
+                                       );
+                        return TRUE;
+
+                    case IDM_LOCATION:
+                    {
+                        char szCanNumber[ TAPIMAXDESTADDRESSSIZE ] = "";
+
+                        // fetch the number to be dialed
+                        if ( GetDlgItemText ( 
+                                              ghWndMain,
+                                              IDD_DCOMBO,
+                                              szNumber,
+                                              TAPIMAXDESTADDRESSSIZE
+                                            )
+                           )
+                        {
+                            // if a number exists, convert it to 
+                            // its canonical form.
+                            if ( !MakeCanonicalNumber ( szNumber, szCanNumber ) )
+                            {
+                                lstrcpy( szCanNumber, szNumber );
+                            }
+                        }
+
+                        lineTranslateDialog (
+                                             ghLineApp,
+                                             0,
+                                             TAPI_CURRENT_VERSION,
+                                             ghWndMain,
+                                             szCanNumber
+                                            );
+                        return TRUE;
+
+                    }
+                    // HELP menu
+                    case IDM_HELP_CONTENTS:
+                        WinHelp(ghWndMain, gszHELPfilename, HELP_CONTENTS, 0);
+                        return TRUE;
+
+                    case IDM_HELP_WHATSTHIS:
+                        PostMessage(ghWndMain, WM_SYSCOMMAND, SC_CONTEXTHELP, 0);
+                        return TRUE;
+
+                    case IDM_ABOUT:
+                        DialogBoxParam(
+                                       ghInst,
+                                       MAKEINTRESOURCE(IDD_ABOUT),
+                                       ghWndMain,
+                                       (DLGPROC)AboutProc,
+                                       0
+                                      );
+
+                        return TRUE;
+
+
+                        // Accelerator processing
+                    case IDM_ACCEL_NUMTODIAL:
+                        if(GetActiveWindow() == ghWndMain)
+                            SetFocus(GetDlgItem(ghWndMain, IDD_DCOMBO));
+                        return TRUE;
+
+
+                        // Buttons
+                    case IDD_DDIAL:
+
+                    {
+                        DWORD cSDEntry;
+                        char szSDNumber[TAPIMAXDESTADDRESSSIZE];
+                        char szFieldName[MAXBUFSIZE];
+
+                        // check if number entered is dialable
+                        if ( SendMessage (
+                                          GetDlgItem(ghWndMain, IDD_DCOMBO),
+                                          WM_GETTEXTLENGTH,
+                                          0,
+                                          0
+                                         ) > 0 
+                           )
+                        {
+                            // get the number to be dialed
+                            GetDlgItemText (
+                                            ghWndMain,
+                                            IDD_DCOMBO,
+                                            (LPSTR)szNumber,
+                                            TAPIMAXDESTADDRESSSIZE
+                                           );
+
+                            // check if it is a speed dial number.  
+                            // If so choose the name to be displayed.
+                            for( cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry)
+                            {
+                                wsprintf(szFieldName, "Number%d", cSDEntry);
+                                GetPrivateProfileString (
+                                    "Speed Dial Settings",
+                                    szFieldName,
+                                    gszNULL,
+                                    szSDNumber,
+                                    TAPIMAXCALLEDPARTYSIZE - 1,
+                                    gszINIfilename
+                                    );
+
+                                // if the number matches, get the name
+                                if ( lstrcmp(szSDNumber, szNumber) == 0 )
+                                {
+                                    wsprintf( szFieldName, "Name%d", cSDEntry);
+                                    GetPrivateProfileString (
+                                        "Speed Dial Settings",
+                                        szFieldName,
+                                        gszNULL,
+                                        szName,
+                                        TAPIMAXCALLEDPARTYSIZE - 1,
+                                        gszINIfilename
+                                        );
+                                    break;
+                                }
+                            }
+
+                            SetFocus( GetDlgItem( ghWndMain, IDD_DDIAL ) );
+
+                            // once the currentline has been set
+                            // using the connect proc
+                            // the user must hit dial again 
+                            if ( giCurrentLine == (DWORD)-1 )
+                            {
+                                DialogBoxParam (
+                                                ghInst,
+                                                MAKEINTRESOURCE(IDD_CONNECTUSING),
+                                                ghWndMain,
+                                                (DLGPROC)ConnectUsingProc,
+                                                INVALID_LINE
+                                               );
+                            }
+                            else
+                            {
+                                AddToRedialList(szNumber);
+                                InitiateCall(szNumber, szName);
+                            }
+                        }
+                        return TRUE;
+                    }
+
+
+                    case IDD_DBUTTON1:
+                    case IDD_DBUTTON2:
+                    case IDD_DBUTTON3:
+                    case IDD_DBUTTON4:
+                    case IDD_DBUTTON5:
+                    case IDD_DBUTTON6:
+                    case IDD_DBUTTON7:
+                    case IDD_DBUTTON8:
+                    case IDD_DBUTTON9:
+                    case IDD_DBUTTON0:
+                    case IDD_DBUTTONSTAR:
+                    case IDD_DBUTTONPOUND:
+                    {
+                        int     i;
+                        TCHAR   szBuffer[TAPIMAXDESTADDRESSSIZE+1];
+
+                        static const char digits[] = { '1', '2', '3', '4',
+                        '5', '6', '7', '8',
+                        '9', '0', '*', '#' };
+
+                        i = SendDlgItemMessage(ghWndMain,
+                                               IDD_DCOMBO,
+                                               WM_GETTEXT,
+                                               (WPARAM)TAPIMAXDESTADDRESSSIZE+1,
+                                               (LPARAM)szBuffer);
+
+                        if (i < TAPIMAXDESTADDRESSSIZE)
+                        {
+                            MoveMemory(szBuffer+gdwStartSel+1,
+                                       szBuffer+gdwEndSel,
+                                       i - ( gdwEndSel ) + 1 );
+
+                            szBuffer[gdwStartSel] = digits[LOWORD(wParam) - IDD_DBUTTON1];
+
+                            SendDlgItemMessage(ghWndMain,
+                                               IDD_DCOMBO,
+                                               WM_SETTEXT,
+                                               0,
+                                               (LPARAM)szBuffer);
+
+                            gdwStartSel++;
+                            gdwEndSel = gdwStartSel;
+                        }
+
+                        SetFocus(GetDlgItem(ghWndMain, IDD_DDIAL));
+                        EnableWindow(GetDlgItem(ghWndMain, IDD_DDIAL), TRUE);
+
+                        return TRUE;
+                    }
+
+
+                    case IDD_DCOMBO:
+
+                        if (HIWORD(wParam) == CBN_SELENDOK)
+                        {
+                            EnableWindow( GetDlgItem(ghWndMain, IDD_DDIAL), TRUE );
+                        }
+
+                        if ((HIWORD(wParam) == CBN_SELENDOK) ||
+                            (HIWORD(wParam) == CBN_SELENDCANCEL))
+                        {
+
+                            (DWORD)SendDlgItemMessage(ghWndMain,
+                                IDD_DCOMBO,
+                                CB_GETEDITSEL,
+                                (WPARAM)&gdwStartSel,
+                                (LPARAM)&gdwEndSel);
+                            return FALSE;
+                        }
+
+                        if ( HIWORD( wParam ) == CBN_EDITCHANGE )
+                        {
+                            EnableWindow (
+                                          GetDlgItem( ghWndMain, IDD_DDIAL ),
+                                          (BOOL) GetWindowTextLength (
+                                GetDlgItem (
+                                            ghWndMain,
+                                            IDD_DCOMBO
+                                           )
+                                )
+                                         );
+                            return TRUE;
+                        }
+
+                        break;
+
+                    case IDD_DSPEEDDIAL1:
+                    case IDD_DSPEEDDIAL2:
+                    case IDD_DSPEEDDIAL3:
+                    case IDD_DSPEEDDIAL4:
+                    case IDD_DSPEEDDIAL5:
+                    case IDD_DSPEEDDIAL6:
+                    case IDD_DSPEEDDIAL7:
+                    case IDD_DSPEEDDIAL8:
+                    {
+                        DWORD cSDEntry = LOWORD( (DWORD) wParam)  - IDD_DSPEEDDIAL1 + 1;
+                        char szFieldName [MAXBUFSIZE];
+
+                        // get information for the speed dial button
+                        // from the INI file
+                        wsprintf(szFieldName, "Name%d", cSDEntry);                    
+                        GetPrivateProfileString (
+                            "Speed Dial Settings",
+                            szFieldName,
+                            gszNULL,
+                            szName,
+                            TAPIMAXCALLEDPARTYSIZE - 1,
+                            gszINIfilename
+                                                );
+
+                        wsprintf(szFieldName, "%s%d", "Number", cSDEntry);
+                        GetPrivateProfileString (
+                            "Speed Dial Settings",
+                            szFieldName,
+                            gszNULL,
+                            gszSDNumber[cSDEntry],
+                            TAPIMAXDESTADDRESSSIZE - 1,
+                            gszINIfilename
+                                                );
+
+                        // entry not set yet
+                        if( gszSDNumber[cSDEntry][0] == 0 )
+                        {
+                            DialogBoxParam (
+                                            ghInst,
+                                            MAKEINTRESOURCE(IDD_SD2),
+                                            ghWndMain,
+                                            (DLGPROC)SpeedDial2Proc,
+                                            MAKELPARAM(wParam,0)
+                                           );
+                        }
+                        
+                        // no line open
+                        // once the currentline has been set
+                        // using the connect proc
+                        // the user must hit dial again 
+                        else if ( giCurrentLine == (DWORD)-1)
+                        {
+                            DialogBoxParam (
+                                            ghInst,
+                                            MAKEINTRESOURCE(IDD_CONNECTUSING),
+                                            ghWndMain,
+                                            (DLGPROC)ConnectUsingProc,
+                                            INVALID_LINE
+                                           );
+                        }
+                        // entry is set and valid voice line is open
+                        else
+                        {
+                            // add number to list box combo.
+                            AddToRedialList( gszSDNumber[cSDEntry] );
+                            InitiateCall( gszSDNumber[cSDEntry], szName );
+                        }
+                        break;
+                    }
+                           } // end switch (LOWORD((DWORD)wParam)) { ... }
+
+                            break; // end case WM_COMMAND
+                            }
+
+
+                                            case WM_PAINT:
+                                            {
+                                                PAINTSTRUCT ps;
+
+
+                                                BeginPaint(ghWndMain, &ps);
+
+                                                if(IsIconic(ghWndMain))
+                                                    DrawIcon(ps.hdc, 0, 0, hIcon);
+                                                else
+                                                {
+                                                    HBRUSH hBrush;
+
+                                                    hBrush = GetSysColorBrush( COLOR_3DFACE );
+                                                    //                FillRect(ps.hdc, &ps.rcPaint, GetStockObject(LTGRAY_BRUSH));
+                                                    FillRect(ps.hdc, &ps.rcPaint, hBrush);
+                                                }
+
+                                                EndPaint(ghWndMain, &ps);
+
+                                                return TRUE;
+                                            }
+
+
+                                            case WM_DRAWITEM:
+                                            {
+                                                LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
+                                                BOOL fHighlighted = (SendDlgItemMessage(
+                                                    ghWndMain,
+                                                    lpdis->CtlID,
+                                                    BM_GETSTATE,
+                                                    0,
+                                                    0
+                                                    ) & 0x0004);
+
+                                                DrawButton(lpdis->hDC, lpdis->rcItem, fHighlighted);
+                                                DrawButtonText(
+                                                    lpdis->hDC,
+                                                    lpdis->rcItem,
+                                                    fHighlighted,
+                                                    lpdis->CtlID
+                                                    );
+                                                return TRUE;
+                                            }
+
+
+                                            case WM_CTLCOLORLISTBOX:
+                                            case WM_CTLCOLORBTN:
+                                            case WM_CTLCOLORSTATIC:
+                                                SetBkColor((HDC)wParam, GetSysColor(COLOR_BTNFACE));
+                                                return (BOOL)GetSysColorBrush( COLOR_3DFACE );
+
+
+                                            default:
+                                                ;
+                                                //            return DefDlgProc( hwnd, msg, wParam, lParam );
+                                                //            return DefWindowProc( hwnd, msg, wParam, lParam );
+
+
+                    } // switch (msg) { ... }
+
+	return FALSE;
+	}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID AddToRedialList( LPCSTR szNumber )
+{
+	// NLASTDIALED == 10
+	WORD cNum;
+	HWND hWndCombo = GetDlgItem(ghWndMain, IDD_DCOMBO);
+	DWORD nMatch;
+
+	// if valid number
+	if ( szNumber[0] ) 
+	{
+		// if list box has entries, check if this number
+		// is already present.  If so delete old entry
+		cNum = (WORD) SendMessage(hWndCombo, CB_GETCOUNT, 0, 0);
+		if ( cNum != 0 )
+		{
+			nMatch = SendMessage ( hWndCombo, CB_FINDSTRING, 0, (LPARAM)szNumber );
+			if ( nMatch != CB_ERR )
+			{
+				SendMessage(hWndCombo, CB_DELETESTRING, nMatch, 0);
+			}
+			else 
+			{
+				// if the list is full, remove oldest
+				if ( cNum == NLASTDIALED )
+				{
+					SendMessage( hWndCombo, CB_DELETESTRING, NLASTDIALED - 1, 0 );
+				}
+			}
+		}
+		SendMessage(hWndCombo, CB_INSERTSTRING, 0, (LPARAM)szNumber);
+		SendMessage(hWndCombo, CB_SETCURSEL, 0, 0L);
+		EnableWindow ( GetDlgItem( ghWndMain, IDD_DDIAL ), TRUE ); 
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID InitiateCall ( LPCSTR szNumber, LPCSTR szName )
+{
+	HLINE hLine = NULL;
+
+	DWORD errCode;
+
+	// struct size info
+	DWORD dwLTPSize	= sizeof ( LINETRANSLATEOUTPUT );
+	DWORD dwNameLen	= lstrlen( szName ) + 1;
+	DWORD dwLCPSize	= sizeof( LINECALLPARAMS );
+
+	LPLINETRANSLATEOUTPUT lpTransOut = NULL;
+	LPLINECALLPARAMS lpLineCallParams = NULL;
+
+	char szCanNumber[ TAPIMAXDESTADDRESSSIZE ];
+
+	// Open a line
+	errCode = lineOpen (
+						ghLineApp,
+						giCurrentLine,
+						&hLine,
+						gCurrentLineInfo.dwAPIVersion,
+						0,
+						0, 
+						LINECALLPRIVILEGE_NONE,
+						0,
+						NULL
+					   );
+	if (errCode)
+	{
+		errString ( ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+		goto error;
+	}
+
+	
+	// call translate address before dialing
+	do
+	{
+		lpTransOut = (LPLINETRANSLATEOUTPUT) DialerAlloc( dwLTPSize );
+		if ( !lpTransOut )
+		{
+			errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+			goto error;
+		}
+		lpTransOut-> dwTotalSize = dwLTPSize;
+
+
+		if ( !MakeCanonicalNumber( szNumber, szCanNumber ) )
+		{
+			lstrcpy( szCanNumber, szNumber );
+		}
+
+		errCode = lineTranslateAddress (
+										ghLineApp,
+										giCurrentLine,
+										gCurrentLineInfo.dwAPIVersion,
+										szCanNumber,
+										0,
+										0,
+										lpTransOut
+									   );
+		if ( ((LONG)errCode) < 0 )
+		{
+			errString( ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+			goto error;
+		}
+		
+		if ( lpTransOut-> dwNeededSize <= lpTransOut->dwTotalSize  )
+		{
+			// ok we are done
+			break;
+		}
+		else
+		{
+			dwLTPSize = lpTransOut-> dwNeededSize;
+			DialerFree ( lpTransOut );
+			lpTransOut = NULL;
+		}
+
+	} while ( TRUE );
+
+	
+	// if number dialed is 911, bring up a warning
+	if ( Is911( lpTransOut) )
+	{
+		INT nRes = errString ( ghWndMain, ERR_911WARN, MB_ICONSTOP | MB_YESNO );
+		if ( nRes == IDNO )
+		{
+			goto error;
+		}
+	}
+
+	
+	// set call parameters
+	dwLCPSize += dwNameLen + lpTransOut-> dwDisplayableStringSize;
+
+	lpLineCallParams = (LPLINECALLPARAMS) DialerAlloc( dwLCPSize );
+	if ( !lpLineCallParams )
+	{
+		errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+		goto error;
+	}
+
+	lpLineCallParams->dwTotalSize = dwLCPSize;
+	lpLineCallParams->dwBearerMode = LINEBEARERMODE_VOICE;
+	lpLineCallParams->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+	lpLineCallParams->dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
+	lpLineCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+	lpLineCallParams->dwAddressID = giCurrentAddress;
+
+	if ( szName[ 0 ] )
+	{
+		lpLineCallParams->dwCalledPartySize = dwNameLen;
+		lpLineCallParams->dwCalledPartyOffset = sizeof( LINECALLPARAMS );
+		lstrcpy ( 
+					(LPSTR) lpLineCallParams + sizeof(LINECALLPARAMS), 
+					szName 
+			    );
+	}
+
+	lpLineCallParams-> dwDisplayableAddressSize = lpTransOut-> dwDisplayableStringSize;
+	lpLineCallParams-> dwDisplayableAddressOffset = sizeof( LINECALLPARAMS ) + dwNameLen;
+		
+	lstrcpy (
+				(LPSTR) lpLineCallParams + sizeof(LINECALLPARAMS) + dwNameLen,
+				(LPSTR) lpTransOut + lpTransOut-> dwDisplayableStringOffset
+			);
+
+
+	// save dialing information
+	// Free old allocs.
+	if ( gszCurrentName )
+	{
+		DialerFree ( gszCurrentName );
+	}
+
+	if ( gszCurrentNumber )
+	{
+		DialerFree ( gszCurrentNumber );
+	}
+
+	// save new stuff
+	gszCurrentName = (LPSTR) DialerAlloc( dwNameLen );
+	if ( !gszCurrentName )
+	{
+		errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+		goto error;
+	}
+	lstrcpy ( gszCurrentName, szName ); 
+
+	gszCurrentNumber = (LPSTR) DialerAlloc( lpTransOut-> dwDisplayableStringSize );
+	if ( !gszCurrentNumber )
+	{
+		errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+		goto error;
+	}
+	lstrcpy ( 
+			 gszCurrentNumber, 
+			 (LPSTR) lpTransOut + lpTransOut-> dwDisplayableStringOffset  
+			);
+
+	gCurrentLineInfo.hLine = hLine;
+	ghCall = NULL;
+
+
+	// finally make the call.
+	gMakeCallRequestID = 0;
+
+	gMakeCallRequestID = lineMakeCall ( 
+										hLine, 
+										&ghCall, 
+										(LPSTR) lpTransOut + lpTransOut-> dwDialableStringOffset, 
+										0, 
+										lpLineCallParams 
+									  );
+
+	// async request ID 
+	// - the call is going out
+	if ( (LONG) gMakeCallRequestID > 0 ) 
+	{
+		gfCurrentLineAvail = FALSE;
+		gfMakeCallReplyPending = TRUE;
+		DialogBoxParam (
+						ghInst,
+						MAKEINTRESOURCE(IDD_DIALING),
+						ghWndMain,
+						(DLGPROC)DialingProc,
+						0
+					   );
+
+	}
+
+	else 
+	{
+		if ( gMakeCallRequestID == LINEERR_CALLUNAVAIL ) 
+		{
+			DialogBoxParam (
+							ghInst,
+							MAKEINTRESOURCE(IDD_CALLFAILED),
+							ghWndMain,
+							(DLGPROC)LineInUseProc,
+							0
+						   );
+		}
+
+		else
+		{
+			errString( ghWndMain, gMakeCallRequestID, MB_ICONEXCLAMATION | MB_OK );
+		}
+
+		DialerLineClose();
+		gfCurrentLineAvail = TRUE;
+	}
+
+error :
+	if ( lpLineCallParams )
+	{
+		DialerFree( lpLineCallParams );
+	}
+
+	if ( lpTransOut )
+	{
+		DialerFree( lpTransOut );
+	}
+
+	// if makecall did not succeed but line
+	// was opened, close it.
+	if ( ( gMakeCallRequestID <= 0 ) && ( gCurrentLineInfo.hLine ) )
+	{
+		DialerLineClose ();
+		gfCurrentLineAvail = TRUE;
+	}
+
+	SetFocus( GetDlgItem( ghWndMain, IDD_DCOMBO ) );
+
+	return;
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+DWORD GetLineInfo ( DWORD iLine, LPLINEINFO lpLineInfo )
+{
+	DWORD errCode = 0;
+	DWORD dwNeededSize = 0; 
+	LINEEXTENSIONID ExtensionID;
+
+	LPSTR pszLineName = NULL; 
+	LPLINEDEVCAPS lpDevCaps = NULL;
+
+
+	errCode = lineNegotiateAPIVersion (
+										ghLineApp,
+										iLine,
+										TAPI_VERSION_1_0,
+										TAPI_CURRENT_VERSION,
+										&( lpLineInfo->dwAPIVersion ),
+										&ExtensionID
+									  );
+	if ( errCode )
+	{
+		GetLineInfoFailed( iLine, lpDevCaps, lpLineInfo );
+		goto error;
+	}
+
+	dwNeededSize = sizeof( LINEDEVCAPS );
+	do
+	{
+		lpDevCaps = ( LPLINEDEVCAPS ) DialerAlloc( dwNeededSize );
+		if ( !lpDevCaps )
+		{
+			GetLineInfoFailed( iLine, lpDevCaps, lpLineInfo );
+			errCode = LINEERR_NOMEM;
+			goto error;
+		}
+
+		lpDevCaps->dwTotalSize = dwNeededSize;
+		errCode = lineGetDevCaps (
+									ghLineApp,
+									iLine,
+									lpLineInfo->dwAPIVersion,
+									0,
+									lpDevCaps
+								 );
+		if ( errCode )
+		{
+			GetLineInfoFailed( iLine, lpDevCaps, lpLineInfo );
+			goto error;
+		}
+
+		if ( lpDevCaps-> dwNeededSize <= lpDevCaps-> dwTotalSize )
+		{
+			break;
+		}
+
+		dwNeededSize = lpDevCaps->dwNeededSize;
+		DialerFree( lpDevCaps );
+		lpDevCaps = NULL;
+
+	} while ( TRUE );
+
+
+	lpLineInfo->nAddr = lpDevCaps->dwNumAddresses;
+	lpLineInfo->fVoiceLine =
+		( (lpDevCaps->dwMediaModes & LINEMEDIAMODE_INTERACTIVEVOICE) != 0 );
+
+	pszLineName = (LPSTR) DialerAlloc( MAXBUFSIZE );
+	if ( !pszLineName )
+	{
+		errCode = LINEERR_NOMEM;
+		goto error;
+	}
+
+	if ( lpDevCaps->dwLineNameSize > 0 )
+	{
+		if ( lpDevCaps-> dwLineNameSize > (MAXBUFSIZE - 1) )
+		{
+			strncpy ( 
+					 pszLineName, 
+					 (LPSTR) lpDevCaps + lpDevCaps->dwLineNameOffset,
+					 MAXBUFSIZE - 1
+					);
+			pszLineName[ MAXBUFSIZE - 1 ] = '\0';
+		}
+		else
+		{
+			lstrcpy( pszLineName, (LPSTR) lpDevCaps + lpDevCaps-> dwLineNameOffset );
+		}
+	}
+	else 
+	{
+		wsprintf ( pszLineName, "Line %d", iLine );
+	}
+
+
+	lstrcpy( lpLineInfo->szLineName, pszLineName );
+	lpLineInfo->dwPermanentLineID = lpDevCaps->dwPermanentLineID;
+
+	
+error:
+	if ( lpDevCaps )
+		DialerFree( lpDevCaps );
+
+	if ( pszLineName )
+		DialerFree( pszLineName );
+
+	return errCode; 
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID GetLineInfoFailed ( DWORD iLine, LPLINEDEVCAPS lpDevCaps, LPLINEINFO lpLineInfo )
+{
+	if ( lpDevCaps ) 
+		DialerFree(lpDevCaps);
+
+	lpLineInfo->nAddr = 0;
+	lpLineInfo->fVoiceLine = FALSE;
+	lpLineInfo->dwAPIVersion = 0; 
+	lpLineInfo->hLine = (HLINE)0;
+	lpLineInfo->dwPermanentLineID = 0;
+	lpLineInfo->szLineName[0] = 0;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LPSTR GetAddressName(DWORD iLine, DWORD iAddress)
+{
+	DWORD errCode = 0;
+	DWORD dwNeededSize = 0;       
+	LPSTR pszAddressName = NULL;
+	LPLINEADDRESSCAPS lpAddressCaps = NULL;
+
+	// allocate space for lineGetAddressCaps data
+	dwNeededSize = sizeof( LINEADDRESSCAPS );
+	
+	do
+	{
+		lpAddressCaps = ( LPLINEADDRESSCAPS )DialerAlloc( dwNeededSize );
+		if ( !lpAddressCaps )
+		{
+			goto error;
+		}
+
+		lpAddressCaps->dwTotalSize = dwNeededSize;
+		errCode = lineGetAddressCaps (
+										ghLineApp,
+										iLine,
+										iAddress,
+										gCurrentLineInfo.dwAPIVersion,
+										0,
+										lpAddressCaps
+									 );
+		if ( errCode )
+		{
+			errString( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+			goto error;
+		}
+
+		if ( lpAddressCaps-> dwNeededSize <= lpAddressCaps-> dwTotalSize )
+		{
+			break;
+		}
+
+		dwNeededSize = lpAddressCaps->dwNeededSize;
+		DialerFree( lpAddressCaps );
+		lpAddressCaps = NULL;
+
+	} while( TRUE );
+
+
+	// get the address name
+	pszAddressName = DialerAlloc( MAXBUFSIZE );
+	if ( !pszAddressName )
+	{
+		goto error;
+	}
+
+	if ( lpAddressCaps-> dwAddressSize > 0 )
+	{
+		// keep string length bounded
+		if ( lpAddressCaps-> dwAddressSize > (MAXBUFSIZE - 1 ) )
+		{
+			strncpy( 
+					pszAddressName, 
+					(LPSTR) lpAddressCaps + lpAddressCaps->dwAddressOffset,
+					MAXBUFSIZE - 1
+				   );
+			pszAddressName[ MAXBUFSIZE - 1] = '\0';
+		}
+		else
+		{
+			lstrcpy ( 
+					 pszAddressName,
+					 (LPSTR) lpAddressCaps + lpAddressCaps->dwAddressOffset
+				    );
+		}
+	}
+	else 
+	// use default name
+	{
+		wsprintf(pszAddressName, "Address %d", iAddress);
+	}
+
+error:
+	if ( lpAddressCaps )
+	{
+		DialerFree( lpAddressCaps );
+	}
+
+	return pszAddressName;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK DialingProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+
+	switch(msg)
+	{
+		char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+
+		case WM_INITDIALOG:
+			// set global handle to window
+			ghWndDialing = hwnd;
+
+			AmpersandCompensate( gszCurrentName, szTemp );
+            
+			SetDlgItemText(hwnd, IDD_DGNUMBERTEXT, gszCurrentNumber);
+			SetDlgItemText(hwnd, IDD_DGNAMETEXT, szTemp );
+			break;
+
+		case WM_COMMAND:
+			switch ( LOWORD( (DWORD)wParam ) )
+			{
+				// hang up
+				case IDCANCEL: 
+					//gfDropping = TRUE;
+					
+					// if lineMakeCall has completed
+					// only then drop call.
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						if ( ( gDropCallRequestID = lineDrop ( ghCall, NULL, 0 ) ) < 0 )
+						{
+							errString ( ghWndDialing, gDropCallRequestID, MB_ICONSTOP | MB_OK );
+						}
+					}
+					else
+					{
+						DialerLineClose();
+						gfCurrentLineAvail = TRUE;
+						gfMakeCallReplyPending = FALSE;
+					}
+
+					ghWndDialing = NULL;
+					EndDialog(hwnd, FALSE);
+
+					return TRUE;
+
+
+				// something else terminated the call
+				// all we have to do is terminate this dialog box
+				case IDOK: 
+					ghWndDialing = NULL;
+					EndDialog(hwnd, TRUE);
+
+					return TRUE;
+			}
+			break;
+
+		default:
+		  ;
+	}
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK AboutProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    switch(msg)
+    {
+        case WM_INITDIALOG:
+        {
+            return TRUE;
+        }
+
+        case WM_CLOSE:
+            EndDialog(hwnd, TRUE);
+            return TRUE;
+
+        case WM_COMMAND:
+            if(LOWORD((DWORD)wParam) == IDOK)
+            {
+                EndDialog(hwnd, TRUE);
+                return TRUE;
+            }
+
+            break;
+    }
+
+    return FALSE;
+    
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK ConnectUsingProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
+{
+	static const DWORD aMenuHelpIDs[] = 
+	{
+		IDD_CUTEXTLINE,         IDH_DIALER_OPTIONS_LINE,
+		IDD_CULISTLINE,         IDH_DIALER_OPTIONS_LINE,
+		IDD_CUTEXTADDRESS,      IDH_DIALER_OPTIONS_ADDRESS,
+		IDD_CULISTADDRESS,      IDH_DIALER_OPTIONS_ADDRESS,
+		IDD_CUSIMPLETAPICHKBOX, IDH_DIALER_OPTIONS_VOICE,
+		IDD_CUPROPERTIES,       IDH_DIALER_OPTIONS_PROPERTIES,
+		0,                      0
+	};
+
+	switch(msg)
+	{
+		case WM_HELP: 
+			// processes clicks on controls when
+			// context mode help is selected
+			WinHelp (
+						((LPHELPINFO)lParam)->hItemHandle,
+						gszHELPfilename,
+						HELP_WM_HELP,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_CONTEXTMENU:
+			// processes right-clicks on controls
+			WinHelp (
+						(HWND)wParam,
+						gszHELPfilename,
+						HELP_CONTEXTMENU,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_INITDIALOG:
+		{
+			BOOL fEnable;
+			DWORD dwPriority;
+
+			//
+			// Is there any point in even showing this dialog box?
+			if ( gnAvailDevices == 0 )
+			{
+				// Nope.  Let's tell the user what we don't like.
+				errString ( ghWndMain, ERR_NOLINES, MB_ICONEXCLAMATION | MB_OK );
+
+				EndDialog(hwnd, FALSE);
+				return TRUE;
+			}
+
+			// if not brought up by InitializeTAPI()
+			if ( lParam != INVALID_LINE ) 
+			{
+				// hide error text
+				EnableWindow( GetDlgItem( hwnd, IDD_CUERRORTEXT ), FALSE );
+			}
+
+			// get list of lines into the line list box.
+			fEnable = InitializeLineBox( GetDlgItem(hwnd, IDD_CULISTLINE) );
+			EnableWindow( GetDlgItem( hwnd, IDD_CULISTLINE ), fEnable);
+
+			// get list of addresses into the address list box.
+			fEnable =	fEnable && 
+						InitializeAddressBox (
+												GetDlgItem(hwnd, IDD_CULISTLINE),
+												GetDlgItem(hwnd, IDD_CULISTADDRESS)
+											 );
+			EnableWindow( GetDlgItem( hwnd, IDD_CULISTADDRESS ), fEnable );
+			EnableWindow( GetDlgItem( hwnd, IDOK ), fEnable );
+
+			EnableWindow( GetDlgItem( hwnd, IDD_CUPROPERTIES ), fEnable );
+
+			lineGetAppPriority (
+								"DIALER.EXE",
+								0, // checking app priority for Assisted Telephony requests
+								NULL,
+								LINEREQUESTMODE_MAKECALL,
+								NULL,
+								&dwPriority
+							   );
+			CheckDlgButton(hwnd, IDD_CUSIMPLETAPICHKBOX, (dwPriority == 1));
+
+			// if dwPriority == 1, we're supporting Assisted Telephony AND
+			// have the highest priority.
+			EnableWindow (
+							GetDlgItem(hwnd, IDD_CUSIMPLETAPICHKBOX),
+							gfRegistered
+						 );
+
+			return FALSE;
+		}
+
+		case WM_COMMAND:
+		{
+			switch ( LOWORD( (DWORD)wParam ) )
+			{
+				case IDD_CULISTLINE:
+					if ( HIWORD( wParam ) == CBN_SELENDOK )
+						// update address box
+						InitializeAddressBox (
+												GetDlgItem(hwnd, IDD_CULISTLINE),
+												GetDlgItem(hwnd, IDD_CULISTADDRESS)
+											 ); 
+					break;
+
+				case IDD_CUPROPERTIES:
+				{
+					HWND hW = GetDlgItem(hwnd, IDD_CULISTLINE);
+
+					lineConfigDialog (	
+										// device ID
+										(DWORD) SendMessage (
+																hW,
+																CB_GETITEMDATA,
+																(WORD) SendMessage(hW, CB_GETCURSEL, 0, 0),
+																0
+														    ), 
+										hwnd,
+										NULL
+									 );
+					break;
+				}
+
+				case IDOK:
+				{
+					HWND hwndBox;
+					char szBuffer[MAXBUFSIZE];
+					DWORD dwPriority;
+
+					// Update line
+					hwndBox = GetDlgItem( hwnd, IDD_CULISTLINE );
+					giCurrentLine = SendMessage (
+													hwndBox,
+													CB_GETITEMDATA,
+													SendMessage( hwndBox, CB_GETCURSEL, 0, 0 ),
+													0
+												);
+
+					// base 10
+					itoa( gdwPLID[giCurrentLine], szBuffer, 10 ); 
+					WritePrivateProfileString (  
+												"Preference",
+												"Preferred Line",
+												szBuffer,
+												gszINIfilename
+											  );
+
+
+					// Update address
+					hwndBox = GetDlgItem( hwnd, IDD_CULISTADDRESS );
+					giCurrentAddress = SendMessage (
+													hwndBox,
+													CB_GETITEMDATA,
+													SendMessage(hwndBox, CB_GETCURSEL, 0, 0),
+													0
+												   );
+
+					itoa( giCurrentAddress, szBuffer, 10 ); 
+					WritePrivateProfileString ( 
+												"Preference",
+												"Preferred Address",
+												szBuffer,
+												gszINIfilename
+											  );
+
+
+					// Update application priority
+					if ( SendDlgItemMessage (
+												hwnd,
+												IDD_CUSIMPLETAPICHKBOX,
+												BM_GETCHECK,
+												0,
+												0L
+											)
+						  == 0)
+					{
+						dwPriority = 0;
+					}
+					else   
+					{
+						dwPriority = 1;
+					}
+
+					lineSetAppPriority (
+										"DIALER.EXE",
+										0,
+										NULL,
+										LINEREQUESTMODE_MAKECALL,
+										NULL,
+										dwPriority
+									   );
+
+					EndDialog(hwnd, TRUE);
+					return TRUE;
+				}
+
+				case IDCANCEL:
+					EndDialog(hwnd, FALSE);
+					return TRUE;
+			}
+		}
+
+		default:
+			  ;
+
+	}
+
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK LineInUseProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+    {
+    LPARAM lNewParam = lParam;
+    PTSTR  ptStr;
+
+
+    switch(msg)
+        {
+        case WM_INITDIALOG:
+            {
+            switch(lParam)
+                {
+                case LINEDISCONNECTMODE_REJECT:
+                    lNewParam = ikszDisconnectedReject;
+                    break;
+
+                case LINEDISCONNECTMODE_BUSY:
+                    lNewParam = ikszDisconnectedBusy;
+                    break;
+
+                case LINEDISCONNECTMODE_NOANSWER:
+                    lNewParam = ikszDisconnectedNoAnswer;
+                    break;
+
+                case LINEDISCONNECTMODE_CONGESTION:
+                    lNewParam = ikszDisconnectedNetwork;
+                    break;
+
+                case LINEDISCONNECTMODE_INCOMPATIBLE:
+                    lNewParam = ikszDisconnectedIncompatible;
+                    break;
+
+                case LINEDISCONNECTMODE_NODIALTONE:
+                    lNewParam = ikszDisconnectedNoDialTone;
+                    break;
+
+                default:
+                    lNewParam = ikszDisconnectedCantDo;
+                    break;
+                }
+            return TRUE;
+            }
+
+        case WM_COMMAND:
+            if(LOWORD((DWORD)wParam) == IDOK)
+                {
+                EndDialog(hwnd, TRUE);
+                return TRUE;
+                }
+            break;
+
+        default:
+              ;
+//            return DefDlgProc( hwnd, msg, wParam, lParam );
+
+        }    
+
+
+    ptStr = DialerAlloc( MAXBUFSIZE );
+
+    LoadString( ghInst, lNewParam, ptStr, MAXBUFSIZE );
+
+    SetDlgItemText(
+        hwnd,
+        IDD_CFTEXT,
+        ptStr
+        );
+
+    DialerFree( ptStr );
+
+
+    return FALSE;
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK SpeedDial1Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static DWORD nCurrentSpeedDial;
+
+	static const DWORD aMenuHelpIDs[] = 
+	{
+		IDOK,                   IDH_DIALER_SPEED_SAVE,
+		IDD_SD1SPEEDDIAL1,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL2,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL3,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL4,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL5,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL6,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL7,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIAL8,      IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT1,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT2,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT3,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT4,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT5,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT6,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT7,  IDH_DIALER_BUTTONS,
+		IDD_SD1SPEEDDIALTEXT8,  IDH_DIALER_BUTTONS,
+		IDD_SD1TEXTNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD1EDITNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD1TEXTNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		IDD_SD1EDITNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		IDD_SD1TEXTCHOOSE,      (DWORD)-1,
+		IDD_SD1TEXTENTER,       (DWORD)-1,
+		0,                      0
+	};
+
+	// buffer to store speed dial names till they are saved.
+	static TCHAR szSDName[NSPEEDDIALS + 1][TAPIMAXDESTADDRESSSIZE];
+
+	switch(msg)
+	{
+		case WM_HELP:
+			// processes clicks on controls when
+			// context mode help is selected
+			WinHelp(
+				((LPHELPINFO)lParam)->hItemHandle,
+				gszHELPfilename,
+				HELP_WM_HELP,
+				(DWORD)(LPVOID)aMenuHelpIDs
+				);
+			return TRUE;
+
+		case WM_CONTEXTMENU: // processes right-clicks on controls
+			WinHelp(
+				(HWND)wParam,
+				gszHELPfilename,
+				HELP_CONTEXTMENU,
+				(DWORD)(LPVOID)aMenuHelpIDs
+				);
+			return TRUE;
+
+		case WM_INITDIALOG:
+		{
+			DWORD cSDEntry;
+			DWORD idFirstEmpty = (DWORD) -1;
+
+			char szName[TAPIMAXCALLEDPARTYSIZE];
+			char szTemp[TAPIMAXCALLEDPARTYSIZE];
+			char szFieldName[MAXBUFSIZE];
+
+			// Retrieve speed dial info from INI file
+			for(cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry)
+			{
+				wsprintf(szFieldName, "Name%d", cSDEntry);        
+				GetPrivateProfileString (
+											"Speed Dial Settings",
+											szFieldName,
+											gszNULL,
+											szSDName[ cSDEntry ],
+											TAPIMAXCALLEDPARTYSIZE - 1,
+											gszINIfilename
+										);
+
+				// set the first empty speed dial button
+				if ( idFirstEmpty == -1 && 
+					 szSDName[ cSDEntry ][0] == '\0' &&
+					 gszSDNumber[ cSDEntry ][ 0 ] == '\0' )
+					idFirstEmpty = cSDEntry;
+
+				wsprintf(szFieldName, "Number%d", cSDEntry);
+				GetPrivateProfileString (
+											"Speed Dial Settings",
+											szFieldName,
+											gszNULL,
+											gszSDNumber[cSDEntry],
+											MAXBUFSIZE - 1,
+											gszINIfilename
+										);
+
+				// get a copy of the name for editing
+				// if name is empty, use the number as the
+				// name.
+				if ( lstrcmp( gszNULL, szSDName[ cSDEntry ] ) )
+				{			
+					lstrcpy( szName, szSDName[ cSDEntry] );
+				}
+				else
+				{
+					lstrcpy( szName, gszSDNumber[ cSDEntry ] );
+				}
+			
+				FitTextToButton( hwnd, IDD_SD1SPEEDDIAL1 + cSDEntry - 1, szName );
+				AmpersandCompensate( szName, szTemp );
+
+				SetDlgItemText (
+								hwnd,
+								IDD_SD1SPEEDDIAL1 + cSDEntry - 1,
+								(LPCSTR) szTemp
+							   ); 
+
+			}
+
+			// for the edit speed dial dialog
+			// limit the lengths of text
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD1EDITNAME,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXCALLEDPARTYSIZE - 1),
+								0
+							   );
+
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD1EDITNUMBER,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXDESTADDRESSSIZE - 1),
+								0
+							   );
+
+			// select the first empty button
+			// nothing empty, then edit #1
+			if ( -1 == idFirstEmpty ) 
+			{
+				nCurrentSpeedDial = 1;
+				SetDlgItemText(
+								hwnd,
+								IDD_SD1EDITNAME,
+								(LPCSTR) szSDName[ 1 ]
+							  );
+
+				SetDlgItemText(
+								hwnd,
+								IDD_SD1EDITNUMBER,
+								(LPCSTR) gszSDNumber[ 1 ]
+							  );
+			}
+			else
+			{
+				nCurrentSpeedDial = idFirstEmpty;
+			}
+
+			SetFocus( GetDlgItem( hwnd, IDD_SD1EDITNAME ) );
+			return FALSE;
+		}
+
+		case WM_COMMAND:
+		{
+			char szName[TAPIMAXCALLEDPARTYSIZE];
+			char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+
+			switch( LOWORD( (DWORD) wParam ) )
+			{
+				case IDOK:
+				{
+					DWORD cSDEntry;
+					char szFieldName[MAXBUFSIZE];
+
+					// save new speed dial settings
+					for ( cSDEntry = 1; cSDEntry <= NSPEEDDIALS; ++cSDEntry )
+					{
+						wsprintf(szFieldName, "Name%d", cSDEntry);
+						WritePrivateProfileString ( 
+													"Speed Dial Settings",
+													szFieldName,
+													szSDName [cSDEntry],
+													gszINIfilename
+												  );
+
+						wsprintf(szFieldName, "Number%d", cSDEntry);
+						WritePrivateProfileString ( 
+													"Speed Dial Settings",
+													szFieldName,
+													gszSDNumber[cSDEntry],
+													gszINIfilename
+												  );
+
+						// set the text for the corresponding 
+						// main window button
+						if ( szSDName[ cSDEntry ][ 0 ] == '\0' )
+						{
+							lstrcpy( szName, gszSDNumber[ cSDEntry ] );
+						}
+						else
+						{
+							lstrcpy( szName, szSDName[ cSDEntry ] );
+						}
+
+						FitTextToButton( 
+										ghWndMain, 
+										IDD_DSPEEDDIAL1 + cSDEntry - 1, 
+										szName 
+									   );
+
+						AmpersandCompensate( szName, szTemp );
+						SetDlgItemText ( 
+										ghWndMain,
+										IDD_DSPEEDDIAL1 + cSDEntry - 1,
+										(LPCSTR) szTemp
+									   );
+					}
+
+					EndDialog(hwnd, TRUE);
+					return TRUE;
+				}
+
+				case IDCANCEL:
+					EndDialog(hwnd, FALSE);
+					return TRUE;
+
+				case IDD_SD1SPEEDDIAL1:
+				case IDD_SD1SPEEDDIAL2:
+				case IDD_SD1SPEEDDIAL3:
+				case IDD_SD1SPEEDDIAL4:
+				case IDD_SD1SPEEDDIAL5:
+				case IDD_SD1SPEEDDIAL6:
+				case IDD_SD1SPEEDDIAL7:
+				case IDD_SD1SPEEDDIAL8:
+
+					nCurrentSpeedDial =	LOWORD( (DWORD) wParam ) - IDD_SD1SPEEDDIAL1 + 1;
+
+					SetDlgItemText (
+									hwnd,
+									IDD_SD1EDITNAME,
+									szSDName [ nCurrentSpeedDial ]
+								   );
+					SetDlgItemText (
+									hwnd,
+									IDD_SD1EDITNUMBER,
+									gszSDNumber[nCurrentSpeedDial]
+								   );
+
+					SetFocus( GetDlgItem( hwnd, IDD_SD1EDITNAME ) );
+					SendDlgItemMessage(
+										hwnd,
+										IDD_SD1EDITNAME,
+										EM_SETSEL,
+										0,
+										MAKELPARAM(0, -1)
+									);
+					break;
+
+				case IDD_SD1EDITNAME:
+					if ( HIWORD( wParam ) == EN_CHANGE )
+					{
+
+						GetDlgItemText (
+										hwnd,
+										IDD_SD1EDITNAME,
+										szName,
+										TAPIMAXCALLEDPARTYSIZE
+									   );
+
+						// if there is no name, label the button with
+						// the number
+						if ( szName[ 0 ] == '\0' )
+						{
+							szSDName[ nCurrentSpeedDial ][ 0 ] = '\0';
+							lstrcpy( szName, gszSDNumber[ nCurrentSpeedDial ] );
+						}
+						else
+						{
+							lstrcpy( szSDName[ nCurrentSpeedDial ], szName );
+						}
+
+						FitTextToButton ( 
+											hwnd, 
+											IDD_SD1SPEEDDIAL1 + nCurrentSpeedDial - 1,
+											szName
+										);
+						AmpersandCompensate( szName, szTemp );
+
+						SetDlgItemText (
+										hwnd,
+										IDD_SD1SPEEDDIAL1 + nCurrentSpeedDial - 1,
+										szTemp
+									   );
+					}
+					break;
+
+				case IDD_SD1EDITNUMBER:
+					if ( HIWORD( wParam ) == EN_CHANGE )
+					{
+						GetDlgItemText (
+										hwnd,
+										IDD_SD1EDITNUMBER,
+										gszSDNumber[nCurrentSpeedDial],
+										TAPIMAXDESTADDRESSSIZE
+									   );
+
+						if ( gszSDNumber[ nCurrentSpeedDial ][ 0 ] == '\0' )
+						{
+							GetDlgItemText (
+											hwnd,
+											IDD_SD1EDITNAME,
+											szName,
+											TAPIMAXDESTADDRESSSIZE
+										   );
+
+							if ( szName[ 0 ] == '\0' )
+							{
+								SetDlgItemText ( 
+												hwnd,
+												IDD_SD1SPEEDDIAL1 + nCurrentSpeedDial - 1,
+												szName
+											   );
+
+							}
+						}
+					}
+					break;
+				} // switch(LOWORD((DWORD)wParam))
+			break;
+
+		} // case WM_COMMAND:
+
+		default:
+			  ;
+
+	} // switch(msg)
+
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK SpeedDial2Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static DWORD nCurrentSpeedDial;
+
+	static const DWORD aMenuHelpIDs[] = 
+	{
+		IDOK,                   IDH_DIALER_SPEED_SAVE,
+		IDD_SD2SAVEANDDIAL,     IDH_DIALER_SPEED_SAVE_DIAL,
+		IDD_SD2TEXTNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD2EDITNAME,        IDH_DIALER_SPEED_NAME,
+		IDD_SD2TEXTNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		IDD_SD2EDITNUMBER,      IDH_DIALER_SPEED_NUMBER,
+		0,                      0
+	};
+
+	switch(msg)
+	{
+		case WM_HELP: 
+			// processes clicks on controls when
+			// context mode help is selected
+			WinHelp (
+						((LPHELPINFO)lParam)->hItemHandle,
+						gszHELPfilename,
+						HELP_WM_HELP,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_CONTEXTMENU: 
+			// processes right-clicks on controls
+			WinHelp (
+						(HWND)wParam,
+						gszHELPfilename,
+						HELP_CONTEXTMENU,
+						(DWORD)(LPVOID)aMenuHelpIDs
+					);
+			return TRUE;
+
+		case WM_INITDIALOG:
+		{
+			char szFieldName [MAXBUFSIZE];
+			char szName [TAPIMAXCALLEDPARTYSIZE];
+
+			nCurrentSpeedDial = LOWORD( lParam ) - IDD_DSPEEDDIAL1 + 1;
+
+			// retrieve speed dial button info
+			wsprintf(szFieldName, "Name%d", nCurrentSpeedDial);
+			GetPrivateProfileString (
+										"Speed Dial Settings",
+										szFieldName,
+										gszNULL,
+										szName,
+										TAPIMAXCALLEDPARTYSIZE - 1,
+										gszINIfilename
+									);
+			SetDlgItemText (
+							hwnd,
+							IDD_SD2EDITNAME,
+							szName
+						   );
+
+			SetDlgItemText (
+							hwnd,
+							IDD_SD2EDITNUMBER,
+							gszSDNumber[nCurrentSpeedDial]
+						   );
+
+			// limit the lengths of the texts
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD2EDITNAME,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXCALLEDPARTYSIZE - 1),
+								0
+							   );
+
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD2EDITNUMBER,
+								EM_LIMITTEXT,
+								(WPARAM)(TAPIMAXDESTADDRESSSIZE - 1),
+								0
+							   );
+
+
+			SetFocus( GetDlgItem( hwnd, IDD_SD2EDITNAME ) );
+			SendDlgItemMessage (
+								hwnd,
+								IDD_SD2EDITNAME,
+								EM_SETSEL,
+								0,
+								MAKELPARAM(0, -1)
+							   );
+
+			return FALSE;
+		}
+
+		case WM_COMMAND:
+		{
+			char szName[ TAPIMAXCALLEDPARTYSIZE ];
+			char szTemp[ TAPIMAXCALLEDPARTYSIZE ];
+			char szFieldName[MAXBUFSIZE];
+
+			switch ( LOWORD( (DWORD) wParam ) )
+			{
+				case IDOK:
+				case IDD_SD2SAVEANDDIAL:
+				{
+					GetDlgItemText (
+									hwnd,
+									IDD_SD2EDITNAME,
+									(LPTSTR) szName,
+									TAPIMAXCALLEDPARTYSIZE
+								   );
+
+					GetDlgItemText (
+									hwnd,
+									IDD_SD2EDITNUMBER,
+									(LPTSTR) gszSDNumber[nCurrentSpeedDial],
+									TAPIMAXCALLEDPARTYSIZE
+								   );
+
+					wsprintf ( szFieldName, "Name%d", nCurrentSpeedDial );
+
+					WritePrivateProfileString ( 
+												"Speed Dial Settings",
+												szFieldName,
+												szName,
+												gszINIfilename
+											  );
+	
+					wsprintf ( szFieldName, "Number%d", nCurrentSpeedDial );
+					WritePrivateProfileString ( 
+												"Speed Dial Settings",
+												szFieldName,
+												gszSDNumber[nCurrentSpeedDial],
+												gszINIfilename
+											  );
+
+					// update main window buttons
+					// is only number has been entered, label button with it.
+					if ( szName[ 0 ] == '\0' )
+					{
+						lstrcpy( szName, gszSDNumber[ nCurrentSpeedDial ] );
+					}
+
+					FitTextToButton ( 
+										ghWndMain, 
+										IDD_DSPEEDDIAL1 + nCurrentSpeedDial - 1, 
+										(LPSTR) szName
+									);
+
+					AmpersandCompensate( szName, szTemp );
+					
+					SetDlgItemText ( 
+									ghWndMain,
+									IDD_DSPEEDDIAL1 + nCurrentSpeedDial - 1,
+									(LPCSTR)szTemp
+								   );
+
+					// if save and dial, then post dial message to main window
+					if ( LOWORD( (DWORD) wParam ) == IDD_SD2SAVEANDDIAL )
+					{
+						PostMessage (
+										ghWndMain,
+										WM_COMMAND,
+										MAKEWPARAM (
+													nCurrentSpeedDial + IDD_DSPEEDDIAL1 - 1,
+													BN_CLICKED
+												   ),
+										(LPARAM) GetDlgItem (
+																ghWndMain,
+																nCurrentSpeedDial + IDD_DSPEEDDIAL1 - 1
+															)
+									);
+					}
+					EndDialog(hwnd, TRUE);
+					return TRUE;
+				}
+
+				case IDCANCEL:
+					EndDialog(hwnd, FALSE);
+					return TRUE;
+
+				case IDD_SD2EDITNAME:
+				case IDD_SD2EDITNUMBER:
+					if ( HIWORD( wParam ) == EN_CHANGE)
+					{
+						EnableWindow (
+										GetDlgItem( hwnd, IDD_SD2SAVEANDDIAL ),
+										GetWindowTextLength ( GetDlgItem( hwnd, IDD_SD2EDITNUMBER ) ) > 0
+									 );
+					}
+					break;
+
+			} // switch(LOWORD((DWORD)wParam))
+			break;
+		}
+
+
+		default:
+			  ;
+
+	} // switch(msg)
+
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID CALLBACK
+tapiCallback (
+				DWORD   hDevice,
+				DWORD   dwMsg,
+				DWORD   dwCBInstance,
+				DWORD   dwParam1,
+				DWORD   dwParam2,
+				DWORD   dwParam3
+		    )
+{
+	switch (dwMsg)
+	{
+		INT errCode;
+
+		case LINE_ADDRESSSTATE:
+			break;
+
+		case LINE_CALLINFO:
+			break;
+
+		case LINE_CALLSTATE:
+			if ( (HCALL)hDevice != ghCall )
+				return;
+
+			switch ( dwParam1 ) // new state
+			{
+				case LINECALLSTATE_IDLE:
+
+					// tell "Dialing" window to terminate
+					if ( ghWndDialing )
+					{
+						SendMessage ( 
+										ghWndDialing,
+										WM_COMMAND,
+										MAKEWPARAM( IDOK, 0 ),
+										0
+									);
+					}
+
+					// tapi call cleanup
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						if ( ( errCode = lineDeallocateCall( ghCall ) ) < 0 )
+						{
+							errString ( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+						}
+						ghCall = NULL;
+					}
+					DialerLineClose();
+					gfCurrentLineAvail = TRUE;
+
+					// update main window
+					DisableDialButtons( FALSE );
+					break;
+
+				case LINECALLSTATE_BUSY:
+					tapiCallback (
+									hDevice,
+									dwMsg,
+									dwCBInstance,
+									LINECALLSTATE_DISCONNECTED,
+									LINEDISCONNECTMODE_BUSY,
+									dwParam3
+								 );
+					break;
+
+				case LINECALLSTATE_SPECIALINFO:
+					tapiCallback (
+									hDevice,
+									dwMsg,
+									dwCBInstance,
+									LINECALLSTATE_DISCONNECTED,
+									LINEDISCONNECTMODE_UNREACHABLE,
+									dwParam3
+								 );
+					break;
+
+				case LINECALLSTATE_DISCONNECTED:
+				{
+					BOOL fCallOK;
+					DWORD LineDisconnectMode;
+
+
+					if ( dwParam2 == 0 )
+						LineDisconnectMode = LINEDISCONNECTMODE_NORMAL;
+					else
+						LineDisconnectMode = dwParam2;
+
+					fCallOK = ( LineDisconnectMode == LINEDISCONNECTMODE_NORMAL		||
+								LineDisconnectMode == LINEDISCONNECTMODE_UNKNOWN	||
+								LineDisconnectMode == LINEDISCONNECTMODE_PICKUP		||
+								LineDisconnectMode == LINEDISCONNECTMODE_FORWARDED	||
+								LineDisconnectMode == LINEDISCONNECTMODE_UNAVAIL
+							  );
+
+					
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						//gfDropping = TRUE;
+						if ( ( gDropCallRequestID = lineDrop ( ghCall, NULL, 0 ) ) < 0 )
+						{
+							errString ( ghWndMain, gDropCallRequestID, MB_ICONSTOP | MB_OK );
+						}
+					}
+
+					if ( !fCallOK )
+						DialogBoxParam (
+										ghInst,
+										MAKEINTRESOURCE(IDD_CALLFAILED),
+										ghWndMain,
+										(DLGPROC)LineInUseProc,
+										LineDisconnectMode
+									   );
+					break;
+				}
+			}
+			break;
+
+
+		case LINE_CLOSE:
+			if ( gCurrentLineInfo.hLine == (HLINE)hDevice )
+			{
+				errString(ghWndMain, ERR_LINECLOSE, MB_ICONEXCLAMATION | MB_OK );
+				gCurrentLineInfo.hLine = NULL;
+				gfCurrentLineAvail = FALSE;
+				DisableDialButtons(FALSE);                
+			}
+			break;
+
+		case LINE_CREATE:
+			// dwParam1 is the new device's ID
+			if ( dwParam1 >= gnAvailDevices ) 
+			{
+				DWORD* gnAddrTemp;
+				DWORD iLine;
+				LINEINFO LineInfo;
+
+				// we record new device's address count.
+
+                // we are assuming here that we're just adding a new
+                // line and it's sequential and it's the last one
+
+                gnAvailDevices = dwParam1 + 1;
+                
+				gnAddrTemp = (DWORD *) DialerAlloc ( sizeof(DWORD) * (int)(gnAvailDevices) );
+
+				for ( iLine = 0; iLine < (gnAvailDevices-1); ++iLine )
+					gnAddrTemp[iLine] = gnAddr[iLine];
+
+				DialerFree( gnAddr );
+
+				// we have effectively added one more
+				// space in the gnAddr array
+				gnAddr = gnAddrTemp; 
+
+				if ( GetLineInfo( dwParam1, &LineInfo ) != ERR_NONE )
+					break;
+
+ 				gnAddr[dwParam1] = LineInfo.nAddr;
+			}
+			break;
+
+		case LINE_DEVSPECIFIC:
+			break;
+
+		case LINE_DEVSPECIFICFEATURE:
+			break;
+
+		case LINE_GATHERDIGITS:
+			break;
+
+		case LINE_GENERATE:
+			break;
+
+		case LINE_LINEDEVSTATE:
+			if ( dwParam1 & LINEDEVSTATE_REINIT )
+			{
+				if(dwParam2 != 0) 
+				{
+					// this is another msg translated into REINIT
+					tapiCallback( hDevice, dwParam2, dwCBInstance, dwParam3, 0, 0 );
+				}
+				else 
+				{
+					// Re-initialize TAPI
+					gfNeedToReinit = TRUE;
+				}
+			}
+
+			if ( dwParam1 & LINEDEVSTATE_REMOVED )
+			{
+				DialerLineClose();
+				tapiCallback(hDevice, LINE_CLOSE, dwCBInstance, 0, 0, 0); // is this needed?
+			}
+			break;
+
+		case LINE_MONITORDIGITS:
+			break;
+
+		case LINE_MONITORMEDIA:
+			break;
+
+		case LINE_MONITORTONE:
+			break;
+
+		// async reply from lineMakeCall() or lineDrop()
+		case LINE_REPLY:
+
+			// reply for lineMakeCall 
+			if ( (LONG) dwParam1 == gMakeCallRequestID )
+			{
+				// error on make call
+				if ( dwParam2 != ERR_NONE )
+				{
+					// Get rid of the Dialing Dialog box if it's up
+					if ( ghWndDialing )
+					{
+					   SendMessage(
+									ghWndDialing,
+									WM_COMMAND,
+									MAKEWPARAM(IDOK,0),
+									0
+								  );
+					}
+
+					if ( dwParam2 == LINEERR_CALLUNAVAIL )
+					{
+						DialogBoxParam (
+										ghInst,
+										MAKEINTRESOURCE(IDD_CALLFAILED),
+										ghWndMain,
+										(DLGPROC)LineInUseProc,
+										0
+									   );
+					}
+					else
+					{
+						errString ( ghWndMain, dwParam2, MB_ICONEXCLAMATION | MB_OK );
+					}
+
+					ghCall = NULL;
+					DialerLineClose();
+					gfCurrentLineAvail = TRUE;
+				}
+
+				gfMakeCallReplyPending = FALSE;
+			}
+
+			// reply from lineDrop()
+			if ( (LONG) dwParam1 == gDropCallRequestID )
+			{
+				//gfDropping = FALSE;
+
+				// tell "Dialing" window to terminate
+				if ( ghWndDialing )
+				{
+					SendMessage ( 
+									ghWndDialing,
+									WM_COMMAND,
+									MAKEWPARAM( IDOK,0 ),
+									0
+								);
+				}
+				
+				// tapi call cleanup
+				if ( dwParam2 == ERR_NONE )
+				{
+					if ( !gfMakeCallReplyPending && ghCall )
+					{
+						if ( ( errCode = lineDeallocateCall( ghCall ) ) < 0 )
+						{
+							errString ( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+						}
+						ghCall = NULL;
+					}
+				}
+				DialerLineClose ();
+				gfCurrentLineAvail = TRUE;
+			}
+
+			break;
+
+		case LINE_REQUEST:
+			// Simple TAPI request
+			if ( dwParam1 == LINEREQUESTMODE_MAKECALL )
+			{
+				gfCallRequest = TRUE;
+			}
+			break;
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL InitializeLineBox(HWND hwndLineBox)
+{
+
+	DWORD iLine, iItem, iItemCurrent = (DWORD)-1;
+	DWORD errCode;
+
+	LPLINEINFO lpLineInfo = NULL;
+
+	// allocate buffer for storing LINEINFO for all of 
+	// the available lines.  Always allocate space for 
+	// at least one line
+	if ( gnAvailDevices == 0 )
+	{
+		lpLineInfo = (LPLINEINFO) DialerAlloc( sizeof(LINEINFO) );
+	}
+	else
+	{
+		lpLineInfo = (LPLINEINFO) DialerAlloc ( sizeof(LINEINFO) * (int)gnAvailDevices );
+	}
+
+	// if no space was set aside...
+	if ( lpLineInfo == NULL ) 
+		return LINEERR_NOMEM;
+
+	// fill lpLineInfo[] and open each line
+	for ( iLine = 0; iLine < gnAvailDevices; ++iLine )
+	{
+		// skip remaining processing for this line if it didn't open
+		if ( GetLineInfo( iLine, &lpLineInfo[iLine] ) != ERR_NONE )
+		{
+			continue;
+		}
+
+		iItem = SendMessage (
+								hwndLineBox,
+								CB_ADDSTRING,
+								0,
+								(LPARAM)(LPCSTR)(lpLineInfo[iLine].szLineName)
+							);
+
+		// error, bail out.
+		if ( iItem == CB_ERR || iItem == CB_ERRSPACE )
+		{
+            if (lpLineInfo)
+            {
+                DialerFree(lpLineInfo);
+            }
+            
+			return FALSE; 
+		}
+
+		errCode = SendMessage (
+								hwndLineBox,
+								CB_SETITEMDATA,
+								(WPARAM)iItem,
+								(LPARAM)iLine
+							  );
+
+		if ( iLine == giCurrentLine )
+		{
+			iItemCurrent = iItem;
+		}
+		else if ( iItemCurrent != -1 && iItem <= iItemCurrent )
+		{
+			// if the item we are putting is before the
+			// "current" item, we must increment iItemCurrent
+			// to reflect that something is being placed before
+			// it, due to sorting
+			++iItemCurrent;
+		}
+	}
+
+	if ( iItemCurrent == (DWORD)-1 )
+		iItemCurrent = 0;
+
+	if ( SendMessage( hwndLineBox, CB_GETCOUNT, 0, 0) != 0 )
+	{
+		SendMessage( hwndLineBox, CB_SETCURSEL, (WPARAM)iItemCurrent, 0 );
+		return TRUE;
+	}
+
+    DialerFree(lpLineInfo);
+	return FALSE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL InitializeAddressBox( HWND hwndLineBox, HWND hwndAddressBox )
+{
+	DWORD errCode;
+	DWORD iAddress, iItem, iItemCurrent = (DWORD)-1;
+	DWORD iLineBoxCurrent;
+	LPSTR pszAddressName;
+
+	if ( SendMessage( hwndLineBox, CB_GETCOUNT, 0, 0 ) == 0 )
+	{
+		return FALSE;
+	}
+
+	// select current entry in line box
+	iLineBoxCurrent = SendMessage ( 
+									hwndLineBox,
+									CB_GETITEMDATA,
+									SendMessage( hwndLineBox, CB_GETCURSEL, 0, 0 ),
+									0
+								  );
+	// empty address list box
+	SendMessage ( hwndAddressBox, CB_RESETCONTENT, 0, 0); 
+
+	// get all the address for this line
+	for ( iAddress = 0; iAddress < gnAddr[iLineBoxCurrent]; ++iAddress )
+	{
+		pszAddressName = GetAddressName( iLineBoxCurrent, iAddress );
+
+		// if this address if fails, try the next one
+		if ( !pszAddressName )
+			continue; 
+
+		iItem = SendMessage (
+								hwndAddressBox,
+								CB_ADDSTRING,
+								0,
+								(LPARAM) (LPCSTR) (pszAddressName)
+							);
+
+		// error, bail out
+		if ( iItem == CB_ERR || iItem == CB_ERRSPACE )
+			return FALSE; 
+
+		errCode = SendMessage (
+								hwndAddressBox,
+								CB_SETITEMDATA,
+								(WPARAM) iItem,
+								(LPARAM) iAddress
+							  );
+
+		if ( iLineBoxCurrent == giCurrentLine )
+		{
+			if(iAddress == giCurrentAddress)
+			{
+				iItemCurrent = iItem;
+			}
+			else 
+			{
+				// if the item we are putting is before the
+				// "current" item, we must increment iItemCur
+				// to reflect that something is being placed
+				// before it, due to sorting
+				if ( iItemCurrent != -1 && iItem <= iItemCurrent )
+				{
+					++iItemCurrent; 
+				}
+			}
+		}
+
+		DialerFree( pszAddressName );
+	}
+	
+	if ( iLineBoxCurrent != giCurrentLine )
+	{	
+		// if we're not looking at the current line
+		// then highlight address 0
+		iItemCurrent = 0;
+	}
+
+	SendMessage (
+					hwndAddressBox,
+					CB_SETCURSEL,
+					iItemCurrent,
+					0
+				);
+	return TRUE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID ManageAssistedTelephony(VOID)
+{
+	DWORD errCode;
+	LPLINEREQMAKECALL lpRequestBuffer;
+
+	lpRequestBuffer = (LPLINEREQMAKECALL) DialerAlloc( sizeof( LINEREQMAKECALL ) );
+	if ( !lpRequestBuffer ) 
+	{
+		goto error;
+	}
+
+    // bring window to front
+    SetForegroundWindow(ghWndMain);
+    
+	// get next queued request.
+	errCode = lineGetRequest (
+								ghLineApp,
+								LINEREQUESTMODE_MAKECALL,
+								lpRequestBuffer
+	
+							 );
+	if ( errCode )
+	{
+		// if no more call requests pending, reset flag.
+		if ( errCode == LINEERR_NOREQUEST )
+		{
+			gfCallRequest = FALSE;
+		}
+		else
+		{
+			errString ( ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+		}
+		goto error;
+	}
+
+	
+	// if a line has not been selected
+	if ( giCurrentLine == (DWORD)-1 )
+	{
+		if (!DialogBoxParam (
+						ghInst,
+						MAKEINTRESOURCE(IDD_CONNECTUSING),
+						ghWndMain,
+						(DLGPROC) ConnectUsingProc,
+						INVALID_LINE
+					  ))
+        {
+            // failed to get a line
+            goto error;
+        }
+	}
+
+	// make the reuested call.
+	InitiateCall (
+					lpRequestBuffer->szDestAddress,
+					lpRequestBuffer->szCalledParty
+				 );
+
+error :
+	if ( lpRequestBuffer )
+	{
+		DialerFree( lpRequestBuffer );
+	}
+	return;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID DialerLineClose()
+{
+	DWORD errCode;
+
+	if ( gCurrentLineInfo.hLine )
+	{
+		if ( errCode = lineClose ( gCurrentLineInfo.hLine ) )
+		{
+			errString ( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+		}
+		gCurrentLineInfo.hLine = NULL;
+	}
+
+
+	// re-initialize TAPI if it needs to be re-initialized
+	if ( gfNeedToReinit ) 
+	{
+		CloseTAPI();
+
+		errCode = InitializeTAPI();
+		if(errCode)
+		{
+			errString(ghWndMain, errCode, MB_APPLMODAL | MB_ICONEXCLAMATION );
+			DialerCleanup(); // terminate program if we can't init
+			return;
+		}
+
+		errCode = lineRegisterRequestRecipient (
+												ghLineApp,
+												0, 
+												LINEREQUESTMODE_MAKECALL,
+												TRUE
+											   );
+		if (errCode)
+		{
+			errString(ghWndMain, errCode, MB_ICONEXCLAMATION | MB_OK );
+		}
+
+		gfNeedToReinit = FALSE;
+	}
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+int errString( HWND hWndOwner, UINT errCode, UINT uFlags )
+{
+	PTSTR ptStrTitle;
+	PTSTR ptStrError;
+	int   nResult;
+    BOOL  bDefault = FALSE;
+
+	ptStrTitle = DialerAlloc( MAXBUFSIZE );
+	if ( NULL == ptStrTitle )
+	{
+	   // Now, _this_ is a problem.
+	   return 0;
+	}
+
+	ptStrError = DialerAlloc( MAXBUFSIZE );
+	if ( NULL == ptStrError )
+	{
+	   // Now, _this_ is a problem.
+	   DialerFree( ptStrTitle);
+	   return 0;
+	}
+
+	switch(errCode)
+	{
+		case ERR_NOLINES:
+			errCode = ikszErrNoVoiceLine;
+			break;
+
+		case ERR_NOVOICELINE:
+			errCode = ikszErrNoVoiceLine;
+			break;
+    
+		case ERR_LINECLOSE:
+			errCode = ikszErrLineClose;
+			break;
+
+		case ERR_911WARN:
+			errCode = ikszWarningFor911;
+			break;
+    
+		case ERR_NEWDEFAULT:
+			errCode = ikszWarningNewDefault;
+			break;
+
+		case LINEERR_NODRIVER:
+			errCode = ikszErrLineInitNoDriver;
+			break;
+    
+		case LINEERR_NODEVICE:
+			errCode = ikszErrLineInitNoDevice;
+			break;
+    
+		case LINEERR_INIFILECORRUPT:
+			errCode = ikszErrLineInitBadIniFile ;
+			break;
+    
+		case LINEERR_NOMEM:
+			errCode = ikszErrOOM;
+			break;
+    
+		case LINEERR_INCOMPATIBLEAPIVERSION:
+			errCode = ikszErrLineInitWrongDrivers ;
+			break;
+    
+		case LINEERR_OPERATIONFAILED:
+			errCode = ikszErrTAPI;
+			break;
+    
+		case LINEERR_INVALADDRESS:
+			errCode = ikszErrInvalAddress;
+			break;
+    
+		case LINEERR_ADDRESSBLOCKED:
+			errCode = ikszErrAddrBlocked;
+			break;
+    
+		case LINEERR_BILLINGREJECTED:
+			errCode = ikszErrBillingRejected;
+			break;
+    
+		case LINEERR_RESOURCEUNAVAIL:
+		case LINEERR_ALLOCATED:
+		case LINEERR_INUSE:
+			errCode = ikszErrResUnavail;
+			break;
+    
+		case LINEERR_NOMULTIPLEINSTANCE:
+			errCode = ikszErrNoMultipleInstance;
+			break;
+    
+		case LINEERR_INVALCALLSTATE:
+			errCode = ikszErrInvalCallState;
+			break;
+
+        case LINEERR_INVALCOUNTRYCODE:
+            errCode = ikszErrInvalidCountryCode;
+            break;
+    
+		default:
+            bDefault = TRUE;
+            break;
+
+	}
+
+
+    if (bDefault)
+    {
+        // if using default error, get TAPI's
+        // error message from FormatError()
+        if (!FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+                           (LPCVOID)GetModuleHandle(TEXT("TAPI32.DLL")),
+                           (DWORD)TAPIERROR_FORMATMESSAGE(errCode),
+                           0,
+                           (LPTSTR)ptStrError,
+                           MAXBUFSIZE,
+                           NULL))
+        {
+            // if this fails, fall back on default
+            LoadString( ghInst, ikszErrDefault, ptStrError, MAXBUFSIZE);
+        }
+
+    }
+    else    // not the default error message
+    {
+
+        if ( 0 == LoadString( ghInst, errCode, ptStrError, MAXBUFSIZE ) )
+        {
+#if DBG
+            TCHAR buf[200];
+            wsprintf( buf, "Cannot load string: hinst:0x%08lx errcode: %ld", (DWORD)ghInst,(DWORD)errCode);
+            OutputDebugString( buf );
+            MessageBox( NULL, buf, "Dialer", MB_OK);
+#endif
+
+            LoadString( ghInst, ikszErrDefault, ptStrError, MAXBUFSIZE );
+        }
+    }
+
+    LoadString( ghInst, ikszWarningTitle, ptStrTitle, MAXBUFSIZE );
+
+	nResult = MessageBox( hWndOwner, ptStrError, ptStrTitle, uFlags );
+
+
+	DialerFree( ptStrTitle );
+	DialerFree( ptStrError );
+
+
+	return nResult;
+}
+
+
+/*
+ *	Name :
+ *		FitTextToButton 
+ *
+ *	Arguements :
+ *		hDlg 		handle for the dialog in which this button is embedded
+ *		nButtonID 	button id of this button
+ *		szName		Name to fit on the button. Max size TAPIMAXCALLEDPARTYSIZE
+ *
+ *	Return :
+ *		None
+ *
+ *	Comments :
+ *		Function first checks to see if the button text specified fits in the
+ *		button.  If it does not it truncates it appropriately and adds trailing
+ *		ellipses.  
+ */
+VOID FitTextToButton ( HWND hDlg, INT nButtonID, LPSTR szName )
+{
+
+	HDC hDC;
+	HFONT hFont, hOldFont;
+	HWND hWnd;
+
+	do
+	{
+		// calculate number of chars. that can fit on 
+		// the button
+		int	nLen;
+		RECT rect;
+		SIZE size;
+		POINT pt;
+		char buf [TAPIMAXCALLEDPARTYSIZE + 1];
+
+		// get button dimensions
+		hWnd = GetDlgItem( hDlg, nButtonID );
+		if ( hWnd == NULL )
+			break;
+
+		if ( !GetClientRect( hWnd, &rect ) )
+			break;
+		
+		// get character dimensions
+		hDC = GetDC( hWnd );
+		if ( hDC == NULL )
+			break;
+
+		hFont = (HFONT) SendMessage( hWnd, WM_GETFONT, 0, 0 );
+		if ( hFont == NULL )
+			hOldFont = SelectObject( hDC, GetStockObject( SYSTEM_FONT ) );
+		else
+			hOldFont = SelectObject( hDC, hFont );
+
+		// add an extra char at the end to compensate for
+		// leading space,
+		lstrcpy ( buf, szName );
+		nLen = lstrlen( buf );
+		buf [ nLen ] = 'X';
+		buf [ nLen + 1 ] = '\0';
+
+		if ( !GetTextExtentPoint32( hDC, buf, nLen + 1, &size ) )
+			break;
+
+		pt.x = size.cx;
+		if ( !LPtoDP( hDC, &pt, 1 ) )
+			break;
+
+		// check if name fits on button
+		if (  pt.x > rect.right )
+		{
+			// find how much of the name fits 
+			int i = 0;
+
+			nLen = lstrlen( szName );
+			for ( i = 0; i < nLen; i++ )
+			{
+				buf[ i ] = szName[ i ];
+				// an extra char is stuffed to compensate for the
+				// leading space left by the left alignment
+				buf [ i + 1 ] = 'X';
+				buf [ i + 2 ] = '\0';
+
+				// break out in cases of error condition
+				if ( !GetTextExtentPoint32( hDC, buf, i + 2, &size ) )
+				{
+					i = nLen;
+					break;
+				}
+
+				pt.x = size.cx;
+				if ( !LPtoDP( hDC, &pt, 1 ) )
+				{
+					i = nLen;
+					break;
+				}
+					
+				if ( pt.x > rect.right ) 
+					break;
+			}
+
+            // error
+			if ( i >= nLen )
+				break;
+
+			// name is too long. truncate and add ellipses
+			szName [i - 3] = '\0';
+			lstrcat( szName, "..." );
+		}
+
+	} while( FALSE );
+
+	if ( hDC )
+	{
+		SelectObject( hDC, hOldFont );
+		ReleaseDC( hWnd, hDC );
+	}
+
+	return;
+}
+
+
+
+/*
+ *	Name :
+ *		Is911
+ *
+ *	Arguements :
+ *		lpTransOut -		Translated address contained the dialable string
+ *
+ *	Returns
+ *		TRUE -				If number to be dialed (in the US) is prefixed by 911 
+ *		FALSE -				Otherwise
+ *
+ * Comments
+ *
+ */
+BOOL Is911 ( LPLINETRANSLATEOUTPUT lpTransOut )
+{
+
+	DWORD i = 0, j = 0;	
+	LPSTR lpDialDigits = (LPSTR)lpTransOut + lpTransOut-> dwDialableStringOffset;
+	char sz3Pref [ 4 ] = "";
+
+
+	// if this is not the US
+	if ( lpTransOut-> dwCurrentCountry != 1 )
+		return FALSE;
+
+	// skip non digit characters and extract
+	// the first 3 digits in the dialable number
+	for ( i = 0, j = 0; i < lpTransOut-> dwDialableStringSize ; i++ )
+	{
+		if ( ISDIGIT( lpDialDigits[i] ) )
+		{
+			sz3Pref[ j++ ] = lpDialDigits [ i ];
+			sz3Pref[ j ] = '\0'; 
+			if ( j == 3 )
+				break;
+		}
+	}
+
+	if ( !lstrcmp( sz3Pref, "911" ) )
+	{
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+/*
+ *	Name :
+ *		MakeCanonicalNumber
+ *
+ *	Arguements :
+ *		szNumber 		Number to convert into canonical form. Max size TAPIMAXDESTADDRESSSIZE
+ *		szCanNumber		Canonical representation of number specified in szNumber
+ *
+ *	Return :
+ *		TRUE			If the conversion was successful.
+ *		FALSE			otherwise
+ *
+ *	Comments :
+ *		Function first checks if given number is already in canonical form.
+ *		If it is, it returns.  If it is not, then it performs the conversion.
+ */
+ 
+BOOL MakeCanonicalNumber ( LPCSTR szNumber, LPSTR szCanNumber )
+{
+	char szDigits [ TAPIMAXDESTADDRESSSIZE ];
+	char szPref [ TAPIMAXDESTADDRESSSIZE ];
+
+	BOOL bRes = FALSE;
+
+	INT errCode = -1;
+	INT nLenPref, nLenDigits, cPos, i;
+
+	DWORD dwSize = 0;
+	DWORD dwInd = 0;
+
+	LPLINETRANSLATEOUTPUT lpTransOut = NULL;
+	LPLINETRANSLATECAPS lpTransCaps = NULL;
+
+
+	dwSize = sizeof ( LINETRANSLATEOUTPUT );
+	do
+	{
+		lpTransOut = ( LPLINETRANSLATEOUTPUT ) DialerAlloc ( dwSize );
+		if ( !lpTransOut )
+		{
+			errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+			goto error;
+		}
+			
+		lpTransOut-> dwTotalSize = dwSize;
+		errCode = lineTranslateAddress (
+											ghLineApp,
+											giCurrentLine,
+											gCurrentLineInfo.dwAPIVersion,
+											szNumber,
+											0,
+											0,
+											lpTransOut
+									   );
+		if ( errCode )
+		{
+			goto error;
+		}
+
+		if ( lpTransOut-> dwNeededSize <= lpTransOut-> dwTotalSize )
+			break;
+
+		dwSize = lpTransOut-> dwNeededSize;
+		DialerFree( lpTransOut );
+
+	} while( TRUE );
+
+	
+	// check if input number is already in 
+	// canonical form.
+	if ( lpTransOut-> dwTranslateResults & LINETRANSLATERESULT_CANONICAL )
+		goto error;
+
+	// ensure country is the USA.
+	if ( lpTransOut-> dwCurrentCountry != 1 )
+		goto error;
+
+
+	// Extract the digits from given string
+	// allowed formatting characters that are ignored are
+	// space, (, ), -, . 
+	// presence of other characters will render the string invalid.
+	
+	// find the prefix of the address upto the | mark.
+	// the rest of the string can be ignored
+	nLenPref = strcspn ( szNumber, "|" );
+	strncpy( szPref, szNumber, nLenPref );
+	szPref[ nLenPref ] = '\0';
+
+	// if string is not composed entirely of digits
+	// and allowable formating characters, quit conversion
+	if ( strspn( szPref, " 0123456789()-." ) != (size_t) nLenPref )
+		goto error;
+
+	// collect digits ignoring formating characters.
+	szDigits[ 0 ] = '\0';
+	for ( i = 0, nLenDigits = 0; i < nLenPref; i++ )
+	{
+		if ( ISDIGIT( szNumber[ i ] ) )
+		{
+			szDigits[ nLenDigits++ ] = szNumber[ i ];
+		}
+	}
+	szDigits[ nLenDigits ] = '\0';
+
+	// if "internal" number
+	if ( nLenDigits < LOCAL_NUMBER )
+		goto error;
+
+	switch ( nLenDigits )
+	{
+		// Local number ( 7 digits) preceeded by a 0/1
+		// Strip leading 0/1 and treat as a local number
+		case EXTENDED_LOCAL_NUMBER:
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' )
+			{
+				nLenDigits--;
+				memmove( szDigits, &(szDigits[1]), nLenDigits );
+				szDigits[ nLenDigits ] = '\0';
+
+				cPos = strcspn( szPref, "01" );
+				nLenPref--;
+				memmove( &(szPref[ cPos ]), &(szPref[ cPos + 1 ]), nLenPref - cPos );
+				szPref[ nLenPref ] = '\0';
+			}
+			else
+			{
+				goto error;
+			}
+
+		case LOCAL_NUMBER :
+		{
+			LPLINELOCATIONENTRY lpLocLst;
+
+			// if leading digit is 0 or 1, it is 
+			// illegal in the US
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' )
+			{
+				goto error;
+			}
+
+			// get area code nformation for local number
+			dwSize = sizeof( LINETRANSLATECAPS );
+			do
+			{
+				lpTransCaps = (LPLINETRANSLATECAPS) DialerAlloc( dwSize );
+				if ( !lpTransCaps )
+				{
+					errString( ghWndMain, LINEERR_NOMEM, MB_ICONSTOP | MB_OK );
+					goto error;
+				}
+
+				lpTransCaps-> dwTotalSize = dwSize;
+				errCode = lineGetTranslateCaps (
+												ghLineApp,
+												gCurrentLineInfo.dwAPIVersion,
+												lpTransCaps
+											   );
+				if ( errCode )
+				{
+					errString( ghWndMain, errCode, MB_ICONSTOP | MB_OK );
+					goto error;
+				}
+
+				if ( lpTransCaps-> dwNeededSize <= lpTransCaps-> dwTotalSize )
+				{
+					break;
+				}
+
+				dwSize = lpTransCaps-> dwNeededSize;
+				DialerFree( lpTransCaps );
+
+			} while ( TRUE );
+
+			// skip entries till you locate information for current location
+			dwSize = sizeof( LINELOCATIONENTRY );
+			lpLocLst = (LPLINELOCATIONENTRY) ( (LPSTR) lpTransCaps + 
+												lpTransCaps-> dwLocationListOffset );
+
+			for ( dwInd = 0; dwInd < lpTransCaps-> dwNumLocations ; dwInd++ )
+			{
+				if ( lpLocLst[ dwInd ].dwPermanentLocationID == lpTransCaps-> dwCurrentLocationID )
+					break;
+			}
+			
+			// current location no found ?????
+			// login error
+			if ( dwInd == lpTransCaps-> dwNumLocations )
+			{
+				goto error;
+			}
+
+			// construct canonical form as
+			szCanNumber[ 0 ]= '\0';
+			lstrcat( szCanNumber, "+1 (" );
+			lstrcat( szCanNumber, (LPSTR) lpTransCaps + lpLocLst[ dwInd ].dwCityCodeOffset );
+			lstrcat( szCanNumber, ") " );
+			lstrcat( szCanNumber, szDigits );
+
+			cPos = strcspn( szNumber, "|" );
+			if ( cPos != lstrlen( szNumber ) )
+			{
+				lstrcat( szCanNumber, &(szNumber[ cPos ]) );
+			}
+
+			bRes = TRUE;
+			break;
+		}
+
+		case EXTENDED_LONG_DISTANCE_NUMBER:
+		{
+			// Long distance number ( 10 digits) preceeded by a 0/1
+			// Strip leading 0/1 and treat as a long distance number
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' )
+			{
+				nLenDigits--;
+				memmove( szDigits, &(szDigits[1]), nLenDigits );
+				szDigits[ nLenDigits ] = '\0';
+
+				cPos = strcspn( szPref, "01" );
+				nLenPref--;
+				memmove( &(szPref[ cPos ]), &(szPref[ cPos + 1 ]), nLenPref - cPos );
+				szPref[ nLenPref ] = '\0';
+			}
+			else
+			{
+				goto error;
+			}
+
+		}
+
+		case LONG_DISTANCE_NUMBER:
+		{
+			// if first or fourth digit is 0/1, illegal number
+			if ( szDigits[ 0 ] == '0' || szDigits[ 0 ] == '1' ||
+				 szDigits[ 3 ] == '0' || szDigits[ 3 ] == '1' )
+			{
+				goto error;
+			}
+			
+			szCanNumber[ 0 ] = '\0';
+			lstrcat( szCanNumber, "+1 (" );
+			strncat( szCanNumber, szDigits, 3 );
+			lstrcat( szCanNumber, ") " );
+
+			lstrcat( szCanNumber, &(szDigits[ 3 ]) );
+		
+			bRes = TRUE;
+		}
+		break;
+
+		default :
+			goto error;
+	}
+
+error:
+	if ( lpTransOut )
+		DialerFree( lpTransOut );
+
+	if ( lpTransCaps )
+		DialerFree( lpTransCaps );
+
+	return bRes;
+}
+
+
+/*
+ *	Name :
+ *		AmpersandCompensate
+ *
+ *	Arguements :
+ *		lpszSrc		:	Src string containing &s
+ *		lpszDst		:	Dest string   
+ *
+ *	Return :
+ *
+ *	Comments :
+ *		Copies string pointed to by lpszSrc to lpszDst character by
+ *		character.  If an & is encountered in this process in lpszSrc
+ *		it is copied as && into lpszDst.
+ *		Assumes lpszDst and lpszSrc are of size TAPIMAXCALLEDPARTYSIZE
+ */
+VOID AmpersandCompensate ( LPCSTR lpszSrc, LPSTR lpszDst )
+{
+	// check if the name has an & in it.  If so replace
+	// it with &&.
+	INT cCnt, cInd;
+
+	for ( cCnt = 0, cInd = 0; 
+		  cInd < TAPIMAXCALLEDPARTYSIZE; 
+		  cInd++, cCnt++ )
+	{
+		if ( lpszSrc[ cCnt ] == '&' )
+		{
+			lpszDst[ cInd++ ] = '&';
+		}
+		lpszDst[ cInd ] = lpszSrc[ cCnt ];
+
+		if ( lpszSrc[ cCnt ] == '\0' )
+			break;
+	}
+
+	// make sure string is null terminated.
+	lpszDst[ TAPIMAXCALLEDPARTYSIZE - 1 ] = '\0';
+
+	return;
+}
+
+
+ /*
+ *	Name :
+ *		AmpersandDeCompensate
+ *
+ *	Arguements :
+ *		lpszSrc		:	Src string containing &s
+ *		lpszDst		:	Dest string   
+ *
+ *	Return :
+ *
+ *	Comments :
+ *		Copies string pointed to by lpszSrc to lpszDst character by
+ *		character.  If an && is encountered in this process in lpszSrc
+ *		it is copied as & into lpszDst.
+ *		Assumes lpszDst and lpszSrc are of size TAPIMAXCALLEDPARTYSIZE
+ */
+ VOID AmpersandDeCompensate ( LPCSTR lpszSrc, LPSTR lpszDst )
+ {
+	// check if the name has an & in it.  If so replace
+	// it with &&.
+	INT cCnt, cInd;
+
+	for ( cCnt = 0, cInd = 0; 
+		  cInd < TAPIMAXCALLEDPARTYSIZE; 
+		  cInd++, cCnt++ )
+	{
+		if  ( ( lpszSrc[ cInd ] == '&' ) &&
+			  ( lpszSrc[ cInd + 1 ] == '&' ) )
+		{
+			cInd++;
+		}
+		lpszDst[ cCnt ] = lpszSrc[ cInd ] ;
+
+		if ( lpszSrc [ cInd ] == '\0' )
+		{
+			break;
+		}
+	}
+
+	lpszDst[ TAPIMAXCALLEDPARTYSIZE - 1 ] = '\0';
+
+	return;
+ }
diff --git a/private/tapi/dev/apps/dialer/nextver/dialer.def b/private/tapi/dev/apps/dialer/nextver/dialer.def
new file mode 100644
index 000000000..b40ab0af1
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialer.def
@@ -0,0 +1,9 @@
+NAME         DIALER
+;STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD   MOVEABLE MULTIPLE
+HEAPSIZE     2048
+STACKSIZE    8192
+
+EXPORTS
+    MainWndProc
diff --git a/private/tapi/dev/apps/dialer/nextver/dialer.h b/private/tapi/dev/apps/dialer/nextver/dialer.h
new file mode 100644
index 000000000..6f5832862
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialer.h
@@ -0,0 +1,51 @@
+/*++ BUILD Version: 0001    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    dialer.h
+
+Abstract:
+
+    Header file for dialer
+
+Author:
+
+    Dan Knudson (DanKn)        05-Apr-1995
+
+Revision History:
+
+    Jeremy Horwitz (t-jereh)   30-May-1995
+
+--*/
+
+
+#define TAPI_VERSION_1_0 0x00010003
+#define TAPI_VERSION_1_4 0x00010004
+#define TAPI_VERSION_2_0 0x00020000
+#define TAPI_CURRENT_VERSION TAPI_VERSION_2_0
+
+#include <windows.h>
+#include "tapi.h"
+#include "resource.h"
+#include "dialhelp.h"
+
+
+#define MENU_CHOICE         1 // for Connect Using dialog...
+#define INVALID_LINE        2 // if INVALID_LINE, turn off CANCEL
+                              // button and add extra text...
+
+#define MAXNUMLENGTH    64
+#define MAXBUFSIZE      256
+#define NSPEEDDIALS     8 // Dialer supports 8 configurable speed dial entries.
+#define NLASTDIALED     20 // Dialer keeps track of the 20 last dialed numbers.
+
+#define ERR_NONE        0
+#define ERR_NOVOICELINE 1
+#define ERR_LINECLOSE   2
+#define ERR_NOLINES     3
+#define	ERR_911WARN		4
+#define ERR_NEWDEFAULT	5
+
+#define itoa(x,y,z) _itoa(x,y,z)
diff --git a/private/tapi/dev/apps/dialer/nextver/dialer.ico b/private/tapi/dev/apps/dialer/nextver/dialer.ico
new file mode 100644
index 000000000..44ccbca29
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialer.ico
diff --git a/private/tapi/dev/apps/dialer/nextver/dialer.mak b/private/tapi/dev/apps/dialer/nextver/dialer.mak
new file mode 100644
index 000000000..3c4a04bea
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialer.mak
@@ -0,0 +1,389 @@
+# Microsoft Visual C++ Generated NMAKE File, Format Version 2.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+# TARGTYPE "Win32 (MIPS) Application" 0x0501
+
+!IF "$(CFG)" == ""
+CFG=Win32 (80x86) Debug
+!MESSAGE No configuration specified.  Defaulting to Win32 (80x86) Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "Win32 (80x86) Release" && "$(CFG)" != "Win32 (80x86) Debug" &&\
+ "$(CFG)" != "Win32 (MIPS) Debug" && "$(CFG)" != "Win32 (MIPS) Release"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "dialer.mak" CFG="Win32 (80x86) Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Win32 (80x86) Release" (based on "Win32 (x86) Application")
+!MESSAGE "Win32 (80x86) Debug" (based on "Win32 (x86) Application")
+!MESSAGE "Win32 (MIPS) Debug" (based on "Win32 (MIPS) Application")
+!MESSAGE "Win32 (MIPS) Release" (based on "Win32 (MIPS) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "Win32 (MIPS) Debug"
+
+!IF  "$(CFG)" == "Win32 (80x86) Release"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "WinRel"
+# PROP BASE Intermediate_Dir "WinRel"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "WinRel"
+# PROP Intermediate_Dir "WinRel"
+OUTDIR=.\WinRel
+INTDIR=.\WinRel
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /W3 /GX /YX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /FR /c
+CPP_PROJ=/nologo /W3 /GX /YX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "_MBCS" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/ /c 
+CPP_OBJS=.\WinRel/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"DIALER.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+	$(INTDIR)/DIALER.SBR
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib mfc30.lib mfco30.lib mfcd30.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:I386
+# ADD LINK32 tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:I386
+LINK32_FLAGS=tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /INCREMENTAL:no\
+ /PDB:$(OUTDIR)/"dialer.pdb" /MACHINE:I386 /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+	$(INTDIR)/DIALER.res \
+	$(INTDIR)/DIALER.OBJ
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 (80x86) Debug"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "WinDebug"
+# PROP BASE Intermediate_Dir "WinDebug"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "WinDebug"
+# PROP Intermediate_Dir "WinDebug"
+OUTDIR=.\WinDebug
+INTDIR=.\WinDebug
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /FR /c
+CPP_PROJ=/nologo /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "_MBCS" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/\
+ /Fd$(OUTDIR)/"dialer.pdb" /c 
+CPP_OBJS=.\WinDebug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"DIALER.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+	$(INTDIR)/DIALER.SBR
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib mfc30d.lib mfco30d.lib mfcd30d.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:I386
+# ADD LINK32 tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:I386
+LINK32_FLAGS=tapi32.lib version.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /INCREMENTAL:yes\
+ /PDB:$(OUTDIR)/"dialer.pdb" /DEBUG /MACHINE:I386 /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+	$(INTDIR)/DIALER.res \
+	$(INTDIR)/DIALER.OBJ
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Debug"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 1
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "WinDebug"
+# PROP Intermediate_Dir "WinDebug"
+OUTDIR=.\WinDebug
+INTDIR=.\WinDebug
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32  
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /Gt0 /QMOb2000 /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /Gt0 /QMOb2000 /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "WIN32" /FR /c
+CPP_PROJ=/nologo /Gt0 /QMOb2000 /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "_WINDOWS"\
+ /D "_MBCS" /D "WIN32" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/\
+ /Fd$(OUTDIR)/"dialer.pdb" /c 
+CPP_OBJS=.\WinDebug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"dialer.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+        $(INTDIR)/dialer.sbr
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib odbc32.lib mfc30d.lib mfco30d.lib mfcd30d.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:MIPS
+# ADD LINK32 version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /DEBUG /MACHINE:MIPS
+LINK32_FLAGS=version.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO\
+ /SUBSYSTEM:windows /PDB:$(OUTDIR)/"dialer.pdb" /DEBUG /MACHINE:MIPS\
+ /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+        $(INTDIR)/dialer.res \
+        $(INTDIR)/dialer.obj
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Release"
+
+# PROP BASE Use_MFC 2
+# PROP BASE Use_Debug_Libraries 0
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "WinRel"
+# PROP Intermediate_Dir "WinRel"
+OUTDIR=.\WinRel
+INTDIR=.\WinRel
+
+ALL : $(OUTDIR)/dialer.exe $(OUTDIR)/dialer.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+MTL=MkTypLib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+CPP=cl.exe
+# ADD BASE CPP /nologo /MD /Gt0 /QMOb2000 /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /c
+# ADD CPP /nologo /Gt0 /QMOb2000 /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "WIN32" /FR /c
+CPP_PROJ=/nologo /Gt0 /QMOb2000 /W3 /GX /YX /O2 /D "NDEBUG" /D "_WINDOWS" /D\
+ "_MBCS" /D "WIN32" /FR$(INTDIR)/ /Fp$(OUTDIR)/"dialer.pch" /Fo$(INTDIR)/ /c 
+CPP_OBJS=.\WinRel/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo$(INTDIR)/"dialer.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# SUBTRACT BASE BSC32 /Iu
+# ADD BSC32 /nologo
+# SUBTRACT BSC32 /Iu
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"dialer.bsc" 
+BSC32_SBRS= \
+        $(INTDIR)/dialer.sbr
+
+$(OUTDIR)/dialer.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib odbc32.lib mfc30.lib mfco30.lib mfcd30.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:MIPS
+# ADD LINK32 version.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO /SUBSYSTEM:windows /MACHINE:MIPS
+LINK32_FLAGS=version.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /NOLOGO\
+ /SUBSYSTEM:windows /PDB:$(OUTDIR)/"dialer.pdb" /MACHINE:MIPS\
+ /OUT:$(OUTDIR)/"dialer.exe" 
+DEF_FILE=
+LINK32_OBJS= \
+        $(INTDIR)/dialer.res \
+        $(INTDIR)/dialer.obj
+
+$(OUTDIR)/dialer.exe : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+################################################################################
+# Begin Group "Source Files"
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\DIALER.RC
+DEP_DIALE=\
+	.\dialer.ico
+
+!IF  "$(CFG)" == "Win32 (80x86) Release"
+
+$(INTDIR)/DIALER.res :  $(SOURCE)  $(DEP_DIALE) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ELSEIF  "$(CFG)" == "Win32 (80x86) Debug"
+
+$(INTDIR)/DIALER.res :  $(SOURCE)  $(DEP_DIALE) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Debug"
+
+$(INTDIR)/dialer.res :  $(SOURCE)  $(DEP_GENER) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Release"
+
+$(INTDIR)/dialer.res :  $(SOURCE)  $(DEP_GENER) $(INTDIR)
+   $(RSC) $(RSC_PROJ)  $(SOURCE) 
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\DIALER.C
+DEP_DIALER=\
+	.\DIALER.H\
+        ..\..\INC\TAPI.H\
+	.\dialhelp.h
+
+!IF  "$(CFG)" == "Win32 (80x86) Release"
+
+$(INTDIR)/DIALER.OBJ :  $(SOURCE)  $(DEP_DIALER) $(INTDIR)
+
+!ELSEIF  "$(CFG)" == "Win32 (80x86) Debug"
+
+$(INTDIR)/DIALER.OBJ :  $(SOURCE)  $(DEP_DIALER) $(INTDIR)
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Debug"
+
+$(INTDIR)/dialer.obj :  $(SOURCE)  $(DEP_GENERI) $(INTDIR)
+
+!ELSEIF  "$(CFG)" == "Win32 (MIPS) Release"
+
+$(INTDIR)/dialer.obj :  $(SOURCE)  $(DEP_GENERI) $(INTDIR)
+
+!ENDIF 
+
+# End Source File
+# End Group
+# End Project
+################################################################################
diff --git a/private/tapi/dev/apps/dialer/nextver/dialer.rc b/private/tapi/dev/apps/dialer/nextver/dialer.rc
new file mode 100644
index 000000000..157bf41dd
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialer.rc
@@ -0,0 +1,419 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "windows.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""windows.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALER DIALOG PRELOAD DISCARDABLE  50, 50, 194, 168
+STYLE DS_3DLOOK | WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU
+CAPTION "Phone Dialer"
+MENU IDM_MENU
+CLASS "DialerClass"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    CONTROL         "",IDD_DRECTSEPARATOR,"Static",SS_ETCHEDHORZ | 
+                    WS_DISABLED,0,0,194,1
+    LTEXT           "&Number to dial:",IDD_DNUMTODIAL,7,7,90,10
+    COMBOBOX        IDD_DCOMBO,7,21,90,104,CBS_DROPDOWN | CBS_AUTOHSCROLL | 
+                    WS_VSCROLL | WS_GROUP | WS_TABSTOP | ES_NOHIDESEL
+    DEFPUSHBUTTON   "&Dial",IDD_DDIAL,7,38,90,14,WS_DISABLED | WS_GROUP
+    CONTROL         "\n1",IDD_DBUTTON1,"Button",BS_OWNERDRAW,14,62,23,20
+    CONTROL         "ABC\n2",IDD_DBUTTON2,"Button",BS_OWNERDRAW,40,62,23,20
+    CONTROL         "DEF\n3",IDD_DBUTTON3,"Button",BS_OWNERDRAW,66,62,23,20
+    CONTROL         "GHI\n4",IDD_DBUTTON4,"Button",BS_OWNERDRAW,14,86,23,20
+    CONTROL         "JKL\n5",IDD_DBUTTON5,"Button",BS_OWNERDRAW,40,86,23,20
+    CONTROL         "MNO\n6",IDD_DBUTTON6,"Button",BS_OWNERDRAW,66,86,23,20
+    CONTROL         "PQRS\n7",IDD_DBUTTON7,"Button",BS_OWNERDRAW,14,110,23,
+                    20
+    CONTROL         "TUV\n8",IDD_DBUTTON8,"Button",BS_OWNERDRAW,40,110,23,20
+    CONTROL         "WXYZ\n9",IDD_DBUTTON9,"Button",BS_OWNERDRAW,66,110,23,
+                    20
+    CONTROL         "\n*",IDD_DBUTTONSTAR,"Button",BS_OWNERDRAW,14,134,23,20
+    CONTROL         "\n0",IDD_DBUTTON0,"Button",BS_OWNERDRAW,40,134,23,20
+    CONTROL         "\n#",IDD_DBUTTONPOUND,"Button",BS_OWNERDRAW,66,134,23,
+                    20
+    GROUPBOX        "Speed dial",IDD_DSPEEDDIALGRP,103,7,84,154
+    LTEXT           "&1",IDD_DSPEEDDIALTEXT1,109,24,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL1,117,21,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&2",IDD_DSPEEDDIALTEXT2,109,41,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL2,117,38,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&3",IDD_DSPEEDDIALTEXT3,109,58,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL3,117,55,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&4",IDD_DSPEEDDIALTEXT4,109,75,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL4,117,72,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&5",IDD_DSPEEDDIALTEXT5,109,92,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL5,117,89,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&6",IDD_DSPEEDDIALTEXT6,109,109,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL6,117,106,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&7",IDD_DSPEEDDIALTEXT7,109,126,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL7,117,123,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "&8",IDD_DSPEEDDIALTEXT8,109,143,7,10
+    PUSHBUTTON      "",IDD_DSPEEDDIAL8,117,140,63,14,BS_LEFT | WS_GROUP
+END
+
+IDD_SD1 DIALOG DISCARDABLE  12, 29, 165, 173
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Edit Speed Dial"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Choose a button from the group below.",
+                    IDD_SD1TEXTCHOOSE,7,7,140,10
+    LTEXT           "1",IDD_SD1SPEEDDIALTEXT1,7,27,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL1,16,24,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "2",IDD_SD1SPEEDDIALTEXT2,7,44,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL2,16,41,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "3",IDD_SD1SPEEDDIALTEXT3,7,61,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL3,16,58,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "4",IDD_SD1SPEEDDIALTEXT4,7,78,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL4,16,75,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "5",IDD_SD1SPEEDDIALTEXT5,86,27,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL5,95,24,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "6",IDD_SD1SPEEDDIALTEXT6,86,44,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL6,95,41,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "7",IDD_SD1SPEEDDIALTEXT7,86,61,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL7,95,58,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "8",IDD_SD1SPEEDDIALTEXT8,86,78,8,10
+    PUSHBUTTON      "",IDD_SD1SPEEDDIAL8,95,75,63,14,BS_LEFT | WS_GROUP
+    LTEXT           "",IDD_SD1RECTSEPARATOR,7,96,151,8,WS_DISABLED | NOT 
+                    WS_GROUP
+    LTEXT           "Enter a name and number for the selected button.",
+                    IDD_SD1TEXTENTER,7,104,160,10
+    LTEXT           "&Name:",IDD_SD1TEXTNAME,16,119,29,10
+    EDITTEXT        IDD_SD1EDITNAME,16,130,63,14,ES_AUTOHSCROLL
+    LTEXT           "N&umber to dial:",IDD_SD1TEXTNUMBER,95,119,53,10
+    EDITTEXT        IDD_SD1EDITNUMBER,95,130,63,14,ES_AUTOHSCROLL
+    PUSHBUTTON      "&Save",IDOK,55,152,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,108,152,50,14
+END
+
+IDD_SD2 DIALOG DISCARDABLE  12, 29, 158, 91
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Program Speed Dial"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Enter a name and number to save on this button.",
+                    IDD_SD2TEXTENTER,7,7,85,21
+    DEFPUSHBUTTON   "&Save",IDOK,98,7,53,14,WS_GROUP
+    PUSHBUTTON      "Save and &Dial",IDD_SD2SAVEANDDIAL,98,24,53,14,
+                    WS_DISABLED | WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,98,41,53,14
+    LTEXT           "&Name:",IDD_SD2TEXTNAME,7,30,29,10
+    EDITTEXT        IDD_SD2EDITNAME,7,41,63,14,ES_AUTOHSCROLL
+    LTEXT           "N&umber to dial:",IDD_SD2TEXTNUMBER,7,59,53,10
+    EDITTEXT        IDD_SD2EDITNUMBER,7,70,63,14,ES_AUTOHSCROLL
+END
+
+IDD_CONNECTUSING DIALOG PRELOAD DISCARDABLE  50, 50, 260, 105
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Connect Using"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Line:",IDD_CUTEXTLINE,7,16,79,10,NOT WS_GROUP
+    COMBOBOX        IDD_CULISTLINE,7,27,173,97,CBS_DROPDOWNLIST | CBS_SORT | 
+                    WS_GROUP | WS_TABSTOP | WS_VSCROLL
+    LTEXT           "&Address:",IDD_CUTEXTADDRESS,7,43,79,10,NOT WS_GROUP
+    COMBOBOX        IDD_CULISTADDRESS,7,53,173,82,CBS_DROPDOWNLIST | 
+                    CBS_SORT | WS_GROUP | WS_TABSTOP | WS_VSCROLL
+    CONTROL         "Use Phone Dialer to handle &voice call requests from other programs",
+                    IDD_CUSIMPLETAPICHKBOX,"Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,7,72,230,10
+    PUSHBUTTON      "Line &Properties...",IDD_CUPROPERTIES,190,26,63,14
+    DEFPUSHBUTTON   "OK",IDOK,146,84,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,203,84,50,14,WS_GROUP
+END
+
+IDD_ABOUT DIALOG DISCARDABLE  22, 38, 227, 100
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "About Phone Dialer"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    ICON            IDI_DIALER,IDD_AICON,10,5,18,20
+    LTEXT           "",IDD_ATEXTTITLE,38,5,127,10,SS_NOPREFIX | NOT WS_GROUP
+    LTEXT           "Copyright © 1993-1996  Microsoft.  All Rights Reserved.",
+                    IDD_ATEXTCOPYRIGHT,38,35,179,20,SS_NOPREFIX | NOT 
+                    WS_GROUP
+    DEFPUSHBUTTON   "OK",IDOK,177,5,40,14
+END
+
+IDD_INUSE DIALOG DISCARDABLE  22, 38, 199, 81
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Line In Use"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,36,58,53,16
+    ICON            IDI_LINEBUSY,IDD_IUICON,10,5,18,20
+    LTEXT           "The selected line or address is in use by another program or device on the line. Your call can not be placed at this time.",
+                    IDD_IUTEXT1,45,5,144,27,SS_NOPREFIX | NOT WS_GROUP
+    LTEXT           "Try your call again later.",IDD_IUTEXT2,45,40,114,12,
+                    SS_NOPREFIX | NOT WS_GROUP
+END
+
+IDD_CALLFAILED DIALOG DISCARDABLE  22, 38, 199, 73
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Call Failed"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,72,50,53,16
+    ICON            IDI_LINEBUSY,IDD_IUICON,10,5,18,20
+    LTEXT           "",IDD_CFTEXT,45,5,144,40,SS_NOPREFIX | NOT WS_GROUP
+END
+
+IDD_DIALING DIALOG DISCARDABLE  0, 0, 172, 62
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION
+CAPTION "Dialing"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    PUSHBUTTON      "&Hang Up",IDCANCEL,9,37,50,14
+    RTEXT           "Currently dialing:",IDD_DGNUMBER,9,9,52,9
+    LTEXT           "",IDD_DGNUMBERTEXT,63,9,100,9
+    LTEXT           "",IDD_DGNAMETEXT,63,23,100,9
+END
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDM_MENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "E&xit",                       IDM_EXIT
+    END
+    POPUP "&Edit"
+    BEGIN
+        MENUITEM "Cu&t\tCtrl+X",                IDM_EDIT_CUT
+        MENUITEM "&Copy\tCtrl+C",               IDM_EDIT_COPY
+        MENUITEM "&Paste\tCtrl+V",              IDM_EDIT_PASTE
+        MENUITEM "&Delete\tDel",                IDM_EDIT_DELETE
+        MENUITEM SEPARATOR
+        MENUITEM "&Speed Dial...",              IDM_EDIT_SPEEDDIAL
+    END
+    POPUP "&Tools"
+    BEGIN
+        MENUITEM "&Connect Using...",           IDM_CONNECTUSING
+        MENUITEM "&Dialing Properties...",      IDM_LOCATION
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Help Topics",                IDM_HELP_CONTENTS
+        MENUITEM "&What's This?",               IDM_HELP_WHATSTHIS
+        MENUITEM SEPARATOR
+        MENUITEM "&About Phone Dialer",         IDM_ABOUT
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+#if WINNT
+IDI_DIALER              ICON    DISCARDABLE     "DIALER.ICO"
+IDI_LINEBUSY            ICON    DISCARDABLE     "LINEBUSY.ICO"
+#else
+IDI_DIALER              ICON    DISCARDABLE     "..\\DIALER.ICO"
+IDI_LINEBUSY            ICON    DISCARDABLE     "..\\LINEBUSY.ICO"
+#endif
+/////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDA_DIALER ACCELERATORS DISCARDABLE 
+BEGIN
+    "1",            IDD_DSPEEDDIAL1,        VIRTKEY, ALT, NOINVERT
+    "2",            IDD_DSPEEDDIAL2,        VIRTKEY, ALT, NOINVERT
+    "3",            IDD_DSPEEDDIAL3,        VIRTKEY, ALT, NOINVERT
+    "4",            IDD_DSPEEDDIAL4,        VIRTKEY, ALT, NOINVERT
+    "5",            IDD_DSPEEDDIAL5,        VIRTKEY, ALT, NOINVERT
+    "6",            IDD_DSPEEDDIAL6,        VIRTKEY, ALT, NOINVERT
+    "7",            IDD_DSPEEDDIAL7,        VIRTKEY, ALT, NOINVERT
+    "8",            IDD_DSPEEDDIAL8,        VIRTKEY, ALT, NOINVERT
+    "C",            IDM_EDIT_COPY,          VIRTKEY, CONTROL, NOINVERT
+    "D",            IDD_DDIAL,              VIRTKEY, ALT, NOINVERT
+    "N",            IDM_ACCEL_NUMTODIAL,    VIRTKEY, ALT, NOINVERT
+    "V",            IDM_EDIT_PASTE,         VIRTKEY, CONTROL, NOINVERT
+    VK_INSERT,      IDM_EDIT_PASTE,         VIRTKEY, SHIFT, NOINVERT
+    "X",            IDM_EDIT_CUT,           VIRTKEY, CONTROL, NOINVERT
+END
+
+
+#ifndef _MAC
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 4,0,1259,1
+ PRODUCTVERSION 4,0,1259,1
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904B0"
+        BEGIN
+            VALUE "CompanyName", "Microsoft Corporation\0"
+            VALUE "FileDescription", "Microsoft® Windows(TM) Phone Dialer\0"
+            VALUE "FileVersion", "4.00\0"
+            VALUE "InternalName", "Phone Dialer\0"
+            VALUE "LegalCopyright", "Copyright © Microsoft Corporation 1996.  All Rights Reserved.\0"
+            VALUE "OriginalFilename", "dialer.exe\0"
+            VALUE "ProductName", "Microsoft(R) Windows NT(TM) Operating System\0"
+            VALUE "ProductVersion", "4.00\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+
+#endif    // !_MAC
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszAppName             "Dialer"
+    ikszAppFriendlyName     "Phone Dialer"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszErrDefault          "An internal error occurred in Phone Dialer.\nQuit and restart Phone Dialer."
+    ikszErrOOM              "There was not enough memory to continue.\nQuit one or more programs, and then try again."
+    ikszErrTAPI             "Windows Telephony was unable to complete an operation requested by Phone Dialer.\nQuit and restart Phone Dialer."
+    ikszErrNoVoiceLine      "Phone Dialer was unable to find a telephone device or modem to use to dial voice calls.\nIn Control Panel, double-click the Modems icon to install a modem, or install another telephone device to use for dialing calls."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszWarningTapiReInit   "Phone Dialer cannot successfully start.\nQuit all other telephony programs, and then try again."
+    ikszErrLineClose        "Your call was cancelled because the Telephony device driver closed the line."
+    ikszDisconnectedNoDialTone 
+                            "A dial tone was not detected. Please check your telephone cable connections, and be sure the line is not in use by someone else."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszErrLineInitBadIniFile 
+                            "Configuration information relating to Telephony services appears to be corrupt.\nPlease check the configuration of telephone devices in the control panel."
+    ikszErrLineInitNoDriver "One of the components of the Telephony device driver is missing.\nUse the Control Panel to set up the driver properly."
+    ikszErrLineInitNoDevice "The selected device has been removed from your computer. Please select a different device for dialing."
+    ikszErrNoMultipleInstance 
+                            "You have two copies of the same Telephony driver installed.\nUse the Control Panel to remove one of the copies."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszErrInvalAddress     "The specified phone number either contains invalid characters, or is incorrectly formatted.\nClick on the number box with the right mouse button to see more information."
+    ikszErrLineInitWrongDrivers 
+                            "One or more telephone device drivers are incompatible with TAPI.DLL.\nInstall an updated version."
+    ikszErrAddrBlocked      "The specified phone number cannot be dialed on the selected line device because it is blocked at the telephone switch."
+    ikszErrBillingRejected  "The billing information specified as part of the phone number has been rejected.\nCheck to make sure you've entered it correctly, and then try again."
+    ikszErrResUnavail       "Another program is using the selected Telephony device.\nTry again after the other program completes."
+    ikszErrInvalidCountryCode   "The country code you entered is invalid.\nPlease check the phone number again."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszDisconnectedReject  "The call was rejected by the called party."
+    ikszDisconnectedBusy    "The called number is busy."
+    ikszDisconnectedNoAnswer "There was no answer."
+    ikszDisconnectedCantDo  "The call cannot be completed as dialed."
+    ikszDisconnectedNetwork "The call failed due to network congestion."
+    ikszDisconnectedIncompatible 
+                            "Equipment at the called number is incompatible with your equipment."
+    ikszErrInvalCallState   "The Telephony device driver is unable to respond to your request at this time."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ikszWarningTitle        "Warning"
+    ikszWarningFor911       "Using your current location and calling card selection, dialing this number could result in a emergency services call to 911.  Are you sure you want to dial this call ?"
+    ikszWarningNewDefault   "Your preferred device selection is not available.  A new device has been selected by default.  If you wish to change the selection use the 'Connect Using' option under the 'Tools' menu"
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/private/tapi/dev/apps/dialer/nextver/dialhelp.h b/private/tapi/dev/apps/dialer/nextver/dialhelp.h
new file mode 100644
index 000000000..54084e44c
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/dialhelp.h
@@ -0,0 +1,29 @@
+//
+// (c) 1995 Microsoft Corporation.  All Rights Reserved.
+//
+#define IDH_DIALER_CHANGE_DIAL_HELPER    1000
+#define IDH_DIALER_CHANGE_DIGITS         1001
+#define IDH_DIALER_CHANGE_OPTIONS        1002
+#define IDH_DIALER_CHANGE_REDIAL_BUTTON  1003
+#define IDH_DIALER_DIALING_LOGNAME       1004
+#define IDH_DIALER_DIALING_STATUS        1005
+#define IDH_DIALER_HANGUP                1006
+#define IDH_DIALER_LOG_IN                1007
+#define IDH_DIALER_LOG_OUT               1008
+#define IDH_DIALER_OPTIONS_ADDRESS       1009
+#define IDH_DIALER_OPTIONS_LINE          1010
+#define IDH_DIALER_OPTIONS_NONVOICE      1011
+#define IDH_DIALER_OPTIONS_VOICE         1012
+#define IDH_DIALER_PAUSE_CONTINUE        1013
+#define IDH_DIALER_SPEED_CHOOSE          1014
+#define IDH_DIALER_SPEED_NAME            1015
+#define IDH_DIALER_SPEED_NUMBER          1016
+#define IDH_DIALER_SPEED_SAVE            1017
+#define IDH_DIALER_SPEED_SAVE_DIAL       1018
+#define IDH_DIALER_DIAL_NUMBER           1019
+#define IDH_DIALER_DIAL_SPEED_CHOOSE     1020
+#define IDH_DIALER_DIAL_BUTTON           1021
+#define IDH_DIALER_DIAL_KEYPAD           1022
+#define IDH_DIALER_LOG                   1023
+#define IDH_DIALER_OPTIONS_PROPERTIES    1024
+#define IDH_DIALER_BUTTONS               1025
diff --git a/private/tapi/dev/apps/dialer/nextver/linebusy.ico b/private/tapi/dev/apps/dialer/nextver/linebusy.ico
new file mode 100644
index 000000000..589f2671b
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/linebusy.ico
diff --git a/private/tapi/dev/apps/dialer/nextver/makefile b/private/tapi/dev/apps/dialer/nextver/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/dialer/nextver/makefile.def b/private/tapi/dev/apps/dialer/nextver/makefile.def
new file mode 100644
index 000000000..1eb194df8
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/makefile.def
@@ -0,0 +1,50 @@
+##############################################################################
+#
+#   Dialer Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+IS_OEM=1
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=dialer
+TARGETS=dialer.exe
+
+DEFENTRY = WinMain
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+L32EXE=dialer.exe		# Name of exe.
+L32DEF=..\dialer.def              # Our def file.
+L32MAP=dialer.map		# Our map file.
+L32SYM=dialer.sym		# Our sym file.
+L32LIBS= \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\gdi32.lib                   \
+        $(W32LIBID)\kernel32.lib                \
+        $(DEVROOT)\sdk\lib\tapi32.lib           \
+        $(DEVROOT)\tools\c932\lib\oldnames.lib  \
+        $(DEVROOT)\tools\c932\lib\msvcrt.lib  \
+        $(DEVROOT)\sdk\lib\shell32.lib
+
+L32RES=dialer.res	# Resource file.
+L32OBJS = dialer.obj
+
+!include $(ROOT)\dev\master.mk
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Og
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/apps/dialer/nextver/nt.mak b/private/tapi/dev/apps/dialer/nextver/nt.mak
new file mode 100644
index 000000000..a93df1f2d
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/nt.mak
@@ -0,0 +1,27 @@
+!include <ntwin32.mak>
+
+!ifndef  MYDEBUG
+MYDEBUG = 0
+!endif
+
+!if $(MYDEBUG)
+L_FLAGS = $(linkdebug)
+!else
+L_FLAGS =
+!endif
+
+APPLIBS=\telephon\tapi\lib\tapi32.lib
+
+OBJS=ui.obj vars.obj tb.obj widget.obj
+
+all: tb.exe
+
+.c.obj:
+    $(cc) -DTAPI_1_1 $(cdebug) $(cflags) $(cvars) $*.c
+
+tb.rbj: tb.rc
+    $(rc) -DTAPI_1_1 $(rcvars) -r -fo tb.res tb.rc
+    cvtres -$(CPU) tb.res -o tb.rbj
+
+tb.exe: $(OBJS) tb.rbj tb.def
+    $(link) $(L_FLAGS) $(guiflags) -out:tb14.exe $(OBJS) tb.rbj $(APPLIBS) $(guilibsdll)
diff --git a/private/tapi/dev/apps/dialer/nextver/resource.h b/private/tapi/dev/apps/dialer/nextver/resource.h
new file mode 100644
index 000000000..0296f8654
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/resource.h
@@ -0,0 +1,155 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by dialer.RC
+//
+#define IDI_DIALER                      1
+#define IDD_DDIAL                       1
+#define IDI_LINEBUSY                    116
+#define IDA_DIALER                      117
+#define IDM_MENU                        118
+#define IDD_DIALER                      200
+#define IDD_DCOMBO                      201
+#define IDD_DBUTTON1                    202
+#define IDD_DBUTTON2                    203
+#define IDD_DBUTTON3                    204
+#define IDD_DBUTTON4                    205
+#define IDD_DBUTTON5                    206
+#define IDD_DBUTTON6                    207
+#define IDD_DBUTTON7                    208
+#define IDD_DBUTTON8                    209
+#define IDD_DBUTTON9                    210
+#define IDD_DBUTTON0                    211
+#define IDD_DBUTTONSTAR                 212
+#define IDD_DBUTTONPOUND                213
+#define IDD_DSPEEDDIAL1                 214
+#define IDD_DSPEEDDIAL2                 215
+#define IDD_DSPEEDDIAL3                 216
+#define IDD_DSPEEDDIAL4                 217
+#define IDD_DSPEEDDIAL5                 218
+#define IDD_DSPEEDDIAL6                 219
+#define IDD_DSPEEDDIAL7                 220
+#define IDD_DSPEEDDIAL8                 221
+#define IDD_DSPEEDDIALGRP               222
+#define IDD_DNUMTODIAL                  223
+#define IDD_DRECTSEPARATOR              224
+#define IDD_DSPEEDDIALTEXT1             225
+#define IDD_DSPEEDDIALTEXT2             226
+#define IDD_DSPEEDDIALTEXT3             227
+#define IDD_DSPEEDDIALTEXT4             228
+#define IDD_DSPEEDDIALTEXT5             229
+#define IDD_DSPEEDDIALTEXT6             230
+#define IDD_DSPEEDDIALTEXT7             231
+#define IDD_DSPEEDDIALTEXT8             232
+#define IDD_SD1                         300
+#define IDD_SD1SPEEDDIAL1               301
+#define IDD_SD1SPEEDDIAL2               302
+#define IDD_SD1SPEEDDIAL3               303
+#define IDD_SD1SPEEDDIAL4               304
+#define IDD_SD1SPEEDDIAL5               305
+#define IDD_SD1SPEEDDIAL6               306
+#define IDD_SD1SPEEDDIAL7               307
+#define IDD_SD1SPEEDDIAL8               308
+#define IDD_SD1EDITNAME                 317
+#define IDD_SD1EDITNUMBER               318
+#define IDD_SD1TEXTCHOOSE               319
+#define IDD_SD1TEXTENTER                320
+#define IDD_SD1TEXTNAME                 321
+#define IDD_SD1TEXTNUMBER               322
+#define IDD_SD1RECTSEPARATOR            323
+#define IDD_SD1SPEEDDIALTEXT1           324
+#define IDD_SD1SPEEDDIALTEXT2           325
+#define IDD_SD1SPEEDDIALTEXT3           326
+#define IDD_SD1SPEEDDIALTEXT4           327
+#define IDD_SD1SPEEDDIALTEXT5           328
+#define IDD_SD1SPEEDDIALTEXT6           329
+#define IDD_SD1SPEEDDIALTEXT7           330
+#define IDD_SD1SPEEDDIALTEXT8           331
+#define IDD_SD2                         400
+#define IDD_SD2SAVEANDDIAL              401
+#define IDD_SD2EDITNAME                 402
+#define IDD_SD2EDITNUMBER               403
+#define IDD_SD2TEXTENTER                404
+#define IDD_SD2TEXTNAME                 405
+#define IDD_SD2TEXTNUMBER               406
+#define IDD_CONNECTUSING                500
+#define IDD_CULISTLINE                  501
+#define IDD_CULISTADDRESS               502
+#define IDD_CUSIMPLETAPICHKBOX          503
+#define IDD_CUTEXTLINE                  504
+#define IDD_CUTEXTADDRESS               505
+#define IDD_CUPROPERTIES                506
+#define IDD_ABOUT                       700
+#define IDD_AICON                       701
+#define IDD_ATEXTTITLE                  702
+#define IDD_ATEXTVERSION                703
+#define IDD_ATEXTWINMODE                704
+#define IDD_ATEXTFREEMEM                705
+#define IDD_ATEXTRESOURCE               706
+#define IDD_ATEXTCOPYRIGHT              707
+#define IDD_INUSE                       900
+#define IDD_IUICON                      901
+#define ikszAppName                     901
+#define IDD_IUTEXT1                     902
+#define ikszAppFriendlyName             902
+#define IDD_IUTEXT2                     903
+#define ikszErrDefault                  940
+#define ikszErrOOM                      941
+#define ikszErrTAPI                     942
+#define ikszErrNoVoiceLine              943
+#define ikszErrInvalAddress             945
+#define ikszErrLineInitWrongDrivers     949
+#define ikszErrAddrBlocked              950
+#define ikszErrBillingRejected          952
+#define ikszErrResUnavail               956
+#define ikszWarningTitle                977
+#define ikszWarningRegisterSTapi        978
+#define ikszWarningFor911               978
+#define ikszWarningNewDefault           979
+#define IDM_EXIT                        1000
+#define IDM_EDIT_CUT                    1001
+#define IDM_EDIT_COPY                   1002
+#define IDD_DGNUMBERTEXT                1002
+#define IDM_EDIT_PASTE                  1003
+#define IDM_EDIT_DELETE                 1004
+#define IDD_DGNAMETEXT                  1004
+#define IDM_EDIT_SPEEDDIAL              1005
+#define IDM_CONNECTUSING                1006
+#define IDM_LOCATION                    1008
+#define IDM_HELP_CONTENTS               1010
+#define IDM_ABOUT                       1011
+#define IDM_ACCEL_NUMTODIAL             1012
+#define ikszErrLineInitBadIniFile       1013
+#define IDM_ACCEL_HELP                  1013
+#define ikszErrLineInitNoDriver         1014
+#define ikszErrBadTAPIAddr              1015
+#define IDM_HELP_WHATSTHIS              1015
+#define ikszErrLineInitNoDevice         1016
+#define ikszErrNoMultipleInstance       1020
+#define IDD_CALLFAILED                  1300
+#define IDD_CFTEXT                      1301
+#define ikszWarning911                  1544
+#define ikszDisconnectedReject          1545
+#define ikszDisconnectedBusy            1546
+#define ikszDisconnectedNoAnswer        1547
+#define ikszDisconnectedCantDo          1548
+#define ikszDisconnectedNetwork         1549
+#define ikszDisconnectedIncompatible    1550
+#define ikszErrInvalCallState           1551
+#define ikszWarningTapiReInit           1552
+#define ikszErrLineClose                1553
+#define ikszDisconnectedNoDialTone      1554
+#define ikszErrInvalidCountryCode       1555
+#define IDD_DIALING                     9115
+#define IDD_CUERRORTEXT                 -1
+#define IDD_DGNUMBER                    -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        9116
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1005
+#define _APS_NEXT_SYMED_VALUE           9101
+#endif
+#endif
diff --git a/private/tapi/dev/apps/dialer/nextver/sources b/private/tapi/dev/apps/dialer/nextver/sources
new file mode 100644
index 000000000..0e80d7fe8
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nextver/sources
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=dialer
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+!if 0
+#           $(BASEDIR)\public\sdk\lib\*\oldnames.lib
+!endif
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=dialer.c \
+        dialer.rc
+
+C_DEFINES=-DWINVER=0x0400
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/dialer/nt.mak b/private/tapi/dev/apps/dialer/nt.mak
new file mode 100644
index 000000000..a93df1f2d
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/nt.mak
@@ -0,0 +1,27 @@
+!include <ntwin32.mak>
+
+!ifndef  MYDEBUG
+MYDEBUG = 0
+!endif
+
+!if $(MYDEBUG)
+L_FLAGS = $(linkdebug)
+!else
+L_FLAGS =
+!endif
+
+APPLIBS=\telephon\tapi\lib\tapi32.lib
+
+OBJS=ui.obj vars.obj tb.obj widget.obj
+
+all: tb.exe
+
+.c.obj:
+    $(cc) -DTAPI_1_1 $(cdebug) $(cflags) $(cvars) $*.c
+
+tb.rbj: tb.rc
+    $(rc) -DTAPI_1_1 $(rcvars) -r -fo tb.res tb.rc
+    cvtres -$(CPU) tb.res -o tb.rbj
+
+tb.exe: $(OBJS) tb.rbj tb.def
+    $(link) $(L_FLAGS) $(guiflags) -out:tb14.exe $(OBJS) tb.rbj $(APPLIBS) $(guilibsdll)
diff --git a/private/tapi/dev/apps/dialer/resource.h b/private/tapi/dev/apps/dialer/resource.h
new file mode 100644
index 000000000..0296f8654
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/resource.h
@@ -0,0 +1,155 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by dialer.RC
+//
+#define IDI_DIALER                      1
+#define IDD_DDIAL                       1
+#define IDI_LINEBUSY                    116
+#define IDA_DIALER                      117
+#define IDM_MENU                        118
+#define IDD_DIALER                      200
+#define IDD_DCOMBO                      201
+#define IDD_DBUTTON1                    202
+#define IDD_DBUTTON2                    203
+#define IDD_DBUTTON3                    204
+#define IDD_DBUTTON4                    205
+#define IDD_DBUTTON5                    206
+#define IDD_DBUTTON6                    207
+#define IDD_DBUTTON7                    208
+#define IDD_DBUTTON8                    209
+#define IDD_DBUTTON9                    210
+#define IDD_DBUTTON0                    211
+#define IDD_DBUTTONSTAR                 212
+#define IDD_DBUTTONPOUND                213
+#define IDD_DSPEEDDIAL1                 214
+#define IDD_DSPEEDDIAL2                 215
+#define IDD_DSPEEDDIAL3                 216
+#define IDD_DSPEEDDIAL4                 217
+#define IDD_DSPEEDDIAL5                 218
+#define IDD_DSPEEDDIAL6                 219
+#define IDD_DSPEEDDIAL7                 220
+#define IDD_DSPEEDDIAL8                 221
+#define IDD_DSPEEDDIALGRP               222
+#define IDD_DNUMTODIAL                  223
+#define IDD_DRECTSEPARATOR              224
+#define IDD_DSPEEDDIALTEXT1             225
+#define IDD_DSPEEDDIALTEXT2             226
+#define IDD_DSPEEDDIALTEXT3             227
+#define IDD_DSPEEDDIALTEXT4             228
+#define IDD_DSPEEDDIALTEXT5             229
+#define IDD_DSPEEDDIALTEXT6             230
+#define IDD_DSPEEDDIALTEXT7             231
+#define IDD_DSPEEDDIALTEXT8             232
+#define IDD_SD1                         300
+#define IDD_SD1SPEEDDIAL1               301
+#define IDD_SD1SPEEDDIAL2               302
+#define IDD_SD1SPEEDDIAL3               303
+#define IDD_SD1SPEEDDIAL4               304
+#define IDD_SD1SPEEDDIAL5               305
+#define IDD_SD1SPEEDDIAL6               306
+#define IDD_SD1SPEEDDIAL7               307
+#define IDD_SD1SPEEDDIAL8               308
+#define IDD_SD1EDITNAME                 317
+#define IDD_SD1EDITNUMBER               318
+#define IDD_SD1TEXTCHOOSE               319
+#define IDD_SD1TEXTENTER                320
+#define IDD_SD1TEXTNAME                 321
+#define IDD_SD1TEXTNUMBER               322
+#define IDD_SD1RECTSEPARATOR            323
+#define IDD_SD1SPEEDDIALTEXT1           324
+#define IDD_SD1SPEEDDIALTEXT2           325
+#define IDD_SD1SPEEDDIALTEXT3           326
+#define IDD_SD1SPEEDDIALTEXT4           327
+#define IDD_SD1SPEEDDIALTEXT5           328
+#define IDD_SD1SPEEDDIALTEXT6           329
+#define IDD_SD1SPEEDDIALTEXT7           330
+#define IDD_SD1SPEEDDIALTEXT8           331
+#define IDD_SD2                         400
+#define IDD_SD2SAVEANDDIAL              401
+#define IDD_SD2EDITNAME                 402
+#define IDD_SD2EDITNUMBER               403
+#define IDD_SD2TEXTENTER                404
+#define IDD_SD2TEXTNAME                 405
+#define IDD_SD2TEXTNUMBER               406
+#define IDD_CONNECTUSING                500
+#define IDD_CULISTLINE                  501
+#define IDD_CULISTADDRESS               502
+#define IDD_CUSIMPLETAPICHKBOX          503
+#define IDD_CUTEXTLINE                  504
+#define IDD_CUTEXTADDRESS               505
+#define IDD_CUPROPERTIES                506
+#define IDD_ABOUT                       700
+#define IDD_AICON                       701
+#define IDD_ATEXTTITLE                  702
+#define IDD_ATEXTVERSION                703
+#define IDD_ATEXTWINMODE                704
+#define IDD_ATEXTFREEMEM                705
+#define IDD_ATEXTRESOURCE               706
+#define IDD_ATEXTCOPYRIGHT              707
+#define IDD_INUSE                       900
+#define IDD_IUICON                      901
+#define ikszAppName                     901
+#define IDD_IUTEXT1                     902
+#define ikszAppFriendlyName             902
+#define IDD_IUTEXT2                     903
+#define ikszErrDefault                  940
+#define ikszErrOOM                      941
+#define ikszErrTAPI                     942
+#define ikszErrNoVoiceLine              943
+#define ikszErrInvalAddress             945
+#define ikszErrLineInitWrongDrivers     949
+#define ikszErrAddrBlocked              950
+#define ikszErrBillingRejected          952
+#define ikszErrResUnavail               956
+#define ikszWarningTitle                977
+#define ikszWarningRegisterSTapi        978
+#define ikszWarningFor911               978
+#define ikszWarningNewDefault           979
+#define IDM_EXIT                        1000
+#define IDM_EDIT_CUT                    1001
+#define IDM_EDIT_COPY                   1002
+#define IDD_DGNUMBERTEXT                1002
+#define IDM_EDIT_PASTE                  1003
+#define IDM_EDIT_DELETE                 1004
+#define IDD_DGNAMETEXT                  1004
+#define IDM_EDIT_SPEEDDIAL              1005
+#define IDM_CONNECTUSING                1006
+#define IDM_LOCATION                    1008
+#define IDM_HELP_CONTENTS               1010
+#define IDM_ABOUT                       1011
+#define IDM_ACCEL_NUMTODIAL             1012
+#define ikszErrLineInitBadIniFile       1013
+#define IDM_ACCEL_HELP                  1013
+#define ikszErrLineInitNoDriver         1014
+#define ikszErrBadTAPIAddr              1015
+#define IDM_HELP_WHATSTHIS              1015
+#define ikszErrLineInitNoDevice         1016
+#define ikszErrNoMultipleInstance       1020
+#define IDD_CALLFAILED                  1300
+#define IDD_CFTEXT                      1301
+#define ikszWarning911                  1544
+#define ikszDisconnectedReject          1545
+#define ikszDisconnectedBusy            1546
+#define ikszDisconnectedNoAnswer        1547
+#define ikszDisconnectedCantDo          1548
+#define ikszDisconnectedNetwork         1549
+#define ikszDisconnectedIncompatible    1550
+#define ikszErrInvalCallState           1551
+#define ikszWarningTapiReInit           1552
+#define ikszErrLineClose                1553
+#define ikszDisconnectedNoDialTone      1554
+#define ikszErrInvalidCountryCode       1555
+#define IDD_DIALING                     9115
+#define IDD_CUERRORTEXT                 -1
+#define IDD_DGNUMBER                    -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        9116
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1005
+#define _APS_NEXT_SYMED_VALUE           9101
+#endif
+#endif
diff --git a/private/tapi/dev/apps/dialer/sources b/private/tapi/dev/apps/dialer/sources
new file mode 100644
index 000000000..0e80d7fe8
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/sources
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=dialer
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+!if 0
+#           $(BASEDIR)\public\sdk\lib\*\oldnames.lib
+!endif
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=dialer.c \
+        dialer.rc
+
+C_DEFINES=-DWINVER=0x0400
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/dialer/version.rc b/private/tapi/dev/apps/dialer/version.rc
new file mode 100644
index 000000000..7d824cc20
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/version.rc
@@ -0,0 +1,66 @@
+//
+// (c) 1995 Microsoft Corporation.  All Rights Reserved.
+//
+/* Version Numbering stuff */
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Phone Dialer"
+#define VER_INTERNALNAME_STR        "Phone Dialer"
+#define VER_ORIGINALFILENAME_STR    "dialer.exe"
+
+#ifdef SDKRELEASE
+#include <ver.h>
+
+#define VER_PRODUCTVERSION_STR      "1.00.150"
+#define VER_PRODUCTVERSION          1,0,0,150
+
+VS_VERSION_INFO VERSIONINFO 
+FILEVERSION    VER_PRODUCTVERSION
+PRODUCTVERSION VER_PRODUCTVERSION
+FILEFLAGSMASK  VS_FF_DEBUG | VS_FF_PRERELEASE
+FILEFLAGS      VS_FF_DEBUG | VS_FF_PRERELEASE
+FILEOS         VOS__WINDOWS16
+FILETYPE       VFT_APP
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904E4"
+        BEGIN 
+            VALUE "CompanyName",     "Microsoft Corporation", "\0"
+            VALUE "FileDescription", VER_FILEDESCRIPTION_STR, "\0"
+            VALUE "FileVersion",     VER_PRODUCTVERSION_STR, "\0"
+            VALUE "InternalName",    VER_INTERNALNAME_STR, "\0"
+            VALUE "LegalCopyright",  "Copyright 1995 Microsoft Corp", "\0"
+            VALUE "OriginalFilename",VER_ORIGINALFILENAME_STR, "\0"
+            VALUE "ProductName",     "Windows Telephony", "\0"
+            VALUE "ProductVersion",  VER_PRODUCTVERSION_STR, "\0"
+        END 
+    END
+    BLOCK "VarFileInfo" 
+    BEGIN 
+        /* the following line should be extended for localized versions */
+        VALUE "Translation", 0x0409, 0x04E4
+    END 
+END 
+#else
+
+
+// Is the following FLAG good to use for this?
+#ifdef NT_INST
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+// #include <tapiver.h>
+// #include <common.ver>
+#endif
diff --git a/private/tapi/dev/apps/dialer/win31.mak b/private/tapi/dev/apps/dialer/win31.mak
new file mode 100644
index 000000000..0481e0d68
--- /dev/null
+++ b/private/tapi/dev/apps/dialer/win31.mak
@@ -0,0 +1,39 @@
+!ifndef  TAPI_1_1
+TAPI_1_1 = 0
+!endif
+
+!ifndef  MYDEBUG
+MYDEBUG = 0
+!endif
+
+!if $(TAPI_1_1)
+TAPI_VER_FLAGS = -DTAPI_1_1
+TAPILIB        = ..\..\lib\i386\tapi.lib
+TAPIINC        = -I..\..\inc
+TARGET         = ..\..\lib\i386\tb1416.exe
+!else
+TAPI_VER_FLAGS =
+TAPILIB        = ..\..\lib\tapi10\tapi.lib
+TAPIINC        = -I..\..\inc\tapi10
+TARGET         = ..\..\lib\i386\tb13.exe
+!endif
+
+!if $(MYDEBUG)
+C_FLAGS = -AL -G2s -W3 -GA -GEf -Zp /Od /Oi /Zi
+!else
+C_FLAGS = -AL -G2s -W3 -GA -GEf -Zp /Od /Oi
+!endif
+
+
+OBJS=ui.obj vars.obj tb.obj widget.obj
+
+all : $(TARGET)
+
+.c.obj:
+   cl -c $(TAPI_VER_FLAGS) $(TAPIINC) $(C_FLAGS) $*.c
+
+$(TARGET) : $(OBJS) tb.def tb.rc
+   rc -r $(TAPI_VER_FLAGS) tb.rc
+   link $(OBJS),$(TARGET),tb.map,libw.lib /MAP:FULL /COD /NOD:llibce llibcew commdlg $(TAPILIB),tb.def
+   rc -k tb.res $(TARGET)
+   mapsym tb
diff --git a/private/tapi/dev/apps/dirs b/private/tapi/dev/apps/dirs
new file mode 100644
index 000000000..556cbb1a4
--- /dev/null
+++ b/private/tapi/dev/apps/dirs
@@ -0,0 +1,27 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     tb      \
+     dialer  \
+     tapitna \
+     tapiupr
diff --git a/private/tapi/dev/apps/enumtapi/depend.mk b/private/tapi/dev/apps/enumtapi/depend.mk
new file mode 100644
index 000000000..beb7ce4bb
--- /dev/null
+++ b/private/tapi/dev/apps/enumtapi/depend.mk
@@ -0,0 +1 @@
+.\enumtapi.obj: ..\enumtapi.c
diff --git a/private/tapi/dev/apps/enumtapi/enumtapi.c b/private/tapi/dev/apps/enumtapi/enumtapi.c
new file mode 100644
index 000000000..f6c737477
--- /dev/null
+++ b/private/tapi/dev/apps/enumtapi/enumtapi.c
@@ -0,0 +1,257 @@
+#include <windows.h>
+#include <tapi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char szAppName[] = "TapiTest";
+
+#define APIVERSION 0x00010004
+
+// TAPI global variables.
+HINSTANCE hInstance;
+HLINEAPP hLineApp;
+DWORD dwNumDevs;
+long lReturn;
+
+void CALLBACK lineCallbackFunc(
+    DWORD dwDevice, DWORD dwMsg, DWORD dwCallbackInstance, 
+    DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
+void PrintTapiLines(DWORD dwDeviceID);
+
+int main (int argc, char * argv[], char * envp[])
+{
+   MSG msg;
+   DWORD i;
+
+   // Prime the message queue
+   PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
+
+   hInstance = GetModuleHandle(NULL);
+
+   if (lReturn = lineInitialize(&hLineApp, hInstance, lineCallbackFunc, 
+      szAppName, &dwNumDevs))
+   {
+      printf("lineInitialize failed: %li.\n", lReturn);
+      return 0;
+   }
+
+   if (dwNumDevs)
+   {
+      printf(
+         "<- dwDeviceID\n"
+         "|   <- Max dwAPIVersion\n"
+         "|   |    <- Number of addresses\n"
+         "|   |    |  <- Supports voice comm/datamodem calls?\n"
+         "|   |    |  |  <- Call in progress?\n"
+         "|   |    |  |  |  <- Any application waiting for calls?\n"
+         "|   |    |  |  |  |  <- Service Povider - Line Device Name\n"
+         "V   V    V  V  V  V  V\n"
+         );
+      for (i=0;i<dwNumDevs;i++)
+      {
+         PrintTapiLines(i);
+      }
+   }
+   else
+      printf("No TAPI Line devices installed.\n");
+
+   lineShutdown(hLineApp);
+}
+
+void PrintTapiLines(DWORD dwDeviceID)
+{
+   BOOL bSupportsDataComm = TRUE;
+
+   DWORD dwApiVersion;
+   LINEEXTENSIONID ExtensionID;
+   HLINE hLine;
+   DWORD dwAddressID = 0;
+
+   VARSTRING SmallVarString;
+
+   BYTE bufferLDC[4096];
+   LPLINEDEVCAPS lpLineDevCaps = (LPLINEDEVCAPS) bufferLDC;
+
+   BYTE bufferLDS[4096];
+   LPLINEDEVSTATUS lpLineDevStatus = (LPLINEDEVSTATUS) bufferLDS;
+
+   static BYTE bufferLPL[4096];
+   static LPLINEPROVIDERLIST lpLineProviderList = 
+      (LPLINEPROVIDERLIST) bufferLPL;
+   static LPLINEPROVIDERENTRY lpLineProviderEntry;
+   DWORD dwCount;
+
+   char * lpszLineName;
+   char szLineUnavail[] = "Line Unavailable";
+   char szLineUnnamed[] = "Line Unnamed";
+   char szLineNameEmpty[] = "Line Name is Empty";
+
+   lpLineDevCaps     ->dwTotalSize = sizeof(bufferLDC);
+   lpLineDevStatus   ->dwTotalSize = sizeof(bufferLDS);
+   lpLineProviderList->dwTotalSize = sizeof(bufferLPL);
+   SmallVarString     .dwTotalSize = sizeof(VARSTRING);
+
+   if (!lpLineProviderEntry)
+   {
+      lpLineProviderList->dwTotalSize = sizeof(bufferLPL);
+      lineGetProviderList(0x00010004, lpLineProviderList);
+      lpLineProviderEntry = (LPLINEPROVIDERENTRY)
+         ((BYTE *) lpLineProviderList + 
+            lpLineProviderList->dwProviderListOffset);
+   }
+
+   printf("%-2lu, ", dwDeviceID);
+
+   lReturn = lineNegotiateAPIVersion (hLineApp, dwDeviceID,
+      0x00010003, 0x00FF0004, &dwApiVersion, &ExtensionID);
+
+   if (lReturn)
+   {
+      printf("lineNegotiateAPIVersion error: %li\n", lReturn);
+      return;
+   }
+
+   printf("%lx.%lx, ", (dwApiVersion&0xFFFF0000)/0x00010000, 
+      dwApiVersion&0x0000FFFF);
+
+   lReturn = lineNegotiateAPIVersion (hLineApp, dwDeviceID,
+      APIVERSION, APIVERSION, &dwApiVersion, &ExtensionID);
+
+   if (lReturn == LINEERR_INCOMPATIBLEAPIVERSION)
+      bSupportsDataComm = FALSE;
+   else if (lReturn)
+   {
+      printf("lineNegotiateAPIVersion error: %li\n", lReturn);
+      return;
+   }
+
+//printf("\r\nAbout to call linegetdevcaps");
+
+   lReturn = lineGetDevCaps(hLineApp, dwDeviceID, 
+      dwApiVersion, 0, lpLineDevCaps);
+
+//printf("\r\nDone\r\n");
+
+   if (lReturn)
+   {
+      printf("lineGetDevCaps error: %li\n", lReturn);
+      return;
+   }
+
+//printf("\r\nprint\r\n");
+
+   printf("%lu, ", lpLineDevCaps->dwNumAddresses);
+
+//printf("\r\nDone2\r\n");
+
+   // TODO list available bearer modes
+
+   if (!(lpLineDevCaps->dwBearerModes & LINEBEARERMODE_VOICE ))
+      bSupportsDataComm = FALSE;
+
+   if (!(lpLineDevCaps->dwMediaModes & LINEMEDIAMODE_DATAMODEM))
+      bSupportsDataComm = FALSE;
+
+   if (!(lpLineDevCaps->dwLineFeatures & LINEFEATURE_MAKECALL))
+      bSupportsDataComm = FALSE;
+
+   lReturn = lineOpen(hLineApp, dwDeviceID, &hLine,
+      dwApiVersion, 0, 0, LINECALLPRIVILEGE_NONE, 0, 0);
+
+   if(lReturn == LINEERR_ALLOCATED)
+   {
+      printf("Line is already in use by a non-TAPI app or another TSP\n");
+      return;
+   }
+
+   if (lReturn)
+   {
+      printf("lineOpen error: %li\n", lReturn);
+      return;
+   }
+
+   // Make sure the "comm/datamodem" device class is supported
+   // Note that we don't want any of the 'extra' information
+   // normally returned in the VARSTRING structure.  All we care
+   // about is if lineGetID succeeds.
+   lReturn = lineGetID(hLine, 0, 0, LINECALLSELECT_LINE,
+      &SmallVarString, "comm/datamodem");
+
+   if (lReturn)
+      bSupportsDataComm = FALSE;
+
+   if (bSupportsDataComm)
+      printf("Y, ");
+   else
+      printf("N, ");
+
+   // TODO list calls already in progress.
+
+   lReturn = lineGetLineDevStatus(hLine, lpLineDevStatus);
+   if (lReturn)
+   {
+      printf("lineGetLineDevStatus error: %li\n", lReturn);
+      return;
+   }
+
+   if (lpLineDevStatus->dwNumActiveCalls ||
+       lpLineDevStatus->dwNumOnHoldCalls ||
+       lpLineDevStatus->dwNumOnHoldPendCalls)
+      printf("Y, ");
+   else
+      printf("N, ");
+
+   if (lpLineDevStatus->dwOpenMediaModes)
+      printf("Y, ");
+   else
+      printf("N, ");
+
+   
+   dwCount = lpLineProviderList->dwNumProviders;
+   while(dwCount--)
+   {
+      if (HIWORD(lpLineDevCaps->dwPermanentLineID) == 
+          lpLineProviderEntry[dwCount].dwPermanentProviderID)
+      {
+         printf("%s - ", (char *)
+            ((BYTE *) lpLineProviderList + 
+               lpLineProviderEntry[dwCount].dwProviderFilenameOffset));
+         dwCount = 1;
+         break;
+      }
+   }
+   if (dwCount != 1)
+      printf("Unknown TSP - ");
+
+   if ((lpLineDevCaps -> dwLineNameSize) &&
+       (lpLineDevCaps -> dwLineNameOffset) &&
+       (lpLineDevCaps -> dwStringFormat == STRINGFORMAT_ASCII))
+   {
+      // This is the name of the device.
+      lpszLineName = (char *)
+         ((BYTE *) lpLineDevCaps + lpLineDevCaps -> dwLineNameOffset);
+
+      if (lpszLineName[0] != '\0')
+      {
+         // If the device name is not null terminated, null
+         // terminate it.  Yes, this looses the end character.
+         // Its a bug in the service provider.
+         lpszLineName[lpLineDevCaps->dwLineNameSize-1] = '\0';
+      }
+      else // Line name started with a NULL.
+         lpszLineName = szLineNameEmpty;
+   }
+   else  // DevCaps doesn't have a valid line name.  Unnamed.
+      lpszLineName = szLineUnnamed;
+
+   printf("%s\n",lpszLineName);
+   lineClose(hLine);
+}
+
+
+void CALLBACK lineCallbackFunc(
+    DWORD dwDevice, DWORD dwMsg, DWORD dwCallbackInstance, 
+    DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
+{
+}
diff --git a/private/tapi/dev/apps/enumtapi/makefile b/private/tapi/dev/apps/enumtapi/makefile
new file mode 100644
index 000000000..b72e1a9ac
--- /dev/null
+++ b/private/tapi/dev/apps/enumtapi/makefile
@@ -0,0 +1,30 @@
+
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   enumtapi.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/enumtapi/makefile.def b/private/tapi/dev/apps/enumtapi/makefile.def
new file mode 100644
index 000000000..df65e8ef8
--- /dev/null
+++ b/private/tapi/dev/apps/enumtapi/makefile.def
@@ -0,0 +1,53 @@
+##############################################################################
+#
+#   enumtapi Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+WANT_C1032=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=enumtapi
+TARGETS=enumtapi.exe
+
+SRCDIR=..
+
+#BUILD_COFF=1
+
+DEFENTRY=main
+DEFSUBSYSTEM=CONSOLE
+
+L32EXE=enumtapi.exe		# Name of exe.
+#L32DEF=..\enumtapi.def              # Our def file.
+L32MAP=enumtapi.map		# Our map file.
+L32LIBS= \
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(ROOT)\dev\tools\c1032\lib\msvcrt.lib                  \
+        $(W32LIBID)\tapi32.lib                  \
+
+#L32RES=enumtapi.res	# Resource file.
+
+L32OBJS = enumtapi.obj
+
+
+L32FLAGS=$(L32FLAGS) /PDB:enumtapi.pdb /MAP:enumtapi.map
+
+!include $(ROOT)\dev\master.mk
+
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Og
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/apps/extidgen/depend.mk b/private/tapi/dev/apps/extidgen/depend.mk
new file mode 100644
index 000000000..3157782dc
--- /dev/null
+++ b/private/tapi/dev/apps/extidgen/depend.mk
@@ -0,0 +1,3 @@
+.\extidgen.obj:  ..\extidgen.c
+
+.\extidgen.res: ..\extidgen.rc
diff --git a/private/tapi/dev/apps/extidgen/extidgen.c b/private/tapi/dev/apps/extidgen/extidgen.c
new file mode 100644
index 000000000..d94abd5ed
--- /dev/null
+++ b/private/tapi/dev/apps/extidgen/extidgen.c
@@ -0,0 +1,73 @@
+#include <windows.h>
+#include <rpcdce.h>
+
+
+int WINAPI WinMain(
+                    HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow
+                  )
+{
+   TCHAR buf[1024];
+   TCHAR buf2[1024];
+   HANDLE hclipbuf;
+   LPVOID clipbuf;
+
+   union {
+           UUID uuid;
+           DWORD dwData[4];
+         }u;
+
+   
+//
+//      wsprintf (buf, "\nMicrosoft Extension ID Generator v%s\n", version);
+//      lstrcat(buf, "Copyright 1993-1995 Microsoft Corporation. All Rights Reserved.\n");
+//      lstrcat(buf, "A component of the Windows Telephony Software Development Kit.\n\n");
+//      lstrcat(buf, "Usage: EXTIDGEN\n");
+
+
+   if (UuidCreate ((UUID *)&u))
+   { 
+      wsprintf (buf, "An extended media mode ID could not be generated.\n(You must have NetBIOS loaded to generate an extension ID.)\n");
+      MessageBox(NULL, buf, "ExtIdGen", MB_OK);
+   }
+   else
+   {
+      int i;                          
+   
+   
+      hclipbuf = GlobalAlloc( GPTR, sizeof(buf) );
+      clipbuf =  GlobalLock( hclipbuf );
+
+
+      wsprintf (buf, "You may use the following extension ID as your TAPI extended media mode:\n");
+      wsprintf (clipbuf, "\r\n");
+
+      for (i = 0; i < 4; i++)
+      {
+         wsprintf(buf2, "dwExtensionID%u = 0x%08lX;\r\n", i, u.dwData[i]);
+         lstrcat( buf, buf2 );
+         lstrcat( clipbuf, buf2 );
+      }
+
+
+      lstrcat( buf, "\r\nThis program will now exit.  Should the ID be copied to the clipboard before exiting?");
+
+      i = MessageBox(NULL, buf, "ExtIdGen", MB_YESNO);
+
+
+      if ( IDYES == i )
+      {
+         OpenClipboard( NULL );
+         EmptyClipboard();
+         SetClipboardData( CF_TEXT, hclipbuf );
+         CloseClipboard();
+      }
+
+   }
+   
+//   GlobalFreePtr( clipbuf );
+
+   return 0;
+}
diff --git a/private/tapi/dev/apps/extidgen/extidgen.rc b/private/tapi/dev/apps/extidgen/extidgen.rc
new file mode 100644
index 000000000..be2ac06be
--- /dev/null
+++ b/private/tapi/dev/apps/extidgen/extidgen.rc
@@ -0,0 +1,27 @@
+#include "windows.h"
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) TAPI Extended Media Mode ID Generator"
+#define VER_INTERNALNAME_STR        "ExtIDGen"
+#define VER_ORIGINALFILENAME_STR    "EXTIDGEN.EXE"
+#define VER_LEGALCOPYRIGHT_YEARS    "1996"
+
+//#undef VER_PRODUCTVERSION
+//#undef VER_PRODUCTVERSION_STR
+//#define VER_PRODUCTVERSION      1.00.0.0000
+//#define VER_PRODUCTVERSION_STR "1.00.0.0000"
+
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
diff --git a/private/tapi/dev/apps/extidgen/makefile b/private/tapi/dev/apps/extidgen/makefile
new file mode 100644
index 000000000..cbc1f027e
--- /dev/null
+++ b/private/tapi/dev/apps/extidgen/makefile
@@ -0,0 +1,30 @@
+
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   extidgen Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/extidgen/makefile.def b/private/tapi/dev/apps/extidgen/makefile.def
new file mode 100644
index 000000000..74f7b012d
--- /dev/null
+++ b/private/tapi/dev/apps/extidgen/makefile.def
@@ -0,0 +1,57 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   extidgen Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+IS_32 = TRUE
+IS_OEM = TRUE
+WANT_C932=TUE
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=extidgen.exe extidgen.sym
+
+BUILD_COFF=1
+
+SRCDIR=..
+
+#DEFENTRY=main
+
+L32EXE=extidgen.exe		# Name of exe.
+# L32DEF=..\extidgen.def              # Our def file.
+L32MAP=extidgen.map		# Our map file.
+L32RES=extidgen.res
+L32LIBS=\
+        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib \
+        $(ROOT)\dev\lib\kernel32.lib \
+        $(ROOT)\dev\lib\user32.lib \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib 
+#..\llibce.lib ..\rpc.lib
+
+
+# L32RES=extidgen.res	# Resource file.
+
+L32OBJS=extidgen.obj
+
+!include $(ROOT)\dev\master.mk
+
+
+CFLAGS=$(CFLAGS) -DCHICOBUILD=1
+
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
+!endif
diff --git a/private/tapi/dev/apps/extidgen/sources b/private/tapi/dev/apps/extidgen/sources
new file mode 100644
index 000000000..d8fef11b4
--- /dev/null
+++ b/private/tapi/dev/apps/extidgen/sources
@@ -0,0 +1,25 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=ExtIDGen
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS= \
+            $(BASEDIR)\public\sdk\lib\*\kernel32.lib
+
+INCLUDES=$(BASEDIR)\public\sdk\inc;.
+
+UMENTRY=WinMain
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+USE_CRTDLL=1
+
+SOURCES=extidgen.c  \
+        extidgen.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/rstress/app2/app2.cpp b/private/tapi/dev/apps/rstress/app2/app2.cpp
new file mode 100644
index 000000000..37e72a4b9
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/app2/app2.cpp
@@ -0,0 +1,1215 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+#include "clntapp.h"
+
+//////////////////////////////////////////////////////////////////////////////
+//  GLOBALS
+//////////////////////////////////////////////////////////////////////////////
+HINSTANCE           ghInstance;
+HWND                ghMainWnd;
+ReplyStruct *       pReplyStruct;
+CRITICAL_SECTION    csReply;
+DWORD				dwNumLines;
+DWORD				dwNumInits;
+DWORD				dwSleep;
+DWORD				dwNumThreads;
+DWORD				dwThreadSleep;
+TCHAR				szFileName[MAX_PATH];
+BOOL                            gbLogging;
+
+BOOL InitializeVariables(LPTSTR lpszCommandLine);
+BOOL ESPLine(HLINEAPP hLineApp,
+             DWORD    dwDeviceID);
+BOOL ESPInstalled();
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID);
+LINEDEVSTATUS* LineGetLineDevStatus(HLINE hLine);
+
+
+
+TCHAR gszRStressKey[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\RStress");
+TCHAR gszPlacementValue[] = TEXT("WindowPlacement");
+
+DWORD MyTToL(LPTSTR lpszBuf);
+void MyIToT(int i, TCHAR * szBuf);
+DWORD MyRand();
+TCHAR MyToTLower(TCHAR tc);
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  MACRO for logging tapi error.
+//  must have a local variable dwProcess ID and dwThreadID
+//
+/////////////////////////////////////////////////////////////////////////////
+#define LOGTAPIERROR(lpszFunctionName, lRes)          \
+                {                                     \
+                    if ((LONG)(lRes) < 0)             \
+                    {                                 \
+                        LogTapiError(lpszFunctionName, lRes, dwProcessID, dwThreadID); \
+                    }                                 \
+                }
+
+// random number stuff
+#define MAX_SHORT       0xFFFF
+#define BCONST          12345
+
+typedef LONG (*SCENARIOPROC)(HANDLE);
+
+DWORD   dwPrivs[] = 
+        {
+            LINECALLPRIVILEGE_NONE,
+            LINECALLPRIVILEGE_MONITOR,
+            LINECALLPRIVILEGE_OWNER,
+            LINECALLPRIVILEGE_MONITOR | LINECALLPRIVILEGE_OWNER
+        };
+
+DWORD   dwModes[] = 
+        {
+            LINEMEDIAMODE_UNKNOWN,
+            LINEMEDIAMODE_INTERACTIVEVOICE,
+            LINEMEDIAMODE_AUTOMATEDVOICE,
+            LINEMEDIAMODE_DATAMODEM,
+            LINEMEDIAMODE_G3FAX,
+            LINEMEDIAMODE_TDD,
+            LINEMEDIAMODE_G4FAX,
+            LINEMEDIAMODE_DIGITALDATA,
+            LINEMEDIAMODE_TELETEX,
+            LINEMEDIAMODE_VIDEOTEX,
+            LINEMEDIAMODE_TELEX,
+            LINEMEDIAMODE_MIXED,
+            LINEMEDIAMODE_ADSI,
+            LINEMEDIAMODE_VOICEVIEW,
+        };
+
+int nummodes = sizeof(dwModes)/sizeof(DWORD);
+int numprivs = sizeof(dwPrivs)/sizeof(DWORD);
+            
+SCENARIOPROC ScenarioProcs[] = 
+             {
+                 Scenario4
+             };
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+
+int WINAPI WinMainCRTStartup()
+
+//int WINAPI WinMain (
+//HINSTANCE hInstance,
+//                    HINSTANCE hPrevInstance,
+//                    LPSTR     lpszCmdLine,
+//                    int       nCmdShow)
+{
+    MSG     msg;
+    DWORD   dwThreadID;
+
+    ghInstance = GetModuleHandle(NULL);
+
+    if (!CreateMainWindow(SW_SHOWNORMAL))
+    {
+        return 0;
+    }
+
+    InitializeVariables(GetCommandLine());
+    
+    if (!ESPInstalled())
+    {
+        return 0;
+    }
+
+
+    if (szFileName[0] == 0)
+    {
+//        MessageBox(NULL, TEXT("Failed to create log"), NULL, MB_OK);
+        return 0;
+
+    }
+
+    if (!InitLogging())
+    {
+//        MessageBox(NULL, TEXT("Failed to create log"), NULL, MB_OK);
+        return 0;
+    }
+
+    
+    CreateThread(NULL,
+                 0,
+                 (LPTHREAD_START_ROUTINE)StartThreads,
+                 NULL,
+                 0,
+                 &dwThreadID);
+
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    return 1;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  CreateMainWindow()
+//
+//////////////////////////////////////////////////////////////////////////////
+BOOL CreateMainWindow (int nCmdShow)
+{
+    WNDCLASS wc;
+    static TCHAR szClassName[] = TEXT("TapiClientWndClass");
+
+    wc.style         = 0;
+    wc.lpfnWndProc   = MainWndProc;
+    wc.cbClsExtra    = 0;
+    wc.cbWndExtra    = 0;
+    wc.hInstance     = ghInstance;
+    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wc.lpszMenuName  = NULL;
+    wc.lpszClassName = szClassName;
+
+
+    if (!RegisterClass(&wc))
+    {
+        return FALSE;
+    }
+
+    ghMainWnd = CreateWindow(szClassName, 
+                             TEXT("Tapi Client App"),
+                             WS_OVERLAPPEDWINDOW,
+                             0,
+                             0,
+                             GetSystemMetrics(SM_CXSCREEN)/2,
+                             GetSystemMetrics(SM_CYSCREEN)/2,
+                             NULL, 
+                             NULL, 
+                             ghInstance, 
+                             NULL);
+
+    if (ghMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+
+
+    {
+    WINDOWPLACEMENT pwp;
+    HKEY hKey;
+    DWORD dwDataSize;
+    DWORD dwDataType;
+
+
+
+    pwp.length = sizeof(WINDOWPLACEMENT);
+
+    RegOpenKeyEx(
+                    HKEY_CURRENT_USER,
+                    gszRStressKey,
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKey
+                  );
+
+    if ( RegQueryValueEx(
+                   hKey,
+                   gszPlacementValue,
+                   0,
+                   &dwDataType,
+                   (LPBYTE)&pwp,
+                   &dwDataSize
+                 ) )
+    {
+        ShowWindow(ghMainWnd, nCmdShow);
+    }
+    else
+    {
+        SetWindowPlacement( ghMainWnd, &pwp );
+    }
+
+
+    RegCloseKey( hKey );
+    }
+
+
+    UpdateWindow(ghMainWnd);
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  MainWndProc()
+//
+//////////////////////////////////////////////////////////////////////////////
+LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_DESTROY:
+            {
+            WINDOWPLACEMENT pwp;
+            HKEY hKey;
+            DWORD dwDisposition;
+
+
+            pwp.length = sizeof(WINDOWPLACEMENT);
+
+            GetWindowPlacement( hwnd, &pwp );
+
+            RegCreateKeyEx(
+                            HKEY_CURRENT_USER,
+                            gszRStressKey,
+                            0,
+                            TEXT(""),
+                            REG_OPTION_NON_VOLATILE,
+                            KEY_ALL_ACCESS,
+                            0,
+                            &hKey,
+                            &dwDisposition
+                          );
+
+            RegSetValueEx(
+                           hKey,
+                           gszPlacementValue,
+                           0,
+                           REG_BINARY,
+                           (LPBYTE)&pwp,
+                           sizeof(WINDOWPLACEMENT)
+                         );
+
+            RegCloseKey( hKey );
+
+
+            ExitProcess(0);
+//            PostQuitMessage(0);
+            }
+            break;
+
+        case WM_QUIT:
+            ExitProcess(0);
+            break;
+
+        default:
+            return DefWindowProc(hwnd, uMsg, wParam, lParam);
+    }
+    return 0;
+}
+
+BOOL InitializeVariables(LPTSTR lpszCommandLine)
+{
+    int             i, j;
+    TCHAR           szBuff[64];
+    TCHAR           tFlag;
+
+    dwNumLines = NUMLINES;
+    dwNumInits = NUMINITS;
+    dwNumThreads = NUMTHREADS;
+    dwSleep = SLEEPTIME;
+    dwThreadSleep = THREADSLEEP;
+    szFileName[0] = 0;
+    gbLogging = FALSE;
+    
+    while (*lpszCommandLine && *lpszCommandLine != '/')
+    {
+        lpszCommandLine ++;
+    }
+
+    if (!*lpszCommandLine)
+    {
+        return TRUE;
+    }
+
+    while (*lpszCommandLine != NULL)
+    {
+        while((*lpszCommandLine == ' ') ||
+              (*lpszCommandLine == '/') ||
+              (*lpszCommandLine == '\t'))
+        {
+            lpszCommandLine++;
+        }
+
+        tFlag = *lpszCommandLine;
+
+        lpszCommandLine++;
+        
+        if (*lpszCommandLine == ':')
+        {
+            lpszCommandLine++;
+        }
+
+        switch (MyToTLower(tFlag))
+        {
+            case 'f':
+            {
+                i = 0;
+                
+                while (*lpszCommandLine && (*lpszCommandLine != ' ') )
+                {
+                    szFileName[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                break;
+            }
+            case 'l':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumLines = MyTToL(szBuff);
+                break;
+                
+            }
+
+
+            case 'i':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumInits = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }                
+
+            case 't':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumThreads = (DWORD) MyTToL(szBuff);
+                    
+                break;
+                
+            }                
+
+         case 's':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwSleep = (DWORD) MyTToL(szBuff);
+
+                break;
+                
+            }                
+
+         case 'h':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwThreadSleep = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }
+         case 'g':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    lpszCommandLine++;
+                }
+                
+                gbLogging = TRUE;
+                break;
+                
+            }                
+            
+        }
+    }
+
+    return TRUE;
+}
+
+
+LONG StartThreads(DWORD dwHold)
+{
+    int                 i, iThreads, j, iLoc;
+    LPHANDLE            pHandles;
+    DWORD               dwThreadID;
+
+    pHandles = (LPHANDLE)GlobalAlloc(GPTR, sizeof(HANDLE) * dwNumThreads);
+
+    InitializeCriticalSection(&csReply);
+    InitReplyStruct();
+
+    iThreads = dwNumThreads;
+
+    for (i = 0; i < iThreads; i++)
+    {
+        pHandles[i] = CreateThread(NULL,
+                                   0,
+                                   (LPTHREAD_START_ROUTINE)ScenarioProcs[0],
+                                   NULL,
+                                   0,
+                                   &dwThreadID);
+
+        Sleep(dwThreadSleep);
+
+    }
+
+    iLoc = 0;
+           
+    while (iThreads > MAXIMUM_WAIT_OBJECTS)
+    {
+        WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS,
+                               (LPHANDLE)pHandles[iLoc],
+                               TRUE,
+                               INFINITE);
+
+        iThreads -= MAXIMUM_WAIT_OBJECTS;
+        iLoc += MAXIMUM_WAIT_OBJECTS;
+    }
+
+    WaitForMultipleObjects(iThreads,
+                           (LPHANDLE)(&(pHandles[iLoc])),
+                           TRUE,
+                           INFINITE);
+
+            {
+            WINDOWPLACEMENT pwp;
+            HKEY hKey;
+            DWORD dwDisposition;
+
+
+            pwp.length = sizeof(WINDOWPLACEMENT);
+
+            GetWindowPlacement( ghMainWnd, &pwp );
+
+            RegCreateKeyEx(
+                            HKEY_CURRENT_USER,
+                            gszRStressKey,
+                            0,
+                            TEXT(""),
+                            REG_OPTION_NON_VOLATILE,
+                            KEY_ALL_ACCESS,
+                            0,
+                            &hKey,
+                            &dwDisposition
+                          );
+
+            RegSetValueEx(
+                           hKey,
+                           gszPlacementValue,
+                           0,
+                           REG_BINARY,
+                           (LPBYTE)&pwp,
+                           sizeof(WINDOWPLACEMENT)
+                         );
+
+            RegCloseKey( hKey );
+            }
+
+
+    ExitProcess(1);
+
+    return 1;
+}
+
+void CALLBACK LineCallbackFunc(DWORD dwDevice, 
+                               DWORD dwMsg, 
+                               DWORD dwCallbackInstance, 
+                               DWORD dwParam1, 
+                               DWORD dwParam2, 
+                               DWORD dwParam3)
+{
+
+    return;
+}
+
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3)
+{
+    return;
+}
+
+
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3)
+{
+    DWORD       dwProcessID, dwThreadID;
+
+    dwProcessID = GetCurrentProcessId();
+    dwThreadID = GetCurrentThreadId();
+
+    LOGTAPIERROR(TEXT("LINE_REPLY"), dwParam2);
+
+    SignalReply(dwParam1, dwParam2);
+
+    return;
+}
+
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3)
+{
+    LONG lResult;
+    DWORD dwThreadID, dwProcessID;
+    
+    switch (dwParam1)
+    {
+    case LINECALLSTATE_CONNECTED:
+        SignalConnected((HCALL)dwDevice);
+        break;
+
+    case LINECALLSTATE_DISCONNECTED:
+        SignalDisconnected((HCALL)dwDevice, FALSE);
+        break;
+
+    case LINECALLSTATE_IDLE:
+        
+        dwThreadID = GetCurrentThreadId();
+        dwProcessID = GetCurrentProcessId();
+        
+        SignalDisconnected((HCALL)dwDevice, TRUE);
+        lResult = lineDeallocateCall((HCALL)dwDevice);
+        
+        LOGTAPIERROR(TEXT("lineDeallocateCall"), lResult);
+        
+        break;
+
+    case LINECALLSTATE_BUSY:
+        SignalError((HCALL)dwDevice);
+        break;
+
+    default:
+        break;
+    }
+}
+
+void HandleLineCallInfo(DWORD dwParam1,
+                             DWORD dwParam2,
+                             DWORD dwParam3)
+{
+}
+
+void HandleLineClose(DWORD dwParam1,
+                          DWORD dwParam2,
+                          DWORD dwParam3)
+{
+}
+
+
+LONG Scenario4(LPVOID lpv)
+{
+    HLINEAPP            hLineApp;
+    HCALL*              phCall;
+    HLINE               hLine;
+    DWORD               dwNumDevs;
+    int                 i;
+
+    phCall = (HCALL *)GlobalAlloc(GPTR, 10000*sizeof(HCALL));
+    
+    lineInitialize(&hLineApp,
+                   ghInstance,
+                   LineCallbackFunc,
+                   TEXT(""),
+                   &dwNumDevs);
+
+    lineOpen(hLineApp,
+             0,
+             &hLine,
+             TAPI_VERSION,
+             0,
+             0,
+             LINECALLPRIVILEGE_NONE,
+             LINEMEDIAMODE_UNKNOWN,
+             NULL);
+
+    while (TRUE)
+    {
+        i = 10000;
+
+        while (i--)
+        {
+
+            lineMakeCall(hLine,
+                         &phCall[i],
+                         TEXT("55555"),
+                         0,
+                         NULL);
+
+        }
+
+       lineClose(hLine);
+
+        lineOpen(hLineApp,
+                 0,
+                 &hLine,
+                 TAPI_VERSION,
+                 0,
+                 0,
+                 LINECALLPRIVILEGE_NONE,
+                 LINEMEDIAMODE_UNKNOWN,
+                 NULL);
+
+//        Sleep(0);
+    }
+    
+    ExitThread(0);
+
+    return 1;
+}
+
+void InitReplyStruct()
+{
+    EnterCriticalSection(&csReply);
+
+    pReplyStruct = (ReplyStruct *)GlobalAlloc(GPTR, sizeof(ReplyStruct));
+    pReplyStruct->pNext = NULL;
+
+    LeaveCriticalSection(&csReply);
+}
+
+DWORD AddReplyStruct()
+{
+    static DWORD    dwStaticID = 0;
+    ReplyStruct*    prs, * prsHold;
+    DWORD           dwRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    dwStaticID++;
+
+    dwRetVal = dwStaticID;
+
+    prs = (ReplyStruct *)GlobalAlloc(GPTR, sizeof(ReplyStruct));
+    memset(prs, 0, sizeof(ReplyStruct));
+	prs->dwID = dwStaticID;
+
+    prsHold = pReplyStruct;
+    pReplyStruct = prs;
+    pReplyStruct->pNext = prsHold;
+
+    LeaveCriticalSection(&csReply);
+
+    return dwRetVal;
+}
+
+void DeleteReplyStruct(DWORD dwID)
+{
+    ReplyStruct *   prsDelete, * prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsDelete = pReplyStruct;
+
+    while (prsDelete)
+    {
+        if (prsDelete->dwID == dwID)
+            break;
+
+        prsDelete = prsDelete->pNext;
+    }
+
+    if (!prsDelete)
+    {
+        return;
+    }
+    
+    prsHold = prsDelete->pNext;
+
+    if (!prsHold)
+    {
+        return;
+    }
+
+    memcpy(prsDelete, prsHold, sizeof(ReplyStruct));
+
+    GlobalFree(prsHold);
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalReply(DWORD dwReplyID, DWORD dwError)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->dwReplyID == dwReplyID)
+        {
+            prsHold->bSignaled = TRUE;
+            if ((LONG)dwError < 0)
+                prsHold->bError = TRUE;
+            break;
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SetReplyID(DWORD dwID, DWORD dwReplyID)
+{
+    ReplyStruct *		prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->dwID == dwID)
+        {
+            prsHold->dwReplyID = dwReplyID;
+            break;
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SetCallHandle(DWORD dwID, HCALL* phCall)
+{
+    ReplyStruct *		prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->dwID == dwID)
+            break;
+
+        prsHold = prsHold->pNext;
+    }
+
+    if (prsHold)
+    {
+        prsHold->phCall = phCall;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalConnected(HCALL hCall)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->phCall != NULL)
+        {
+            if (*(prsHold->phCall) == hCall)
+            {
+                prsHold->bConnected = TRUE;
+                break;
+            }
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalDisconnected(HCALL hCall, BOOL fTimeToDie)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->phCall != NULL)
+        {
+            if (*(prsHold->phCall) == hCall)
+            {
+                prsHold->bConnected = FALSE;
+                
+                //
+                // Is the call IDLE and about to be
+                // terminated?
+                //
+                if ( fTimeToDie )
+                {
+                    //
+                    // Zero out our hCall so we don't try to
+                    // use it anywhere...
+                    //
+                    *(prsHold->phCall) = 0;
+                }
+                
+                break;
+            }
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalError(HCALL hCall)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->phCall != NULL)
+        {
+            if (*(prsHold->phCall) == hCall)
+            {
+                prsHold->bError = TRUE;
+                break;
+            }
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+BOOL GetSignaled(DWORD dwID)
+{
+    ReplyStruct *		pRS;
+    BOOL				bRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            bRetVal = pRS->bSignaled;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+
+    return bRetVal;
+}
+
+
+BOOL GetConnected(DWORD dwID)
+{
+    ReplyStruct *		pRS;
+    BOOL				bRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            bRetVal = pRS->bConnected;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+
+    return bRetVal;
+}
+
+BOOL GetError(DWORD dwID)
+{
+    ReplyStruct *   		pRS;
+    BOOL				bRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            bRetVal = pRS->bError;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+
+    return bRetVal;
+}
+
+void ClearError(DWORD dwID)
+{
+    ReplyStruct *       pRS;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            pRS->bError = FALSE;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+#define SZPROVIDERINFO      TEXT("ESP v2.0")
+
+BOOL ESPInstalled()
+{
+    HLINEAPP        hLineApp;
+    LINEDEVCAPS *   pLDC;
+    DWORD           dwDeviceID, dwCount;
+    LPTSTR          lpszName;
+    int             i;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (lineInitialize(&hLineApp,
+                          ghInstance,
+                          LineCallbackFunc,
+                          TEXT(""),
+                          &dwDeviceID) == 0)
+        {
+            for (dwCount = 0; dwCount < dwDeviceID; dwCount ++)
+            {
+                if (ESPLine(hLineApp,
+                            dwCount))
+                {
+                    return TRUE;
+                }
+            }
+
+            lineShutdown(hLineApp);
+            
+            Sleep(5000);
+        }
+    }
+    return FALSE;
+}
+
+            
+BOOL ESPLine(HLINEAPP hLineApp,
+             DWORD    dwDeviceID)
+{
+    LINEDEVCAPS *       pLDC;
+    LPTSTR               lpszName;
+    
+    pLDC = LineGetDevCaps(hLineApp,
+                          dwDeviceID);
+
+    if (!pLDC)
+    {
+        return FALSE;
+    }
+
+    lpszName = (LPTSTR) ( ( (LPBYTE)pLDC ) + pLDC->dwProviderInfoOffset);
+
+    if (!lstrcmpi(lpszName,
+                  SZPROVIDERINFO))
+    {
+        LocalFree(pLDC);
+        return TRUE;
+    }
+
+    LocalFree(pLDC);
+    return FALSE;
+    
+}
+
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID)
+{
+    LONG           lRetVal;
+    LINEDEVCAPS  * pLineDevCaps;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVCAPS);
+
+    pLineDevCaps = (LINEDEVCAPS *)LocalAlloc(LPTR, dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineDevCaps->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetDevCaps(hLineApp,
+                                 dwDeviceID,
+                                 TAPI_VERSION,
+                                 0,
+                                 pLineDevCaps);
+        if (lRetVal < 0)
+        {
+            LocalFree((HLOCAL)pLineDevCaps);
+            return NULL;
+        }
+        if (pLineDevCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevCaps->dwNeededSize;
+            pLineDevCaps = (LINEDEVCAPS *)LocalReAlloc((HLOCAL)pLineDevCaps,
+                                        dwMaxNeededSize,
+                                        LMEM_MOVEABLE);
+        }
+    }
+}
+
+LINEDEVSTATUS * LineGetLineDevStatus (HLINE hLine)
+{
+    LONG           lRetVal;
+    LINEDEVSTATUS* pLineDevStatus;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVSTATUS);
+
+    pLineDevStatus = (LINEDEVSTATUS *)LocalAlloc(LPTR, dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevStatus == NULL)
+        {
+            return NULL;
+        }
+        pLineDevStatus->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetLineDevStatus(hLine,
+                                       pLineDevStatus);
+        
+        if ((lRetVal != LINEERR_STRUCTURETOOSMALL) && (lRetVal < 0))
+        {
+            LocalFree((HLOCAL)pLineDevStatus);
+            return NULL;
+        }
+        
+        if (pLineDevStatus->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevStatus;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevStatus->dwNeededSize;
+            pLineDevStatus = (LINEDEVSTATUS *)LocalReAlloc((HLOCAL)pLineDevStatus,
+                dwMaxNeededSize,
+                LMEM_MOVEABLE);
+        }
+    }
+}
+
+#define ISDIGIT(c) ( ( (c) >= '0') && ( (c) <= '9') )
+
+DWORD MyTToL(LPTSTR lpszBuf)
+{
+    DWORD   dwReturn = 0;
+
+    while (*lpszBuf && ISDIGIT(*lpszBuf))
+    {
+        dwReturn = dwReturn*10 + (*lpszBuf - '0');
+        lpszBuf++;
+    }
+
+    return dwReturn;
+}
+
+DWORD MyRand()
+{
+    static DWORD RandSeed = GetTickCount();
+
+    RandSeed = (RandSeed*BCONST+1) % MAX_SHORT;
+
+    return RandSeed;
+}
+
+void MyIToT(int i, TCHAR * szBuf)
+{
+    wsprintf(szBuf, TEXT("%d"), i);
+
+    return;
+}
+
+TCHAR MyToTLower(TCHAR tc)
+{
+    if ((tc <= 'z') && (tc >= 'a'))
+        return tc;
+
+    return tc-'A'+'a';
+}
diff --git a/private/tapi/dev/apps/rstress/app2/clntapp.h b/private/tapi/dev/apps/rstress/app2/clntapp.h
new file mode 100644
index 000000000..b60117025
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/app2/clntapp.h
@@ -0,0 +1,80 @@
+#include <windows.h>
+#include <tapi.h>
+
+#define TAPI_VERSION    0x00010004
+#define NUMLINES        200
+#define NUMINITS        200
+#define SZAPPNAME       TEXT("TapiClientApp")
+#define SLEEPTIME       2000
+#define NUMTHREADS      20
+#define THREADSLEEP     15000           // up to 15 seconds
+#define GLOBALTIMEOUT   10000           // 10 seconds
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+static LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                                     UINT   uMsg,
+                                     WPARAM wParam,
+                                     LPARAM lParam);
+
+BOOL SetupEnvironment (int argc, char * argv[], char * szFileName);
+
+void CALLBACK LineCallbackFunc(DWORD dwDevice, 
+                               DWORD dwMsg, 
+                               DWORD dwCallbackInstance, 
+                               DWORD dwParam1, 
+                               DWORD dwParam2, 
+                               DWORD dwParam3);
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3);
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3);
+void HandleLineCallInfo(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3);
+void HandleLineClose(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+LONG Scenario1(LPVOID lpv);
+LONG Scenario2(LPVOID lpv);
+LONG Scenario3(LPVOID lpv);
+LONG Scenario4(LPVOID lpv);
+LONG StartThreads(DWORD dwHold);
+
+typedef struct _ReplyStruct
+{
+    HCALL *                 phCall;
+    DWORD                   dwReplyID;
+    BOOL                    bSignaled;
+    BOOL                    bConnected;
+    BOOL                    bError;
+    DWORD                   dwID;
+    struct _ReplyStruct *   pNext;
+} ReplyStruct;
+
+void InitReplyStruct();
+DWORD AddReplyStruct();
+void DeleteReplyStruct(DWORD dwID);
+void SignalReply(DWORD dwReplyID, DWORD);
+void SetReplyID(DWORD dwID, DWORD dwReplyID);
+void SetCallHandle(DWORD dwID, HCALL * phCall);
+void SignalConnected(HCALL hCall);
+void SignalDisconnected(HCALL hCall, BOOL);
+BOOL GetSignaled(DWORD dwID);
+BOOL GetConnected(DWORD dwID);
+BOOL GetError(DWORD dwID);
+void ClearError(DWORD dwID);
+void SignalError(HCALL hCall);
+
+BOOL InitLogging();
+void CloseLogging();
+TCHAR * FormatTime(LONG dwTime);
+void LogTapiError(LPTSTR lpszFunction, LONG lResult, DWORD dwProcessID, DWORD dwThreadID);
diff --git a/private/tapi/dev/apps/rstress/app2/logging.cpp b/private/tapi/dev/apps/rstress/app2/logging.cpp
new file mode 100644
index 000000000..2a116e441
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/app2/logging.cpp
@@ -0,0 +1,210 @@
+#include "clntapp.h"
+
+HANDLE              hLogFile;
+extern TCHAR        szFileName[MAX_PATH];
+CRITICAL_SECTION    csFile;
+extern BOOL         gbLogging;
+
+LPTSTR lpszLineErrs[] =
+{
+   TEXT("SUCCESS"),
+   TEXT("ALLOCATED"),
+   TEXT("BADDEVICEID"),
+   TEXT("BEARERMODEUNAVAIL"),
+   TEXT("inval err code (0x80000004)"),      // 0x80000004 isn't valid err code
+   TEXT("CALLUNAVAIL"),
+   TEXT("COMPLETIONOVERRUN"),
+   TEXT("CONFERENCEFULL"),
+   TEXT("DIALBILLING"),
+   TEXT("DIALDIALTONE"),
+   TEXT("DIALPROMPT"),
+   TEXT("DIALQUIET"),
+   TEXT("INCOMPATIBLEAPIVERSION"),
+   TEXT("INCOMPATIBLEEXTVERSION"),
+   TEXT("INIFILECORRUPT"),
+   TEXT("INUSE"),
+   TEXT("INVALADDRESS"),                     // 0x80000010
+   TEXT("INVALADDRESSID"),
+   TEXT("INVALADDRESSMODE"),
+   TEXT("INVALADDRESSSTATE"),
+   TEXT("INVALAPPHANDLE"),
+   TEXT("INVALAPPNAME"),
+   TEXT("INVALBEARERMODE"),
+   TEXT("INVALCALLCOMPLMODE"),
+   TEXT("INVALCALLHANDLE"),
+   TEXT("INVALCALLPARAMS"),
+   TEXT("INVALCALLPRIVILEGE"),
+   TEXT("INVALCALLSELECT"),
+   TEXT("INVALCALLSTATE"),
+   TEXT("INVALCALLSTATELIST"),
+   TEXT("INVALCARD"),
+   TEXT("INVALCOMPLETIONID"),
+   TEXT("INVALCONFCALLHANDLE"),              // 0x80000020
+   TEXT("INVALCONSULTCALLHANDLE"),
+   TEXT("INVALCOUNTRYCODE"),
+   TEXT("INVALDEVICECLASS"),
+   TEXT("INVALDEVICEHANDLE"),
+   TEXT("INVALDIALPARAMS"),
+   TEXT("INVALDIGITLIST"),
+   TEXT("INVALDIGITMODE"),
+   TEXT("INVALDIGITS"),
+   TEXT("INVALEXTVERSION"),
+   TEXT("INVALGROUPID"),
+   TEXT("INVALLINEHANDLE"),
+   TEXT("INVALLINESTATE"),
+   TEXT("INVALLOCATION"),
+   TEXT("INVALMEDIALIST"),
+   TEXT("INVALMEDIAMODE"),
+   TEXT("INVALMESSAGEID"),                   // 0x80000030
+   TEXT("inval err code (0x80000031)"),      // 0x80000031 isn't valid err code
+   TEXT("INVALPARAM"),
+   TEXT("INVALPARKID"),
+   TEXT("INVALPARKMODE"),
+   TEXT("INVALPOINTER"),
+   TEXT("INVALPRIVSELECT"),
+   TEXT("INVALRATE"),
+   TEXT("INVALREQUESTMODE"),
+   TEXT("INVALTERMINALID"),
+   TEXT("INVALTERMINALMODE"),
+   TEXT("INVALTIMEOUT"),
+   TEXT("INVALTONE"),
+   TEXT("INVALTONELIST"),
+   TEXT("INVALTONEMODE"),
+   TEXT("INVALTRANSFERMODE"),
+   TEXT("LINEMAPPERFAILED"),                 // 0x80000040
+   TEXT("NOCONFERENCE"),
+   TEXT("NODEVICE"),
+   TEXT("NODRIVER"),
+   TEXT("NOMEM"),
+   TEXT("NOREQUEST"),
+   TEXT("NOTOWNER"),
+   TEXT("NOTREGISTERED"),
+   TEXT("OPERATIONFAILED"),
+   TEXT("OPERATIONUNAVAIL"),
+   TEXT("RATEUNAVAIL"),
+   TEXT("RESOURCEUNAVAIL"),
+   TEXT("REQUESTOVERRUN"),
+   TEXT("STRUCTURETOOSMALL"),
+   TEXT("TARGETNOTFOUND"),
+   TEXT("TARGETSELF"),
+   TEXT("UNINITIALIZED"),                    // 0x80000050
+   TEXT("USERUSERINFOTOOBIG"),
+   TEXT("REINIT"),
+   TEXT("ADDRESSBLOCKED"),
+   TEXT("BILLINGREJECTED"),
+   TEXT("INVALFEATURE"),
+   TEXT("NOMULTIPLEINSTANCE")
+};
+   
+BOOL InitLogging()
+{
+    LONG        dwTime;
+    DWORD       dwLen;
+
+    if (!gbLogging)
+            return TRUE;
+    
+    InitializeCriticalSection(&csFile);
+
+    EnterCriticalSection(&csFile);
+
+    hLogFile = CreateFile(szFileName,
+                          GENERIC_WRITE,
+                          0,
+                          NULL,
+                          OPEN_ALWAYS,
+                          FILE_ATTRIBUTE_NORMAL,
+                          NULL);
+
+    CloseHandle(hLogFile);
+
+    LeaveCriticalSection(&csFile);
+
+    return TRUE;
+}
+
+void LogTapiError(LPTSTR lpszFunction, LONG lResult, DWORD dwProcessID, DWORD dwThreadID)
+{
+    TCHAR       szBuffer[512];
+    DWORD       dwBytes;
+    char        szCharBuffer[512];
+    DWORD       dwerror;
+    SYSTEMTIME  st;
+
+    if (!gbLogging)
+        return ;
+    
+    EnterCriticalSection(&csFile);
+    
+    if (hLogFile == 0)
+    {
+        LeaveCriticalSection(&csFile);
+        return;
+    }
+
+    GetSystemTime(&st);
+
+    wsprintf(szBuffer,
+             TEXT("%02d:%02d:%02d:%04d: PROCESS:%lu THREAD:%lu %s FAILED with %s\r\n"),
+             st.wHour,
+             st.wMinute,
+             st.wSecond,
+             st.wMilliseconds,
+             dwProcessID,
+             dwThreadID,
+             lpszFunction,
+             lpszLineErrs[LOWORD(lResult)]);
+
+    WideCharToMultiByte(CP_ACP,
+                        0,
+                        szBuffer,
+                        -1,
+                        szCharBuffer,
+                        512,
+                        NULL,
+                        NULL);
+        
+    while (TRUE)
+    {
+        // wait until file is available
+        hLogFile = CreateFile(szFileName,
+                              GENERIC_WRITE,
+                              0,
+                              NULL,
+                              OPEN_EXISTING,
+                              FILE_ATTRIBUTE_NORMAL,
+                              NULL);
+
+        if (hLogFile == INVALID_HANDLE_VALUE)
+        {
+            Sleep(1000);
+            continue;
+        }
+
+        break;
+    }
+
+    
+    SetFilePointer(hLogFile,
+                   0,
+                   NULL,
+                   FILE_END);
+
+    WriteFile(hLogFile,
+              szCharBuffer,
+              lstrlenA(szCharBuffer),
+              &dwBytes,
+              NULL);
+
+    CloseHandle(hLogFile);
+
+    LeaveCriticalSection(&csFile);
+    
+}
+
+void CloseLogging()
+{
+
+//    CloseHandle(hLogFile);
+}
+
diff --git a/private/tapi/dev/apps/rstress/app2/makefile b/private/tapi/dev/apps/rstress/app2/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/app2/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/rstress/app2/sources b/private/tapi/dev/apps/rstress/app2/sources
new file mode 100644
index 000000000..a383c269b
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/app2/sources
@@ -0,0 +1,55 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=app2
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32l.lib \
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_NOLIBS=1
+
+SOURCES=app2.cpp \
+        logging.cpp
+
+C_DEFINES=-DWINVER=0x0400 -DUNICODE -DREALLY_USE_UNICODE -DTAPI_CURRENT_VERSION=0x00010004
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/rstress/client/makefile b/private/tapi/dev/apps/rstress/client/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/client/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/rstress/client/sources b/private/tapi/dev/apps/rstress/client/sources
new file mode 100644
index 000000000..21ec8d2d0
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/client/sources
@@ -0,0 +1,54 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tclient
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+#USE_NOLIBS=1
+USE_CRTDLL=1
+
+SOURCES=tclient.cpp
+
+C_DEFINES=-DWINVER=0x0400
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/rstress/client/tclient.cpp b/private/tapi/dev/apps/rstress/client/tclient.cpp
new file mode 100644
index 000000000..90384bbde
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/client/tclient.cpp
@@ -0,0 +1,488 @@
+#include <windows.h>
+
+#define SZCLIENTAPP         "clntapp.exe"
+#define TAPI_VERSION1_4     0x00010004
+
+char        szFileDirectory[MAX_PATH + 1];
+char        szFileName[MAX_PATH + 1];
+DWORD       dwSleepTime         = 2000;
+DWORD       dwNumApps           = 15;
+DWORD       dwNumThreads        = 10;
+DWORD       dwNumInits          = 50;
+DWORD       dwNumLines          = 50;
+DWORD       dwThreadSleep       = 15000;
+DWORD       dwID;
+BOOL        bRun                = TRUE;
+BOOL        gbNTSD              = FALSE;
+
+HANDLE      hDestroyEvent;
+HINSTANCE   ghInstance;
+HWND        ghMainWnd;
+
+LONG ThreadProc(LPVOID lpv);
+BOOL CreateMainWindow (int nCmdShow);
+LRESULT CALLBACK MainWndProc (HWND   hWnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam);
+void CALLBACK LineCallbackFunc (DWORD hDevice,
+                                DWORD dwMessage,
+                                DWORD dwInstance,
+                                DWORD dwParam1,
+                                DWORD dwParam2,
+                                DWORD dwParam3);
+void CreateFileName();
+BOOL InitializeVariables(LPTSTR lpszCommandLine);
+DWORD MyTToL(LPTSTR lpszBuf);
+TCHAR MyToTLower(TCHAR tc);
+
+//int WINAPI WinMainCRTStartup()
+int WINAPI WinMain(
+                   HINSTANCE hInstance,
+                   HINSTANCE hPrevInstance,
+                   LPSTR     lpszCmdLine,
+                   int       nCmdShow)
+{
+    MSG         msg;
+    DWORD       dwThreadID;
+
+    ghInstance = GetModuleHandle(NULL);
+
+    if (!CreateMainWindow(SW_SHOWNORMAL))
+    {
+        return 0;
+    }
+
+    hDestroyEvent = CreateEvent(NULL,
+                                TRUE,
+                                FALSE,
+                                NULL);
+
+    CreateThread(NULL,
+                 0,
+                 (LPTHREAD_START_ROUTINE)ThreadProc,
+                 NULL,
+                 0,
+                 &dwThreadID);
+
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    return 1;
+}
+
+BOOL CreateMainWindow (int nCmdShow)
+{
+    WNDCLASS wc;
+    static char szClassName[] = "TClientWndClass";
+    RECT rc;
+
+    wc.style         = 0;
+    wc.lpfnWndProc   = MainWndProc;
+    wc.cbClsExtra    = 0;
+    wc.cbWndExtra    = 0;
+    wc.hInstance     = ghInstance;
+    wc.hIcon         = NULL;
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wc.lpszMenuName  = NULL;
+    wc.lpszClassName = szClassName;
+
+
+    if (!RegisterClass(&wc))
+    {
+        return FALSE;
+    }
+
+    ghMainWnd = CreateWindow(
+        szClassName, "",
+        WS_OVERLAPPEDWINDOW,
+        GetSystemMetrics(SM_CXSCREEN)-GetSystemMetrics(SM_CXSCREEN)/4,
+        0,
+        GetSystemMetrics(SM_CXSCREEN)/4,
+        GetSystemMetrics(SM_CYSCREEN)/4,
+        NULL, NULL, ghInstance, NULL);
+
+    if (ghMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+    ShowWindow(ghMainWnd, SW_SHOWMINNOACTIVE);
+    UpdateWindow(ghMainWnd);
+    return TRUE;
+}
+
+LRESULT CALLBACK MainWndProc (HWND   hWnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_QUERYENDSESSION:
+            bRun = FALSE;
+            DestroyWindow(ghMainWnd);
+            return TRUE;
+            
+        case WM_CLOSE:
+            bRun = FALSE;
+
+            DestroyWindow(ghMainWnd);
+
+            return 0;
+            
+        case WM_DESTROY:
+            WaitForSingleObject(hDestroyEvent,
+                                15000);
+            
+//            PostQuitMessage(0);
+            ExitProcess(0);
+            break;
+
+        default:
+            return DefWindowProc(hWnd, uMsg, wParam, lParam);
+
+    }
+    return 0;
+}
+
+LONG ThreadProc(LPVOID lpv)
+{
+    STARTUPINFO             si;
+    PROCESS_INFORMATION     pi;
+    char                    szCommandLine[MAX_PATH+256];
+    int                     i;
+    LPHANDLE                pProcessHandles;
+    DWORD                   dwReturn;
+
+    GetWindowsDirectory(szFileDirectory,
+                        MAX_PATH);
+
+    InitializeVariables(GetCommandLine());
+
+    pProcessHandles = (LPHANDLE)GlobalAlloc(GPTR, sizeof(HANDLE) * dwNumApps);
+
+    memset(&si, 0, sizeof(si));
+    si.cb = sizeof(si);
+
+    Sleep(1000);
+
+    // start up initial ones
+    for (i = 0; i < (LONG)dwNumApps; )
+    {
+        CreateFileName();
+
+        wsprintf(szCommandLine,
+                 gbNTSD?
+               "ntsd -g -G %s /f:%s /l:%lu /i:%lu /s:%lu /t:%lu /h:%lu":
+                 "%s /f:%s /l:%lu /i:%lu /s:%lu /t:%lu /h:%lu",
+                 SZCLIENTAPP,
+                 szFileName,
+                 dwNumLines,
+                 dwNumInits,
+                 dwSleepTime,
+                 dwNumThreads,
+                 dwThreadSleep);
+
+        if (CreateProcess(NULL,
+                      szCommandLine,
+                      NULL,
+                      NULL,
+                      FALSE,
+                      NORMAL_PRIORITY_CLASS,
+                      NULL,
+                      NULL,
+                      &si,
+                      &pi))
+        {
+            pProcessHandles[i] = pi.hProcess;
+            CloseHandle(pi.hThread);
+            i++;
+        }
+
+        if (!bRun)
+            break;
+
+        Sleep(dwThreadSleep);
+    }
+
+    // keep starting up apps
+    while (bRun)
+    {
+        // wait for one to finish
+        dwReturn = WaitForMultipleObjects(dwNumApps,
+                                          pProcessHandles,
+                                          FALSE,
+                                          INFINITE);
+
+        if ((dwReturn >= WAIT_OBJECT_0) &&
+            (dwReturn < (WAIT_OBJECT_0 + dwNumApps)))
+        {
+            CreateFileName();
+
+            wsprintf(szCommandLine,
+                     gbNTSD?
+                      "ntsd -g -G %s /f:%s /l:%lu /i:%lu /s:%lu /t:%lu /h:%lu":
+                      "%s /f:%s /l:%lu /i:%lu /s:%lu /t:%lu /h:%lu",
+                     SZCLIENTAPP,
+                     szFileName,
+                     dwNumLines,
+                     dwNumInits,
+                     dwSleepTime,
+                     dwNumThreads,
+                     dwThreadSleep);
+
+            while (!(CreateProcess(NULL,
+                          szCommandLine,
+                          NULL,
+                          NULL,
+                          FALSE,
+                          NORMAL_PRIORITY_CLASS,
+                          NULL,
+                          NULL,
+                          &si,
+                          &pi)))
+            {
+                Sleep(5000);
+            }
+
+            CloseHandle(pProcessHandles[dwReturn - WAIT_OBJECT_0]);
+            CloseHandle(pi.hThread);
+            pProcessHandles[dwReturn - WAIT_OBJECT_0] = pi.hProcess;
+        }
+    }
+
+    // asked to terminate, but wait for all clntapps to finish
+    for (i = 0; i < (LONG)dwNumApps; i++)
+    {
+        TerminateProcess(pProcessHandles[i],
+                         0);
+
+        CloseHandle(pProcessHandles[i]);
+
+    }
+
+    SetEvent(hDestroyEvent);
+    
+   return 1;
+}
+
+/////////////////////////////////////////////////
+
+BOOL InitializeVariables(LPTSTR lpszCommandLine)
+{
+    int             i, j;
+    TCHAR           szBuff[64];
+    TCHAR           tFlag;
+
+    while (*lpszCommandLine != '/')
+    {
+        lpszCommandLine ++;
+    }
+
+    while (*lpszCommandLine != NULL)
+    {
+        while((*lpszCommandLine == ' ') ||
+              (*lpszCommandLine == '/') ||
+              (*lpszCommandLine == '\t'))
+        {
+            lpszCommandLine++;
+        }
+
+        tFlag = *lpszCommandLine;
+
+        lpszCommandLine++;
+        
+        if (*lpszCommandLine == ':')
+        {
+            lpszCommandLine++;
+        }
+
+        switch (MyToTLower(tFlag))
+        {
+
+            case 'a':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumApps = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }                
+
+            case 'l':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumLines = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }                
+
+            case 'i':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumInits = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }                
+
+            case 't':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumThreads = (DWORD) MyTToL(szBuff);
+
+                break;
+                
+            }                
+
+            case 's':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwSleepTime = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }                
+
+            case 'h':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwThreadSleep = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }                
+
+            case 'f':
+            {
+                i = 0;
+                
+                while (*lpszCommandLine && (*lpszCommandLine != ' ') )
+                {
+                    szFileDirectory[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                break;
+            }
+            case 'g':
+            {
+                i = 0;
+                
+                while (*lpszCommandLine && (*lpszCommandLine != ' ') )
+                {
+                    lpszCommandLine++;
+                }
+
+                gbNTSD = TRUE;
+                
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    return TRUE;
+}
+
+void CreateFileName()
+{
+    SYSTEMTIME      st;
+
+    GetSystemTime(&st);
+
+    wsprintf(szFileName, 
+             "%s\\TAPICLIENT%u.%u",
+             szFileDirectory,
+             st.wDay,
+             st.wHour);
+
+    return;
+}
+
+#define ISDIGIT(c) ( ( (c) >= '0') && ( (c) <= '9') )
+
+DWORD MyTToL(LPTSTR lpszBuf)
+{
+    DWORD   dwReturn = 0;
+
+    while (ISDIGIT(*lpszBuf))
+    {
+        dwReturn = dwReturn*10 + (*lpszBuf - '0');
+        lpszBuf++;
+    }
+
+    return dwReturn;
+}
+
+TCHAR MyToTLower(TCHAR tc)
+{
+    if ((tc <= 'z') && (tc >= 'a'))
+        return tc;
+
+    return tc-'A'+'a';
+}
diff --git a/private/tapi/dev/apps/rstress/clntapp/clntapp.cpp b/private/tapi/dev/apps/rstress/clntapp/clntapp.cpp
new file mode 100644
index 000000000..a36df0403
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/clntapp/clntapp.cpp
@@ -0,0 +1,1635 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+#include "clntapp.h"
+
+//////////////////////////////////////////////////////////////////////////////
+//  GLOBALS
+//////////////////////////////////////////////////////////////////////////////
+HINSTANCE           ghInstance;
+HWND                ghMainWnd;
+ReplyStruct *       pReplyStruct;
+CRITICAL_SECTION    csReply;
+DWORD				dwNumLines;
+DWORD				dwNumInits;
+DWORD				dwSleep;
+DWORD				dwNumThreads;
+DWORD				dwThreadSleep;
+TCHAR				szFileName[MAX_PATH];
+BOOL                            gbLogging;
+
+BOOL InitializeVariables(LPTSTR lpszCommandLine);
+BOOL ESPLine(HLINEAPP hLineApp,
+             DWORD    dwDeviceID);
+BOOL ESPInstalled();
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID);
+LINEDEVSTATUS* LineGetLineDevStatus(HLINE hLine);
+
+
+
+TCHAR gszRStressKey[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\RStress");
+TCHAR gszPlacementValue[] = TEXT("WindowPlacement");
+
+DWORD MyTToL(LPTSTR lpszBuf);
+void MyIToT(int i, TCHAR * szBuf);
+DWORD MyRand();
+TCHAR MyToTLower(TCHAR tc);
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  MACRO for logging tapi error.
+//  must have a local variable dwProcess ID and dwThreadID
+//
+/////////////////////////////////////////////////////////////////////////////
+#define LOGTAPIERROR(lpszFunctionName, lRes)          \
+                {                                     \
+                    if ((LONG)(lRes) < 0)             \
+                    {                                 \
+                        LogTapiError(lpszFunctionName, lRes, dwProcessID, dwThreadID); \
+                    }                                 \
+                }
+
+// random number stuff
+#define MAX_SHORT       0xFFFF
+#define BCONST          12345
+
+typedef LONG (*SCENARIOPROC)(HANDLE);
+
+DWORD   dwPrivs[] = 
+        {
+            LINECALLPRIVILEGE_NONE,
+            LINECALLPRIVILEGE_MONITOR,
+            LINECALLPRIVILEGE_OWNER,
+            LINECALLPRIVILEGE_MONITOR | LINECALLPRIVILEGE_OWNER
+        };
+
+DWORD   dwModes[] = 
+        {
+            LINEMEDIAMODE_UNKNOWN,
+            LINEMEDIAMODE_INTERACTIVEVOICE,
+            LINEMEDIAMODE_AUTOMATEDVOICE,
+            LINEMEDIAMODE_DATAMODEM,
+            LINEMEDIAMODE_G3FAX,
+            LINEMEDIAMODE_TDD,
+            LINEMEDIAMODE_G4FAX,
+            LINEMEDIAMODE_DIGITALDATA,
+            LINEMEDIAMODE_TELETEX,
+            LINEMEDIAMODE_VIDEOTEX,
+            LINEMEDIAMODE_TELEX,
+            LINEMEDIAMODE_MIXED,
+            LINEMEDIAMODE_ADSI,
+            LINEMEDIAMODE_VOICEVIEW,
+        };
+
+int nummodes = sizeof(dwModes)/sizeof(DWORD);
+int numprivs = sizeof(dwPrivs)/sizeof(DWORD);
+            
+SCENARIOPROC ScenarioProcs[] = 
+             {
+//                 Scenario1,
+//                 Scenario2,
+//                 Scenario3,
+                 Scenario4
+             };
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//int WINAPI WinMainCRTStartup()
+
+int WINAPI WinMain (
+                    HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow)
+{
+    MSG     msg;
+    DWORD   dwThreadID;
+
+    ghInstance = GetModuleHandle(NULL);
+
+    if (!CreateMainWindow(SW_SHOWNORMAL))
+    {
+        return 0;
+    }
+
+    InitializeVariables(GetCommandLine());
+    
+    if (!ESPInstalled())
+    {
+        return 0;
+    }
+
+
+    if (szFileName[0] == 0)
+    {
+        MessageBox(NULL, TEXT("Failed to create log"), NULL, MB_OK);
+        return 0;
+
+    }
+
+    if (!InitLogging())
+    {
+        MessageBox(NULL, TEXT("Failed to create log"), NULL, MB_OK);
+        return 0;
+    }
+
+    
+    CreateThread(NULL,
+                 0,
+                 (LPTHREAD_START_ROUTINE)StartThreads,
+                 NULL,
+                 0,
+                 &dwThreadID);
+
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    return 1;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  CreateMainWindow()
+//
+//////////////////////////////////////////////////////////////////////////////
+BOOL CreateMainWindow (int nCmdShow)
+{
+    WNDCLASS wc;
+    static TCHAR szClassName[] = TEXT("TapiClientWndClass");
+
+    wc.style         = 0;
+    wc.lpfnWndProc   = MainWndProc;
+    wc.cbClsExtra    = 0;
+    wc.cbWndExtra    = 0;
+    wc.hInstance     = ghInstance;
+    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wc.lpszMenuName  = NULL;
+    wc.lpszClassName = szClassName;
+
+
+    if (!RegisterClass(&wc))
+    {
+        return FALSE;
+    }
+
+    ghMainWnd = CreateWindow(szClassName, 
+                             TEXT("Tapi Client App"),
+                             WS_OVERLAPPEDWINDOW,
+                             0,
+                             0,
+                             GetSystemMetrics(SM_CXSCREEN)/2,
+                             GetSystemMetrics(SM_CYSCREEN)/2,
+                             NULL, 
+                             NULL, 
+                             ghInstance, 
+                             NULL);
+
+    if (ghMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+
+    ShowWindow(ghMainWnd, SW_SHOWMINNOACTIVE);
+
+    UpdateWindow(ghMainWnd);
+    return TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  MainWndProc()
+//
+//////////////////////////////////////////////////////////////////////////////
+LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_QUERYENDSESSION:
+        case WM_ENDSESSION:
+            ExitProcess(0);
+            return TRUE;
+            break;
+            
+        case WM_DESTROY:
+
+            ExitProcess(0);
+//            PostQuitMessage(0);
+            break;
+
+        case WM_QUIT:
+            ExitProcess(0);
+            break;
+
+        default:
+            return DefWindowProc(hwnd, uMsg, wParam, lParam);
+    }
+    return 0;
+}
+
+BOOL InitializeVariables(LPTSTR lpszCommandLine)
+{
+    int             i, j;
+    TCHAR           szBuff[64];
+    TCHAR           tFlag;
+
+    dwNumLines = NUMLINES;
+    dwNumInits = NUMINITS;
+    dwNumThreads = NUMTHREADS;
+    dwSleep = SLEEPTIME;
+    dwThreadSleep = THREADSLEEP;
+    szFileName[0] = 0;
+    gbLogging = FALSE;
+    
+    while (*lpszCommandLine && *lpszCommandLine != '/')
+    {
+        lpszCommandLine ++;
+    }
+
+    if (!*lpszCommandLine)
+    {
+        return TRUE;
+    }
+
+    while (*lpszCommandLine != NULL)
+    {
+        while((*lpszCommandLine == ' ') ||
+              (*lpszCommandLine == '/') ||
+              (*lpszCommandLine == '\t'))
+        {
+            lpszCommandLine++;
+        }
+
+        tFlag = *lpszCommandLine;
+
+        lpszCommandLine++;
+        
+        if (*lpszCommandLine == ':')
+        {
+            lpszCommandLine++;
+        }
+
+        switch (MyToTLower(tFlag))
+        {
+            case 'f':
+            {
+                i = 0;
+                
+                while (*lpszCommandLine && (*lpszCommandLine != ' ') )
+                {
+                    szFileName[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                break;
+            }
+
+            case 't':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwNumThreads = (DWORD) MyTToL(szBuff);
+                    
+                break;
+                
+            }                
+
+         case 's':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwSleep = (DWORD) MyTToL(szBuff);
+
+                break;
+                
+            }                
+
+         case 'h':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+                
+                szBuff[i] = 0;
+
+                dwThreadSleep = (DWORD) MyTToL(szBuff);
+                break;
+                
+            }
+         case 'g':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    lpszCommandLine++;
+                }
+                
+                gbLogging = TRUE;
+                break;
+                
+            }                
+            
+        }
+    }
+
+    return TRUE;
+}
+
+/*
+BOOL InitializeVariables(int argc, char * argv[])
+{
+	int			i, j;
+	char		chFlag;
+
+	i = 0;
+
+	dwNumLines = NUMLINES;
+	dwNumInits = NUMINITS;
+	dwNumThreads = NUMTHREADS;
+	dwSleep = SLEEPTIME;
+	dwThreadSleep = THREADSLEEP;
+	szFileName[0] = 0;
+
+   while (++i < argc)
+   {
+      j = 0;
+      if ((argv[i][j] == '/') || (argv[i][j] == '-') || (argv[i][j] == '+'))
+         j = 1;
+
+      chFlag = argv[i][j++];
+
+      if (argv[i][j] == ':')
+         j++;
+
+      switch(tolower(chFlag))
+      {
+         case 'l':
+            sscanf(&argv[i][j], "%lu", &dwNumLines);
+            break;
+
+         case 'i':
+            sscanf(&argv[i][j], "%lu", &dwNumInits);
+            break;
+
+         case 't':
+            sscanf(&argv[i][j], "%lu", &dwNumThreads);
+            break;
+
+         case 's':
+            sscanf(&argv[i][j], "%lu", &dwSleep);
+            break;
+
+         case 'h':
+            sscanf(&argv[i][j], "%lu", &dwThreadSleep);
+            break;
+			
+         case 'f':
+            sscanf(&argv[i][j], "%s", szFileName);
+            break;
+
+         default:
+             break;
+      }
+   }
+
+   MessageBox(NULL,
+              szFileName,
+              NULL,
+              MB_OK);
+
+   return TRUE;
+}
+*/
+
+LONG StartThreads(DWORD dwHold)
+{
+    int                 i, iThreads, j, iLoc;
+    LPHANDLE            pHandles;
+    DWORD               dwThreadID;
+
+    pHandles = (LPHANDLE)GlobalAlloc(GPTR, sizeof(HANDLE) * dwNumThreads);
+
+    InitializeCriticalSection(&csReply);
+    InitReplyStruct();
+
+    iThreads = dwNumThreads;
+
+    for (i = 0; i < iThreads; i++)
+    {
+        j = (DWORD)MyRand() * (sizeof(ScenarioProcs) / sizeof (SCENARIOPROC)) / MAX_SHORT;
+
+        pHandles[i] = CreateThread(NULL,
+                                   0,
+                                   (LPTHREAD_START_ROUTINE)ScenarioProcs[j],
+                                   NULL,
+                                   0,
+                                   &dwThreadID);
+
+        Sleep((DWORD)MyRand() * dwThreadSleep / MAX_SHORT);
+
+    }
+
+    iLoc = 0;
+           
+    while (iThreads > MAXIMUM_WAIT_OBJECTS)
+    {
+        WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS,
+                               (LPHANDLE)pHandles[iLoc],
+                               TRUE,
+                               INFINITE);
+
+        iThreads -= MAXIMUM_WAIT_OBJECTS;
+        iLoc += MAXIMUM_WAIT_OBJECTS;
+    }
+
+    WaitForMultipleObjects(iThreads,
+                           (LPHANDLE)(&(pHandles[iLoc])),
+                           TRUE,
+                           INFINITE);
+
+            {
+            WINDOWPLACEMENT pwp;
+            HKEY hKey;
+            DWORD dwDisposition;
+
+
+            pwp.length = sizeof(WINDOWPLACEMENT);
+
+            GetWindowPlacement( ghMainWnd, &pwp );
+
+            RegCreateKeyEx(
+                            HKEY_CURRENT_USER,
+                            gszRStressKey,
+                            0,
+                            TEXT(""),
+                            REG_OPTION_NON_VOLATILE,
+                            KEY_ALL_ACCESS,
+                            0,
+                            &hKey,
+                            &dwDisposition
+                          );
+
+            RegSetValueEx(
+                           hKey,
+                           gszPlacementValue,
+                           0,
+                           REG_BINARY,
+                           (LPBYTE)&pwp,
+                           sizeof(WINDOWPLACEMENT)
+                         );
+
+            RegCloseKey( hKey );
+            }
+
+
+    ExitProcess(1);
+
+    return 1;
+}
+
+void CALLBACK LineCallbackFunc(DWORD dwDevice, 
+                               DWORD dwMsg, 
+                               DWORD dwCallbackInstance, 
+                               DWORD dwParam1, 
+                               DWORD dwParam2, 
+                               DWORD dwParam3)
+{
+
+   switch(dwMsg)
+   {
+      case LINE_LINEDEVSTATE:
+          HandleLineDevState(dwParam1,
+                             dwParam2,
+                             dwParam3);
+          return;
+      case LINE_REPLY:
+          HandleLineReply(dwParam1,
+                          dwParam2,
+                          dwParam3);
+          return;
+      case LINE_CALLSTATE:
+          HandleLineCallState(dwDevice,
+                              dwParam1,
+                              dwParam2,
+                              dwParam3);
+          return; 
+      case LINE_CALLINFO:
+          HandleLineCallInfo(dwParam1,
+                             dwParam2,
+                             dwParam3);
+          return;
+      case LINE_CLOSE:
+          HandleLineClose(dwParam1,
+                          dwParam2,
+                          dwParam3);
+          return;
+
+      default:
+          return;
+   }
+}
+
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3)
+{
+    return;
+}
+
+
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3)
+{
+    DWORD       dwProcessID, dwThreadID;
+
+    dwProcessID = GetCurrentProcessId();
+    dwThreadID = GetCurrentThreadId();
+
+    LOGTAPIERROR(TEXT("LINE_REPLY"), dwParam2);
+
+    SignalReply(dwParam1, dwParam2);
+
+    return;
+}
+
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3)
+{
+    LONG lResult;
+    DWORD dwThreadID, dwProcessID;
+    
+    switch (dwParam1)
+    {
+    case LINECALLSTATE_CONNECTED:
+        SignalConnected((HCALL)dwDevice);
+        break;
+
+    case LINECALLSTATE_DISCONNECTED:
+        SignalDisconnected((HCALL)dwDevice, FALSE);
+        break;
+
+    case LINECALLSTATE_IDLE:
+        
+        dwThreadID = GetCurrentThreadId();
+        dwProcessID = GetCurrentProcessId();
+        
+        SignalDisconnected((HCALL)dwDevice, TRUE);
+        lResult = lineDeallocateCall((HCALL)dwDevice);
+        
+        LOGTAPIERROR(TEXT("lineDeallocateCall"), lResult);
+        
+        break;
+
+    case LINECALLSTATE_BUSY:
+        SignalError((HCALL)dwDevice);
+        break;
+
+    default:
+        break;
+    }
+}
+
+void HandleLineCallInfo(DWORD dwParam1,
+                             DWORD dwParam2,
+                             DWORD dwParam3)
+{
+}
+
+void HandleLineClose(DWORD dwParam1,
+                          DWORD dwParam2,
+                          DWORD dwParam3)
+{
+}
+
+LONG Scenario1(LPVOID lpv)
+{
+    HLINEAPP            hLineApp;
+    HLINE               hLine;
+    DWORD               dwDeviceID, dwNumDevs, dwProcessID, dwThreadID;
+    int                 i;
+    int                 iMode, iPriv;
+    LONG                lResult;
+
+    dwProcessID = GetCurrentProcessId();
+    dwThreadID  = GetCurrentThreadId();
+
+    lResult = lineInitialize(&hLineApp,
+                             ghInstance,
+                             LineCallbackFunc,
+                             SZAPPNAME,
+                             &dwNumDevs);
+
+    LOGTAPIERROR(TEXT("lineInitialize"), lResult);
+
+    if (lResult < 0)
+    {
+        ExitThread(0);
+        return 0;
+    }
+
+    i = MyRand() * dwNumLines / MAX_SHORT + 1;
+
+    while (i--)
+    {
+        iMode = MyRand() * nummodes / MAX_SHORT;
+        iPriv = MyRand() * numprivs / MAX_SHORT;
+        dwDeviceID = (DWORD)(MyRand() * dwNumDevs / MAX_SHORT);
+
+        lResult = lineOpen(hLineApp,
+                           dwDeviceID,
+                           &hLine,
+                           TAPI_VERSION,
+                           0,
+                           0, 
+                           dwPrivs[iPriv],
+                           dwModes[iMode],
+                           NULL);
+
+        LOGTAPIERROR(TEXT("lineOpen"), lResult);
+
+        lResult = lineClose(hLine);
+
+        LOGTAPIERROR(TEXT("lineClose"), lResult);
+
+        Sleep(MyRand() * dwSleep / MAX_SHORT);
+    }
+
+    lResult = lineShutdown(hLineApp);
+
+    LOGTAPIERROR(TEXT("lineShutdown"), lResult);
+
+    ExitThread(0);
+
+    return 1;
+}
+
+LONG Scenario2(LPVOID lpv)
+{
+    HLINEAPP            hLineApp;
+    HLINE               hLine;
+    DWORD               dwDeviceID, dwNumDevs, dwThreadID, dwProcessID;
+    int                 i;
+    int                 iMode, iPriv;
+    LONG                lResult;
+
+    dwThreadID  = GetCurrentThreadId();
+    dwProcessID = GetCurrentProcessId();
+
+    i = MyRand() * dwNumLines / MAX_SHORT + 1;
+
+    while (i--)
+    {
+        lResult = lineInitialize(&hLineApp,
+                                 ghInstance,
+                                 LineCallbackFunc,
+                                 SZAPPNAME,
+                                 &dwNumDevs);
+
+        LOGTAPIERROR(TEXT("lineInitialize"), lResult);
+        if (lResult < 0)
+        {
+            break;
+        }
+
+        iMode = MyRand() * nummodes / MAX_SHORT;
+        iPriv = MyRand() * numprivs / MAX_SHORT;
+        dwDeviceID = (DWORD)(MyRand() * dwNumDevs / MAX_SHORT);
+
+        lResult = lineOpen(hLineApp,
+                           dwDeviceID,
+                           &hLine,
+                           TAPI_VERSION,
+                           0,
+                           0,
+                           dwPrivs[iPriv],
+                           dwModes[iMode],
+                           NULL);
+        LOGTAPIERROR(TEXT("lineOpen"), lResult);
+
+        Sleep(MyRand() * dwSleep / MAX_SHORT);
+
+        lResult = lineClose(hLine);
+        LOGTAPIERROR(TEXT("lineClose"), lResult);
+
+        lResult = lineShutdown(hLineApp);
+        LOGTAPIERROR(TEXT("lineShutdown"), lResult);
+    }
+
+    ExitThread(0);
+
+    return 1;
+}
+
+LONG Scenario3(LPVOID lpv)
+{
+    HLINEAPP *          phLineApps;
+    HLINE *             phLine;
+    DWORD               dwDeviceID, dwNumDevs, dwThreadID, dwProcessID;
+    int                 i, k, iOpens, iInits;
+    int                 iMode, iPriv, iLineApp;
+    LONG                lResult;
+
+    dwThreadID  = GetCurrentThreadId();
+    dwProcessID = GetCurrentProcessId();
+
+    phLineApps = (HLINEAPP *)GlobalAlloc(GPTR, sizeof(HLINEAPP) * dwNumInits);
+    phLine = (HLINE *)GlobalAlloc(GPTR, sizeof(HLINE) * dwNumLines);
+
+    i = MyRand() * dwNumLines / MAX_SHORT + 1;
+
+    while (i--)
+    {
+        iInits = MyRand() * dwNumInits / MAX_SHORT;
+
+        for (k = 0; k < iInits; k++)
+        {
+            lResult = lineInitialize(&phLineApps[k],
+                           ghInstance,
+                           LineCallbackFunc,
+                           SZAPPNAME,
+                           &dwNumDevs);
+
+            LOGTAPIERROR(TEXT("lineInitialize"), lResult);
+        }
+
+        iOpens = MyRand() * dwNumInits / MAX_SHORT;
+        
+        for (k = 0; k < iOpens; k++)
+        {
+            iMode = MyRand() * nummodes / MAX_SHORT;
+            iPriv = MyRand() * numprivs / MAX_SHORT;
+            dwDeviceID = (DWORD)(MyRand() * dwNumDevs / MAX_SHORT);
+            iLineApp = MyRand() * iInits / MAX_SHORT;
+
+            lResult = lineOpen(phLineApps[iLineApp],
+                     dwDeviceID,
+                     &phLine[k],
+                     TAPI_VERSION,
+                     0,
+                     0,
+                     dwPrivs[iPriv],
+                     dwModes[iMode],
+                     NULL);
+
+            LOGTAPIERROR(TEXT("lineOpen"), lResult);
+        }
+
+        for (k = 0; k < iOpens; k++)
+        {
+            lResult = lineClose(phLine[k]);
+
+            LOGTAPIERROR(TEXT("lineClose"), lResult);
+        }
+        for (k = 0; k < iInits; k++)
+        {
+            lResult = lineShutdown(phLineApps[k]);
+
+            LOGTAPIERROR(TEXT("lineShutdown"), lResult);
+        }
+    }
+
+    GlobalFree(phLineApps);
+    GlobalFree(phLine);
+
+    ExitThread(0);
+
+    return 1;
+}
+
+LONG Scenario4(LPVOID lpv)
+{
+    HLINEAPP            hLineApp;
+    HLINE               hLine, hCallLine;
+    HCALL               hCall;
+    DWORD               dwDeviceID, dwReplyID, dwNumDevs, dwCallID;
+    DWORD               dwThreadID, dwProcessID;
+    MSG                 msg;
+    int                 i, iMode, iPriv, k;
+    DWORD				dwRS;
+    LINECALLINFO        CI;
+    LINECALLSTATUS      CS;
+    LINEDEVCAPS*        pLDC;
+    LINEDEVSTATUS*      pLDS;
+    LINEADDRESSSTATUS   AS;
+    TCHAR               szNumber[16];
+    LONG                lResult;
+    DWORD               dwTime;
+
+    dwThreadID  = GetCurrentThreadId();
+    dwProcessID = GetCurrentProcessId();
+
+  //  i = MyRand() * dwNumLines / MAX_SHORT + 1;
+
+    i = 10;
+
+    while (i--)
+    {
+        lResult = lineInitialize(&hLineApp,
+                       ghInstance,
+                       LineCallbackFunc,
+                       SZAPPNAME,
+                       &dwNumDevs);
+
+        LOGTAPIERROR(TEXT("linelineInitialize"), lResult);
+        if (lResult < 0)
+        {
+            break;
+        }
+
+        iMode = MyRand() * nummodes / MAX_SHORT;
+        iPriv = MyRand() * numprivs / MAX_SHORT;
+
+        while (TRUE)
+        {
+            dwDeviceID = (DWORD)(MyRand() * dwNumDevs / MAX_SHORT);
+
+            pLDC = LineGetDevCaps(hLineApp,
+                                  dwDeviceID);
+
+            if (pLDC)
+            {
+                LocalFree(pLDC);
+            }
+                        
+            lResult = lineOpen(hLineApp,
+                               dwDeviceID,
+                               &hLine,
+                               TAPI_VERSION,
+                               0,
+                               0,
+                               dwPrivs[iPriv],
+                               dwModes[iMode],
+                               NULL);
+            LOGTAPIERROR(TEXT("lineOpen"), lResult);
+
+            if (lResult < 0)
+            {
+                continue;
+            }
+
+            pLDS = LineGetLineDevStatus(hLine);
+            
+            if (pLDS)
+            {
+                if ((pLDS->dwNumActiveCalls == 0) && ESPLine(hLineApp, dwDeviceID))
+                {
+                    LocalFree(pLDS);
+                    break;
+                }
+
+                LocalFree(pLDS);
+                
+            }
+
+            lResult = lineClose(hLine);
+            LOGTAPIERROR(TEXT("lineClose"), lResult);
+        }
+
+        while (TRUE)
+        {
+            dwCallID = (DWORD)(MyRand() * dwNumDevs / MAX_SHORT);
+
+            pLDC = LineGetDevCaps(hLineApp,
+                                  dwCallID);
+            if (pLDC)
+            {
+                LocalFree(pLDC);
+            }
+
+            lResult = lineOpen(hLineApp,
+                     dwCallID,
+                     &hCallLine,
+                     TAPI_VERSION,
+                     0,
+                     0,
+                     dwPrivs[iPriv],
+                     dwModes[iMode],
+                     NULL);
+            LOGTAPIERROR(TEXT("lineOpen"), lResult);
+
+            if (lResult < 0)
+            {
+                continue;
+            }
+
+            pLDS = LineGetLineDevStatus(hCallLine);
+
+            if (pLDS)
+            {
+                lResult = lineClose(hCallLine);
+                LOGTAPIERROR(TEXT("lineClose"), lResult);
+
+                if ((pLDS->dwNumActiveCalls == 0) &&
+                    (dwCallID != dwDeviceID) &&
+                    ESPLine(hLineApp, dwCallID))
+                {
+                    LocalFree(pLDS);
+                    break;
+                }
+
+                LocalFree(pLDS);
+            }
+            
+        }
+
+        dwRS = AddReplyStruct();
+
+        MyIToT((int)dwCallID, szNumber);
+
+        SetCallHandle(dwRS, &hCall);
+
+        ClearError(dwRS);
+
+        dwReplyID = lineMakeCall(hLine,
+                                 &hCall,
+                                 szNumber,
+                                 0,
+                                 NULL);
+
+        SetReplyID(dwRS, dwReplyID);
+
+        if ((LONG)dwReplyID < 0)
+        {
+            LOGTAPIERROR(TEXT("lineMakeCall"), dwReplyID);
+            DeleteReplyStruct(dwRS);
+            lineClose(hLine);
+            lineShutdown(hLineApp);
+
+            continue;
+        }
+
+        dwTime = GetTickCount();
+        while (TRUE)
+        {
+            AS.dwTotalSize = sizeof(AS);
+            CS.dwTotalSize = sizeof(CS);
+            CI.dwTotalSize = sizeof(CI);
+
+            lResult = lineGetAddressStatus(hLine,
+                                 0,
+                                 &AS);
+            LOGTAPIERROR(TEXT("lineGetAddressStatus"), lResult);
+
+            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+            {
+                    TranslateMessage(&msg);
+                    DispatchMessage(&msg);
+            }
+
+            if (GetSignaled(dwRS))
+            {
+                if (GetConnected(dwRS))
+                {
+                    break;
+                }
+                if (GetError(dwRS))
+                {
+                    
+                    goto callerror;
+                }
+            }
+
+            if ((GetTickCount() - dwTime) > GLOBALTIMEOUT)
+            {
+                goto callerror;
+            }
+
+            Sleep(0);
+        }
+
+        if (hCall)
+        {
+            lResult = lineGetCallStatus(hCall,
+                              &CS);
+            LOGTAPIERROR(TEXT("lineGetCallStatus"), lResult);
+
+            lResult = lineGetCallInfo(hCall,
+                            &CI);
+            LOGTAPIERROR(TEXT("lineGetCallInfo"), lResult);
+        }
+
+        ClearError(dwRS);
+
+        if (hCall)
+        {
+            lResult = lineDrop(hCall,
+                     NULL,
+                     0);
+            LOGTAPIERROR(TEXT("lineDrop"), lResult);
+        }
+
+        dwTime = GetTickCount();
+
+        while (TRUE && hCall)
+        {
+            AS.dwTotalSize = sizeof(AS);
+            CS.dwTotalSize = sizeof(CS);
+            CI.dwTotalSize = sizeof(CI);
+
+            lResult = lineGetAddressStatus(hLine,
+                                           0,
+                                           &AS);
+            LOGTAPIERROR(TEXT("lineGetAddressStatus"), lResult);
+
+            lResult = lineGetCallStatus(hCall,
+                                        &CS);
+            LOGTAPIERROR(TEXT("lineGetCallStatus"), lResult);
+
+            lResult  = lineGetCallInfo(hCall,
+                                       &CI);
+            LOGTAPIERROR(TEXT("lineGetCallInfo"), lResult);
+
+            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+            {
+                    TranslateMessage(&msg);
+                    DispatchMessage(&msg);
+            }
+
+            if (!GetConnected(dwRS))
+            {
+                break;
+            }
+
+            if (GetError(dwRS))
+            {
+                break;
+            }
+
+            if ((GetTickCount() - dwTime) > GLOBALTIMEOUT)
+            {
+                goto callerror;
+            }
+
+            Sleep(0);
+        }
+
+callerror:
+
+        if ( hCall )
+        {
+            lineDeallocateCall(hCall);
+        }
+
+        DeleteReplyStruct(dwRS);
+
+        lResult = lineClose(hLine);
+        LOGTAPIERROR(TEXT("lineClose"), lResult);
+
+        lResult = lineShutdown(hLineApp);
+        LOGTAPIERROR(TEXT("lineShutdown"), lResult);
+    }
+
+    ExitThread(0);
+
+    return 1;
+}
+
+void InitReplyStruct()
+{
+    EnterCriticalSection(&csReply);
+
+    pReplyStruct = (ReplyStruct *)GlobalAlloc(GPTR, sizeof(ReplyStruct));
+    pReplyStruct->pNext = NULL;
+
+    LeaveCriticalSection(&csReply);
+}
+
+DWORD AddReplyStruct()
+{
+    static DWORD    dwStaticID = 0;
+    ReplyStruct*    prs, * prsHold;
+    DWORD           dwRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    dwStaticID++;
+
+    dwRetVal = dwStaticID;
+
+    prs = (ReplyStruct *)GlobalAlloc(GPTR, sizeof(ReplyStruct));
+    memset(prs, 0, sizeof(ReplyStruct));
+	prs->dwID = dwStaticID;
+
+    prsHold = pReplyStruct;
+    pReplyStruct = prs;
+    pReplyStruct->pNext = prsHold;
+
+    LeaveCriticalSection(&csReply);
+
+    return dwRetVal;
+}
+
+void DeleteReplyStruct(DWORD dwID)
+{
+    ReplyStruct *   prsDelete, * prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsDelete = pReplyStruct;
+
+    while (prsDelete)
+    {
+        if (prsDelete->dwID == dwID)
+            break;
+
+        prsDelete = prsDelete->pNext;
+    }
+
+    if (!prsDelete)
+    {
+        return;
+    }
+    
+    prsHold = prsDelete->pNext;
+
+    if (!prsHold)
+    {
+        return;
+    }
+
+    memcpy(prsDelete, prsHold, sizeof(ReplyStruct));
+
+    GlobalFree(prsHold);
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalReply(DWORD dwReplyID, DWORD dwError)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->dwReplyID == dwReplyID)
+        {
+            prsHold->bSignaled = TRUE;
+            if ((LONG)dwError < 0)
+                prsHold->bError = TRUE;
+            break;
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SetReplyID(DWORD dwID, DWORD dwReplyID)
+{
+    ReplyStruct *		prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->dwID == dwID)
+        {
+            prsHold->dwReplyID = dwReplyID;
+            break;
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SetCallHandle(DWORD dwID, HCALL* phCall)
+{
+    ReplyStruct *		prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->dwID == dwID)
+            break;
+
+        prsHold = prsHold->pNext;
+    }
+
+    if (prsHold)
+    {
+        prsHold->phCall = phCall;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalConnected(HCALL hCall)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->phCall != NULL)
+        {
+            if (*(prsHold->phCall) == hCall)
+            {
+                prsHold->bConnected = TRUE;
+                break;
+            }
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalDisconnected(HCALL hCall, BOOL fTimeToDie)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->phCall != NULL)
+        {
+            if (*(prsHold->phCall) == hCall)
+            {
+                prsHold->bConnected = FALSE;
+                
+                //
+                // Is the call IDLE and about to be
+                // terminated?
+                //
+                if ( fTimeToDie )
+                {
+                    //
+                    // Zero out our hCall so we don't try to
+                    // use it anywhere...
+                    //
+                    *(prsHold->phCall) = 0;
+                }
+                
+                break;
+            }
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+void SignalError(HCALL hCall)
+{
+    ReplyStruct *       prsHold;
+
+    EnterCriticalSection(&csReply);
+
+    prsHold = pReplyStruct;
+
+    while (prsHold)
+    {
+        if (prsHold->phCall != NULL)
+        {
+            if (*(prsHold->phCall) == hCall)
+            {
+                prsHold->bError = TRUE;
+                break;
+            }
+        }
+
+        prsHold = prsHold->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+BOOL GetSignaled(DWORD dwID)
+{
+    ReplyStruct *		pRS;
+    BOOL				bRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            bRetVal = pRS->bSignaled;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+
+    return bRetVal;
+}
+
+
+BOOL GetConnected(DWORD dwID)
+{
+    ReplyStruct *		pRS;
+    BOOL				bRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            bRetVal = pRS->bConnected;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+
+    return bRetVal;
+}
+
+BOOL GetError(DWORD dwID)
+{
+    ReplyStruct *   		pRS;
+    BOOL				bRetVal;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            bRetVal = pRS->bError;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+
+    return bRetVal;
+}
+
+void ClearError(DWORD dwID)
+{
+    ReplyStruct *       pRS;
+
+    EnterCriticalSection(&csReply);
+
+    pRS = pReplyStruct;
+
+    while (pRS)
+    {
+        if (pRS->dwID == dwID)
+        {
+            pRS->bError = FALSE;
+            break;
+        }
+
+        pRS = pRS->pNext;
+    }
+
+    LeaveCriticalSection(&csReply);
+}
+
+#define SZPROVIDERINFO      TEXT("ESP v2.0")
+
+BOOL ESPInstalled()
+{
+    HLINEAPP        hLineApp;
+    LINEDEVCAPS *   pLDC;
+    DWORD           dwDeviceID, dwCount;
+    LPTSTR          lpszName;
+    int             i;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (lineInitialize(&hLineApp,
+                          ghInstance,
+                          LineCallbackFunc,
+                          SZAPPNAME,
+                          &dwDeviceID) == 0)
+        {
+            for (dwCount = 0; dwCount < dwDeviceID; dwCount ++)
+            {
+                if (ESPLine(hLineApp,
+                            dwCount))
+                {
+                    return TRUE;
+                }
+            }
+
+            lineShutdown(hLineApp);
+            
+            Sleep(5000);
+        }
+    }
+    return FALSE;
+}
+
+            
+BOOL ESPLine(HLINEAPP hLineApp,
+             DWORD    dwDeviceID)
+{
+    LINEDEVCAPS *       pLDC;
+    LPTSTR               lpszName;
+    
+    pLDC = LineGetDevCaps(hLineApp,
+                          dwDeviceID);
+
+    if (!pLDC)
+    {
+        return FALSE;
+    }
+
+    lpszName = (LPTSTR) ( ( (LPBYTE)pLDC ) + pLDC->dwProviderInfoOffset);
+
+    if (!lstrcmpi(lpszName,
+                  SZPROVIDERINFO))
+    {
+        LocalFree(pLDC);
+        return TRUE;
+    }
+
+    LocalFree(pLDC);
+    return FALSE;
+    
+}
+
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID)
+{
+    LONG           lRetVal;
+    LINEDEVCAPS  * pLineDevCaps;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVCAPS);
+
+    pLineDevCaps = (LINEDEVCAPS *)LocalAlloc(LPTR, dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineDevCaps->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetDevCaps(hLineApp,
+                                 dwDeviceID,
+                                 TAPI_VERSION,
+                                 0,
+                                 pLineDevCaps);
+        if (lRetVal < 0)
+        {
+            LocalFree((HLOCAL)pLineDevCaps);
+            return NULL;
+        }
+        if (pLineDevCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevCaps->dwNeededSize;
+            pLineDevCaps = (LINEDEVCAPS *)LocalReAlloc((HLOCAL)pLineDevCaps,
+                                        dwMaxNeededSize,
+                                        LMEM_MOVEABLE);
+        }
+    }
+}
+
+LINEDEVSTATUS * LineGetLineDevStatus (HLINE hLine)
+{
+    LONG           lRetVal;
+    LINEDEVSTATUS* pLineDevStatus;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVSTATUS);
+
+    pLineDevStatus = (LINEDEVSTATUS *)LocalAlloc(LPTR, dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevStatus == NULL)
+        {
+            return NULL;
+        }
+        pLineDevStatus->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetLineDevStatus(hLine,
+                                       pLineDevStatus);
+        
+        if ((lRetVal != LINEERR_STRUCTURETOOSMALL) && (lRetVal < 0))
+        {
+            LocalFree((HLOCAL)pLineDevStatus);
+            return NULL;
+        }
+        
+        if (pLineDevStatus->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevStatus;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevStatus->dwNeededSize;
+            pLineDevStatus = (LINEDEVSTATUS *)LocalReAlloc((HLOCAL)pLineDevStatus,
+                dwMaxNeededSize,
+                LMEM_MOVEABLE);
+        }
+    }
+}
+
+#define ISDIGIT(c) ( ( (c) >= '0') && ( (c) <= '9') )
+
+DWORD MyTToL(LPTSTR lpszBuf)
+{
+    DWORD   dwReturn = 0;
+
+    while (*lpszBuf && ISDIGIT(*lpszBuf))
+    {
+        dwReturn = dwReturn*10 + (*lpszBuf - '0');
+        lpszBuf++;
+    }
+
+    return dwReturn;
+}
+
+DWORD MyRand()
+{
+    static DWORD RandSeed = GetTickCount();
+
+    RandSeed = (RandSeed*BCONST+1) % MAX_SHORT;
+
+    return RandSeed;
+}
+
+void MyIToT(int i, TCHAR * szBuf)
+{
+    wsprintf(szBuf, TEXT("%d"), i);
+
+    return;
+}
+
+TCHAR MyToTLower(TCHAR tc)
+{
+    if ((tc <= 'z') && (tc >= 'a'))
+        return tc;
+
+    return tc-'A'+'a';
+}
diff --git a/private/tapi/dev/apps/rstress/clntapp/clntapp.h b/private/tapi/dev/apps/rstress/clntapp/clntapp.h
new file mode 100644
index 000000000..9613265ab
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/clntapp/clntapp.h
@@ -0,0 +1,80 @@
+#include <windows.h>
+#include <tapi.h>
+
+#define TAPI_VERSION    0x00010004
+#define NUMLINES        10
+#define NUMINITS        10
+#define SZAPPNAME       "TapiClientApp"
+#define SLEEPTIME       2000
+#define NUMTHREADS      20
+#define THREADSLEEP     15000           // up to 15 seconds
+#define GLOBALTIMEOUT   10000           // 10 seconds
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+static LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                                     UINT   uMsg,
+                                     WPARAM wParam,
+                                     LPARAM lParam);
+
+BOOL SetupEnvironment (int argc, char * argv[], char * szFileName);
+
+void CALLBACK LineCallbackFunc(DWORD dwDevice, 
+                               DWORD dwMsg, 
+                               DWORD dwCallbackInstance, 
+                               DWORD dwParam1, 
+                               DWORD dwParam2, 
+                               DWORD dwParam3);
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3);
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3);
+void HandleLineCallInfo(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3);
+void HandleLineClose(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+LONG Scenario1(LPVOID lpv);
+LONG Scenario2(LPVOID lpv);
+LONG Scenario3(LPVOID lpv);
+LONG Scenario4(LPVOID lpv);
+LONG StartThreads(DWORD dwHold);
+
+typedef struct _ReplyStruct
+{
+    HCALL *                 phCall;
+    DWORD                   dwReplyID;
+    BOOL                    bSignaled;
+    BOOL                    bConnected;
+    BOOL                    bError;
+    DWORD                   dwID;
+    struct _ReplyStruct *   pNext;
+} ReplyStruct;
+
+void InitReplyStruct();
+DWORD AddReplyStruct();
+void DeleteReplyStruct(DWORD dwID);
+void SignalReply(DWORD dwReplyID, DWORD);
+void SetReplyID(DWORD dwID, DWORD dwReplyID);
+void SetCallHandle(DWORD dwID, HCALL * phCall);
+void SignalConnected(HCALL hCall);
+void SignalDisconnected(HCALL hCall, BOOL);
+BOOL GetSignaled(DWORD dwID);
+BOOL GetConnected(DWORD dwID);
+BOOL GetError(DWORD dwID);
+void ClearError(DWORD dwID);
+void SignalError(HCALL hCall);
+
+BOOL InitLogging();
+void CloseLogging();
+TCHAR * FormatTime(LONG dwTime);
+void LogTapiError(LPTSTR lpszFunction, LONG lResult, DWORD dwProcessID, DWORD dwThreadID);
diff --git a/private/tapi/dev/apps/rstress/clntapp/logging.cpp b/private/tapi/dev/apps/rstress/clntapp/logging.cpp
new file mode 100644
index 000000000..2a116e441
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/clntapp/logging.cpp
@@ -0,0 +1,210 @@
+#include "clntapp.h"
+
+HANDLE              hLogFile;
+extern TCHAR        szFileName[MAX_PATH];
+CRITICAL_SECTION    csFile;
+extern BOOL         gbLogging;
+
+LPTSTR lpszLineErrs[] =
+{
+   TEXT("SUCCESS"),
+   TEXT("ALLOCATED"),
+   TEXT("BADDEVICEID"),
+   TEXT("BEARERMODEUNAVAIL"),
+   TEXT("inval err code (0x80000004)"),      // 0x80000004 isn't valid err code
+   TEXT("CALLUNAVAIL"),
+   TEXT("COMPLETIONOVERRUN"),
+   TEXT("CONFERENCEFULL"),
+   TEXT("DIALBILLING"),
+   TEXT("DIALDIALTONE"),
+   TEXT("DIALPROMPT"),
+   TEXT("DIALQUIET"),
+   TEXT("INCOMPATIBLEAPIVERSION"),
+   TEXT("INCOMPATIBLEEXTVERSION"),
+   TEXT("INIFILECORRUPT"),
+   TEXT("INUSE"),
+   TEXT("INVALADDRESS"),                     // 0x80000010
+   TEXT("INVALADDRESSID"),
+   TEXT("INVALADDRESSMODE"),
+   TEXT("INVALADDRESSSTATE"),
+   TEXT("INVALAPPHANDLE"),
+   TEXT("INVALAPPNAME"),
+   TEXT("INVALBEARERMODE"),
+   TEXT("INVALCALLCOMPLMODE"),
+   TEXT("INVALCALLHANDLE"),
+   TEXT("INVALCALLPARAMS"),
+   TEXT("INVALCALLPRIVILEGE"),
+   TEXT("INVALCALLSELECT"),
+   TEXT("INVALCALLSTATE"),
+   TEXT("INVALCALLSTATELIST"),
+   TEXT("INVALCARD"),
+   TEXT("INVALCOMPLETIONID"),
+   TEXT("INVALCONFCALLHANDLE"),              // 0x80000020
+   TEXT("INVALCONSULTCALLHANDLE"),
+   TEXT("INVALCOUNTRYCODE"),
+   TEXT("INVALDEVICECLASS"),
+   TEXT("INVALDEVICEHANDLE"),
+   TEXT("INVALDIALPARAMS"),
+   TEXT("INVALDIGITLIST"),
+   TEXT("INVALDIGITMODE"),
+   TEXT("INVALDIGITS"),
+   TEXT("INVALEXTVERSION"),
+   TEXT("INVALGROUPID"),
+   TEXT("INVALLINEHANDLE"),
+   TEXT("INVALLINESTATE"),
+   TEXT("INVALLOCATION"),
+   TEXT("INVALMEDIALIST"),
+   TEXT("INVALMEDIAMODE"),
+   TEXT("INVALMESSAGEID"),                   // 0x80000030
+   TEXT("inval err code (0x80000031)"),      // 0x80000031 isn't valid err code
+   TEXT("INVALPARAM"),
+   TEXT("INVALPARKID"),
+   TEXT("INVALPARKMODE"),
+   TEXT("INVALPOINTER"),
+   TEXT("INVALPRIVSELECT"),
+   TEXT("INVALRATE"),
+   TEXT("INVALREQUESTMODE"),
+   TEXT("INVALTERMINALID"),
+   TEXT("INVALTERMINALMODE"),
+   TEXT("INVALTIMEOUT"),
+   TEXT("INVALTONE"),
+   TEXT("INVALTONELIST"),
+   TEXT("INVALTONEMODE"),
+   TEXT("INVALTRANSFERMODE"),
+   TEXT("LINEMAPPERFAILED"),                 // 0x80000040
+   TEXT("NOCONFERENCE"),
+   TEXT("NODEVICE"),
+   TEXT("NODRIVER"),
+   TEXT("NOMEM"),
+   TEXT("NOREQUEST"),
+   TEXT("NOTOWNER"),
+   TEXT("NOTREGISTERED"),
+   TEXT("OPERATIONFAILED"),
+   TEXT("OPERATIONUNAVAIL"),
+   TEXT("RATEUNAVAIL"),
+   TEXT("RESOURCEUNAVAIL"),
+   TEXT("REQUESTOVERRUN"),
+   TEXT("STRUCTURETOOSMALL"),
+   TEXT("TARGETNOTFOUND"),
+   TEXT("TARGETSELF"),
+   TEXT("UNINITIALIZED"),                    // 0x80000050
+   TEXT("USERUSERINFOTOOBIG"),
+   TEXT("REINIT"),
+   TEXT("ADDRESSBLOCKED"),
+   TEXT("BILLINGREJECTED"),
+   TEXT("INVALFEATURE"),
+   TEXT("NOMULTIPLEINSTANCE")
+};
+   
+BOOL InitLogging()
+{
+    LONG        dwTime;
+    DWORD       dwLen;
+
+    if (!gbLogging)
+            return TRUE;
+    
+    InitializeCriticalSection(&csFile);
+
+    EnterCriticalSection(&csFile);
+
+    hLogFile = CreateFile(szFileName,
+                          GENERIC_WRITE,
+                          0,
+                          NULL,
+                          OPEN_ALWAYS,
+                          FILE_ATTRIBUTE_NORMAL,
+                          NULL);
+
+    CloseHandle(hLogFile);
+
+    LeaveCriticalSection(&csFile);
+
+    return TRUE;
+}
+
+void LogTapiError(LPTSTR lpszFunction, LONG lResult, DWORD dwProcessID, DWORD dwThreadID)
+{
+    TCHAR       szBuffer[512];
+    DWORD       dwBytes;
+    char        szCharBuffer[512];
+    DWORD       dwerror;
+    SYSTEMTIME  st;
+
+    if (!gbLogging)
+        return ;
+    
+    EnterCriticalSection(&csFile);
+    
+    if (hLogFile == 0)
+    {
+        LeaveCriticalSection(&csFile);
+        return;
+    }
+
+    GetSystemTime(&st);
+
+    wsprintf(szBuffer,
+             TEXT("%02d:%02d:%02d:%04d: PROCESS:%lu THREAD:%lu %s FAILED with %s\r\n"),
+             st.wHour,
+             st.wMinute,
+             st.wSecond,
+             st.wMilliseconds,
+             dwProcessID,
+             dwThreadID,
+             lpszFunction,
+             lpszLineErrs[LOWORD(lResult)]);
+
+    WideCharToMultiByte(CP_ACP,
+                        0,
+                        szBuffer,
+                        -1,
+                        szCharBuffer,
+                        512,
+                        NULL,
+                        NULL);
+        
+    while (TRUE)
+    {
+        // wait until file is available
+        hLogFile = CreateFile(szFileName,
+                              GENERIC_WRITE,
+                              0,
+                              NULL,
+                              OPEN_EXISTING,
+                              FILE_ATTRIBUTE_NORMAL,
+                              NULL);
+
+        if (hLogFile == INVALID_HANDLE_VALUE)
+        {
+            Sleep(1000);
+            continue;
+        }
+
+        break;
+    }
+
+    
+    SetFilePointer(hLogFile,
+                   0,
+                   NULL,
+                   FILE_END);
+
+    WriteFile(hLogFile,
+              szCharBuffer,
+              lstrlenA(szCharBuffer),
+              &dwBytes,
+              NULL);
+
+    CloseHandle(hLogFile);
+
+    LeaveCriticalSection(&csFile);
+    
+}
+
+void CloseLogging()
+{
+
+//    CloseHandle(hLogFile);
+}
+
diff --git a/private/tapi/dev/apps/rstress/clntapp/makefile b/private/tapi/dev/apps/rstress/clntapp/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/clntapp/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/rstress/clntapp/sources b/private/tapi/dev/apps/rstress/clntapp/sources
new file mode 100644
index 000000000..0952d7472
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/clntapp/sources
@@ -0,0 +1,56 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=clntapp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32l.lib 
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+#USE_NOLIBS=1
+USE_CRTDLL=1
+
+SOURCES=clntapp.cpp \
+        logging.cpp
+
+C_DEFINES=-DWINVER=0x0400 -DUNICODE -DREALLY_USE_UNICODE -DTAPI_CURRENT_VERSION=0x00010004
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/rstress/dirs b/private/tapi/dev/apps/rstress/dirs
new file mode 100644
index 000000000..047f7d933
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/dirs
@@ -0,0 +1,4 @@
+DIRS=\
+	 client   \
+     clntapp  \
+     srvapp
diff --git a/private/tapi/dev/apps/rstress/extrastr.bat b/private/tapi/dev/apps/rstress/extrastr.bat
new file mode 100644
index 000000000..0dbbff64f
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/extrastr.bat
@@ -0,0 +1,22 @@
+@ECHO OFF
+
+IF "%PROCESSOR_ARCHITECTURE%" == ""     GOTO DEFAULT
+
+
+COPY \\TAPISTRESS\STRESS\%PROCESSOR_ARCHITECTURE%\*.* %windir%\SYSTEM32
+GOTO START
+
+
+
+:DEFAULT
+ECHO NO PLATFORM SPECIFIED -- USING I386
+COPY \\TAPISTRESS\STRESS\x86\*.* %windir%\SYSTEM32
+GOTO START
+
+
+:START
+START SRVAPP /E:50 /F:\\TAPISTRESS\SERVERLOGS /G
+START TCLIENT /A:3 /T:15 /S:0 /H:0 /F:\\TAPISTRESS\CLIENTLOGS
+
+:END
+
diff --git a/private/tapi/dev/apps/rstress/perfctr.h b/private/tapi/dev/apps/rstress/perfctr.h
new file mode 100644
index 000000000..9308e5329
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/perfctr.h
@@ -0,0 +1,22 @@
+//
+//  Offset definition file for extensible counter objects and counters
+//
+//  These "relative" offsets must start at 0 and be multiples of 2 (i.e.
+//  even numbers). In the Open Procedure, they will be added to the 
+//  "First Counter" and "First Help" values for the device they belong to, 
+//  in order to determine the absolute location of the counter and 
+//  object names and corresponding Explain text in the registry.
+//
+//  This file is used by the extensible counter DLL code as well as the 
+//  counter name and Explain text definition file (.INI) file that is used
+//  by LODCTR to load the names into the registry.
+//
+#define TAPIOBJ                 0
+#define NUMLINES                2
+#define CURRENTOPENS            4
+#define TOTALOUTGOINGCALLS      6
+#define TOTALINCOMINGCALLS      8
+
+
+  
+  
diff --git a/private/tapi/dev/apps/rstress/regini.ini b/private/tapi/dev/apps/rstress/regini.ini
new file mode 100644
index 000000000..a175fbf53
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/regini.ini
@@ -0,0 +1,8 @@
+\registry\machine\SYSTEM\CurrentControlSet\Services
+\registry\machine\SYSTEM\CurrentControlSet\Services\TapiSrv
+\registry\machine\SYSTEM\CurrentControlSet\Services\TapiSrv\Performance
+    Library = REG_SZ TAPI32.DLL
+    Open = REG_SZ OpenTapiPerformanceData
+    Collect = REG_SZ CollectTapiPerformanceData
+    Close = REG_SZ CloseTapiPerformanceData
+
\ No newline at end of file
diff --git a/private/tapi/dev/apps/rstress/srvapp/logging.cpp b/private/tapi/dev/apps/rstress/srvapp/logging.cpp
new file mode 100644
index 000000000..ad4df9642
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/srvapp/logging.cpp
@@ -0,0 +1,390 @@
+#include "srvapp.h"
+
+HANDLE  hLogFile;
+extern BOOL gbLogging;
+
+LPSTR lpszLineErrs[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "BEARERMODEUNAVAIL",
+    "inval err code (0x80000004)",      // 0x80000004 isn't valid err code
+    "CALLUNAVAIL",
+    "COMPLETIONOVERRUN",
+    "CONFERENCEFULL",
+    "DIALBILLING",
+    "DIALDIALTONE",
+    "DIALPROMPT",
+    "DIALQUIET",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALADDRESS",                     // 0x80000010
+    "INVALADDRESSID",
+    "INVALADDRESSMODE",
+    "INVALADDRESSSTATE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBEARERMODE",
+    "INVALCALLCOMPLMODE",
+    "INVALCALLHANDLE",
+    "INVALCALLPARAMS",
+    "INVALCALLPRIVILEGE",
+    "INVALCALLSELECT",
+    "INVALCALLSTATE",
+    "INVALCALLSTATELIST",
+    "INVALCARD",
+    "INVALCOMPLETIONID",
+    "INVALCONFCALLHANDLE",              // 0x80000020
+    "INVALCONSULTCALLHANDLE",
+    "INVALCOUNTRYCODE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEHANDLE",
+    "INVALDIALPARAMS",
+    "INVALDIGITLIST",
+    "INVALDIGITMODE",
+    "INVALDIGITS",
+    "INVALEXTVERSION",
+    "INVALGROUPID",
+    "INVALLINEHANDLE",
+    "INVALLINESTATE",
+    "INVALLOCATION",
+    "INVALMEDIALIST",
+    "INVALMEDIAMODE",
+    "INVALMESSAGEID",                   // 0x80000030
+    "inval err code (0x80000031)",      // 0x80000031 isn't valid err code
+    "INVALPARAM",
+    "INVALPARKID",
+    "INVALPARKMODE",
+    "INVALPOINTER",
+    "INVALPRIVSELECT",
+    "INVALRATE",
+    "INVALREQUESTMODE",
+    "INVALTERMINALID",
+    "INVALTERMINALMODE",
+    "INVALTIMEOUT",
+    "INVALTONE",
+    "INVALTONELIST",
+    "INVALTONEMODE",
+    "INVALTRANSFERMODE",
+    "LINEMAPPERFAILED",                 // 0x80000040
+    "NOCONFERENCE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOREQUEST",
+    "NOTOWNER",
+    "NOTREGISTERED",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "RATEUNAVAIL",
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",
+    "STRUCTURETOOSMALL",
+    "TARGETNOTFOUND",
+    "TARGETSELF",
+    "UNINITIALIZED",                    // 0x80000050
+    "USERUSERINFOTOOBIG",
+    "REINIT",
+    "ADDRESSBLOCKED",
+    "BILLINGREJECTED",
+    "INVALFEATURE",
+    "NOMULTIPLEINSTANCE"
+};
+
+BOOL InitLogging(LPSTR lpszFileDirectory)
+{
+    LPSTR       lpszFileNameBuffer, lpszBuffer, lpszComputerNameBuffer;
+    SYSTEMTIME  st;
+	DWORD		dwSize;
+	HANDLE		hUserFile;
+#ifdef ENHANCE_LOG
+   SYSTEM_INFO SysInfo;
+   char lpszArchitecture[8];
+#endif
+	
+
+    if (!gbLogging)
+        return TRUE;
+
+    lpszFileNameBuffer = (LPSTR) LocalAlloc(LPTR, MAX_PATH+1);
+
+    GetSystemTime(&st);
+    wsprintf(lpszFileNameBuffer,
+             "%s%s%02d%02d%02d",
+             lpszFileDirectory,
+             "\\TAPISTRESSSRV_",
+             st.wHour,
+             st.wMinute,
+             st.wSecond);
+
+    hLogFile = CreateFile(lpszFileNameBuffer,
+                          GENERIC_WRITE,
+                          FILE_SHARE_READ,
+                          NULL,
+                          CREATE_ALWAYS,
+                          FILE_ATTRIBUTE_NORMAL,
+                          NULL);
+
+    if (hLogFile == INVALID_HANDLE_VALUE)
+    {
+        hLogFile = 0;
+        LocalFree(lpszFileNameBuffer);
+        return FALSE;
+    }
+
+    wsprintf(lpszFileNameBuffer, "%s\\users.txt", lpszFileDirectory);
+
+    hUserFile = CreateFile(lpszFileNameBuffer,
+                           GENERIC_WRITE,
+                           FILE_SHARE_READ,
+                           NULL,
+                           OPEN_ALWAYS,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL);
+
+    if (hUserFile == INVALID_HANDLE_VALUE)
+    {
+          return FALSE;
+    }
+
+	lpszBuffer = (LPSTR)GlobalAlloc(GPTR, 1024);
+	lpszComputerNameBuffer = (LPSTR)GlobalAlloc(GPTR, 1024);
+
+
+    SetFilePointer(hUserFile,
+                   0,
+                   NULL,
+                   FILE_END);
+
+    dwSize = MAX_PATH;
+
+    GetUserName(lpszFileNameBuffer,
+                &dwSize);
+
+	dwSize = MAX_PATH;
+	
+	GetComputerName(lpszComputerNameBuffer,
+					&dwSize);
+
+#ifdef ENHANCE_LOG
+   GetSystemInfo(&SysInfo);
+
+   switch (SysInfo.wProcessorArchitecture) {
+      case PROCESSOR_ARCHITECTURE_INTEL :
+            wsprintf(lpszArchitecture, "INTEL  ");
+            break;
+      case PROCESSOR_ARCHITECTURE_ALPHA :
+            wsprintf(lpszArchitecture, "ALPHA  ");
+            break;
+      case PROCESSOR_ARCHITECTURE_MIPS :
+            wsprintf(lpszArchitecture, "MIPS   ");
+            break;
+      case PROCESSOR_ARCHITECTURE_PPC :
+            wsprintf(lpszArchitecture, "PPC    ");
+            break;
+      case PROCESSOR_ARCHITECTURE_UNKNOWN :
+            wsprintf(lpszArchitecture, "UNKNOWN");
+            break;
+   }
+
+   wsprintf(lpszBuffer,
+			 "LOGON  %15s from %15s(%s) at %02d:%02d:%02d %02d-%02d-%02d\n\r",
+			 lpszFileNameBuffer,
+			 lpszComputerNameBuffer,
+          lpszArchitecture,
+			 st.wHour,
+			 st.wMinute,
+			 st.wSecond,
+			 st.wMonth,
+			 st.wDay,
+			 st.wYear);
+
+#else // !ENHANCE_LOG
+
+	wsprintf(lpszBuffer,
+			 "NAME: %s COMPUTER: %s TIME: %02d%02d%02d DATE: %02d%02d%02d\n\r",
+			 lpszFileNameBuffer,
+			 lpszComputerNameBuffer,
+			 st.wHour,
+			 st.wMinute,
+			 st.wSecond,
+			 st.wMonth,
+			 st.wDay,
+			 st.wYear);
+#endif // !ENHANCE_LOG
+	
+    WriteFile(hUserFile,
+              lpszBuffer,
+              lstrlen(lpszBuffer),
+              &dwSize,
+              NULL);
+
+    CloseHandle(hUserFile);
+
+    LocalFree(lpszFileNameBuffer);
+	GlobalFree(lpszBuffer);
+	GlobalFree(lpszComputerNameBuffer);
+
+    return TRUE;
+}
+
+void LogTapiError(LPSTR lpszFunction, LONG lResult)
+{
+    char        szBuffer[256];
+    DWORD       dwBytes;
+    SYSTEMTIME  st;
+
+    if (!gbLogging)
+        return;
+
+    if (hLogFile == 0)
+        return;
+
+    GetSystemTime(&st);
+
+    wsprintf(szBuffer,
+             "%02d:%02d:%02d:%04d:\t%s FAILED with %s\r\n",
+             st.wHour,
+             st.wMinute,
+             st.wSecond,
+             st.wMilliseconds,
+             lpszFunction,
+             lpszLineErrs[LOWORD(lResult)]);
+
+    WriteFile(hLogFile,
+              szBuffer,
+              strlen(szBuffer),
+              &dwBytes,
+              NULL);
+
+}
+
+void CloseLogging(LPSTR lpszFileDirectory, LONG lLineReplies)
+{
+    char    szBuffer[64];
+    DWORD   dwBytes, dwSize;
+	LPSTR	lpszComputerNameBuffer, lpszNameBuffer, lpszBuffer;
+	SYSTEMTIME	st;
+	HANDLE		hUserFile;
+	
+	lpszComputerNameBuffer = (LPSTR)GlobalAlloc(GPTR, MAX_PATH);
+	lpszNameBuffer = (LPSTR)GlobalAlloc(GPTR, MAX_PATH);
+	lpszBuffer = (LPSTR)GlobalAlloc(GPTR, 1024);
+	
+
+    wsprintf(lpszNameBuffer, "%s\\users.txt", lpszFileDirectory);
+	
+	hUserFile = CreateFile(lpszNameBuffer,
+                           GENERIC_WRITE,
+                           FILE_SHARE_READ,
+                           NULL,
+                           OPEN_ALWAYS,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL);
+
+    if (hUserFile == INVALID_HANDLE_VALUE)
+    {
+		goto close_real_log;
+    }
+
+    SetFilePointer(hUserFile,
+                   0,
+                   NULL,
+                   FILE_END);
+
+    dwSize = MAX_PATH;
+
+    GetUserName(lpszNameBuffer,
+                &dwSize);
+
+	dwSize = MAX_PATH;
+	
+	GetComputerName(lpszComputerNameBuffer,
+					&dwSize);
+
+	GetSystemTime(&st);
+
+#ifdef ENHANCE_LOG
+   {
+      SYSTEM_INFO SysInfo;
+      char lpszArchitecture[8];
+
+      GetSystemInfo(&SysInfo);
+
+      switch (SysInfo.wProcessorArchitecture) {
+      case PROCESSOR_ARCHITECTURE_INTEL :
+            wsprintf(lpszArchitecture, "INTEL  ");
+            break;
+      case PROCESSOR_ARCHITECTURE_ALPHA :
+            wsprintf(lpszArchitecture, "ALPHA  ");
+            break;
+      case PROCESSOR_ARCHITECTURE_MIPS :
+            wsprintf(lpszArchitecture, "MIPS   ");
+            break;
+      case PROCESSOR_ARCHITECTURE_PPC :
+            wsprintf(lpszArchitecture, "PPC    ");
+            break;
+      case PROCESSOR_ARCHITECTURE_UNKNOWN :
+            wsprintf(lpszArchitecture, "UNKNOWN");
+            break;
+      }
+
+      wsprintf(lpszBuffer,
+			 "LOGOFF %15s from %15s(%s) at %02d:%02d:%02d %02d-%02d-%02d\n\r",
+			 lpszNameBuffer,
+			 lpszComputerNameBuffer,
+          lpszArchitecture,
+			 st.wHour,
+			 st.wMinute,
+			 st.wSecond,
+			 st.wMonth,
+			 st.wDay,
+			 st.wYear);
+   }
+#else // !ENHANCE_LOG
+	wsprintf(lpszBuffer,
+			 "LOGOFF: NAME: %s COMPUTER: %s TIME: %02d%02d%02d DATE: %02d%02d%02d\n\r",
+			 lpszNameBuffer,
+			 lpszComputerNameBuffer,
+			 st.wHour,
+			 st.wMinute,
+			 st.wSecond,
+			 st.wMonth,
+			 st.wDay,
+			 st.wYear);
+#endif // !ENHANCE_LOG
+	
+    WriteFile(hUserFile,
+              lpszBuffer,
+              lstrlen(lpszBuffer),
+              &dwSize,
+              NULL);
+
+    CloseHandle(hUserFile);
+
+close_real_log:
+	
+	GlobalFree(lpszComputerNameBuffer);
+	GlobalFree(lpszNameBuffer);
+	GlobalFree(lpszBuffer);
+
+
+    if (!gbLogging)
+        return;
+
+    wsprintf(szBuffer, "LEFT OVER LINE REPLIES %lu\r\n", lLineReplies);
+
+    WriteFile(hLogFile,
+              szBuffer,
+              strlen(szBuffer),
+              &dwBytes,
+              NULL);
+
+    CloseHandle(hLogFile);
+
+}
+
+
diff --git a/private/tapi/dev/apps/rstress/srvapp/makefile b/private/tapi/dev/apps/rstress/srvapp/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/srvapp/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/rstress/srvapp/sources b/private/tapi/dev/apps/rstress/srvapp/sources
new file mode 100644
index 000000000..0a8551efa
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/srvapp/sources
@@ -0,0 +1,56 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=srvapp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32l.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+#USE_NOLIBS=1
+USE_CRTDLL=1
+
+SOURCES=srvapp.cpp \
+        logging.cpp
+
+C_DEFINES=-DWINVER=0x0400
+
+UMTYPE=console
+
+UMENTRY=main
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/rstress/srvapp/srvapp.cpp b/private/tapi/dev/apps/rstress/srvapp/srvapp.cpp
new file mode 100644
index 000000000..06bb5acb7
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/srvapp/srvapp.cpp
@@ -0,0 +1,764 @@
+#include "srvapp.h"
+
+HANDLE      ghCompletionPort;
+HINSTANCE   ghInstance;
+LONG        lLineReplies;
+HLINE*      gphLine;
+DWORD       dwNumDevs;
+HLINEAPP    ghLineApp;
+DWORD       dwESPLines = 10;
+char        szFileDir[MAX_PATH + 1];
+char        szClientFileName[MAX_PATH+1];
+char        szClientFileDirectory[MAX_PATH+1];
+BOOL        bInstalledESP = FALSE;
+DWORD       dwID;
+BOOL        gbLogging = FALSE;
+
+LONG ThreadRoutine(LPVOID);
+void WriteESPDefaults();
+BOOL InitializeVariables(LPTSTR lpszCommnandLine);
+LINEDEVCAPS * LineGetDevCaps (HLINEAPP hLineApp,
+                              DWORD    dwDeviceID);
+BOOL InstallESP();
+void RemoveESP();
+LONG DismissInstallDlg(LPVOID);
+DWORD MyTToL(LPTSTR lpszBuf);
+TCHAR MyToTLower(TCHAR tc);
+void CreateClientFileName();
+
+//int __cdecl mainCRTStartup()
+int __cdecl main()
+{
+    DWORD                       dwAPIVersion, dwHold, dwThreadID;
+    LONG                        lResult;
+    LINEINITIALIZEEXPARAMS      exparams;
+    HANDLE                      hEvent;
+
+    lLineReplies = 0;
+
+    GetWindowsDirectory(szFileDir,
+                        MAX_PATH);
+
+    InitializeVariables(GetCommandLine());
+
+    if (!InitLogging(szFileDir))
+        return 0;
+
+    SetConsoleCtrlHandler((PHANDLER_ROUTINE) BreakHandlerRoutine, TRUE);	
+
+    WriteESPDefaults();
+
+    InstallESP();
+
+    ghCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,
+                                              NULL,
+                                              0,
+                                              0);
+
+    ghInstance = GetModuleHandle(NULL);
+    exparams.dwTotalSize = sizeof(LINEINITIALIZEEXPARAMS);
+    exparams.dwOptions   = LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    exparams.Handles.hCompletionPort = ghCompletionPort;
+
+    dwAPIVersion = TAPI2_0_VERSION;
+
+    lResult = lineInitializeEx(&ghLineApp,
+                               ghInstance,
+                               LineCallbackFunc,
+                               SZAPPNAME,
+                               &dwNumDevs,
+                               &dwAPIVersion,
+                               &exparams);
+
+    if (lResult < 0)
+    {
+        LogTapiError("lineInitializeEx", lResult);
+        return 0;
+    }
+
+    gphLine = (HLINE*)GlobalAlloc(GPTR, sizeof(HLINE) * dwNumDevs);
+
+    for (dwHold = 0; dwHold < dwNumDevs; dwHold++)
+    {
+        lResult = lineOpen(ghLineApp,
+                           dwHold,
+                           &gphLine[dwHold],
+                           dwAPIVersion,
+                           0,
+                           0,
+                           LINECALLPRIVILEGE_OWNER,
+                           LINEMEDIAMODE_UNKNOWN |
+                           LINEMEDIAMODE_INTERACTIVEVOICE |
+                           LINEMEDIAMODE_AUTOMATEDVOICE |
+                           LINEMEDIAMODE_DATAMODEM |
+                           LINEMEDIAMODE_G3FAX |
+                           LINEMEDIAMODE_TDD |
+                           LINEMEDIAMODE_G4FAX |
+                           LINEMEDIAMODE_DIGITALDATA |
+                           LINEMEDIAMODE_TELETEX |
+                           LINEMEDIAMODE_VIDEOTEX |
+                           LINEMEDIAMODE_TELEX |
+                           LINEMEDIAMODE_MIXED |
+                           LINEMEDIAMODE_ADSI |
+                           LINEMEDIAMODE_VOICEVIEW,
+                           NULL);
+
+        if (lResult < 0)
+        {
+            char            szBuffer[64];
+
+            wsprintf(szBuffer, "lineOpen DEVICE # %lu", dwHold);
+            LogTapiError(szBuffer, lResult);
+        }
+    }
+
+    CreateThread(NULL,
+                 0,
+                 (LPTHREAD_START_ROUTINE)ThreadRoutine,
+                 NULL,
+                 0,
+                 &dwThreadID);
+
+    hEvent = CreateEvent(NULL,
+                         TRUE,
+                         FALSE,
+                         NULL);
+
+    WaitForSingleObject(hEvent,
+                        INFINITE);
+
+    return 1;
+
+}
+
+LONG ThreadRoutine(LPVOID lpv)
+{
+    LPLINEMESSAGE       pMsg;
+    DWORD               dwNumBytesTransfered, dwCompletionKey;
+
+    while (GetQueuedCompletionStatus(ghCompletionPort,
+                                     &dwNumBytesTransfered,
+                                     &dwCompletionKey,
+                                     (LPOVERLAPPED *) &pMsg,
+                                     INFINITE))
+    {
+        if (pMsg)
+        {
+            LineCallbackFunc(pMsg->hDevice,
+                             pMsg->dwMessageID,
+                             pMsg->dwCallbackInstance,
+                             pMsg->dwParam1,
+                             pMsg->dwParam2,
+                             pMsg->dwParam3);
+
+            LocalFree (pMsg);
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    ExitThread(0);
+    return 0;
+}
+
+
+
+void CALLBACK LineCallbackFunc(DWORD dwDevice,
+                               DWORD dwMsg,
+                               DWORD dwCallbackInstance,
+                               DWORD dwParam1,
+                               DWORD dwParam2,
+                               DWORD dwParam3)
+{
+
+   switch(dwMsg)
+   {
+      case LINE_LINEDEVSTATE:
+          HandleLineDevState(dwParam1,
+                             dwParam2,
+                             dwParam3);
+          return;
+      case LINE_REPLY:
+          HandleLineReply(dwParam1,
+                          dwParam2,
+                          dwParam3);
+          return;
+      case LINE_CALLSTATE:
+          HandleLineCallState(dwDevice,
+                              dwParam1,
+                              dwParam2,
+                              dwParam3);
+          return;
+      case LINE_CALLINFO:
+          HandleLineCallInfo(dwParam1,
+                             dwParam2,
+                             dwParam3);
+          return;
+      case LINE_CLOSE:
+          HandleLineClose(dwParam1,
+                          dwParam2,
+                          dwParam3);
+          return;
+
+      default:
+          return;
+   }
+}
+
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3)
+{
+    return;
+}
+
+
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3)
+{
+    char        szBuffer[128];
+
+    lLineReplies--;
+
+    if ((LONG)dwParam2 != 0)
+    {
+        LogTapiError("LINE_REPLY", dwParam2);
+        wsprintf(szBuffer, "ID %lu", dwParam1);
+        LogTapiError(szBuffer, 0);
+    }
+    else
+    {
+//        LogTapiError("LINE_REPLY", dwParam2);
+//        wsprintf(szBuffer, "ID %lu", dwParam1);
+//        LogTapiError(szBuffer, 0);
+    }
+
+    return;
+}
+
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3)
+{
+    LONG        lResult;
+    char        szBuffer[128];
+
+    switch (dwParam1)
+    {
+    case LINECALLSTATE_OFFERING:
+
+/*        lResult = lineAccept((HCALL)dwDevice,
+                             NULL,
+                             0);
+
+        if (lResult <= 0)
+        {
+            LogTapiError("lineAccept", lResult);
+        }
+        else
+        {
+            lLineReplies++;
+            wsprintf(szBuffer, "lineAccept reply ID %lu", lResult);
+            LogTapiError(szBuffer, 0);
+        }
+
+*/
+        lResult = lineAnswer((HCALL)dwDevice,
+                             NULL,
+                             0);
+
+        if (lResult <= 0)
+        {
+            LogTapiError("lineAnswer", lResult);
+            wsprintf(szBuffer, "hcall %lx", dwDevice);
+            LogTapiError(szBuffer, 0);
+            lineDeallocateCall((HCALL)dwDevice);
+        }
+        else
+        {
+//            wsprintf(szBuffer, "lineAnswer reply ID %lu", lResult);
+//            LogTapiError(szBuffer, 0);
+            lLineReplies++;
+        }
+
+        break;
+
+    case LINECALLSTATE_CONNECTED:
+        break;
+
+    case LINECALLSTATE_DISCONNECTED:
+        lResult = lineDrop((HCALL)dwDevice,
+                           NULL,
+                           0);
+        if (lResult < 0)
+        {
+            LogTapiError("lineDrop", lResult);
+            wsprintf(szBuffer, "hcall %lx", dwDevice);
+            LogTapiError(szBuffer, 0);
+            lineDeallocateCall((HCALL)dwDevice);
+        }
+        else
+        {
+//            wsprintf(szBuffer, "lineDrop reply id %lu", lResult);
+//            LogTapiError(szBuffer, 0);
+            lLineReplies++;
+        }
+
+        break;
+
+    case LINECALLSTATE_IDLE:
+        lResult = lineDeallocateCall((HCALL)dwDevice);
+
+        if (lResult != 0)
+        {
+            LogTapiError("lineDeallocateCall", lResult);
+        }
+
+        break;
+
+    default:
+        break;
+    }
+}
+
+void HandleLineCallInfo(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3)
+{
+}
+
+void HandleLineClose(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3)
+{
+}
+
+BOOL BreakHandlerRoutine(DWORD dwCtrlType)
+{
+    DWORD       dwHold;
+    LONG        lResult;
+
+    for (dwHold = 0; dwHold < dwNumDevs; dwHold++)
+    {
+        lResult = lineClose(gphLine[dwHold]);
+
+        if (lResult < 0)
+        {
+            char            szBuffer[64];
+
+            wsprintf(szBuffer, "lineClose DEVICE # %lu", dwHold);
+            LogTapiError(szBuffer, lResult);
+        }
+    }
+
+    lineShutdown(ghLineApp);
+
+    GlobalFree(gphLine);
+
+    RemoveESP();
+
+    CloseLogging(szFileDir, lLineReplies);
+
+    ExitProcess(1);
+
+    return TRUE;
+}
+
+#define SZSECTION       "ESP32"
+#define SZNUMLINES      "NumLines"
+#define SZAUTOCLOSE     "AutoClose"
+#define SZDEBUGOUTPUT   "DebugOutput"
+#define SZDISABLEUI		"DisableUI"
+
+
+void WriteESPDefaults()
+{
+    char    szBuffer[32];
+
+    wsprintf(szBuffer, "%d", dwESPLines);
+
+    WriteProfileString(SZSECTION,
+                       SZNUMLINES,
+                       szBuffer);
+
+    WriteProfileString(SZSECTION,
+                       SZAUTOCLOSE,
+                       "1");
+
+    WriteProfileString(SZSECTION,
+                       SZDEBUGOUTPUT,
+                       "0");
+	WriteProfileString(SZSECTION,
+					   SZDISABLEUI,
+					   "1");
+
+}
+//////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+BOOL InitializeVariables(LPTSTR lpszCommandLine)
+{
+    int             i, j;
+    TCHAR           szBuff[64];
+    TCHAR           tFlag;
+
+    dwESPLines   = 10;
+
+    while (*lpszCommandLine && *lpszCommandLine != '/')
+    {
+        lpszCommandLine ++;
+    }
+
+    if (!*lpszCommandLine)
+    {
+        return TRUE;
+    }
+
+    while (*lpszCommandLine != NULL)
+    {
+        while((*lpszCommandLine == ' ') ||
+              (*lpszCommandLine == '/') ||
+              (*lpszCommandLine == '\t'))
+        {
+            lpszCommandLine++;
+        }
+
+        tFlag = *lpszCommandLine;
+
+        lpszCommandLine++;
+
+        if (*lpszCommandLine == ':')
+        {
+            lpszCommandLine++;
+        }
+
+        switch (MyToTLower(tFlag))
+        {
+            case 'f':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' ') )
+                {
+                    szFileDir[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+#ifdef ENHANCE_LOG
+//bug - no end of string
+                     szFileDir[i] = '\0';
+#endif
+                break;
+            }
+            case 'e':
+            {
+                i = 0;
+
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    szBuff[i] = *lpszCommandLine;
+                    lpszCommandLine++;
+                    i++;
+                }
+
+                szBuff[i] = 0;
+
+                dwESPLines = MyTToL(szBuff);
+                break;
+
+            }
+            case 'g':
+            {
+                while (*lpszCommandLine && (*lpszCommandLine != ' '))
+                {
+                    lpszCommandLine++;
+                }
+
+                gbLogging = TRUE;
+
+            }
+
+        }
+    }
+
+    return TRUE;
+}
+
+/////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+
+
+
+#define SZ_DLG_INSTALLTITLE "TUISPI_providerInstall"
+#define SZ_DLG_REMOVETITLE "TUISPI_providerRemove"
+#define TIMEOUT   3000
+#define SZPROVIDERINFO      "ESP v2.0"
+#define SZESPFILENAME  "esp32.tsp"
+
+LONG DismissInstallDlg(LPVOID lpv)
+{
+    Sleep(TIMEOUT);
+
+    HWND hwndChild = GetWindow (GetDesktopWindow(), GW_CHILD);
+
+
+    while (hwndChild)
+    {
+        char buf[32];
+
+
+        GetWindowText (hwndChild, buf, 31);
+
+        if (strcmp (buf, SZ_DLG_INSTALLTITLE) == 0)
+        {
+            break;
+        }
+
+        hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+    }
+
+    if (hwndChild)
+    {
+        //
+        // We found the right hwnd, so nuke the timer, post a
+        // <Esc> key msg to dismiss the dlg, & reset the global
+        // uiTimer to zero so we don't try to kill the timer again
+        //
+
+        PostMessage (hwndChild, WM_KEYDOWN, 0x0D, 0x00010001); // <Enter> key
+    }
+
+    return TRUE;
+}
+
+
+BOOL InstallESP()
+{
+    LONG            lResult;
+    HLINEAPP        hLineApp;
+    DWORD           dwNumDevs, dwThreadID;
+    int             i;
+    LINEDEVCAPS *   pLDC;
+    LPSTR           lpszName;
+
+    lResult = lineInitialize(&hLineApp,
+                             ghInstance,
+                             LineCallbackFunc,
+                             "",
+                             &dwNumDevs);
+
+    if (lResult < 0)
+    {
+//        MessageBox(ghMainWnd,
+//                   "Can't initialize TAPI",
+//                   NULL,
+//                   MB_OK);
+        return 0;
+    }
+
+    WriteESPDefaults();
+
+    // check for esp
+    for (i = 0; i < (LONG)dwNumDevs; i++)
+    {
+        pLDC = LineGetDevCaps(hLineApp,
+                              (DWORD)i);
+
+        if (!pLDC)
+            continue;
+
+        lpszName = (LPSTR)(((LPBYTE)pLDC)+pLDC->dwProviderInfoOffset);
+
+        if (!lstrcmpi(lpszName, SZPROVIDERINFO))
+        {
+            LocalFree(pLDC);
+            break;
+        }
+
+        LocalFree(pLDC);
+    }
+
+    // install esp
+
+    if ((DWORD)i == dwNumDevs)
+    {
+        CreateThread(NULL,
+                     0,
+                     (LPTHREAD_START_ROUTINE)DismissInstallDlg,
+                     NULL,
+                     0,
+                     &dwThreadID);
+
+        if (lineAddProvider(SZESPFILENAME,
+                            GetDesktopWindow(),
+                            &dwID) != 0)
+        {
+//            MessageBox(ghMainWnd,
+//                       "Can't initialize TAPI",
+//                       NULL,
+//                       MB_OK);
+            return 0;
+        }
+
+		bInstalledESP = TRUE;
+
+    }
+
+    lineShutdown(hLineApp);
+
+    return TRUE;
+}
+
+#define SZPROVIDERSKEY  "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Providers"
+#define SZNUMPROVIDERS  "NumProviders"
+#define SZNEXTPROVIDERID "NextProviderID"
+#define SZPROVIDERFILENAME "ProviderFilename"
+#define SZPROVIDERID    "ProviderID"
+
+void RemoveESP()
+{
+    DWORD           dwNumProviders, dwNextID, dwSize;
+    HKEY            hProvidersKey;
+    TCHAR           szbuf[64];
+
+
+    if (!bInstalledESP)
+        return;
+
+    // get tapi key
+    RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+                 SZPROVIDERSKEY,
+                 0,
+                 KEY_ALL_ACCESS,
+                 &hProvidersKey);
+
+    // get number of providers
+    dwSize = sizeof(DWORD);
+    RegQueryValueEx(hProvidersKey,
+                    SZNUMPROVIDERS,
+                    NULL,
+                    NULL,
+                    (LPBYTE)&dwNumProviders,
+                    &dwSize);
+
+    // decrement
+    dwNumProviders--;
+
+    // set num providers
+    RegSetValueEx(hProvidersKey,
+                  "NumProviders",
+                  0,
+                  REG_DWORD,
+                  (LPBYTE)&dwNumProviders,
+                  sizeof(DWORD));
+
+    // get NextProviderID
+    dwSize = sizeof(DWORD);
+    RegQueryValueEx(hProvidersKey,
+                    SZNEXTPROVIDERID,
+                    NULL,
+                    NULL,
+                    (LPBYTE)&dwNextID,
+                    &dwSize);
+
+    // decrement
+    dwNextID--;
+
+    // set NextProviderID
+    RegSetValueEx(hProvidersKey,
+                  SZNEXTPROVIDERID,
+                  0,
+                  REG_DWORD,
+                  (LPBYTE)&dwNextID,
+                  sizeof(DWORD));
+
+    // create ProviderFilename
+    wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, dwNumProviders);
+
+    // remove that value
+    RegDeleteValue(hProvidersKey,
+                   szbuf);
+
+    wsprintf(szbuf, "%s%d", SZPROVIDERID, dwNumProviders);
+
+    RegDeleteValue(hProvidersKey,
+                   szbuf);
+
+
+}
+
+//*****************************************************************************
+// LineGetDevCaps()
+//*****************************************************************************
+
+LINEDEVCAPS * LineGetDevCaps (
+        HLINEAPP hLineApp,
+        DWORD    dwDeviceID)
+{
+    LONG           lRetVal;
+    LINEDEVCAPS  * pLineDevCaps;
+    static DWORD   dwMaxNeededSize = sizeof(LINEDEVCAPS);
+
+    pLineDevCaps = (LINEDEVCAPS *)LocalAlloc(LPTR, dwMaxNeededSize);
+    for (;;)
+    {
+        if (pLineDevCaps == NULL)
+        {
+            return NULL;
+        }
+        pLineDevCaps->dwTotalSize = dwMaxNeededSize;
+        lRetVal = lineGetDevCaps(hLineApp,
+                                 dwDeviceID,
+                                 TAPI2_0_VERSION,
+                                 0,
+                                 pLineDevCaps);
+        if (lRetVal < 0)
+        {
+            LocalFree((HLOCAL)pLineDevCaps);
+            return NULL;
+        }
+        if (pLineDevCaps->dwNeededSize <= dwMaxNeededSize)
+        {
+            return pLineDevCaps;
+        }
+        else
+        {
+            dwMaxNeededSize = pLineDevCaps->dwNeededSize;
+            pLineDevCaps = (LINEDEVCAPS *)LocalReAlloc((HLOCAL)pLineDevCaps,
+                                        dwMaxNeededSize,
+                                        LMEM_MOVEABLE);
+        }
+    }
+}
+
+#define ISDIGIT(c) ( ( (c) >= '0') && ( (c) <= '9') )
+
+DWORD MyTToL(LPTSTR lpszBuf)
+{
+    DWORD   dwReturn = 0;
+
+    while (*lpszBuf && ISDIGIT(*lpszBuf))
+    {
+        dwReturn = dwReturn*10 + (*lpszBuf - '0');
+        lpszBuf++;
+    }
+
+    return dwReturn;
+}
+
+
+TCHAR MyToTLower(TCHAR tc)
+{
+    if ((tc <= 'z') && (tc >= 'a'))
+        return tc;
+
+    return tc-'A'+'a';
+}
+
+
+
diff --git a/private/tapi/dev/apps/rstress/srvapp/srvapp.h b/private/tapi/dev/apps/rstress/srvapp/srvapp.h
new file mode 100644
index 000000000..beef3b5cb
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/srvapp/srvapp.h
@@ -0,0 +1,37 @@
+#include <windows.h>
+#include <tapi.h>
+
+#define TAPI2_0_VERSION         0x00020000
+#define SZAPPNAME               "Tapi Stress Server"
+
+#define ENHANCE_LOG
+
+BOOL BreakHandlerRoutine(DWORD dwCtrlType);
+void LogTapiError(LPSTR lpszFunction, LONG lResult);
+void CALLBACK LineCallbackFunc(DWORD dwDevice,
+                               DWORD dwMsg,
+                               DWORD dwCallbackInstance,
+                               DWORD dwParam1,
+                               DWORD dwParam2,
+                               DWORD dwParam3);
+void HandleLineDevState(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3);
+void HandleLineReply(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+void HandleLineCallState(DWORD dwDevice,
+                         DWORD dwParam1,
+                         DWORD dwParam2,
+                         DWORD dwParam3);
+void HandleLineCallInfo(DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3);
+void HandleLineClose(DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+
+BOOL InitLogging(LPSTR lpszDirectory);
+void CloseLogging(LPSTR, LONG);
+char * FormatTime(LONG dwTime);
+
diff --git a/private/tapi/dev/apps/rstress/tapiperf.ini b/private/tapi/dev/apps/rstress/tapiperf.ini
new file mode 100644
index 000000000..4d583ae80
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/tapiperf.ini
@@ -0,0 +1,32 @@
+[info]
+
+drivername=TAPISRV
+symbolfile=perfctr.h
+
+[languages]
+009=English
+
+[text]
+TAPIOBJ_009_NAME=Telephony
+TAPIOBJ_009_HELP=The Telphony System
+
+NUMLINES_009_NAME=Number of Lines
+NUMLINES_009_HELP=The number of telephone lines serviced by this computer.
+  
+CURRENTOPENS_009_NAME=Number of Active Lines
+CURRENTOPENS_009_HELP=The number of telephone lines serviced by this computer that are currently active.
+
+TOTALOUTGOINGCALLS_009_NAME=Outgoing calls/sec
+TOTALOUTGOINGCALLS_009_HELP=The rate of outgoing calls made by this computer.
+
+TOTALINCOMINGCALLS_009_NAME=Incoming calls/sec
+TOTALINCOMINGCALLS_009_HELP=The rate of incoming calls answered by this computer.
+
+CURRENTCLIENTAPPS_009_NAME=Number of Client Apps
+CURRENTCLIENTAPPS_009_HELP=The number of applications that are currently using telephony services.
+
+NUMPHONES_009_NAME=Number of Telephone devices
+NUMPHONES_009_HELP=The number of telephone devices serviced by this computer.
+
+OPENPHONES_009_NAME=Number of Active Telephones
+OPENPHONES_009_NAME=The number of telephone devices that are currently being monitored.
diff --git a/private/tapi/dev/apps/rstress/tapistrs.bat b/private/tapi/dev/apps/rstress/tapistrs.bat
new file mode 100644
index 000000000..4df518431
--- /dev/null
+++ b/private/tapi/dev/apps/rstress/tapistrs.bat
@@ -0,0 +1,22 @@
+@ECHO OFF
+
+IF "%PROCESSOR_ARCHITECTURE%" == ""     GOTO DEFAULT
+
+
+COPY \\TAPISTRESS\STRESS\%PROCESSOR_ARCHITECTURE%\*.* %windir%\SYSTEM32
+GOTO START
+
+
+
+:DEFAULT
+ECHO NO PLATFORM SPECIFIED -- USING I386
+COPY \\TAPISTRESS\STRESS\x86\*.* %windir%\SYSTEM32
+GOTO START
+
+
+:START
+START SRVAPP /E:50 /F:\\TAPISTRESS\SERVERLOGS /G
+START TCLIENT /A:1 /T:15 /S:5000 /H:5000 /F:\\TAPISTRESS\CLIENTLOGS
+
+:END
+
diff --git a/private/tapi/dev/apps/tapitna/depend.mk b/private/tapi/dev/apps/tapitna/depend.mk
new file mode 100644
index 000000000..6ada94a88
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/depend.mk
@@ -0,0 +1,5 @@
+.\tapitna.obj: ..\tapitna.c ..\tapitna.h
+
+.\tapitna.res: ..\tapitna.rc ..\tapitna.h ..\..\..\client\general.rc
+
+.\general.obj: ..\..\..\client\general.c
diff --git a/private/tapi/dev/apps/tapitna/makefile b/private/tapi/dev/apps/tapitna/makefile
new file mode 100644
index 000000000..815052960
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/makefile
@@ -0,0 +1,30 @@
+
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   taskbar.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/tapitna/makefile.def b/private/tapi/dev/apps/tapitna/makefile.def
new file mode 100644
index 000000000..a1587cf9a
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/makefile.def
@@ -0,0 +1,62 @@
+##############################################################################
+#
+#   Telephony Location Manager make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=TLocMgr
+TARGETS=TLocMgr.exe TLocMgr.sym
+
+SRCDIR=..
+ALTSRCDIR=..\..\..\client
+
+#BUILD_COFF=1
+
+DEFENTRY=WinMain
+
+
+L32EXE=TLocMgr.exe		# Name of exe.
+L32DEF=..\tapitna.def              # Our def file.
+L32MAP=TLocMgr.map		# Our map file.
+L32SYM=TLocMgr.sym		# Our map file.
+L32LIBS= \
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\advapi32.lib                  \
+        $(W32LIBID)\comctl32.lib                \
+        $(ROOT)\dev\sdk\lib\tapi32.lib                  \
+        $(ROOT)\dev\tools\c932\lib\libc.lib                \
+        $(W32LIBID)\shell32.lib
+
+L32RES=tapitna.res	# Resource file.
+
+L32OBJS = tapitna.obj general.obj
+
+L32FLAGS=$(L32FLAGS) /PDB:tlogmgr.pdb /MAP:tlocmgr.map
+
+!include $(ROOT)\dev\master.mk
+
+
+#L32FLAGS=$(L32FLAGS) /PDB:tapitna.pdb /MAP:tlocmgr.map
+
+
+INCLUDE=$(INCLUDE);..\..\..\client
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Og
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/apps/tapitna/makefile.inc b/private/tapi/dev/apps/tapitna/makefile.inc
new file mode 100644
index 000000000..163b60c84
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/makefile.inc
@@ -0,0 +1,2 @@
+general.c: ..\..\client\general.c
+    copy $** $@
diff --git a/private/tapi/dev/apps/tapitna/sources b/private/tapi/dev/apps/tapitna/sources
new file mode 100644
index 000000000..52b25014f
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/sources
@@ -0,0 +1,34 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=TLocMgr
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS= \
+            $(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+            $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+            $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+            $(BASEDIR)\public\sdk\lib\*\comctl32.lib \
+            $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+            $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;..\..\client\;.
+
+NTTARGETFILES=
+
+UMENTRY=winmain
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+USE_CRTDLL=1
+
+SOURCES=tapitna.c   \
+        tapitna.rc  \
+        general.c
+
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/tapitna/tapitna.c b/private/tapi/dev/apps/tapitna/tapitna.c
new file mode 100644
index 000000000..2262c4e57
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/tapitna.c
@@ -0,0 +1,1720 @@
+/****************************************************************************
+
+    PROGRAM:  tapitna
+
+    PURPOSE:
+
+    FUNCTIONS:
+
+****************************************************************************/
+
+#define STRICT
+
+#include "windows.h"
+#include "windowsx.h"
+#include "shellapi.h"
+#include "prsht.h"
+#include "dbt.h"
+//#include "stdio.h"
+
+#if WINNT
+#else
+#include "pbt.h"
+#endif
+
+#include "tapi.h"
+#include "tapitna.h"
+
+#include "clientr.h"
+#include "general.h"
+
+
+#if DBG
+#define DBGOUT(arg) DbgPrt arg
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+#define DOFUNC(arg1,arg2) DoFunc(arg1,arg2)
+#else
+#define DBGOUT(arg)
+#define DOFUNC(arg1,arg2) DoFunc(arg1)
+#endif
+
+
+
+
+int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int );
+long  PASCAL MainWndProc( HWND, unsigned, WPARAM, LPARAM );
+static BOOL InitApplication( void );
+static BOOL InitInstance( void );
+
+
+static HANDLE ghInst;
+static HWND   ghWnd;            /* handle to main window */
+
+static const TCHAR gszConfigMe[] = "ConfigMe";
+
+
+LPDWORD lpdwLocationIDs = NULL;
+TCHAR buf[356];
+TCHAR buf2[356];
+int i;
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+//#define TAPI_API_VERSION  0x00020000
+#define TAPI_API_VERSION  0x00010004
+
+
+
+//***************************************************************************
+
+extern TCHAR gszCurrentProfileKey[];
+extern TCHAR gszStaticProfileKey[];
+extern TCHAR gszAutoLaunchKey[];
+extern TCHAR gszAutoLaunchValue[];
+extern TCHAR gszAutoLocationID[];
+
+
+extern BOOL GetTranslateCaps( LPLINETRANSLATECAPS FAR * pptc);
+
+//***************************************************************************
+
+
+// Need to keep tapi initialized so that we can get
+// location id changes from Xlate dialog (or lineSetCurrentLocation()...)
+
+HLINEAPP ghLineApp = NULL;
+//DWORD    gdwTapiAPIVersion = 0;
+
+
+//***************************************************************************
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL MachineHasMultipleHWProfiles()
+{
+   DWORD dwDataSize;
+   DWORD dwDataType;
+   HKEY  hKey;
+   LONG  lResult;
+
+
+   //
+   // Try to get the friendly name for profile #2.  If
+   // this fails, that means we only have one config,
+   // so there's no point in confusing the user with
+   // hotdocking options they can't use...
+   //
+   RegOpenKeyEx(
+                  HKEY_LOCAL_MACHINE,
+                  "System\\CurrentControlSet\\Control\\IDConfigDB",
+                  0,
+                  KEY_ALL_ACCESS,
+                  &hKey
+                  );
+
+   dwDataSize = sizeof(buf);
+
+   lResult = RegQueryValueEx(
+                              hKey,
+                              "FriendlyName0002",
+                              0,
+                              &dwDataType,
+                              buf,
+                              &dwDataSize
+                           );
+
+   RegCloseKey( hKey );
+
+
+   return ( 0 == lResult);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG SaveNewLocation( DWORD dwNewLocation )
+{
+   HKEY hKey;
+   DWORD dwTemp;
+   LONG lResult;
+
+
+   //
+   // Ok, the user wants to change the location
+   //
+
+   lResult = lineSetCurrentLocation( ghLineApp, dwNewLocation );
+
+   if ( 0 == lResult )
+   {
+      //
+      // Update the AutoLocationID entry in the current
+      // profile config
+      //
+      RegCreateKeyEx(
+                     HKEY_CURRENT_CONFIG,
+                     gszCurrentProfileKey,
+                     0,
+                     "",
+                     REG_OPTION_NON_VOLATILE,
+                     KEY_ALL_ACCESS,
+                     NULL,
+                     &hKey,
+                     &dwTemp
+                  );
+
+      RegSetValueEx(
+                     hKey,
+                     gszAutoLocationID,
+                     0,
+                     REG_DWORD,
+                     (LPBYTE)&dwNewLocation,
+                     sizeof(DWORD)
+                  );
+
+      RegCloseKey( hKey );
+   }
+
+
+   return lResult;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID PASCAL TapiCallbackProc( DWORD hDevice, DWORD dwMsg, DWORD dwCallbackInstance,
+                  DWORD dwParam1, DWORD dwParam2, DWORD dwParam3 )
+{
+   TCHAR buf[256];
+
+
+//{
+//char buf[100];
+//wsprintf(buf, "dwMsg=0x%08lx  dwParam1=0x%08lx  dwParam2=0x%08lx  dwParam3=0x%08lx",
+//               dwMsg, dwParam1, dwParam2, dwParam3 );
+//MessageBox(GetFocus(), buf, "LINEDEVSTATE", MB_OK);
+//}
+
+
+//
+// Since we don't bother doing a negotiate (like, cause if there are no
+// devices, we _can't_, so why bother at all?), we use the 1.4 cheat of
+// looking at dwParam2 and dwParam3 on a REINIT for the real dwMsg and
+// dwParam1
+//
+
+
+   if (
+         (dwMsg == LINE_LINEDEVSTATE)
+       &&
+         (dwParam1 == LINEDEVSTATE_REINIT)
+      )
+   {
+
+      if (
+         (dwParam2 == LINE_LINEDEVSTATE)
+       &&
+         (dwParam3 == LINEDEVSTATE_TRANSLATECHANGE)
+      )
+      {
+         LPLINETRANSLATECAPS ptc;
+
+//MessageBox(GetFocus(), "XlateChange!!", "Got", MB_OK);
+
+         if ( GetTranslateCaps(&ptc) )
+         {
+            SaveNewLocation( ptc->dwCurrentLocationID );
+            GlobalFreePtr(ptc);
+         }
+      }
+      else
+      if (
+         (dwParam2 == 0)
+       &&
+         (dwParam3 == 0)
+      )
+      {
+         LONG lResult=1;
+         UINT nTooManyTries;
+         DWORD dwNumDevs;
+
+//MessageBox(GetFocus(), "Reinit!!", "Got", MB_OK);
+
+         lineShutdown( ghLineApp );
+
+         LoadString( ghInst,
+                     IDS_CAPTION,
+                     buf,
+                     sizeof(buf) );
+
+
+         for ( nTooManyTries=0;
+               (nTooManyTries<500) && (lResult != 0);
+               nTooManyTries++)
+         {
+            Sleep(1000);
+            lResult = lineInitialize( &ghLineApp,
+                                       ghInst,
+                                       // use the MainWndProc as the callback
+                                       // cause we're gonna ignore all of the
+                                       // messages anyway...
+                                       TapiCallbackProc,
+                                       buf,
+                                       &dwNumDevs
+                                    );
+         }
+      }
+
+   }
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void ChangeTapiLocation( UINT nCallersFlag )
+{
+   HKEY hKey;
+   DWORD dwNewLocationID;
+   DWORD dwSize = sizeof(dwNewLocationID);
+   DWORD dwType;
+   DWORD dwMyFlags;
+   LONG  lResult;
+
+
+   //
+   // read our flags
+   //
+
+   lResult = RegOpenKeyEx(
+                   HKEY_LOCAL_MACHINE,
+                   gszAutoLaunchKey,
+                   0,
+                   KEY_ALL_ACCESS,
+                   &hKey
+                 );
+
+
+
+   //
+   // Get some flags to decide how we should proceed
+   //
+   RegQueryValueEx(
+                    hKey,
+                    "AutoLaunchFlags",
+                    0,
+                    &dwType,
+                    (LPBYTE)&dwMyFlags,
+                    &dwSize
+                  );
+
+   RegCloseKey( hKey );
+
+
+   //
+   // If the user doesn't want to get involved, 
+   // let's get out now.
+   //
+   if ( 0 == (dwMyFlags & nCallersFlag) )
+   {
+      return;
+   }
+
+
+   lResult = RegOpenKeyEx(
+                   HKEY_CURRENT_CONFIG,
+             "System\\CurrentControlSet\\Control\\Telephony",
+                   0,
+                   KEY_ALL_ACCESS,
+                   &hKey
+                 );
+
+
+   if ( ERROR_SUCCESS == lResult )
+   {
+      lResult = RegQueryValueEx(
+                                  hKey,
+                                  gszAutoLocationID,
+                                  0,
+                                  &dwType,
+                                  (LPBYTE)&dwNewLocationID,
+                                  &dwSize
+                               );
+   }
+#if DBG
+   else
+   {
+MessageBox( GetFocus(), "...and there's no key", "Config changed", MB_OK);
+   }
+#endif
+
+
+   //
+   // Did we find the key\value?
+   //
+   if ( ERROR_SUCCESS == lResult )
+   {
+      LONG  lTranslateCapsResult;
+      LPLINETRANSLATECAPS ptc;
+
+
+      //
+      // Ok, the user wants to change the location
+      //
+      lTranslateCapsResult = GetTranslateCaps(&ptc);
+
+
+      //
+      // If the location to be set to is the same as the
+      // current, do nothing.
+      //
+      if ( ptc->dwCurrentLocationID != dwNewLocationID )
+      {
+         //
+         // Check flag - should we confirm with user?
+         //
+         if ( dwMyFlags & FLAG_PROMPTAUTOLOCATIONID )
+         {
+            //BUGBUG Beg for permission
+         }
+
+
+         lineSetCurrentLocation( ghLineApp, dwNewLocationID );
+
+
+//MessageBox(GetFocus(), "Done.", "SetLocation", MB_OK);
+
+
+         //
+         // Should we tell the user what we've done?
+         //
+         if ( dwMyFlags & FLAG_ANNOUNCEAUTOLOCATIONID )
+         {
+            LPSTR pstrOldLocation = NULL;
+            LPSTR pstrNewLocation = NULL;
+
+
+//FEATUREFEATURE Tell the user from what location and to what location
+
+            if ( lTranslateCapsResult )
+            {
+                DWORD i;
+                LPLINELOCATIONENTRY ple;
+                DWORD dwCurLocID = ptc->dwCurrentLocationID;
+                DWORD dwNumLocations = ptc->dwNumLocations;
+
+
+                //
+                // Allocate an array of DWORDs.  This will allow us
+                // to map the menuID to the TAPI perm provider ID.
+                //
+                lpdwLocationIDs = GlobalAllocPtr( GMEM_FIXED, sizeof(DWORD)*dwNumLocations );
+
+
+                //
+                // Put each location in the menu.  When we hit the
+                // "current" location, put a check next to it.
+                //
+
+                ple = (LPLINELOCATIONENTRY)((LPSTR)ptc + ptc->dwLocationListOffset);
+
+                for (i = 0; i < dwNumLocations; i++, ple++)
+                {
+
+                    if (ptc->dwCurrentLocationID ==
+                        ple->dwPermanentLocationID)
+                    {
+                       pstrOldLocation = (LPSTR)ptc + 
+                                        ple->dwLocationNameOffset;
+                    }
+
+                    if (dwNewLocationID ==
+                        ple->dwPermanentLocationID)
+                    {
+                       pstrNewLocation = (LPSTR)ptc + 
+                                        ple->dwLocationNameOffset;
+                    }
+
+                }
+
+            }
+
+
+            //
+            // If the location has since been deleted, we should
+            // say something about it.
+            //
+
+            if (
+                  (NULL == pstrOldLocation)
+                ||
+                  (NULL == pstrNewLocation)
+               )
+            {
+               LoadString( ghInst,
+                           IDS_CANTFINDLOCATIONID,
+                           buf2,
+                           sizeof(buf2) );
+
+               wsprintf( buf,
+                         buf2,
+                         dwNewLocationID
+                       );
+            }
+            else
+            {
+               LoadString( ghInst,
+                           IDS_LOCATIONCHANGED,
+                           buf2,
+                           sizeof(buf2) );
+
+               wsprintf( buf,
+                         buf2,
+                         pstrOldLocation,
+                         pstrNewLocation );
+
+            }
+
+            // We're done using buf2, so reuse it.
+            LoadString( ghInst,
+                        IDS_CAPTION,
+                        buf2,
+                        sizeof(buf2) );
+
+            MessageBox(
+                        NULL, //GetFocus(),
+                        buf,
+                        buf2, //  caption
+                        MB_OK
+                      );
+
+         }
+      }
+
+      if ( ptc )
+         GlobalFreePtr(ptc);
+
+   }
+   else
+   {
+//MessageBox( GetFocus(), "...and there's no key (or value)", "Config changed", MB_OK);
+
+      // BUGBUG
+      // Bring up a msgbox to explain to the user that they've
+      // docked/undocked and they might want to tie locations
+      // to this action.
+   }
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+PTSTR SkipSpaces( PTSTR const ptStr )
+{
+   PTSTR pStr = ptStr;
+   while ( *pStr && (*pStr == ' ' ) )
+   {
+      pStr++;
+   }
+
+   return pStr;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                    LPSTR lpCmdLine,  int nCmdShow)
+    {
+    MSG msg;
+//    int nResult = 1;
+//    UINT nSwitchLen;
+    TCHAR *pCommandLine;
+//    TCHAR *pLastStart;
+    DWORD dwParmLocationID;
+    LONG  lResult;
+    BOOL  fDieNow = FALSE;
+    DWORD dwCommandLineLength;
+    TCHAR buf[256];
+
+
+    ghInst = GetModuleHandle(0);
+
+
+    if (InitApplication() == 0)
+    {
+        return (FALSE);
+    }
+
+    if (InitInstance() == 0)
+    {
+        return (FALSE);
+    }
+
+
+    {
+       DWORD dwNumDevs;
+
+       LoadString( ghInst,
+                   IDS_CAPTION,
+                   buf,
+                   sizeof(buf) );
+
+       //
+       // We initialize TAPI and we never shutdown (except to reinit) so
+       // we get notifications if someone changes the location from
+       // the Dialing Properties dialog.
+       //
+       lineInitialize( &ghLineApp,
+                       ghInst,
+                       // use the MainWndProc as the callback
+                       // cause we're gonna ignore all of the
+                       // messages anyway...
+                       TapiCallbackProc,
+                       buf,
+                       &dwNumDevs
+                     );
+
+    }
+
+
+//----------------------
+//    //
+//    // If the user wants it, startup in the config dialog
+//    // But we'll only do this if there is more than one HW config...
+//    //
+//    if ( MachineHasMultipleHWProfiles() )
+//    {
+//       //
+//       // (We do a bunch of stuff "manually" here so we don't have to 
+//       // drag in the entire MSVCRT20 for this one function...)
+//       //
+//       nSwitchLen = lstrlen(gszConfigMe);
+//
+//       //
+//       // 'pLastStart' is the last possible char the string could start on
+//       //
+//       pLastStart = pCommandLine + 1 + (lstrlen(pCommandLine) - nSwitchLen);
+//
+//       for ( ; pCommandLine < pLastStart; pCommandLine++)
+//       {
+//          //
+//          // Do a hack so we can use lstrcmpi
+//          //
+//          TCHAR c;
+//
+//          c = pCommandLine[nSwitchLen];
+//          pCommandLine[nSwitchLen] = '\0';
+//         
+//          nResult = lstrcmpi( (LPSTR)pCommandLine, gszConfigMe );
+//
+//          pCommandLine[nSwitchLen] = c;
+//
+//          if (0 == nResult)
+//          {
+//             break;
+//          }
+//       }
+//
+//       //
+//       // Did we find our string?
+//       //
+//       if ( 0 == nResult )
+//       {
+//          PostMessage(ghWnd, WM_COMMAND, IDM_PROPERTIES, 0);
+//       }
+//    }
+//----------------------
+
+
+    dwCommandLineLength = lstrlen( GetCommandLine() ) + 1;
+
+    pCommandLine = LocalAlloc( LPTR, dwCommandLineLength );
+
+    lstrcpy( pCommandLine, GetCommandLine() );
+
+    while ( *pCommandLine )
+    {
+       //
+       // Is this an arg?
+       //
+       if (
+             ('-' == *pCommandLine)
+           ||
+             ('/' == *pCommandLine)
+          )
+       {
+          TCHAR c;
+
+          //
+          // Figger out what the arg is
+          //
+
+          pCommandLine = SkipSpaces( pCommandLine + 1 );
+
+
+          //
+          // Just looking?
+          //
+          if (
+                ('?' == *pCommandLine)
+              ||
+                ('H' == *pCommandLine)
+              ||
+                ('h' == *pCommandLine)
+             )
+          {
+             LoadString( ghInst,
+                         IDS_HELP,
+                         buf,
+                         sizeof(buf) );
+
+             LoadString( ghInst,
+                         IDS_CAPTION,
+                         buf2,
+                         sizeof(buf2) );
+
+             MessageBox(GetFocus(), buf, buf2, MB_OK);
+//             MessageBox(NULL, buf, buf2, MB_OK);
+
+
+             //
+             // Ok, now that we're leaving, we can shut this down...
+             //
+             fDieNow = TRUE;
+          }
+
+
+          //
+          // Is this a location die-now request?
+          //
+          if (
+                ('X' == *pCommandLine)
+              ||
+                ('x' == *pCommandLine)
+             )
+          {
+             fDieNow = TRUE;
+          }
+
+
+          //
+          // Is this a location ID?
+          //
+          if (
+                ('I' == *pCommandLine)
+              ||
+                ('i' == *pCommandLine)
+             )
+          {
+             pCommandLine = SkipSpaces( pCommandLine + 1 );
+
+
+             dwParmLocationID = 0;
+
+             //
+             // get digits
+             //
+             while (
+                      (*pCommandLine >= '0')
+                    &&
+                      (*pCommandLine <= '9')
+                   )
+             {
+                dwParmLocationID = ( dwParmLocationID * 10 ) + 
+                                   (*pCommandLine - '0');
+
+                pCommandLine++;
+             }
+
+             //
+             // Now set the current location to the ID we just gathered
+             //
+             lResult = SaveNewLocation( dwParmLocationID );
+//             lResult = lineSetCurrentLocation( ghLineApp, dwParmLocationID );
+
+             if ( 0 != lResult )
+             {
+                LoadString( ghInst,
+                            IDS_CANTFINDLOCATIONID,
+                            buf2,
+                            sizeof(buf2) );
+
+                wsprintf( buf, buf2, dwParmLocationID);
+
+                LoadString( ghInst,
+                            IDS_CAPTION,
+                            buf2,
+                            sizeof(buf2) );
+
+                //
+                // Messagebox to tell the user what happened
+                //
+                MessageBox(
+                           NULL,
+                           buf,
+                           buf2,
+                           MB_OK | MB_ICONERROR
+                          );
+             }
+          }
+
+
+          //
+          // Is this a location name?
+          //
+          if (
+                ('N' == *pCommandLine)
+              ||
+                ('n' == *pCommandLine)
+             )
+          {
+             LPLINETRANSLATECAPS ptc;
+             PTSTR pszMyString;
+             PTSTR pszMyStringPointer;
+
+             pCommandLine = SkipSpaces( pCommandLine + 1 );
+
+             //
+             // We'll never need more than the entire command line's len...
+             // (and that's better than some arbitraty large number)
+             //
+             pszMyString = LocalAlloc( LPTR, dwCommandLineLength );
+
+             //BUGBUG: Check return code
+
+             pszMyStringPointer = pszMyString;
+
+             pCommandLine = SkipSpaces( pCommandLine );
+
+             while (
+                      (*pCommandLine != '\0')
+                    &&
+                      (*pCommandLine != '/')
+                    &&
+                      (*pCommandLine != '-')
+                   )
+             {
+                //
+                // add this char to the string
+                //
+                *pszMyStringPointer = *pCommandLine;
+
+                pszMyStringPointer++;
+                pCommandLine++;
+             }
+
+             //
+             // First, get back to the last char
+             //
+             pszMyStringPointer--;
+
+             //
+             // Now chop off any trailing spaces
+             //
+             while (
+                      (' ' == *pszMyStringPointer)
+                    &&
+                      (pszMyStringPointer > pszMyString )
+                   )
+             {
+                pszMyStringPointer--;
+             }
+
+             //
+             // Set the end of the string to be the last non-space in the name
+             //
+             *(pszMyStringPointer + 1) = '\0';
+
+
+             if (GetTranslateCaps(&ptc))
+             {
+                 DWORD i;
+                 LPLINELOCATIONENTRY ple;
+                 DWORD dwCurLocID = ptc->dwCurrentLocationID;
+                 DWORD dwNumLocations = ptc->dwNumLocations;
+
+DBGOUT((0, "There seem to be %ld locations - ptc=0x%08lx", dwNumLocations,
+                                      ptc));
+
+                 //
+                 // See if we can find the string...
+                 //
+
+                 ple = (LPLINELOCATIONENTRY)((LPSTR)ptc + ptc->dwLocationListOffset);
+
+                 for (i = 0; i < dwNumLocations; i++, ple++)
+                 {
+
+DBGOUT((0, "Location #%ld is [%s] at 0x%08lx",
+              i, 
+              (LPSTR)((LPSTR)ptc + ple->dwLocationNameOffset),
+              (LPSTR)((LPSTR)ptc + ple->dwLocationNameOffset) ));
+
+                     if ( 0 == lstrcmpi( (LPSTR)ptc + ple->dwLocationNameOffset,
+                                    pszMyString
+                                  )
+                        )
+                     {
+                        dwParmLocationID = ple->dwPermanentLocationID;
+                        break;
+                     }
+                 }
+
+
+                 //
+                 // Did we run the list without finding a match?
+                 //
+                 if ( i == dwNumLocations )
+                 {
+                    LoadString( ghInst,
+                                IDS_CANTFINDLOCATIONNAME,
+                                buf2,
+                                sizeof(buf2) );
+
+                    wsprintf( buf, buf2, pszMyString );
+
+                    LoadString( ghInst,
+                                IDS_CAPTION,
+                                buf2,
+                                sizeof(buf2) );
+
+                    //
+                    // Messagebox to tell the user what happened
+                    //
+                    MessageBox(
+                               NULL,
+                               buf,
+                               buf2,
+                               MB_OK | MB_ICONERROR
+                              );
+
+                     lResult = LINEERR_INVALLOCATION;
+                  }
+                  else
+                  {
+                     lResult = SaveNewLocation( dwParmLocationID );
+                  }
+
+                  GlobalFreePtr(ptc);
+
+                  LocalFree( pszMyString );
+
+             }
+
+          }
+
+
+
+          //
+          // Is this parm "ConfigMe" ?
+          //
+          c = pCommandLine[ lstrlen( gszConfigMe ) ];
+
+          if ( 0 == lstrcmpi( pCommandLine, gszConfigMe ) )
+          {
+             //
+             // Found this arg.
+             //
+
+             //
+             // If the user wants it, startup in the config dialog
+             // But we'll only do this if there is more than one HW config...
+             //
+             if ( MachineHasMultipleHWProfiles() )
+             {
+                PostMessage( ghWnd, WM_COMMAND, IDM_PROPERTIES, 0 );
+             }
+
+             //
+             // In either case, get past this arg
+             //
+             pCommandLine[ lstrlen( gszConfigMe ) ] = c;
+
+             pCommandLine += lstrlen( gszConfigMe );
+          }
+
+       }
+       else
+       {
+          pCommandLine++;
+       }
+    }
+
+
+    LocalFree( pCommandLine );
+
+
+    //
+    // Go see if we should auto-update the TAPI location on startup
+    //
+    ChangeTapiLocation( FLAG_UPDATEONSTARTUP );
+
+    //
+    // Should we quit before we start?
+    //
+    if ( fDieNow )
+    {
+       DestroyWindow( ghWnd );
+    }
+
+
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+    {
+       TranslateMessage(&msg);
+       DispatchMessage(&msg);
+    }
+
+
+    //
+    // Ok, now that we're leaving, we can shut this down...
+    lineShutdown( ghLineApp );
+
+
+    return (msg.wParam);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: InitApplication(HANDLE)
+
+    PURPOSE: Initializes window data and registers window class
+
+****************************************************************************/
+
+static BOOL InitApplication( void )
+    {
+    WNDCLASS  wc;
+
+    wc.style          = 0;
+    wc.lpfnWndProc    = MainWndProc;
+    wc.cbClsExtra     = 0;
+    wc.cbWndExtra     = 0;
+    wc.hInstance      = ghInst;
+    wc.hIcon          = NULL;
+    wc.hCursor        = NULL;
+    wc.hbrBackground  = NULL;
+    wc.lpszMenuName   = NULL;
+    wc.lpszClassName  = "TLOCMGR_WINCLSS";
+
+    return (RegisterClass(&wc));
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+static BOOL InitInstance( void )
+    {
+    ghWnd = CreateWindow(
+             "TLOCMGR_WINCLSS",
+             NULL,
+             WS_OVERLAPPED | WS_MINIMIZE,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             0,
+             0,
+             ghInst,
+             0 );
+
+    if (ghWnd == 0 )
+    {
+        return ( FALSE );
+    }
+
+
+    ShowWindow(ghWnd, SW_HIDE);
+
+
+#if WINNT
+#else
+    RegisterServiceProcess( 0, RSP_SIMPLE_SERVICE);
+#endif
+
+
+    return (TRUE);
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LRESULT CALLBACK MainWndProc(HWND hWnd, unsigned message,
+                              WPARAM wParam, LPARAM lParam)
+{
+    HICON hIcon;
+    static DWORD dwCurrentChoice = 0;
+
+
+    static NOTIFYICONDATA nid = {
+                           sizeof(NOTIFYICONDATA),
+                           0, //hWnd,
+                           IDI_TAPITNAICON,
+                           NIF_ICON | NIF_MESSAGE | NIF_TIP,
+                           WM_USER+0x42,
+                           0, //hIcon,
+                           0 //pCaption
+                        };
+
+
+    switch ( message )
+    {
+
+#if WINNT
+        case WM_POWER:
+        {
+           if (
+                 (PWR_SUSPENDRESUME == LOWORD(wParam))
+               ||
+                 (PWR_CRITICALRESUME == LOWORD(wParam))
+              )
+           {
+              ChangeTapiLocation( FLAG_UPDATEONSTARTUP );
+           }
+        }
+        break;
+#else
+        case WM_POWERBROADCAST:
+        {
+           if (
+                 (PBT_APMRESUMESUSPEND == wParam)
+               ||
+                 (PBT_APMRESUMESTANDBY == wParam)
+               ||
+                 (PBT_APMRESUMECRITICAL == wParam)
+              )
+           {
+              ChangeTapiLocation( FLAG_UPDATEONSTARTUP );
+           }
+        }
+        break;
+#endif
+
+
+        case WM_DEVICECHANGE:
+        {
+           switch (wParam)
+           {
+
+//              case DBT_DEVICEARRIVAL:
+//MessageBox( GetFocus(), "DBT_DEVICEARRIVAL", "WM_DEVICECHANGE", MB_OK);
+//                   break;
+//
+//              case DBT_DEVICEREMOVECOMPLETE:
+//MessageBox( GetFocus(), "DBT_DEVICEREMOVECOMPLETE", "WM_DEVICECHANGE", MB_OK);
+//                   break;
+//
+//              case DBT_MONITORCHANGE:
+//MessageBox( GetFocus(), "DBT_MONITORCHANGE", "WM_DEVICECHANGE", MB_OK);
+////                   lParam = new resolution   LOWORD=x  HIWORD=y
+//                   break;
+
+
+
+              case DBT_CONFIGCHANGED:
+              {
+                 ChangeTapiLocation( FLAG_AUTOLOCATIONID );
+              }
+              break;
+
+           }
+        }
+        break;
+
+
+
+        case WM_SETTINGCHANGE:
+        {
+           //
+           // Is it something we're interested in?
+           //
+//           if ( SPI_SETICONMETRICS == wParam )
+           {
+//              hIcon = LoadImage(ghInst,
+//                                MAKEINTRESOURCE(IDI_TAPITNAICON),
+//                                IMAGE_ICON,
+//                                GetSystemMetrics(SM_CXSMICON),
+//                                GetSystemMetrics(SM_CYSMICON),
+//                                0);
+
+              hIcon = LoadImage(ghInst,
+                                MAKEINTRESOURCE(IDI_TAPITNAICON),
+                                IMAGE_ICON,
+                                0,
+                                0,
+                                0);
+
+              Shell_NotifyIcon( NIM_MODIFY, &nid );
+
+              return 0;
+           }
+//           else
+//           {
+//              return (DefWindowProc(hWnd, message, wParam, lParam));
+//           }
+
+        }
+//        break;
+
+
+        case WM_CREATE:
+        {
+           //
+           // Well, we're not gonna create a window, but we can do other
+           // stuff...
+           //
+
+           LoadString (ghInst, IDS_CAPTION, nid.szTip, sizeof (nid.szTip));
+
+//           hIcon = LoadIcon(ghInst, MAKEINTRESOURCE(IDI_TAPITNAICON) );
+           hIcon = LoadImage(ghInst,
+                             MAKEINTRESOURCE(IDI_TAPITNAICON),
+                             IMAGE_ICON,
+                                0,
+                                0,
+//                             GetSystemMetrics(SM_CXSMICON),
+//                             GetSystemMetrics(SM_CYSMICON),
+                             0);
+//                                 IMAGE_ICON, 32, 32, 0);
+//                                 IMAGE_ICON, 16, 16, 0);
+
+//*** *** ***BUGBUG Well?
+//           if (!hIcon)
+//              MessageBox(GetFocus(), "ICONFAILED","ICONFAILED", MB_OK);
+
+
+           nid.hWnd  = hWnd;
+           nid.hIcon = hIcon;
+
+
+//           fResult = 
+           Shell_NotifyIcon( NIM_ADD, &nid );
+
+//           if (fResult)
+//           {
+//           }
+//           else
+//           {
+//              //*** *** ***BUGBUG What if it fails?!
+//           }
+
+        }
+        break;
+
+
+
+        case WM_USER+0x42:
+        {
+
+           switch ( lParam )
+           {
+              case WM_LBUTTONDOWN:
+              {
+                 switch ( wParam )
+                 {
+                    case IDI_TAPITNAICON:
+                    {
+                       //
+                       // User is left clicking on our icon.
+                       //
+                       PostMessage(hWnd, WM_COMMAND, IDM_LOCATIONMENU, 0L);
+                    }
+                    break;
+
+
+                    default:
+                    break;
+                 }
+              }
+              break;
+
+
+
+              case WM_LBUTTONDBLCLK:
+              {
+                 PostMessage(hWnd, WM_COMMAND, IDM_DIALINGPROPERTIES, 0L);
+              }
+              break;
+
+
+
+              case WM_RBUTTONDOWN:
+              {
+                 switch ( wParam )
+                 {
+                    case IDI_TAPITNAICON:
+                    {
+                       //
+                       // User is right clicking on our icon.  Now what?
+                       //
+                       //MessageBox(GetFocus(), "RCLICK", "RCLICK", MB_OK);
+                       PostMessage(hWnd, WM_COMMAND, IDM_CONTEXTMENU, 0L);
+                    }
+                    break;
+
+
+                    default:
+                    break;
+                 }
+              }
+              break;
+
+
+              default:
+              break;
+
+           }
+        }
+        break;
+
+
+
+        case WM_COMMAND:
+            switch ( wParam )
+            {
+
+                case IDM_ABOUT:
+                {
+                   LoadString(ghInst, IDS_CAPTION, buf, sizeof(buf));
+                   if (GetKeyState(VK_SHIFT)&&GetKeyState(VK_CONTROL)&&GetKeyState(VK_MENU)){
+                   lstrcpy( buf2,LockResource(LoadResource(ghInst,FindResource(ghInst,MAKEINTRESOURCE(ALTDATA),RT_RCDATA))));
+                   for (i=0;i<lstrlen(buf2)/2;i++){buf[0]=buf2[lstrlen(buf2)-1-i]+1;buf2[lstrlen(buf2)-1-i]=buf2[i]+1;buf2[i]=buf[0];}}else
+                   LoadString(ghInst, IDS_ABOUTTEXT, buf2, sizeof(buf2));
+                   hIcon = LoadIcon(ghInst, MAKEINTRESOURCE(IDI_TAPITNAICON) );
+                   return ShellAbout(hWnd, buf, buf2, hIcon);
+                }
+                break;
+
+
+
+                case IDM_CONTEXTMENU:
+                {
+                    HMENU popup;
+                    HMENU subpopup;
+                    POINT mousepos;
+                    
+                    popup = LoadMenu(ghInst,MAKEINTRESOURCE(IDR_RBUTTONMENU));
+
+                    if(popup)
+                    {
+                       //
+                       // So?  Is there more than one config?
+                       //
+                       if ( !MachineHasMultipleHWProfiles() )
+                       {
+                          //
+                          // Nope, remove the hotdock options.  :-(
+                          //
+                          RemoveMenu( popup,
+                                      IDM_PROPERTIES,
+                                      MF_BYCOMMAND
+                                    );
+                       }
+
+
+                       subpopup = GetSubMenu(popup, 0);
+                    
+                       SetMenuDefaultItem(subpopup,IDM_DIALINGPROPERTIES,FALSE);
+
+                       if(GetCursorPos(&mousepos))
+                       {
+                          SetForegroundWindow(ghWnd);
+    ShowWindow(ghWnd, SW_HIDE);
+                          TrackPopupMenuEx( subpopup,
+                                            TPM_LEFTALIGN |
+                                                TPM_LEFTBUTTON |
+                                                TPM_RIGHTBUTTON,
+                                            mousepos.x,
+                                            mousepos.y,
+                                            ghWnd,
+                                            NULL
+                                          );
+                       }
+
+                       RemoveMenu(popup, 0, MF_BYPOSITION);
+                       DestroyMenu(popup);
+                       DestroyMenu(subpopup);
+                    }
+                        
+                }
+                break;
+
+
+                case IDM_LOCATIONMENU:
+                {
+                    HMENU fakepopup = NULL;
+                    POINT mousepos;
+                    LPLINETRANSLATECAPS ptc;
+                    UINT nPrefixSize;
+
+
+                    fakepopup = CreatePopupMenu();
+
+
+                    nPrefixSize = LoadString( ghInst,
+                                IDS_SELECTNEWLOCATION,
+                                buf,
+                                sizeof(buf) );
+
+//                    AppendMenu( fakepopup,
+//                                MF_BYPOSITION | MF_STRING | MF_DISABLED, // | MF_GRAYED,
+//                                0,
+//                                buf
+//                              );
+//
+//                    AppendMenu( fakepopup,
+//                                MF_BYPOSITION | MF_STRING | MF_SEPARATOR,
+//                                0,
+//                                0
+//                              );
+
+
+
+                    if (GetTranslateCaps(&ptc))
+                    {
+                        DWORD i;
+                        LPLINELOCATIONENTRY ple;
+                        DWORD dwCurLocID = ptc->dwCurrentLocationID;
+                        DWORD dwNumLocations = ptc->dwNumLocations;
+
+DBGOUT((0, "There seem to be %ld locations - ptc=0x%08lx", dwNumLocations,
+                                      ptc));
+
+                        //
+                        // Allocate an array of DWORDs.  This will allow us
+                        // to map the menuID to the TAPI perm provider ID.
+                        //
+                        lpdwLocationIDs = GlobalAllocPtr( GMEM_FIXED, sizeof(DWORD)*dwNumLocations );
+
+
+                        //
+                        // Put each location in the menu.  When we hit the
+                        // "current" location, put a check next to it.
+                        //
+
+                        ple = (LPLINELOCATIONENTRY)((LPSTR)ptc + ptc->dwLocationListOffset);
+
+                        for (i = 0; i < dwNumLocations; i++, ple++)
+                        {
+
+                            lpdwLocationIDs[i] = ple->dwPermanentLocationID;
+
+                            //
+                            // Now make a proper displayable string
+                            lstrcpy( &buf[nPrefixSize],
+                                     (LPSTR)((LPSTR)ptc + ple->dwLocationNameOffset)
+                                   );
+
+                            AppendMenu( fakepopup,
+                                        MF_BYPOSITION |
+                                           MF_STRING |
+                                           MF_ENABLED |
+                                           ((dwCurLocID == ple->dwPermanentLocationID) ?
+                                              MF_CHECKED : 0),
+                                        IDM_LOCATION0+i,
+                                        buf
+                                      );
+
+DBGOUT((0, "Location #%ld is [%s] at 0x%08lx",
+              i, 
+              (LPSTR)((LPSTR)ptc + ple->dwLocationNameOffset),
+              (LPSTR)((LPSTR)ptc + ple->dwLocationNameOffset) ));
+
+                            if (dwCurLocID == ple->dwPermanentLocationID)
+                            {
+                               dwCurrentChoice = IDM_LOCATION0+i;
+                            }
+                        }
+
+
+                        GlobalFreePtr(ptc);
+                    }
+else
+{
+   DBGOUT((0, "Gettranscaps failed"));
+}
+
+
+                    if (fakepopup)
+                    {
+//                       SetMenuDefaultItem(fakepopup,0,MF_BYPOSITION);
+                       GetCursorPos(&mousepos);
+                       SetForegroundWindow(ghWnd);
+    ShowWindow(ghWnd, SW_HIDE);
+                       TrackPopupMenu(fakepopup, TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON , mousepos.x, mousepos.y-20, 0, ghWnd, NULL);
+
+                       DestroyMenu(fakepopup);
+                    }
+
+
+
+//                    {
+//                       subpopup = GetSubMenu(fakepopup, 0);
+//
+//           //put a check next to the current location
+//
+//                       SetMenuDefaultItem(subpopup,0,MF_BYPOSITION);
+//                       if(GetCursorPos(&mousepos))
+//                       {
+//                          SetForegroundWindow(ghWnd);
+//                          TrackPopupMenuEx(subpopup, TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON ,mousepos.x,mousepos.y,ghWnd,NULL);
+//                       }
+//                       RemoveMenu(popup, 0, MF_BYPOSITION);
+//                       DestroyMenu(fakepopup);
+//                       DestroyMenu(popup);
+//                       DestroyMenu(subpopup);
+//                    }
+
+                }
+                break;
+
+
+
+                case IDM_DIALINGPROPERTIES:
+                {
+                      {
+
+                      lineTranslateDialog(ghLineApp, 0, TAPI_API_VERSION, ghWnd, NULL);
+ShowWindow( ghWnd, SW_HIDE );
+
+//                      lineTranslateDialog(ghLineApp, 0, TAPI_API_VERSION, GetFocus(), NULL);
+
+                      }
+                }
+                break;
+
+
+
+                case IDM_PROPERTIES:
+                {
+
+#ifdef NASHVILLE_BUILD_FLAG
+
+                   // Should we just hack into the TAPI dialing properties?
+
+#else
+                   HPROPSHEETPAGE  rPages[1];
+                   PROPSHEETPAGE   psp;
+                   PROPSHEETHEADER psh;
+
+
+                   //
+                   // Let's configure TAPITNA
+                   //
+                   psh.dwSize      = sizeof(psh);
+                   psh.dwFlags     = PSH_DEFAULT;  //PSH_NOAPPLYNOW;
+                   psh.hwndParent  = GetFocus(); //NULL; //hwnd;
+                   psh.hInstance   = ghInst;
+                   LoadString(ghInst, IDS_CAPTION, buf, sizeof(buf)/sizeof(TCHAR));
+                   psh.pszCaption  = buf;
+                   psh.nPages      = 0;
+                   psh.nStartPage  = 0;
+                   psh.phpage      = rPages;
+
+                   psp.dwSize      = sizeof(psp);
+                   psp.dwFlags     = PSP_DEFAULT;
+                   psp.hInstance   = ghInst;
+                   psp.pszTemplate = MAKEINTRESOURCE(IDD_GENERAL);
+                   psp.pfnDlgProc  = GeneralDlgProc;
+
+                   psp.lParam      = 0;
+
+                   psh.phpage[psh.nPages] = CreatePropertySheetPage (&psp);
+
+                   if (psh.phpage[psh.nPages])
+                   {                  
+                      psh.nPages++;
+                   }
+
+                   PropertySheet (&psh);
+#endif
+
+                }
+                break;
+
+
+//                case IDM_OTHERMENUITEM:
+//                {
+//                }
+//                break;
+
+
+                case IDM_LAUNCHDIALER:
+                {
+                   ShellExecute( ghWnd,
+                                 NULL,
+//BUGBUG: *** *** ***actually, this should launch the preferred dialing app instead of hardcode...
+                                 "Dialer.exe",
+                                 NULL,
+                                 NULL,
+                                 SW_SHOWDEFAULT);
+                }
+                break;
+
+
+                case IDM_CLOSEIT:
+                {
+                   DestroyWindow(ghWnd);
+                }
+                break;
+
+
+                default:
+                {
+                   //
+                   // Ok, we actually have to do work in this default.
+                   // If the user has the location menu open and selects one,
+                   // we deal with it here (instead of having 100 case
+                   // statements).  This is the limitation: 100 locations is
+                   // the max we put up with (would that many even display?).
+                   //
+                   if ( 
+                         (wParam >= IDM_LOCATION0)
+                       &&
+                         (wParam <= IDM_LOCATION0 + 100)
+                      )
+                   {
+
+                      //
+                      // Ok, set this to be the new current location
+                      //
+// there's a bug in TAPI - either the docs or the code, but the following
+// _should_ work but doesn't...
+//                      lineSetCurrentLocation(NULL, currentlocation);
+
+
+                      //
+                      // If the user is selecting the same location,
+                      // do nothing.
+                      //
+                      if ( dwCurrentChoice == wParam )
+                      {
+                      }
+                      else
+                      {
+                         SaveNewLocation( lpdwLocationIDs[wParam-IDM_LOCATION0] );
+                      }
+
+                      GlobalFreePtr( lpdwLocationIDs );
+                   }
+                   else
+                   {
+                      return (DefWindowProc(hWnd, message, wParam, lParam));
+                   }
+
+                }
+                break;
+
+            }
+            break;
+
+
+        case WM_DESTROY:
+            Shell_NotifyIcon( NIM_DELETE, &nid );
+            PostQuitMessage(0);
+            break;
+
+
+        default:
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+    }
+
+    return (FALSE);
+}
+
+
+//{
+//char buf[100];
+//wsprintf(buf, "GetActiveWindwow() = 0x%08lx", (DWORD) GetActiveWindow());
+//OutputDebugString(buf);
+//}
+//{
+//char buf[60];
+//wsprintf (buf, "fResult = 0x%08lx",
+//                fResult);
+//MessageBox(GetFocus(), buf, "", MB_OK);
+//}
+
+
+
+
+
+
+#if DBG
+
+
+#include "stdarg.h"
+#include "stdio.h"
+
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    static DWORD gdwDebugLevel = 0;   //HACKHACK
+
+
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[256] = "TAPITNA: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[8],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
+
diff --git a/private/tapi/dev/apps/tapitna/tapitna.def b/private/tapi/dev/apps/tapitna/tapitna.def
new file mode 100644
index 000000000..62ac19e6b
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/tapitna.def
@@ -0,0 +1,10 @@
+NAME         TLocMgr
+
+DESCRIPTION  'Microsoft Windows Telephony Location Manager'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     4024
+STACKSIZE    7120
+
diff --git a/private/tapi/dev/apps/tapitna/tapitna.h b/private/tapi/dev/apps/tapitna/tapitna.h
new file mode 100644
index 000000000..8cc708c18
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/tapitna.h
@@ -0,0 +1,46 @@
+#if !defined(tapitna_h)
+#define tapitna_h
+
+#define IDM_CONTEXTMENU 203
+#define IDM_DIALINGPROPERTIES    204
+#define IDM_OTHERMENUITEM        205
+#define IDM_LOCATIONMENU         206
+#define IDM_LAUNCHDIALER         207
+#define IDM_CLOSEIT              208
+#define IDM_ABOUT                209
+#define IDM_PROPERTIES           210
+
+
+//*** *** ***WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
+//*** *** ***WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
+//*** *** ***WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
+
+//This value is a base.  A menu is dynamically created with as many menuitems
+//as there are locations.  The menuid starts with IDM_LOCATION0 and is
+//incremented for each.  So, don't use any values above 700 (for how many?).
+
+#define IDM_LOCATION0   700
+
+//*** *** ***WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
+//*** *** ***WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
+//*** *** ***WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
+
+
+#define IDS_CAPTION               401
+#define IDS_SELECTNEWLOCATION     402
+#define IDS_ABOUTTEXT             403
+#define IDS_LOCATIONCHANGED       404
+#define ALTDATA                   405
+#define IDS_CANTFINDLOCATIONID    406
+#define IDS_CANTFINDLOCATIONNAME  407
+#define IDS_HELP                  408
+
+
+#define IDI_TAPITNAICON  501
+
+
+#define IDR_RBUTTONMENU 601
+
+
+
+#endif
diff --git a/private/tapi/dev/apps/tapitna/tapitna.ico b/private/tapi/dev/apps/tapitna/tapitna.ico
new file mode 100644
index 000000000..44ccbca29
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/tapitna.ico
diff --git a/private/tapi/dev/apps/tapitna/tapitna.rc b/private/tapi/dev/apps/tapitna/tapitna.rc
new file mode 100644
index 000000000..07bf578f9
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/tapitna.rc
@@ -0,0 +1,89 @@
+#include "windows.h"
+#include "tapitna.h"
+
+STRINGTABLE
+BEGIN
+//  IDS_TITLE      "Telephony Location Selector"
+  IDS_CAPTION,   "Telephony Location Manager"
+  IDS_ABOUTTEXT, "Telephony Location Manager - Version 1.0"
+  IDS_SELECTNEWLOCATION,   "I am dialing from "
+  IDS_LOCATIONCHANGED,    "The location has been automatically changed.\r\n   Previous Location: %s\r\n   Current Location:  %s"
+
+  IDS_CANTFINDLOCATIONID    "The location ID [%ld] does not exist."
+  IDS_CANTFINDLOCATIONNAME  "The location [%s] does not exist."
+
+IDS_HELP "Usage:\r\n\r\nTLOCMGR [ /i xxx | /n nnn ]  [ /x ]\r\n\r\n/n  xxxx\tSet Telephony Location to existing name: xxxx\r\n/i nn\tSet Telephony Location to existing ID: nn\r\n/x\tExit immediately after setting new location"
+//IDS_HELP "\r\n-?       Display usage list (this list)\r\n-N xxxx  Set Telephony Location to existing name: xxxx\r\n-I nnn   Set Telephony Location to existing ID: nnn\r\n-X       Exit immediately after setting new location"
+//         "Microsoft (R) Telephony Location Manager Version 1.00.0.0000" \
+//         "Copyright (c) Microsoft Corp. 1996.  All rights reserved.\r\n" \
+//         "\r\n" \
+
+
+
+END
+ALTDATA RCDATA DISCARDABLE
+BEGIN
+0x6378,0x7463,0x1f41,0x6e71,0x1f65,0x6872,0x411f,0
+END
+IDR_RBUTTONMENU MENU DISCARDABLE
+BEGIN
+   POPUP ""
+   BEGIN
+      MENUITEM "Start Phone Dialer", IDM_LAUNCHDIALER
+//      MENUITEM "This space for rent", IDM_OTHERMENUITEM
+      MENUITEM "About", IDM_ABOUT
+      MENUITEM "Exit", IDM_CLOSEIT
+      MENUITEM SEPARATOR
+
+#ifdef NASHVILLE_BUILD_FLAG
+#else
+      MENUITEM "HOTDOCK Properties", IDM_PROPERTIES
+#endif
+      MENUITEM "Dialing Properties", IDM_DIALINGPROPERTIES
+   END
+END
+
+
+
+// /////////////////////////////////////////////////////////////////////////
+
+#include  "general.rc"
+
+// /////////////////////////////////////////////////////////////////////////
+
+#if WINNT
+IDI_TAPITNAICON         ICON    DISCARDABLE     "TAPITNA.ICO"
+#else
+IDI_TAPITNAICON         ICON    DISCARDABLE     "..\\TAPITNA.ICO"
+#endif
+
+
+// /////////////////////////////////////////////////////////////////////////
+
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony Location Manager"
+#define VER_INTERNALNAME_STR        "TLocMgr"
+#define VER_ORIGINALFILENAME_STR    "TLOCMGR.EXE"
+//#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1996.  All Rights Reserved."
+#define VER_LEGALCOPYRIGHT_YEARS    "1996"
+
+#undef VER_PRODUCTVERSION
+#undef VER_PRODUCTVERSION_STR
+#define VER_PRODUCTVERSION      1.00.0.0000
+#define VER_PRODUCTVERSION_STR "1.00.0.0000"
+
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
diff --git a/private/tapi/dev/apps/tapitna/tlocmgr.inf b/private/tapi/dev/apps/tapitna/tlocmgr.inf
new file mode 100644
index 000000000..afbc5c54c
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/tlocmgr.inf
@@ -0,0 +1,52 @@
+[version]
+signature="$CHICAGO$"
+
+[DefaultInstall]
+CopyFiles = TLocMgr.Files.Sys, TLocMgr.Files.Inf
+AddReg    = TLocMgr.Add.Reg
+
+[TLocMgrInstall]
+CopyFiles = TLocMgr.Files.Sys, TLocMgr.Files.Inf
+AddReg    = TLocMgr.Add.Reg
+
+[DefaultUninstall]
+DelFiles  = TLocMgr.Files.Sys, TLocMgr.Files.Inf
+DelReg    = TLocMgr.Del.Reg
+
+[DestinationDirs]
+TLocMgr.Files.Sys = 11
+TLocMgr.Files.Inf = 17
+
+[SourceDisksNames]
+1="TLocMgr","",1
+
+[SourceDisksFiles]
+TLocMgr.EXE=1
+TLocMgr.INF=1
+
+[TLocMgr.Files.Sys]
+TLocMgr.EXE
+
+[TLocMgr.Files.Inf]
+TLocMgr.INF
+
+[Strings]
+TLocMgr_DESC = "Telephony Location Manager"
+TLocMgr_REMOVE_DESC = "Telephony Location Manager (Remove only)"
+
+[TLocMgr.Add.Reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\Uninstall\TLocMgr,DisplayName,,"%TLocMgr_REMOVE_DESC%"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Uninstall\TLocMgr,UninstallString,,"%10%\rundll.exe setupx.dll,InstallHinfSection DefaultUninstall 132 %17%\TLocMgr.inf"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Run,%TLocMgr_DESC%,,"%11%\TLocMgr.EXE"
+HKLM,Software\Microsoft\Windows\CurrentVersion\RunOnce,%TLocMgr_DESC%,,"start %11%\TLocMgr.EXE -ConfigMe"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,AutoLaunchFlags,3,0x1f
+
+[TLocMgr.Del.Reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,AutoLaunchFlags
+HKLM,Config\0001\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0002\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0003\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0004\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Software\Microsoft\Windows\CurrentVersion\Uninstall\TLocMgr
+HKLM,Software\Microsoft\Windows\CurrentVersion\Run,%TLocMgr_DESC%
+
diff --git a/private/tapi/dev/apps/tapitna/ver.10/online.xls b/private/tapi/dev/apps/tapitna/ver.10/online.xls
new file mode 100644
index 000000000..b41e099e5
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/ver.10/online.xls
diff --git a/private/tapi/dev/apps/tapitna/ver.10/readme.txt b/private/tapi/dev/apps/tapitna/ver.10/readme.txt
new file mode 100644
index 000000000..7874471a1
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/ver.10/readme.txt
@@ -0,0 +1,139 @@
+Microsoft Windows 95 Power Toys Readme
+Copyright Microsoft Corporation, 10/19/95
+
+-------------
+WHAT'S NEW:
+-------------
+2/18/96 New PowerToy! TLocMgr (Telephony Location Manager) enables mobile computer users to change their dialing location from a handy icon in the taskbar (or automatically, if you have a laptop that has hot-docking).
+1/17/96 New PowerToy! HTML Printer driver enables you to print HTML documents (web pages!) from any application
+1/17/96 Small fixes to install/uninstall of QuickRes, Fast Folder Contents, Shortcut Target Menu
+
+10/25/95 XMouse 1.10 changes from 1.0: a. works when installedLong File Name directory. b.
+Doesn't move focus while a menu is up. c. Adds "Reaction time" configuration.
+
+10/19/95  TweakUI 0.95  New Powertoy for "type A" personalities. You've just got to see it to believe it! 
+
+10/5/95 QuickRes 2.1, fixes several bugs, changes UI to improve ease-of-use. New version does not expire.
+
+8/9/95. Content 1.0, incorporates new ShellFix.dll, fixes "wide menu" problem.
+
+8/9/95. APlayExt, replaces CDPlay, incorporates ShellFix.dll
+
+8/16/95. FlexiCD 4.3, adds support for a command line argument /resume. When you re-install, the link in your startup group has this command line. If you setup a hotkey for this link you can now pause/resume the CD player from the keyboard.
+
+---------------------
+WELCOME to POWERTOYS
+---------------------
+This folder contains a series of "PowerToys"-- UI enhancements for advanced Windows 95 users that can easily be installed on Windows 95.
+
+These enhancements were developed by members of the Microsoft Win95 team, and are now being made available to Win95 users at no cost. NOTE: these are not part of any shipping retail product at this point in time, and therefore are not supported through any official support channels. Use "at your own risk". (See official disclaimer below.)
+
+The contents of this folder will be updated over time as we make enhancements to the utilities you see here now, and as we add new utilities for people to try out. Stop back every now and then and see what's changed.
+
+Here's what's available now:
+
+*** HTML Printer Driver
+
+New PowerToy! HTML Printer driver enables you to print HTML documents (web pages!) from any application. 
+Please read 'HTMLdrv.txt' for more information.
+
+
+*** TLocMgr - the Telephony Location Manager
+
+If you use any telephone applications from several locations (e.g. Dial-Up Networking from a laptop computer) this powertoy is a must!
+Double-click the TLocMgr icon or place a shortcut to it in your Start menu.
+An icon will appear in your Taskbar notification area (near the clock)
+A menu from this icon enables you quick access to:
+	+) change your current TAPI location (via left-click)
+	+) bring up dialing properties (via right-click)
+	+) run Phone Dialer (via right-click)
+
+
+*** TweakUI
+
+TweakUI is the handy Control Panel for "Type A" personalities. With TweakUI, you can change:
+--menu speed
+--mouse sensitivity
+--window animation and sound
+--shortcut appearance and default names
+--which icons appear on your desktop
+--create new templates
+--boot parameters including whether or not to start the graphic user interface
+--and there's more!!!!!
+
+Please give it a try
+
+*** FAST FOLDER CONTENTS
+
+With this handy-dandy context-menu extension, when you right-click on any folder or other container, you'll get a cascade menu that shows you all the contents of that folder, one-level deep. It works on shortcuts-to-folders, too.
+
+PENDING CHANGES/FIXES: None.
+
+
+*** FLEXI CD
+
+FlexiCD is a taskbar notification icon that makes controlling audio CDs a breeze. When an audio CD is in your drive, FlexiCD gives you convenient single-click play/pause control, a tooltip that tells you which track and time you're on, and a right-click menu that provides commands for starting, stopping, ejecting and moving around the tracks on your CD.
+
+
+*** CABFILE VIEWER
+
+You know those *.CAB files that you'll find on the Win95 CD and floppies? (These are files containing one or more compressed files.) Well, with the CABFILE Viewer shell extension, you can browse right into a CAB file and see all of its contents, and perform normal shell operations on the files inside.
+
+
+*** ROUND CLOCK
+
+This version of CLOCK.EXE takes advantage of win95's region windows, so your analog clock will be round, just like a real clock would. To see it in action, run Clock, then choose "Analog" and "No Title". (Note.. you just need to copy this EXE to use the clock. No setup file is provided.)
+
+
+*** EXPLORE FROM HERE   
+
+This is a simple custom command for all folders and containers that lets you right-click and choose "Explore from Here" to get an Explorer window that has the target folder as its root.
+
+
+*** SHORTCUT TARGET MENU
+
+Finally, you can get the properties for a shortcut's target just by right-clicking the shortcut. This extension will add to any shortcut's context menu the complete context menu of its target.
+
+
+*** XMOUSE
+
+For all of the CS majors in the audience-- make the focus follow the mouse without clicking, a la X Windows. TIP: To turn it off, use the control panel.
+
+
+*** QUICKRES
+
+Here's one we wish was built right in: change DPI and bit depth without rebooting. QuickRes lives in the notification area-- just single-click (right OR left) on it to select your new display settings. Does not have an expiration date, but only runs on Windows 95.
+
+
+Installing the PowerToys 
+------------------------
+1.Create a folder for the PowerToys: Right-click on the desktop and choose New:Folder from the pop-up menu. Name the folder "Power". 
+
+2.Download the PowerToys: Click the link on the PowerToy page to download the file "PowerToy.exe". Save it in the Power folder you just created. 
+
+3.De-compress the file "PowerToy.exe": Open the Power folder and double-click the file "PowerToy.EXE". This will create several new files in your Power folder. 
+
+4.Install the PowerToys: Find the new file called "Install". Right-click it, then choose Install. 
+
+
+Uninstalling the PowerToys 
+--------------------------
+1.Open the control panel: On the Start Menu, choose Settings->Control Panel. 
+
+2.Open "Add/Remove Programs": Find the Control Panel called Add/Remove Programs and double-click it. 
+
+3.Remove PowerToys: Select the PowerToy you want to uninstall on the list, then click the button marked "Add/Remove". 
+
+LET US KNOW WHAT YOU THINK
+--------------------------
+To send us your comments or feedback, click the "Feedback" button at the bottom of the PowerToy page at http://www.microsoft.com/windows/software/PowerToy.htm.
+
+
+Thanks!
+- the Win95 shell team
+
+
+
+LIABILITY DISCLAIMER -- READ BEFORE INSTALLING THE POWERTOYS:
+
+The PowerToy software and documentation is provided for your personal use and may not be distributed.  The entire risk arising out of the use or performance of such products and documentation remains with you.  In no event shall Microsoft or its suppliers be liable for any damages whatsoever (including, without limitation, damages for loss of business profits, business interruption, loss of business information, or other pecuniary loss) arising out of the use of or inability to use the products or documentation, even if Microsoft has been advised of the possibility of such damages. Because some states/jurisdictions do not allow the exclusion or limitation of liability for consequential or incidental damages, the above limitation may not apply to you.
diff --git a/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.cdf b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.cdf
new file mode 100644
index 000000000..b0d0e9a21
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.cdf
diff --git a/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.inf b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.inf
new file mode 100644
index 000000000..4ed497a3a
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.inf
@@ -0,0 +1,50 @@
+[version]
+signature="$CHICAGO$"
+
+[DefaultInstall]
+CopyFiles = TLocMgr.Files.Sys, TLocMgr.Files.Inf
+AddReg    = TLocMgr.Add.Reg
+
+[TLocMgrInstall]
+CopyFiles = TLocMgr.Files.Sys, TLocMgr.Files.Inf
+AddReg    = TLocMgr.Add.Reg
+
+[DefaultUninstall]
+DelFiles  = TLocMgr.Files.Sys, TLocMgr.Files.Inf
+DelReg    = TLocMgr.Del.Reg
+
+[DestinationDirs]
+TLocMgr.Files.Sys = 10,Desktop
+TLocMgr.Files.Inf = 17
+
+[SourceDisksNames]
+1="TLocMgr","",1
+
+[SourceDisksFiles]
+TLocMgr.EXE=1
+TLocMgr.INF=1
+
+[TLocMgr.Files.Sys]
+TLocMgr.EXE
+
+[TLocMgr.Files.Inf]
+TLocMgr.INF
+
+[Strings]
+TLocMgr_DESC = "Telephony Location Manager"
+TLocMgr_REMOVE_DESC = "Telephony Location Manager (Remove only)"
+
+[TLocMgr.Add.Reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\Uninstall\TLocMgr,DisplayName,,"%TLocMgr_REMOVE_DESC%"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Uninstall\TLocMgr,UninstallString,,"%10%\rundll.exe setupx.dll,InstallHinfSection DefaultUninstall 132 %17%\TLocMgr.inf"
+HKLM,Software\Microsoft\Windows\CurrentVersion\RunOnce,%TLocMgr_DESC%,,"start %10%\Desktop\TLocMgr.EXE -ConfigMe"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,AutoLaunchFlags,3,0x1f
+
+[TLocMgr.Del.Reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,AutoLaunchFlags
+HKLM,Config\0001\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0002\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0003\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0004\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Software\Microsoft\Windows\CurrentVersion\Uninstall\TLocMgr
+
diff --git a/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.map b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.map
new file mode 100644
index 000000000..e3ca8a5c5
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.map
@@ -0,0 +1,139 @@
+ TLocMgr
+
+ Timestamp is 3117ed0e (Tue Feb 06 16:06:38 1996)
+
+ Preferred load address is 00400000
+
+ Start         Length     Name                   Class
+ 0001:00000000 0000003dH .rdata                  CODE
+ 0001:00000040 0000183eH .text                   CODE
+ 0001:00001880 00000034H .edata                  CODE
+ 0002:00000000 000002f4H .bss                    DATA
+ 0002:000002f4 00000235H .data                   DATA
+ 0003:00000000 00000078H .idata$2                DATA
+ 0003:00000078 00000028H .idata$3                DATA
+ 0003:000000a0 00000120H .idata$4                DATA
+ 0003:000001c0 00000120H .idata$5                DATA
+ 0003:000002e0 00000486H .idata$6                DATA
+ 0004:00000000 00000238H .rsrc$01                DATA
+ 0004:00000240 000010a8H .rsrc$02                DATA
+
+  Address         Publics by Value              Rva+Base   Lib:Object
+
+ 0001:00000040       _MachineHasMultipleHWProfiles 00401040 f tapitna.obj
+ 0001:000000b0       _SaveNewLocation           004010b0 f tapitna.obj
+ 0001:00000130       _TapiCallbackProc@24       00401130 f tapitna.obj
+ 0001:00000240       _ChangeTapiLocation        00401240 f tapitna.obj
+ 0001:00000450       _SkipSpaces                00401450 f tapitna.obj
+ 0001:00000470       _WinMain@16                00401470 f tapitna.obj
+ 0001:00000950       _MainWndProc@16            00401950 f tapitna.obj
+ 0001:00001010       _GetTranslateCaps          00402010 f general.obj
+ 0001:000010e0       _FillConfigProfileBox      004020e0 f general.obj
+ 0001:000012f0       _GeneralDlgProc@16         004022f0 f general.obj
+ 0001:00001860       _lineSetCurrentLocation@8  00402860 f tapi32:TAPI32.dll
+ 0001:00001866       _lineInitialize@20         00402866 f tapi32:TAPI32.dll
+ 0001:0000186c       _lineShutdown@4            0040286c f tapi32:TAPI32.dll
+ 0001:00001872       _lineTranslateDialog@20    00402872 f tapi32:TAPI32.dll
+ 0001:00001878       _lineGetTranslateCaps@12   00402878 f tapi32:TAPI32.dll
+ 0002:00000010       _gdwConfigProfiles         00403010   <common>
+ 0002:00000020       _buf                       00403020   <common>
+ 0002:00000184       _i                         00403184   <common>
+ 0002:00000190       _buf2                      00403190   <common>
+ 0002:000002f4       _lpdwLocationIDs           004032f4   tapitna.obj
+ 0002:000002f8       _ghLineApp                 004032f8   tapitna.obj
+ 0002:00000404       _gszCurrentProfileKey      00403404   general.obj
+ 0002:00000430       _gszStaticProfileKey       00403430   general.obj
+ 0002:00000468       _gszAutoLaunchKey          00403468   general.obj
+ 0002:0000049c       _gszAutoLaunchValue        0040349c   general.obj
+ 0002:000004ac       _gszAutoLocationID         004034ac   general.obj
+ 0002:000004bc       _gnNumConfigProfiles       004034bc   general.obj
+ 0003:00000000       __IMPORT_DESCRIPTOR_KERNEL32 00404000   kernel32:KERNEL32.dll
+ 0003:00000014       __IMPORT_DESCRIPTOR_USER32 00404014   user32:USER32.dll
+ 0003:00000028       ADVAPI32_IMPORT_DESCRIPTOR 00404028   advapi32:ADVAPI32.dll
+ 0003:0000003c       __IMPORT_DESCRIPTOR_COMCTL32 0040403c   comctl32:COMCTL32.dll
+ 0003:00000050       __IMPORT_DESCRIPTOR_TAPI32 00404050   tapi32:TAPI32.dll
+ 0003:00000064       __IMPORT_DESCRIPTOR_SHELL32 00404064   shell32:SHELL32.dll
+ 0003:00000078       __NULL_IMPORT_DESCRIPTOR   00404078   kernel32:KERNEL32.dll
+ 0003:0000008c       NULL_IMPORT_DESCRIPTOR     0040408c   advapi32:ADVAPI32.dll
+ 0003:000001c0       __imp__RegQueryValueExA@24 004041c0   advapi32:ADVAPI32.dll
+ 0003:000001c4       __imp__RegOpenKeyExA@20    004041c4   advapi32:ADVAPI32.dll
+ 0003:000001c8       __imp__RegCloseKey@4       004041c8   advapi32:ADVAPI32.dll
+ 0003:000001cc       __imp__RegCreateKeyExA@36  004041cc   advapi32:ADVAPI32.dll
+ 0003:000001d0       __imp__RegSetValueExA@24   004041d0   advapi32:ADVAPI32.dll
+ 0003:000001d4       \177ADVAPI32_NULL_THUNK_DATA 004041d4   advapi32:ADVAPI32.dll
+ 0003:000001d8       __imp__CreatePropertySheetPageA@4 004041d8   comctl32:COMCTL32.dll
+ 0003:000001dc       __imp__PropertySheetA@4    004041dc   comctl32:COMCTL32.dll
+ 0003:000001e0       \177COMCTL32_NULL_THUNK_DATA 004041e0   comctl32:COMCTL32.dll
+ 0003:000001e4       __imp__lstrcmpiA@8         004041e4   kernel32:KERNEL32.dll
+ 0003:000001e8       __imp__lstrcpyA@8          004041e8   kernel32:KERNEL32.dll
+ 0003:000001ec       __imp__GetCommandLineA@0   004041ec   kernel32:KERNEL32.dll
+ 0003:000001f0       __imp__lstrlenA@4          004041f0   kernel32:KERNEL32.dll
+ 0003:000001f4       __imp__LocalAlloc@8        004041f4   kernel32:KERNEL32.dll
+ 0003:000001f8       __imp__LockResource@4      004041f8   kernel32:KERNEL32.dll
+ 0003:000001fc       __imp__LoadResource@8      004041fc   kernel32:KERNEL32.dll
+ 0003:00000200       __imp__FindResourceA@12    00404200   kernel32:KERNEL32.dll
+ 0003:00000204       __imp__GlobalLock@4        00404204   kernel32:KERNEL32.dll
+ 0003:00000208       __imp__LocalFree@4         00404208   kernel32:KERNEL32.dll
+ 0003:0000020c       __imp__GlobalAlloc@8       0040420c   kernel32:KERNEL32.dll
+ 0003:00000210       __imp__GlobalFree@4        00404210   kernel32:KERNEL32.dll
+ 0003:00000214       __imp__GlobalHandle@4      00404214   kernel32:KERNEL32.dll
+ 0003:00000218       __imp__GlobalUnlock@4      00404218   kernel32:KERNEL32.dll
+ 0003:0000021c       __imp__GetModuleHandleA@4  0040421c   kernel32:KERNEL32.dll
+ 0003:00000220       __imp__Sleep@4             00404220   kernel32:KERNEL32.dll
+ 0003:00000224       __imp__RegisterServiceProcess@8 00404224   kernel32:KERNEL32.dll
+ 0003:00000228       \177KERNEL32_NULL_THUNK_DATA 00404228   kernel32:KERNEL32.dll
+ 0003:0000022c       __imp__ShellExecuteA@24    0040422c   shell32:SHELL32.dll
+ 0003:00000230       __imp__ShellAboutA@16      00404230   shell32:SHELL32.dll
+ 0003:00000234       __imp__Shell_NotifyIconA@8 00404234   shell32:SHELL32.dll
+ 0003:00000238       \177SHELL32_NULL_THUNK_DATA 00404238   shell32:SHELL32.dll
+ 0003:0000023c       __imp__lineGetTranslateCaps@12 0040423c   tapi32:TAPI32.dll
+ 0003:00000240       __imp__lineTranslateDialog@20 00404240   tapi32:TAPI32.dll
+ 0003:00000244       __imp__lineShutdown@4      00404244   tapi32:TAPI32.dll
+ 0003:00000248       __imp__lineInitialize@20   00404248   tapi32:TAPI32.dll
+ 0003:0000024c       __imp__lineSetCurrentLocation@8 0040424c   tapi32:TAPI32.dll
+ 0003:00000250       \177TAPI32_NULL_THUNK_DATA 00404250   tapi32:TAPI32.dll
+ 0003:00000254       __imp__TrackPopupMenuEx@24 00404254   user32:USER32.dll
+ 0003:00000258       __imp__SetMenuDefaultItem@12 00404258   user32:USER32.dll
+ 0003:0000025c       __imp__GetSubMenu@8        0040425c   user32:USER32.dll
+ 0003:00000260       __imp__RemoveMenu@12       00404260   user32:USER32.dll
+ 0003:00000264       __imp__CreatePopupMenu@0   00404264   user32:USER32.dll
+ 0003:00000268       __imp__LoadMenuA@8         00404268   user32:USER32.dll
+ 0003:0000026c       __imp__DefWindowProcA@16   0040426c   user32:USER32.dll
+ 0003:00000270       __imp__LoadImageA@24       00404270   user32:USER32.dll
+ 0003:00000274       __imp__PostQuitMessage@4   00404274   user32:USER32.dll
+ 0003:00000278       __imp__SendMessageA@16     00404278   user32:USER32.dll
+ 0003:0000027c       __imp__GetDlgItem@8        0040427c   user32:USER32.dll
+ 0003:00000280       __imp__GetKeyState@4       00404280   user32:USER32.dll
+ 0003:00000284       __imp__RegisterClassA@4    00404284   user32:USER32.dll
+ 0003:00000288       __imp__CheckDlgButton@12   00404288   user32:USER32.dll
+ 0003:0000028c       __imp__WinHelpA@16         0040428c   user32:USER32.dll
+ 0003:00000290       __imp__GetFocus@0          00404290   user32:USER32.dll
+ 0003:00000294       __imp__PostMessageA@16     00404294   user32:USER32.dll
+ 0003:00000298       __imp__DestroyWindow@4     00404298   user32:USER32.dll
+ 0003:0000029c       __imp__GetMessageA@16      0040429c   user32:USER32.dll
+ 0003:000002a0       __imp__TranslateMessage@4  004042a0   user32:USER32.dll
+ 0003:000002a4       __imp__DispatchMessageA@4  004042a4   user32:USER32.dll
+ 0003:000002a8       __imp__wsprintfA           004042a8   user32:USER32.dll
+ 0003:000002ac       __imp__MessageBoxA@16      004042ac   user32:USER32.dll
+ 0003:000002b0       __imp__LoadStringA@16      004042b0   user32:USER32.dll
+ 0003:000002b4       __imp__SetForegroundWindow@4 004042b4   user32:USER32.dll
+ 0003:000002b8       __imp__TrackPopupMenu@28   004042b8   user32:USER32.dll
+ 0003:000002bc       __imp__DestroyMenu@4       004042bc   user32:USER32.dll
+ 0003:000002c0       __imp__LoadIconA@8         004042c0   user32:USER32.dll
+ 0003:000002c4       __imp__CreateWindowExA@48  004042c4   user32:USER32.dll
+ 0003:000002c8       __imp__ShowWindow@8        004042c8   user32:USER32.dll
+ 0003:000002cc       __imp__GetParent@4         004042cc   user32:USER32.dll
+ 0003:000002d0       __imp__EnableWindow@8      004042d0   user32:USER32.dll
+ 0003:000002d4       __imp__GetCursorPos@4      004042d4   user32:USER32.dll
+ 0003:000002d8       __imp__AppendMenuA@16      004042d8   user32:USER32.dll
+ 0003:000002dc       \177USER32_NULL_THUNK_DATA 004042dc   user32:USER32.dll
+
+ entry point at        0001:00000470
+
+ Static symbols
+
+ 0001:000008a0       _InitApplication           004018a0 f tapitna.obj
+ 0001:000008f0       _InitInstance              004018f0 f tapitna.obj
+
+FIXUPS: 2041 68 3aa 2b ffffec43 b8 18 3f 50 d1 23 17c 10 46 4d 93 26 7a
+FIXUPS: 1684 3d b8 55 4e 63 228 68 b7 45 35f 13
diff --git a/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.sym b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.sym
new file mode 100644
index 000000000..fa8419402
--- /dev/null
+++ b/private/tapi/dev/apps/tapitna/ver.10/tlocmgr.sym
diff --git a/private/tapi/dev/apps/tapiupr/dagger.inf b/private/tapi/dev/apps/tapiupr/dagger.inf
new file mode 100644
index 000000000..8033b99ee
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/dagger.inf
@@ -0,0 +1,46 @@
+[version]
+signature="$CHICAGO$"
+
+[DefaultInstall]
+CopyFiles = Tapi32.DLL TapiSrv.EXE Telephon.CPL
+AddReg    = Dagger.Add.Reg
+
+[DaggerInstall]
+CopyFiles = Tapi32.DLL TapiSrv.EXE Telephon.CPL
+AddReg    = Dagger.Add.Reg
+
+[DefaultUninstall]
+CopyFiles = Tapi32.DLL TapiSrv.EXE Telephon.CPL
+DelReg    = Dagger.Del.Reg
+
+[DestinationDirs]
+Dagger.Files.Sys = 11
+Dagger.Files.Inf = 17
+
+[SourceDisksNames]
+1="Dagger","",1
+
+[SourceDisksFiles]
+Dagger.EXE=1
+Dagger.INF=1
+
+[Dagger.Files.Sys]
+Tapi32.DLL TapiSrv.EXE Telephon.CPL
+
+[Dagger.Files.Inf]
+Dagger.INF
+
+[Strings]
+Dagger_DESC = "Telephony Setup INF"
+
+[Dagger.Add.Reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\RunOnce\Setup,%Dagger_DESC%,,"start %11%\tapiupr.EXE"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,AutoLaunchFlags,3,0x1f
+
+[Dagger.Del.Reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,AutoLaunchFlags
+HKLM,Config\0001\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0002\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0003\System\CurrentControlSet\Control\Telephony,AutoLocationID
+HKLM,Config\0004\System\CurrentControlSet\Control\Telephony,AutoLocationID
+
diff --git a/private/tapi/dev/apps/tapiupr/depend.mk b/private/tapi/dev/apps/tapiupr/depend.mk
new file mode 100644
index 000000000..e2eadeb78
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/depend.mk
@@ -0,0 +1,3 @@
+.\tapiupr.obj: ..\tapiupr.c
+
+.\tapiupr.res: ..\tapiupr.rc
diff --git a/private/tapi/dev/apps/tapiupr/makefile b/private/tapi/dev/apps/tapiupr/makefile
new file mode 100644
index 000000000..6b4c11cae
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/makefile
@@ -0,0 +1,26 @@
+
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/apps/tapiupr/makefile.def b/private/tapi/dev/apps/tapiupr/makefile.def
new file mode 100644
index 000000000..1501e7342
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/makefile.def
@@ -0,0 +1,54 @@
+##############################################################################
+#
+#   TapiUpr Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+IS_OEM=TRUE
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+
+DEPENDNAME=..\depend.mk
+      
+DRVNAME=TapiUpr
+TARGETS=TapiUpr.exe TapiUpr.sym
+
+SRCDIR=..
+
+DEFENTRY=main
+
+#CONSOLE=1
+
+L32EXE=TapiUpr.exe              # Name of exe.
+#L32DEF=..\TapiUpr.def              # Our def file.
+L32MAP=TapiUpr.map              # Our map file.
+L32LIBS= \
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\advapi32.lib  \
+        $(DEVROOT)\tools\c932\lib\msvcrt.lib
+
+L32RES=TapiUpr.res      # Resource file.
+
+L32OBJS = TapiUpr.obj
+
+
+L32FLAGS=$(L32FLAGS) /MAP
+
+!include $(ROOT)\dev\master.mk
+
+
+INCLUDE=$(INCLUDE);..\..\..\client
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Ox
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/apps/tapiupr/sources b/private/tapi/dev/apps/tapiupr/sources
new file mode 100644
index 000000000..77b4a9cf5
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/sources
@@ -0,0 +1,28 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tapiupr
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS= \
+            $(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+            $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+            $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc
+
+C_DEFINES=-DWINVER=0x0400
+
+USE_CRTDLL=1
+
+SOURCES=tapiupr.c    \
+        tapiupr.rc
+
+
+UMTYPE=windows
+
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/tapiupr/tapi.inx b/private/tapi/dev/apps/tapiupr/tapi.inx
new file mode 100644
index 000000000..c16a28075
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/tapi.inx
@@ -0,0 +1,110 @@
+; TAPI.INF
+;
+; Copyright 1993,1994,1995 Microsoft Corporation
+
+[version]
+;LayoutFile=layout.inf
+signature="$CHICAGO$"
+;SetupClass=BASE
+
+
+
+[DefaultInstall]
+CopyFiles=tapibase.files, MS_TAPI_SYS_CopyFiles, MS_TAPI_HelpFiles
+DelFiles=tapibase.del.files
+AddReg = add.reg
+UpdateInis=UpdateTelephonIni
+[SourceDisksNames]
+1="Tapi","",1
+[SourceDisksFiles]
+tapi.dll=1
+tapi32.dll=1
+tapisrv.exe=1
+tapiupr.exe=1
+telephon.cp$=1
+telephon.cpl=1
+tlocmgr.exe=1
+tsp3216l.tsp=1
+tsp3216s.dll=1
+
+
+
+
+[DestinationDirs]
+MS_TAPI_HelpFiles        = 18    ; LDID_HELP
+MS_TAPI_SYS_CopyFiles    = 11    ; LDID_SYS
+MS_TAPI_CopyFiles        = 10    ; LDID_WIN
+tapibase.files           = 17    ; LDID_INF
+tapibase.del.files       = 25    ; LDID_SHARED
+
+[BaseWinOptions]
+tapibase
+tapi
+
+[tapibase]
+CopyFiles=tapibase.files
+DelFiles=tapibase.del.files
+
+[tapi]
+OptionDesc=%MS_TAPI_Desc%
+CopyFiles=MS_TAPI_SYS_CopyFiles, MS_TAPI_HelpFiles
+AddReg = add.reg
+
+[MS_TAPI_CopyFiles]
+tlocmgr.exe
+
+[MS_TAPI_SYS_CopyFiles]
+tapi.dll
+tapi32.dll
+tapisrv.exe
+tapiupr.exe
+tsp3216l.tsp
+tsp3216s.dll
+telephon.cp$, telephon.cpl
+
+tsp3216s.sym
+tsp3216l.sym
+tapi.sym
+tapi32.sym
+tapisrv.sym
+
+
+[MS_TAPI_HelpFiles]
+telephon.hlp
+
+[tapibase.files]
+tapi.inf
+
+[tapibase.del.files]
+tapi.dll
+tapi32.dll
+tapisrv.exe
+tapiupr.exe
+telephon.cpl
+tsp3216l.tsp
+tsp3216s.dll
+tlocmgr.exe
+telephon.cpl
+telephon.cp$
+telephon.hlp
+
+[add.reg]
+HKLM,Software\Microsoft\Windows\CurrentVersion\RunOnce,TapiSetup,,"tapiupr.exe"
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,,,
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony\Locations,"NextID",1,01,00,00,00
+HKLM,"Software\Microsoft\Windows\CurrentVersion\Telephony\Providers","NumProviders",1,01,00,00,00
+HKLM,"Software\Microsoft\Windows\CurrentVersion\Telephony\Providers","NextID",1,02,00,00,00
+HKLM,"Software\Microsoft\Windows\CurrentVersion\Telephony\Providers","ProviderID0",1,01,00,00,00
+HKLM,"Software\Microsoft\Windows\CurrentVersion\Telephony\Providers","ProviderFilename0",0,"TSP3216l.TSP"
+HKLM,"Software\Microsoft\Windows\CurrentVersion\Telephony\Providers\Provider1","comm/datamodem",1,00,00,00,00
+
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,Tapi32DebugLevel,1,02,00,00,00
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,TapiSrvDebugLevel,1,02,00,00,00
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony,TelephonDebugLevel,1,02,00,00,00
+HKLM,Software\Microsoft\Windows\CurrentVersion\Telephony\Providers\Provider1,DebugLevel,1,02,00,00,00
+
+[UpdateTelephonIni]
+%10%\TELEPHON.INI,Debug,,"TSP3216SDebugLevel=99"
+
+[Strings]
+MS_TAPI_Desc    = "Telephony Support"
diff --git a/private/tapi/dev/apps/tapiupr/tapiupr.c b/private/tapi/dev/apps/tapiupr/tapiupr.c
new file mode 100644
index 000000000..560ab94b8
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/tapiupr.c
@@ -0,0 +1,1021 @@
+#define STRICT
+
+#include <windows.h>
+#include <windowsx.h>
+
+#include "..\..\client\location.h"
+
+
+
+#if DBG
+
+#define DBGOUT(arg) DbgPrt arg
+
+void
+DbgPrt(
+    DWORD  dwDbgLevel,
+    PSTR DbgMessage,
+    ...
+    );
+
+#else
+
+#define DBGOUT(_x_)
+#endif
+
+
+
+
+const TCHAR gszName[]               = "Name";
+const TCHAR gszID[]                 = "ID";
+const TCHAR gszAreaCode[]           = "AreaCode";
+const TCHAR gszCountry[]            = "Country";
+const TCHAR gszOutsideAccess[]      = "OutsideAccess";
+const TCHAR gszLongDistanceAccess[] = "LongDistanceAccess";
+const TCHAR gszFlags[]              = "Flags";
+const TCHAR gszCallingCard[]        = "CallingCard";
+const TCHAR gszDisableCallWaiting[] = "DisableCallWaiting";
+const TCHAR gszTollList[]           = "TollList";
+//const TCHAR gszNumLocations[]       = "NumLocations";
+//const TCHAR gszCurrLocation[]       = "CurrLocation";
+//const TCHAR gszNextLocationID[]     = "NextLocationID";
+
+const TCHAR gszCard[]               = "Card";
+const TCHAR gszPin[]                = "Pin";
+const TCHAR gszCards[]              = "Cards";
+//const TCHAR gszNumCards[]           = "NumCards";
+//const TCHAR gszCurrCard[]           = "CurrCard";
+const TCHAR gszLocalRule[]          = "LocalRule";
+const TCHAR gszLDRule[]             = "LDRule";
+const TCHAR gszInternationalRule[]  = "InternationalRule";
+
+const TCHAR gszNumEntries[]         = "NumEntries";
+const TCHAR gszCurrentID[]          = "CurrentID";
+const TCHAR gszNextID[]             = "NextID";
+
+
+const TCHAR gszEmpty[]     =  "";
+
+const TCHAR gszLocations[] =  "Locations";
+const TCHAR gszLocation[]  =  "Location";
+const TCHAR gszCurrentLocation[] = "CurrentLocation";
+
+
+const TCHAR gszHandoffPriorities[] = "HandoffPriorities";
+
+const TCHAR gszProviders[] = "Providers";
+const TCHAR gszProvider[]  = "Provider%d";
+
+const TCHAR gszTelephonIni[] =  "Telephon.ini";
+
+
+const TCHAR gszTelephony[]    = "Software\\Microsoft\\Windows\\"
+                                "CurrentVersion\\Telephony";
+
+
+void FixPriorityList(HKEY hKeyHandoffPriorities,
+                     LPWSTR pszListName);
+
+#pragma check_stack ( off )
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL ParseSomething( LPCSTR pFormat, LPCSTR pInputString, LPVOID pOutputPtr )
+{
+   BYTE c;
+   LPBYTE pOutput = (LPBYTE)pOutputPtr;
+   LPBYTE pInput = (LPBYTE)pInputString;
+
+
+   while ( (c = *pFormat) && *pInput )
+   {
+#if DBG
+DBGOUT((11, "Inputstring[%s]\r\n   Format[%s]\r\n",
+              pInput, pFormat));
+#endif
+
+      switch ( c )
+      {
+         case 'n':
+         {
+            DWORD dwValue = 0;
+            BYTE bDigit;
+
+            //
+            // Parse value from the string
+            //
+            while ( ((bDigit = *pInput) != '\0') && bDigit != ',' )
+            {
+               dwValue = (dwValue * 10) + ( bDigit - '0' );
+#if DBG
+DBGOUT((11, "val of bDigit=%d dwValue=%ld\r\n", (int)bDigit, dwValue));
+#endif
+
+               bDigit = *(++pInput);
+            }
+
+            *(LPDWORD)pOutput = dwValue;
+
+            pOutput += sizeof(DWORD);
+
+         }
+         break;
+
+
+         case 's':
+         {
+            //
+            // If the caller is looking for a string, the first char
+            // MUST be a quotes.  So, just step past it.
+            //
+            pInput++;
+
+            //
+            // Ok, _now_ we're into the meat of the string (if there _is_
+            // any...)
+            //
+
+            while ( *pInput != '\0' && *pInput != '"' )
+            {
+               *pOutput = *pInput;
+               pOutput++;
+               pInput++;
+            }
+
+            //
+            // Don't forget to put a cap on that thing.
+            //
+            *pOutput = '\0';
+            pOutput++;
+
+            // The input should now be at a ->"<-  if it's not, the ini
+            // file was hosed, and I'm not fixing it.
+            // So, we step past it, and we're done
+            //
+            if ( *pInput == '"' )
+            {
+               pInput++;
+            }
+
+         }
+         break;
+
+
+      }
+
+      //
+      // Step past the comma...
+      //
+      //
+      if ( *pInput == ',' )
+      {
+         pInput++;
+      }
+
+      pFormat++;
+   }
+
+   return TRUE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//VOID __cdecl main( void )
+void main( void )
+{
+
+   DWORD dw;
+   DWORD dwNumEntries;
+   DWORD dwCurrentID;
+   DWORD dwNextID;
+
+   DWORD dwArray[10];
+   BYTE  bBigArray[5120];
+   BYTE  Buffer[5120];  //Might need tons of room for the tolllist...
+   LPBYTE  pSource;
+
+   HKEY  hKey3;
+   HKEY  hKey2;
+   HKEY  hKey;
+   DWORD dwDisposition;
+
+
+   dw = GetPrivateProfileString(
+                               gszCards,
+                               gszCards,
+                               gszEmpty,
+                               Buffer,
+                               sizeof(Buffer),
+                               gszTelephonIni
+                             );
+
+
+   //
+   // Is there an existing AND valid TELEPHON.INI file?
+   // There would HAVE TO be at least one card.  The SYSTEM cards cannot
+   // be deleted, only hidden.
+   //
+   if ( 0 != dw )
+   {
+
+
+
+//[Cards]
+//Cards=23,23
+//Card0=0,"None (Direct Dial)","","","","",1
+//Card1=1,"AT&T Direct Dial via 10ATT1","","G","102881FG","10288011EFG",1
+#define	CARD_INI_ID			(0)
+#define	CARD_INI_NAME		(1)
+#define CARD_INI_SNUMBER	(2)
+#define	CARD_INI_SARULE		(3)
+#define	CARD_INI_LDRULE		(4)
+#define	CARD_INI_INTNLRULE	(5)
+#define	CARD_INI_HIDDEN		(6)
+
+
+#define	PC_INI_ID			(0)
+#define	PC_INI_NEXTID		(1)
+#define	PC_INI_NAME			(2)
+#define	PC_INI_SARULE		(3)
+#define PC_INI_LDRULE		(4)
+#define	PC_INI_INTNLRULE	(5)
+
+
+      //
+      // Move CARDS entries to registry
+      //
+
+      ParseSomething( "nn", Buffer, &dwArray);
+
+      dwNumEntries = dwArray[0];
+      dwNextID = dwArray[1];
+
+
+      RegCreateKeyEx(
+                      HKEY_CURRENT_USER,
+//BUGBUG   or should this be default user or not at all or what?
+                      gszTelephony,
+                      0,
+                      "",   //Class?  What class?
+                      REG_OPTION_NON_VOLATILE,
+                      KEY_ALL_ACCESS,
+                      0,
+                      &hKey3,
+                      &dwDisposition
+                    );
+
+      RegCreateKeyEx(
+                      hKey3,
+                      gszCards,
+                      0,
+                      "",   //Class?  What class?
+                      REG_OPTION_NON_VOLATILE,
+                      KEY_ALL_ACCESS,
+                      0,
+                      &hKey2,
+                      &dwDisposition
+                    );
+
+      RegSetValueEx(
+                     hKey2,
+                     gszNumEntries,
+                     0,
+                     REG_DWORD,
+                     (LPBYTE)&dwNumEntries,
+                     sizeof(DWORD)
+                   );
+
+      RegSetValueEx(
+                     hKey2,
+                     gszNextID,
+                     0,
+                     REG_DWORD,
+                     (LPBYTE)&dwNextID,
+                     sizeof(DWORD)
+                   );
+
+
+
+      for ( dw=0; dw<dwNumEntries; dw++ )
+      {
+         TCHAR Temp[18];
+
+         wsprintf(Temp, "%s%d", gszCard, dw);
+
+         //
+         // Create the key for this Card
+         //
+         RegCreateKeyEx(
+                         hKey2,
+                         Temp,
+                         0,
+                         "",   //Class?  What class?
+                         REG_OPTION_NON_VOLATILE,
+                         KEY_ALL_ACCESS,
+                         0,
+                         &hKey,
+                         &dwDisposition
+                       );
+
+
+         GetPrivateProfileString(
+                                  gszCards,
+                                  Temp,
+                                  gszEmpty,
+                                  Buffer,
+                                  sizeof(Buffer),
+                                  gszTelephonIni
+                                );
+
+         ParseSomething("nsssssn", Buffer, bBigArray);
+
+
+         pSource = bBigArray;
+
+         RegSetValueEx(
+                        hKey,
+                        gszID,
+                        0,
+                        REG_DWORD,
+                        pSource,
+                        sizeof(DWORD)
+                      );
+         pSource += sizeof(DWORD);
+
+         RegSetValueEx(
+                        hKey,
+                        gszName,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszPin,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszLocalRule,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszLDRule,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszInternationalRule,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszFlags,
+                        0,
+                        REG_DWORD,
+                        pSource,
+                        sizeof(DWORD)
+                      );
+         pSource += sizeof(DWORD);
+
+
+         RegCloseKey( hKey );
+      }
+
+
+      RegCloseKey( hKey2 );
+      RegCloseKey( hKey3 );
+
+
+//---------------------------------------------------------------------------
+
+      GetPrivateProfileString(
+                               gszLocations,
+                               gszCurrentLocation,
+                               gszEmpty,
+                               Buffer,
+                               sizeof(Buffer),
+                               gszTelephonIni
+                             );
+
+      ParseSomething( "nn", Buffer, &dwArray);
+
+      dwCurrentID = dwArray[0];
+//BUGBUG: What's the other one for?
+
+
+      GetPrivateProfileString(
+                               gszLocations,
+                               gszLocations,
+                               gszEmpty,
+                               Buffer,
+                               sizeof(Buffer),
+                               gszTelephonIni
+                             );
+
+      ParseSomething( "nn", Buffer, &dwArray);
+
+      dwNumEntries = dwArray[0];
+      dwNextID = dwArray[1];
+
+
+      RegCreateKeyEx(
+                      HKEY_LOCAL_MACHINE,
+                      gszTelephony,
+                      0,
+                      "",   //Class?  What class?
+                      REG_OPTION_NON_VOLATILE,
+                      KEY_ALL_ACCESS,
+                      0,
+                      &hKey3,
+                      &dwDisposition
+                    );
+
+
+      RegCreateKeyEx(
+                      hKey3,
+                      gszLocations,
+                      0,
+                      "",   //Class?  What class?
+                      REG_OPTION_NON_VOLATILE,
+                      KEY_ALL_ACCESS,
+                      0,
+                      &hKey2,
+                      &dwDisposition
+                    );
+
+
+      RegSetValueEx(
+                     hKey2,
+                     gszCurrentID,
+                     0,
+                     REG_DWORD,
+                     (LPBYTE)&dwCurrentID,
+                     sizeof(DWORD)
+                   );
+
+      RegSetValueEx(
+                     hKey2,
+                     gszNumEntries,
+                     0,
+                     REG_DWORD,
+                     (LPBYTE)&dwNumEntries,
+                     sizeof(DWORD)
+                   );
+
+      RegSetValueEx(
+                     hKey2,
+                     gszNextID,
+                     0,
+                     REG_DWORD,
+                     (LPBYTE)&dwNextID,
+                     sizeof(DWORD)
+                   );
+
+
+
+      for ( dw=0; dw<dwNumEntries; dw++ )
+      {
+         TCHAR Temp[18];
+         DWORD dwFlags = 0;
+
+         wsprintf(Temp, "%s%d", gszLocation, dw);
+
+         //
+         // Create the key for this Location
+         //
+         RegCreateKeyEx(
+                         hKey2,
+                         Temp,
+                         0,
+                         "",   //Class?  What class?
+                         REG_OPTION_NON_VOLATILE,
+                         KEY_ALL_ACCESS,
+                         0,
+                         &hKey,
+                         &dwDisposition
+                       );
+
+
+
+         GetPrivateProfileString(
+                                  gszLocations,
+                                  Temp,
+                                  gszEmpty,
+                                  Buffer,
+                                  sizeof(Buffer),
+                                  gszTelephonIni
+                                );
+
+         ParseSomething("nssssnnnnsns", Buffer, bBigArray);
+//BUGBUG if this is upgrade over 3.1, the last 2 fields don't exist
+
+
+
+//[Locations]
+//CurrentLocation=1,2
+//Locations=3,4
+//Location0=0,"Work","9","9","206",1,0,0,1,"",0,""
+//Location1=3,"RoadHouse","","","215",1,0,0,0,"",0,""
+//Location2=1,"Home","","","206",1,0,0,0,"",0," "
+//	Positions in ini file entries for locations,cards,countries
+//	NOTE: dialing rules are in same positions for locations and cards!
+
+//#define LOC_INI_ID 			(0)
+//#define	LOC_INI_NAME		(1)
+//#define	LOC_INI_LPREFIX		(2)
+//#define LOC_INI_LDPREFIX	(3)
+//#define	LOC_INI_AREACODE	(4)
+//#define	LOC_INI_COUNTRYCODE	(5)
+//#define	LOC_INI_CARDID		(6)
+//#define LOC_INI_CARDHINT	(7)
+//#define	LOC_INI_INSERTAC	(8)
+//#define	LOC_INI_TOLLLIST	(9)
+//
+//#define	LOC_INI_PULSE		(10)
+//#define	LOC_INI_CALLWAITING	(11)
+
+
+         pSource = bBigArray;
+
+         RegSetValueEx(
+                        hKey,
+                        gszID,
+                        0,
+                        REG_DWORD,
+                        pSource,
+                        sizeof(DWORD)
+                      );
+         pSource += sizeof(DWORD);
+
+         RegSetValueEx(
+                        hKey,
+                        gszName,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszOutsideAccess,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszLongDistanceAccess,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszAreaCode,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         RegSetValueEx(
+                        hKey,
+                        gszCountry,
+                        0,
+                        REG_DWORD,
+                        pSource,
+                        sizeof(DWORD)
+                      );
+         pSource += sizeof(DWORD);
+
+
+         //
+         // If the callingcard == 0, it means this location does not
+         // use a calling card.
+         //
+         if ( *(LPDWORD)pSource != 0 )
+         {
+            dwFlags |= LOCATION_USECALLINGCARD;
+         }
+
+         RegSetValueEx(
+                        hKey,
+                        gszCallingCard,
+                        0,
+                        REG_DWORD,
+                        pSource,
+                        sizeof(DWORD)
+                      );
+         pSource += sizeof(DWORD);
+
+
+//BUGBUG What the hell is a CardHint?  Or Insert AC, for that matter?
+         pSource += sizeof(DWORD);
+         pSource += sizeof(DWORD);
+
+
+         RegSetValueEx(
+                        hKey,
+                        gszTollList,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+         //
+         // pSource is currently pointing to the old dwFlags.  However,
+         // the only flag that was used was bit 1 which indicated
+         // tone dialing.  As luck (yeah, right) would have it, we
+         // use bit 1 to indicate tone dialing as well.
+         //
+         dwFlags |= !((*(LPDWORD)pSource) & 1);
+
+         pSource += sizeof(DWORD);
+
+         //
+         // Is there a disablecallwaiting string
+         //
+         dwFlags |= ( lstrlen( pSource ) == 0 ) ?
+                                                  0 :
+                                                  LOCATION_HASCALLWAITING;
+
+         RegSetValueEx(
+                        hKey,
+                        gszDisableCallWaiting,
+                        0,
+                        REG_SZ,
+                        pSource,
+                        lstrlen(pSource)+1
+                      );
+         pSource += lstrlen(pSource)+1;
+
+
+         RegSetValueEx(
+                        hKey,
+                        gszFlags,
+                        0,
+                        REG_DWORD,
+                        (LPBYTE)&dwFlags,
+                        sizeof(DWORD)
+                      );
+         pSource += sizeof(DWORD);
+
+
+         RegCloseKey( hKey );
+      }
+
+//---------------------------------------------------------------------------
+
+
+      //
+      //  If we're on Win95, copy the PROVIDERS entries to the
+      //  registry for TSP3216L.TSP
+      //
+      {
+      }
+
+
+//---------------------------------------------------------------------------
+
+      //
+      // Q: How do we update COUNTRY OVERRIDES?
+      // A: We don't.  We assume we've corrected everything by now...
+      //
+
+
+//      RegCloseKey( hKey );
+      RegCloseKey( hKey2 );
+      RegCloseKey( hKey3 );
+
+   }
+   
+
+   {
+       int      i;
+       HKEY     hKeyHandoffPriorities;
+       WCHAR *gaszMediaModes[] =
+       {
+           L"",
+           L"unknown",
+           L"interactivevoice",
+           L"automatedvoice",
+           L"datamodem",
+           L"g3fax",
+           L"tdd",
+           L"g4fax",
+           L"digitaldata",
+           L"teletex",
+           L"videotex",
+           L"telex",
+           L"mixed",
+           L"adsi",
+           L"voiceview",
+           NULL
+       };
+       
+       WCHAR    *gszRequestMakeCallW = L"RequestMakeCall";
+       WCHAR    *gszRequestMediaCallW = L"RequestMediaCall";
+       WCHAR    *gszRegKeyHandoffPriorities = L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\HandoffPriorities";
+       
+       if (RegOpenKeyExW(
+                        HKEY_CURRENT_USER,
+                        gszRegKeyHandoffPriorities,
+                        0,
+                        KEY_ALL_ACCESS,
+                        &hKeyHandoffPriorities
+
+                       ) == ERROR_SUCCESS)
+       {
+
+
+           for (i = 1; gaszMediaModes[i] != NULL; i++)
+           {
+               FixPriorityList(
+                               hKeyHandoffPriorities,
+                               gaszMediaModes[i]
+                              );
+           }
+
+           FixPriorityList(
+                           hKeyHandoffPriorities,
+                           gszRequestMakeCallW
+                          );
+
+           FixPriorityList(
+                           hKeyHandoffPriorities,
+                           gszRequestMediaCallW
+                          );
+
+
+           RegCloseKey (hKeyHandoffPriorities);
+
+       }
+   }
+         
+
+
+   {
+      //----------------------------------------------------------------------
+      //----------------------------------------------------------------------
+      //----------------------------------------------------------------------
+      //
+      // Now we discuss someone who is upgrading from beta 2 to RTM.  They have
+      // "EVERYONE:FULL CONTROL" access on the LOCATIONS key.  Let's change that
+      // to have the same security as the TELEPHONY key.
+      //
+      
+      SECURITY_INFORMATION SecInf;
+      PSECURITY_DESCRIPTOR pSecDesc;
+      DWORD                cbSecDesc = 65535;
+      
+      
+      pSecDesc = LocalAlloc( LPTR, cbSecDesc );
+      if ( pSecDesc )
+      {
+         
+      
+      
+         RegOpenKeyEx(
+                         HKEY_LOCAL_MACHINE,
+                         gszTelephony,
+                         0,
+                         KEY_ALL_ACCESS,
+                         &hKey
+                       );
+
+         RegCreateKeyEx(
+                         hKey,
+                         gszLocations,
+                         0,
+                         "",   //Class?  What class?
+                         REG_OPTION_NON_VOLATILE,
+                         KEY_ALL_ACCESS,
+                         0,
+                         &hKey2,
+                         &dwDisposition
+                       );
+                       
+         cbSecDesc = 65535;
+         dw = RegGetKeySecurity( hKey,
+                            OWNER_SECURITY_INFORMATION,
+                            pSecDesc,
+                            &cbSecDesc
+                          );
+   
+         if ( ERROR_SUCCESS == dw )
+            RegSetKeySecurity( hKey2,
+                            OWNER_SECURITY_INFORMATION,
+                            pSecDesc
+                          );
+   
+         cbSecDesc = 65535;
+         dw = RegGetKeySecurity( hKey,
+                            GROUP_SECURITY_INFORMATION,
+                            pSecDesc,
+                            &cbSecDesc
+                          );
+   
+         if ( ERROR_SUCCESS == dw )
+            RegSetKeySecurity( hKey2,
+                            GROUP_SECURITY_INFORMATION,
+                            pSecDesc
+                          );
+   
+         cbSecDesc = 65535;
+         dw = RegGetKeySecurity( hKey,
+                            DACL_SECURITY_INFORMATION,
+                            pSecDesc,
+                            &cbSecDesc
+                          );
+   
+         if ( ERROR_SUCCESS == dw )
+            RegSetKeySecurity( hKey2,
+                            DACL_SECURITY_INFORMATION,
+                            pSecDesc
+                          );
+   
+         cbSecDesc = 65535;
+         dw = RegGetKeySecurity( hKey,
+                            SACL_SECURITY_INFORMATION,
+                            pSecDesc,
+                            &cbSecDesc
+                          );
+   
+         if ( ERROR_SUCCESS == dw )
+            RegSetKeySecurity( hKey2,
+                            SACL_SECURITY_INFORMATION,
+                            pSecDesc
+                          );
+   
+   
+         RegCloseKey( hKey );
+         RegCloseKey( hKey2);
+         
+         
+         LocalFree( pSecDesc );
+      }
+   }                          
+
+   
+   return;
+}
+
+void FixPriorityList(HKEY hKeyHandoffPriorities,
+                     LPWSTR pszListName)
+{
+    DWORD   dwType, dwNumBytes;
+    LPWSTR  pszPriorityList, pszHold;
+
+    if (RegQueryValueExW(
+            hKeyHandoffPriorities,
+            pszListName,
+            NULL,
+            &dwType,
+            NULL,
+            &dwNumBytes
+                        ) == ERROR_SUCCESS &&
+
+        (dwNumBytes != 0))
+    {
+        pszPriorityList = (LPWSTR) GlobalAlloc ( GPTR, dwNumBytes );
+
+        if (pszPriorityList)
+        {
+            pszHold = pszPriorityList;
+            
+            if ( RegQueryValueExW(
+                    hKeyHandoffPriorities,
+                    pszListName,
+                    NULL,
+                    &dwType,
+                    (LPBYTE)(pszPriorityList),
+                    &dwNumBytes
+
+                                 ) == ERROR_SUCCESS)
+            {
+                while (*pszPriorityList != L'\0')
+                {
+                    if (*pszPriorityList == L',')
+                    {
+                        *pszPriorityList = L'"';
+                    }
+
+                    pszPriorityList++;
+                }
+
+                pszPriorityList = pszHold;
+
+                RegSetValueExW(
+                               hKeyHandoffPriorities,
+                               pszListName,
+                               0,
+                               REG_SZ,
+                               (LPBYTE)pszPriorityList,
+                               (lstrlenW(pszPriorityList) + 1) * sizeof(WCHAR));
+            }
+
+            GlobalFree(pszPriorityList);
+        }
+    }
+
+}
+
+
+
+#if DBG
+
+
+#include "stdarg.h"
+#include "stdio.h"
+
+
+VOID
+DbgPrt(
+    DWORD  dwDbgLevel,
+    PSTR   lpszFormat,
+    ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    static DWORD gdwDebugLevel = 0;   //HACKHACK
+
+
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[256] = "TAPIUPR: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[8],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
+
+
diff --git a/private/tapi/dev/apps/tapiupr/tapiupr.rc b/private/tapi/dev/apps/tapiupr/tapiupr.rc
new file mode 100644
index 000000000..a33ebcc04
--- /dev/null
+++ b/private/tapi/dev/apps/tapiupr/tapiupr.rc
@@ -0,0 +1,23 @@
+#include "windows.h"
+
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony INI-file Upgrade Utility"
+#define VER_INTERNALNAME_STR        "TapiUpr"
+#define VER_ORIGINALFILENAME_STR    "TAPIUPR.EXE"
+//#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+#define VER_LEGALCOPYRIGHT_YEARS    "1996"
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
diff --git a/private/tapi/dev/apps/tb/depend.mk b/private/tapi/dev/apps/tb/depend.mk
new file mode 100644
index 000000000..e2d724f43
--- /dev/null
+++ b/private/tapi/dev/apps/tb/depend.mk
@@ -0,0 +1,11 @@
+ui.obj:  ui.c vars.h tb.h
+
+tb.obj:  tb.c vars.h tb.h resource.h
+
+vars.obj:  vars.c tb.h
+
+widget.obj:  widget.c vars.h tb.h
+
+tb.res: tb.rc resource.h
+
+
diff --git a/private/tapi/dev/apps/tb/makefile b/private/tapi/dev/apps/tb/makefile
new file mode 100644
index 000000000..23524cb99
--- /dev/null
+++ b/private/tapi/dev/apps/tb/makefile
@@ -0,0 +1,11 @@
+!ifndef NTMAKEENV
+NTMAKEENV=.
+!endif
+
+
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/apps/tb/makefile.def b/private/tapi/dev/apps/tb/makefile.def
new file mode 100644
index 000000000..521b15dad
--- /dev/null
+++ b/private/tapi/dev/apps/tb/makefile.def
@@ -0,0 +1,72 @@
+##############################################################################
+#
+#   Dialer Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+#VERSIONLIST=debug retail
+
+#!ifdef RETAIL
+#DEFAULTVERDIR=retail
+#!else
+#DEFAULTVERDIR=debug
+#!endif
+
+
+IS_OEM=1
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+
+#DEFENTRY=main
+
+#CLEANLIST = *.drv 
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=tb14
+TARGETS=tb14.exe
+
+#VERDIR = debug
+
+SRCDIR=..
+OBJDIR=obj\i386
+
+#INCFILE = ..\dagger.mk
+
+BUILD_COFF=1
+
+
+L32EXE=tb14.exe		# Name of exe.
+L32DEF=tb.def              # Our def file.
+L32MAP=tb14.map		# Our map file.
+L32SYM=tb14.sym		# Our sym file.
+L32LIBS= \
+        $(W32LIBID)\kernel32.lib                  \
+        $(W32LIBID)\comdlg32.lib                  \
+        $(W32LIBID)\user32.lib                    \
+        $(W32LIBID)\gdi32.lib                     \
+        $(DEVROOT)\tools\c932\lib\oldnames.lib    \
+        $(DEVROOT)\tools\c932\lib\crtdll.lib      \
+        $(DEVROOT)\sdk\lib\tapi32.lib
+
+#        $(DEVROOT)\sdk\lib\shell32.lib                 
+
+L32RES=tb.res	# Resource file.
+
+RCFLAGS=-DWIN32=100
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = tb.obj ui.obj vars.obj widget.obj
+
+
+!include $(ROOT)\dev\master.mk
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -DDBG=1
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100
diff --git a/private/tapi/dev/apps/tb/nt.mak b/private/tapi/dev/apps/tb/nt.mak
new file mode 100644
index 000000000..a93df1f2d
--- /dev/null
+++ b/private/tapi/dev/apps/tb/nt.mak
@@ -0,0 +1,27 @@
+!include <ntwin32.mak>
+
+!ifndef  MYDEBUG
+MYDEBUG = 0
+!endif
+
+!if $(MYDEBUG)
+L_FLAGS = $(linkdebug)
+!else
+L_FLAGS =
+!endif
+
+APPLIBS=\telephon\tapi\lib\tapi32.lib
+
+OBJS=ui.obj vars.obj tb.obj widget.obj
+
+all: tb.exe
+
+.c.obj:
+    $(cc) -DTAPI_1_1 $(cdebug) $(cflags) $(cvars) $*.c
+
+tb.rbj: tb.rc
+    $(rc) -DTAPI_1_1 $(rcvars) -r -fo tb.res tb.rc
+    cvtres -$(CPU) tb.res -o tb.rbj
+
+tb.exe: $(OBJS) tb.rbj tb.def
+    $(link) $(L_FLAGS) $(guiflags) -out:tb14.exe $(OBJS) tb.rbj $(APPLIBS) $(guilibsdll)
diff --git a/private/tapi/dev/apps/tb/resource.h b/private/tapi/dev/apps/tb/resource.h
new file mode 100644
index 000000000..90a7e3a9f
--- /dev/null
+++ b/private/tapi/dev/apps/tb/resource.h
@@ -0,0 +1,98 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-95  Microsoft Corporation
+
+Module Name:
+
+    resource.h
+
+NOTE from Testing: 
+  If these values are changed, it will very likely break test automation. Please advise the test
+  team if these values are altered. (peterje)
+
+Abstract:
+
+    Resource header file for the TAPI Browser util
+
+Author:
+
+    Dan Knudson (DanKn)    23-Oct-1994
+
+Revision History:
+
+--*/
+
+
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by TB.RC
+//
+#define IDR_MENU1                       101
+#define IDD_DIALOG1                     102
+#define IDD_DIALOG2                     103
+#define IDD_DIALOG3                     104
+#define IDD_DIALOG4                     105
+#define IDD_DIALOG5                     106
+#define IDD_DIALOG6                     107
+#define IDI_ICON1                       108
+#define IDR_ACCELERATOR1                109
+#define IDC_LIST1                       1000
+#define IDC_LIST2                       1001
+#define IDC_COMBO1                      1002
+#define IDC_EDIT1                       1003
+#define IDC_CLEAR                       1004
+#define IDC_STATIC1                     1005
+#define IDC_BUTTON1                     1006
+#define IDC_BUTTON2                     1007
+#define IDC_BUTTON3                     1008
+#define IDC_BUTTON4                     1009
+#define IDC_BUTTON5                     1010
+#define IDC_BUTTON6                     1011
+#define IDC_BUTTON7                     1012
+#define IDC_BUTTON8                     1013
+#define IDC_BUTTON9                     1014
+#define IDC_BUTTON10                    1015
+#define IDC_BUTTON11                    1016
+#define IDC_BUTTON12                    1017
+#define IDC_BUTTON13                    1018
+#define IDC_BUTTON14                    1019
+#define IDC_BUTTON15                    1020
+#define IDC_BUTTON16                    1021
+#define IDC_BUTTON17                    1022
+#define IDC_BUTTON18                    1023
+#define IDC_TB_HELP                     1024
+#define IDC_F1HELP                      1025
+#define IDC_PREVCTRL                    1026
+#define IDC_NEXTCTRL                    1027
+#define IDC_ENTER                       1028
+#define IDM_DEFAULTVALUES               40001
+#define IDM_ABOUT                       40002
+#define IDM_USINGTB                     40003
+#define IDM_DUMPPARAMS                  40004
+#define IDM_LOGSTRUCTDWORD              40005
+#define IDM_LOGSTRUCTALLFIELD           40006
+#define IDM_LOGSTRUCTNONZEROFIELD       40007
+#define IDM_LOGSTRUCTNONE               40008
+#define IDM_USERBUTTONS                 40009
+#define IDM_LOGFILE                     40010
+#define IDM_CLEAR                       40011
+#define IDM_PARAMS                      40012
+#define IDM_EXIT                        40013
+#define IDM_TAPIHLP                     40014
+#define IDM_TSPIHLP                     40015
+#define IDM_NUKEIDLEMONITORCALLS        40016
+#define IDM_NUKEIDLEOWNEDCALLS          40017
+#define IDM_TIMESTAMP                   40018
+#define IDM_NOHANDLECHK                 40019
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        110
+#define _APS_NEXT_COMMAND_VALUE         40020
+#define _APS_NEXT_CONTROL_VALUE         1029
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/apps/tb/sources b/private/tapi/dev/apps/tb/sources
new file mode 100644
index 000000000..72fbfc5ba
--- /dev/null
+++ b/private/tapi/dev/apps/tb/sources
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tb20
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32l.lib
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=tb.c     \
+        tb2.c    \
+        ui.c     \
+        vars.c   \
+        widget.c \
+        tb.rc
+
+C_DEFINES=-DTAPI_1_1=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/tb/sources.1_4 b/private/tapi/dev/apps/tb/sources.1_4
new file mode 100644
index 000000000..3593d2ff8
--- /dev/null
+++ b/private/tapi/dev/apps/tb/sources.1_4
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tb14
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=tb.c     \
+        tb2.c    \
+        ui.c     \
+        vars.c   \
+        widget.c \
+        tb.rc
+
+C_DEFINES=-DTAPI_1_1=1
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/apps/tb/tb.c b/private/tapi/dev/apps/tb/tb.c
new file mode 100644
index 000000000..72cd628c6
--- /dev/null
+++ b/private/tapi/dev/apps/tb/tb.c
@@ -0,0 +1,3854 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-96  Microsoft Corporation
+
+Module Name:
+
+    tb.c
+
+Abstract:
+
+    API wrapper code for the TAPI Browser util.  Contains the big switch
+    statement for all the supported Telephony API's, & various support funcs.
+
+Author:
+
+    Dan Knudson (DanKn)    23-Aug-1994
+
+Revision History:
+
+--*/
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <malloc.h>
+#include "tb.h"
+#include "vars.h"
+#include "resource.h"
+
+
+char szdwDeviceID[]   = "dwDeviceID";
+char szdwSize[]       = "dwSize";
+char szhCall[]        = "hCall";
+char szhLine[]        = "hLine";
+char szhLineApp[]     = "hLineApp";
+char szhPhone[]       = "hPhone";
+char szlpCallParams[] = "lpCallParams";
+
+char szlphCall[]         = "lphCall";
+char szlpParams[]        = "lpParams";
+char szhwndOwner[]       = "hwndOwner";
+char szdwAddressID[]     = "dwAddressID";
+char szlpszAppName[]     = "lpszAppName";
+char szdwAPIVersion[]    = "APIVersion";
+char szlphConsultCall[]  = "lphConsultCall";
+char szlpszDeviceClass[] = "lpszDeviceClass";
+char szlpszDestAddress[] = "lpszDestAddress";
+char szlpsUserUserInfo[] = "lpsUserUserInfo";
+char szlpszFriendlyAppName[] = "lpszFriendlyAppName";
+
+
+DWORD NullWidget[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+
+void
+FuncDriver2(
+    FUNC_INDEX funcIndex
+    );
+
+
+char *
+PASCAL
+GetTimeStamp(
+    void
+    )
+{
+    static char szEmptyString[] = "", szTimeStamp[32];
+    SYSTEMTIME  systemTime;
+
+
+    if (!bTimeStamp)
+    {
+        return szEmptyString;
+    }
+
+    GetLocalTime (&systemTime);
+
+    wsprintf(
+        szTimeStamp,
+        "%d:%d.%d.%d : ",
+        (DWORD) systemTime.wHour,
+        (DWORD) systemTime.wMinute,
+        (DWORD) systemTime.wSecond,
+        (DWORD) systemTime.wMilliseconds
+        );
+
+    return szTimeStamp;
+}
+
+
+void
+ShowLineFuncResult(
+    LPSTR   lpFuncName,
+    LONG    lResult
+    )
+{
+    char   *pszTimeStamp = GetTimeStamp();
+
+
+    if (lResult > 0)
+    {
+        ShowStr ("%s%s returned x%lx", pszTimeStamp, lpFuncName, lResult);
+    }
+    else if (lResult != 0 &&
+             ((DWORD) lResult < LINEERR_ALLOCATED ||
+             (DWORD) lResult > LAST_LINEERR))
+    {
+        MessageBeep ((UINT) -1);
+
+        ShowStr(
+            "%s%s returned inval err code (x%lx)",
+            pszTimeStamp,
+            lpFuncName,
+            lResult
+            );
+    }
+    else
+    {
+        if (lResult < 0)
+        {
+            MessageBeep ((UINT) -1);
+        }
+
+        ShowStr(
+            "%s%s returned %s%s",
+            pszTimeStamp,
+            lpFuncName,
+            (lResult ? "LINEERR_" : ""), // ...to shrink aszLineErrs array
+            aszLineErrs[LOWORD(lResult)]
+            );
+    }
+}
+
+
+void
+ShowPhoneFuncResult(
+    LPSTR   lpFuncName,
+    LONG    lResult
+    )
+{
+    char *pszTimeStamp = GetTimeStamp();
+
+
+    if (lResult > 0)
+    {
+        ShowStr ("%s%s returned x%lx", pszTimeStamp, lpFuncName, lResult);
+    }
+    else if (lResult != 0 &&
+             ((DWORD) lResult < PHONEERR_ALLOCATED ||
+             (DWORD) lResult > PHONEERR_REINIT))
+    {
+        MessageBeep ((UINT) -1);
+
+        ShowStr(
+            "%s%s returned inval err code (x%lx)",
+            pszTimeStamp,
+            lpFuncName,
+            lResult
+            );
+    }
+    else
+    {
+        if (lResult < 0)
+        {
+            MessageBeep ((UINT) -1);
+        }
+
+        ShowStr(
+            "%s%s returned %s%s",
+            pszTimeStamp,
+            lpFuncName,
+            (lResult ? "PHONEERR_" : ""), // ...to shrink aszPhoneErrs array
+            aszPhoneErrs[LOWORD(lResult)]
+            );
+    }
+}
+
+
+void
+ShowTapiFuncResult(
+    LPSTR   lpFuncName,
+    LONG    lResult
+    )
+{
+    char *pszTimeStamp = GetTimeStamp();
+
+
+    if ((lResult > 0) || (lResult < TAPIERR_INVALPOINTER))
+    {
+        ShowStr(
+            "%s%s returned inval err code (x%lx)",
+            pszTimeStamp,
+            lpFuncName,
+            lResult
+            );
+    }
+    else
+    {
+        lResult = (~lResult) + 1;
+
+        if (lResult > 0)
+        {
+            MessageBeep ((UINT) -1);
+        }
+
+        ShowStr(
+            "%s%s returned %s%s",
+            pszTimeStamp,
+            lpFuncName,
+            (lResult ? "TAPIERR_" : ""), // ...to shrink aszTapiErrs array
+            aszTapiErrs[lResult]
+            );
+    }
+}
+
+
+void
+UpdateResults(
+    BOOL bBegin
+    )
+{
+    //
+    // In order to maximize speed, minimize flash, & have the
+    // latest info in the edit control scrolled into view we
+    // shrink the window down and hide it. Later, when all the
+    // text has been inserted in the edit control, we show
+    // the window (since window must be visible in order to
+    // scroll caret into view), then tell it to scroll the caret
+    // (at this point the window is still 1x1 so the painting
+    // overhead is 0), and finally restore the control to it's
+    // full size. In doing so we have zero flash and only 1 real
+    // complete paint. Also put up the hourglass for warm fuzzies.
+    //
+
+    static RECT    rect;
+    static HCURSOR hCurSave;
+    static int     iNumBegins = 0;
+
+
+    if (bBegin)
+    {
+        iNumBegins++;
+
+        if (iNumBegins > 1)
+        {
+            return;
+        }
+
+        hCurSave = SetCursor (LoadCursor ((HINSTANCE)NULL, IDC_WAIT));
+        GetWindowRect (ghwndEdit, &rect);
+        SetWindowPos(
+            ghwndEdit,
+            (HWND) NULL,
+            0,
+            0,
+            1,
+            1,
+            SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOREDRAW |
+                SWP_NOZORDER | SWP_HIDEWINDOW
+            );
+    }
+    else
+    {
+        iNumBegins--;
+
+        if (iNumBegins > 0)
+        {
+            return;
+        }
+
+        //
+        // Do control restoration as described above
+        //
+
+        ShowWindow (ghwndEdit, SW_SHOW);
+#ifdef WIN32
+        SendMessage (ghwndEdit, EM_SCROLLCARET, 0, 0);
+#else
+        SendMessage(
+            ghwndEdit,
+            EM_SETSEL,
+            (WPARAM)0,
+            (LPARAM) MAKELONG(0xfffd,0xfffe)
+            );
+#endif
+        SetWindowPos(
+            ghwndEdit,
+            (HWND) NULL,
+            0,
+            0,
+            rect.right - rect.left,
+            rect.bottom - rect.top,
+            SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER
+            );
+        SetCursor (hCurSave);
+    }
+}
+
+
+void
+ShowModBytes(
+    DWORD               dwSize,
+    unsigned char far  *lpc,
+    char               *pszTab,
+    char               *buf
+    )
+{
+    DWORD   dwSize2 = dwSize, i, j, k;
+
+
+    strcpy (buf, pszTab);
+
+    k = strlen (buf);
+
+    for (i = 8; i < 36; i += 9)
+    {
+        buf[k + i] = ' ';
+
+        for (j = 2; j < 9; j += 2)
+        {
+            char buf2[8] = "xx";
+
+            if (dwSize2)
+            {
+                sprintf (buf2, "%02x", (int) (*lpc));
+                dwSize2--;
+            }
+
+            buf[k + i - j]     = buf2[0];
+            buf[k + i - j + 1] = buf2[1];
+
+            lpc++;
+        }
+    }
+
+    k += 37;
+
+    buf[k - 1] = ' ';
+
+    lpc -= 16;
+
+    for (i = 0; i < dwSize; i++)
+    {
+        buf[k + i] = aAscii[*(lpc+i)];
+    }
+
+    buf[k + i] = 0;
+
+    ShowStr (buf);
+}
+
+
+void
+ShowBytes(
+    DWORD   dwSize,
+    LPVOID  lp,
+    DWORD   dwNumTabs
+    )
+{
+    char    tabBuf[17] = "";
+    char    buf[80];
+    DWORD   i, j, k, dwNumDWORDs, dwMod4 = ((DWORD) lp) % 4;
+    LPDWORD lpdw;
+    unsigned char far *lpc = (unsigned char far *) lp;
+
+
+    UpdateResults (TRUE);
+
+
+    for (i = 0; i < dwNumTabs; i++)
+    {
+        strcat (tabBuf, szTab);
+    }
+
+
+    //
+    // Special case for unaligned pointers (will fault on ppc/mips)
+    //
+
+    if (dwMod4)
+    {
+        DWORD   dwNumUnalignedBytes = 4 - dwMod4,
+                dwNumBytesToShow = (dwNumUnalignedBytes > dwSize ?
+                    dwSize : dwNumUnalignedBytes);
+
+
+        ShowModBytes (dwNumBytesToShow, lpc, tabBuf, buf);
+        lpc += dwNumUnalignedBytes;
+        lpdw = (LPDWORD) lpc;
+        dwSize -= dwNumBytesToShow;
+    }
+    else
+    {
+        lpdw = (LPDWORD) lp;
+    }
+
+
+    //
+    // Dump full lines of four DWORDs in hex & corresponding ASCII
+    //
+
+    if (dwSize >= (4*sizeof(DWORD)))
+    {
+        dwNumDWORDs = dwSize / 4; // adjust from numBytes to num DWORDs
+
+        for (i = 0; i < (dwNumDWORDs - (dwNumDWORDs%4)); i += 4)
+        {
+            sprintf (
+                buf,
+                "%s%08lx %08lx %08lx %08lx  ",
+                tabBuf,
+                *lpdw,
+                *(lpdw+1),
+                *(lpdw+2),
+                *(lpdw+3)
+                );
+
+            k = strlen (buf);
+
+            for (j = 0; j < 16; j++)
+            {
+                buf[k + j] = aAscii[*(lpc + j)];
+            }
+
+            buf[k + j] = 0;
+
+            ShowStr (buf);
+            lpdw += 4;
+            lpc += 16;
+        }
+    }
+
+
+    //
+    // Special case for remaining bytes to dump (0 < n < 16)
+    //
+
+    if ((dwSize %= 16))
+    {
+        ShowModBytes (dwSize, lpc, tabBuf, buf);
+    }
+
+
+    UpdateResults (FALSE);
+}
+
+
+void
+ShowStructByDWORDs(
+    LPVOID  lp
+    )
+{
+
+    if (dwDumpStructsFlags & DS_BYTEDUMP)
+    {
+        //
+        // Cast lp as DWORD, then add 2 to point to where a
+        // dwUsedSize field is in a TAPI struct
+        //
+
+        ShowBytes (*(((LPDWORD) lp) + 2), lp, 0);
+    }
+}
+
+
+void
+ShowStructByField(
+    PSTRUCT_FIELD_HEADER    pHeader,
+    BOOL    bSubStructure
+    )
+{
+    static char far *aszCommonFields[] =
+    {
+        "dwTotalSize",
+        "dwNeededSize",
+        "dwUsedSize"
+    };
+    DWORD i, j;
+    char far *buf = malloc (256);
+
+
+    UpdateResults (TRUE);
+
+    ShowStr (pHeader->szName);
+
+    if (!bSubStructure)
+    {
+        LPDWORD lpdw =  (LPDWORD) pHeader->pStruct;
+
+
+        for (i = 0; i < 3; i++)
+        {
+            ShowStr ("%s%s=x%lx", szTab, aszCommonFields[i], *lpdw);
+            lpdw++;
+        }
+    }
+
+    for (i = 0; i < pHeader->dwNumFields; i++)
+    {
+        if ((pHeader->aFields[i].dwValue == 0) &&
+            !(dwDumpStructsFlags & DS_ZEROFIELDS))
+        {
+            continue;
+        }
+
+        sprintf(
+            buf,
+            "%s%s=x%lx",
+            szTab,
+            pHeader->aFields[i].szName,
+            pHeader->aFields[i].dwValue
+            );
+
+        switch (pHeader->aFields[i].dwType)
+        {
+        case FT_DWORD:
+
+            ShowStr (buf);
+            break;
+
+        case FT_FLAGS:
+        {
+            PLOOKUP pLookup = pHeader->aFields[i].pLookup;
+
+
+            strcat (buf, ", ");
+
+            for(
+                j = 0;
+                pHeader->aFields[i].dwValue, pLookup[j].dwVal != 0xffffffff;
+                j++
+                )
+            {
+                if (pHeader->aFields[i].dwValue & pLookup[j].dwVal)
+                {
+                    if (buf[0] == 0)
+                    {
+                        sprintf (buf, "%s%s", szTab, szTab);
+                    }
+
+                    strcat (buf, pLookup[j].lpszVal);
+                    strcat (buf, " ");
+                    pHeader->aFields[i].dwValue =
+                        pHeader->aFields[i].dwValue & ~pLookup[j].dwVal;
+
+                    if (strlen (buf) > 50)
+                    {
+                        //
+                        // We don't want strings getting so long that
+                        // they're going offscreen, so break them up.
+                        //
+
+                        ShowStr (buf);
+                        buf[0] = 0;
+                    }
+                }
+            }
+
+            if (pHeader->aFields[i].dwValue)
+            {
+                strcat (buf, "<unknown flag(s)>");
+            }
+
+            if (buf[0])
+            {
+                ShowStr (buf);
+            }
+
+            break;
+        }
+        case FT_ORD:
+        {
+            PLOOKUP pLookup = pHeader->aFields[i].pLookup;
+
+
+            strcat (buf, ", ");
+
+            for(
+                j = 0;
+                pLookup[j].dwVal != 0xffffffff;
+                j++
+                )
+            {
+                if (pHeader->aFields[i].dwValue == pLookup[j].dwVal)
+                {
+                    strcat (buf, pLookup[j].lpszVal);
+                    break;
+                }
+            }
+
+            if (pLookup[j].dwVal == 0xffffffff)
+            {
+                strcpy (buf, "<unknown ordinal>");
+            }
+
+            ShowStr (buf);
+            break;
+        }
+        case FT_SIZE:
+
+            ShowStr (buf);
+            break;
+
+        case FT_OFFSET:
+
+            ShowStr (buf);
+
+            if (IsBadReadPtr(
+                    ((char far *) pHeader->pStruct) +
+                        pHeader->aFields[i].dwValue,
+                    (UINT)pHeader->aFields[i-1].dwValue
+                    ))
+            {
+                ShowStr ("<size/offset pair yields bad pointer>");
+            }
+            else
+            {
+                ShowBytes(
+                    pHeader->aFields[i-1].dwValue,
+                    ((char far *) pHeader->pStruct) +
+                        pHeader->aFields[i].dwValue,
+                    2
+                    );
+            }
+
+            break;
+        }
+    }
+
+    free (buf);
+
+    UpdateResults (FALSE);
+}
+
+
+void
+ShowVARSTRING(
+    LPVARSTRING lpVarString
+    )
+{
+    if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+    {
+        STRUCT_FIELD fields[] =
+        {
+            { "dwStringFormat", FT_ORD,     lpVarString->dwStringFormat, aStringFormats },
+            { "dwStringSize",   FT_SIZE,    lpVarString->dwStringSize, NULL },
+            { "dwStringOffset", FT_OFFSET,  lpVarString->dwStringOffset, NULL }
+
+        };
+        STRUCT_FIELD_HEADER fieldHeader =
+        {
+            lpVarString,
+            "VARSTRING",
+            3,
+            fields
+        };
+
+        ShowStructByField (&fieldHeader, FALSE);
+    }
+}
+
+
+BOOL
+LetUserMungeParams(
+    PFUNC_PARAM_HEADER pParamsHeader
+    )
+{
+    if (!bShowParams)
+    {
+        return TRUE;
+    }
+
+    return (DialogBoxParam(
+        ghInst,
+        (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG2),
+        ghwndMain,
+        (DLGPROC) ParamsDlgProc,
+        (LPARAM) pParamsHeader
+        ));
+}
+
+
+void
+DumpParams(
+    PFUNC_PARAM_HEADER pHeader
+    )
+{
+    if (bTimeStamp || bDumpParams)
+    {
+        char   *pszTimeStamp = GetTimeStamp();
+
+
+        UpdateResults (TRUE);
+
+        ShowStr(
+            "%sCalling %s",
+            pszTimeStamp,
+            aFuncNames[pHeader->FuncIndex]
+            );
+
+        if (bDumpParams)
+        {
+            DWORD   i;
+
+
+            for (i = 0; i < pHeader->dwNumParams; i++)
+            {
+                ShowStr(
+                    "    %s=x%lx",
+                    pHeader->aParams[i].szName,
+                    pHeader->aParams[i].dwValue
+                    );
+            }
+
+        }
+
+        UpdateResults (FALSE);
+    }
+}
+
+
+LONG
+DoFunc(
+    PFUNC_PARAM_HEADER pHeader
+    )
+{
+    LONG    lResult;
+
+
+    if (!LetUserMungeParams (pHeader))
+    {
+       return 0xffffffff;
+    }
+
+#if TAPI_2_0
+
+    //
+    // Convert any unicode string params as appropriate
+    //
+
+    if (gbWideStringParams)
+    {
+        DWORD       dwNumParams = pHeader->dwNumParams, i;
+        PFUNC_PARAM pParam = pHeader->aParams;
+
+
+        for (i = 0; i < dwNumParams; i++)
+        {
+            if (pParam->dwType == PT_STRING &&
+                pParam->dwValue != 0 &&
+                pParam->dwValue != 0xffffffff)
+            {
+                int    len = strlen ((char *) pParam->dwValue) + 1;
+                WCHAR  buf[MAX_STRING_PARAM_SIZE/2];
+
+
+                MultiByteToWideChar(
+                    GetACP(),
+                    MB_PRECOMPOSED,
+                    (LPCSTR) pParam->dwValue,
+                    (len > MAX_STRING_PARAM_SIZE/2 ?
+                        MAX_STRING_PARAM_SIZE/2 - 1 : -1),
+                    buf,
+                    MAX_STRING_PARAM_SIZE/2
+                    );
+
+                 buf[MAX_STRING_PARAM_SIZE/2 - 1] = 0;
+
+                 lstrcpyW ((WCHAR *) pParam->dwValue, buf);
+            }
+
+            pParam++;
+        }
+    }
+
+#endif
+
+    DumpParams (pHeader);
+
+    switch (pHeader->dwNumParams)
+    {
+    case 1:
+
+        lResult = (*pHeader->u.pfn1)(
+            pHeader->aParams[0].dwValue
+            );
+        break;
+
+    case 2:
+
+        lResult = (*pHeader->u.pfn2)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue
+            );
+        break;
+
+    case 3:
+
+        lResult = (*pHeader->u.pfn3)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue
+            );
+        break;
+
+    case 4:
+
+        lResult = (*pHeader->u.pfn4)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue
+            );
+        break;
+
+    case 5:
+
+        lResult = (*pHeader->u.pfn5)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue
+            );
+        break;
+
+    case 6:
+
+        lResult = (*pHeader->u.pfn6)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue,
+            pHeader->aParams[5].dwValue
+            );
+        break;
+
+    case 7:
+
+        lResult = (*pHeader->u.pfn7)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue,
+            pHeader->aParams[5].dwValue,
+            pHeader->aParams[6].dwValue
+            );
+        break;
+
+    case 8:
+
+        lResult = (*pHeader->u.pfn8)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue,
+            pHeader->aParams[5].dwValue,
+            pHeader->aParams[6].dwValue,
+            pHeader->aParams[7].dwValue
+            );
+        break;
+
+    case 9:
+
+        lResult = (*pHeader->u.pfn9)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue,
+            pHeader->aParams[5].dwValue,
+            pHeader->aParams[6].dwValue,
+            pHeader->aParams[7].dwValue,
+            pHeader->aParams[8].dwValue
+            );
+        break;
+
+    case 10:
+
+        lResult = (*pHeader->u.pfn10)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue,
+            pHeader->aParams[5].dwValue,
+            pHeader->aParams[6].dwValue,
+            pHeader->aParams[7].dwValue,
+            pHeader->aParams[8].dwValue,
+            pHeader->aParams[9].dwValue
+            );
+        break;
+
+    default: // case 12:
+
+        lResult = (*pHeader->u.pfn12)(
+            pHeader->aParams[0].dwValue,
+            pHeader->aParams[1].dwValue,
+            pHeader->aParams[2].dwValue,
+            pHeader->aParams[3].dwValue,
+            pHeader->aParams[4].dwValue,
+            pHeader->aParams[5].dwValue,
+            pHeader->aParams[6].dwValue,
+            pHeader->aParams[7].dwValue,
+            pHeader->aParams[8].dwValue,
+            pHeader->aParams[9].dwValue,
+            pHeader->aParams[10].dwValue,
+            pHeader->aParams[11].dwValue
+            );
+        break;
+    }
+
+    if (pHeader->FuncIndex < pClose)
+    {
+        ShowLineFuncResult (aFuncNames[pHeader->FuncIndex], lResult);
+    }
+    else if (pHeader->FuncIndex < tGetLocationInfo)
+    {
+        ShowPhoneFuncResult (aFuncNames[pHeader->FuncIndex], lResult);
+    }
+    else
+    {
+        ShowTapiFuncResult (aFuncNames[pHeader->FuncIndex], lResult);
+    }
+
+    return lResult;
+}
+
+
+BOOL
+IsLineAppSelected(
+    void
+    )
+{
+    if (!pLineAppSel)
+    {
+        if (gbDisableHandleChecking)
+        {
+            pLineAppSel = (PMYLINEAPP) NullWidget;
+        }
+        else
+        {
+            MessageBeep ((UINT) -1);
+            MessageBox (ghwndMain, "Select an hLineApp", "", MB_OK);
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+IsLineSelected(
+    void
+    )
+{
+    if (!pLineSel)
+    {
+        if (gbDisableHandleChecking)
+        {
+            pLineSel = (PMYLINE) NullWidget;
+        }
+        else
+        {
+            MessageBeep ((UINT) -1);
+            MessageBox (ghwndMain, "Select a Line", "", MB_OK);
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+IsCallSelected(
+    void
+    )
+{
+    if (!pCallSel)
+    {
+        if (gbDisableHandleChecking)
+        {
+            pCallSel = (PMYCALL) NullWidget;
+        }
+        else
+        {
+            MessageBeep ((UINT) -1);
+            MessageBox (ghwndMain, "Select a Call", "", MB_OK);
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+IsTwoCallsSelected(
+    void
+    )
+{
+    if (!pCallSel || !pCallSel2)
+    {
+        if (gbDisableHandleChecking)
+        {
+            if (!pCallSel)
+            {
+                pCallSel = (PMYCALL) NullWidget;
+            }
+
+            pCallSel2 = (PMYCALL) NullWidget;
+        }
+        else
+        {
+            MessageBeep ((UINT) -1);
+            MessageBox(
+                ghwndMain,
+                "Select a Call (must have at least two calls on same line)",
+                "",
+                MB_OK
+                );
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+IsPhoneAppSelected(
+    void
+    )
+{
+    if (!pPhoneAppSel)
+    {
+        if (gbDisableHandleChecking)
+        {
+            pPhoneAppSel = (PMYPHONEAPP) NullWidget;
+        }
+        else
+        {
+            MessageBeep ((UINT) -1);
+            MessageBox (ghwndMain, "Select a PhoneApp", "", MB_OK);
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+IsPhoneSelected(
+    void
+    )
+{
+    if (!pPhoneSel)
+    {
+        if (gbDisableHandleChecking)
+        {
+            pPhoneSel = (PMYPHONE) NullWidget;
+        }
+        else
+        {
+            MessageBeep ((UINT) -1);
+            MessageBox (ghwndMain, "Select a Phone", "", MB_OK);
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+//
+// We get a slough of C4113 (func param lists differed) warnings down below
+// in the initialization of FUNC_PARAM_HEADER structs as a result of the
+// real func prototypes having params that are pointers rather than DWORDs,
+// so since these are known non-interesting warnings just turn them off
+//
+
+#pragma warning (disable:4113)
+
+//#pragma code_seg ("myseg")
+
+void
+FuncDriver(
+    FUNC_INDEX funcIndex
+    )
+{
+    int     i;
+    LONG    lResult;
+
+
+#if TAPI_2_0
+
+    //
+    // Determine if we're doing a ascii or a unicode op
+    //
+
+    gbWideStringParams =
+        ((aFuncNames[funcIndex])[strlen (aFuncNames[funcIndex]) - 1] == 'W' ?
+            TRUE : FALSE);
+
+#endif
+
+    switch (funcIndex)
+    {
+    case lAccept:
+    {
+        char szUserUserInfo[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpsUserUserInfo,    PT_STRING, (DWORD) szUserUserInfo, szUserUserInfo },
+            { szdwSize,             PT_DWORD,  strlen(szDefUserUserInfo)+1, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineAccept };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szUserUserInfo, szDefUserUserInfo);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lAddToConference:
+    {
+        FUNC_PARAM params[] =
+        {
+            { "hConfCall",       PT_DWORD, 0, NULL },
+            { "hConsultCall",    PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineAddToConference };
+
+
+        CHK_TWO_CALLS_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[1].dwValue = (DWORD) pCallSel2->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+#if TAPI_2_0
+    case lAgentSpecific:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,                      PT_DWORD, 0, NULL },
+            { szdwAddressID,                PT_DWORD, 0, NULL },
+            { "dwAgentExtensionIDIndex",    PT_DWORD, 0, NULL },
+            { szlpParams,                   PT_STRING,  (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,                     PT_DWORD,   dwBigBufSize, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineAgentSpecific };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+#endif
+    case lAnswer:
+    {
+        char szUserUserInfo[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpsUserUserInfo,    PT_STRING, (DWORD) szUserUserInfo, szUserUserInfo },
+            { szdwSize,             PT_DWORD,  strlen(szDefUserUserInfo)+1, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineAnswer };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szUserUserInfo, szDefUserUserInfo);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lBlindTransfer:
+#if TAPI_2_0
+    case lBlindTransferW:
+#endif
+    {
+        char szDestAddress[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpszDestAddress,    PT_STRING, (DWORD) szDestAddress, szDestAddress },
+            { "dwCountryCode",      PT_DWORD,  dwDefCountryCode, NULL }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lBlindTransfer ?
+                (PFN3) lineBlindTransfer : (PFN3) lineBlindTransferW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineBlindTransfer };
+#endif
+
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szDestAddress, szDefDestAddress);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lClose:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineClose };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if ((lResult = DoFunc(&paramsHeader)) == 0)
+        {
+            FreeLine (GetLine((HLINE) params[0].dwValue));
+        }
+
+        break;
+    }
+    case lCompleteCall:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,   0, NULL },
+            { "lpdwCompletionID",   PT_POINTER, 0, NULL },
+            { "dwCompletionMode",   PT_FLAGS,   LINECALLCOMPLMODE_CAMPON, aCallComplModes },
+            { "dwMessageID",        PT_DWORD,   0, NULL },
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineCompleteCall };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[1].dwValue = (DWORD) &pCallSel->dwCompletionID;
+
+// BUGBUG if user chgs hCall the wrong &pCallSel->dwCompletionID filled in
+
+        DoFunc(&paramsHeader);
+
+        break;
+    }
+    case lCompleteTransfer:
+    {
+        PMYCALL pNewCall;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,   0, NULL },
+            { "hConsultCall",   PT_DWORD,   0, NULL },
+            { "lphConfCall",    PT_POINTER, 0, NULL },
+            { "dwTransferMode", PT_ORDINAL, LINETRANSFERMODE_TRANSFER, aTransferModes }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineCompleteTransfer };
+
+
+        CHK_TWO_CALLS_SELECTED()
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[1].dwValue = (DWORD) pCallSel2->hCall;
+        params[2].dwValue = params[2].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) >= 0)
+        {
+            //
+            // First make sure we're created the call under the right line,
+            // and if not move it to the right place in the widgets list
+            //
+
+            LINECALLINFO callInfo;
+
+
+            memset (&callInfo, 0, sizeof(LINECALLINFO));
+            callInfo.dwTotalSize = sizeof(LINECALLINFO);
+            if (lineGetCallInfo ((HCALL) params[0].dwValue, &callInfo) == 0)
+            {
+                if (callInfo.hLine != pLineSel->hLine)
+                {
+                    MoveCallToLine (pNewCall, callInfo.hLine);
+                }
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        break;
+    }
+    case lConfigDialog:
+#if TAPI_2_0
+    case lConfigDialogW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,       PT_DWORD, dwDefLineDeviceID, NULL },
+            { szhwndOwner,        PT_DWORD, (DWORD) ghwndMain, NULL },
+            { szlpszDeviceClass,  PT_STRING, (DWORD) szDeviceClass, szDeviceClass }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lConfigDialog ?
+                (PFN3) lineConfigDialog : (PFN3) lineConfigDialogW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineConfigDialog };
+#endif
+
+
+        CHK_LINEAPP_SELECTED()
+
+        strcpy (szDeviceClass, szDefLineDeviceClass);
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDSs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineConfigDialog(
+            params[0].dwValue,
+            (HWND) params[1].dwValue,
+            (LPCSTR) params[2].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        break;
+    }
+    case lDeallocateCall:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineDeallocateCall };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            FreeCall (GetCall((HCALL) params[0].dwValue));
+        }
+
+        break;
+    }
+    case lDevSpecific:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { szhCall,              PT_DWORD,   0, NULL },
+            { szlpParams,           PT_STRING,  (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,             PT_DWORD,   dwBigBufSize, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineDevSpecific };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if (pCallSel)
+        {
+            params[2].dwValue = (DWORD) pCallSel->hCall;
+        }
+
+        memset (pBigBuf, 0, (size_t) dwBigBufSize);
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lDevSpecificFeature:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+//            { "dwFeature",          PT_???, 0, aPhoneButtonFunctions },
+            { "dwFeature",          PT_DWORD,   0, NULL },
+            { szlpParams,           PT_STRING,  (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,             PT_DWORD,   dwBigBufSize, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineDevSpecificFeature };
+
+
+        // BUGBUG need another PT_ type for constants for dwFeature param
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (pBigBuf, 0, (size_t) dwBigBufSize);
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lDial:
+#if TAPI_2_0
+    case lDialW:
+#endif
+    {
+        char szAddress[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpszDestAddress,    PT_STRING, (DWORD) szAddress, szAddress },
+            { "dwCountryCode",      PT_DWORD,  dwDefCountryCode, NULL }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lDial ?
+                (PFN3) lineDial : (PFN3) lineDialW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineDial };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szAddress, szDefDestAddress);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lDrop:
+    {
+        char szUserUserInfo[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpsUserUserInfo,    PT_STRING, (DWORD) szUserUserInfo, szUserUserInfo },
+            { szdwSize,             PT_DWORD,  strlen(szDefUserUserInfo)+1, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineDrop };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szUserUserInfo, szDefUserUserInfo);
+
+        lResult = DoFunc (&paramsHeader);
+
+        // assert (lResult != 0);
+
+        if (gbDeallocateCall && (lResult > 0))
+        {
+            PMYCALL pCall = GetCall ((HCALL) params[0].dwValue);
+
+            dwNumPendingDrops++;
+            pCall->lDropReqID = lResult;
+        }
+
+        break;
+    }
+    case lForward:
+#if TAPI_2_0
+    case lForwardW:
+#endif
+    {
+        PMYCALL pNewCall;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,        0, NULL },
+            { "bAllAddresses",      PT_DWORD,        1, NULL },
+            { szdwAddressID,        PT_DWORD,        0, NULL },
+            { "lpForwardList",      PT_FORWARDLIST,  0, NULL },
+            { "dwNumRingsNoAnswer", PT_DWORD,        5, NULL },
+            { szlphConsultCall,     PT_POINTER,      0, NULL },
+            { szlpCallParams,       PT_CALLPARAMS,   0, lpCallParams }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (funcIndex == lForward ?
+                (PFN7) lineForward : (PFN7) lineForwardW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (PFN7) lineForward };
+#endif
+        LPLINEFORWARDLIST lpForwardList;
+        DWORD   dwTotalSize = sizeof(LINEFORWARDLIST) +
+                    MAX_LINEFORWARD_ENTRIES *
+                    (sizeof(LINEFORWARD) + 2*MAX_STRING_PARAM_SIZE);
+
+
+        CHK_LINE_SELECTED()
+
+
+        if (!(lpForwardList = malloc (dwTotalSize)))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error alloc'ing data structure");
+            break;
+        }
+
+        memset (lpForwardList, 0, dwTotalSize);
+
+        lpForwardList->dwTotalSize  = dwTotalSize;
+        lpForwardList->dwNumEntries = 0;
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            free (lpForwardList);
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+        params[3].dwValue = params[3].u.dwDefValue = (DWORD) lpForwardList;
+        params[5].dwValue = params[5].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) > 0)
+        {
+            if (params[0].dwValue != (DWORD) pLineSel->hLine)
+            {
+                MoveCallToLine (pNewCall, (HLINE) params[0].dwValue);
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        free (lpForwardList);
+
+        break;
+    }
+    case lGatherDigits:
+#if TAPI_2_0
+    case lGatherDigitsW:
+#endif
+    {
+        char *buf;
+        char szTermDigits[MAX_STRING_PARAM_SIZE] = "";
+        FUNC_PARAM params[] =
+        {
+            { szhCall,                  PT_DWORD,   0, NULL },
+            { "dwDigitModes",           PT_FLAGS,   LINEDIGITMODE_DTMF, aDigitModes },
+            { "lpsDigits",              PT_POINTER, 0, NULL },
+            { "dwNumDigits",            PT_DWORD,   0, NULL },
+            { "lpszTerminationDigits",  PT_STRING,  (DWORD) szTermDigits, szTermDigits },
+            { "dwFirstDigitTimeout",    PT_DWORD,   0x8000, NULL },
+            { "dwInterDigitTimeout",    PT_DWORD,   0x8000, NULL },
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (funcIndex == lGatherDigits ?
+                (PFN7) lineGatherDigits : (PFN7) lineGatherDigitsW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (PFN7) lineGatherDigits };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        #define DEF_NUM_GATHERED_DIGITS 64
+
+        if (!(buf = (char *) malloc ((DEF_NUM_GATHERED_DIGITS + 1) * 2)))
+        {
+            ShowStr ("failed to allocate memory");
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[2].dwValue =
+        params[2].u.dwDefValue = (DWORD) buf;
+        params[3].dwValue = DEF_NUM_GATHERED_DIGITS;
+
+        memset (buf, 0, DEF_NUM_GATHERED_DIGITS * 2);
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        if (params[0].dwValue != (DWORD) pCallSel->hCall)
+        {
+            pCallSel = GetCall ((HCALL) params[0].dwValue);
+        }
+
+        if (params[2].dwValue == (DWORD) buf &&
+            params[3].dwValue > DEF_NUM_GATHERED_DIGITS)
+        {
+            if (MessageBox(
+                    ghwndMain,
+                    "Do you want to allocate a larger GatherDigits buffer?" \
+                        "(Not doing so may cause undefined app behavior.)",
+                    "Warning: lineGatherDigits",
+                    MB_YESNO
+                    ) == IDYES)
+            {
+                free (buf);
+
+                // Note: we get weird errors in malloc when specifying a
+                //       size > 0xffffff00, so special case
+
+                if (params[3].dwValue > 0x10000)
+                {
+                    ShowStr ("sorry, too many digits.");
+                    break;
+                }
+
+                buf = (char *) malloc ((size_t) (params[3].dwValue + 1) * 2);
+
+                if (!(params[2].dwValue = (DWORD) buf))
+                {
+                    ShowStr ("failed to allocate memory");
+                    break;
+                }
+
+                memset (buf, 0, (size_t) params[3].dwValue * 2);
+            }
+        }
+
+        if (pCallSel->lpsGatheredDigits && params[2].dwValue)
+        {
+            if (MessageBox(
+                    ghwndMain,
+                    "GatherDigits already in progress on this hCall; if you" \
+                        "continue previous digits buffer may be discarded" \
+                        "without being freed",
+                    "Warning: lineGatherDigits",
+                    MB_OKCANCEL
+
+                    ) == IDCANCEL)
+            {
+                if (buf)
+                {
+                    free (buf);
+                }
+                break;
+            }
+        }
+
+        DumpParams (&paramsHeader);
+
+#if TAPI_2_0
+        if (funcIndex == lGatherDigits)
+        {
+            lResult = lineGatherDigits(
+                (HCALL) params[0].dwValue,
+                params[1].dwValue,
+                (LPSTR) params[2].dwValue,
+                params[3].dwValue,
+                (LPCSTR) params[4].dwValue,
+                params[5].dwValue,
+                params[6].dwValue
+                );
+        }
+        else
+        {
+            lResult = lineGatherDigitsW(
+                (HCALL) params[0].dwValue,
+                params[1].dwValue,
+                (LPWSTR) params[2].dwValue,
+                params[3].dwValue,
+                (LPCWSTR) params[4].dwValue,
+                params[5].dwValue,
+                params[6].dwValue
+                );
+        }
+#else
+        lResult = lineGatherDigits(
+            (HCALL) params[0].dwValue,
+            params[1].dwValue,
+            (LPSTR) params[2].dwValue,
+            params[3].dwValue,
+            (LPCSTR) params[4].dwValue,
+            params[5].dwValue,
+            params[6].dwValue
+            );
+
+#endif
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult) // FAILURE
+        {
+            if (buf)
+            {
+                free (buf);
+            }
+        }
+        else // SUCCESS
+        {
+            if (pCallSel->lpsGatheredDigits)
+            {
+                free (pCallSel->lpsGatheredDigits);
+            }
+
+            pCallSel->lpsGatheredDigits   = (char *) params[2].dwValue;
+            pCallSel->dwNumGatheredDigits = params[3].dwValue;
+#if TAPI_2_0
+            if (funcIndex == lGatherDigitsW)
+            {
+                pCallSel->dwNumGatheredDigits *= 2;
+            }
+#endif
+        }
+
+        break;
+    }
+    case lGenerateDigits:
+#if TAPI_2_0
+    case lGenerateDigitsW:
+#endif
+    {
+        char szDigits[MAX_STRING_PARAM_SIZE] = "123";
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,  0, NULL },
+            { "dwDigitMode",    PT_FLAGS,  LINEDIGITMODE_DTMF, aDigitModes },
+            { "lpszDigits",     PT_STRING, (DWORD) szDigits, szDigits },
+            { "dwDuration",     PT_DWORD,  0, NULL }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (funcIndex == lGenerateDigits ?
+                (PFN4) lineGenerateDigits :  (PFN4) lineGenerateDigitsW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineGenerateDigits };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lGenerateTone:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,         PT_DWORD,  0, NULL },
+            { "dwToneMode",    PT_FLAGS,  LINETONEMODE_CUSTOM, aToneModes },
+            { "dwDuration",    PT_DWORD,  0, NULL },
+            { "dwNumTones",    PT_DWORD,  1, NULL },
+            { "lpTones",       PT_POINTER, (DWORD) pBigBuf, pBigBuf }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineGenerateTone };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lGetAddressCaps:
+#if TAPI_2_0
+    case lGetAddressCapsW:
+#endif
+    {
+        LPLINEADDRESSCAPS lpAddrCaps = (LPLINEADDRESSCAPS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,       PT_DWORD,   0, NULL },
+            { szdwDeviceID,     PT_DWORD,   dwDefLineDeviceID, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { szdwAPIVersion,   PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "dwExtVersion",   PT_DWORD,   dwDefLineExtVersion, NULL },
+            { "lpAddressCaps",  PT_POINTER, (DWORD) lpAddrCaps, lpAddrCaps }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (funcIndex == lGetAddressCaps ?
+                (PFN6) lineGetAddressCaps : (PFN6) lineGetAddressCapsW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineGetAddressCaps };
+#endif
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        memset (lpAddrCaps, 0, (size_t) dwBigBufSize);
+
+        lpAddrCaps->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpAddrCaps);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwLineDeviceID",                 FT_DWORD,   lpAddrCaps->dwLineDeviceID, NULL },
+                    { "dwAddressSize",                  FT_SIZE,    lpAddrCaps->dwAddressSize, NULL },
+                    { "dwAddressOffset",                FT_OFFSET,  lpAddrCaps->dwAddressOffset, NULL },
+                    { "dwDevSpecificSize",              FT_SIZE,    lpAddrCaps->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",            FT_OFFSET,  lpAddrCaps->dwDevSpecificOffset, NULL },
+                    { "dwAddressSharing",               FT_FLAGS,   lpAddrCaps->dwAddressSharing, aAddressSharing },
+                    { "dwAddressStates",                FT_FLAGS,   lpAddrCaps->dwAddressStates, aAddressStates },
+                    { "dwCallInfoStates",               FT_FLAGS,   lpAddrCaps->dwCallInfoStates, aCallInfoStates },
+                    { "dwCallerIDFlags",                FT_FLAGS,   lpAddrCaps->dwCallerIDFlags, aCallerIDFlags },
+                    { "dwCalledIDFlags",                FT_FLAGS,   lpAddrCaps->dwCalledIDFlags, aCallerIDFlags },
+                    { "dwConnectedIDFlags",             FT_FLAGS,   lpAddrCaps->dwConnectedIDFlags, aCallerIDFlags },
+                    { "dwRedirectionIDFlags",           FT_FLAGS,   lpAddrCaps->dwRedirectionIDFlags, aCallerIDFlags },
+                    { "dwRedirectingIDFlags",           FT_FLAGS,   lpAddrCaps->dwRedirectingIDFlags, aCallerIDFlags },
+                    { "dwCallStates",                   FT_FLAGS,   lpAddrCaps->dwCallStates, aCallStates },
+                    { "dwDialToneModes",                FT_FLAGS,   lpAddrCaps->dwDialToneModes, aDialToneModes },
+                    { "dwBusyModes",                    FT_FLAGS,   lpAddrCaps->dwBusyModes, aBusyModes },
+                    { "dwSpecialInfo",                  FT_FLAGS,   lpAddrCaps->dwSpecialInfo, aSpecialInfo },
+                    { "dwDisconnectModes",              FT_FLAGS,   lpAddrCaps->dwDisconnectModes, aDisconnectModes },
+                    { "dwMaxNumActiveCalls",            FT_DWORD,   lpAddrCaps->dwMaxNumActiveCalls, NULL },
+                    { "dwMaxNumOnHoldCalls",            FT_DWORD,   lpAddrCaps->dwMaxNumOnHoldCalls, NULL },
+                    { "dwMaxNumOnHoldPendingCalls",     FT_DWORD,   lpAddrCaps->dwMaxNumOnHoldPendingCalls, NULL },
+                    { "dwMaxNumConference",             FT_DWORD,   lpAddrCaps->dwMaxNumConference, NULL },
+                    { "dwMaxNumTransConf",              FT_DWORD,   lpAddrCaps->dwMaxNumTransConf, NULL },
+                    { "dwAddrCapFlags",                 FT_FLAGS,   lpAddrCaps->dwAddrCapFlags, aAddressCapFlags },
+                    { "dwCallFeatures",                 FT_FLAGS,   lpAddrCaps->dwCallFeatures, aCallFeatures },
+                    { "dwRemoveFromConfCaps",           FT_FLAGS,   lpAddrCaps->dwRemoveFromConfCaps, aRemoveFromConfCaps },
+                    { "dwRemoveFromConfState",          FT_FLAGS,   lpAddrCaps->dwRemoveFromConfState, aCallStates },
+                    { "dwTransferModes",                FT_FLAGS,   lpAddrCaps->dwTransferModes, aTransferModes },
+                    { "dwParkModes",                    FT_FLAGS,   lpAddrCaps->dwParkModes, aParkModes },
+                    { "dwForwardModes",                 FT_FLAGS,   lpAddrCaps->dwForwardModes, aForwardModes },
+                    { "dwMaxForwardEntries",            FT_DWORD,   lpAddrCaps->dwMaxForwardEntries, NULL },
+                    { "dwMaxSpecificEntries",           FT_DWORD,   lpAddrCaps->dwMaxSpecificEntries, NULL },
+                    { "dwMinFwdNumRings",               FT_DWORD,   lpAddrCaps->dwMinFwdNumRings, NULL },
+                    { "dwMaxFwdNumRings",               FT_DWORD,   lpAddrCaps->dwMaxFwdNumRings, NULL },
+                    { "dwMaxCallCompletions",           FT_DWORD,   lpAddrCaps->dwMaxCallCompletions, NULL },
+                    { "dwCallCompletionConds",          FT_FLAGS,   lpAddrCaps->dwCallCompletionConds, aCallComplConds },
+                    { "dwCallCompletionModes",          FT_FLAGS,   lpAddrCaps->dwCallCompletionModes, aCallComplModes },
+                    { "dwNumCompletionMessages",        FT_DWORD,   lpAddrCaps->dwNumCompletionMessages, NULL },
+                    { "dwCompletionMsgTextEntrySize",   FT_DWORD,   lpAddrCaps->dwCompletionMsgTextEntrySize, NULL },
+                    { "dwCompletionMsgTextSize",        FT_SIZE,    lpAddrCaps->dwCompletionMsgTextSize, NULL },
+                    { "dwCompletionMsgTextOffset",      FT_OFFSET,  lpAddrCaps->dwCompletionMsgTextOffset, NULL }
+#if TAPI_1_1
+                     ,
+                    { "dwAddressFeatures",              FT_FLAGS,   0, aAddressFeatures }
+#if TAPI_2_0
+                     ,
+                    { "dwPredictiveAutoTransferStates", FT_FLAGS,   0, aCallStates },
+                    { "dwNumCallTreatments",            FT_DWORD,   0, NULL },
+                    { "dwCallTreatmentListSize",        FT_SIZE,    0, NULL },
+                    { "dwCallTreatmentListOffset",      FT_OFFSET,  0, NULL },
+                    { "dwDeviceClassesSize",            FT_SIZE,    0, NULL },
+                    { "dwDeviceClassesOffset",          FT_OFFSET,  0, NULL },
+                    { "dwMaxCallDataSize",              FT_DWORD,   0, NULL },
+                    { "dwCallFeatures2",                FT_FLAGS,   0, aCallFeatures2 },
+                    { "dwMaxNoAnswerTimeout",           FT_DWORD,   0, NULL },
+                    { "dwConnectedModes",               FT_FLAGS,   0, aConnectedModes },
+                    { "dwOfferingModes",                FT_FLAGS,   0, aOfferingModes },
+                    { "dwAvailableMediaModes",          FT_FLAGS,   0, aMediaModes }
+#endif
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpAddrCaps, "LINEADDRESSCAPS", 0, fields
+                };
+
+
+                if (params[3].dwValue == 0x10003)
+                {
+                    //
+                    // Only show ver 1.0 params
+                    //
+
+                    fieldHeader.dwNumFields = 41;
+                }
+#if TAPI_1_1
+                else if (params[3].dwValue == 0x10004)
+                {
+                    //
+                    // Only show <= ver 1.4 params
+                    //
+
+                    fieldHeader.dwNumFields = 42;
+
+                    fields[41].dwValue = lpAddrCaps->dwAddressFeatures;
+                }
+#if TAPI_2_0
+                else
+                {
+                    //
+                    // Only show <= ver 2.0 params
+                    //
+
+                    fieldHeader.dwNumFields = 54;
+
+                    fields[41].dwValue = lpAddrCaps->dwAddressFeatures;
+                    fields[42].dwValue = lpAddrCaps->dwPredictiveAutoTransferStates;
+                    fields[43].dwValue = lpAddrCaps->dwNumCallTreatments;
+                    fields[44].dwValue = lpAddrCaps->dwCallTreatmentListSize;
+                    fields[45].dwValue = lpAddrCaps->dwCallTreatmentListOffset;
+                    fields[46].dwValue = lpAddrCaps->dwDeviceClassesSize;
+                    fields[47].dwValue = lpAddrCaps->dwDeviceClassesOffset;
+                    fields[48].dwValue = lpAddrCaps->dwMaxCallDataSize;
+                    fields[49].dwValue = lpAddrCaps->dwCallFeatures2;
+                    fields[50].dwValue = lpAddrCaps->dwMaxNoAnswerTimeout;
+                    fields[51].dwValue = lpAddrCaps->dwConnectedModes;
+                    fields[52].dwValue = lpAddrCaps->dwOfferingModes;
+                    fields[53].dwValue = lpAddrCaps->dwAvailableMediaModes;
+                }
+#endif
+#endif
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case lGetAddressID:
+#if TAPI_2_0
+    case lGetAddressIDW:
+#endif
+    {
+        DWORD dwAddressID;
+        char  szAddress[MAX_STRING_PARAM_SIZE] = "0";
+        LPLINEADDRESSCAPS lpAddrCaps = (LPLINEADDRESSCAPS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { "lpdwAddressID",  PT_POINTER, (DWORD) &dwAddressID, &dwAddressID },
+            { "dwAddressMode",  PT_FLAGS,   LINEADDRESSMODE_DIALABLEADDR, aAddressModes },
+            { "lpsAddress",     PT_STRING,  (DWORD) szAddress, szAddress },
+            { szdwSize,         PT_DWORD,   2, NULL }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (funcIndex == lGetAddressID ?
+                (PFN5) lineGetAddressID : (PFN5) lineGetAddressIDW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineGetAddressID };
+#endif
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStr ("%s%s=x%lx", szTab, szdwAddressID, dwAddressID);
+        }
+
+        break;
+    }
+    case lGetAddressStatus:
+#if TAPI_2_0
+    case lGetAddressStatusW:
+#endif
+    {
+        LPLINEADDRESSSTATUS lpAddrStatus = (LPLINEADDRESSSTATUS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { "lpAddressCaps",  PT_POINTER, (DWORD) lpAddrStatus, lpAddrStatus }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetAddressStatus ?
+                (PFN3) lineGetAddressStatus : (PFN3) lineGetAddressStatusW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetAddressStatus };
+#endif
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (lpAddrStatus, 0, (size_t) dwBigBufSize);
+        lpAddrStatus->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpAddrStatus);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwNumInUse",             FT_DWORD,   lpAddrStatus->dwNumInUse, NULL },
+                    { "dwNumActiveCalls",       FT_DWORD,   lpAddrStatus->dwNumActiveCalls, NULL },
+                    { "dwNumOnHoldCalls",       FT_DWORD,   lpAddrStatus->dwNumOnHoldCalls, NULL },
+                    { "dwNumOnHoldPendCalls",   FT_DWORD,   lpAddrStatus->dwNumOnHoldPendCalls, NULL },
+                    { "dwAddressFeatures",      FT_FLAGS,   lpAddrStatus->dwAddressFeatures, aAddressFeatures },
+                    { "dwNumRingsNoAnswer",     FT_DWORD,   lpAddrStatus->dwNumRingsNoAnswer, NULL },
+                    { "dwForwardNumEntries",    FT_DWORD,   lpAddrStatus->dwForwardNumEntries, NULL },
+                    { "dwForwardSize",          FT_SIZE,    lpAddrStatus->dwForwardSize, NULL },
+                    { "dwForwardOffset",        FT_OFFSET,  lpAddrStatus->dwForwardOffset, NULL },
+                    { "dwTerminalModesSize",    FT_SIZE,    lpAddrStatus->dwTerminalModesSize, NULL },
+                    { "dwTerminalModesOffset",  FT_OFFSET,  lpAddrStatus->dwTerminalModesOffset, NULL },
+                    { "dwDevSpecificSize",      FT_SIZE,    lpAddrStatus->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",    FT_OFFSET,  lpAddrStatus->dwDevSpecificOffset, NULL }
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpAddrStatus,
+                    "LINEADDRESSSTATUS",
+                    13,
+                    fields
+                };
+
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case lGetAgentActivityList:
+    case lGetAgentActivityListW:
+    {
+        LPLINEAGENTACTIVITYLIST lpActivityList = (LPLINEAGENTACTIVITYLIST)
+                                    pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { "lpAgentActivityList",  PT_POINTER, (DWORD) lpActivityList, lpActivityList }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetAgentActivityList ?
+                (PFN3) lineGetAgentActivityList :
+                (PFN3) lineGetAgentActivityListW) };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (lpActivityList, 0, (size_t) dwBigBufSize);
+        lpActivityList->dwTotalSize = dwBigBufSize;
+
+        lResult = DoFunc (&paramsHeader);
+
+// BUGBUG dump agent activity list on successful async completion
+
+        break;
+    }
+    case lGetAgentCaps:
+    {
+        LPLINEAGENTCAPS lpAgentCaps = (LPLINEAGENTCAPS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,       PT_DWORD,   0, NULL },
+            { szdwDeviceID,     PT_DWORD,   dwDefLineDeviceID, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { szdwAPIVersion,   PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "lpAgentCaps",    PT_POINTER, (DWORD) lpAgentCaps, lpAgentCaps }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineGetAgentCaps };
+
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        memset (lpAgentCaps, 0, (size_t) dwBigBufSize);
+        lpAgentCaps->dwTotalSize = dwBigBufSize;
+
+        lResult = DoFunc (&paramsHeader);
+
+// BUGBUG dump agent caps on successful async completion
+
+        break;
+    }
+    case lGetAgentGroupList:
+    {
+        LPLINEAGENTGROUPLIST    lpGroupList = (LPLINEAGENTGROUPLIST) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { "lpAgentGroupList",   PT_POINTER, (DWORD) lpGroupList, lpGroupList }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetAgentGroupList };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (lpGroupList, 0, (size_t) dwBigBufSize);
+        lpGroupList->dwTotalSize = dwBigBufSize;
+
+        lResult = DoFunc (&paramsHeader);
+
+// BUGBUG dump agent group list on successful async completion
+
+        break;
+    }
+    case lGetAgentStatus:
+    {
+        LPLINEAGENTSTATUS   lpStatus = (LPLINEAGENTSTATUS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { "lpAgentStatus",  PT_POINTER, (DWORD) lpStatus, lpStatus }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetAgentStatus };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (lpStatus, 0, (size_t) dwBigBufSize);
+        lpStatus->dwTotalSize = dwBigBufSize;
+
+        lResult = DoFunc (&paramsHeader);
+
+// BUGBUG dump agent status on successful async completion
+
+        break;
+    }
+#endif
+    case lGetCallInfo:
+#if TAPI_2_0
+    case lGetCallInfoW:
+#endif
+    {
+        LPLINECALLINFO lpCallInfo = (LPLINECALLINFO) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,      PT_DWORD,   0, NULL },
+            { "lpCallInfo", PT_POINTER, (DWORD) lpCallInfo, lpCallInfo }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (funcIndex == lGetCallInfo ?
+                (PFN2) lineGetCallInfo : (PFN2) lineGetCallInfoW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineGetCallInfo };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        memset (lpCallInfo, 0x5a, (size_t) dwBigBufSize);
+        lpCallInfo->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpCallInfo);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { szhLine,                      FT_DWORD,   (DWORD)lpCallInfo->hLine, NULL },
+                    { "dwLineDeviceID",             FT_DWORD,   lpCallInfo->dwLineDeviceID, NULL },
+                    { szdwAddressID,                FT_DWORD,   lpCallInfo->dwAddressID, NULL },
+                    { "dwBearerMode",               FT_FLAGS,   lpCallInfo->dwBearerMode, aBearerModes },
+                    { "dwRate",                     FT_DWORD,   lpCallInfo->dwRate, NULL },
+                    { "dwMediaMode",                FT_FLAGS,   lpCallInfo->dwMediaMode, aMediaModes },
+                    { "dwAppSpecific",              FT_DWORD,   lpCallInfo->dwAppSpecific, NULL },
+                    { "dwCallID",                   FT_DWORD,   lpCallInfo->dwCallID, NULL },
+                    { "dwRelatedCallID",            FT_DWORD,   lpCallInfo->dwRelatedCallID, NULL },
+                    { "dwCallParamFlags",           FT_FLAGS,   lpCallInfo->dwCallParamFlags, aCallParamFlags },
+                    { "dwCallStates",               FT_FLAGS,   lpCallInfo->dwCallStates, aCallStates },
+                    { "dwMonitorDigitModes",        FT_FLAGS,   lpCallInfo->dwMonitorDigitModes, aDigitModes },
+                    { "dwMonitorMediaModes",        FT_FLAGS,   lpCallInfo->dwMonitorMediaModes, aMediaModes },
+                    { "DialParams.dwDialPause",         FT_DWORD,   lpCallInfo->DialParams.dwDialPause, NULL },
+                    { "DialParams.dwDialSpeed",         FT_DWORD,   lpCallInfo->DialParams.dwDialSpeed, NULL },
+                    { "DialParams.dwDigitDuration",     FT_DWORD,   lpCallInfo->DialParams.dwDigitDuration, NULL },
+                    { "DialParams.dwWaitForDialtone",   FT_DWORD,   lpCallInfo->DialParams.dwWaitForDialtone, NULL },
+                    { "dwOrigin",                   FT_FLAGS,   lpCallInfo->dwOrigin, aCallOrigins },
+                    { "dwReason",                   FT_FLAGS,   lpCallInfo->dwReason, aCallReasons },
+                    { "dwCompletionID",             FT_DWORD,   lpCallInfo->dwCompletionID, NULL },
+                    { "dwNumOwners",                FT_DWORD,   lpCallInfo->dwNumOwners, NULL },
+                    { "dwNumMonitors",              FT_DWORD,   lpCallInfo->dwNumMonitors, NULL },
+                    { "dwCountryCode",              FT_DWORD,   lpCallInfo->dwCountryCode, NULL },
+                    { "dwTrunk",                    FT_DWORD,   lpCallInfo->dwTrunk, NULL },
+                    { "dwCallerIDFlags",            FT_FLAGS,   lpCallInfo->dwCallerIDFlags, aCallerIDFlags },
+                    { "dwCallerIDSize",             FT_SIZE,    lpCallInfo->dwCallerIDSize, NULL },
+                    { "dwCallerIDOffset",           FT_OFFSET,  lpCallInfo->dwCallerIDOffset, NULL },
+                    { "dwCallerIDNameSize",         FT_SIZE,    lpCallInfo->dwCallerIDNameSize, NULL },
+                    { "dwCallerIDNameOffset",       FT_OFFSET,  lpCallInfo->dwCallerIDNameOffset, NULL },
+                    { "dwCalledIDFlags",            FT_FLAGS,   lpCallInfo->dwCalledIDFlags, aCallerIDFlags },
+                    { "dwCalledIDSize",             FT_SIZE,    lpCallInfo->dwCalledIDSize, NULL },
+                    { "dwCalledIDOffset",           FT_OFFSET,  lpCallInfo->dwCalledIDOffset, NULL },
+                    { "dwCalledIDNameSize",         FT_SIZE,    lpCallInfo->dwCalledIDNameSize, NULL },
+                    { "dwCalledIDNameOffset",       FT_OFFSET,  lpCallInfo->dwCalledIDNameOffset, NULL },
+                    { "dwConnectedIDFlags",         FT_FLAGS,   lpCallInfo->dwConnectedIDFlags, aCallerIDFlags },
+                    { "dwConnectedIDSize",          FT_SIZE,    lpCallInfo->dwConnectedIDSize, NULL },
+                    { "dwConnectedIDOffset",        FT_OFFSET,  lpCallInfo->dwConnectedIDOffset, NULL },
+                    { "dwConnectedIDNameSize",      FT_SIZE,    lpCallInfo->dwConnectedIDNameSize, NULL },
+                    { "dwConnectedIDNameOffset",    FT_OFFSET,  lpCallInfo->dwConnectedIDNameOffset, NULL },
+                    { "dwRedirectionIDFlags",       FT_FLAGS,   lpCallInfo->dwRedirectionIDFlags, aCallerIDFlags },
+                    { "dwRedirectionIDSize",        FT_SIZE,    lpCallInfo->dwRedirectionIDSize, NULL },
+                    { "dwRedirectionIDOffset",      FT_OFFSET,  lpCallInfo->dwRedirectionIDOffset, NULL },
+                    { "dwRedirectionIDNameSize",    FT_SIZE,    lpCallInfo->dwRedirectionIDNameSize, NULL },
+                    { "dwRedirectionIDNameOffset",  FT_OFFSET,  lpCallInfo->dwRedirectionIDNameOffset, NULL },
+                    { "dwRedirectingIDFlags",       FT_FLAGS,   lpCallInfo->dwRedirectingIDFlags, aCallerIDFlags },
+                    { "dwRedirectingIDSize",        FT_SIZE,    lpCallInfo->dwRedirectingIDSize, NULL },
+                    { "dwRedirectingIDOffset",      FT_OFFSET,  lpCallInfo->dwRedirectingIDOffset, NULL },
+                    { "dwRedirectingIDNameSize",    FT_SIZE,    lpCallInfo->dwRedirectingIDNameSize, NULL },
+                    { "dwRedirectingIDNameOffset",  FT_OFFSET,  lpCallInfo->dwRedirectingIDNameOffset, NULL },
+                    { "dwAppNameSize",              FT_SIZE,    lpCallInfo->dwAppNameSize, NULL },
+                    { "dwAppNameOffset",            FT_OFFSET,  lpCallInfo->dwAppNameOffset, NULL },
+                    { "dwDisplayableAddressSize",   FT_SIZE,    lpCallInfo->dwDisplayableAddressSize, NULL },
+                    { "dwDisplayableAddressOffset", FT_OFFSET,  lpCallInfo->dwDisplayableAddressOffset, NULL },
+                    { "dwCalledPartySize",          FT_SIZE,    lpCallInfo->dwCalledPartySize, NULL },
+                    { "dwCalledPartyOffset",        FT_OFFSET,  lpCallInfo->dwCalledPartyOffset, NULL },
+                    { "dwCommentSize",              FT_SIZE,    lpCallInfo->dwCommentSize, NULL },
+                    { "dwCommentOffset",            FT_OFFSET,  lpCallInfo->dwCommentOffset, NULL },
+                    { "dwDisplaySize",              FT_SIZE,    lpCallInfo->dwDisplaySize, NULL },
+                    { "dwDisplayOffset",            FT_OFFSET,  lpCallInfo->dwDisplayOffset, NULL },
+                    { "dwUserUserInfoSize",         FT_SIZE,    lpCallInfo->dwUserUserInfoSize, NULL },
+                    { "dwUserUserInfoOffset",       FT_OFFSET,  lpCallInfo->dwUserUserInfoOffset, NULL },
+                    { "dwHighLevelCompSize",        FT_SIZE,    lpCallInfo->dwHighLevelCompSize, NULL },
+                    { "dwHighLevelCompOffset",      FT_OFFSET,  lpCallInfo->dwHighLevelCompOffset, NULL },
+                    { "dwLowLevelCompSize",         FT_SIZE,    lpCallInfo->dwLowLevelCompSize, NULL },
+                    { "dwLowLevelCompOffset",       FT_OFFSET,  lpCallInfo->dwLowLevelCompOffset, NULL },
+                    { "dwChargingInfoSize",         FT_SIZE,    lpCallInfo->dwChargingInfoSize, NULL },
+                    { "dwChargingInfoOffset",       FT_OFFSET,  lpCallInfo->dwChargingInfoOffset, NULL },
+                    { "dwTerminalModesSize",        FT_SIZE,    lpCallInfo->dwTerminalModesSize, NULL },
+                    { "dwTerminalModesOffset",      FT_OFFSET,  lpCallInfo->dwTerminalModesOffset, NULL },
+                    { "dwDevSpecificSize",          FT_SIZE,    lpCallInfo->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",        FT_OFFSET,  lpCallInfo->dwDevSpecificOffset, NULL }
+#if TAPI_2_0
+                     ,
+                    { "dwCallTreatment",            FT_DWORD,   0, NULL },
+                    { "dwCallDataSize",             FT_SIZE,    0, NULL },
+                    { "dwCallDataOffset",           FT_OFFSET,  0, NULL },
+                    { "dwSendingFlowspecSize",      FT_SIZE,    0, NULL },
+                    { "dwSendingFlowspecOffset",    FT_OFFSET,  0, NULL },
+                    { "dwReceivingFlowspecSize",    FT_SIZE,    0, NULL },
+                    { "dwReceivingFlowspecOffset",  FT_OFFSET,  0, NULL }
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpCallInfo, "LINECALLINFO", 0, fields
+                };
+
+
+                if (pLineSel->dwAPIVersion < 0x00020000)
+                {
+                    //
+                    // Only show ver 1.0 params
+                    //
+
+                    fieldHeader.dwNumFields = 71;
+                }
+#if TAPI_2_0
+                else
+                {
+                    fieldHeader.dwNumFields = 78;
+
+                    fields[71].dwValue = lpCallInfo->dwCallTreatment;
+                    fields[72].dwValue = lpCallInfo->dwCallDataSize;
+                    fields[73].dwValue = lpCallInfo->dwCallDataOffset;
+                    fields[74].dwValue = lpCallInfo->dwSendingFlowspecSize;
+                    fields[75].dwValue = lpCallInfo->dwSendingFlowspecOffset;
+                    fields[76].dwValue = lpCallInfo->dwReceivingFlowspecSize;
+                    fields[77].dwValue = lpCallInfo->dwReceivingFlowspecOffset;
+                }
+#endif
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case lGetCallStatus:
+    {
+        LPLINECALLSTATUS lpCallStatus = (LPLINECALLSTATUS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,   0, NULL },
+            { "lpCallStatus",   PT_POINTER, (DWORD) lpCallStatus, lpCallStatus }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineGetCallStatus };
+        DWORD   dwAPIVersion;
+
+
+        CHK_CALL_SELECTED()
+
+        dwAPIVersion = pLineSel->dwAPIVersion;
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        memset (lpCallStatus, 0, (size_t) dwBigBufSize);
+        lpCallStatus->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpCallStatus);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwCallState",            FT_FLAGS,   lpCallStatus->dwCallState, aCallStates },
+                    { "dwCallStateMode",        FT_FLAGS,   lpCallStatus->dwCallStateMode, NULL },
+                    { "dwCallPrivilege",        FT_FLAGS,   lpCallStatus->dwCallPrivilege, aCallPrivileges },
+                    { "dwCallFeatures",         FT_FLAGS,   lpCallStatus->dwCallFeatures, aCallFeatures },
+                    { "dwDevSpecificSize",      FT_SIZE,    lpCallStatus->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",    FT_OFFSET,  lpCallStatus->dwDevSpecificOffset, NULL }
+#if TAPI_2_0
+                     ,
+                    { "dwCallFeatures2",        FT_FLAGS,   0, aCallFeatures2 },
+                    { "tStateEntryTime[0]",     FT_DWORD,   0, NULL },
+                    { "tStateEntryTime[1]",     FT_DWORD,   0, NULL },
+                    { "tStateEntryTime[2]",     FT_DWORD,   0, NULL },
+                    { "tStateEntryTime[3]",     FT_DWORD,   0, NULL }
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpCallStatus, "LINECALLSTATUS", 0, fields
+                };
+
+
+                switch (lpCallStatus->dwCallState)
+                {
+                case LINECALLSTATE_DIALTONE:
+
+                    fields[1].pLookup = aDialToneModes;
+                    break;
+
+                case LINECALLSTATE_BUSY:
+
+                    fields[1].pLookup = aBusyModes;
+                    break;
+
+                case LINECALLSTATE_SPECIALINFO:
+
+                    fields[1].pLookup = aSpecialInfo;
+                    break;
+
+                case LINECALLSTATE_DISCONNECTED:
+
+                    fields[1].pLookup = aDisconnectModes;
+                    break;
+
+                default:
+
+                    fields[1].dwType = FT_DWORD;
+                    break;
+                }
+
+                if (dwAPIVersion < 0x00020000)
+                {
+                    fieldHeader.dwNumFields = 6;
+                }
+#if TAPI_2_0
+                else
+                {
+                    fieldHeader.dwNumFields = 11;
+
+                    fields[6].dwValue  = lpCallStatus->dwCallFeatures2;
+                    fields[7].dwValue  = *((LPDWORD) &lpCallStatus->tStateEntryTime);
+                    fields[8].dwValue  = *(((LPDWORD) &lpCallStatus->tStateEntryTime) + 1);
+                    fields[9].dwValue  = *(((LPDWORD) &lpCallStatus->tStateEntryTime) + 2);
+                    fields[10].dwValue = *(((LPDWORD) &lpCallStatus->tStateEntryTime) + 3);
+                }
+#endif
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case lGetConfRelatedCalls:
+    {
+        LPLINECALLLIST lpCallList = (LPLINECALLLIST) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,      PT_DWORD,   0, NULL },
+            { "lpCallList", PT_POINTER, (DWORD) lpCallList, lpCallList }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineGetConfRelatedCalls };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        memset (lpCallList, 0, (size_t) dwBigBufSize);
+        lpCallList->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpCallList);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwCallsNumEntries",  FT_DWORD,   lpCallList->dwCallsNumEntries, NULL },
+                    { "dwCallsSize",        FT_SIZE,    lpCallList->dwCallsSize, NULL },
+                    { "dwCallsOffset",      FT_OFFSET,  lpCallList->dwCallsOffset, NULL }
+
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpCallList,
+                    "LINECALLLIST",
+                    3,
+                    fields
+                };
+
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case lGetDevCaps:
+#if TAPI_2_0
+    case lGetDevCapsW:
+#endif
+    {
+        LPLINEDEVCAPS lpDevCaps = (LPLINEDEVCAPS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,       PT_DWORD,   0, NULL },
+            { szdwDeviceID,     PT_DWORD,   dwDefLineDeviceID, NULL },
+            { szdwAPIVersion,   PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "dwExtVersion",   PT_DWORD,   dwDefLineExtVersion, NULL },
+            { "lpLineDevCaps",  PT_POINTER, (DWORD) lpDevCaps, lpDevCaps }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (funcIndex == lGetDevCaps ?
+                (PFN5) lineGetDevCaps : (PFN5) lineGetDevCapsW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineGetDevCaps };
+#endif
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        memset (lpDevCaps, 0, (size_t) dwBigBufSize);
+        lpDevCaps->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpDevCaps);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwProviderInfoSize",             FT_SIZE,    lpDevCaps->dwProviderInfoSize, NULL },
+                    { "dwProviderInfoOffset",           FT_OFFSET,  lpDevCaps->dwProviderInfoOffset, NULL },
+                    { "dwSwitchInfoSize",               FT_SIZE,    lpDevCaps->dwSwitchInfoSize, NULL },
+                    { "dwSwitchInfoOffset",             FT_OFFSET,  lpDevCaps->dwSwitchInfoOffset, NULL },
+                    { "dwPermanentLineID",              FT_DWORD,   lpDevCaps->dwPermanentLineID, NULL },
+                    { "dwLineNameSize",                 FT_SIZE,    lpDevCaps->dwLineNameSize, NULL },
+                    { "dwLineNameOffset",               FT_OFFSET,  lpDevCaps->dwLineNameOffset, NULL },
+                    { "dwStringFormat",                 FT_ORD,     lpDevCaps->dwStringFormat, aStringFormats },
+                    { "dwAddressModes",                 FT_FLAGS,   lpDevCaps->dwAddressModes, aAddressModes },
+                    { "dwNumAddresses",                 FT_DWORD,   lpDevCaps->dwNumAddresses, NULL },
+                    { "dwBearerModes",                  FT_FLAGS,   lpDevCaps->dwBearerModes, aBearerModes },
+                    { "dwMaxRate",                      FT_DWORD,   lpDevCaps->dwMaxRate, NULL },
+                    { "dwMediaModes",                   FT_FLAGS,   lpDevCaps->dwMediaModes, aMediaModes },
+                    { "dwGenerateToneModes",            FT_FLAGS,   lpDevCaps->dwGenerateToneModes, aToneModes },
+                    { "dwGenerateToneMaxNumFreq",       FT_DWORD,   lpDevCaps->dwGenerateToneMaxNumFreq, NULL },
+                    { "dwGenerateDigitModes",           FT_FLAGS,   lpDevCaps->dwGenerateDigitModes, aDigitModes },
+                    { "dwMonitorToneMaxNumFreq",        FT_DWORD,   lpDevCaps->dwMonitorToneMaxNumFreq, NULL },
+                    { "dwMonitorToneMaxNumEntries",     FT_DWORD,   lpDevCaps->dwMonitorToneMaxNumEntries, NULL },
+                    { "dwMonitorDigitModes",            FT_FLAGS,   lpDevCaps->dwMonitorDigitModes, aDigitModes },
+                    { "dwGatherDigitsMinTimeout",       FT_DWORD,   lpDevCaps->dwGatherDigitsMinTimeout, NULL },
+                    { "dwGatherDigitsMaxTimeout",       FT_DWORD,   lpDevCaps->dwGatherDigitsMaxTimeout, NULL },
+                    { "dwMedCtlDigitMaxListSize",       FT_DWORD,   lpDevCaps->dwMedCtlDigitMaxListSize, NULL },
+                    { "dwMedCtlMediaMaxListSize",       FT_DWORD,   lpDevCaps->dwMedCtlMediaMaxListSize, NULL },
+                    { "dwMedCtlToneMaxListSize",        FT_DWORD,   lpDevCaps->dwMedCtlToneMaxListSize, NULL },
+                    { "dwMedCtlCallStateMaxListSize",   FT_DWORD,   lpDevCaps->dwMedCtlCallStateMaxListSize, NULL },
+                    { "dwDevCapFlags",                  FT_FLAGS,   lpDevCaps->dwDevCapFlags, aDevCapsFlags },
+                    { "dwMaxNumActiveCalls",            FT_DWORD,   lpDevCaps->dwMaxNumActiveCalls, NULL },
+                    { "dwAnswerMode",                   FT_FLAGS,   lpDevCaps->dwAnswerMode, aAnswerModes },
+                    { "dwRingModes",                    FT_DWORD,   lpDevCaps->dwRingModes, NULL },
+                    { "dwLineStates",                   FT_FLAGS,   lpDevCaps->dwLineStates, aLineStates },
+                    { "dwUUIAcceptSize",                FT_DWORD,   lpDevCaps->dwUUIAcceptSize, NULL },
+                    { "dwUUIAnswerSize",                FT_DWORD,   lpDevCaps->dwUUIAnswerSize, NULL },
+                    { "dwUUIMakeCallSize",              FT_DWORD,   lpDevCaps->dwUUIMakeCallSize, NULL },
+                    { "dwUUIDropSize",                  FT_DWORD,   lpDevCaps->dwUUIDropSize, NULL },
+                    { "dwUUISendUserUserInfoSize",      FT_DWORD,   lpDevCaps->dwUUISendUserUserInfoSize, NULL },
+                    { "dwUUICallInfoSize",              FT_DWORD,   lpDevCaps->dwUUICallInfoSize, NULL },
+                    { "MinDialParams.dwDialPause",          FT_DWORD,   lpDevCaps->MinDialParams.dwDialPause, NULL },
+                    { "MinDialParams.dwDialSpeed",          FT_DWORD,   lpDevCaps->MinDialParams.dwDialSpeed, NULL },
+                    { "MinDialParams.dwDigitDuration",      FT_DWORD,   lpDevCaps->MinDialParams.dwDigitDuration, NULL },
+                    { "MinDialParams.dwWaitForDialtone",    FT_DWORD,   lpDevCaps->MinDialParams.dwWaitForDialtone, NULL },
+                    { "MaxDialParams.dwDialPause",          FT_DWORD,   lpDevCaps->MaxDialParams.dwDialPause, NULL },
+                    { "MaxDialParams.dwDialSpeed",          FT_DWORD,   lpDevCaps->MaxDialParams.dwDialSpeed, NULL },
+                    { "MaxDialParams.dwDigitDuration",      FT_DWORD,   lpDevCaps->MaxDialParams.dwDigitDuration, NULL },
+                    { "MaxDialParams.dwWaitForDialtone",    FT_DWORD,   lpDevCaps->MaxDialParams.dwWaitForDialtone, NULL },
+                    { "DefDialParams.dwDialPause",          FT_DWORD,   lpDevCaps->DefaultDialParams.dwDialPause, NULL },
+                    { "DefDialParams.dwDialSpeed",          FT_DWORD,   lpDevCaps->DefaultDialParams.dwDialSpeed, NULL },
+                    { "DefDialParams.dwDigitDuration",      FT_DWORD,   lpDevCaps->DefaultDialParams.dwDigitDuration, NULL },
+                    { "DefDialParams.dwWaitForDialtone",    FT_DWORD,   lpDevCaps->DefaultDialParams.dwWaitForDialtone, NULL },
+                    { "dwNumTerminals",                 FT_DWORD,   lpDevCaps->dwNumTerminals, NULL },
+                    { "dwTerminalCapsSize",             FT_SIZE,    lpDevCaps->dwTerminalCapsSize, NULL },
+                    { "dwTerminalCapsOffset",           FT_OFFSET,  lpDevCaps->dwTerminalCapsOffset, NULL },
+                    { "dwTerminalTextEntrySize",        FT_DWORD,   lpDevCaps->dwTerminalTextEntrySize, NULL },
+                    { "dwTerminalTextSize",             FT_SIZE,    lpDevCaps->dwTerminalTextSize, NULL },
+                    { "dwTerminalTextOffset",           FT_OFFSET,  lpDevCaps->dwTerminalTextOffset, NULL },
+                    { "dwDevSpecificSize",              FT_SIZE,    lpDevCaps->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",            FT_OFFSET,  lpDevCaps->dwDevSpecificOffset, NULL }
+#if TAPI_1_1
+                     ,
+                    { "dwLineFeatures",                 FT_FLAGS,   0, aLineFeatures }
+#if TAPI_2_0
+                     ,
+                    { "dwSettableDevStatus",            FT_FLAGS,   0, aLineDevStatusFlags },
+                    { "dwDeviceClassesSize",            FT_SIZE,    0, NULL },
+                    { "dwDeviceClassesOffset",          FT_OFFSET,  0, NULL }
+#endif
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpDevCaps, "LINEDEVCAPS", 0, fields
+                };
+
+                if (params[2].dwValue == 0x10003)
+                {
+                    //
+                    // Only show ver 1.0 params
+                    //
+
+                    fieldHeader.dwNumFields = 56;
+                }
+#if TAPI_1_1
+                else if (params[2].dwValue == 0x10004)
+                {
+                    //
+                    // Only show <= ver 1.1 params
+                    //
+
+                    fieldHeader.dwNumFields = 57;
+
+                    fields[56].dwValue = lpDevCaps->dwLineFeatures;
+                }
+#if TAPI_2_0
+                else
+                {
+                    //
+                    // Only show <= ver 2.0 params
+                    //
+
+                    fieldHeader.dwNumFields = 60;
+
+                    fields[56].dwValue = lpDevCaps->dwLineFeatures;
+                    fields[57].dwValue = lpDevCaps->dwSettableDevStatus;
+                    fields[58].dwValue = lpDevCaps->dwDeviceClassesSize;
+                    fields[59].dwValue = lpDevCaps->dwDeviceClassesOffset;
+                }
+#endif
+#endif
+
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case lGetDevConfig:
+#if TAPI_2_0
+    case lGetDevConfigW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        LPVARSTRING lpDevConfig = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,         PT_DWORD,   dwDefLineDeviceID, NULL },
+            { "lpDeviceConfig",     PT_POINTER, (DWORD) lpDevConfig, lpDevConfig },
+            { szlpszDeviceClass,    PT_STRING,  (DWORD) szDeviceClass, szDeviceClass }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetDevConfig ?
+                (PFN3) lineGetDevConfig : (PFN3) lineGetDevConfigW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetDevConfig };
+#endif
+
+        memset (lpDevConfig, 0, (size_t) dwBigBufSize);
+        lpDevConfig->dwTotalSize = dwBigBufSize;
+
+        strcpy (szDeviceClass, szDefLineDeviceClass);
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpDevConfig);
+
+            ShowVARSTRING (lpDevConfig);
+        }
+
+        break;
+    }
+    case lGetIcon:
+#if TAPI_2_0
+    case lGetIconW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE] = "";
+        HICON hIcon;
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,         PT_DWORD,   dwDefLineDeviceID, NULL },
+            { szlpszDeviceClass,    PT_STRING,  (DWORD) szDeviceClass, szDeviceClass },
+            { "lphIcon",            PT_POINTER, (DWORD) &hIcon, &hIcon }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetIcon ?
+                (PFN3) lineGetIcon : (PFN3) lineGetIconW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetIcon };
+#endif
+
+        strcpy (szDeviceClass, szDefLineDeviceClass);
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            DialogBoxParam (
+                ghInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG5),
+                (HWND) ghwndMain,
+                (DLGPROC) IconDlgProc,
+                (LPARAM) hIcon
+                );
+        }
+
+        break;
+    }
+    case lGetID:
+#if TAPI_2_0
+    case lGetIDW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        LPVARSTRING lpDevID = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { szhCall,              PT_DWORD,   0, NULL },
+            { "dwSelect",           PT_ORDINAL, LINECALLSELECT_LINE, aCallSelects },
+            { "lpDeviceID",         PT_POINTER, (DWORD) lpDevID, lpDevID },
+            { szlpszDeviceClass,    PT_STRING,   (DWORD) szDeviceClass, szDeviceClass }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (funcIndex == lGetID ?
+                (PFN6) lineGetID : (PFN6) lineGetIDW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineGetID };
+#endif
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if (pCallSel)
+        {
+            params[2].dwValue = (DWORD) pCallSel->hCall;
+            params[3].dwValue = LINECALLSELECT_CALL;
+        }
+        else
+        {
+            params[3].dwValue = LINECALLSELECT_LINE;
+        }
+
+        memset (lpDevID, 0, (size_t) dwBigBufSize);
+        lpDevID->dwTotalSize = dwBigBufSize;
+
+        strcpy (szDeviceClass, szDefLineDeviceClass);
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpDevID);
+
+            ShowVARSTRING (lpDevID);
+        }
+
+        break;
+    }
+    case lGetLineDevStatus:
+#if TAPI_2_0
+    case lGetLineDevStatusW:
+#endif
+    {
+        LPLINEDEVSTATUS lpDevStatus = (LPLINEDEVSTATUS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { "lpLineDevStatus",    PT_POINTER, (DWORD) lpDevStatus, lpDevStatus }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (funcIndex == lGetLineDevStatus ?
+                (PFN2) lineGetLineDevStatus : (PFN2) lineGetLineDevStatusW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineGetLineDevStatus };
+#endif
+        DWORD   dwAPIVersion;
+
+
+        CHK_LINE_SELECTED()
+
+        dwAPIVersion = pLineSel->dwAPIVersion;
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (lpDevStatus, 0, (size_t) dwBigBufSize);
+        lpDevStatus->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpDevStatus);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwNumOpens",             FT_DWORD,   lpDevStatus->dwNumOpens, NULL },
+                    { "dwOpenMediaModes",       FT_FLAGS,   lpDevStatus->dwOpenMediaModes, aMediaModes },
+                    { "dwNumActiveCalls",       FT_DWORD,   lpDevStatus->dwNumActiveCalls, NULL },
+                    { "dwNumOnHoldCalls",       FT_DWORD,   lpDevStatus->dwNumOnHoldCalls, NULL },
+                    { "dwNumOnHoldPendCalls",   FT_DWORD,   lpDevStatus->dwNumOnHoldPendCalls, NULL },
+                    { "dwLineFeatures",         FT_FLAGS,   lpDevStatus->dwLineFeatures, aLineFeatures },
+                    { "dwNumCallCompletions",   FT_DWORD,   lpDevStatus->dwNumCallCompletions, NULL },
+                    { "dwRingMode",             FT_DWORD,   lpDevStatus->dwRingMode, NULL },
+                    { "dwSignalLevel",          FT_DWORD,   lpDevStatus->dwSignalLevel, NULL },
+                    { "dwBatteryLevel",         FT_DWORD,   lpDevStatus->dwBatteryLevel, NULL },
+                    { "dwRoamMode",             FT_FLAGS,   lpDevStatus->dwRoamMode, aLineRoamModes },
+                    { "dwDevStatusFlags",       FT_FLAGS,   lpDevStatus->dwDevStatusFlags, aLineDevStatusFlags },
+                    { "dwTerminalModesSize",    FT_SIZE,    lpDevStatus->dwTerminalModesSize, NULL },
+                    { "dwTerminalModesOffset",  FT_OFFSET,  lpDevStatus->dwTerminalModesOffset, NULL },
+                    { "dwDevSpecificSize",      FT_SIZE,    lpDevStatus->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",    FT_OFFSET,  lpDevStatus->dwDevSpecificOffset, NULL }
+#if TAPI_2_0
+                     ,
+                    { "dwAvailableMediaModes",  FT_FLAGS,   0, aMediaModes },
+                    { "dwAppInfoSize",          FT_DWORD,   0, NULL },
+                    { "dwAppInfoOffset",        FT_DWORD,   0, NULL }
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpDevStatus, "LINEDEVSTATUS", 0, fields
+                };
+
+                if (dwAPIVersion < 0x00020000)
+                {
+                    fieldHeader.dwNumFields = 16;
+                }
+#if TAPI_2_0
+                else
+                {
+                    fieldHeader.dwNumFields = 19;
+
+                    fields[16].dwValue = lpDevStatus->dwAvailableMediaModes;
+                    fields[17].dwValue = lpDevStatus->dwAppInfoSize;
+                    fields[18].dwValue = lpDevStatus->dwAppInfoOffset;
+                }
+#endif
+                ShowStructByField (&fieldHeader, FALSE);
+
+#if TAPI_2_0
+                if (dwAPIVersion >= 0x00020000 && lpDevStatus->dwAppInfoSize)
+                {
+                    char            szAppInfoN[16];
+                    DWORD           i;
+                    LPLINEAPPINFO   pAppInfo;
+                    STRUCT_FIELD    fields[] =
+                    {
+                        { "dwMachineNameSize",      FT_SIZE,    0, NULL },
+                        { "dwMachineNameOffset",    FT_OFFSET,  0, NULL },
+                        { "dwUserNameSize",         FT_SIZE,    0, NULL },
+                        { "dwUserNameOffset",       FT_OFFSET,  0, NULL },
+                        { "dwModuleFilenameSize",   FT_SIZE,    0, NULL },
+                        { "dwModuleFilenameOffset", FT_OFFSET,  0, NULL },
+                        { "dwFriendlyNameSize",     FT_SIZE,    0, NULL },
+                        { "dwFriendlyNameOffset",   FT_OFFSET,  0, NULL },
+                        { "dwMediaModes",           FT_FLAGS,   0, aMediaModes },
+                        { "dwAddressID",            FT_DWORD,   0, NULL },
+                    };
+                    STRUCT_FIELD_HEADER fieldHeader =
+                    {
+                        lpDevStatus, szAppInfoN, 10, fields
+                    };
+
+
+                    pAppInfo = (LPLINEAPPINFO) (((LPBYTE) lpDevStatus) +
+                        lpDevStatus->dwAppInfoOffset);
+
+                    for (i = 0; i < lpDevStatus->dwNumOpens; i++)
+                    {
+                        wsprintf (szAppInfoN, "APPINFO[%d]", i);
+
+                        fields[0].dwValue = pAppInfo->dwMachineNameSize;
+                        fields[1].dwValue = pAppInfo->dwMachineNameOffset;
+                        fields[2].dwValue = pAppInfo->dwUserNameSize;
+                        fields[3].dwValue = pAppInfo->dwUserNameOffset;
+                        fields[4].dwValue = pAppInfo->dwModuleFilenameSize;
+                        fields[5].dwValue = pAppInfo->dwModuleFilenameOffset;
+                        fields[6].dwValue = pAppInfo->dwFriendlyNameSize;
+                        fields[7].dwValue = pAppInfo->dwFriendlyNameOffset;
+                        fields[8].dwValue = pAppInfo->dwMediaModes;;
+                        fields[9].dwValue = pAppInfo->dwAddressID;
+
+                        ShowStructByField (&fieldHeader, TRUE);
+
+                        pAppInfo++;
+                    }
+                }
+#endif
+            }
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case lGetMessage:
+    {
+        LINEMESSAGE msg;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,   PT_DWORD,   0, NULL },
+            { "lpMessage",  PT_POINTER, (DWORD) &msg, &msg },
+            { "dwTimeout",  PT_DWORD,   0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, NULL };
+
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        // Max timeout of 2 seconds (don't want to hang app & excite user)
+
+        params[2].dwValue = (params[2].dwValue > 2000 ?
+            2000 : params[2].dwValue);
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineGetMessage(
+            (HLINEAPP)      params[0].dwValue,
+            (LPLINEMESSAGE) params[1].dwValue,
+            (DWORD)         params[2].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult == 0)
+        {
+            tapiCallback(
+                msg.hDevice,
+                msg.dwMessageID,
+                msg.dwCallbackInstance,
+                msg.dwParam1,
+                msg.dwParam2,
+                msg.dwParam3
+                );
+        }
+
+        break;
+    }
+#endif
+    case lGetNewCalls:
+    {
+        LPLINECALLLIST lpCallList = (LPLINECALLLIST) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { "dwSelect",       PT_ORDINAL, LINECALLSELECT_LINE, aCallSelects },
+            { "lpCallList",     PT_POINTER, (DWORD) lpCallList, lpCallList }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineGetNewCalls };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        memset (lpCallList, 0, (size_t) dwBigBufSize);
+        lpCallList->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpCallList);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwCallsNumEntries",  FT_DWORD,   lpCallList->dwCallsNumEntries, NULL },
+                    { "dwCallsSize",        FT_SIZE,    lpCallList->dwCallsSize, NULL },
+                    { "dwCallsOffset",      FT_OFFSET,  lpCallList->dwCallsOffset, NULL }
+
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpCallList,
+                    "LINECALLLIST",
+                    3,
+                    fields
+                };
+
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+
+
+            //
+            // If there are any hCalls returned in this struct we want
+            // to add them to the widget list
+            //
+
+            if (lpCallList->dwCallsNumEntries)
+            {
+                PMYLINE pLine = GetLine ((HLINE) params[0].dwValue);
+                LPHCALL lphCall = (LPHCALL)
+                    (((LPBYTE) lpCallList) + lpCallList->dwCallsOffset);
+
+
+                for (i = 0; i < (int) lpCallList->dwCallsNumEntries; i++)
+                {
+                    PMYCALL pNewCall = AllocCall (pLine);
+                    LINECALLSTATUS callStatus;
+
+
+                    if (pNewCall)
+                    {
+                        pNewCall->hCall    = *lphCall;
+                        pNewCall->bMonitor = TRUE;
+                        lphCall++;
+
+                        memset (&callStatus, 0, sizeof(LINECALLSTATUS));
+                        callStatus.dwTotalSize = sizeof(LINECALLSTATUS);
+
+                        if (lineGetCallStatus (pNewCall->hCall, &callStatus)
+                                == 0)
+                        {
+                            //
+                            // Special case chk for bNukeIdleMonitorCalls
+                            //
+
+                            if ((callStatus.dwCallState
+                                    == LINECALLSTATE_IDLE) &&
+                                bNukeIdleMonitorCalls &&
+                                (callStatus.dwCallPrivilege
+                                    == LINECALLPRIVILEGE_MONITOR))
+                            {
+                                if ((lResult = lineDeallocateCall(
+                                        (HCALL) pNewCall->hCall)) == 0)
+                                {
+                                    ShowStr(
+                                        "Monitored call x%lx deallocated " \
+                                            "on IDLE",
+                                        pNewCall->hCall
+                                        );
+
+                                    FreeCall (pNewCall);
+                                }
+                                else
+                                {
+                                    ShowStr(
+                                        "lineDeallocateCall failed (x%lx) to" \
+                                            " free idle monitored call x%lx",
+                                        lResult,
+                                        pNewCall->hCall
+                                        );
+
+                                    pNewCall->dwCallState = callStatus.dwCallState;
+                                }
+                            }
+                            else
+                            {
+                                pNewCall->dwCallState = callStatus.dwCallState;
+                            }
+                        }
+                        else
+                        {
+                            pNewCall->dwCallState = LINECALLSTATE_UNKNOWN;
+                        }
+                    }
+                }
+
+                UpdateWidgetList();
+            }
+        }
+
+        break;
+    }
+    case lGetNumRings:
+    {
+        DWORD dwNumRings;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { szdwAddressID,    PT_DWORD,   dwDefAddressID, NULL },
+            { "lpdwNumRings",   PT_POINTER, (DWORD) &dwNumRings, &dwNumRings }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetNumRings };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStr ("%snum rings = x%lx", szTab, dwNumRings);
+        }
+
+        break;
+    }
+    case lGetRequest:
+#if TAPI_2_0
+    case lGetRequestW:
+#endif
+    {
+#if TAPI_2_0
+        LINEREQMEDIACALLW   reqXxxCall;
+#else
+        LINEREQMEDIACALL    reqXxxCall;
+#endif
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,   0, NULL },
+            { "dwRequestMode",      PT_ORDINAL, LINEREQUESTMODE_MAKECALL, aRequestModes },
+            { "lpRequestBuffer",    PT_POINTER, (DWORD) &reqXxxCall, &reqXxxCall }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetRequest ?
+                (PFN3) lineGetRequest : (PFN3) lineGetRequestW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetRequest };
+#endif
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        memset (&reqXxxCall, 0, sizeof (reqXxxCall));
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            if (params[1].dwValue == LINEREQUESTMODE_MAKECALL)
+            {
+#if TAPI_2_0
+                if (gbWideStringParams)
+                {
+                    LPLINEREQMAKECALLW  lpReqMakeCall = (LPLINEREQMAKECALLW)
+                                            &reqXxxCall;
+
+
+                    ShowStr ("%sszDestAddress=%ws", szTab, lpReqMakeCall->szDestAddress);
+                    ShowStr ("%sszAppName=%ws",     szTab, lpReqMakeCall->szAppName);
+                    ShowStr ("%sszCalledParty=%ws", szTab, lpReqMakeCall->szCalledParty);
+                    ShowStr ("%sszComment=%ws",     szTab, lpReqMakeCall->szComment);
+                }
+                else
+                {
+                    LPLINEREQMAKECALL   lpReqMakeCall = (LPLINEREQMAKECALL)
+                                            &reqXxxCall;
+
+                    ShowStr ("%sszDestAddress=%s", szTab, lpReqMakeCall->szDestAddress);
+                    ShowStr ("%sszAppName=%s",     szTab, lpReqMakeCall->szAppName);
+                    ShowStr ("%sszCalledParty=%s", szTab, lpReqMakeCall->szCalledParty);
+                    ShowStr ("%sszComment=%s",     szTab, lpReqMakeCall->szComment);
+                }
+#else
+                LPLINEREQMAKECALL   lpReqMakeCall = (LPLINEREQMAKECALL)
+                                        &reqXxxCall;
+
+
+                ShowStr ("%sszDestAddress=%s", szTab, lpReqMakeCall->szDestAddress);
+                ShowStr ("%sszAppName=%s",     szTab, lpReqMakeCall->szAppName);
+                ShowStr ("%sszCalledParty=%s", szTab, lpReqMakeCall->szCalledParty);
+                ShowStr ("%sszComment=%s",     szTab, lpReqMakeCall->szComment);
+#endif
+            }
+            else
+            {
+                //
+                // NOTE: lineGetRequest(MEDIACALL) is a NOOP for win32,
+                //       so we don't have to sweat differing sizes for
+                //       HWND & WPARAM in the struct
+                //
+
+                LPLINEREQMEDIACALL  lpReqMediaCall = (LPLINEREQMEDIACALL)
+                                        &reqXxxCall;
+
+
+                ShowStr ("%shWnd=x%x",         szTab, lpReqMediaCall->hWnd);
+                ShowStr ("%swRequestID=x%x",   szTab, lpReqMediaCall->wRequestID);
+                ShowStr ("%sszDeviceClass=%s", szTab, lpReqMediaCall->szDeviceClass);
+                ShowStr ("%sdwSize=x%lx",      szTab, lpReqMediaCall->dwSize);
+                ShowStr ("%sdwSecure=x%lx",    szTab, lpReqMediaCall->dwSecure);
+                ShowStr ("%sszDestAddress=%s", szTab, lpReqMediaCall->szDestAddress);
+                ShowStr ("%sszAppName=%s",     szTab, lpReqMediaCall->szAppName);
+                ShowStr ("%sszCalledParty=%s", szTab, lpReqMediaCall->szCalledParty);
+                ShowStr ("%sszComment=%s",     szTab, lpReqMediaCall->szComment);
+            }
+        }
+
+        break;
+    }
+    case lGetStatusMessages:
+    {
+        DWORD aFlags[2];
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { "lpdwLineStates",     PT_POINTER, (DWORD) &aFlags[0], &aFlags[0] },
+            { "lpdwAddressStates",  PT_POINTER, (DWORD) &aFlags[1], &aFlags[1] }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetStatusMessages };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { "dwLineStates",       FT_FLAGS,   aFlags[0], aLineStates },
+                { "dwAddressStates",    FT_FLAGS,   aFlags[1], aAddressStates }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                aFlags,
+                "",
+                2,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+        }
+
+        break;
+    }
+    case lGetTranslateCaps:
+#if TAPI_2_0
+    case lGetTranslateCapsW:
+#endif
+    {
+        LPLINETRANSLATECAPS lpTranslateCaps = (LPLINETRANSLATECAPS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,   0, NULL },
+            { szdwAPIVersion,       PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "lpTranslateCaps",    PT_POINTER, (DWORD) lpTranslateCaps, lpTranslateCaps }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetTranslateCaps ?
+                (PFN3) lineGetTranslateCaps : (PFN3) lineGetTranslateCapsW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetTranslateCaps };
+#endif
+
+        if (pLineAppSel)
+        {
+            params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+        }
+
+        memset (lpTranslateCaps, 0, (size_t) dwBigBufSize);
+        lpTranslateCaps->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            UpdateResults (TRUE);
+
+            ShowStructByDWORDs (lpTranslateCaps);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                DWORD i;
+                LPLINECARDENTRY lpCardEntry;
+                LPLINELOCATIONENTRY lpLocationEntry;
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwNumLocations",           FT_DWORD,   lpTranslateCaps->dwNumLocations, NULL },
+                    { "dwLocationListSize",       FT_DWORD,   lpTranslateCaps->dwLocationListSize, NULL },
+                    { "dwLocationListOffset",     FT_DWORD,   lpTranslateCaps->dwLocationListOffset, NULL },
+                    { "dwCurrentLocationID",      FT_DWORD,   lpTranslateCaps->dwCurrentLocationID, NULL },
+                    { "dwNumCards",               FT_DWORD,   lpTranslateCaps->dwNumCards, NULL },
+                    { "dwCardListSize",           FT_DWORD,   lpTranslateCaps->dwCardListSize, NULL },
+                    { "dwCardListOffset",         FT_DWORD,   lpTranslateCaps->dwCardListOffset, NULL },
+                    { "dwCurrentPreferredCardID", FT_DWORD,   lpTranslateCaps->dwCurrentPreferredCardID, NULL }
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpTranslateCaps,
+                    "LINETRANSLATECAPS",
+                    8,
+                    fields
+                };
+
+                ShowStructByField (&fieldHeader, FALSE);
+
+                lpLocationEntry = (LPLINELOCATIONENTRY)
+                    (((LPBYTE) lpTranslateCaps) +
+                        lpTranslateCaps->dwLocationListOffset);
+
+                for (i = 0; i < lpTranslateCaps->dwNumLocations; i++)
+                {
+                    char buf[32];
+                    STRUCT_FIELD fields[] =
+                    {
+                        { "dwPermanentLocationID",          FT_DWORD,  lpLocationEntry->dwPermanentLocationID, NULL },
+                        { "dwLocationNameSize",             FT_SIZE,   lpLocationEntry->dwLocationNameSize, NULL },
+                        { "dwLocationNameOffset",           FT_OFFSET, lpLocationEntry->dwLocationNameOffset, NULL },
+                        { "dwCountryCode",                  FT_DWORD,  lpLocationEntry->dwCountryCode, NULL },
+                        { "dwCityCodeSize",                 FT_SIZE,   lpLocationEntry->dwCityCodeSize, NULL },
+                        { "dwCityCodeOffset",               FT_OFFSET, lpLocationEntry->dwCityCodeOffset, NULL },
+                        { "dwPreferredCardID",              FT_DWORD,  lpLocationEntry->dwPreferredCardID, NULL }
+#if TAPI_1_1
+                         ,
+                        { "dwLocalAccessCodeSize",          FT_SIZE,    lpLocationEntry->dwLocalAccessCodeSize, NULL },
+                        { "dwLocalAccessCodeOffset",        FT_OFFSET,  lpLocationEntry->dwLocalAccessCodeOffset, NULL },
+                        { "dwLongDistanceAccessCodeSize",   FT_SIZE,    lpLocationEntry->dwLongDistanceAccessCodeSize, NULL },
+                        { "dwLongDistanceAccessCodeOffset", FT_OFFSET,  lpLocationEntry->dwLongDistanceAccessCodeOffset, NULL },
+                        { "dwTollPrefixListSize",           FT_SIZE,    lpLocationEntry->dwTollPrefixListSize, NULL },
+                        { "dwTollPrefixListOffset",         FT_OFFSET,  lpLocationEntry->dwTollPrefixListOffset, NULL },
+                        { "dwCountryID",                    FT_DWORD,   lpLocationEntry->dwCountryID, NULL },
+                        { "dwOptions",                      FT_FLAGS,   lpLocationEntry->dwOptions, aLocationOptions },
+                        { "dwCancelCallWaitingSize",        FT_SIZE,    lpLocationEntry->dwCancelCallWaitingSize, NULL },
+                        { "dwCancelCallWaitingOffset",      FT_OFFSET,  lpLocationEntry->dwCancelCallWaitingOffset, NULL }
+#endif
+                    };
+                    STRUCT_FIELD_HEADER fieldHeader =
+                    {
+                        lpTranslateCaps, // size,offset relative to lpXlatCaps
+                        buf,
+#if TAPI_1_1
+                        17,
+#else
+                        7,
+#endif
+                        fields
+                    };
+
+
+                    sprintf (buf, "LINELOCATIONENTRY[%ld]", i);
+
+                    lpLocationEntry++;
+#if TAPI_1_1
+                    if (params[1].dwValue == 0x10003)
+                    {
+                        //
+                        // Only show ver 1.0 params & munge ptr to
+                        // compensate for for smaller struct size
+                        //
+
+                        fieldHeader.dwNumFields = 7;
+                        lpLocationEntry = (LPLINELOCATIONENTRY)
+                            (((LPBYTE) lpLocationEntry) - 10*sizeof(DWORD));
+
+                    }
+#endif
+                    ShowStructByField (&fieldHeader, TRUE);
+
+                }
+
+                lpCardEntry = (LPLINECARDENTRY)
+                    (((LPBYTE) lpTranslateCaps) +
+                        lpTranslateCaps->dwCardListOffset);
+
+                for (i = 0; i < lpTranslateCaps->dwNumCards; i++)
+                {
+                    char buf[32];
+                    STRUCT_FIELD fields[] =
+                    {
+                        { "dwPermanentCardID",          FT_DWORD,   lpCardEntry->dwPermanentCardID, NULL },
+                        { "dwCardNameSize",             FT_SIZE,    lpCardEntry->dwCardNameSize, NULL },
+                        { "dwCardNameOffset",           FT_OFFSET,  lpCardEntry->dwCardNameOffset, NULL }
+#if TAPI_1_1
+                         ,
+                        { "dwCardNumberDigits",         FT_DWORD,   lpCardEntry->dwCardNumberDigits, NULL },
+                        { "dwSameAreaRuleSize",         FT_SIZE,    lpCardEntry->dwSameAreaRuleSize, NULL },
+                        { "dwSameAreaRuleOffset",       FT_OFFSET,  lpCardEntry->dwSameAreaRuleOffset, NULL },
+                        { "dwLongDistanceRuleSize",     FT_SIZE,    lpCardEntry->dwLongDistanceRuleSize, NULL },
+                        { "dwLongDistanceRuleOffset",   FT_OFFSET,  lpCardEntry->dwLongDistanceRuleOffset, NULL },
+                        { "dwInternationalRuleSize",    FT_SIZE,    lpCardEntry->dwInternationalRuleSize, NULL },
+                        { "dwInternationalRuleOffset",  FT_OFFSET,  lpCardEntry->dwInternationalRuleOffset, NULL },
+                        { "dwOptions",                  FT_FLAGS,   lpCardEntry->dwOptions, aCardOptions }
+#endif
+                    };
+                    STRUCT_FIELD_HEADER fieldHeader =
+                    {
+                        lpTranslateCaps, // size,offset relative to lpXlatCaps
+                        buf,
+#if TAPI_1_1
+                        11,
+#else
+                        3,
+#endif
+                        fields
+                    };
+
+
+                    sprintf (buf, "LINECARDENTRY[%ld]", i);
+
+                    lpCardEntry++;
+#if TAPI_1_1
+                    if (params[1].dwValue == 0x10003)
+                    {
+                        //
+                        // Only show ver 1.0 params & munge ptr to
+                        // compensate for for smaller struct size
+                        //
+
+                        fieldHeader.dwNumFields = 3;
+                        lpCardEntry = (LPLINECARDENTRY)
+                            (((LPBYTE) lpCardEntry) - 8*sizeof(DWORD));
+
+                    }
+#endif
+                    ShowStructByField (&fieldHeader, TRUE);
+                }
+            }
+
+            UpdateResults (FALSE);
+        }
+
+        break;
+    }
+    case lHandoff:
+#if TAPI_2_0
+    case lHandoffW:
+#endif
+    {
+        char szFilename[MAX_STRING_PARAM_SIZE] = "tb20.exe";
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,  0, NULL },
+            { "lpszFileName",   PT_STRING, (DWORD) szFilename, szFilename },
+            { "dwMediaMode",    PT_FLAGS,  dwDefMediaMode, aMediaModes }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lHandoff ?
+                (PFN3) lineHandoff : (PFN3) lineHandoffW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineHandoff };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lHold:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineHold };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lInitialize:
+    {
+        PMYLINEAPP pNewLineApp;
+        char szAppName[MAX_STRING_PARAM_SIZE];
+        DWORD dwNumLineDevs;
+        FUNC_PARAM params[] =
+        {
+            { "lphLineApp",     PT_POINTER, 0, NULL },
+            { "hInstance",      PT_DWORD,   (DWORD) ghInst, NULL },
+            { "lpfnCallback",   PT_POINTER, (DWORD) tapiCallback, tapiCallback },
+            { szlpszAppName,    PT_STRING,  (DWORD) szAppName, szAppName },
+            { "lpdwNumDevs",    PT_POINTER, (DWORD) &dwNumLineDevs, &dwNumLineDevs }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineInitialize };
+
+
+        if (!(pNewLineApp = AllocLineApp()))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue =
+        params[0].u.dwDefValue = (DWORD) &pNewLineApp->hLineApp;
+
+        strcpy (szAppName, szDefAppName);
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HINSTANCEs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            FreeLineApp (pNewLineApp);
+
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineInitialize(
+            (LPHLINEAPP)   params[0].dwValue,
+            (HINSTANCE)    params[1].dwValue,
+            (LINECALLBACK) params[2].dwValue,
+            (LPCSTR)       params[3].dwValue,
+            (LPDWORD)      params[4].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        if (lResult == 0)
+        {
+            ShowStr ("%snum line devs = %ld", szTab, dwNumLineDevs);
+            //SendMessage (ghwndLineApps, LB_SETCURSEL, (WPARAM) i, 0);
+            UpdateWidgetList();
+            gdwNumLineDevs = dwNumLineDevs;
+            SelectWidget ((PMYWIDGET) pNewLineApp);
+        }
+        else
+        {
+            FreeLineApp (pNewLineApp);
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case lInitializeEx:
+    case lInitializeExW:
+    {
+        char                    szAppName[MAX_STRING_PARAM_SIZE];
+        DWORD                   dwNumLineDevs, dwAPIVersion;
+        PMYLINEAPP              pNewLineApp;
+        LINEINITIALIZEEXPARAMS  initExParams;
+        FUNC_PARAM params[] =
+        {
+            { "lphLineApp",     PT_POINTER, 0, NULL },
+            { "hInstance",      PT_DWORD,   (DWORD) ghInst, NULL },
+            { "lpfnCallback",   PT_POINTER, (DWORD) tapiCallback, tapiCallback },
+            { szlpszFriendlyAppName, PT_STRING,  (DWORD) szAppName, szAppName },
+            { "lpdwNumDevs",    PT_POINTER, (DWORD) &dwNumLineDevs, &dwNumLineDevs },
+            { "lpdwAPIVersion", PT_POINTER, (DWORD) &dwAPIVersion, &dwAPIVersion },
+            { "  ->dwAPIVersion",PT_ORDINAL,(DWORD) 0x00020000, aAPIVersions },
+            { "lpInitExParams", PT_POINTER, (DWORD) &initExParams, &initExParams },
+            { "  ->dwOptions",  PT_ORDINAL, (DWORD) LINEINITIALIZEEXOPTION_USECOMPLETIONPORT, aInitExOptions }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 9, funcIndex, params, NULL };
+
+
+        if (!(pNewLineApp = AllocLineApp()))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue =
+        params[0].u.dwDefValue = (DWORD) &pNewLineApp->hLineApp;
+
+        strcpy (szAppName, szDefAppName);
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            FreeLineApp (pNewLineApp);
+
+            break;
+        }
+
+        initExParams.dwTotalSize = sizeof (LINEINITIALIZEEXPARAMS);
+        initExParams.dwOptions = params[8].dwValue;
+        initExParams.Handles.hCompletionPort = ghCompletionPort;
+
+        dwAPIVersion = params[6].dwValue;
+
+        DumpParams (&paramsHeader);
+
+        if (funcIndex == lInitializeEx)
+        {
+            lResult = lineInitializeEx(
+                (LPHLINEAPP)                params[0].dwValue,
+                (HINSTANCE)                 params[1].dwValue,
+                (LINECALLBACK)              params[2].dwValue,
+                (LPCSTR)                    params[3].dwValue,
+                (LPDWORD)                   params[4].dwValue,
+                (LPDWORD)                   params[5].dwValue,
+                (LPLINEINITIALIZEEXPARAMS)  params[7].dwValue
+                );
+        }
+        else
+        {
+            lResult = lineInitializeExW(
+                (LPHLINEAPP)                params[0].dwValue,
+                (HINSTANCE)                 params[1].dwValue,
+                (LINECALLBACK)              params[2].dwValue,
+                (LPCWSTR)                   params[3].dwValue,
+                (LPDWORD)                   params[4].dwValue,
+                (LPDWORD)                   params[5].dwValue,
+                (LPLINEINITIALIZEEXPARAMS)  params[7].dwValue
+                );
+        }
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult == 0)
+        {
+            ShowStr ("%snum line devs = %ld", szTab, dwNumLineDevs);
+
+            if (params[7].dwValue != 0  &&
+                (initExParams.dwOptions & 3) ==
+                    LINEINITIALIZEEXOPTION_USEEVENT)
+            {
+                ShowStr(
+                    "hLineApp x%x was created with the\r\n" \
+                        "USEEVENT option, so you must use\r\n" \
+                        "lineGetMessage to retrieve messages.",
+                    pNewLineApp->hLineApp
+                    );
+            }
+
+            //SendMessage (ghwndLineApps, LB_SETCURSEL, (WPARAM) i, 0);
+            UpdateWidgetList();
+            gdwNumLineDevs = dwNumLineDevs;
+            SelectWidget ((PMYWIDGET) pNewLineApp);
+        }
+        else
+        {
+            FreeLineApp (pNewLineApp);
+        }
+
+        break;
+    }
+#endif
+    case lMakeCall:
+#if TAPI_2_0
+    case lMakeCallW:
+#endif
+    {
+        PMYCALL pNewCall;
+        char szAddress[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,        0, NULL },
+            { szlphCall,            PT_POINTER,      0, NULL },
+            { szlpszDestAddress,    PT_STRING,       (DWORD) szAddress, szAddress },
+            { "dwCountryCode",      PT_DWORD,        dwDefCountryCode, NULL },
+            { szlpCallParams,       PT_CALLPARAMS,   0, lpCallParams }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (funcIndex == lMakeCall ?
+                (PFN5) lineMakeCall : (PFN5) lineMakeCallW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineMakeCall };
+#endif
+
+        CHK_LINE_SELECTED()
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+        params[1].dwValue = params[1].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        strcpy (szAddress, szDefDestAddress);
+
+        if ((lResult = DoFunc (&paramsHeader)) > 0)
+        {
+            if (params[0].dwValue != (DWORD) pLineSel->hLine)
+            {
+                MoveCallToLine (pNewCall, (HLINE) params[0].dwValue);
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        break;
+    }
+    case lMonitorDigits:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD, 0, NULL },
+            { "dwDigitModes",   PT_FLAGS, LINEDIGITMODE_DTMF, aDigitModes }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineMonitorDigits };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lMonitorMedia:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD, 0, NULL },
+            { "dwMediaModes",   PT_FLAGS, dwDefMediaMode, aMediaModes }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineMonitorMedia };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lMonitorTones:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,   0, NULL },
+            { "lpToneList",     PT_POINTER, (DWORD) pBigBuf, pBigBuf },
+            { "dwNumEntries",   PT_DWORD,   1, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineMonitorTones };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lNegotiateAPIVersion:
+    {
+        DWORD dwAPIVersion;
+        LINEEXTENSIONID extID;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,   0, NULL },
+            { szdwDeviceID,         PT_DWORD,   dwDefLineDeviceID, NULL },
+            { "dwAPILowVersion",    PT_DWORD,   0x00010000, aAPIVersions },
+            { "dwAPIHighVersion",   PT_DWORD,   0x10000000, aAPIVersions },
+            { "lpdwAPIVersion",     PT_POINTER, (DWORD) &dwAPIVersion, &dwAPIVersion },
+            { "lpExtensionID",      PT_POINTER, (DWORD) &extID, &extID }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineNegotiateAPIVersion };
+
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStr ("%s%s=x%lx", szTab, szdwAPIVersion, dwAPIVersion);
+            ShowStr(
+                "%sextID.ID0=x%lx, .ID1=x%lx, .ID2=x%lx, .ID3=x%lx, ",
+                szTab,
+                extID.dwExtensionID0,
+                extID.dwExtensionID1,
+                extID.dwExtensionID2,
+                extID.dwExtensionID3
+                );
+        }
+
+        break;
+    }
+    case lNegotiateExtVersion:
+    {
+        DWORD dwExtVersion;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,   0, NULL },
+            { szdwDeviceID,         PT_DWORD,   dwDefLineDeviceID, NULL },
+            { szdwAPIVersion,       PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "dwExtLowVersion",    PT_DWORD,   0x00000000, NULL },
+            { "dwExtHighVersion",   PT_DWORD,   0x80000000, NULL },
+            { "lpdwExtVersion",     PT_POINTER, (DWORD) &dwExtVersion, &dwExtVersion }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineNegotiateExtVersion };
+
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            ShowStr ("%sdwExtVersion=x%lx", szTab, dwExtVersion);
+        }
+
+        break;
+    }
+    default:
+
+        FuncDriver2 (funcIndex);
+        break;
+    }
+
+    gbWideStringParams = FALSE;
+}
+
+//#pragma code_seg ()
+
+#pragma warning (default:4113)
diff --git a/private/tapi/dev/apps/tb/tb.def b/private/tapi/dev/apps/tb/tb.def
new file mode 100644
index 000000000..d2ced5f48
--- /dev/null
+++ b/private/tapi/dev/apps/tb/tb.def
@@ -0,0 +1,13 @@
+NAME         TB
+STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD   MOVEABLE MULTIPLE
+HEAPSIZE     2048
+STACKSIZE    16384
+
+EXPORTS
+    MainWndProc
+    ParamsDlgProc
+    tapiCallback
+    AboutDlgProc
+    IconDlgProc
diff --git a/private/tapi/dev/apps/tb/tb.h b/private/tapi/dev/apps/tb/tb.h
new file mode 100644
index 000000000..f9e46174f
--- /dev/null
+++ b/private/tapi/dev/apps/tb/tb.h
@@ -0,0 +1,872 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-96  Microsoft Corporation
+
+Module Name:
+
+    tb.h
+
+Abstract:
+
+    Header file for the TAPI Browser util
+
+Author:
+
+    Dan Knudson (DanKn)    23-Aug-1994
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include <tapi.h>
+
+
+//
+// Symbolic constants
+//
+
+#define DS_NONZEROFIELDS            0x00000001
+#define DS_ZEROFIELDS               0x00000002
+#define DS_BYTEDUMP                 0x00000004
+
+#define WT_LINEAPP                  1
+#define WT_LINE                     2
+#define WT_CALL                     3
+#define WT_PHONEAPP                 4
+#define WT_PHONE                    5
+
+#define PT_DWORD                    1
+#define PT_FLAGS                    2
+#define PT_POINTER                  3
+#define PT_STRING                   4
+#define PT_CALLPARAMS               5
+#define PT_FORWARDLIST              6
+#define PT_ORDINAL                  7
+
+#define FT_DWORD                    1
+#define FT_FLAGS                    2
+#define FT_ORD                      3
+#define FT_SIZE                     4
+#define FT_OFFSET                   5
+
+#define MAX_STRING_PARAM_SIZE       96
+
+#define MAX_USER_BUTTONS            6
+
+#define MAX_USER_BUTTON_TEXT_SIZE   8
+
+#define MAX_LINEFORWARD_ENTRIES     5
+
+#define TABSIZE 4
+
+#if TAPI_2_0
+#define LAST_LINEERR                LINEERR_DIALVOICEDETECT
+#else
+#define LAST_LINEERR                LINEERR_NOMULTIPLEINSTANCE
+#endif
+
+
+//
+//
+//
+
+typedef LONG (WINAPI *PFN1)(DWORD);
+typedef LONG (WINAPI *PFN2)(DWORD, DWORD);
+typedef LONG (WINAPI *PFN3)(DWORD, DWORD, DWORD);
+typedef LONG (WINAPI *PFN4)(DWORD, DWORD, DWORD, DWORD);
+typedef LONG (WINAPI *PFN5)(DWORD, DWORD, DWORD, DWORD, DWORD);
+typedef LONG (WINAPI *PFN6)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
+typedef LONG (WINAPI *PFN7)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
+typedef LONG (WINAPI *PFN8)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD,
+                            DWORD);
+typedef LONG (WINAPI *PFN9)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD,
+                            DWORD, DWORD);
+typedef LONG (WINAPI *PFN10)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD,
+                                DWORD, DWORD, DWORD);
+typedef LONG (WINAPI *PFN12)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD,
+                                DWORD, DWORD, DWORD, DWORD, DWORD);
+
+
+typedef struct _MYWIDGET
+{
+    DWORD       dwType;
+
+    struct _MYWIDGET   *pNext;
+
+} MYWIDGET, *PMYWIDGET;
+
+
+typedef struct _MYLINEAPP
+{
+    MYWIDGET    Widget;
+
+    HLINEAPP    hLineApp;
+
+} MYLINEAPP, *PMYLINEAPP;
+
+
+typedef struct _MYLINE
+{
+    MYWIDGET    Widget;
+
+    HLINE       hLine;
+
+    HLINEAPP    hLineApp;
+
+    DWORD       dwDevID;
+
+    DWORD       dwPrivileges;
+
+    DWORD       dwMediaModes;
+
+    DWORD       dwAPIVersion;
+
+    PMYLINEAPP  pLineApp;
+
+} MYLINE, *PMYLINE;
+
+
+typedef struct _MYCALL
+{
+    MYWIDGET    Widget;
+
+    HCALL       hCall;
+
+    DWORD       dwCallState;
+
+    LONG        lMakeCallReqID;
+
+    LONG        lDropReqID;
+
+    DWORD       dwCompletionID;
+
+    DWORD       dwNumGatheredDigits;
+
+    char        *lpsGatheredDigits;
+
+    PMYLINE     pLine;
+
+    BOOL        bMonitor;
+
+} MYCALL, *PMYCALL;
+
+
+typedef struct _MYPHONEAPP
+{
+    MYWIDGET    Widget;
+
+    HPHONEAPP   hPhoneApp;
+
+} MYPHONEAPP, *PMYPHONEAPP;
+
+
+typedef struct _MYPHONE
+{
+    MYWIDGET    Widget;
+
+    HPHONE      hPhone;
+
+    HPHONEAPP   hPhoneApp;
+
+    DWORD       dwDevID;
+
+    DWORD       dwPrivilege;
+
+    DWORD       dwAPIVersion;
+
+    PMYPHONEAPP pPhoneApp;
+
+} MYPHONE, *PMYPHONE;
+
+
+typedef struct _LOOKUP
+{
+    DWORD       dwVal;
+
+    char        lpszVal[20];
+
+} LOOKUP, *PLOOKUP;
+
+
+typedef enum
+{
+    lAccept,
+#if TAPI_1_1
+    lAddProvider,
+#if TAPI_2_0
+    lAddProviderW,
+#endif
+#endif
+    lAddToConference,
+#if TAPI_2_0
+    lAgentSpecific,
+#endif
+    lAnswer,
+    lBlindTransfer,
+#if TAPI_2_0
+    lBlindTransferW,
+#endif
+    lClose,
+    lCompleteCall,
+    lCompleteTransfer,
+    lConfigDialog,
+#if TAPI_2_0
+    lConfigDialogW,
+#endif
+#if TAPI_1_1
+    lConfigDialogEdit,
+#if TAPI_2_0
+    lConfigDialogEditW,
+#endif
+    lConfigProvider,
+#endif
+    lDeallocateCall,
+    lDevSpecific,
+    lDevSpecificFeature,
+    lDial,
+#if TAPI_2_0
+    lDialW,
+#endif
+    lDrop,
+    lForward,
+#if TAPI_2_0
+    lForwardW,
+#endif
+    lGatherDigits,
+#if TAPI_2_0
+    lGatherDigitsW,
+#endif
+    lGenerateDigits,
+#if TAPI_2_0
+    lGenerateDigitsW,
+#endif
+    lGenerateTone,
+    lGetAddressCaps,
+#if TAPI_2_0
+    lGetAddressCapsW,
+#endif
+    lGetAddressID,
+#if TAPI_2_0
+    lGetAddressIDW,
+#endif
+    lGetAddressStatus,
+#if TAPI_2_0
+    lGetAddressStatusW,
+    lGetAgentActivityList,
+    lGetAgentActivityListW,
+    lGetAgentCaps,
+    lGetAgentGroupList,
+    lGetAgentStatus,
+#endif
+#if TAPI_1_1
+    lGetAppPriority,
+#if TAPI_2_0
+    lGetAppPriorityW,
+#endif
+#endif
+    lGetCallInfo,
+#if TAPI_2_0
+    lGetCallInfoW,
+#endif
+    lGetCallStatus,
+    lGetConfRelatedCalls,
+#if TAPI_1_1
+    lGetCountry,
+#if TAPI_2_0
+    lGetCountryW,
+#endif
+#endif
+    lGetDevCaps,
+#if TAPI_2_0
+    lGetDevCapsW,
+#endif
+    lGetDevConfig,
+#if TAPI_2_0
+    lGetDevConfigW,
+#endif
+    lGetIcon,
+#if TAPI_2_0
+    lGetIconW,
+#endif
+    lGetID,
+#if TAPI_2_0
+    lGetIDW,
+#endif
+    lGetLineDevStatus,
+#if TAPI_2_0
+    lGetLineDevStatusW,
+    lGetMessage,
+#endif
+    lGetNewCalls,
+    lGetNumRings,
+#if TAPI_1_1
+    lGetProviderList,
+#if TAPI_2_0
+    lGetProviderListW,
+#endif
+#endif
+    lGetRequest,
+#if TAPI_2_0
+    lGetRequestW,
+#endif
+    lGetStatusMessages,
+    lGetTranslateCaps,
+#if TAPI_2_0
+    lGetTranslateCapsW,
+#endif
+    lHandoff,
+#if TAPI_2_0
+    lHandoffW,
+#endif
+    lHold,
+    lInitialize,
+#if TAPI_2_0
+    lInitializeEx,
+    lInitializeExW,
+#endif
+    lMakeCall,
+#if TAPI_2_0
+    lMakeCallW,
+#endif
+    lMonitorDigits,
+    lMonitorMedia,
+    lMonitorTones,
+    lNegotiateAPIVersion,
+    lNegotiateExtVersion,
+    lOpen,
+#if TAPI_2_0
+    lOpenW,
+#endif
+    lPark,
+#if TAPI_2_0
+    lParkW,
+#endif
+    lPickup,
+#if TAPI_2_0
+    lPickupW,
+#endif
+    lPrepareAddToConference,
+#if TAPI_2_0
+    lPrepareAddToConferenceW,
+    lProxyMessage,
+    lProxyResponse,
+#endif
+    lRedirect,
+#if TAPI_2_0
+    lRedirectW,
+#endif
+    lRegisterRequestRecipient,
+#if TAPI_1_1
+    lReleaseUserUserInfo,
+#endif
+    lRemoveFromConference,
+#if TAPI_1_1
+    lRemoveProvider,
+#endif
+    lSecureCall,
+    lSendUserUserInfo,
+#if TAPI_2_0
+    lSetAgentActivity,
+    lSetAgentGroup,
+    lSetAgentState,
+#endif
+#if TAPI_1_1
+    lSetAppPriority,
+#if TAPI_2_0
+    lSetAppPriorityW,
+#endif
+#endif
+    lSetAppSpecific,
+#if TAPI_2_0
+    lSetCallData,
+#endif
+    lSetCallParams,
+    lSetCallPrivilege,
+#if TAPI_2_0
+    lSetCallQualityOfService,
+    lSetCallTreatment,
+#endif
+    lSetCurrentLocation,
+    lSetDevConfig,
+#if TAPI_2_0
+    lSetDevConfigW,
+    lSetLineDevStatus,
+#endif
+    lSetMediaControl,
+    lSetMediaMode,
+    lSetNumRings,
+    lSetStatusMessages,
+    lSetTerminal,
+    lSetTollList,
+#if TAPI_2_0
+    lSetTollListW,
+#endif
+    lSetupConference,
+#if TAPI_2_0
+    lSetupConferenceW,
+#endif
+    lSetupTransfer,
+#if TAPI_2_0
+    lSetupTransferW,
+#endif
+    lShutdown,
+    lSwapHold,
+    lTranslateAddress,
+#if TAPI_2_0
+    lTranslateAddressW,
+#endif
+#if TAPI_1_1
+    lTranslateDialog,
+#if TAPI_2_0
+    lTranslateDialogW,
+#endif
+#endif
+    lUncompleteCall,
+    lUnhold,
+    lUnpark,
+#if TAPI_2_0
+    lUnparkW,
+#endif
+
+    pClose,
+    pConfigDialog,
+#if TAPI_2_0
+    pConfigDialogW,
+#endif
+    pDevSpecific,
+    pGetButtonInfo,
+#if TAPI_2_0
+    pGetButtonInfoW,
+#endif
+    pGetData,
+    pGetDevCaps,
+#if TAPI_2_0
+    pGetDevCapsW,
+#endif
+    pGetDisplay,
+    pGetGain,
+    pGetHookSwitch,
+    pGetIcon,
+#if TAPI_2_0
+    pGetIconW,
+#endif
+    pGetID,
+#if TAPI_2_0
+    pGetIDW,
+#endif
+    pGetLamp,
+#if TAPI_2_0
+    pGetMessage,
+#endif
+    pGetRing,
+    pGetStatus,
+#if TAPI_2_0
+    pGetStatusW,
+#endif
+    pGetStatusMessages,
+    pGetVolume,
+    pInitialize,
+#if TAPI_2_0
+    pInitializeEx,
+    pInitializeExW,
+#endif
+    pOpen,
+    pNegotiateAPIVersion,
+    pNegotiateExtVersion,
+    pSetButtonInfo,
+#if TAPI_2_0
+    pSetButtonInfoW,
+#endif
+    pSetData,
+    pSetDisplay,
+    pSetGain,
+    pSetHookSwitch,
+    pSetLamp,
+    pSetRing,
+    pSetStatusMessages,
+    pSetVolume,
+    pShutdown,
+
+    tGetLocationInfo,
+#if TAPI_2_0
+    tGetLocationInfoW,
+#endif
+    tRequestDrop,
+    tRequestMakeCall,
+#if TAPI_2_0
+    tRequestMakeCallW,
+#endif
+    tRequestMediaCall,
+#if TAPI_2_0
+    tRequestMediaCallW,
+#endif
+
+    OpenAllLines,
+    OpenAllPhones,
+    CloseHandl,
+    DumpBuffer,
+
+    MiscBegin,
+
+    DefValues,
+    lCallParams,
+    lForwardList
+
+} FUNC_INDEX;
+
+
+typedef struct _FUNC_PARAM
+{
+    char far    *szName;
+
+    DWORD       dwType;
+
+    DWORD       dwValue;
+
+    union
+    {
+        LPVOID  pLookup;
+
+        char far *buf;
+
+        LPVOID  ptr;
+
+        DWORD   dwDefValue;
+
+    } u;
+
+} FUNC_PARAM, *PFUNC_PARAM;
+
+
+typedef struct _FUNC_PARAM_HEADER
+{
+    DWORD       dwNumParams;
+
+    FUNC_INDEX  FuncIndex;
+
+    PFUNC_PARAM aParams;
+
+    union
+    {
+        PFN1    pfn1;
+        PFN2    pfn2;
+        PFN3    pfn3;
+        PFN4    pfn4;
+        PFN5    pfn5;
+        PFN6    pfn6;
+        PFN7    pfn7;
+        PFN8    pfn8;
+        PFN9    pfn9;
+        PFN10   pfn10;
+        PFN12   pfn12;
+
+    } u;
+
+} FUNC_PARAM_HEADER, *PFUNC_PARAM_HEADER;
+
+
+typedef struct _STRUCT_FIELD
+{
+    char far    *szName;
+
+    DWORD       dwType;
+
+    DWORD       dwValue;
+
+    LPVOID      pLookup;
+
+} STRUCT_FIELD, *PSTRUCT_FIELD;
+
+
+typedef struct _STRUCT_FIELD_HEADER
+{
+    LPVOID      pStruct;
+
+    char far    *szName;
+
+    DWORD       dwNumFields;
+
+    PSTRUCT_FIELD   aFields;
+
+} STRUCT_FIELD_HEADER, *PSTRUCT_FIELD_HEADER;
+
+
+//
+// Func prototypes
+//
+
+BOOL
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+void
+FAR
+ShowStr(
+    LPCSTR format,
+    ...
+    );
+
+void
+ShowBytes(
+    DWORD   dwSize,
+    LPVOID  lp,
+    DWORD   dwNumTabs
+    );
+
+VOID
+CALLBACK
+tapiCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    );
+
+BOOL
+CALLBACK
+ParamsDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+BOOL
+CALLBACK
+IconDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+BOOL
+IsLineAppSelected(
+    void
+    );
+
+BOOL
+IsLineSelected(
+    void
+    );
+
+BOOL
+IsCallSelected(
+    void
+    );
+
+BOOL
+IsTwoCallsSelected(
+    void
+    );
+
+BOOL
+IsPhoneAppSelected(
+    void
+    );
+
+BOOL
+IsPhoneSelected(
+    void
+    );
+
+LONG
+DoFunc(
+    PFUNC_PARAM_HEADER pHeader
+    );
+
+BOOL
+LetUserMungeParams(
+    PFUNC_PARAM_HEADER pParamsHeader
+    );
+
+void
+ShowLineFuncResult(
+    LPSTR lpFuncName,
+    LONG  lResult
+    );
+
+void
+FuncDriver(
+    FUNC_INDEX funcIndex
+    );
+
+void
+UpdateWidgetList(
+    void
+    );
+
+void
+InsertWidgetInList(
+    PMYWIDGET pNewWidget,
+    PMYWIDGET pWidgetInsertBefore
+    );
+
+BOOL
+RemoveWidgetFromList(
+    PMYWIDGET pWidgetToRemove
+    );
+
+PMYLINEAPP
+AllocLineApp(
+    void
+    );
+
+PMYLINEAPP
+GetLineApp(
+    HLINEAPP hLineApp
+    );
+
+VOID
+FreeLineApp(
+    PMYLINEAPP pLineApp
+    );
+
+PMYLINE
+AllocLine(
+    PMYLINEAPP pLineApp
+    );
+
+PMYLINE
+GetLine(
+    HLINE hLine
+    );
+
+VOID
+FreeLine(
+    PMYLINE pLine
+    );
+
+PMYCALL
+AllocCall(
+    PMYLINE pLine
+    );
+
+PMYCALL
+GetCall(
+    HCALL hCall
+    );
+
+VOID
+FreeCall(
+    PMYCALL pCall
+    );
+
+VOID
+MoveCallToLine(
+    PMYCALL pCall,
+    HLINE hLine
+    );
+
+PMYPHONEAPP
+AllocPhoneApp(
+    void
+    );
+
+PMYPHONEAPP
+GetPhoneApp(
+    HPHONEAPP hPhoneApp
+    );
+
+VOID
+FreePhoneApp(
+    PMYPHONEAPP pPhoneApp
+    );
+
+PMYPHONE
+AllocPhone(
+    PMYPHONEAPP pPhoneApp
+    );
+
+PMYPHONE
+GetPhone(
+    HPHONE hPhone
+    );
+
+VOID
+FreePhone(
+    PMYPHONE pPhone
+    );
+
+int
+GetWidgetIndex(
+    PMYWIDGET pWidget
+    );
+
+void
+SelectWidget(
+    PMYWIDGET pWidget
+    );
+
+void
+UpdateResults(
+    BOOL bBegin
+    );
+
+BOOL
+CALLBACK
+UserButtonsDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+
+//
+// Macros
+//
+
+#define CHK_LINEAPP_SELECTED()                      \
+        if (!IsLineAppSelected())                   \
+        {                                           \
+            break;                                  \
+        }
+
+#define CHK_LINE_SELECTED()                         \
+        if (!IsLineSelected())                      \
+        {                                           \
+            break;                                  \
+        }
+
+#define CHK_CALL_SELECTED()                         \
+        if (!IsCallSelected())                      \
+        {                                           \
+            break;                                  \
+        }
+
+#define CHK_TWO_CALLS_SELECTED()                    \
+        if (!IsTwoCallsSelected())                  \
+        {                                           \
+            break;                                  \
+        }
+
+#define CHK_PHONEAPP_SELECTED()                     \
+        if (!IsPhoneAppSelected())                  \
+        {                                           \
+            break;                                  \
+        }
+
+#define CHK_PHONE_SELECTED()                        \
+        if (!IsPhoneSelected())                     \
+        {                                           \
+            break;                                  \
+        }
diff --git a/private/tapi/dev/apps/tb/tb.ico b/private/tapi/dev/apps/tb/tb.ico
new file mode 100644
index 000000000..89de5322d
--- /dev/null
+++ b/private/tapi/dev/apps/tb/tb.ico
diff --git a/private/tapi/dev/apps/tb/tb.rc b/private/tapi/dev/apps/tb/tb.rc
new file mode 100644
index 000000000..21b3b8210
--- /dev/null
+++ b/private/tapi/dev/apps/tb/tb.rc
@@ -0,0 +1,266 @@
+//Microsoft App Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#ifdef WIN32
+#include "windows.h"
+#else
+#include "afxres.h"
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+#ifdef APSTUDIO_INVOKED
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 292, 217
+STYLE WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU | 
+    WS_THICKFRAME | WS_CLIPCHILDREN
+CAPTION "Tapi Browser"
+MENU IDR_MENU1
+FONT 6, "Courier"
+BEGIN
+    CONTROL         "Params",IDC_BUTTON12,"Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,2,4,25,10
+    PUSHBUTTON      "LAp+",IDC_BUTTON1,30,1,14,16
+    PUSHBUTTON      "LAp-",IDC_BUTTON2,44,1,14,16
+    PUSHBUTTON      "Line+",IDC_BUTTON3,58,1,14,16
+    PUSHBUTTON      "Line-",IDC_BUTTON4,72,1,14,16
+    PUSHBUTTON      "Call+",IDC_BUTTON5,86,1,14,16
+    PUSHBUTTON      "Call-",IDC_BUTTON6,100,1,14,16
+    PUSHBUTTON      "PAp+",IDC_BUTTON7,118,1,14,16
+    PUSHBUTTON      "PAp-",IDC_BUTTON8,132,1,14,16
+    PUSHBUTTON      "Pho+",IDC_BUTTON9,146,1,14,16
+    PUSHBUTTON      "Pho-",IDC_BUTTON10,160,1,14,16
+    PUSHBUTTON      "Clear",IDC_BUTTON11,178,1,14,16
+    PUSHBUTTON      "",IDC_BUTTON13,196,1,14,16
+    PUSHBUTTON      "",IDC_BUTTON14,210,1,14,16
+    PUSHBUTTON      "",IDC_BUTTON15,224,1,14,16
+    PUSHBUTTON      "",IDC_BUTTON16,238,1,14,16
+    PUSHBUTTON      "",IDC_BUTTON17,252,1,14,16
+    PUSHBUTTON      "",IDC_BUTTON18,266,1,14,16
+    EDITTEXT        IDC_EDIT1,129,19,117,195,ES_MULTILINE | ES_AUTOVSCROLL | 
+                    ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL | 0x1000
+    LISTBOX         IDC_LIST1,70,20,58,194, LBS_NOINTEGRALHEIGHT |
+                    WS_VSCROLL | WS_TABSTOP
+    LISTBOX         IDC_LIST2,2,20,65,197,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+END
+
+IDD_DIALOG2 DIALOG DISCARDABLE  0, 0, 205, 192
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION ""
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Parameters:",55,4,6,42,7
+    LISTBOX         IDC_LIST1,4,16,100,148,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Value:",56,116,6,30,7
+    COMBOBOX        IDC_COMBO1,116,16,80,47,CBS_SIMPLE | CBS_AUTOHSCROLL |
+                    CBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Bit flags:",57,116,66,40,9
+    LISTBOX         IDC_LIST2,116,75,80,89,LBS_MULTIPLESEL | 
+                    LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,116,171,36,14
+    PUSHBUTTON      "Cancel",IDCANCEL,160,171,37,14
+// help    PUSHBUTTON      "Help",IDC_TB_HELP,4,171,36,14
+END
+
+IDD_DIALOG3 DIALOG DISCARDABLE  0, 0, 203, 198
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "User-defined buttons"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Button number:",55,8,8,54,7
+    LISTBOX         IDC_LIST1,8,18,50,72,LBS_SORT | LBS_NOINTEGRALHEIGHT |
+                    WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Button function:",56,78,8,58,7
+    LISTBOX         IDC_LIST2,79,18,118,174,LBS_SORT | LBS_NOINTEGRALHEIGHT |
+                    WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Button Text:",57,8,100,45,7
+    EDITTEXT        IDC_EDIT1,9,110,28,11,ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "OK",IDOK,8,158,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,8,178,50,14
+END
+
+IDD_DIALOG4 DIALOG DISCARDABLE  0, 0, 185, 69
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "About TAPI Browser"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,69,50,50,14
+    LTEXT           "TAPI Browser v2.0",38,80,12,70,7
+    LTEXT           "Copyright (c) 1994-95  Microsoft Corporation",70,20,30,168,
+                    12
+    ICON            IDI_ICON1,IDC_STATIC1,52,5,18,20
+END
+
+IDD_DIALOG5 DIALOG DISCARDABLE  0, 0, 90, 69
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Displaying Icon"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,35,50,50,14
+END
+
+IDD_DIALOG6 DIALOG 6, 18, 192, 173
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Using the TAPI Browser"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK", IDOK, 66, 157, 60, 14
+    EDITTEXT        IDC_EDIT1, 4, 4, 184, 150, ES_MULTILINE | ES_AUTOVSCROLL |
+                    ES_AUTOHSCROLL | ES_READONLY | WS_VSCROLL
+END
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MENU1 MENU DISCARDABLE
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Clear",                      IDM_CLEAR
+        MENUITEM SEPARATOR
+        MENUITEM "&Params",                     IDM_PARAMS
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       IDM_EXIT
+    END
+    POPUP "&Options"
+    BEGIN
+        MENUITEM "&Default values...",          IDM_DEFAULTVALUES
+        MENUITEM SEPARATOR
+        MENUITEM "&User buttons...",            IDM_USERBUTTONS
+        MENUITEM SEPARATOR
+        MENUITEM "Log &parameters",             IDM_DUMPPARAMS
+        POPUP "Log &structures"
+        BEGIN
+            MENUITEM "by &fields (all)",            IDM_LOGSTRUCTALLFIELD
+            MENUITEM "by fields (&non-zero only)",  IDM_LOGSTRUCTNONZEROFIELD
+            MENUITEM "by &DWORDs/ASCII",            IDM_LOGSTRUCTDWORD
+            MENUITEM "by n&one",                    IDM_LOGSTRUCTNONE
+        END
+        MENUITEM SEPARATOR
+        MENUITEM "&Show time stamps",           IDM_TIMESTAMP
+        MENUITEM SEPARATOR
+        MENUITEM "Record log &file",            IDM_LOGFILE
+        MENUITEM SEPARATOR
+        MENUITEM "Auto-deallocate idle &monitored calls", IDM_NUKEIDLEMONITORCALLS
+        MENUITEM "Auto-deallocate idle &owned calls", IDM_NUKEIDLEOWNEDCALLS
+        MENUITEM SEPARATOR
+        MENUITEM "Disable handle checking",     IDM_NOHANDLECHK
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Using TB...",                IDM_USINGTB
+// help       MENUITEM SEPARATOR
+// help       MENUITEM "&Telephony API help...\tF1",  IDM_TAPIHLP
+// help       MENUITEM "Telephony &SPI help...",      IDM_TSPIHLP
+        MENUITEM SEPARATOR
+        MENUITEM "&About TB...",                IDM_ABOUT
+    END
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+IDI_ICON1               ICON    DISCARDABLE     "TB.ICO"
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDR_ACCELERATOR1 ACCELERATORS DISCARDABLE
+BEGIN
+// help    VK_F1, IDC_F1HELP, VIRTKEY
+    VK_TAB, IDC_PREVCTRL, VIRTKEY, SHIFT
+    VK_TAB, IDC_NEXTCTRL, VIRTKEY
+    VK_RETURN, IDC_ENTER, VIRTKEY
+END
+
+
+#ifndef APSTUDIO_INVOKED
+////////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <ver.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) TAPI Browser"
+#if TAPI_1_1
+#if TAPI_2_0
+#define VER_INTERNALNAME_STR        "tb20"
+#define VER_ORIGINALFILENAME_STR    "TB20.EXE"
+#else
+#define VER_INTERNALNAME_STR        "tb14"
+#define VER_ORIGINALFILENAME_STR    "TB14.EXE"
+#endif
+#else
+#define VER_INTERNALNAME_STR        "tb13"
+#define VER_ORIGINALFILENAME_STR    "TB13.EXE"
+#endif
+
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
diff --git a/private/tapi/dev/apps/tb/tb2.c b/private/tapi/dev/apps/tb/tb2.c
new file mode 100644
index 000000000..242d4bd61
--- /dev/null
+++ b/private/tapi/dev/apps/tb/tb2.c
@@ -0,0 +1,3877 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-96  Microsoft Corporation
+
+Module Name:
+
+    tb2.c
+
+Abstract:
+
+    API wrapper code for the TAPI Browser util.  Contains the big switch
+    statement for all the supported Telephony API's, & various support funcs.
+
+Author:
+
+    Dan Knudson (DanKn)    18-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <malloc.h>
+#include "tb.h"
+#include "vars.h"
+#include "resource.h"
+
+
+extern char szdwDeviceID[];
+extern char szdwSize[];
+extern char szhCall[];
+extern char szhLine[];
+extern char szhLineApp[];
+extern char szhPhone[];
+extern char szlpCallParams[];
+
+extern char szlphCall[];
+extern char szlpParams[];
+extern char szhwndOwner[];
+extern char szdwAddressID[];
+extern char szlpszAppName[];
+extern char szdwAPIVersion[];
+extern char szlphConsultCall[];
+extern char szlpszDeviceClass[];
+extern char szlpszDestAddress[];
+extern char szlpsUserUserInfo[];
+extern char szlpszFriendlyAppName[];
+
+char szhPhoneApp[] = "hPhoneApp";
+
+
+void
+ShowStructByDWORDs(
+    LPVOID  lp
+    );
+
+void
+ShowStructByField(
+    PSTRUCT_FIELD_HEADER    pHeader,
+    BOOL    bSubStructure
+    );
+
+void
+DumpParams(
+    PFUNC_PARAM_HEADER pHeader
+    );
+
+void
+ShowPhoneFuncResult(
+    LPSTR lpFuncName,
+    LONG  lResult
+    );
+
+void
+ShowVARSTRING(
+    LPVARSTRING lpVarString
+    );
+
+void
+ShowTapiFuncResult(
+    LPSTR lpFuncName,
+    LONG  lResult
+    );
+
+VOID
+UpdateWidgetListCall(
+    PMYCALL pCall
+    );
+
+
+//
+// We get a slough of C4113 (func param lists differed) warnings down below
+// in the initialization of FUNC_PARAM_HEADER structs as a result of the
+// real func prototypes having params that are pointers rather than DWORDs,
+// so since these are known non-interesting warnings just turn them off
+//
+
+#pragma warning (disable:4113)
+
+void
+FuncDriver2(
+    FUNC_INDEX funcIndex
+    )
+{
+    int     i;
+    LONG    lResult;
+
+
+    switch (funcIndex)
+    {
+    case lOpen:
+#if TAPI_2_0
+    case lOpenW:
+#endif
+    {
+        PMYLINE pNewLine;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,       0, NULL },
+            { szdwDeviceID,         PT_DWORD,       dwDefLineDeviceID, NULL },
+            { "lphLine",            PT_POINTER,     0, NULL },
+            { szdwAPIVersion,       PT_ORDINAL,     dwDefLineAPIVersion, aAPIVersions },
+            { "dwExtVersion",       PT_DWORD,       dwDefLineExtVersion, NULL },
+            { "dwCallbackInstance", PT_DWORD,       0, NULL },
+            { "dwPrivileges",       PT_FLAGS,       dwDefLinePrivilege, aLineOpenOptions },
+            { "dwMediaModes",       PT_FLAGS,       dwDefMediaMode, aMediaModes },
+            { szlpCallParams,       PT_CALLPARAMS,  0, lpCallParams }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 9, funcIndex, params, (funcIndex == lOpen ?
+                (PFN9) lineOpen : (PFN9) lineOpenW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 9, funcIndex, params, (PFN9) lineOpen };
+#endif
+
+        CHK_LINEAPP_SELECTED()
+
+        if (!(pNewLine = AllocLine (pLineAppSel)))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+        params[2].dwValue =
+        params[2].u.dwDefValue = (DWORD) &pNewLine->hLine;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            if ((HLINEAPP) params[0].dwValue != pLineAppSel->hLineApp)
+            {
+                //
+                // User has switched line apps on us we need to recreate
+                // the line data structure under a different line app
+                //
+
+                PMYLINE pNewLine2 =
+                    AllocLine (GetLineApp((HLINEAPP)params[0].dwValue));
+
+                if (pNewLine2)
+                {
+                    pNewLine2->hLine = pNewLine->hLine;
+
+                    FreeLine (pNewLine);
+
+                    pNewLine = pNewLine2;
+                }
+                else
+                {
+                    // BUGBUG show error: couldn't alloc a new line struct
+
+                    lineClose (pNewLine->hLine);
+                    FreeLine  (pNewLine);
+                    break;
+                }
+            }
+
+
+            //
+            // Save info about this line that we can display
+            //
+
+            pNewLine->hLineApp     = (HLINEAPP) params[0].dwValue;
+            pNewLine->dwDevID      = params[1].dwValue;
+            pNewLine->dwAPIVersion = params[3].dwValue;
+            pNewLine->dwPrivileges = params[6].dwValue;
+            pNewLine->dwMediaModes = params[7].dwValue;
+
+            //SendMessage (ghwndLines, LB_SETCURSEL, (WPARAM) i, 0);
+            UpdateWidgetList();
+            SelectWidget ((PMYWIDGET) pNewLine);
+        }
+        else
+        {
+            FreeLine (pNewLine);
+        }
+
+        break;
+    }
+    case lPark:
+#if TAPI_2_0
+    case lParkW:
+#endif
+    {
+        char szDirAddress[MAX_STRING_PARAM_SIZE] = "";
+        LPVARSTRING lpNonDirAddress = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,            PT_DWORD,   0, NULL },
+            { "dwParkMode",       PT_ORDINAL, LINEPARKMODE_DIRECTED, aParkModes },
+            { "lpszDirAddress",   PT_STRING,  (DWORD) szDirAddress, szDirAddress },
+            { "lpNonDirAddress",  PT_POINTER, (DWORD) lpNonDirAddress, lpNonDirAddress }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (funcIndex == lPark ?
+                (PFN4) linePark : (PFN4) lineParkW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) linePark };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        memset (lpNonDirAddress, 0, (size_t) dwBigBufSize);
+        lpNonDirAddress->dwTotalSize = dwBigBufSize;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lPickup:
+#if TAPI_2_0
+    case lPickupW:
+#endif
+    {
+        PMYCALL pNewCall;
+        char szDestAddress[MAX_STRING_PARAM_SIZE];
+        char szGroupID[MAX_STRING_PARAM_SIZE] = "";
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { szlphCall,            PT_POINTER, 0, NULL },
+            { szlpszDestAddress,    PT_STRING,  (DWORD) szDestAddress, szDestAddress },
+            { "lpszGroupID",        PT_STRING,  (DWORD) szGroupID, szGroupID }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (funcIndex == lPickup ?
+                (PFN5) linePickup : (PFN5) linePickupW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) linePickup };
+#endif
+
+
+        CHK_LINE_SELECTED()
+
+
+        //
+        // Find a free entry in the call array
+        //
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+        params[2].dwValue = params[2].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        strcpy (szDestAddress, szDefDestAddress);
+
+        if ((lResult = DoFunc (&paramsHeader)) >= 0)
+        {
+            if (params[0].dwValue != (DWORD) pLineSel->hLine)
+            {
+                MoveCallToLine (pNewCall, (HLINE) params[0].dwValue);
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        break;
+    }
+    case lPrepareAddToConference:
+#if TAPI_2_0
+    case lPrepareAddToConferenceW:
+#endif
+    {
+        PMYCALL pNewCall;
+        FUNC_PARAM params[] =
+        {
+            { "hConfCall",          PT_DWORD,       0, NULL },
+            { szlphConsultCall,     PT_POINTER,     0, NULL },
+            { szlpCallParams,       PT_CALLPARAMS,  0, lpCallParams }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lPrepareAddToConference ?
+                (PFN3) linePrepareAddToConference : (PFN3) linePrepareAddToConferenceW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) linePrepareAddToConference };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[1].dwValue = params[1].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) >= 0)
+        {
+            //
+            // First make sure we're created the call under the right line,
+            // and if not move it to the right place in the widgets list
+            //
+
+            LINECALLINFO callInfo;
+
+
+            memset (&callInfo, 0, sizeof(LINECALLINFO));
+            callInfo.dwTotalSize = sizeof(LINECALLINFO);
+            if (lineGetCallInfo ((HCALL) params[0].dwValue, &callInfo) == 0)
+            {
+                if (callInfo.hLine != pLineSel->hLine)
+                {
+                    MoveCallToLine (pNewCall, callInfo.hLine);
+                }
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case lProxyMessage:
+    {
+        static LOOKUP aValidProxyMsgs[] =
+        {
+            { LINE_AGENTSPECIFIC    ,"AGENTSPECIFIC"    },
+            { LINE_AGENTSTATUS      ,"AGENTSTATUS"      },
+            { 0xffffffff            ,""                 }
+        };
+
+        FUNC_PARAM params[] =
+        {
+            { szhLine,      PT_DWORD,   (DWORD) 0, NULL },
+            { szhCall,      PT_DWORD,   (DWORD) 0, NULL },
+            { "dwMsg",      PT_ORDINAL, (DWORD) LINE_AGENTSTATUS, aValidProxyMsgs },
+            { "dwParam1",   PT_DWORD,   (DWORD) 0, NULL },
+            { "dwParam2",   PT_FLAGS,   (DWORD) 0, aAgentStatus },
+            { "dwParam3",   PT_ORDINAL, (DWORD) 0, aAgentStates }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineProxyMessage };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if (pCallSel)
+        {
+            params[1].dwValue = (DWORD) pCallSel->hCall;
+        }
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lProxyResponse:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD,   0, NULL },
+            { "lpProxyBuffer",  PT_DWORD,   0, NULL },
+            { "dwResult",       PT_DWORD,   0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineProxyResponse };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+#endif
+    case lRedirect:
+#if TAPI_2_0
+    case lRedirectW:
+#endif
+    {
+        char szDestAddress[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpszDestAddress,    PT_STRING, (DWORD) szDestAddress, szDestAddress },
+            { "dwCountryCode",      PT_DWORD,  dwDefCountryCode, NULL }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lRedirect ?
+                (PFN3) lineRedirect : (PFN3) lineRedirectW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineRedirect };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szDestAddress, szDefDestAddress);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lRegisterRequestRecipient:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,               PT_DWORD,  0, NULL },
+            { "dwRegistrationInstance", PT_DWORD,  0, NULL },
+            { "dwRequestMode",          PT_FLAGS,  LINEREQUESTMODE_MAKECALL, aRequestModes2 },
+            { "bEnable",                PT_DWORD,  1, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineRegisterRequestRecipient };
+
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lRemoveFromConference:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineRemoveFromConference };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSecureCall:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineSecureCall };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSendUserUserInfo:
+    {
+        char szUserUserInfo[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,  0, NULL },
+            { szlpsUserUserInfo,    PT_STRING, (DWORD) szUserUserInfo, szUserUserInfo },
+            { szdwSize,             PT_DWORD,  strlen(szDefUserUserInfo)+1, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSendUserUserInfo };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        strcpy (szUserUserInfo, szDefUserUserInfo);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+#if TAPI_2_0
+    case lSetAgentActivity:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD, 0, NULL },
+            { szdwAddressID,    PT_DWORD, 0, NULL },
+            { "dwActivityID",   PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSetAgentActivity };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetAgentGroup:
+    {
+        LPLINEAGENTGROUPLIST    lpGroupList = (LPLINEAGENTGROUPLIST) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { "lpAgentGroupList",   PT_POINTER, (DWORD) lpGroupList, lpGroupList }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetAgentGroupList };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+// BUGBUG SetAgentGRp: allow user to fill in agent group list
+
+        memset (lpGroupList, 0, (size_t) dwBigBufSize);
+        lpGroupList->dwTotalSize = dwBigBufSize;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetAgentState:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD, (DWORD) 0, NULL },
+            { szdwAddressID,        PT_DWORD, (DWORD) 0, NULL },
+            { "dwAgentState",       PT_FLAGS, (DWORD) 0, aAgentStates },
+            { "dwNextAgentState",   PT_FLAGS, (DWORD) 0, aAgentStates }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineSetAgentState };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+#endif
+    case lSetAppSpecific:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD, 0, NULL },
+            { "dwAppSpecific",  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineSetAppSpecific };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+#if TAPI_2_0
+    case lSetCallData:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,      PT_DWORD,   0, NULL },
+            { "lpCallData", PT_POINTER, (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,     PT_DWORD,   (DWORD) dwBigBufSize, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSetCallData };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+#endif
+    case lSetCallParams:
+    {
+        LINEDIALPARAMS dialParams;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,                  PT_DWORD,   0, NULL },
+            { "dwBearerMode",           PT_FLAGS,   dwDefBearerMode, aBearerModes },
+            { "dwMinRate",              PT_DWORD,   3100, NULL },
+            { "dwMaxRate",              PT_DWORD,   3100, NULL },
+            { "lpDialParams",           PT_POINTER, 0, &dialParams },
+            { "  ->dwDialPause",        PT_DWORD,   0, NULL },
+            { "  ->dwDialSpeed",        PT_DWORD,   0, NULL },
+            { "  ->dwDigitDuration",    PT_DWORD,   0, NULL },
+            { "  ->dwWaitForDialtone",  PT_DWORD,   0, NULL }
+
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 9, funcIndex, params, NULL };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        dialParams.dwDialPause       = params[5].dwValue;
+        dialParams.dwDialSpeed       = params[6].dwValue;
+        dialParams.dwDigitDuration   = params[7].dwValue;
+        dialParams.dwWaitForDialtone = params[8].dwValue;
+
+        lResult = lineSetCallParams(
+            (HCALL)   params[0].dwValue,
+            params[1].dwValue,
+            params[2].dwValue,
+            params[3].dwValue,
+            (LPLINEDIALPARAMS) params[4].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        break;
+    }
+    case lSetCallPrivilege:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,              PT_DWORD,   0, NULL },
+            { "dwCallPrivilege",    PT_ORDINAL, LINECALLPRIVILEGE_OWNER, aCallPrivileges }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineSetCallPrivilege };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            if (params[0].dwValue == (DWORD) pCallSel->hCall)
+            {
+                pCallSel->bMonitor =  (params[0].dwValue ==
+                    LINECALLPRIVILEGE_MONITOR ? TRUE : FALSE);
+                UpdateWidgetListCall (pCallSel);
+            }
+            else
+            {
+                PMYCALL pCall;
+
+
+                if ((pCall = GetCall ((HCALL) params[0].dwValue)))
+                {
+                    pCall->bMonitor =  (params[0].dwValue ==
+                        LINECALLPRIVILEGE_MONITOR ? TRUE : FALSE);
+                    UpdateWidgetListCall (pCall);
+                }
+            }
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case lSetCallQualityOfService:
+    {
+        char szSendingFlowspec[MAX_STRING_PARAM_SIZE] = "123";
+        char szReceivingFlowspec[MAX_STRING_PARAM_SIZE] = "321";
+        FUNC_PARAM params[] =
+        {
+            { szhCall,                  PT_DWORD, (DWORD) 0, NULL },
+            { "lpSendingFlowspec",      PT_STRING, (DWORD) szSendingFlowspec, szSendingFlowspec },
+            { "dwSendingFlowspecSize",  PT_DWORD, (DWORD) 4, 0 },
+            { "lpReceivingFlowspec",    PT_STRING, (DWORD) szReceivingFlowspec, szReceivingFlowspec },
+            { "dwReceivingFlowspecSize",PT_DWORD, (DWORD) 4, 0 }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineSetCallQualityOfService };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetCallTreatment:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,      PT_DWORD,   0, NULL },
+            { "dwTreatment",PT_ORDINAL, LINECALLTREATMENT_SILENCE, aCallTreatments }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineSetCallTreatment };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+#endif
+    case lSetCurrentLocation:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,   PT_DWORD, 0, NULL },
+            { "dwLocation", PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineSetCurrentLocation };
+
+
+        if (pLineAppSel)
+        {
+            params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+        }
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetDevConfig:
+#if TAPI_2_0
+    case lSetDevConfigW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        char szErrorMsg[] = "Bad config info in buffer";
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,         PT_DWORD,   0, NULL },
+            { "lpDeviceConfig",     PT_POINTER, 0, NULL },
+            { szdwSize,             PT_DWORD,   0, NULL },
+            { szlpszDeviceClass,    PT_STRING,  (DWORD) szDeviceClass, szDeviceClass },
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (funcIndex == lSetDevConfig ?
+                (PFN4) lineSetDevConfig : (PFN4) lineSetDevConfigW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineSetDevConfig };
+#endif
+
+        //
+        // Check to see if there's existing config info in the global buffer
+        // (not a foolproof check, but good enough)
+        //
+
+        ShowStr ("Call lineGetDevConfig before calling lineSetDevConfig");
+
+        if (dwBigBufSize >= sizeof (VARSTRING))
+        {
+            DWORD       dwMaxDataSize = dwBigBufSize - sizeof (VARSTRING);
+            LPVARSTRING pVarString = (LPVARSTRING) pBigBuf;
+
+
+            if (pVarString->dwStringSize > dwMaxDataSize ||
+
+                (pVarString->dwStringSize != 0 &&
+                    (pVarString->dwStringOffset < sizeof (VARSTRING) ||
+                    pVarString->dwStringOffset >
+                        (dwBigBufSize - pVarString->dwStringSize))))
+            {
+                ShowStr (szErrorMsg);
+                break;
+            }
+
+            params[1].dwValue      =
+            params[1].u.dwDefValue = (DWORD)
+                ((LPBYTE) pBigBuf + pVarString->dwStringOffset);
+            params[2].dwValue      =
+            params[2].u.dwDefValue =  pVarString->dwStringSize;
+        }
+        else
+        {
+            ShowStr (szErrorMsg);
+            break;
+        }
+
+        strcpy (szDeviceClass, szDefLineDeviceClass);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+#if TAPI_2_0
+    case lSetLineDevStatus:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   (DWORD) 0, NULL },
+            { "dwStatusToChange",   PT_FLAGS,   (DWORD) 0, aLineDevStatusFlags },
+            { "fStatus",            PT_DWORD,   (DWORD) 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSetLineDevStatus };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+#endif
+    case lSetMediaControl:
+    {
+        LINEMEDIACONTROLDIGIT       aDigits[1];
+        LINEMEDIACONTROLMEDIA       aMedias[1];
+        LINEMEDIACONTROLTONE        aTones[1];
+        LINEMEDIACONTROLCALLSTATE   aCallSts[1];
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD, 0, NULL },
+            { szdwAddressID,    PT_DWORD, 0, NULL },
+            { szhCall,          PT_DWORD, 0, NULL },
+            { "dwSelect",       PT_ORDINAL, 0, aCallSelects },
+
+            { "lpDigitList",        PT_POINTER, (DWORD) aDigits, aDigits },
+            { "  ->dwDigit",        PT_DWORD,   (DWORD) 0, NULL },
+            { "  ->dwDigitModes",   PT_FLAGS,   (DWORD) 0, aDigitModes },
+            { "  ->dwMediaControl", PT_ORDINAL, (DWORD) 0, aMediaControls },
+            { "dwDigitNumEntries",  PT_DWORD,   (DWORD) 0, NULL },
+
+            { "lpMediaList",        PT_POINTER, (DWORD) aMedias, aMedias },
+            { "  ->dwMediaModes",   PT_FLAGS,   (DWORD) 0, aMediaModes },
+            { "  ->dwDuration",     PT_DWORD,   (DWORD) 0, 0 },
+            { "  ->dwMediaControl", PT_ORDINAL, (DWORD) 0, aMediaControls },
+            { "dwMediaNumEntries",  PT_DWORD,   (DWORD) 0, NULL },
+
+            { "lpToneList",         PT_POINTER, (DWORD) aTones, aTones },
+            { "  ->dwAppSpecific",  PT_DWORD,   (DWORD) 0, NULL },
+            { "  ->dwDuration",     PT_DWORD,   (DWORD) 0, NULL },
+            { "  ->dwFrequency1",   PT_DWORD,   (DWORD) 0, NULL },
+            { "  ->dwFrequency2",   PT_DWORD,   (DWORD) 0, NULL },
+            { "  ->dwFrequency3",   PT_DWORD,   (DWORD) 0, NULL },
+            { "  ->dwMediaControl", PT_ORDINAL, (DWORD) 0, aMediaControls },
+            { "dwToneNumEntries",   PT_DWORD,   (DWORD) 0, NULL },
+
+            { "lpCallStateList",    PT_POINTER, (DWORD) aCallSts, aCallSts },
+            { "  ->dwCallStates",   PT_FLAGS,   (DWORD) 0, aCallStates },
+            { "  ->dwMediaControl", PT_ORDINAL, (DWORD) 0, aMediaControls },
+            { "dwCallStateNumEntries", PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 26, funcIndex, params, (PFN12) lineSetMediaControl };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if (pCallSel)
+        {
+            params[2].dwValue = (DWORD) pCallSel->hCall;
+            params[3].dwValue =  LINECALLSELECT_CALL;
+        }
+        else
+        {
+            params[3].dwValue =  LINECALLSELECT_LINE;
+        }
+
+        if (LetUserMungeParams (&paramsHeader))
+        {
+            DumpParams (&paramsHeader);
+
+            lResult = lineSetMediaControl(
+                (HLINE)                       params[0].dwValue,
+                (DWORD)                       params[1].dwValue,
+                (HCALL)                       params[2].dwValue,
+                (DWORD)                       params[3].dwValue,
+                (LPLINEMEDIACONTROLDIGIT)     params[4].dwValue,
+                (DWORD)                       params[8].dwValue,
+                (LPLINEMEDIACONTROLMEDIA)     params[9].dwValue,
+                (DWORD)                       params[13].dwValue,
+                (LPLINEMEDIACONTROLTONE)      params[14].dwValue,
+                (DWORD)                       params[21].dwValue,
+                (LPLINEMEDIACONTROLCALLSTATE) params[22].dwValue,
+                (DWORD)                       params[25].dwValue
+                );
+
+            ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+        }
+
+        break;
+    }
+    case lSetMediaMode:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD, 0, NULL },
+            { "dwMediaModes",   PT_FLAGS, dwDefMediaMode, aMediaModes }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineSetMediaMode };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetNumRings:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD, 0, NULL },
+            { szdwAddressID,    PT_DWORD, dwDefAddressID, NULL },
+            { "dwNumRings",     PT_DWORD, 5, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSetNumRings };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetStatusMessages:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD, 0, NULL },
+            { "dwLineStates",       PT_FLAGS, 0, aLineStates },
+            { "dwAddressStates",    PT_FLAGS, 0, aAddressStates }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSetStatusMessages };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetTerminal:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { szhCall,              PT_DWORD,   0, NULL },
+            { "dwSelect",           PT_ORDINAL, LINECALLSELECT_LINE, aCallSelects },
+            { "dwTerminalModes",    PT_FLAGS,   LINETERMMODE_BUTTONS, aTerminalModes },
+            { "dwTerminalID",       PT_DWORD,   0, NULL },
+            { "bEnable",            PT_DWORD,   0, NULL },
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (PFN7) lineSetTerminal };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        if (pCallSel)
+        {
+            params[2].dwValue = (DWORD) pCallSel->hCall;
+        }
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetTollList:
+#if TAPI_2_0
+    case lSetTollListW:
+#endif
+    {
+        char szAddressIn[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,  0, NULL },
+            { szdwDeviceID,         PT_DWORD,  dwDefLineDeviceID, NULL },
+            { "lpszAddressIn",      PT_STRING, (DWORD) szAddressIn, szAddressIn },
+            { "dwTollListOption",   PT_FLAGS,  LINETOLLLISTOPTION_ADD, aTollListOptions }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (funcIndex == lSetTollList ?
+                (PFN4) lineSetTollList : (PFN4) lineSetTollListW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineSetTollList };
+#endif
+
+        if (pLineAppSel)
+        {
+            params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+        }
+
+        strcpy (szAddressIn, szDefDestAddress);
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lSetupConference:
+#if TAPI_2_0
+    case lSetupConferenceW:
+#endif
+    {
+        PMYCALL pNewCall, pNewCall2;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,       0, NULL },
+            { szhLine,          PT_DWORD,       0, NULL },
+            { "lphConfCall",    PT_POINTER,     0, NULL },
+            { szlphConsultCall, PT_POINTER,     0, NULL },
+            { "dwNumParties",   PT_DWORD,       3, NULL },
+            { szlpCallParams,   PT_CALLPARAMS,  0, lpCallParams }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (funcIndex == lSetupConference ?
+                (PFN6) lineSetupConference : (PFN6) lineSetupConferenceW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineSetupConference };
+#endif
+
+        CHK_LINE_SELECTED()
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            break;
+        }
+
+        if (!(pNewCall2 = AllocCall (pLineSel)))
+        {
+            FreeCall (pNewCall);
+            break;
+        }
+
+        params[0].dwValue = (DWORD) (pCallSel ? pCallSel->hCall : 0);
+        params[1].dwValue = (DWORD) pLineSel->hLine;
+        params[2].dwValue = params[2].u.dwDefValue = (DWORD) &pNewCall->hCall;
+        params[3].dwValue = params[3].u.dwDefValue = (DWORD) &pNewCall2->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) >= 0)
+        {
+            //
+            // Note that the hLine param is ignored if the hCall is non-NULL
+            //
+
+            if (params[0].dwValue)
+            {
+                if (!pCallSel ||
+                    (params[0].dwValue != (DWORD) pCallSel->hCall))
+                {
+                    //
+                    // Get the assoc pLine, if it's diff need to move new calls
+                    //
+
+                    PMYWIDGET pWidget = aWidgets;
+                    PMYLINE   pLine = (PMYLINE) NULL;
+
+
+                    while (1)
+                    {
+                        if ((pWidget->dwType == WT_CALL) &&
+                            (params[0].dwValue == (DWORD)
+                                ((PMYCALL)pWidget)->hCall))
+                        {
+                            break;
+                        }
+                        else if (pWidget->dwType == WT_LINE)
+                        {
+                            pLine = (PMYLINE) pWidget;
+                        }
+
+                        pWidget = pWidget->pNext;
+                    }
+
+                    if (pLine != pLineSel)
+                    {
+                        MoveCallToLine (pNewCall, pLine->hLine);
+                        MoveCallToLine (pNewCall2, pLine->hLine);
+                    }
+                }
+            }
+            else if (params[1].dwValue != (DWORD) pLineSel->hLine)
+            {
+                MoveCallToLine (pNewCall, (HLINE) params[1].dwValue);
+                MoveCallToLine (pNewCall2, (HLINE) params[1].dwValue);
+            }
+
+            pNewCall->lMakeCallReqID  =
+            pNewCall2->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls += 2;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+            FreeCall (pNewCall2);
+        }
+
+        break;
+    }
+    case lSetupTransfer:
+#if TAPI_2_0
+    case lSetupTransferW:
+#endif
+    {
+        PMYCALL pNewCall;
+        FUNC_PARAM params[] =
+        {
+            { szhCall,          PT_DWORD,       0, NULL },
+            { szlphConsultCall, PT_POINTER,     0, NULL },
+            { szlpCallParams,   PT_CALLPARAMS,  0, lpCallParams }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lSetupTransfer ?
+                (PFN3) lineSetupTransfer : (PFN3) lineSetupTransferW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineSetupTransfer };
+#endif
+
+        CHK_CALL_SELECTED()
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[1].dwValue = params[1].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        if ((lResult = DoFunc (&paramsHeader)) >= 0)
+        {
+            //
+            // First make sure we're created the call under the right line,
+            // and if not move it to the right place in the widgets list
+            //
+
+            LINECALLINFO callInfo;
+
+
+            memset (&callInfo, 0, sizeof(LINECALLINFO));
+            callInfo.dwTotalSize = sizeof(LINECALLINFO);
+            if (lineGetCallInfo ((HCALL) params[0].dwValue, &callInfo) == 0)
+            {
+                if (callInfo.hLine != pLineSel->hLine)
+                {
+                    MoveCallToLine (pNewCall, callInfo.hLine);
+                }
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        break;
+    }
+    case lShutdown:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,   PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineShutdown };
+
+
+        CHK_LINEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+
+        lResult = DoFunc (&paramsHeader);
+
+        if (lResult == 0)
+        {
+            FreeLineApp (GetLineApp((HLINEAPP) params[0].dwValue));
+        }
+
+        break;
+    }
+    case lSwapHold:
+    {
+        FUNC_PARAM params[] =
+        {
+            { "hActiveCall",    PT_DWORD, 0, NULL },
+            { "hHeldCall",      PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineSwapHold };
+
+
+        CHK_TWO_CALLS_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+        params[1].dwValue = (DWORD) pCallSel2->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lTranslateAddress:
+#if TAPI_2_0
+    case lTranslateAddressW:
+#endif
+    {
+        char szAddressIn[MAX_STRING_PARAM_SIZE];
+        LPLINETRANSLATEOUTPUT lpXlatOutput = (LPLINETRANSLATEOUTPUT) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,           PT_DWORD,   0, NULL },
+            { szdwDeviceID,         PT_DWORD,   dwDefLineDeviceID, NULL },
+            { szdwAPIVersion,       PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "lpszAddressIn",      PT_STRING,  (DWORD) szAddressIn, szAddressIn },
+            { "dwCard",             PT_DWORD,   0, NULL },
+            { "dwTranslateOptions", PT_FLAGS,   LINETRANSLATEOPTION_CARDOVERRIDE, aTranslateOptions },
+            { "lpTranslateOutput",  PT_POINTER, (DWORD) lpXlatOutput, lpXlatOutput }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (funcIndex == lTranslateAddress ?
+                (PFN7) lineTranslateAddress : (PFN7) lineTranslateAddressW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (PFN7) lineTranslateAddress };
+#endif
+
+        if (pLineAppSel)
+        {
+            params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+        }
+        else
+        {
+            params[0].dwValue = 0;
+        }
+
+        memset (lpXlatOutput, 0, (size_t) dwBigBufSize);
+        lpXlatOutput->dwTotalSize = dwBigBufSize;
+
+        strcpy (szAddressIn, szDefDestAddress);
+
+        lResult = DoFunc (&paramsHeader);
+
+        if (lResult == 0)
+        {
+            ShowStructByDWORDs (lpXlatOutput);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwDialableStringSize",       FT_SIZE,    lpXlatOutput->dwDialableStringSize, NULL },
+                    { "dwDialableStringOffset",     FT_OFFSET,  lpXlatOutput->dwDialableStringOffset, NULL },
+                    { "dwDisplayableStringSize",    FT_SIZE,    lpXlatOutput->dwDisplayableStringSize, NULL },
+                    { "dwDisplayableStringOffset",  FT_OFFSET,  lpXlatOutput->dwDisplayableStringOffset, NULL },
+                    { "dwCurrentCountry",           FT_DWORD,   lpXlatOutput->dwCurrentCountry, NULL },
+                    { "dwDestCountry",              FT_DWORD,   lpXlatOutput->dwDestCountry, NULL },
+                    { "dwTranslateResults",         FT_FLAGS,   lpXlatOutput->dwTranslateResults, aTranslateResults },
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpXlatOutput,
+                    "LINETRANSLATEOUTPUT",
+                    7,
+                    fields
+                };
+
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case lUncompleteCall:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhLine,          PT_DWORD, 0, NULL },
+            { "dwCompletionID", PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineUncompleteCall };
+
+
+        CHK_LINE_SELECTED()
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lUnhold:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineUnhold };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lUnpark:
+#if TAPI_2_0
+    case lUnparkW:
+#endif
+    {
+        PMYCALL pNewCall;
+        char szDestAddress[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhLine,              PT_DWORD,   0, NULL },
+            { szdwAddressID,        PT_DWORD,   dwDefAddressID, NULL },
+            { szlphCall,            PT_POINTER, 0, NULL },
+            { szlpszDestAddress,    PT_STRING,  (DWORD) szDestAddress, szDestAddress }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (funcIndex == lUnpark ?
+                (PFN4) lineUnpark : (PFN4) lineUnparkW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) lineUnpark };
+#endif
+
+        CHK_LINE_SELECTED()
+
+        if (!(pNewCall = AllocCall (pLineSel)))
+        {
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pLineSel->hLine;
+        params[2].dwValue = params[2].u.dwDefValue = (DWORD) &pNewCall->hCall;
+
+        strcpy (szDestAddress, szDefDestAddress);
+
+        if ((lResult = DoFunc (&paramsHeader)) >= 0)
+        {
+            if (params[0].dwValue != (DWORD) pLineSel->hLine)
+            {
+                MoveCallToLine (pNewCall, (HLINE) params[0].dwValue);
+            }
+
+            pNewCall->lMakeCallReqID = lResult;
+            dwNumPendingMakeCalls++;
+            SelectWidget ((PMYWIDGET) pNewCall);
+        }
+        else
+        {
+            FreeCall (pNewCall);
+        }
+
+        break;
+    }
+#if TAPI_1_1
+    case lAddProvider:
+#if TAPI_2_0
+    case lAddProviderW:
+#endif
+    {
+#if TAPI_2_0
+        char szProviderFilename[MAX_STRING_PARAM_SIZE] = "esp32.tsp";
+#else
+        char szProviderFilename[MAX_STRING_PARAM_SIZE] = "esp.tsp";
+#endif
+        DWORD dwPermanentProviderID;
+        FUNC_PARAM params[] =
+        {
+            { "lpszProviderFilename",       PT_STRING,  (DWORD) szProviderFilename, szProviderFilename },
+            { szhwndOwner,                  PT_DWORD,   (DWORD) ghwndMain, NULL },
+            { "lpdwPermanentProviderID",    PT_POINTER, (DWORD) &dwPermanentProviderID, &dwPermanentProviderID }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lAddProvider ?
+                (PFN3) lineAddProvider : (PFN3) lineAddProviderW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineAddProvider };
+#endif
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineAddProvider(
+            (LPCSTR) params[0].dwValue,
+            (HWND) params[1].dwValue,
+            (LPDWORD) params[2].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult == 0)
+        {
+            ShowStr ("%sdwPermanentProviderID = x%lx", szTab, dwPermanentProviderID);
+        }
+#endif
+        break;
+    }
+    case lConfigDialogEdit:
+#if TAPI_2_0
+    case lConfigDialogEditW:
+#endif
+    {
+        char        szDeviceClass[MAX_STRING_PARAM_SIZE];
+        char        szDeviceConfigIn[MAX_STRING_PARAM_SIZE] = "";
+        char        szErrorMsg[] = "Bad config info in buffer";
+        LPBYTE      pDataIn;
+        LPVARSTRING lpDeviceConfigOut = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,           PT_DWORD,   (DWORD) dwDefLineDeviceID, NULL },
+            { szhwndOwner,            PT_DWORD,   (DWORD) ghwndMain, NULL },
+            { szlpszDeviceClass,      PT_STRING,  (DWORD) szDeviceClass, szDeviceClass },
+            { "lpDeviceConfigIn",     PT_POINTER, (DWORD) 0, NULL },
+            { szdwSize,               PT_DWORD,   (DWORD) 0, NULL },
+            { "lpDeviceConfigOut",    PT_POINTER, (DWORD) lpDeviceConfigOut, lpDeviceConfigOut }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (funcIndex == lConfigDialogEdit ?
+                (PFN6) lineConfigDialogEdit : (PFN6) lineConfigDialogEditW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) lineConfigDialogEdit };
+#endif
+
+        //
+        // Check to see if there's existing config info in the global buffer
+        // (not a foolproof check, but good enough), and if so alloc an
+        // intermediate  buffer to use for config in data & copy the
+        // existing data over
+        //
+
+        ShowStr ("Call lineGetDevConfig before calling lineConfigDialogEdit");
+
+        if (dwBigBufSize >= sizeof (VARSTRING))
+        {
+            DWORD       dwMaxDataSize = dwBigBufSize - sizeof (VARSTRING);
+            LPVARSTRING pVarString = (LPVARSTRING) pBigBuf;
+
+
+            if (pVarString->dwStringSize > dwMaxDataSize ||
+
+                (pVarString->dwStringSize != 0 &&
+                    (pVarString->dwStringOffset < sizeof (VARSTRING) ||
+                    pVarString->dwStringOffset >
+                        (dwBigBufSize - pVarString->dwStringSize))))
+            {
+                ShowStr (szErrorMsg);
+                break;
+            }
+
+            pDataIn = malloc (pVarString->dwStringSize);
+
+            memcpy(
+                pDataIn,
+                (LPBYTE) pBigBuf + pVarString->dwStringOffset,
+                pVarString->dwStringSize
+                );
+
+            params[3].dwValue      =
+            params[3].u.dwDefValue = (DWORD) pDataIn;
+        }
+        else
+        {
+            ShowStr (szErrorMsg);
+            break;
+        }
+
+        strcpy (szDeviceClass, szDefLineDeviceClass);
+
+        memset (lpDeviceConfigOut, 0, (size_t) dwBigBufSize);
+
+        lpDeviceConfigOut->dwTotalSize = dwBigBufSize;
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDSs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineConfigDialogEdit(
+            params[0].dwValue,
+            (HWND) params[1].dwValue,
+            (LPCSTR) params[2].dwValue,
+            (LPVOID) params[3].dwValue,
+            params[4].dwValue,
+            (LPVARSTRING) params[5].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        if (lResult == 0)
+        {
+            ShowStructByDWORDs (lpDeviceConfigOut);
+
+            ShowVARSTRING (lpDeviceConfigOut);
+        }
+
+        free (pDataIn);
+
+        break;
+    }
+    case lConfigProvider:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhwndOwner,              PT_DWORD, (DWORD) ghwndMain, NULL },
+            { "dwPermanentProviderID",  PT_DWORD, 2, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineConfigProvider };
+
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineConfigProvider(
+            (HWND) params[0].dwValue,
+            params[1].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        break;
+    }
+    case lGetAppPriority:
+#if TAPI_2_0
+    case lGetAppPriorityW:
+#endif
+    {
+        DWORD dwPriority;
+        LINEEXTENSIONID extID;
+        char szAppName[MAX_STRING_PARAM_SIZE];
+        LPVARSTRING lpExtName = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szlpszAppName,        PT_STRING,  (DWORD) szAppName, szAppName },
+            { "dwMediaMode",        PT_FLAGS,   dwDefMediaMode, aMediaModes },
+            { "lpExtensionID",      PT_POINTER, (DWORD) &extID, &extID },
+            { "  ->dwExtensionID0", PT_DWORD,   0, NULL },
+            { "  ->dwExtensionID1", PT_DWORD,   0, NULL },
+            { "  ->dwExtensionID2", PT_DWORD,   0, NULL },
+            { "  ->dwExtensionID3", PT_DWORD,   0, NULL },
+            { "dwRequestMode",      PT_FLAGS,   LINEREQUESTMODE_MAKECALL, aRequestModes },
+            { "lpExtensionName",    PT_POINTER, (DWORD) lpExtName, lpExtName },
+            { "lpdwPriority",       PT_POINTER, (DWORD) &dwPriority, &dwPriority }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 10, funcIndex, params, NULL };
+
+
+        memset (lpExtName, 0, (size_t) dwBigBufSize);
+        lpExtName->dwTotalSize = dwBigBufSize;
+
+        strcpy (szAppName, szDefAppName);
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        extID.dwExtensionID0 = params[3].dwValue;
+        extID.dwExtensionID1 = params[4].dwValue;
+        extID.dwExtensionID2 = params[5].dwValue;
+        extID.dwExtensionID3 = params[6].dwValue;
+
+#if TAPI_2_0
+        if (funcIndex == lGetAppPriority)
+        {
+            lResult = lineGetAppPriority(
+                (LPCSTR) params[0].dwValue,
+                params[1].dwValue,
+                (LPLINEEXTENSIONID) params[2].dwValue,
+                params[7].dwValue,
+                (LPVARSTRING) params[8].dwValue,
+                (LPDWORD) params[9].dwValue
+                );
+        }
+        else
+        {
+            if (params[0].dwValue == (DWORD) szAppName)
+            {
+                int    len = strlen (szAppName) + 1;
+                WCHAR  buf[MAX_STRING_PARAM_SIZE/2];
+
+
+                MultiByteToWideChar(
+                    GetACP(),
+                    MB_PRECOMPOSED,
+                    (LPCSTR) szAppName,
+                    (len > MAX_STRING_PARAM_SIZE/2 ?
+                        MAX_STRING_PARAM_SIZE/2 - 1 : -1),
+                    buf,
+                    MAX_STRING_PARAM_SIZE/2
+                    );
+
+                 buf[MAX_STRING_PARAM_SIZE/2 - 1] = 0;
+
+                 lstrcpyW ((WCHAR *) szAppName, buf);
+            }
+
+            lResult = lineGetAppPriorityW(
+                (LPCWSTR) params[0].dwValue,
+                params[1].dwValue,
+                (LPLINEEXTENSIONID) params[2].dwValue,
+                params[7].dwValue,
+                (LPVARSTRING) params[8].dwValue,
+                (LPDWORD) params[9].dwValue
+                );
+        }
+#else
+        lResult = lineGetAppPriority(
+            (LPCSTR) params[0].dwValue,
+            params[1].dwValue,
+            (LPLINEEXTENSIONID) params[2].dwValue,
+            params[7].dwValue,
+            (LPVARSTRING) params[8].dwValue,
+            (LPDWORD) params[9].dwValue
+            );
+#endif
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult == 0)
+        {
+            ShowStr ("%sdwPriority = x%lx", szTab, dwPriority);
+            ShowStructByDWORDs (lpExtName);
+        }
+
+        break;
+    }
+    case lGetCountry:
+#if TAPI_2_0
+    case lGetCountryW:
+#endif
+    {
+        LPLINECOUNTRYLIST lpCountryList = (LPLINECOUNTRYLIST) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { "dwCountryID",       PT_DWORD,   1, NULL },
+            { szdwAPIVersion,      PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "lpLineCountryList", PT_POINTER, (DWORD) lpCountryList, lpCountryList }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == lGetCountry ?
+                (PFN3) lineGetCountry : (PFN3) lineGetCountryW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) lineGetCountry };
+#endif
+
+        memset (lpCountryList, 0, (size_t) dwBigBufSize);
+        lpCountryList->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            UpdateResults (TRUE);
+
+            ShowStructByDWORDs (lpCountryList);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                DWORD i;
+                LPLINECOUNTRYENTRY lpCountryEntry;
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwNumCountries",         FT_DWORD,   lpCountryList->dwNumCountries, NULL },
+                    { "dwCountryListSize",      FT_DWORD,   lpCountryList->dwCountryListSize, NULL },
+                    { "dwCountryListOffset",    FT_DWORD,   lpCountryList->dwCountryListOffset, NULL }
+
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpCountryList,
+                    "LINECOUNTRYLIST",
+                    3,
+                    fields
+                };
+
+
+                ShowStructByField (&fieldHeader, FALSE);
+
+                lpCountryEntry = (LPLINECOUNTRYENTRY)
+                    (((LPBYTE)lpCountryList) +
+                        lpCountryList->dwCountryListOffset);
+
+                for (i = 0; i < lpCountryList->dwNumCountries; i++)
+                {
+                    char buf[32];
+                    STRUCT_FIELD fields[] =
+                    {
+                        { "dwCountryID",                FT_DWORD,   lpCountryEntry->dwCountryID, NULL },
+                        { "dwCountryCode",              FT_DWORD,   lpCountryEntry->dwCountryCode, NULL },
+                        { "dwNextCountryID",            FT_DWORD,   lpCountryEntry->dwNextCountryID, NULL },
+                        { "dwCountryNameSize",          FT_SIZE,    lpCountryEntry->dwCountryNameSize, NULL },
+                        { "dwCountryNameOffset",        FT_OFFSET,  lpCountryEntry->dwCountryNameOffset, NULL },
+                        { "dwSameAreaRuleSize",         FT_SIZE,    lpCountryEntry->dwSameAreaRuleSize, NULL },
+                        { "dwSameAreaRuleOffset",       FT_OFFSET,  lpCountryEntry->dwSameAreaRuleOffset, NULL },
+                        { "dwLongDistanceRuleSize",     FT_SIZE,    lpCountryEntry->dwLongDistanceRuleSize, NULL },
+                        { "dwLongDistanceRuleOffset",   FT_OFFSET,  lpCountryEntry->dwLongDistanceRuleOffset, NULL },
+                        { "dwInternationalRuleSize",    FT_SIZE,    lpCountryEntry->dwInternationalRuleSize, NULL },
+                        { "dwInternationalRuleOffset",  FT_OFFSET,  lpCountryEntry->dwInternationalRuleOffset, NULL }
+                    };
+                    STRUCT_FIELD_HEADER fieldHeader =
+                    {
+                        lpCountryList, // size,offset relative to ctrylist
+                        buf,
+                        11,
+                        fields
+                    };
+
+
+                    sprintf (buf, "LINECOUNTRYENTRY[%ld]", i);
+
+                    ShowStructByField (&fieldHeader, TRUE);
+
+                    lpCountryEntry++;
+                }
+            }
+
+            UpdateResults (FALSE);
+        }
+
+        break;
+    }
+    case lGetProviderList:
+#if TAPI_2_0
+    case lGetProviderListW:
+#endif
+    {
+        LPLINEPROVIDERLIST lpProviderList = (LPLINEPROVIDERLIST) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szdwAPIVersion,   PT_ORDINAL, dwDefLineAPIVersion, aAPIVersions },
+            { "lpProviderList", PT_POINTER, (DWORD) lpProviderList, lpProviderList }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (funcIndex == lGetProviderList ?
+                (PFN3) lineGetProviderList : (PFN3) lineGetProviderListW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN3) lineGetProviderList };
+#endif
+
+        memset (lpProviderList, 0, (size_t) dwBigBufSize);
+        lpProviderList->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            UpdateResults (TRUE);
+
+            ShowStructByDWORDs (lpProviderList);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                DWORD i;
+                LPLINEPROVIDERENTRY lpProviderEntry;
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwNumProviders",         FT_DWORD,   lpProviderList->dwNumProviders, NULL },
+                    { "dwProviderListSize",     FT_DWORD,   lpProviderList->dwProviderListSize, NULL },
+                    { "dwProviderListOffset",   FT_DWORD,   lpProviderList->dwProviderListOffset, NULL },
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpProviderList,
+                    "LINEPROVIDERLIST",
+                    3,
+                    fields
+                };
+
+                ShowStructByField (&fieldHeader, FALSE);
+
+                lpProviderEntry = (LPLINEPROVIDERENTRY)
+                    (((LPBYTE) lpProviderList) +
+                        lpProviderList->dwProviderListOffset);
+
+                for (i = 0; i < lpProviderList->dwNumProviders; i++)
+                {
+                    char buf[32];
+                    STRUCT_FIELD fields[] =
+                    {
+                        { "dwPermanentProviderID",      FT_DWORD,   lpProviderEntry->dwPermanentProviderID, NULL },
+                        { "dwProviderFilenameSize",     FT_SIZE,    lpProviderEntry->dwProviderFilenameSize, NULL },
+                        { "dwProviderFilenameOffset",   FT_OFFSET,  lpProviderEntry->dwProviderFilenameOffset, NULL }
+                    };
+                    STRUCT_FIELD_HEADER fieldHeader =
+                    {
+                        lpProviderList, // size,offset relative to ctrylist
+                        buf,
+                        3,
+                        fields
+                    };
+
+
+                    sprintf (buf, "LINEPROVIDERENTRY[%ld]", i);
+
+                    ShowStructByField (&fieldHeader, TRUE);
+
+                    lpProviderEntry++;
+                }
+
+            }
+
+            UpdateResults (FALSE);
+        }
+
+        break;
+    }
+    case lReleaseUserUserInfo:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhCall,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) lineReleaseUserUserInfo };
+
+
+        CHK_CALL_SELECTED()
+
+        params[0].dwValue = (DWORD) pCallSel->hCall;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case lRemoveProvider:
+    {
+        FUNC_PARAM params[] =
+        {
+            { "dwPermanentProviderID",  PT_DWORD, 2, NULL },
+            { szhwndOwner,              PT_DWORD, (DWORD) ghwndMain, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) lineRemoveProvider };
+
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineRemoveProvider(
+            params[0].dwValue,
+            (HWND) params[1].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        break;
+    }
+    case lSetAppPriority:
+#if TAPI_2_0
+    case lSetAppPriorityW:
+#endif
+    {
+        char szAppName[MAX_STRING_PARAM_SIZE];
+        char szExtName[MAX_STRING_PARAM_SIZE] = "";
+        LINEEXTENSIONID extID;
+        FUNC_PARAM params[] =
+        {
+            { szlpszAppName,        PT_STRING, (DWORD) szAppName, szAppName },
+            { "dwMediaMode",        PT_FLAGS, dwDefMediaMode, aMediaModes },
+            { "lpExtensionID",      PT_POINTER, (DWORD) &extID, &extID },
+            { "  ->dwExtensionID0", PT_DWORD, 0, NULL },
+            { "  ->dwExtensionID1", PT_DWORD, 0, NULL },
+            { "  ->dwExtensionID2", PT_DWORD, 0, NULL },
+            { "  ->dwExtensionID3", PT_DWORD, 0, NULL },
+            { "dwRequestMode",      PT_FLAGS, LINEREQUESTMODE_MAKECALL, aRequestModes },
+            { "lpszExtensionName",  PT_STRING, (DWORD) szExtName, szExtName },
+            { "dwPriority",         PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 10, funcIndex, params, NULL };
+
+
+        strcpy (szAppName, szDefAppName);
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        extID.dwExtensionID0 = params[3].dwValue;
+        extID.dwExtensionID1 = params[4].dwValue;
+        extID.dwExtensionID2 = params[5].dwValue;
+        extID.dwExtensionID3 = params[6].dwValue;
+
+#if TAPI_2_0
+        if (funcIndex == lSetAppPriority)
+        {
+            lResult = lineSetAppPriority(
+                (LPCSTR) params[0].dwValue,
+                params[1].dwValue,
+                (LPLINEEXTENSIONID) params[2].dwValue,
+                params[7].dwValue,
+                (LPCSTR) params[8].dwValue,
+                params[9].dwValue
+                );
+        }
+        else
+        {
+            if (params[0].dwValue == (DWORD) szAppName)
+            {
+                int    len = strlen (szAppName) + 1;
+                WCHAR  buf[MAX_STRING_PARAM_SIZE/2];
+
+
+                MultiByteToWideChar(
+                    GetACP(),
+                    MB_PRECOMPOSED,
+                    (LPCSTR) szAppName,
+                    (len > MAX_STRING_PARAM_SIZE/2 ?
+                        MAX_STRING_PARAM_SIZE/2 - 1 : -1),
+                    buf,
+                    MAX_STRING_PARAM_SIZE/2
+                    );
+
+                 buf[MAX_STRING_PARAM_SIZE/2 - 1] = 0;
+
+                 lstrcpyW ((WCHAR *) szAppName, buf);
+            }
+
+            lResult = lineSetAppPriorityW(
+                (LPCWSTR) params[0].dwValue,
+                params[1].dwValue,
+                (LPLINEEXTENSIONID) params[2].dwValue,
+                params[7].dwValue,
+                (LPCWSTR) params[8].dwValue,
+                params[9].dwValue
+                );
+        }
+#else
+        lResult = lineSetAppPriority(
+            (LPCSTR) params[0].dwValue,
+            params[1].dwValue,
+            (LPLINEEXTENSIONID) params[2].dwValue,
+            params[7].dwValue,
+            (LPCSTR) params[8].dwValue,
+            params[9].dwValue
+            );
+#endif
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+
+        break;
+    }
+    case lTranslateDialog:
+#if TAPI_2_0
+    case lTranslateDialogW:
+#endif
+    {
+        char szAddressIn[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szhLineApp,       PT_DWORD,  0, NULL },
+            { szdwDeviceID,     PT_DWORD,  dwDefLineDeviceID, NULL },
+            { szdwAPIVersion,   PT_ORDINAL,  dwDefLineAPIVersion, aAPIVersions },
+            { szhwndOwner,      PT_DWORD,  (DWORD) ghwndMain, 0 },
+            { "lpszAddressIn",  PT_STRING, (DWORD) szAddressIn, szAddressIn }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (funcIndex == lTranslateDialog ?
+                (PFN5) lineTranslateDialog : (PFN5) lineTranslateDialogW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) lineTranslateDialog };
+#endif
+
+        if (pLineAppSel)
+        {
+            params[0].dwValue = (DWORD) pLineAppSel->hLineApp;
+        }
+
+        strcpy (szAddressIn, szDefDestAddress);
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = lineTranslateDialog(
+            (HLINEAPP) params[0].dwValue,
+            params[1].dwValue,
+            params[2].dwValue,
+            (HWND) params[3].dwValue,
+            (LPCSTR) params[4].dwValue
+            );
+
+        ShowLineFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        break;
+    }
+#endif // TAPI_1_1
+    case pClose:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) phoneClose };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if ((lResult = DoFunc(&paramsHeader)) == 0)
+        {
+            FreePhone (GetPhone((HPHONE) params[0].dwValue));
+
+            // Try to auto select the next valid hPhone in the list
+        }
+
+        break;
+    }
+    case pConfigDialog:
+#if TAPI_2_0
+    case pConfigDialogW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,       PT_DWORD, dwDefPhoneDeviceID, NULL },
+            { szhwndOwner,        PT_DWORD, (DWORD) ghwndMain, NULL },
+            { szlpszDeviceClass,  PT_STRING, (DWORD) szDeviceClass, szDeviceClass }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == pConfigDialog ?
+                (PFN3) phoneConfigDialog : (PFN3) phoneConfigDialogW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneConfigDialog };
+#endif
+
+        CHK_PHONEAPP_SELECTED()
+
+        strcpy (szDeviceClass, szDefPhoneDeviceClass);
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDSs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = phoneConfigDialog(
+            params[0].dwValue,
+            (HWND) params[1].dwValue,
+            (LPCSTR) params[2].dwValue
+            );
+
+        ShowPhoneFuncResult (aFuncNames[funcIndex], lResult);
+#endif
+        break;
+    }
+    case pDevSpecific:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,     PT_DWORD,   0, NULL },
+            { szlpParams,   PT_STRING,  (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,     PT_DWORD,   dwBigBufSize, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneDevSpecific };
+
+
+        CHK_PHONE_SELECTED()
+
+        memset (pBigBuf, 0, (size_t) dwBigBufSize);
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pGetButtonInfo:
+#if TAPI_2_0
+    case pGetButtonInfoW:
+#endif
+    {
+        LPPHONEBUTTONINFO lpButtonInfo = (LPPHONEBUTTONINFO) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,           PT_DWORD,   0, NULL },
+            { "dwButtonLampID",   PT_DWORD,   0, NULL },
+            { "lpButtonInfo",     PT_POINTER, (DWORD) lpButtonInfo, lpButtonInfo }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == pGetButtonInfo ?
+                (PFN3) phoneGetButtonInfo : (PFN3) phoneGetButtonInfoW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetButtonInfo };
+#endif
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        memset (pBigBuf, 0, (size_t) dwBigBufSize);
+        lpButtonInfo->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpButtonInfo);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwButtonMode",           FT_FLAGS,   lpButtonInfo->dwButtonMode, aButtonModes },
+                    { "dwButtonFunction",       FT_FLAGS,   lpButtonInfo->dwButtonFunction, aButtonFunctions },
+                    { "dwButtonTextSize",       FT_SIZE,    lpButtonInfo->dwButtonTextSize, NULL },
+                    { "dwButtonTextOffset",     FT_OFFSET,  lpButtonInfo->dwButtonTextOffset, NULL },
+                    { "dwDevSpecificSize",      FT_SIZE,    lpButtonInfo->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",    FT_OFFSET,  lpButtonInfo->dwDevSpecificOffset, NULL }
+#if TAPI_1_1
+                     ,
+                    { "dwButtonState",          FT_FLAGS,   lpButtonInfo->dwButtonState, aButtonStates }
+#endif
+
+
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpButtonInfo,
+                    "PHONEBUTTONINFO",
+#if TAPI_1_1
+                    7,
+#else
+                    6,
+#endif
+                    fields
+                };
+
+#if TAPI_1_1
+
+                // BUGBUG only show v1.0 fields if APIver == 0x10003
+                //        fieldHeader.dwNumFields--;
+#endif
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case pGetData:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,           PT_DWORD, 0, NULL },
+            { "dwDataID",         PT_DWORD, 0, NULL },
+            { "lpData",           PT_POINTER, (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,           PT_DWORD, (dwBigBufSize > 64 ? 64 : dwBigBufSize), 0}
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) phoneGetData };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowBytes(
+                (dwBigBufSize > params[3].dwValue ?
+                    params[3].dwValue : dwBigBufSize),
+                pBigBuf,
+                0
+                );
+        }
+
+        break;
+    }
+    case pGetDevCaps:
+#if TAPI_2_0
+    case pGetDevCapsW:
+#endif
+    {
+        LPPHONECAPS lpDevCaps = (LPPHONECAPS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhPhoneApp,      PT_DWORD,   0, NULL },
+            { szdwDeviceID,     PT_DWORD,   dwDefPhoneDeviceID, NULL },
+            { szdwAPIVersion,   PT_ORDINAL, dwDefPhoneAPIVersion, aAPIVersions },
+            { "dwExtVersion",   PT_DWORD,   dwDefPhoneExtVersion, NULL },
+            { "lpPhoneDevCaps", PT_POINTER, (DWORD) lpDevCaps, lpDevCaps }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) phoneGetDevCaps };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (funcIndex == pGetDevCaps ?
+                (PFN5) phoneGetDevCaps : (PFN5) phoneGetDevCapsW ) };
+#endif
+
+        CHK_PHONEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneAppSel->hPhoneApp;
+
+        memset (lpDevCaps, 0, (size_t) dwBigBufSize);
+        lpDevCaps->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpDevCaps);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwProviderInfoSize",         FT_SIZE,    lpDevCaps->dwProviderInfoSize, NULL },
+                    { "dwProviderInfoOffset",       FT_OFFSET,  lpDevCaps->dwProviderInfoOffset, NULL },
+                    { "dwPhoneInfoSize",            FT_SIZE,    lpDevCaps->dwPhoneInfoSize, NULL },
+                    { "dwPhoneInfoOffset",          FT_OFFSET,  lpDevCaps->dwPhoneInfoOffset, NULL },
+                    { "dwPermanentPhoneID",         FT_DWORD,   lpDevCaps->dwPermanentPhoneID, NULL },
+                    { "dwPhoneNameSize",            FT_SIZE,    lpDevCaps->dwPhoneNameSize, NULL },
+                    { "dwPhoneNameOffset",          FT_OFFSET,  lpDevCaps->dwPhoneNameOffset, NULL },
+                    { "dwStringFormat",             FT_ORD,     lpDevCaps->dwStringFormat, aStringFormats },
+                    { "dwPhoneStates",              FT_FLAGS,   lpDevCaps->dwPhoneStates, aPhoneStates },
+                    { "dwHookSwitchDevs",           FT_FLAGS,   lpDevCaps->dwHookSwitchDevs, aHookSwitchDevs },
+                    { "dwHandsetHookSwitchModes",   FT_FLAGS,   lpDevCaps->dwHandsetHookSwitchModes, aHookSwitchModes },
+                    { "dwSpeakerHookSwitchModes",   FT_FLAGS,   lpDevCaps->dwSpeakerHookSwitchModes, aHookSwitchModes },
+                    { "dwHeadsetHookSwitchModes",   FT_FLAGS,   lpDevCaps->dwHeadsetHookSwitchModes, aHookSwitchModes },
+                    { "dwVolumeFlags",              FT_FLAGS,   lpDevCaps->dwVolumeFlags, aHookSwitchDevs },
+                    { "dwGainFlags",                FT_FLAGS,   lpDevCaps->dwGainFlags, aHookSwitchDevs },
+                    { "dwDisplayNumRows",           FT_DWORD,   lpDevCaps->dwDisplayNumRows, NULL },
+                    { "dwDisplayNumColumns",        FT_DWORD,   lpDevCaps->dwDisplayNumColumns, NULL },
+                    { "dwNumRingModes",             FT_DWORD,   lpDevCaps->dwNumRingModes, NULL },
+                    { "dwNumButtonLamps",           FT_DWORD,   lpDevCaps->dwNumButtonLamps, NULL },
+                    { "dwButtonModesSize",          FT_SIZE,    lpDevCaps->dwButtonModesSize, NULL },
+                    { "dwButtonModesOffset",        FT_OFFSET,  lpDevCaps->dwButtonModesOffset, NULL },
+                    { "dwButtonFunctionsSize",      FT_SIZE,    lpDevCaps->dwButtonFunctionsSize, NULL },
+                    { "dwButtonFunctionsOffset",    FT_OFFSET,  lpDevCaps->dwButtonFunctionsOffset, NULL },
+                    { "dwLampModesSize",            FT_SIZE,    lpDevCaps->dwLampModesSize, NULL },
+                    { "dwLampModesOffset",          FT_OFFSET,  lpDevCaps->dwLampModesOffset, NULL },
+                    { "dwNumSetData",               FT_DWORD,   lpDevCaps->dwNumSetData, NULL },
+                    { "dwSetDataSize",              FT_SIZE,    lpDevCaps->dwSetDataSize, NULL },
+                    { "dwSetDataOffset",            FT_OFFSET,  lpDevCaps->dwSetDataOffset, NULL },
+                    { "dwNumGetData",               FT_DWORD,   lpDevCaps->dwNumGetData, NULL },
+                    { "dwGetDataSize",              FT_SIZE,    lpDevCaps->dwGetDataSize, NULL },
+                    { "dwGetDataOffset",            FT_OFFSET,  lpDevCaps->dwGetDataOffset, NULL },
+                    { "dwDevSpecificSize",          FT_SIZE,    lpDevCaps->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",        FT_OFFSET,  lpDevCaps->dwDevSpecificOffset, NULL }
+#if TAPI_2_0
+                     ,
+                    { "dwDeviceClassesSize",        FT_SIZE,    0, NULL },
+                    { "dwDeviceClassesOffset",      FT_OFFSET,  0, NULL },
+                    { "dwPhoneFeatures",            FT_FLAGS,   0, aPhoneFeatures },
+                    { "dwSettableHandsetHookSwitchModes",   FT_FLAGS,   0, aHookSwitchModes },
+                    { "dwSettableSpeakerHookSwitchModes",   FT_FLAGS,   0, aHookSwitchModes },
+                    { "dwSettableHeadsetHookSwitchModes",   FT_FLAGS,   0, aHookSwitchModes },
+                    { "dwMonitoredHandsetHookSwitchModes",  FT_FLAGS,   0, aHookSwitchModes },
+                    { "dwMonitoredSpeakerHookSwitchModes",  FT_FLAGS,   0, aHookSwitchModes },
+                    { "dwMonitoredHeadsetHookSwitchModes",  FT_FLAGS,   0, aHookSwitchModes }
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpDevCaps, "PHONECAPS", 0, fields
+                };
+
+
+                if (params[2].dwValue < 0x00020000)
+                {
+                    fieldHeader.dwNumFields = 33;
+                }
+#if TAPI_2_0
+                else
+                {
+                    fieldHeader.dwNumFields = 42;
+
+                    fields[33].dwValue = lpDevCaps->dwDeviceClassesSize;
+                    fields[34].dwValue = lpDevCaps->dwDeviceClassesOffset;
+                    fields[35].dwValue = lpDevCaps->dwPhoneFeatures;
+                    fields[36].dwValue = lpDevCaps->dwSettableHandsetHookSwitchModes;
+                    fields[37].dwValue = lpDevCaps->dwSettableSpeakerHookSwitchModes;
+                    fields[38].dwValue = lpDevCaps->dwSettableHeadsetHookSwitchModes;
+                    fields[39].dwValue = lpDevCaps->dwMonitoredHandsetHookSwitchModes;
+                    fields[40].dwValue = lpDevCaps->dwMonitoredSpeakerHookSwitchModes;
+                    fields[41].dwValue = lpDevCaps->dwMonitoredHeadsetHookSwitchModes;
+                }
+#endif
+
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case pGetDisplay:
+    {
+        LPVARSTRING lpDisplay = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,     PT_DWORD,   0, NULL },
+            { "lpDisplay",  PT_POINTER, (DWORD) lpDisplay, lpDisplay }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) phoneGetDisplay };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        memset (pBigBuf, 0, (size_t) dwBigBufSize);
+        lpDisplay->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpDisplay);
+
+            ShowVARSTRING (lpDisplay);
+        }
+
+        break;
+    }
+    case pGetGain:
+    {
+        DWORD dwGain;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "dwHookSwitchDev",    PT_ORDINAL, PHONEHOOKSWITCHDEV_HANDSET, aHookSwitchDevs },
+            { "lpdwGain",           PT_POINTER, (DWORD) &dwGain, &dwGain }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetGain };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            ShowStr ("%sdwGain=x%lx", szTab, dwGain);
+        }
+
+        break;
+    }
+    case pGetHookSwitch:
+    {
+        DWORD dwHookSwitchDevs;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "lpdwHookSwitchDevs", PT_POINTER, (DWORD) &dwHookSwitchDevs, &dwHookSwitchDevs },
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) phoneGetHookSwitch };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            char szDevsOnHook[32] = "";
+            char szDevsOffHook[32] = "";
+
+            if (dwHookSwitchDevs & PHONEHOOKSWITCHDEV_HANDSET)
+            {
+                strcat (szDevsOffHook, "HANDSET ");
+            }
+            else
+            {
+                strcat (szDevsOnHook, "HANDSET ");
+            }
+
+            if (dwHookSwitchDevs & PHONEHOOKSWITCHDEV_SPEAKER)
+            {
+                strcat (szDevsOffHook, "SPEAKER ");
+            }
+            else
+            {
+                strcat (szDevsOnHook, "SPEAKER ");
+            }
+
+            if (dwHookSwitchDevs & PHONEHOOKSWITCHDEV_HEADSET)
+            {
+                strcat (szDevsOffHook, "HEADSET");
+            }
+            else
+            {
+                strcat (szDevsOnHook, "HEADSET");
+            }
+
+            ShowStr ("%sOn hook : %s", szTab, szDevsOnHook);
+            ShowStr ("%sOff hook: %s", szTab, szDevsOffHook);
+        }
+
+        break;
+    }
+    case pGetIcon:
+#if TAPI_2_0
+    case pGetIconW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        HICON hIcon;
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,         PT_DWORD,   dwDefPhoneDeviceID, NULL },
+            { szlpszDeviceClass,    PT_STRING,  (DWORD) szDeviceClass, szDeviceClass },
+            { "lphIcon",            PT_POINTER, (DWORD) &hIcon, &hIcon }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == pGetIcon ?
+                (PFN3) phoneGetIcon : (PFN3) phoneGetIconW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetIcon };
+#endif
+
+        strcpy (szDeviceClass, szDefPhoneDeviceClass);
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            DialogBoxParam (
+                ghInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG5),
+                (HWND) ghwndMain,
+                (DLGPROC) IconDlgProc,
+                (LPARAM) hIcon
+                );
+        }
+
+        break;
+    }
+    case pGetID:
+#if TAPI_2_0
+    case pGetIDW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        LPVARSTRING lpDevID = (LPVARSTRING) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "lpDeviceID",         PT_POINTER, (DWORD) lpDevID, lpDevID },
+            { szlpszDeviceClass,    PT_STRING,   (DWORD) szDeviceClass, szDeviceClass }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (funcIndex == pGetID ?
+                (PFN3) phoneGetID : (PFN3) phoneGetIDW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetID };
+#endif
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        memset (lpDevID, 0, (size_t) dwBigBufSize);
+        lpDevID->dwTotalSize = dwBigBufSize;
+
+        strcpy (szDeviceClass, szDefPhoneDeviceClass);
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            ShowStructByDWORDs (lpDevID);
+
+            ShowVARSTRING (lpDevID);
+        }
+
+        break;
+    }
+    case pGetLamp:
+    {
+        DWORD dwLampMode;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "dwButtonLampID",     PT_DWORD,   0, NULL },
+            { "lpdwLampMode",       PT_POINTER, (DWORD) &dwLampMode, &dwLampMode }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetLamp };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            int i;
+
+            for (i = 0; aLampModes[i].dwVal != 0xffffffff; i++)
+            {
+                if (dwLampMode == aLampModes[i].dwVal)
+                {
+                    ShowStr ("%slamp mode = %s", szTab, aLampModes[i].lpszVal);
+                    break;
+                }
+            }
+
+            if (aLampModes[i].dwVal == 0xffffffff)
+            {
+                ShowStr ("%sdwLampMode=%xlx (invalid)", szTab, dwLampMode);
+            }
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case pGetMessage:
+    {
+        PHONEMESSAGE msg;
+        FUNC_PARAM params[] =
+        {
+            { szhPhoneApp,  PT_DWORD,   0, NULL },
+            { "lpMessage",  PT_POINTER, (DWORD) &msg, &msg },
+            { "dwTimeout",  PT_DWORD,   0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, NULL };
+
+
+        CHK_PHONEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneAppSel->hPhoneApp;
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        // Max timeout of 2 seconds (don't want to hang app & excite user)
+
+        params[2].dwValue = (params[2].dwValue > 2000 ?
+            2000 : params[2].dwValue);
+
+        DumpParams (&paramsHeader);
+
+        lResult = phoneGetMessage(
+            (HPHONEAPP)      params[0].dwValue,
+            (LPPHONEMESSAGE) params[1].dwValue,
+            (DWORD)          params[2].dwValue
+            );
+
+        ShowPhoneFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult == 0)
+        {
+            tapiCallback(
+                msg.hDevice,
+                msg.dwMessageID,
+                msg.dwCallbackInstance,
+                msg.dwParam1,
+                msg.dwParam2,
+                msg.dwParam3
+                );
+        }
+
+        break;
+    }
+#endif
+    case pGetRing:
+    {
+        DWORD dwRingMode, dwVolume;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,           PT_DWORD,   0, NULL },
+            { "lpdwRingMode",     PT_POINTER, (DWORD) &dwRingMode, &dwRingMode },
+            { "lpdwVolume",       PT_POINTER, (DWORD) &dwVolume, &dwVolume }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetRing };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            ShowStr(
+                "%sdwRingMode=x%lx, dwVolume=x%lx",
+                szTab,
+                dwRingMode,
+                dwVolume
+                );
+        }
+
+        break;
+    }
+    case pGetStatus:
+#if TAPI_2_0
+    case pGetStatusW:
+#endif
+    {
+        LPPHONESTATUS lpPhoneStatus = (LPPHONESTATUS) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,         PT_DWORD,   0, NULL },
+            { "lpPhoneStatus",  PT_POINTER, (DWORD) lpPhoneStatus, lpPhoneStatus }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (funcIndex == pGetStatus ?
+                (PFN2) phoneGetStatus : (PFN2) phoneGetStatusW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) phoneGetStatus };
+#endif
+        DWORD   dwAPIVersion;
+
+
+        CHK_PHONE_SELECTED()
+
+        dwAPIVersion = pPhoneSel->dwAPIVersion;
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        memset (pBigBuf, 0, (size_t) dwBigBufSize);
+        lpPhoneStatus->dwTotalSize = dwBigBufSize;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStructByDWORDs (lpPhoneStatus);
+
+            if (dwDumpStructsFlags & DS_NONZEROFIELDS)
+            {
+                STRUCT_FIELD fields[] =
+                {
+                    { "dwStatusFlags",              FT_FLAGS,   lpPhoneStatus->dwStatusFlags, aPhoneStatusFlags },
+                    { "dwNumOwners",                FT_DWORD,   lpPhoneStatus->dwNumOwners, NULL },
+                    { "dwNumMonitors",              FT_DWORD,   lpPhoneStatus->dwNumMonitors, NULL },
+                    { "dwRingMode",                 FT_DWORD,   lpPhoneStatus->dwRingMode, NULL },
+                    { "dwRingVolume",               FT_DWORD,   lpPhoneStatus->dwRingVolume, NULL },
+                    { "dwHandsetHookSwitchMode",    FT_FLAGS,   lpPhoneStatus->dwHandsetHookSwitchMode, aHookSwitchModes },
+                    { "dwHandsetVolume",            FT_DWORD,   lpPhoneStatus->dwHandsetVolume, NULL },
+                    { "dwHandsetGain",              FT_DWORD,   lpPhoneStatus->dwHandsetGain, NULL },
+                    { "dwSpeakerHookSwitchMode",    FT_FLAGS,   lpPhoneStatus->dwSpeakerHookSwitchMode, aHookSwitchModes },
+                    { "dwSpeakerVolume",            FT_DWORD,   lpPhoneStatus->dwSpeakerVolume, NULL },
+                    { "dwSpeakerGain",              FT_DWORD,   lpPhoneStatus->dwSpeakerGain, NULL },
+                    { "dwHeadsetHookSwitchMode",    FT_FLAGS,   lpPhoneStatus->dwHeadsetHookSwitchMode, aHookSwitchModes },
+                    { "dwHeadsetVolume",            FT_DWORD,   lpPhoneStatus->dwHeadsetVolume, NULL },
+                    { "dwHeadsetGain",              FT_DWORD,   lpPhoneStatus->dwHeadsetGain, NULL },
+                    { "dwDisplaySize",              FT_SIZE,    lpPhoneStatus->dwDisplaySize, NULL },
+                    { "dwDisplayOffset",            FT_OFFSET,  lpPhoneStatus->dwDisplayOffset, NULL },
+                    { "dwLampModesSize",            FT_SIZE,    lpPhoneStatus->dwLampModesSize, NULL },
+                    { "dwLampModesOffset",          FT_OFFSET,  lpPhoneStatus->dwLampModesOffset, NULL },
+                    { "dwOwnerNameSize",            FT_SIZE,    lpPhoneStatus->dwOwnerNameSize, NULL },
+                    { "dwOwnerNameOffset",          FT_OFFSET,  lpPhoneStatus->dwOwnerNameOffset, NULL },
+                    { "dwDevSpecificSize",          FT_SIZE,    lpPhoneStatus->dwDevSpecificSize, NULL },
+                    { "dwDevSpecificOffset",        FT_OFFSET,  lpPhoneStatus->dwDevSpecificOffset, NULL }
+#if TAPI_2_0
+                     ,
+                    { "dwPhoneFeatures",            FT_FLAGS,   0, aPhoneFeatures }
+#endif
+                };
+                STRUCT_FIELD_HEADER fieldHeader =
+                {
+                    lpPhoneStatus, "PHONESTATUS", 0, fields
+                };
+
+
+                if (dwAPIVersion < 0x00020000)
+                {
+                    fieldHeader.dwNumFields = 22;
+                }
+#if TAPI_2_0
+                else
+                {
+                    fieldHeader.dwNumFields = 23;
+
+                    fields[22].dwValue = lpPhoneStatus->dwPhoneFeatures;
+                }
+#endif
+                ShowStructByField (&fieldHeader, FALSE);
+            }
+        }
+
+        break;
+    }
+    case pGetStatusMessages:
+    {
+        DWORD aFlags[3];
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "lpdwPhoneStates",    PT_POINTER, (DWORD) &aFlags[0], &aFlags[0] },
+            { "lpdwButtonModes",    PT_POINTER, (DWORD) &aFlags[1], &aFlags[1] },
+            { "lpdwButtonStates",   PT_POINTER, (DWORD) &aFlags[2], &aFlags[2] }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) phoneGetStatusMessages };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { "dwPhoneStates",  FT_FLAGS,   aFlags[0], aPhoneStates },
+                { "dwButtonModes",  FT_FLAGS,   aFlags[1], aButtonModes },
+                { "dwButtonStates", FT_FLAGS,   aFlags[2], aButtonStates }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                aFlags,
+                "",
+                3,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+        }
+
+        break;
+    }
+    case pGetVolume:
+    {
+        DWORD dwVolume;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "dwHookSwitchDev",    PT_ORDINAL, PHONEHOOKSWITCHDEV_HANDSET, aHookSwitchDevs },
+            { "lpdwVolume",         PT_POINTER, (DWORD) &dwVolume, &dwVolume }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneGetVolume };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            ShowStr ("%sdwVolume=x%lx", szTab, dwVolume);
+        }
+
+        break;
+    }
+    case pInitialize:
+    {
+        DWORD dwNumDevs;
+        PMYPHONEAPP pNewPhoneApp;
+        char szAppName[MAX_STRING_PARAM_SIZE];
+        FUNC_PARAM params[] =
+        {
+            { "lphPhoneApp",    PT_POINTER, 0, NULL },
+            { "hInstance",      PT_DWORD,   (DWORD) ghInst, NULL },
+            { "lpfnCallback",   PT_POINTER, (DWORD) tapiCallback, tapiCallback },
+            { szlpszAppName,    PT_STRING,  (DWORD) szAppName, szAppName },
+            { "lpdwNumDevs",    PT_POINTER, (DWORD) &dwNumDevs, &dwNumDevs }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) phoneInitialize };
+
+
+        if (!(pNewPhoneApp = AllocPhoneApp()))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue =
+        params[0].u.dwDefValue = (DWORD) &pNewPhoneApp->hPhoneApp;
+
+        strcpy (szAppName, szDefAppName);
+
+#ifdef WIN32
+        lResult = DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HINSTANCEs are 16 bits, so we've to hard code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            FreePhoneApp (pNewPhoneApp);
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = phoneInitialize(
+            (LPHPHONEAPP)   params[0].dwValue,
+            (HINSTANCE)     params[1].dwValue,
+            (PHONECALLBACK) params[2].dwValue,
+            (LPCSTR)        params[3].dwValue,
+            (LPDWORD)       params[4].dwValue
+            );
+
+        ShowPhoneFuncResult (aFuncNames[funcIndex], lResult);
+#endif // WIN32
+        if (lResult == 0)
+        {
+            ShowStr ("%snum phone devs=%ld", szTab, dwNumDevs);
+            UpdateWidgetList();
+            gdwNumPhoneDevs = dwNumDevs;
+            SelectWidget ((PMYWIDGET) pNewPhoneApp);
+        }
+        else
+        {
+            FreePhoneApp (pNewPhoneApp);
+        }
+
+        break;
+    }
+#if TAPI_2_0
+    case pInitializeEx:
+    case pInitializeExW:
+    {
+        char                    szAppName[MAX_STRING_PARAM_SIZE];
+        DWORD                   dwNumDevs, dwAPIVersion;
+        PMYPHONEAPP             pNewPhoneApp;
+        PHONEINITIALIZEEXPARAMS initExParams;
+        FUNC_PARAM params[] =
+        {
+            { "lphPhoneApp",    PT_POINTER, 0, NULL },
+            { "hInstance",      PT_DWORD,   (DWORD) ghInst, NULL },
+            { "lpfnCallback",   PT_POINTER, (DWORD) tapiCallback, tapiCallback },
+            { szlpszFriendlyAppName,PT_STRING,  (DWORD) szAppName, szAppName },
+            { "lpdwNumDevs",    PT_POINTER, (DWORD) &dwNumDevs, &dwNumDevs },
+            { "lpdwAPIVersion", PT_POINTER, (DWORD) &dwAPIVersion, &dwAPIVersion },
+            { "  ->dwAPIVersion",PT_ORDINAL,(DWORD) 0x00020000, aAPIVersions },
+            { "lpInitExParams", PT_POINTER, (DWORD) &initExParams, &initExParams },
+            { "  ->dwOptions",  PT_ORDINAL, (DWORD) PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT, aInitExOptions }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 9, funcIndex, params, NULL };
+
+
+        if (!(pNewPhoneApp = AllocPhoneApp()))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue =
+        params[0].u.dwDefValue = (DWORD) &pNewPhoneApp->hPhoneApp;
+
+        strcpy (szAppName, szDefAppName);
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            FreePhoneApp (pNewPhoneApp);
+
+            break;
+        }
+
+        initExParams.dwTotalSize = sizeof (PHONEINITIALIZEEXPARAMS);
+        initExParams.dwOptions = params[8].dwValue;
+        initExParams.Handles.hCompletionPort = ghCompletionPort;
+
+        dwAPIVersion = params[6].dwValue;
+
+        DumpParams (&paramsHeader);
+
+        if (funcIndex == pInitializeEx)
+        {
+            lResult = phoneInitializeEx(
+                (LPHPHONEAPP)               params[0].dwValue,
+                (HINSTANCE)                 params[1].dwValue,
+                (PHONECALLBACK)             params[2].dwValue,
+                (LPCSTR)                    params[3].dwValue,
+                (LPDWORD)                   params[4].dwValue,
+                (LPDWORD)                   params[5].dwValue,
+                (LPPHONEINITIALIZEEXPARAMS) params[7].dwValue
+                );
+        }
+        else
+        {
+            lResult = phoneInitializeExW(
+                (LPHPHONEAPP)               params[0].dwValue,
+                (HINSTANCE)                 params[1].dwValue,
+                (PHONECALLBACK)             params[2].dwValue,
+                (LPCWSTR)                   params[3].dwValue,
+                (LPDWORD)                   params[4].dwValue,
+                (LPDWORD)                   params[5].dwValue,
+                (LPPHONEINITIALIZEEXPARAMS) params[7].dwValue
+                );
+        }
+
+        ShowPhoneFuncResult (aFuncNames[funcIndex], lResult);
+
+        if (lResult == 0)
+        {
+            ShowStr ("%snum phone devs = %ld", szTab, dwNumDevs);
+
+            if (params[7].dwValue != 0  &&
+                (initExParams.dwOptions & 3) ==
+                    PHONEINITIALIZEEXOPTION_USEEVENT)
+            {
+                ShowStr(
+                    "hPhoneApp x%x was created with the\r\n" \
+                        "USEEVENT option, so you must use\r\n" \
+                        "phoneGetMessage to retrieve messages.",
+                    pNewPhoneApp->hPhoneApp
+                    );
+            }
+
+
+            //SendMessage (ghwndLineApps, LB_SETCURSEL, (WPARAM) i, 0);
+            UpdateWidgetList();
+            gdwNumPhoneDevs = dwNumDevs;
+            SelectWidget ((PMYWIDGET) pNewPhoneApp);
+        }
+        else
+        {
+            FreePhoneApp (pNewPhoneApp);
+        }
+
+        break;
+    }
+#endif
+    case pOpen:
+    {
+        PMYPHONE pNewPhone;
+        FUNC_PARAM params[] =
+        {
+            { "hPhoneApp",          PT_DWORD,   0, NULL },
+            { szdwDeviceID,         PT_DWORD,   dwDefPhoneDeviceID, NULL },
+            { "lphPhone",           PT_POINTER, 0, NULL },
+            { szdwAPIVersion,       PT_ORDINAL, dwDefPhoneAPIVersion, aAPIVersions },
+            { "dwExtVersion",       PT_DWORD,   dwDefPhoneExtVersion, NULL },
+            { "dwCallbackInstance", PT_DWORD,   0, NULL },
+            { "dwPrivilege",        PT_ORDINAL, dwDefPhonePrivilege, aPhonePrivileges }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 7, funcIndex, params, (PFN7) phoneOpen };
+
+
+        CHK_PHONEAPP_SELECTED()
+
+        if (!(pNewPhone = AllocPhone(pPhoneAppSel)))
+        {
+            MessageBeep ((UINT) -1);
+            ShowStr ("error creating data structure");
+            break;
+        }
+
+        params[0].dwValue = (DWORD) pPhoneAppSel->hPhoneApp;
+        params[2].dwValue =
+        params[2].u.dwDefValue = (DWORD) &pNewPhone->hPhone;
+
+        if ((lResult = DoFunc(&paramsHeader)) == 0)
+        {
+            if ((HPHONEAPP) params[0].dwValue != pPhoneAppSel->hPhoneApp)
+            {
+                //
+                // User has switched phone apps on us we need to recreate
+                // the phone data structure under a different phone app
+                //
+
+                PMYPHONE pNewPhone2 =
+                    AllocPhone (GetPhoneApp((HPHONEAPP)params[0].dwValue));
+
+                if (pNewPhone2)
+                {
+                    pNewPhone2->hPhone = pNewPhone->hPhone;
+
+                    FreePhone (pNewPhone);
+
+                    pNewPhone = pNewPhone2;
+                }
+                else
+                {
+                    // BUGBUG show error: couldn't alloc a new phone struct
+
+                    phoneClose (pNewPhone->hPhone);
+                    FreePhone (pNewPhone);
+                    break;
+                }
+            }
+
+
+            //
+            // Save info about this phone that we can display later
+            //
+
+            pNewPhone->hPhoneApp    = (HPHONEAPP) params[0].dwValue;
+            pNewPhone->dwDevID      = params[1].dwValue;
+            pNewPhone->dwAPIVersion = params[3].dwValue;
+            pNewPhone->dwPrivilege  = params[6].dwValue;
+
+            UpdateWidgetList();
+            SelectWidget ((PMYWIDGET) pNewPhone);
+        }
+        else
+        {
+            FreePhone (pNewPhone);
+        }
+
+        break;
+    }
+    case pNegotiateAPIVersion:
+    {
+        DWORD dwAPIVersion;
+        PHONEEXTENSIONID extID;
+        FUNC_PARAM params[] =
+        {
+            { "hPhoneApp",          PT_DWORD,   0, NULL },
+            { szdwDeviceID,         PT_DWORD,   dwDefPhoneDeviceID, NULL },
+            { "dwAPILowVersion",    PT_DWORD,   0x00010000, aAPIVersions },
+            { "dwAPIHighVersion",   PT_DWORD,   0x10000000, aAPIVersions },
+            { "lpdwAPIVersion",     PT_POINTER, (DWORD) &dwAPIVersion, &dwAPIVersion },
+            { "lpExtensionID",      PT_POINTER, (DWORD) &extID, &extID }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) phoneNegotiateAPIVersion };
+
+
+        CHK_PHONEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneAppSel->hPhoneApp;
+
+        if ((lResult = DoFunc (&paramsHeader)) == 0)
+        {
+            ShowStr ("%s%s=x%lx", szTab, szdwAPIVersion, dwAPIVersion);
+            ShowStr(
+                "%sextID.ID0=x%lx, .ID1=x%lx, .ID2=x%lx, .ID3=x%lx, ",
+                szTab,
+                extID.dwExtensionID0,
+                extID.dwExtensionID1,
+                extID.dwExtensionID2,
+                extID.dwExtensionID3
+                );
+        }
+
+        break;
+    }
+    case pNegotiateExtVersion:
+    {
+        DWORD dwExtVersion;
+        FUNC_PARAM params[] =
+        {
+            { szhPhoneApp,          PT_DWORD,   0, NULL },
+            { szdwDeviceID,         PT_DWORD,   dwDefPhoneDeviceID, NULL },
+            { szdwAPIVersion,       PT_ORDINAL, dwDefPhoneAPIVersion, aAPIVersions },
+            { "dwExtLowVersion",    PT_DWORD,   0x00000000, NULL },
+            { "dwExtHighVersion",   PT_DWORD,   0x80000000, NULL },
+            { "lpdwExtVersion",     PT_POINTER, (DWORD) &dwExtVersion, &dwExtVersion }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 6, funcIndex, params, (PFN6) phoneNegotiateExtVersion };
+
+
+        CHK_PHONEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneAppSel->hPhoneApp;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            ShowStr ("%sdwExtVersion=x%lx", szTab, dwExtVersion);
+        }
+
+        break;
+    }
+    case pSetButtonInfo:
+#if TAPI_2_0
+    case pSetButtonInfoW:
+#endif
+    {
+        char szButtonText[MAX_STRING_PARAM_SIZE] = "button text";
+        char szDevSpecific[MAX_STRING_PARAM_SIZE] = "dev specific info";
+        LPPHONEBUTTONINFO lpButtonInfo = (LPPHONEBUTTONINFO) pBigBuf;
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,                 PT_DWORD,   0, NULL },
+            { "dwButtonLampID",         PT_DWORD,   0, NULL },
+            { "lpData",                 PT_POINTER, (DWORD) lpButtonInfo, lpButtonInfo },
+            { "  ->dwButtonMode",       PT_FLAGS,   PHONEBUTTONMODE_CALL,  aButtonModes },
+            { "  ->dwButtonFunction",   PT_DWORD,   0, NULL },
+//            { "  ->dwButtonFunction",  PT_???,   , aButtonFunctions },
+            { "  ->ButtonText",         PT_STRING,  (DWORD) szButtonText,  szButtonText },
+            { "  ->DevSpecific",        PT_STRING,  (DWORD) szDevSpecific, szDevSpecific },
+#if TAPI_1_1
+            { "  ->dwButtonState",      PT_FLAGS,   0,  aButtonStates }
+#endif
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+#if TAPI_1_1
+            { 8, funcIndex, params, NULL };
+#else
+            { 7, funcIndex, params, NULL };
+#endif
+        DWORD dwFixedStructSize = sizeof(PHONEBUTTONINFO), dwLength;
+
+
+        // BUGBUG need a PT_ type to specify constants (ords?) for ->dwButtonFunction
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+
+        //
+        // Note: the dwButtonState field in PHONEBUTTONINFO is only valid
+        // in 1.4+.  It'll be ignored for phones opened w/ ver 1.3.
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        memset (lpButtonInfo, 0, (size_t) dwBigBufSize);
+
+        if (dwBigBufSize >= 4)
+        {
+            lpButtonInfo->dwTotalSize = dwBigBufSize;
+
+            if (dwBigBufSize >= 0x24) // sizeof(PHONEBUTTONINFO) in ver 0x10003
+            {
+                lpButtonInfo->dwButtonMode     = params[3].dwValue;
+                lpButtonInfo->dwButtonFunction = params[4].dwValue;
+
+                if ((params[5].dwValue == (DWORD) szButtonText) &&
+                    (dwLength = (DWORD) strlen (szButtonText)) &&
+                    (dwBigBufSize >= (dwFixedStructSize + dwLength + 1)))
+                {
+                    lpButtonInfo->dwButtonTextSize   = dwLength + 1;
+                    lpButtonInfo->dwButtonTextOffset = dwFixedStructSize;
+#if TAPI_2_0
+                    if (gbWideStringParams)
+                    {
+                        lpButtonInfo->dwButtonTextSize *= sizeof (WCHAR);
+
+                        MultiByteToWideChar(
+                            CP_ACP,
+                            MB_PRECOMPOSED,
+                            (LPCSTR) szButtonText,
+                            -1,
+                            (LPWSTR) (((char far *) lpButtonInfo) +
+                                dwFixedStructSize),
+                            MAX_STRING_PARAM_SIZE / 2
+                            );
+                    }
+                    else
+                    {
+                        strcpy(
+                            ((char far *) lpButtonInfo) + dwFixedStructSize,
+                            szButtonText
+                            );
+                    }
+#else
+                    strcpy(
+                        ((char far *) lpButtonInfo) + dwFixedStructSize,
+                        szButtonText
+                        );
+#endif
+                }
+
+                if ((params[6].dwValue == (DWORD) szDevSpecific) &&
+                    (dwLength = (DWORD) strlen (szDevSpecific)) &&
+                    (dwBigBufSize >= (dwFixedStructSize + dwLength + 1 +
+                        lpButtonInfo->dwButtonTextSize)))
+                {
+                    lpButtonInfo->dwDevSpecificSize   = dwLength + 1;
+                    lpButtonInfo->dwDevSpecificOffset = dwFixedStructSize +
+                        lpButtonInfo->dwButtonTextSize;
+#if TAPI_2_0
+                    if (gbWideStringParams)
+                    {
+                        lpButtonInfo->dwDevSpecificSize *= sizeof (WCHAR);
+
+                        MultiByteToWideChar(
+                            CP_ACP,
+                            MB_PRECOMPOSED,
+                            (LPCSTR) szDevSpecific,
+                            -1,
+                            (LPWSTR) (((char far *) lpButtonInfo) +
+                                lpButtonInfo->dwDevSpecificOffset),
+                            MAX_STRING_PARAM_SIZE / 2
+                            );
+                    }
+                    else
+                    {
+                        strcpy(
+                            ((char far *) lpButtonInfo) +
+                                lpButtonInfo->dwDevSpecificOffset,
+                            szDevSpecific
+                            );
+                    }
+#else
+                    strcpy(
+                        ((char far *) lpButtonInfo) +
+                            lpButtonInfo->dwDevSpecificOffset,
+                        szDevSpecific
+                        );
+#endif
+                }
+#if TAPI_1_1
+                if (dwBigBufSize >= dwFixedStructSize)
+                {
+                    lpButtonInfo->dwButtonState = params[7].dwValue;
+                }
+#endif
+            }
+        }
+
+#if TAPI_2_0
+        if (funcIndex == pSetButtonInfo)
+        {
+            lResult = phoneSetButtonInfo(
+                (HPHONE) params[0].dwValue,
+                params[1].dwValue,
+                (LPPHONEBUTTONINFO) params[2].dwValue
+                );
+        }
+        else
+        {
+            lResult = phoneSetButtonInfoW(
+                (HPHONE) params[0].dwValue,
+                params[1].dwValue,
+                (LPPHONEBUTTONINFO) params[2].dwValue
+                );
+        }
+#else
+        lResult = phoneSetButtonInfo(
+            (HPHONE) params[0].dwValue,
+            params[1].dwValue,
+            (LPPHONEBUTTONINFO) params[2].dwValue
+            );
+#endif
+        ShowPhoneFuncResult (aFuncNames[funcIndex], lResult);
+
+        break;
+    }
+    case pSetData:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,     PT_DWORD,   0, NULL },
+            { "dwDataID",   PT_DWORD,   0, NULL },
+            { "lpData",     PT_POINTER, (DWORD) pBigBuf, pBigBuf },
+            { szdwSize,     PT_DWORD,   dwBigBufSize, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) phoneSetData };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetDisplay:
+    {
+        char szDisplay[MAX_STRING_PARAM_SIZE] = "123";
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,     PT_DWORD,   0, NULL },
+            { "dwRow",      PT_DWORD,   0, NULL },
+            { "dwColumn",   PT_DWORD,   0, NULL },
+            { "lpsDisplay", PT_STRING, (DWORD) szDisplay, szDisplay },
+            { szdwSize,     PT_DWORD,   3, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 5, funcIndex, params, (PFN5) phoneSetDisplay };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetGain:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "dwHookSwitchDev",    PT_ORDINAL, PHONEHOOKSWITCHDEV_HANDSET, aHookSwitchDevs },
+            { "dwGain",             PT_DWORD,   0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneSetGain };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetHookSwitch:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "dwHookSwitchDevs",   PT_FLAGS,   PHONEHOOKSWITCHDEV_HANDSET, aHookSwitchDevs },
+            { "dwHookSwitchMode",   PT_ORDINAL, PHONEHOOKSWITCHMODE_ONHOOK, aHookSwitchModes }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneSetHookSwitch };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetLamp:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,         PT_DWORD,   0, NULL },
+            { "dwButtonLampID", PT_DWORD,   0, NULL },
+            { "dwLampMode",     PT_ORDINAL, PHONELAMPMODE_OFF, aLampModes }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneSetLamp };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetRing:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,     PT_DWORD, 0, NULL },
+            { "dwRingMode", PT_DWORD, 0, NULL },
+            { "dwVolume",   PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneSetRing };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetStatusMessages:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,         PT_DWORD, 0, NULL },
+            { "dwPhoneStates",  PT_FLAGS, 0, aPhoneStates },
+            { "dwButtonModes",  PT_FLAGS, 0, aButtonModes },
+            { "dwButtonStates", PT_FLAGS, 0, aButtonStates }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) phoneSetStatusMessages };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pSetVolume:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhone,             PT_DWORD,   0, NULL },
+            { "dwHookSwitchDev",    PT_ORDINAL, PHONEHOOKSWITCHDEV_HANDSET, aHookSwitchDevs },
+            { "dwVolume",           PT_DWORD,   0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 3, funcIndex, params, (PFN3) phoneSetVolume };
+
+
+        CHK_PHONE_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneSel->hPhone;
+
+        lResult = DoFunc (&paramsHeader);
+
+        break;
+    }
+    case pShutdown:
+    {
+        FUNC_PARAM params[] =
+        {
+            { szhPhoneApp,   PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, (PFN1) phoneShutdown };
+
+
+        CHK_PHONEAPP_SELECTED()
+
+        params[0].dwValue = (DWORD) pPhoneAppSel->hPhoneApp;
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+            FreePhoneApp (GetPhoneApp((HPHONEAPP) params[0].dwValue));
+        }
+
+        break;
+    }
+    case tGetLocationInfo:
+#if TAPI_2_0
+    case tGetLocationInfoW:
+#endif
+    {
+        char szCountryCode[MAX_STRING_PARAM_SIZE] = "";
+        char szCityCode[MAX_STRING_PARAM_SIZE] = "";
+        FUNC_PARAM params[] =
+        {
+            { "lpszCountryCode",    PT_POINTER, (DWORD) szCountryCode, szCountryCode },
+            { "lpszCityCode",       PT_POINTER, (DWORD) szCityCode, szCityCode }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (funcIndex == tGetLocationInfo ?
+                (PFN2) tapiGetLocationInfo : (PFN2) tapiGetLocationInfoW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) tapiGetLocationInfo };
+#endif
+
+        if (DoFunc (&paramsHeader) == 0)
+        {
+#if TAPI_2_0
+            ShowStr(
+                (gbWideStringParams ? "%s*lpszCountryCode='%ws'" :
+                    "%s*lpszCountryCode='%s'"),
+                szTab,
+                szCountryCode
+                );
+
+            ShowStr(
+                (gbWideStringParams ? "%s*lpszCityCode='%ws'" :
+                    "%s*lpszCityCode='%s'"),
+                szTab,
+                szCityCode
+                );
+#else
+            ShowStr ("%s*lpszCountryCode='%s'", szTab, szCountryCode);
+            ShowStr ("%s*lpszCityCode='%s'", szTab, szCityCode);
+#endif
+        }
+
+        break;
+    }
+    case tRequestDrop:
+    {
+        FUNC_PARAM params[] =
+        {
+            { "hWnd",       PT_DWORD, (DWORD) ghwndMain, 0 },
+            { "wRequestID", PT_DWORD, (DWORD) 0, 0 }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 2, funcIndex, params, (PFN2) tapiRequestDrop };
+
+#ifdef WIN32
+        DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDSs & WPARAMs are 16 bits, so we've to hard
+        //       code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = tapiRequestDrop(
+            (HWND) params[0].dwValue,
+            (WPARAM) params[1].dwValue
+            );
+
+        ShowTapiFuncResult (aFuncNames[funcIndex], lResult);
+#endif // WIN32
+        break;
+    }
+    case tRequestMakeCall:
+#if TAPI_2_0
+    case tRequestMakeCallW:
+#endif
+    {
+        char szDestAddress[MAX_STRING_PARAM_SIZE];
+        char szAppName[MAX_STRING_PARAM_SIZE];
+        char szCalledParty[MAX_STRING_PARAM_SIZE] = "";
+        char szComment[MAX_STRING_PARAM_SIZE] = "";
+        FUNC_PARAM params[] =
+        {
+            { szlpszDestAddress,    PT_STRING, (DWORD) szDestAddress, szDestAddress },
+            { szlpszAppName,        PT_STRING, (DWORD) szAppName, szAppName },
+            { "lpszCalledParty",    PT_STRING, (DWORD) szCalledParty, szCalledParty },
+            { "lpszComment",        PT_STRING, (DWORD) szComment, szComment }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (funcIndex == tRequestMakeCall ?
+                (PFN4) tapiRequestMakeCall : (PFN4) tapiRequestMakeCallW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 4, funcIndex, params, (PFN4) tapiRequestMakeCall };
+#endif
+
+        strcpy (szDestAddress, szDefDestAddress);
+        strcpy (szAppName, szDefAppName);
+
+        DoFunc (&paramsHeader);
+
+        break;
+    }
+    case tRequestMediaCall:
+#if TAPI_2_0
+    case tRequestMediaCallW:
+#endif
+    {
+        char szDeviceClass[MAX_STRING_PARAM_SIZE];
+        char szDevID[MAX_STRING_PARAM_SIZE] = "0";
+        char szDestAddress[MAX_STRING_PARAM_SIZE];
+        char szAppName[MAX_STRING_PARAM_SIZE];
+        char szCalledParty[MAX_STRING_PARAM_SIZE] = "";
+        char szComment[MAX_STRING_PARAM_SIZE] = "";
+        FUNC_PARAM params[] =
+        {
+            { "hWnd",               PT_DWORD,  (DWORD) ghwndMain, 0 },
+            { "wRequestID",         PT_DWORD,  (DWORD) 0, 0 },
+            { szlpszDeviceClass,    PT_STRING, (DWORD) szDeviceClass, szDeviceClass },
+            { "lpDeviceID",         PT_STRING, (DWORD) szDevID, szDevID },
+            { szdwSize,             PT_DWORD,  0, 0 },
+            { "dwSecure",           PT_DWORD,  0, 0 },
+            { szlpszDestAddress,    PT_STRING, (DWORD) szDestAddress, szDestAddress },
+            { szlpszAppName,        PT_STRING, (DWORD) szAppName, szAppName },
+            { "lpszCalledParty",    PT_STRING, (DWORD) szCalledParty, szCalledParty },
+            { "lpszComment",        PT_STRING, (DWORD) szComment, szComment }
+        };
+#if TAPI_2_0
+        FUNC_PARAM_HEADER paramsHeader =
+            { 10, funcIndex, params, (funcIndex == tRequestMediaCall ?
+                (PFN10) tapiRequestMediaCall : (PFN10) tapiRequestMediaCallW) };
+#else
+        FUNC_PARAM_HEADER paramsHeader =
+            { 10, funcIndex, params, (PFN10) tapiRequestMediaCall };
+#endif
+
+        strcpy (szDeviceClass, szDefLineDeviceClass); // BUGBUG szDefTapiDeviceClass);
+        strcpy (szDestAddress, szDefDestAddress);
+        strcpy (szAppName, szDefAppName);
+
+#ifdef WIN32
+        DoFunc (&paramsHeader);
+#else
+        //
+        // NOTE: on win16 HWNDSs & WPARAMs are 16 bits, so we've to hard
+        //       code this
+        //
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        DumpParams (&paramsHeader);
+
+        lResult = tapiRequestMediaCall(
+            (HWND) params[0].dwValue,
+            (WPARAM) params[1].dwValue,
+            (LPCSTR) params[2].dwValue,
+            (LPCSTR) params[3].dwValue,
+            params[4].dwValue,
+            params[5].dwValue,
+            (LPCSTR) params[6].dwValue,
+            (LPCSTR) params[7].dwValue,
+            (LPCSTR) params[8].dwValue,
+            (LPCSTR) params[9].dwValue
+            );
+
+        ShowTapiFuncResult (aFuncNames[funcIndex], lResult);
+#endif // WIN32
+        break;
+    }
+    case OpenAllLines:
+    {
+        DWORD dwDefLineDeviceIDSav = dwDefLineDeviceID;
+
+
+        CHK_LINEAPP_SELECTED()
+
+        for(
+            dwDefLineDeviceID = 0;
+            dwDefLineDeviceID < gdwNumLineDevs;
+            dwDefLineDeviceID++
+            )
+        {
+            FuncDriver (lOpen);
+        }
+
+        dwDefLineDeviceID = dwDefLineDeviceIDSav;
+
+        break;
+    }
+    case OpenAllPhones:
+    {
+        DWORD dwDefPhoneDeviceIDSav = dwDefPhoneDeviceID;
+
+
+        CHK_PHONEAPP_SELECTED()
+
+        for(
+            dwDefPhoneDeviceID = 0;
+            dwDefPhoneDeviceID < gdwNumPhoneDevs;
+            dwDefPhoneDeviceID++
+            )
+        {
+            FuncDriver (pOpen);
+        }
+
+        dwDefPhoneDeviceID = dwDefPhoneDeviceIDSav;
+
+        break;
+    }
+    case CloseHandl:
+    {
+#ifdef WIN32
+        FUNC_PARAM params[] =
+        {
+            { "hObject",  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, NULL };
+
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        if (CloseHandle ((HANDLE) params[0].dwValue))
+        {
+            ShowStr ("Handle x%lx closed", params[0].dwValue);
+        }
+        else
+        {
+            ShowStr ("CloseHandle failed, err=%lx", GetLastError());
+        }
+#else
+        FUNC_PARAM params[] =
+        {
+            { "idCommDev",  PT_DWORD, 0, NULL }
+        };
+        FUNC_PARAM_HEADER paramsHeader =
+            { 1, funcIndex, params, NULL };
+
+
+        if (!LetUserMungeParams (&paramsHeader))
+        {
+            break;
+        }
+
+        if (CloseComm ((int) params[0].dwValue) == 0)
+        {
+            ShowStr ("Comm dev x%lx closed", params[0].dwValue);
+        }
+        else
+        {
+            ShowStr ("CloseComm() failed");
+        }
+#endif
+
+        break;
+    }
+    case DumpBuffer:
+
+        ShowStr ("Buffer contents:");
+
+        ShowBytes(
+            (dwBigBufSize > 256 ? 256 : dwBigBufSize),
+            pBigBuf,
+            1
+            );
+
+        break;
+
+    default:
+
+        MessageBeep ((UINT)-1);
+        break;
+    }
+}
+
+#pragma warning (default:4113)
diff --git a/private/tapi/dev/apps/tb/ui.c b/private/tapi/dev/apps/tb/ui.c
new file mode 100644
index 000000000..b57a34dee
--- /dev/null
+++ b/private/tapi/dev/apps/tb/ui.c
@@ -0,0 +1,4704 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-96  Microsoft Corporation
+
+Module Name:
+
+    ui.c
+
+Abstract:
+
+    Contains UI support for TAPI Browser util.
+
+Author:
+
+    Dan Knudson (DanKn)    23-Oct-1994
+
+Revision History:
+
+--*/
+
+
+#include "tb.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <io.h>
+#include <malloc.h>
+#include <time.h>
+#include <commdlg.h>
+#include "resource.h"
+#include "vars.h"
+
+
+extern char szdwSize[];
+extern char szdwAddressID[];
+
+
+HWND hwndEdit2;
+
+
+char *
+PASCAL
+GetTimeStamp(
+    void
+    );
+
+void
+ShowStructByField(
+    PSTRUCT_FIELD_HEADER    pHeader,
+    BOOL    bSubStructure
+    );
+
+void
+CompletionPortThread(
+    LPVOID  pParams
+    );
+
+
+int
+WINAPI
+WinMain(
+    HINSTANCE   hInstance,
+    HINSTANCE   hPrevInstance,
+    LPSTR       lpCmdLine,
+    int         nCmdShow
+    )
+{
+    MSG     msg;
+    HWND    hwnd;
+    HACCEL  hAccel;
+
+
+    ghInst = hInstance;
+
+    hwnd = CreateDialog(
+        ghInst,
+        (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG1),
+        (HWND)NULL,
+        (DLGPROC) MainWndProc
+        );
+
+    hwndEdit2 = CreateWindow ("edit", "", 0, 0, 0, 0, 0, NULL, NULL, ghInst, NULL);
+
+    if (!hwndEdit2)
+    {
+        MessageBox (NULL, "err creating edit ctl", "", MB_OK);
+    }
+
+    hAccel = LoadAccelerators(
+        ghInst,
+        (LPCSTR)MAKEINTRESOURCE(IDR_ACCELERATOR1)
+        );
+
+#if TAPI_2_0
+
+    if ((ghCompletionPort = CreateIoCompletionPort(
+            INVALID_HANDLE_VALUE,
+            NULL,
+            0,
+            0
+            )))
+    {
+        DWORD   dwTID;
+        HANDLE  hThread;
+
+
+        if ((hThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) CompletionPortThread,
+                NULL,
+                0,
+                &dwTID
+                )))
+        {
+            CloseHandle (hThread);
+        }
+        else
+        {
+            ShowStr(
+                "CreateThread(CompletionPortThread) failed, err=%d",
+                GetLastError()
+                );
+        }
+    }
+    else
+    {
+        ShowStr ("CreateIoCompletionPort failed, err=%d", GetLastError());
+    }
+
+#endif
+
+    while (GetMessage (&msg, NULL, 0, 0))
+    {
+        if (!TranslateAccelerator (hwnd, hAccel, &msg))
+        {
+            TranslateMessage (&msg);
+            DispatchMessage (&msg);
+        }
+    }
+
+    DestroyWindow (hwndEdit2);
+
+    return 0;
+}
+
+
+void
+CompletionPortThread(
+    LPVOID  pParams
+    )
+{
+    DWORD           dwNumBytesTransfered, dwCompletionKey;
+    LPLINEMESSAGE   pMsg;
+
+
+    while (GetQueuedCompletionStatus(
+            ghCompletionPort,
+            &dwNumBytesTransfered,
+            &dwCompletionKey,
+            (LPOVERLAPPED *) &pMsg,
+            INFINITE
+            ))
+    {
+        if (pMsg)
+        {
+            tapiCallback(
+                pMsg->hDevice,
+                pMsg->dwMessageID,
+                pMsg->dwCallbackInstance,
+                pMsg->dwParam1,
+                pMsg->dwParam2,
+                pMsg->dwParam3
+                );
+
+            LocalFree (pMsg);
+        }
+        else
+        {
+            break;
+        }
+    }
+}
+
+
+void
+GetCurrentSelections(
+    void
+    )
+{
+    LONG      lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+    PMYWIDGET pWidget = aWidgets;
+
+
+    //
+    // Init all pXxxSel ptrs to NULL
+    //
+
+    pLineAppSel  = (PMYLINEAPP) NULL;
+    pLineSel     = (PMYLINE) NULL;
+    pCallSel     =
+    pCallSel2    = (PMYCALL) NULL;
+    pPhoneAppSel = (PMYPHONEAPP) NULL;
+    pPhoneSel    = (PMYPHONE) NULL;
+
+
+    if (lSel != LB_ERR)
+    {
+        //
+        // Find the selected widget & set globals appropriately
+        //
+
+        pWidget = (PMYWIDGET) SendMessage(
+            ghwndList1,
+            LB_GETITEMDATA,
+            (WPARAM) lSel,
+            0
+            );
+
+        switch (pWidget->dwType)
+        {
+        case WT_LINEAPP:
+
+            pLineAppSel = (PMYLINEAPP) pWidget;
+            break;
+
+        case WT_LINE:
+
+            pLineSel    = (PMYLINE) pWidget;
+            pLineAppSel = pLineSel->pLineApp;
+            break;
+
+        case WT_CALL:
+
+            pCallSel    = (PMYCALL) pWidget;
+            pLineSel    = pCallSel->pLine;
+            pLineAppSel = pCallSel->pLine->pLineApp;
+
+            if (pWidget->pNext && (pWidget->pNext->dwType == WT_CALL))
+            {
+                pCallSel2 = (PMYCALL) pWidget->pNext;
+            }
+            else if ((((PMYWIDGET)pLineSel)->pNext != pWidget) &&
+                     (((PMYWIDGET)pLineSel)->pNext->dwType == WT_CALL))
+            {
+                pCallSel2 =  (PMYCALL) (((PMYWIDGET)pLineSel)->pNext);
+            }
+
+            break;
+
+        case WT_PHONEAPP:
+
+            pPhoneAppSel = (PMYPHONEAPP) pWidget;
+            break;
+
+        case WT_PHONE:
+
+            pPhoneSel    = (PMYPHONE) pWidget;
+            pPhoneAppSel = pPhoneSel->pPhoneApp;
+            break;
+        }
+    }
+
+
+    //
+    // The following is an attempt to up the usability level a little bit.
+    // Most folks are going to be messing around with 1 lineapp/line/call
+    // at a time, and it'd end up being a real PITA for them to have to
+    // select a widget each time (and it's fairly obvious which widget
+    // are referring to).  So we're going to try to make some intelligent
+    // decisions in case they haven't selected a widget... (Obviously this
+    // could be cleaned up a bit, like maybe maintaining dwNumXxx as
+    // globals rather than walking the list each time.)
+    //
+
+    {
+        DWORD       dwNumLineApps = 0, dwNumLines = 0, dwNumCalls = 0,
+                    dwNumPhoneApps = 0, dwNumPhones = 0;
+        PMYPHONEAPP pPhoneApp = NULL;
+
+
+        pWidget = aWidgets;
+
+        while (pWidget)
+        {
+            switch (pWidget->dwType)
+            {
+            case WT_LINEAPP:
+
+                dwNumLineApps++;
+                break;
+
+            case WT_LINE:
+
+                dwNumLines++;
+                break;
+
+            case WT_CALL:
+
+                dwNumCalls++;
+                break;
+
+            case WT_PHONEAPP:
+
+                dwNumPhoneApps++;
+
+                if (dwNumPhoneApps == 1)
+                {
+                    pPhoneApp = (PMYPHONEAPP) pWidget;
+                }
+
+                break;
+
+            case WT_PHONE:
+
+                dwNumPhones++;
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+
+        if (dwNumLineApps == 1)
+        {
+            pLineAppSel = (PMYLINEAPP) aWidgets;
+
+            if (dwNumLines == 1)
+            {
+                pLineSel = (PMYLINE) pLineAppSel->Widget.pNext;
+
+                if (dwNumCalls == 1)
+                {
+                    pCallSel = (PMYCALL) pLineSel->Widget.pNext;
+                }
+            }
+        }
+
+        if (dwNumPhoneApps == 1)
+        {
+            pPhoneAppSel = (PMYPHONEAPP) pPhoneApp;
+
+            if (dwNumPhones == 1)
+            {
+                pPhoneSel = (PMYPHONE) pPhoneAppSel->Widget.pNext;
+            }
+        }
+    }
+}
+
+/* help
+VOID
+MyWinHelp(
+    HWND  hwndOwner,
+    BOOL  bTapiHlp,
+    UINT  uiCommand,
+    DWORD dwData
+    )
+{
+    char *lpszHelpFile = (bTapiHlp ? szTapiHlp : szTspiHlp);
+
+
+    if (lpszHelpFile[0] == 0 || _access (lpszHelpFile, 0))
+    {
+        //
+        // Prompt user for helpfile path
+        //
+
+        OPENFILENAME ofn;
+        char szDirName[256] = ".\\";
+        char szFile[256] = "tapi.hlp\0";
+        char szFileTitle[256] = "";
+        char szFilter[] = "Telephony API Help\0tapi.hlp\0\0";
+
+
+        if (MessageBox(
+                hwndOwner,
+                "Help file not found- do you want to specify a new help file?",
+                "Warning",
+                MB_YESNO
+                ) == IDNO)
+        {
+            return;
+        }
+
+        if (!bTapiHlp)
+        {
+            szFile[1] = 's';
+            szFilter[10] = 'S';
+            szFilter[20] = 's';
+        }
+
+        ofn.lStructSize       = sizeof(OPENFILENAME);
+        ofn.hwndOwner         = hwndOwner;
+        ofn.lpstrFilter       = szFilter;
+        ofn.lpstrCustomFilter = (LPSTR) NULL;
+        ofn.nMaxCustFilter    = 0L;
+        ofn.nFilterIndex      = 1;
+        ofn.lpstrFile         = szFile;
+        ofn.nMaxFile          = sizeof(szFile);
+        ofn.lpstrFileTitle    = szFileTitle;
+        ofn.nMaxFileTitle     = sizeof(szFileTitle);
+        ofn.lpstrInitialDir   = szDirName;
+        ofn.lpstrTitle        = (LPSTR) NULL;
+        ofn.Flags             = 0L;
+        ofn.nFileOffset       = 0;
+        ofn.nFileExtension    = 0;
+        ofn.lpstrDefExt       = "HLP";
+
+        if (!GetOpenFileName(&ofn))
+        {
+            return;
+        }
+
+        strcpy (lpszHelpFile, szFile);
+    }
+
+    if (!WinHelp (ghwndMain, (LPCSTR) lpszHelpFile, uiCommand, dwData))
+    {
+        lpszHelpFile[0] = 0;
+    }
+}
+*/
+
+BOOL
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static HICON  hIcon;
+    static HMENU  hMenu;
+    static int    icyButton, icyBorder;
+    static HFONT  hFont, hFont2;
+
+    int  i;
+
+    static LONG cxList1, cxList2, cxWnd, xCapture, cxVScroll, lCaptureFlags = 0;
+    static int cyWnd;
+
+    typedef struct _XXX
+    {
+        DWORD   dwMenuID;
+
+        DWORD   dwFlags;
+
+    } XXX, *PXXX;
+
+    static XXX aXxx[] =
+    {
+        { IDM_LOGSTRUCTDWORD        ,DS_BYTEDUMP },
+        { IDM_LOGSTRUCTALLFIELD     ,DS_NONZEROFIELDS|DS_ZEROFIELDS },
+        { IDM_LOGSTRUCTNONZEROFIELD ,DS_NONZEROFIELDS },
+        { IDM_LOGSTRUCTNONE         ,0 }
+    };
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        RECT rect;
+        char buf[64];
+
+
+        ghwndMain  = hwnd;
+        ghwndList1 = GetDlgItem (hwnd, IDC_LIST1);
+        ghwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+        ghwndEdit  = GetDlgItem (hwnd, IDC_EDIT1);
+        hMenu      = GetMenu (hwnd);
+        hIcon      = LoadIcon (ghInst, MAKEINTRESOURCE(IDI_ICON1));
+
+        icyBorder = GetSystemMetrics (SM_CYFRAME);
+        cxVScroll = 2*GetSystemMetrics (SM_CXVSCROLL);
+
+        GetWindowRect (GetDlgItem (hwnd, IDC_BUTTON1), &rect);
+        icyButton = (rect.bottom - rect.top) + icyBorder + 3;
+
+        for (i = 0; aFuncNames[i]; i++)
+        {
+            SendMessage(
+                ghwndList2,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) aFuncNames[i]
+                );
+        }
+
+        SendMessage (ghwndList2, LB_SETCURSEL, (WPARAM) lInitialize, 0);
+
+
+#ifdef WIN32
+        SetWindowText (hwnd, "TAPI32 Browser");
+#else
+        SetWindowText (hwnd, "TAPI16 Browser");
+#endif
+
+        //
+        // Read in defaults from ini file
+        //
+
+        {
+            typedef struct _DEF_VALUE
+            {
+                char far *lpszEntry;
+                char far *lpszDefValue;
+                LPVOID   lp;
+
+            } DEF_VALUE;
+
+            DEF_VALUE aDefVals[] =
+            {
+                { "BufSize",            "1000", &dwBigBufSize },
+                { "AddressID",          "0", &dwDefAddressID },
+#if TAPI_2_0
+                { "20LineAPIVersion",   "20000", &dwDefLineAPIVersion },
+#else
+#if TAPI_1_1
+                { "14LineAPIVersion",   "10004", &dwDefLineAPIVersion },
+#else
+                { "13LineAPIVersion",   "10003", &dwDefLineAPIVersion },
+#endif
+#endif
+                { "BearerMode",         "1", &dwDefBearerMode },
+                { "CountryCode",        "0", &dwDefCountryCode },
+                { "LineDeviceID",       "0", &dwDefLineDeviceID },
+                { "LineExtVersion",     "0", &dwDefLineExtVersion },
+                { "MediaMode",         "10", &dwDefMediaMode },        // DATAMODEM
+                { "LinePrivilege",      "1", &dwDefLinePrivilege },    // NONE (dialout only)
+#if TAPI_2_0
+                { "20PhoneAPIVersion",  "20000", &dwDefPhoneAPIVersion },
+#else
+#if TAPI_1_1
+                { "14PhoneAPIVersion",  "10004", &dwDefPhoneAPIVersion },
+#else
+                { "13PhoneAPIVersion",  "10003", &dwDefPhoneAPIVersion },
+#endif
+#endif
+                { "PhoneDeviceID",      "0", &dwDefPhoneDeviceID },
+                { "PhoneExtVersion",    "0", &dwDefPhoneExtVersion },
+                { "PhonePrivilege",     "2", &dwDefPhonePrivilege },   // OWNER
+#if TAPI_2_0
+                { "20UserButton1",      "500", aUserButtonFuncs },
+                { "20UserButton2",      "500", aUserButtonFuncs + 1 },
+                { "20UserButton3",      "500", aUserButtonFuncs + 2 },
+                { "20UserButton4",      "500", aUserButtonFuncs + 3 },
+                { "20UserButton5",      "500", aUserButtonFuncs + 4 },
+                { "20UserButton6",      "500", aUserButtonFuncs + 5 },
+#else
+#if TAPI_1_1
+                { "14UserButton1",      "500", aUserButtonFuncs },
+                { "14UserButton2",      "500", aUserButtonFuncs + 1 },
+                { "14UserButton3",      "500", aUserButtonFuncs + 2 },
+                { "14UserButton4",      "500", aUserButtonFuncs + 3 },
+                { "14UserButton5",      "500", aUserButtonFuncs + 4 },
+                { "14UserButton6",      "500", aUserButtonFuncs + 5 },
+#else
+                { "13UserButton1",      "500", aUserButtonFuncs },
+                { "13UserButton2",      "500", aUserButtonFuncs + 1 },
+                { "13UserButton3",      "500", aUserButtonFuncs + 2 },
+                { "13UserButton4",      "500", aUserButtonFuncs + 3 },
+                { "13UserButton5",      "500", aUserButtonFuncs + 4 },
+                { "13UserButton6",      "500", aUserButtonFuncs + 5 },
+#endif
+#endif
+                { "TimeStamp",          "0", &bTimeStamp },
+                { "NukeIdleMonitorCalls",   "1", &bNukeIdleMonitorCalls },
+                { "NukeIdleOwnedCalls",     "0", &bNukeIdleOwnedCalls },
+                { "DisableHandleChecking", "0", &gbDisableHandleChecking },
+                { "DumpStructsFlags",   "1",   &dwDumpStructsFlags },
+                { NULL, NULL, NULL },
+                { "UserUserInfo",       "my user user info", szDefUserUserInfo },
+                { "DestAddress",        "55555", szDefDestAddress },
+                { "LineDeviceClass",    "tapi/line", szDefLineDeviceClass },
+                { "PhoneDeviceClass",   "tapi/phone", szDefPhoneDeviceClass },
+                { "AppName",            "Tapi Browser", szDefAppName },
+                { NULL, NULL, NULL },
+#if TAPI_2_0
+                { "20UserButton1Text",  "", &aUserButtonsText[0] },
+                { "20UserButton2Text",  "", &aUserButtonsText[1] },
+                { "20UserButton3Text",  "", &aUserButtonsText[2] },
+                { "20UserButton4Text",  "", &aUserButtonsText[3] },
+                { "20UserButton5Text",  "", &aUserButtonsText[4] },
+                { "20UserButton6Text",  "", &aUserButtonsText[5] },
+#else
+#if TAPI_1_1
+                { "14UserButton1Text",  "", &aUserButtonsText[0] },
+                { "14UserButton2Text",  "", &aUserButtonsText[1] },
+                { "14UserButton3Text",  "", &aUserButtonsText[2] },
+                { "14UserButton4Text",  "", &aUserButtonsText[3] },
+                { "14UserButton5Text",  "", &aUserButtonsText[4] },
+                { "14UserButton6Text",  "", &aUserButtonsText[5] },
+#else
+                { "13UserButton1Text",  "", &aUserButtonsText[0] },
+                { "13UserButton2Text",  "", &aUserButtonsText[1] },
+                { "13UserButton3Text",  "", &aUserButtonsText[2] },
+                { "13UserButton4Text",  "", &aUserButtonsText[3] },
+                { "13UserButton5Text",  "", &aUserButtonsText[4] },
+                { "13UserButton6Text",  "", &aUserButtonsText[5] },
+#endif
+#endif
+                { NULL, NULL, NULL }
+            };
+
+            int i, j;
+
+            #define MYSECTION "Tapi Browser"
+
+
+            for (i = 0; aDefVals[i].lpszEntry; i++)
+            {
+                GetProfileString(
+                    MYSECTION,
+                    aDefVals[i].lpszEntry,
+                    aDefVals[i].lpszDefValue,
+                    buf,
+                    15
+                    );
+
+                sscanf (buf, "%lx", aDefVals[i].lp);
+            }
+
+            i++;
+
+            for (; aDefVals[i].lpszEntry; i++)
+            {
+                GetProfileString(
+                    MYSECTION,
+                    aDefVals[i].lpszEntry,
+                    aDefVals[i].lpszDefValue,
+                    (LPSTR) aDefVals[i].lp,
+                    MAX_STRING_PARAM_SIZE - 1
+                    );
+            }
+
+            i++;
+
+            for (j = i; aDefVals[i].lpszEntry; i++)
+            {
+                GetProfileString(
+                    MYSECTION,
+                    aDefVals[i].lpszEntry,
+                    aDefVals[i].lpszDefValue,
+                    (LPSTR) aDefVals[i].lp,
+                    MAX_USER_BUTTON_TEXT_SIZE - 1
+                    );
+
+                SetDlgItemText(
+                    hwnd,
+                    IDC_BUTTON13 + (i - j),
+                    (LPCSTR)aDefVals[i].lp
+                    );
+            }
+
+            lpszDefAppName          = szDefAppName;
+            lpszDefUserUserInfo     = szDefUserUserInfo;
+            lpszDefDestAddress      = szDefDestAddress;
+            lpszDefLineDeviceClass  = szDefLineDeviceClass;
+            lpszDefPhoneDeviceClass = szDefPhoneDeviceClass;
+
+            if (GetProfileString (
+                    MYSECTION,
+                    "Version",
+                    "",
+                    buf,
+                    15
+                    ) == 0 || (strcmp (buf, szCurrVer)))
+            {
+                //
+                // If here assume this is first time user had started
+                // TB, so post a msg that will automatically bring up
+                // the hlp dlg
+                //
+
+                PostMessage (hwnd, WM_COMMAND, IDM_USINGTB, 0);
+            }
+
+// help            GetProfileString (MYSECTION, "TapiHlpPath", "", szTapiHlp, 256);
+// help            GetProfileString (MYSECTION, "TspiHlpPath", "", szTspiHlp, 256);
+        }
+
+        pBigBuf = malloc ((size_t)dwBigBufSize);
+
+        {
+            //HFONT hFontMenu = SendMessage (hMenu, WM_GETFONT, 0, 0);
+
+            hFont = CreateFont(
+                13, 5, 0, 0, 400, 0, 0, 0, 0, 1, 2, 1, 34, "MS Sans Serif"
+                );
+            hFont2 = CreateFont(
+                13, 8, 0, 0, 400, 0, 0, 0, 0, 1, 2, 1, 49, "Courier"
+                );
+
+            for (i = 0; i < 18; i++)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_BUTTON1 + i,
+                    WM_SETFONT,
+                    (WPARAM) hFont,
+                    0
+                    );
+            }
+
+            SendMessage (ghwndList1, WM_SETFONT, (WPARAM) hFont, 0);
+            SendMessage (ghwndList2, WM_SETFONT, (WPARAM) hFont, 0);
+            SendMessage (ghwndEdit, WM_SETFONT, (WPARAM) hFont2, 0);
+        }
+
+        GetProfileString(
+            MYSECTION,
+            "ControlRatios",
+            "20, 20, 100",
+            buf,
+            63
+            );
+
+        sscanf (buf, "%ld,%ld,%ld", &cxList2, &cxList1, &cxWnd);
+
+        GetProfileString(
+            MYSECTION,
+            "Position",
+            "max",
+            buf,
+            63
+            );
+
+        if (strcmp (buf, "max") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMAXIMIZED);
+        }
+        else
+        {
+            int left = 100, top = 100, right = 600, bottom = 400;
+
+
+            sscanf (buf, "%d,%d,%d,%d", &left, &top, &right, &bottom);
+
+
+            //
+            // Check to see if wnd pos is wacky, if so reset to reasonable vals
+            //
+
+            if (left < 0 ||
+                left >= (GetSystemMetrics (SM_CXSCREEN) - 32) ||
+                top < 0 ||
+                top >= (GetSystemMetrics (SM_CYSCREEN) - 32))
+            {
+                left = top = 100;
+                right = 600;
+                bottom = 400;
+            }
+
+            SetWindowPos(
+                hwnd,
+                HWND_TOP,
+                left,
+                top,
+                right - left,
+                bottom - top,
+                SWP_SHOWWINDOW
+                );
+
+            GetClientRect (hwnd, &rect);
+
+            SendMessage(
+                hwnd,
+                WM_SIZE,
+                0,
+                MAKELONG((rect.right-rect.left),(rect.bottom-rect.top))
+                );
+
+            ShowWindow (hwnd, SW_SHOW);
+        }
+
+        for (i = 0; aXxx[i].dwFlags != dwDumpStructsFlags; i++);
+
+        CheckMenuItem (hMenu, aXxx[i].dwMenuID, MF_BYCOMMAND | MF_CHECKED);
+
+        CheckMenuItem(
+            hMenu,
+            IDM_TIMESTAMP,
+            MF_BYCOMMAND | (bTimeStamp ? MF_CHECKED : MF_UNCHECKED)
+            );
+
+        CheckMenuItem(
+            hMenu,
+            IDM_NUKEIDLEMONITORCALLS,
+            MF_BYCOMMAND | (bNukeIdleMonitorCalls ? MF_CHECKED : MF_UNCHECKED)
+            );
+
+        CheckMenuItem(
+            hMenu,
+            IDM_NUKEIDLEOWNEDCALLS,
+            MF_BYCOMMAND | (bNukeIdleOwnedCalls ? MF_CHECKED : MF_UNCHECKED)
+            );
+
+        CheckMenuItem(
+            hMenu,
+            IDM_NOHANDLECHK,
+            MF_BYCOMMAND | (gbDisableHandleChecking ? MF_CHECKED : MF_UNCHECKED)
+            );
+
+        //
+        // Alloc & init the global call params
+        //
+
+#if TAPI_2_0
+
+        lpCallParamsW = NULL;
+
+init_call_params:
+
+#endif
+        {
+#if TAPI_2_0
+            size_t callParamsSize =
+                sizeof(LINECALLPARAMS) + 15 * MAX_STRING_PARAM_SIZE;
+#else
+            size_t callParamsSize =
+                sizeof(LINECALLPARAMS) + 8 * MAX_STRING_PARAM_SIZE;
+#endif
+
+            if ((lpCallParams = (LPLINECALLPARAMS) malloc (callParamsSize)))
+            {
+                LPDWORD lpdwXxxOffset = &lpCallParams->dwOrigAddressOffset;
+
+
+                memset (lpCallParams, 0, callParamsSize);
+
+                lpCallParams->dwTotalSize   = (DWORD) callParamsSize;
+                lpCallParams->dwBearerMode  = LINEBEARERMODE_VOICE;
+                lpCallParams->dwMinRate     = 3100;
+                lpCallParams->dwMaxRate     = 3100;
+                lpCallParams->dwMediaMode   = LINEMEDIAMODE_INTERACTIVEVOICE;
+                lpCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+
+                for (i = 0; i < 8; i++)
+                {
+                    *(lpdwXxxOffset + 2*i) =
+                        sizeof(LINECALLPARAMS) + i*MAX_STRING_PARAM_SIZE;
+                }
+#if TAPI_2_0
+                {
+                    LPDWORD pdwProxyRequests = (LPDWORD)
+                                (((LPBYTE) lpCallParams) +
+                                lpCallParams->dwDevSpecificOffset);
+
+
+                    for (i = 0; i < 8; i++)
+                    {
+                        *(pdwProxyRequests + i) = i +
+                            LINEPROXYREQUEST_SETAGENTGROUP;
+                    }
+                }
+
+                lpdwXxxOffset = &lpCallParams->dwTargetAddressOffset;
+
+                for (i = 0; i < 6; i++)
+                {
+                    *(lpdwXxxOffset + 2 * i) =
+                        sizeof(LINECALLPARAMS) + (8+i)*MAX_STRING_PARAM_SIZE;
+                }
+
+                lpCallParams->dwCallingPartyIDOffset    =
+                    sizeof(LINECALLPARAMS) + 14 * MAX_STRING_PARAM_SIZE;
+
+                if (!lpCallParamsW)
+                {
+                    lpCallParamsW = lpCallParams;
+                    goto init_call_params;
+                }
+#endif
+            }
+            else
+            {
+                // BUGBUG
+            }
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        FUNC_INDEX funcIndex;
+        BOOL bShowParamsSave = bShowParams;
+
+        switch (LOWORD((DWORD)wParam))
+        {
+        case IDC_EDIT1:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == EN_CHANGE)
+#else
+            if (HIWORD(lParam) == EN_CHANGE)
+#endif
+            {
+                //
+                // Watch to see if the edit control is full, & if so
+                // purge the top half of the text to make room for more
+                //
+
+                int length = GetWindowTextLength (ghwndEdit);
+
+
+                if (length > 29998)
+                {
+#ifdef WIN32
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM) 0,
+                        (LPARAM) 10000
+                        );
+#else
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM) 1,
+                        (LPARAM) MAKELONG (0, 10000)
+                        );
+#endif
+
+                    SendMessage(
+                        ghwndEdit,
+                        EM_REPLACESEL,
+                        0,
+                        (LPARAM) (char far *) ""
+                        );
+
+#ifdef WIN32
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)0xfffffffd,
+                        (LPARAM)0xfffffffe
+                        );
+#else
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)1,
+                        (LPARAM) MAKELONG (0xfffd, 0xfffe)
+                        );
+#endif
+                }
+            }
+            break;
+
+        case IDC_BUTTON1:
+
+            funcIndex = lInitialize;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON2:
+
+            funcIndex = lShutdown;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON3:
+
+            funcIndex = lOpen;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON4:
+
+            funcIndex = lClose;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON5:
+
+            funcIndex = lMakeCall;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON6:
+
+            GetCurrentSelections();
+
+            if (pCallSel && (pCallSel->dwCallState == LINECALLSTATE_IDLE))
+            {
+                funcIndex = lDeallocateCall;
+            }
+            else
+            {
+                funcIndex = lDrop;
+                gbDeallocateCall = TRUE;
+            }
+
+            FuncDriver (funcIndex);
+            gbDeallocateCall = FALSE;
+            break;
+
+        case IDC_BUTTON7:
+
+            funcIndex = pInitialize;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON8:
+
+            funcIndex = pShutdown;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON9:
+
+            funcIndex = pOpen;
+            goto IDC_BUTTON10_callFuncDriver;
+
+        case IDC_BUTTON10:
+
+            funcIndex = pClose;
+
+IDC_BUTTON10_callFuncDriver:
+
+            //
+            // Want to make the "hot buttons" as simple as possible, so
+            // turn off the show params flag, then call FuncDriver, and
+            // finally restore the flag
+            //
+
+            GetCurrentSelections ();
+            FuncDriver (funcIndex);
+            break;
+
+        case IDC_BUTTON11:
+        case IDM_CLEAR:
+
+            SetWindowText (ghwndEdit, "");
+            break;
+
+
+        case IDM_PARAMS:
+        case IDC_BUTTON12:
+
+            bShowParams = (bShowParams ? FALSE : TRUE);
+
+            if (bShowParams)
+            {
+                CheckMenuItem(
+                    hMenu,
+                    IDM_PARAMS,
+                    MF_BYCOMMAND | MF_CHECKED
+                    );
+
+                CheckDlgButton (hwnd, IDC_BUTTON12, 1);
+            }
+            else
+            {
+                CheckMenuItem(
+                    hMenu,
+                    IDM_PARAMS,
+                    MF_BYCOMMAND | MF_UNCHECKED
+                    );
+
+                CheckDlgButton (hwnd, IDC_BUTTON12, 0);
+            }
+
+            break;
+
+        case IDC_BUTTON13:
+        case IDC_BUTTON14:
+        case IDC_BUTTON15:
+        case IDC_BUTTON16:
+        case IDC_BUTTON17:
+        case IDC_BUTTON18:
+        {
+            DWORD i = (DWORD) (LOWORD((DWORD)wParam)) - IDC_BUTTON13;
+
+
+            if (aUserButtonFuncs[i] >= MiscBegin)
+            {
+                //
+                // Hot button func id is bogus, so bring
+                // up hot button init dlg
+                //
+
+                DialogBoxParam(
+                    ghInst,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    (HWND) hwnd,
+                    (DLGPROC) UserButtonsDlgProc,
+                    (LPARAM) &i
+                    );
+            }
+            else
+            {
+                //
+                // Invoke the user button's corresponding func
+                //
+
+                GetCurrentSelections ();
+                FuncDriver ((FUNC_INDEX) aUserButtonFuncs[i]);
+            }
+
+            break;
+        }
+/* help        case IDC_F1HELP:
+
+            if ((GetFocus() == ghwndEdit) &&
+                SendMessage (ghwndEdit, EM_GETSEL, 0, 0))
+            {
+                //
+                // Display help for the selected text in the edit ctrl
+                //
+
+                char buf[32];
+
+
+                //
+                // Copy the selected text in the edit ctrl to our
+                // temp edit control, then query the temp edit ctrl's
+                // text (this seems to be the easiest way to get the
+                // selected text)
+                //
+
+                SendMessage (ghwndEdit, WM_COPY, 0, 0);
+                SetWindowText (hwndEdit2, "");
+                SendMessage (hwndEdit2, WM_PASTE, 0, 0);
+
+
+                //
+                // In the interest of getting an exact match on a
+                // helpfile key strip off any trailing spaces
+                //
+
+                GetWindowText (hwndEdit2, buf, 32);
+                buf[31] = 0;
+                for (i = 0; i < 32; i++)
+                {
+                    if (buf[i] == ' ')
+                    {
+                        buf[i] = 0;
+                        break;
+                    }
+                }
+
+                MyWinHelp (hwnd, TRUE, HELP_PARTIALKEY, (DWORD) buf);
+            }
+            else
+            {
+                //
+                // Display help for the currently selected func
+                //
+
+                FUNC_INDEX funcIndex = (FUNC_INDEX)
+                    SendMessage (ghwndList2, LB_GETCURSEL, 0, 0);
+
+
+                MyWinHelp (hwnd, TRUE, HELP_PARTIALKEY, (DWORD) aFuncNames[funcIndex]);
+            }
+
+            break;
+*/
+        case IDC_PREVCTRL:
+        {
+            HWND hwndPrev = GetNextWindow (GetFocus (), GW_HWNDPREV);
+
+            if (!hwndPrev)
+            {
+                hwndPrev = ghwndList2;
+            }
+
+            SetFocus (hwndPrev);
+            break;
+        }
+        case IDC_NEXTCTRL:
+        {
+            HWND hwndNext = GetNextWindow (GetFocus (), GW_HWNDNEXT);
+
+            if (!hwndNext)
+            {
+                hwndNext = GetDlgItem (hwnd, IDC_BUTTON12);
+            }
+
+            SetFocus (hwndNext);
+            break;
+        }
+        case IDC_ENTER:
+        {
+            if (GetFocus() != ghwndEdit)
+            {
+                GetCurrentSelections ();
+                FuncDriver(
+                    (FUNC_INDEX)SendMessage(
+                        ghwndList2,
+                        LB_GETCURSEL,
+                        0,
+                        0
+                        ));
+            }
+            else
+            {
+                // Send the edit ctrl a cr/lf
+            }
+
+            break;
+        }
+        case IDC_LIST1:
+
+#ifdef WIN32
+            switch (HIWORD(wParam))
+#else
+            switch (HIWORD(lParam))
+#endif
+            {
+            case LBN_DBLCLK:
+            {
+                LONG lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+                PMYWIDGET pWidget;
+
+
+                pWidget = (PMYWIDGET) SendMessage(
+                    ghwndList1,
+                    LB_GETITEMDATA,
+                    (WPARAM) lSel,
+                    0
+                    );
+
+                if ((pWidget->dwType == WT_LINEAPP)
+                    || (pWidget->dwType == WT_PHONEAPP)
+                    )
+                {
+                    break;
+                }
+
+                bShowParams = FALSE;
+
+                UpdateResults (TRUE);
+
+                switch (pWidget->dwType)
+                {
+                case WT_LINE:
+                {
+                    DWORD dwDefLineDeviceIDSave = dwDefLineDeviceID;
+                    PMYLINE pLine = (PMYLINE) pWidget;
+
+
+                    dwDefLineDeviceID = pLine->dwDevID;
+
+                    pLineAppSel = GetLineApp (pLine->hLineApp);
+                    pLineSel = pLine;
+
+                    FuncDriver (lGetDevCaps);
+                    FuncDriver (lGetLineDevStatus);
+
+                    dwDefLineDeviceID = dwDefLineDeviceIDSave;
+                    break;
+                }
+                case WT_CALL:
+                {
+                    PMYCALL pCall = (PMYCALL) pWidget;
+
+
+                    pCallSel = pCall;
+
+                    FuncDriver (lGetCallInfo);
+                    FuncDriver (lGetCallStatus);
+
+                    break;
+                }
+                case WT_PHONE:
+                {
+                    DWORD dwDefPhoneDeviceIDSave = dwDefPhoneDeviceID;
+                    PMYPHONE pPhone = (PMYPHONE) pWidget;
+
+
+                    dwDefPhoneDeviceID = pPhone->dwDevID;
+
+                    pPhoneAppSel = GetPhoneApp (pPhone->hPhoneApp);
+                    pPhoneSel = pPhone;
+
+                    FuncDriver (pGetDevCaps);
+                    FuncDriver (pGetStatus);
+
+                    dwDefPhoneDeviceID = dwDefPhoneDeviceIDSave;
+                    break;
+                }
+                }
+
+                UpdateResults (FALSE);
+
+                bShowParams = bShowParamsSave;
+
+                break;
+            }
+            } // switch
+
+            break;
+
+        case IDC_LIST2:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_DBLCLK)
+#else
+            if (HIWORD(lParam) == LBN_DBLCLK)
+#endif
+            {
+                GetCurrentSelections ();
+                FuncDriver(
+                    (FUNC_INDEX)SendMessage(
+                        ghwndList2,
+                        LB_GETCURSEL,
+                        0,
+                        0
+                        ));
+            }
+
+            break;
+
+        case IDM_EXIT:
+        {
+            PostMessage (hwnd, WM_CLOSE, 0, 0);
+            break;
+        }
+        case IDM_DEFAULTVALUES:
+        {
+            char szTmpAppName[MAX_STRING_PARAM_SIZE];
+            char szTmpUserUserInfo[MAX_STRING_PARAM_SIZE];
+            char szTmpDestAddress[MAX_STRING_PARAM_SIZE];
+            char szTmpLineDeviceClass[MAX_STRING_PARAM_SIZE];
+            char szTmpPhoneDeviceClass[MAX_STRING_PARAM_SIZE];
+            FUNC_PARAM params[] =
+            {
+                { "Buffer size",            PT_DWORD,  dwBigBufSize, NULL },
+                { "lpszAppName",            PT_STRING, (DWORD) lpszDefAppName, szTmpAppName },
+
+                { "line: dwAddressID",      PT_DWORD,  dwDefAddressID, NULL },
+                { "line: dwAPIVersion",     PT_DWORD,  dwDefLineAPIVersion, NULL },
+                { "line: dwBearerMode",     PT_FLAGS,  dwDefBearerMode, aBearerModes },
+                { "line: dwCountryCode",    PT_DWORD,  dwDefCountryCode, NULL },
+                { "line: dwDeviceID",       PT_DWORD,  dwDefLineDeviceID, NULL },
+                { "line: dwExtVersion",     PT_DWORD,  dwDefLineExtVersion, NULL },
+                { "line: dwMediaMode",      PT_FLAGS,  dwDefMediaMode, aMediaModes },
+                { "line: dwPrivileges",     PT_FLAGS,  dwDefLinePrivilege, aLineOpenOptions },
+                { "line: lpsUserUserInfo",  PT_STRING, (DWORD) lpszDefUserUserInfo, szTmpUserUserInfo },
+                { "line: lpszDestAddress",  PT_STRING, (DWORD) lpszDefDestAddress, szTmpDestAddress },
+                { "line: lpszDeviceClass",  PT_STRING, (DWORD) lpszDefLineDeviceClass, szTmpLineDeviceClass },
+                { "phone: dwAPIVersion",    PT_DWORD,  dwDefPhoneAPIVersion, NULL },
+                { "phone: dwDeviceID",      PT_DWORD,  dwDefPhoneDeviceID, NULL },
+                { "phone: dwExtVersion",    PT_DWORD,  dwDefPhoneExtVersion, NULL },
+                { "phone: dwPrivilege",     PT_FLAGS,  dwDefPhonePrivilege, aPhonePrivileges },
+                { "phone: lpszDeviceClass", PT_STRING, (DWORD) lpszDefPhoneDeviceClass, szTmpPhoneDeviceClass }
+            };
+            FUNC_PARAM_HEADER paramsHeader =
+                { 18, DefValues, params, NULL };
+            BOOL bShowParamsSave = bShowParams;
+
+            bShowParams = TRUE;
+
+            strcpy (szTmpAppName, szDefAppName);
+            strcpy (szTmpUserUserInfo, szDefUserUserInfo);
+            strcpy (szTmpDestAddress, szDefDestAddress);
+            strcpy (szTmpLineDeviceClass, szDefLineDeviceClass);
+            strcpy (szTmpPhoneDeviceClass, szDefPhoneDeviceClass);
+
+            if (LetUserMungeParams (&paramsHeader))
+            {
+                if (params[0].dwValue != dwBigBufSize)
+                {
+                    LPVOID pTmpBigBuf = malloc ((size_t) params[0].dwValue);
+
+                    if (pTmpBigBuf)
+                    {
+                        free (pBigBuf);
+                        pBigBuf = pTmpBigBuf;
+                        dwBigBufSize = params[0].dwValue;
+                    }
+                }
+
+                strcpy (szDefAppName, szTmpAppName);
+
+                dwDefAddressID      = params[2].dwValue;
+                dwDefLineAPIVersion = params[3].dwValue;
+                dwDefBearerMode     = params[4].dwValue;
+                dwDefCountryCode    = params[5].dwValue;
+                dwDefLineDeviceID   = params[6].dwValue;
+                dwDefLineExtVersion = params[7].dwValue;
+                dwDefMediaMode      = params[8].dwValue;
+                dwDefLinePrivilege  = params[9].dwValue;
+
+                strcpy (szDefUserUserInfo, szTmpUserUserInfo);
+                strcpy (szDefDestAddress, szTmpDestAddress);
+                strcpy (szDefLineDeviceClass, szTmpLineDeviceClass);
+
+                dwDefPhoneAPIVersion = params[13].dwValue;
+                dwDefPhoneDeviceID   = params[14].dwValue;
+                dwDefPhoneExtVersion = params[15].dwValue;
+                dwDefPhonePrivilege  = params[16].dwValue;
+
+                strcpy (szDefPhoneDeviceClass, szTmpPhoneDeviceClass);
+
+                if (params[1].dwValue && (params[1].dwValue != 0xffffffff))
+                {
+                    lpszDefAppName = szDefAppName;
+                }
+                else
+                {
+                    lpszDefAppName = (char far *) params[1].dwValue;
+                }
+
+                if (params[10].dwValue && (params[10].dwValue != 0xffffffff))
+                {
+                    lpszDefUserUserInfo = szDefUserUserInfo;
+                }
+                else
+                {
+                    lpszDefUserUserInfo = (char far *) params[10].dwValue;
+                }
+
+                if (params[11].dwValue && (params[11].dwValue != 0xffffffff))
+                {
+                    lpszDefDestAddress = szDefDestAddress;
+                }
+                else
+                {
+                    lpszDefDestAddress = (char far *) params[11].dwValue;
+                }
+
+                if (params[12].dwValue && (params[12].dwValue != 0xffffffff))
+                {
+                    lpszDefLineDeviceClass  = szDefLineDeviceClass;
+                }
+                else
+                {
+                    lpszDefLineDeviceClass  = (char far *) params[12].dwValue;
+                }
+
+                if (params[17].dwValue && (params[17].dwValue != 0xffffffff))
+                {
+                    lpszDefPhoneDeviceClass = szDefPhoneDeviceClass;
+                }
+                else
+                {
+                    lpszDefPhoneDeviceClass = (char far *) params[17].dwValue;
+                }
+            }
+
+            bShowParams = bShowParamsSave;
+
+            break;
+        }
+        case IDM_USERBUTTONS:
+
+            DialogBoxParam(
+                ghInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) hwnd,
+                (DLGPROC) UserButtonsDlgProc,
+                (LPARAM) NULL
+                );
+
+            break;
+
+        case IDM_DUMPPARAMS:
+
+            bDumpParams = (bDumpParams ? FALSE : TRUE);
+
+            CheckMenuItem(
+                hMenu,
+                IDM_DUMPPARAMS,
+                MF_BYCOMMAND | (bDumpParams ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_LOGSTRUCTDWORD:
+        case IDM_LOGSTRUCTALLFIELD:
+        case IDM_LOGSTRUCTNONZEROFIELD:
+        case IDM_LOGSTRUCTNONE:
+
+            for (i = 0; aXxx[i].dwFlags != dwDumpStructsFlags; i++);
+
+            CheckMenuItem(
+                hMenu,
+                aXxx[i].dwMenuID,
+                MF_BYCOMMAND | MF_UNCHECKED
+                );
+
+            for (i = 0; aXxx[i].dwMenuID != LOWORD((DWORD)wParam); i++);
+
+            CheckMenuItem(
+                hMenu,
+                aXxx[i].dwMenuID,
+                MF_BYCOMMAND | MF_CHECKED
+                );
+
+            dwDumpStructsFlags = aXxx[i].dwFlags;
+
+            break;
+
+        case IDM_TIMESTAMP:
+
+            bTimeStamp = (bTimeStamp ? FALSE : TRUE);
+
+            CheckMenuItem(
+                hMenu,
+                IDM_TIMESTAMP,
+                MF_BYCOMMAND | (bTimeStamp ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_LOGFILE:
+        {
+            if (hLogFile)
+            {
+                fclose (hLogFile);
+                hLogFile = (FILE *) NULL;
+                CheckMenuItem(
+                    hMenu,
+                    IDM_LOGFILE,
+                    MF_BYCOMMAND | MF_UNCHECKED
+                    );
+            }
+            else
+            {
+                OPENFILENAME ofn;
+                char szDirName[256] = ".\\";
+                char szFile[256] = "tb.log\0";
+                char szFileTitle[256] = "";
+                static char *szFilter =
+                    "Log files (*.log)\0*.log\0All files (*.*)\0*.*\0\0";
+
+
+                ofn.lStructSize       = sizeof(OPENFILENAME);
+                ofn.hwndOwner         = hwnd;
+                ofn.lpstrFilter       = szFilter;
+                ofn.lpstrCustomFilter = (LPSTR) NULL;
+                ofn.nMaxCustFilter    = 0L;
+                ofn.nFilterIndex      = 1;
+                ofn.lpstrFile         = szFile;
+                ofn.nMaxFile          = sizeof(szFile);
+                ofn.lpstrFileTitle    = szFileTitle;
+                ofn.nMaxFileTitle     = sizeof(szFileTitle);
+                ofn.lpstrInitialDir   = szDirName;
+                ofn.lpstrTitle        = (LPSTR) NULL;
+                ofn.Flags             = 0L;
+                ofn.nFileOffset       = 0;
+                ofn.nFileExtension    = 0;
+                ofn.lpstrDefExt       = "LOG";
+
+                if (!GetOpenFileName(&ofn))
+                {
+                    return 0L;
+                }
+
+                if ((hLogFile = fopen (szFile, "at")) == (FILE *) NULL)
+                {
+                    MessageBox(
+                        hwnd,
+                        "Error creating log file",
+#ifdef WIN32
+                        "TB32.EXE",
+#else
+                        "TB.EXE",
+#endif
+                        MB_OK
+                        );
+                }
+                else
+                {
+                    struct tm *newtime;
+                    time_t aclock;
+
+
+                    time (&aclock);
+                    newtime = localtime (&aclock);
+                    fprintf(
+                        hLogFile,
+                        "\n---Log opened: %s\n",
+                        asctime (newtime)
+                        );
+
+                    CheckMenuItem(
+                        hMenu,
+                        IDM_LOGFILE,
+                        MF_BYCOMMAND | MF_CHECKED
+                        );
+                }
+            }
+            break;
+        }
+        case IDM_USINGTB:
+        {
+            static char szUsingTB[] =
+
+                "ABSTRACT:\r\n"                                         \
+                "    TB (TAPI Browser) is an application that\r\n"      \
+                "allows a user to interactively call into the\r\n"      \
+                "Windows Telephony interface and inspect all\r\n"       \
+                "returned information. The following versions\r\n"      \
+                "of TB are available:\r\n\r\n"                          \
+                "    TB13.EXE: 16-bit app, TAPI v1.0\r\n"               \
+                "    TB14.EXE: 32-bit app, <= TAPI v1.4\r\n"            \
+                "    TB20.EXE: 32-bit app, <= TAPI v2.0\r\n"            \
+
+                "\r\n"                                                  \
+                "GETTING STARTED:\r\n"                                  \
+                "1. Press the 'LAp+' button to initialize TAPI \r\n"    \
+                "2. Press the 'Line+' button to open a line device\r\n" \
+                "3. Press the 'Call+' button to make a call\r\n"        \
+                "*  Pressing the 'LAp-' button will shutdown TAPI\r\n"  \
+
+                "\r\n"                                                  \
+                "MORE INFO:\r\n"                                        \
+                "*  Double-clicking on one of the items in the\r\n"     \
+                "functions listbox (far left) will invoke that \r\n"    \
+                "function. Check the 'Params' checkbox to enable\r\n"   \
+                "parameter modification.\r\n"                           \
+                "*  Choose 'Options/Default values...' to modify\r\n"   \
+                "default parameter values (address,device ID, etc).\r\n"\
+                "*  Choose 'Options/Record log file' to save all\r\n"   \
+                "output to a file.\r\n"                                 \
+                "*  All parameter values in hexadecimal unless\r\n"     \
+                "specified (strings displayed by contents, not \r\n"    \
+                "pointer value).\r\n"                                   \
+                "*  All 'Xxx+' and 'Xxx-' buttons are essentially \r\n" \
+                "hot-links to items in the functions listbox.\r\n"      \
+                "*  Choose 'Options/User buttons...' or press\r\n"      \
+                "one of the buttons on right side of toolbar to\r\n"    \
+                "create a personal hot-link between a button and a\r\n" \
+                "particular function.\r\n"                              \
+
+                "\r\n"                                                  \
+                "  *  Note: Selecting a API version parameter value\r\n"\
+                "which is newer than that for which TB application\r\n" \
+                "is targeted will result in erroneous dumps of some\r\n"\
+                "structures (e.g. specifying an API version of\r\n"     \
+                "0x10004 and calling lineGetTranslateCaps in TB13).\r\n";
+
+            DialogBoxParam(
+                ghInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG6),
+                (HWND)hwnd,
+                (DLGPROC) AboutDlgProc,
+                (LPARAM) szUsingTB
+                );
+
+            break;
+        }
+// help        case IDM_TAPIHLP:
+// help
+// help            MyWinHelp (hwnd, TRUE, HELP_CONTENTS, 0);
+// help            break;
+
+// help        case IDM_TSPIHLP:
+// help
+// help            MyWinHelp (hwnd, FALSE, HELP_CONTENTS, 0);
+// help            break;
+
+        case IDM_NUKEIDLEMONITORCALLS:
+
+            bNukeIdleMonitorCalls = (bNukeIdleMonitorCalls ? 0 : 1);
+
+            CheckMenuItem(
+                hMenu,
+                IDM_NUKEIDLEMONITORCALLS,
+                MF_BYCOMMAND |
+                    (bNukeIdleMonitorCalls ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_NUKEIDLEOWNEDCALLS:
+
+            bNukeIdleOwnedCalls = (bNukeIdleOwnedCalls ? 0 : 1);
+
+            CheckMenuItem(
+                hMenu,
+                IDM_NUKEIDLEOWNEDCALLS,
+                MF_BYCOMMAND |
+                    (bNukeIdleOwnedCalls ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_NOHANDLECHK:
+
+            gbDisableHandleChecking = (gbDisableHandleChecking ? 0 : 1);
+
+            CheckMenuItem(
+                hMenu,
+                IDM_NOHANDLECHK,
+                MF_BYCOMMAND |
+                    (gbDisableHandleChecking ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_ABOUT:
+        {
+            DialogBoxParam(
+                ghInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG4),
+                (HWND)hwnd,
+                (DLGPROC) AboutDlgProc,
+                0
+                );
+
+            break;
+        }
+        } // switch
+
+        break;
+    }
+#ifdef WIN32
+    case WM_CTLCOLORBTN:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_BTN)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+
+    case WM_MOUSEMOVE:
+    {
+        LONG x = (LONG)((short)LOWORD(lParam));
+        int y = (int)((short)HIWORD(lParam));
+
+
+        if ((y > icyButton) || lCaptureFlags)
+        {
+            SetCursor (LoadCursor (NULL, MAKEINTRESOURCE(IDC_SIZEWE)));
+        }
+
+        if (lCaptureFlags == 1)
+        {
+            int cxList2New;
+
+
+            x = (x > (cxList1 + cxList2 - cxVScroll) ?
+                    (cxList1 + cxList2 - cxVScroll) : x);
+            x = (x < cxVScroll ? cxVScroll : x);
+
+            cxList2New = (int) (cxList2 + x - xCapture);
+
+            SetWindowPos(
+                ghwndList2,
+                GetNextWindow (ghwndList2, GW_HWNDPREV),
+                0,
+                icyButton,
+                cxList2New,
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                cxList2New + icyBorder,
+                icyButton,
+                (int) (cxList1 - (x - xCapture)),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+        }
+        else if (lCaptureFlags == 2)
+        {
+            int cxList1New;
+
+
+            x = (x < (cxList2 + cxVScroll) ?  (cxList2 + cxVScroll) : x);
+            x = (x > (cxWnd - cxVScroll) ?  (cxWnd - cxVScroll) : x);
+
+            cxList1New = (int) (cxList1 + x - xCapture);
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                (int) cxList2 + icyBorder,
+                icyButton,
+                cxList1New,
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndEdit,
+                GetNextWindow (ghwndEdit, GW_HWNDPREV),
+                (int) (cxList1New + cxList2) + 2*icyBorder,
+                icyButton,
+                (int)cxWnd - (cxList1New + (int)cxList2 + 2*icyBorder),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+        }
+
+        break;
+    }
+    case WM_LBUTTONDOWN:
+    {
+        if ((int)((short)HIWORD(lParam)) > icyButton)
+        {
+            xCapture = (LONG)LOWORD(lParam);
+
+            SetCapture (hwnd);
+
+            lCaptureFlags = ((xCapture < cxList1 + cxList2) ? 1 : 2);
+        }
+
+        break;
+    }
+    case WM_LBUTTONUP:
+    {
+        if (lCaptureFlags)
+        {
+            POINT p;
+            LONG  x;
+            RECT  rect = { 0, icyButton, 2000, 2000 };
+
+            GetCursorPos (&p);
+            MapWindowPoints (HWND_DESKTOP, hwnd, &p, 1);
+            x = (LONG) p.x;
+
+            ReleaseCapture();
+
+            if (lCaptureFlags == 1)
+            {
+                x = (x < cxVScroll ? cxVScroll : x);
+                x = (x > (cxList1 + cxList2 - cxVScroll) ?
+                    (cxList1 + cxList2 - cxVScroll) : x);
+
+                cxList2 = cxList2 + (x - xCapture);
+                cxList1 = cxList1 - (x - xCapture);
+
+                rect.right = (int) (cxList1 + cxList2) + icyBorder;
+            }
+            else
+            {
+                x = (x < (cxList2 + cxVScroll) ?
+                    (cxList2 + cxVScroll) : x);
+                x = (x > (cxWnd - cxVScroll) ?
+                    (cxWnd - cxVScroll) : x);
+
+                cxList1 = cxList1 + (x - xCapture);
+
+                rect.left = (int)cxList2 + icyBorder;
+            }
+
+            lCaptureFlags = 0;
+
+            InvalidateRect (hwnd, &rect, TRUE);
+        }
+
+        break;
+    }
+    case WM_SIZE:
+    {
+        if (wParam != SIZE_MINIMIZED)
+        {
+            LONG width = (LONG)LOWORD(lParam);
+
+
+            //
+            // Adjust globals based on new size
+            //
+
+            cxWnd = (cxWnd ? cxWnd : 1); // avoid div by 0
+
+            cxList1 = (cxList1 * width) / cxWnd;
+            cxList2 = (cxList2 * width) / cxWnd;
+            cxWnd = width;
+            cyWnd = ((int)HIWORD(lParam)) - icyButton;
+
+
+            //
+            // Now reposition the child windows
+            //
+
+            SetWindowPos(
+                ghwndList2,
+                GetNextWindow (ghwndList2, GW_HWNDPREV),
+                0,
+                icyButton,
+                (int) cxList2,
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                (int) cxList2 + icyBorder,
+                icyButton,
+                (int) cxList1,
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndEdit,
+                GetNextWindow (ghwndEdit, GW_HWNDPREV),
+                (int) (cxList1 + cxList2) + 2*icyBorder,
+                icyButton,
+                (int)width - ((int)(cxList1 + cxList2) + 2*icyBorder),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+
+            InvalidateRect (hwnd, NULL, TRUE);
+        }
+
+        break;
+    }
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+
+        BeginPaint (hwnd, &ps);
+
+        if (IsIconic (hwnd))
+        {
+            DrawIcon (ps.hdc, 0, 0, hIcon);
+        }
+        else
+        {
+            FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+#ifdef WIN32
+            MoveToEx (ps.hdc, 0, 0, NULL);
+#else
+            MoveTo (ps.hdc, 0, 0);
+#endif
+            LineTo (ps.hdc, 5000, 0);
+
+#ifdef WIN32
+            MoveToEx (ps.hdc, 0, icyButton - 4, NULL);
+#else
+            MoveTo (ps.hdc, 0, icyButton - 4);
+#endif
+            LineTo (ps.hdc, 5000, icyButton - 4);
+        }
+
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    case WM_CLOSE:
+    {
+        BOOL bAutoShutdown = FALSE;
+        RECT rect;
+
+
+        //
+        // Save defaults in ini file
+        //
+
+        {
+            char buf[32];
+            typedef struct _DEF_VALUE2
+            {
+                char far *lpszEntry;
+                DWORD     dwValue;
+
+            } DEF_VALUE2;
+
+            DEF_VALUE2 aDefVals[] =
+            {
+                { "BufSize",            dwBigBufSize },
+                { "AddressID",          dwDefAddressID },
+#if TAPI_2_0
+                { "20LineAPIVersion",   dwDefLineAPIVersion },
+#else
+#if TAPI_1_1
+                { "14LineAPIVersion",   dwDefLineAPIVersion },
+#else
+                { "13LineAPIVersion",   dwDefLineAPIVersion },
+#endif
+#endif
+                { "BearerMode",         dwDefBearerMode },
+                { "CountryCode",        dwDefCountryCode },
+                { "LineDeviceID",       dwDefLineDeviceID },
+                { "LineExtVersion",     dwDefLineExtVersion },
+                { "MediaMode",          dwDefMediaMode },
+                { "LinePrivilege",      dwDefLinePrivilege },
+#if TAPI_2_0
+                { "20PhoneAPIVersion",  dwDefPhoneAPIVersion },
+#else
+#if TAPI_1_1
+                { "14PhoneAPIVersion",  dwDefPhoneAPIVersion },
+#else
+                { "13PhoneAPIVersion",  dwDefPhoneAPIVersion },
+#endif
+#endif
+                { "PhoneDeviceID",      dwDefPhoneDeviceID },
+                { "PhoneExtVersion",    dwDefPhoneExtVersion },
+                { "PhonePrivilege",     dwDefPhonePrivilege },
+#if TAPI_2_0
+                { "20UserButton1",      aUserButtonFuncs[0] },
+                { "20UserButton2",      aUserButtonFuncs[1] },
+                { "20UserButton3",      aUserButtonFuncs[2] },
+                { "20UserButton4",      aUserButtonFuncs[3] },
+                { "20UserButton5",      aUserButtonFuncs[4] },
+                { "20UserButton6",      aUserButtonFuncs[5] },
+#else
+#if TAPI_1_1
+                { "14UserButton1",      aUserButtonFuncs[0] },
+                { "14UserButton2",      aUserButtonFuncs[1] },
+                { "14UserButton3",      aUserButtonFuncs[2] },
+                { "14UserButton4",      aUserButtonFuncs[3] },
+                { "14UserButton5",      aUserButtonFuncs[4] },
+                { "14UserButton6",      aUserButtonFuncs[5] },
+#else
+                { "13UserButton1",      aUserButtonFuncs[0] },
+                { "13UserButton2",      aUserButtonFuncs[1] },
+                { "13UserButton3",      aUserButtonFuncs[2] },
+                { "13UserButton4",      aUserButtonFuncs[3] },
+                { "13UserButton5",      aUserButtonFuncs[4] },
+                { "13UserButton6",      aUserButtonFuncs[5] },
+#endif
+#endif
+                { "TimeStamp",          bTimeStamp },
+                { "NukeIdleMonitorCalls",  bNukeIdleMonitorCalls },
+                { "NukeIdleOwnedCalls",    bNukeIdleOwnedCalls },
+                { "DisableHandleChecking", gbDisableHandleChecking },
+                { "DumpStructsFlags",   dwDumpStructsFlags },
+                { NULL, 0 },
+                { "Version",            (DWORD) szCurrVer },
+                { "UserUserInfo",       (DWORD) szDefUserUserInfo },
+                { "DestAddress",        (DWORD) szDefDestAddress },
+                { "LineDeviceClass",    (DWORD) szDefLineDeviceClass },
+                { "PhoneDeviceClass",   (DWORD) szDefPhoneDeviceClass },
+                { "AppName",            (DWORD) szDefAppName },
+#if TAPI_2_0
+                { "20UserButton1Text",  (DWORD) &aUserButtonsText[0] },
+                { "20UserButton2Text",  (DWORD) &aUserButtonsText[1] },
+                { "20UserButton3Text",  (DWORD) &aUserButtonsText[2] },
+                { "20UserButton4Text",  (DWORD) &aUserButtonsText[3] },
+                { "20UserButton5Text",  (DWORD) &aUserButtonsText[4] },
+                { "20UserButton6Text",  (DWORD) &aUserButtonsText[5] },
+#else
+#if TAPI_1_1
+                { "14UserButton1Text",  (DWORD) &aUserButtonsText[0] },
+                { "14UserButton2Text",  (DWORD) &aUserButtonsText[1] },
+                { "14UserButton3Text",  (DWORD) &aUserButtonsText[2] },
+                { "14UserButton4Text",  (DWORD) &aUserButtonsText[3] },
+                { "14UserButton5Text",  (DWORD) &aUserButtonsText[4] },
+                { "14UserButton6Text",  (DWORD) &aUserButtonsText[5] },
+#else
+                { "13UserButton1Text",  (DWORD) &aUserButtonsText[0] },
+                { "13UserButton2Text",  (DWORD) &aUserButtonsText[1] },
+                { "13UserButton3Text",  (DWORD) &aUserButtonsText[2] },
+                { "13UserButton4Text",  (DWORD) &aUserButtonsText[3] },
+                { "13UserButton5Text",  (DWORD) &aUserButtonsText[4] },
+                { "13UserButton6Text",  (DWORD) &aUserButtonsText[5] },
+#endif
+#endif
+// help                { "TapiHlpPath",        (DWORD) szTapiHlp },
+// help                { "TspiHlpPath",        (DWORD) szTspiHlp },
+                { NULL, 0 }
+            };
+
+            int i;
+
+            for (i = 0; aDefVals[i].lpszEntry; i++)
+            {
+                sprintf (buf, "%lx", aDefVals[i].dwValue);
+
+                WriteProfileString(
+                    MYSECTION,
+                    aDefVals[i].lpszEntry,
+                    buf
+                    );
+            }
+
+            i++;
+
+            for (; aDefVals[i].lpszEntry; i++)
+            {
+                WriteProfileString(
+                    MYSECTION,
+                    aDefVals[i].lpszEntry,
+                    (LPCSTR) aDefVals[i].dwValue
+                    );
+            }
+
+
+            //
+            // Save the window dimensions (if iconic then don't bother)
+            //
+
+            if (!IsIconic (hwnd))
+            {
+                if (IsZoomed (hwnd))
+                {
+                    strcpy (buf, "max");
+                }
+                else
+                {
+                    GetWindowRect (hwnd, &rect);
+
+                    sprintf(
+                        buf,
+                        "%d,%d,%d,%d",
+                        rect.left,
+                        rect.top,
+                        rect.right,
+                        rect.bottom
+                        );
+                }
+
+                WriteProfileString(
+                    MYSECTION,
+                    "Position",
+                    (LPCSTR) buf
+                    );
+
+                sprintf (buf, "%ld,%ld,%ld", cxList2, cxList1, cxWnd);
+
+                WriteProfileString(
+                    MYSECTION,
+                    "ControlRatios",
+                    (LPCSTR) buf
+                    );
+            }
+        }
+
+
+
+        //
+        // Give user chance to auto-shutdown any active line/phone apps
+        //
+
+        if (aWidgets)
+        {
+            if (MessageBox(
+                    hwnd,
+                    "Shutdown all hLineApps/hPhoneApps? (recommended)",
+                    "Tapi Browser closing",
+                    MB_YESNO
+                    ) == IDNO)
+            {
+                goto WM_CLOSE_freeBigBuf;
+            }
+
+            bShowParams = FALSE;
+
+            while (aWidgets)
+            {
+                PMYWIDGET pWidgetToClose = aWidgets;
+
+
+                if (aWidgets->dwType == WT_LINEAPP)
+                {
+                    pLineAppSel = (PMYLINEAPP) aWidgets;
+                    FuncDriver (lShutdown);
+                }
+                else if (aWidgets->dwType == WT_PHONEAPP)
+                {
+                    pPhoneAppSel = (PMYPHONEAPP) aWidgets;
+                    FuncDriver (pShutdown);
+                }
+
+                if (pWidgetToClose == aWidgets)
+                {
+                    //
+                    // The shutdown wasn't successful (or our list is
+                    // messed up an it'd not a LINEAPP or PHONEAPP widget),
+                    // so manually nuke this widget so we don't hang in
+                    // this loop forever
+                    //
+
+                    RemoveWidgetFromList (pWidgetToClose);
+                }
+            }
+        }
+
+WM_CLOSE_freeBigBuf:
+
+        if (hLogFile)
+        {
+            fclose (hLogFile);
+        }
+        DestroyIcon (hIcon);
+        free (pBigBuf);
+        free (lpCallParams);
+//        if (aSelWidgets)
+//        {
+//            free (aSelWidgets);
+//        }
+//        if (aSelWidgetsPrev)
+//        {
+//            free (aSelWidgetsPrev);
+//        }
+        DeleteObject (hFont);
+        DeleteObject (hFont2);
+        PostQuitMessage (0);
+        break;
+
+    }
+    } //switch
+
+    return FALSE;
+}
+
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+
+        if (lParam)
+        {
+            SetDlgItemText (hwnd, IDC_EDIT1, (LPCSTR) lParam);
+        }
+
+        break;
+
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        break;
+
+#ifdef WIN32
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_STATIC)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+void
+FAR
+ShowStr(
+    LPCSTR format,
+    ...
+    )
+{
+    char buf[256];
+    va_list ap;
+
+
+    va_start(ap, format);
+    wvsprintf (buf, format, ap);
+
+    if (hLogFile)
+    {
+        fprintf (hLogFile, "%s\n", buf);
+    }
+
+    strcat (buf, "\r\n");
+
+
+    //
+    // Insert text at end
+    //
+
+#ifdef WIN32
+    SendMessage (ghwndEdit, EM_SETSEL, (WPARAM)0xfffffffd, (LPARAM)0xfffffffe);
+#else
+    SendMessage(
+        ghwndEdit,
+        EM_SETSEL,
+        (WPARAM)0,
+        (LPARAM) MAKELONG(0xfffd,0xfffe)
+        );
+#endif
+
+    SendMessage (ghwndEdit, EM_REPLACESEL, 0, (LPARAM) buf);
+
+
+#ifdef WIN32
+
+    //
+    // Scroll to end of text
+    //
+
+    SendMessage (ghwndEdit, EM_SCROLLCARET, 0, 0);
+#endif
+
+    va_end(ap);
+}
+
+
+VOID
+UpdateWidgetListCall(
+    PMYCALL pCall
+    )
+{
+    LONG i, lSel;
+    char buf[64];
+
+
+    for (i = 0; aCallStates[i].dwVal != 0xffffffff; i++)
+    {
+        if (pCall->dwCallState == aCallStates[i].dwVal)
+        {
+            break;
+        }
+    }
+
+    sprintf(
+        buf,
+        "    Call=x%lx %s %s",
+        pCall->hCall,
+        aCallStates[i].lpszVal,
+        (pCall->bMonitor ? "Monitor" : "Owner")
+        );
+
+    i = (LONG) GetWidgetIndex ((PMYWIDGET) pCall);
+
+    lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+    SendMessage (ghwndList1, LB_DELETESTRING, (WPARAM) i, 0);
+    SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM) i, (LPARAM) buf);
+    SendMessage (ghwndList1, LB_SETITEMDATA, (WPARAM) i, (LPARAM) pCall);
+
+    if (lSel == i)
+    {
+        SendMessage (ghwndList1, LB_SETCURSEL, (WPARAM) i, 0);
+    }
+}
+
+
+VOID
+CALLBACK
+tapiCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    )
+{
+    typedef struct _MSG_PARAMS
+    {
+        char    *lpszMsg;
+
+        LPVOID  aParamFlagTables[3];
+
+    } MSG_PARAMS, *PMSG_PARAMS;
+
+    static MSG_PARAMS msgParams[] =
+    {
+        { "LINE_ADDRESSSTATE",       { NULL, aAddressStates, NULL } },
+        { "LINE_CALLINFO",           { aCallInfoStates, NULL, NULL } },
+        { "LINE_CALLSTATE",          { aCallStates, NULL, aCallPrivileges } },
+        { "LINE_CLOSE",              { NULL, NULL, NULL } },
+        { "LINE_DEVSPECIFIC",        { NULL, NULL, NULL } },
+        { "LINE_DEVSPECIFICFEATURE", { NULL, NULL, NULL } },
+        { "LINE_GATHERDIGITS",       { aGatherTerms, NULL, NULL } },
+        { "LINE_GENERATE",           { aGenerateTerms, NULL, NULL } },
+        { "LINE_LINEDEVSTATE",       { aLineStates, NULL, NULL } },
+        { "LINE_MONITORDIGITS",      { NULL, aDigitModes, NULL } },
+        { "LINE_MONITORMEDIA",       { aMediaModes, NULL, NULL } },
+        { "LINE_MONITORTONE",        { NULL, NULL, NULL } },
+        { "LINE_REPLY",              { NULL, NULL, NULL } },
+        { "LINE_REQUEST",            { aRequestModes, NULL, NULL } }
+         ,
+        { "PHONE_BUTTON",            { NULL, aButtonModes, aButtonStates } },
+        { "PHONE_CLOSE",             { NULL, NULL, NULL } },
+        { "PHONE_DEVSPECIFIC",       { NULL, NULL, NULL } },
+        { "PHONE_REPLY",             { NULL, NULL, NULL } },
+        { "PHONE_STATE",             { aPhoneStates, NULL, NULL } }
+
+#if TAPI_1_1
+         ,
+        { "LINE_CREATE",             { NULL, NULL, NULL } },
+        { "PHONE_CREATE",            { NULL, NULL, NULL } }
+
+#if TAPI_2_0
+         ,
+        { "LINE_AGENTSPECIFIC",      { NULL, NULL, NULL } },
+        { "LINE_AGENTSTATUS",        { NULL, NULL, NULL } },
+        { "LINE_APPNEWCALL",         { NULL, NULL, aCallPrivileges } },
+        { "LINE_PROXYREQUEST",       { NULL, NULL, NULL } },
+        { "LINE_REMOVE",             { NULL, NULL, NULL } },
+        { "PHONE_REMOVE",            { NULL, NULL, NULL } }
+
+#endif
+
+#endif
+
+    };
+    int     i, j;
+    LONG    lResult;
+
+
+    UpdateResults (TRUE);
+
+#if TAPI_1_1
+#if TAPI_2_0
+    if (dwMsg <= PHONE_REMOVE)
+#else
+    if (dwMsg <= PHONE_CREATE)
+#endif
+#else
+    if (dwMsg <= PHONE_STATE)
+#endif
+    {
+        DWORD aParams[3] = { dwParam1, dwParam2, dwParam3 };
+
+
+        {
+            char *pszTimeStamp = GetTimeStamp();
+
+            ShowStr(
+                "%sreceived %s",
+                pszTimeStamp,
+                msgParams[dwMsg].lpszMsg
+                );
+        }
+
+        ShowStr ("%sdevice=x%lx", szTab, hDevice);
+        ShowStr ("%scbInst=x%lx", szTab, dwCallbackInstance);
+
+        if (dwMsg == LINE_CALLSTATE)
+        {
+            msgParams[2].aParamFlagTables[1] = NULL;
+
+            switch (dwParam1)
+            {
+            case LINECALLSTATE_BUSY:
+
+                msgParams[2].aParamFlagTables[1] = (LPVOID) aBusyModes;
+                break;
+
+            case LINECALLSTATE_DIALTONE:
+
+                msgParams[2].aParamFlagTables[1] = (LPVOID) aDialToneModes;
+                break;
+
+            case LINECALLSTATE_SPECIALINFO:
+
+                msgParams[2].aParamFlagTables[1] = (LPVOID) aSpecialInfo;
+                break;
+
+            case LINECALLSTATE_DISCONNECTED:
+
+                msgParams[2].aParamFlagTables[1] = (LPVOID) aDisconnectModes;
+                break;
+
+#if TAPI_1_1
+
+            case LINECALLSTATE_CONNECTED:
+
+                msgParams[2].aParamFlagTables[1] = (LPVOID) aConnectedModes;
+                break;
+
+            case LINECALLSTATE_OFFERING:
+
+                msgParams[2].aParamFlagTables[1] = (LPVOID) aOfferingModes;
+                break;
+
+#endif // TAPI_1_1
+
+            } // switch
+        }
+
+        else if (dwMsg == PHONE_STATE)
+        {
+            msgParams[18].aParamFlagTables[1] = NULL;
+
+            switch (dwParam1)
+            {
+            case PHONESTATE_HANDSETHOOKSWITCH:
+            case PHONESTATE_SPEAKERHOOKSWITCH:
+            case PHONESTATE_HEADSETHOOKSWITCH:
+
+                msgParams[18].aParamFlagTables[1] = aHookSwitchModes;
+                break;
+
+            } // switch
+        }
+
+        for (i = 0; i < 3; i++)
+        {
+            char buf[80];
+
+
+            sprintf (buf, "%sparam%d=x%lx, ", szTab, i+1, aParams[i]);
+
+            if (msgParams[dwMsg].aParamFlagTables[i])
+            {
+                PLOOKUP pLookup = (PLOOKUP)
+                    msgParams[dwMsg].aParamFlagTables[i];
+
+
+                for (j = 0; aParams[i], pLookup[j].dwVal != 0xffffffff; j++)
+                {
+                    if (aParams[i] & pLookup[j].dwVal)
+                    {
+                        if (buf[0] == 0)
+                        {
+                            sprintf (buf, "%s%s", szTab, szTab);
+                        }
+
+                        strcat (buf, pLookup[j].lpszVal);
+                        strcat (buf, " ");
+                        aParams[i] = aParams[i] & ~pLookup[j].dwVal;
+
+                        if (strlen (buf) > 50)
+                        {
+                            //
+                            // We don't want strings getting so long that
+                            // they're going offscreen, so break them up.
+                            //
+
+                            ShowStr (buf);
+                            buf[0] = 0;
+                        }
+                    }
+                }
+
+                if (aParams[i])
+                {
+                    strcat (buf, "<unknown flag(s)>");
+                }
+
+            }
+
+            if (buf[0])
+            {
+                ShowStr (buf);
+            }
+        }
+    }
+    else
+    {
+        ShowStr ("ERROR! callback received unknown msg=x%lx", dwMsg);
+        ShowStr ("%shDev=x%lx,  cbInst=x%lx, p1=x%lx, p2=x%lx, p3=x%lx",
+            szTab,
+            hDevice,
+            dwCallbackInstance,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        return;
+    }
+
+    UpdateResults (FALSE);
+
+    switch (dwMsg)
+    {
+    case LINE_CALLSTATE:
+    {
+        PMYLINE pLine;
+        PMYCALL pCall = GetCall ((HCALL) hDevice);
+
+
+        //
+        // If the call state is idle & we're in "nuke idle xxx calls"
+        // mode then determine the privilege of this callto see if we
+        // need to nuke it
+        //
+
+        if ((dwParam1 == LINECALLSTATE_IDLE) &&
+            (bNukeIdleMonitorCalls || bNukeIdleOwnedCalls))
+        {
+            BOOL            bNukeCall = FALSE;
+            LINECALLSTATUS  callStatus;
+
+
+            callStatus.dwTotalSize = (DWORD) sizeof(LINECALLSTATUS);
+
+            lResult = lineGetCallStatus ((HCALL) hDevice, &callStatus);
+
+            ShowLineFuncResult ("lineGetCallStatus", lResult);
+
+            if (lResult == 0)
+            {
+                if ((callStatus.dwCallPrivilege & LINECALLPRIVILEGE_OWNER))
+                {
+                    if (bNukeIdleOwnedCalls)
+                    {
+                        bNukeCall = TRUE;
+                    }
+                }
+                else
+                {
+                    if (bNukeIdleMonitorCalls)
+                    {
+                        bNukeCall = TRUE;
+                    }
+                }
+            }
+
+            if (bNukeCall)
+            {
+                if ((lResult = lineDeallocateCall ((HCALL) hDevice)) == 0)
+                {
+                    ShowStr ("Call x%lx deallocated on IDLE", hDevice);
+
+                    if (pCall)
+                    {
+                        FreeCall (pCall);
+                    }
+
+                    break;
+                }
+                else
+                {
+                    ShowLineFuncResult ("lineDeallocateCall", lResult);
+                }
+            }
+        }
+
+
+        //
+        // Find call in the widget list, save the call state, &
+        // update it's text in the widget list.
+        //
+
+        if (pCall)
+        {
+            //
+            // If dwNumPendingDrops is non-zero, then user previously
+            // pressed "Call-" button and we're waiting for a call to
+            // go IDLE so we can deallocate it. Check to see if this
+            // is the call we want to nuke. (Note: we used to nuke the
+            // call when we got a successful REPLY msg back from the
+            // drop request; the problem with that is some SPs complete
+            // the drop request *before* they set the call state to
+            // IDLE, and our call to lineDeallocateCall would fail
+            // since TAPI won't let a call owner deallocate a call if
+            // it's not IDLE.)
+            //
+
+            if (dwNumPendingDrops &&
+                (dwParam1 == LINECALLSTATE_IDLE) &&
+                pCall->lDropReqID)
+            {
+                dwNumPendingDrops--;
+
+                ShowStr(
+                    "Deallocating hCall x%lx " \
+                        "(REPLY for requestID x%lx might be filtered)",
+                    pCall->hCall,
+                    pCall->lDropReqID
+                    );
+
+                lResult = lineDeallocateCall (pCall->hCall);
+
+                ShowLineFuncResult ("lineDeallocateCall", lResult);
+
+                if (lResult == 0)
+                {
+                    FreeCall (pCall);
+                    break;
+                }
+                else
+                {
+                    pCall->lDropReqID = 0;
+                }
+            }
+
+            pCall->dwCallState = dwParam1;
+            UpdateWidgetListCall (pCall);
+        }
+
+
+        //
+        // If here this is the first we've heard of this this call,
+        // so find out which line it's on & create a call widget
+        // for it
+        //
+
+        else if (dwParam3 != 0)
+        {
+            LINECALLINFO callInfo;
+
+
+            memset (&callInfo, 0, sizeof(LINECALLINFO));
+            callInfo.dwTotalSize = sizeof(LINECALLINFO);
+            lResult = lineGetCallInfo ((HCALL)hDevice, &callInfo);
+
+            ShowStr(
+                "%slineGetCallInfo returned x%lx, hLine=x%lx",
+                szTab,
+                lResult,
+                callInfo.hLine
+                );
+
+            if (lResult == 0)
+            {
+                if ((pLine = GetLine (callInfo.hLine)))
+                {
+                    if ((pCall = AllocCall (pLine)))
+                    {
+                        pCall->hCall       = (HCALL) hDevice;
+                        pCall->dwCallState = dwParam1;
+                        pCall->bMonitor    = (dwParam3 ==
+                            LINECALLPRIVILEGE_MONITOR ? TRUE : FALSE);
+                        UpdateWidgetListCall (pCall);
+                    }
+                }
+            }
+        }
+
+        break;
+    }
+    case LINE_GATHERDIGITS:
+    {
+        PMYCALL pCall;
+
+
+        if ((pCall = GetCall ((HCALL) hDevice)) && pCall->lpsGatheredDigits)
+        {
+            ShowStr ("%sGathered digits:", szTab);
+            ShowBytes (pCall->dwNumGatheredDigits, pCall->lpsGatheredDigits, 2);
+            free (pCall->lpsGatheredDigits);
+            pCall->lpsGatheredDigits = NULL;
+        }
+
+        break;
+    }
+    case LINE_REPLY:
+
+        if (dwNumPendingMakeCalls)
+        {
+            //
+            // Check to see if this is a reply for a lineMakeCall request
+            //
+
+            PMYWIDGET pWidget = aWidgets;
+
+
+            while (pWidget && (pWidget->dwType != WT_PHONEAPP))
+            {
+                if (pWidget->dwType == WT_CALL)
+                {
+                    PMYCALL pCall = (PMYCALL) pWidget;
+
+                    if ((DWORD)pCall->lMakeCallReqID == dwParam1)
+                    {
+                        //
+                        // The reply id matches the make call req id
+                        //
+
+                        dwNumPendingMakeCalls--;
+
+                        if (dwParam2 || !pCall->hCall)
+                        {
+                            //
+                            // Request error or no call created, so free
+                            // up the struct & update the hCalls listbox
+                            //
+
+                            if (dwParam2 == 0)
+                            {
+                                ShowStr(
+                                    "    NOTE: *lphCall==NULL, "\
+                                        "freeing call data structure"
+                                    );
+                            }
+
+                            pWidget = pWidget->pNext;
+
+                            FreeCall (pCall);
+
+                            continue;
+                        }
+                        else
+                        {
+                            //
+                            // Reset this field so we don't run into
+                            // problems later with another of the same
+                            // request id
+                            //
+
+                            pCall->lMakeCallReqID = 0;
+
+                            UpdateWidgetListCall (pCall);
+                        }
+                    }
+                }
+
+                pWidget = pWidget->pNext;
+            }
+        }
+
+        if (dwParam2)
+        {
+            //
+            // Dump the error in a readable format
+            //
+
+            MessageBeep ((UINT) -1);
+
+            if (dwParam2 > LAST_LINEERR)
+            {
+                ShowStr ("inval err code (x%lx)", dwParam2);
+            }
+            else
+            {
+                ShowStr(
+                    "    %s%s",
+                    "LINEERR_", // ...to shrink the aszLineErrs array
+                    aszLineErrs[LOWORD(dwParam2)]
+                    );
+            }
+        }
+
+        break;
+
+    case PHONE_REPLY:
+
+        if (dwParam2)
+        {
+            //
+            // Dump the error in a readable format
+            //
+
+            MessageBeep ((UINT) -1);
+
+            if (dwParam2 > PHONEERR_REINIT)
+            {
+                ShowStr ("inval err code (x%lx)", dwParam2);
+            }
+            else
+            {
+                ShowStr(
+                    "    %s%s",
+                    "PHONEERR_", // ...to shrink the aszPhoneErrs array
+                    aszPhoneErrs[LOWORD(dwParam2)]
+                    );
+            }
+        }
+
+        break;
+
+    case LINE_CLOSE:
+
+        FreeLine (GetLine ((HLINE) hDevice));
+        break;
+
+    case PHONE_CLOSE:
+
+        FreePhone (GetPhone ((HPHONE) hDevice));
+        break;
+
+#if TAPI_2_0
+
+    case LINE_APPNEWCALL:
+    {
+        PMYLINE pLine;
+        PMYCALL pCall;
+
+
+        if ((pLine = GetLine ((HLINE) hDevice)))
+        {
+            if ((pCall = AllocCall (pLine)))
+            {
+                pCall->hCall       = (HCALL) dwParam2;
+                pCall->dwCallState = LINECALLSTATE_UNKNOWN;
+                pCall->bMonitor    = (dwParam3 ==
+                    LINECALLPRIVILEGE_MONITOR ? TRUE : FALSE);
+                UpdateWidgetListCall (pCall);
+            }
+        }
+
+        break;
+    }
+    case LINE_PROXYREQUEST:
+    {
+        LPLINEPROXYREQUEST  pRequest = (LPLINEPROXYREQUEST) dwParam1;
+        STRUCT_FIELD fields[] =
+        {
+            { szdwSize,                     FT_DWORD,   pRequest->dwSize, NULL },
+            { "dwClientMachineNameSize",    FT_SIZE,    pRequest->dwClientMachineNameSize, NULL },
+            { "dwClientMachineNameOffset",  FT_OFFSET,  pRequest->dwClientMachineNameOffset, NULL },
+            { "dwClientUserNameSize",       FT_SIZE,    pRequest->dwClientUserNameSize, NULL },
+            { "dwClientUserNameOffset",     FT_OFFSET,  pRequest->dwClientUserNameOffset, NULL },
+            { "dwClientAppAPIVersion",      FT_DWORD,   pRequest->dwClientAppAPIVersion, NULL },
+            { "dwRequestType",              FT_ORD,     pRequest->dwRequestType, aProxyRequests }
+        };
+        STRUCT_FIELD_HEADER fieldHeader =
+        {
+            pRequest,
+            "LINEPROXYREQUEST",
+            7,
+            fields
+        };
+
+
+        ShowStructByField (&fieldHeader, TRUE);
+
+        switch (pRequest->dwRequestType)
+        {
+        case LINEPROXYREQUEST_SETAGENTGROUP:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,    FT_DWORD,   pRequest->SetAgentGroup.dwAddressID, NULL }
+
+// BUGBUG LINE_PROXYREQUEST: dump agent grp list
+
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "SetAgentGroup",
+                1,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_SETAGENTSTATE:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,        FT_DWORD,   pRequest->SetAgentState.dwAddressID, NULL },
+                { "dwAgentState",       FT_ORD,     pRequest->SetAgentState.dwAgentState, aAgentStates },
+                { "dwNextAgentState",   FT_ORD,     pRequest->SetAgentState.dwNextAgentState, aAgentStates }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "SetAgentState",
+                3,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_SETAGENTACTIVITY:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,    FT_DWORD,   pRequest->SetAgentActivity.dwAddressID, NULL },
+                { "dwActivityID",   FT_DWORD,   pRequest->SetAgentActivity.dwActivityID, NULL }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "SetAgentActivity",
+                2,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_GETAGENTCAPS:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,    FT_DWORD,   pRequest->GetAgentCaps.dwAddressID, NULL }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "GetAgentCaps",
+                1,
+                fields
+            };
+
+
+// BUGBUG LINE_PROXYREQUEST: fill in agent caps?
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_GETAGENTSTATUS:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,    FT_DWORD,   pRequest->GetAgentStatus.dwAddressID, NULL }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "GetAgentStatus",
+                1,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_AGENTSPECIFIC:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,                FT_DWORD,   pRequest->AgentSpecific.dwAddressID, NULL },
+                { "dwAgentExtensionIDIndex",    FT_DWORD,   pRequest->AgentSpecific.dwAgentExtensionIDIndex, NULL },
+                { szdwSize,                     FT_SIZE,    pRequest->AgentSpecific.dwSize, NULL },
+                { "Params",                     FT_OFFSET,  (DWORD) (pRequest->AgentSpecific.Params - (LPBYTE) pRequest), NULL }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "AgentSpecific",
+                4,
+                fields
+            };
+
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_GETAGENTACTIVITYLIST:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,    FT_DWORD,   pRequest->GetAgentActivityList.dwAddressID, NULL }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "GetAgentActivityList",
+                1,
+                fields
+            };
+
+
+// BUGBUG LINE_PROXYREQUEST: fill in agent activity list?
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        case LINEPROXYREQUEST_GETAGENTGROUPLIST:
+        {
+            STRUCT_FIELD fields[] =
+            {
+                { szdwAddressID,    FT_DWORD,   pRequest->GetAgentGroupList.dwAddressID, NULL }
+            };
+            STRUCT_FIELD_HEADER fieldHeader =
+            {
+                pRequest,
+                "GetAgentGroupList",
+                1,
+                fields
+            };
+
+
+// BUGBUG LINE_PROXYREQUEST: fill in agent grp list?
+
+            ShowStructByField (&fieldHeader, TRUE);
+
+            break;
+        }
+        } // switch (pRequest->dwRequestType)
+
+        break;
+    }
+
+#endif
+
+    }
+}
+
+
+BOOL
+CALLBACK
+ParamsDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    DWORD  i;
+
+    typedef struct _DLG_INST_DATA
+    {
+        PFUNC_PARAM_HEADER pParamsHeader;
+
+        LONG lLastSel;
+
+        char szComboText[MAX_STRING_PARAM_SIZE];
+
+    } DLG_INST_DATA, *PDLG_INST_DATA;
+
+    PDLG_INST_DATA pDlgInstData = (PDLG_INST_DATA)
+        GetWindowLong (hwnd, DWL_USER);
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        //
+        // Alloc a dlg instance data struct, init it, & save a ptr to it
+        //
+
+        pDlgInstData = (PDLG_INST_DATA) malloc (sizeof(DLG_INST_DATA));
+
+        // BUGBUG if (!pDlgInstData)
+
+        pDlgInstData->pParamsHeader = (PFUNC_PARAM_HEADER) lParam;
+        pDlgInstData->lLastSel = -1;
+
+        SetWindowLong (hwnd, DWL_USER, (LONG) pDlgInstData);
+
+
+        //
+        // Stick all the param names in the listbox, & for each PT_DWORD
+        // param save it's default value
+        //
+
+        for (i = 0; i < pDlgInstData->pParamsHeader->dwNumParams; i++)
+        {
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST1,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) pDlgInstData->pParamsHeader->aParams[i].szName
+                );
+
+            if (pDlgInstData->pParamsHeader->aParams[i].dwType == PT_DWORD)
+            {
+                pDlgInstData->pParamsHeader->aParams[i].u.dwDefValue =
+                    pDlgInstData->pParamsHeader->aParams[i].dwValue;
+            }
+        }
+
+
+        //
+        // Set the dlg title as appropriate
+        //
+
+// help        if (pDlgInstData->pParamsHeader->FuncIndex == DefValues)
+// help        {
+// help            EnableWindow (GetDlgItem (hwnd, IDC_TB_HELP), FALSE);
+// help        }
+
+        SetWindowText(
+            hwnd,
+            aFuncNames[pDlgInstData->pParamsHeader->FuncIndex]
+            );
+
+
+        //
+        // Limit the max text length for the combobox's edit field
+        // (NOTE: A combobox ctrl actually has two child windows: a
+        // edit ctrl & a listbox.  We need to get the hwnd of the
+        // child edit ctrl & send it the LIMITTEXT msg.)
+        //
+
+        {
+            HWND hwndChild =
+                GetWindow (GetDlgItem (hwnd, IDC_COMBO1), GW_CHILD);
+
+
+            while (hwndChild)
+            {
+                char buf[8];
+
+
+                GetClassName (hwndChild, buf, 7);
+
+                if (_stricmp (buf, "edit") == 0)
+                {
+                    break;
+                }
+
+                hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+            }
+
+            SendMessage(
+                hwndChild,
+                EM_LIMITTEXT,
+                (WPARAM) (gbWideStringParams ?
+                    (MAX_STRING_PARAM_SIZE/2 - 1) : MAX_STRING_PARAM_SIZE - 1),
+                0
+                );
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        LONG      lLastSel      = pDlgInstData->lLastSel;
+        char far *lpszComboText = pDlgInstData->szComboText;
+        PFUNC_PARAM_HEADER pParamsHeader = pDlgInstData->pParamsHeader;
+
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            if (lLastSel != -1)
+            {
+                //
+                // Save val of currently selected param
+                //
+
+                char buf[MAX_STRING_PARAM_SIZE];
+
+
+                i = GetDlgItemText (hwnd, IDC_COMBO1, buf, MAX_STRING_PARAM_SIZE-1);
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    LONG lComboSel;
+
+
+                    lComboSel = SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_GETCURSEL,
+                        0,
+                        0
+                        );
+
+                    if (lComboSel == 0) // "NULL pointer"
+                    {
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD) 0;
+                    }
+                    else if (lComboSel == 2) // "Invalid string pointer"
+                    {
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                            0xffffffff;
+                    }
+                    else // "Valid string pointer"
+                    {
+                        strncpy(
+                            pParamsHeader->aParams[lLastSel].u.buf,
+                            buf,
+                            MAX_STRING_PARAM_SIZE - 1
+                            );
+
+                        pParamsHeader->aParams[lLastSel].u.buf[MAX_STRING_PARAM_SIZE-1] = 0;
+
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                            pParamsHeader->aParams[lLastSel].u.buf;
+                    }
+
+                    break;
+                }
+                case PT_POINTER:
+                case PT_DWORD:
+                case PT_FLAGS:
+                case PT_CALLPARAMS: // ??? BUGBUG
+                case PT_FORWARDLIST: // ??? BUGBUG
+                case PT_ORDINAL:
+                {
+                    if (!sscanf(
+                            buf,
+                            "%08lx",
+                            &pParamsHeader->aParams[lLastSel].dwValue
+                            ))
+                    {
+                        //
+                        // Default to 0
+                        //
+
+                        pParamsHeader->aParams[lLastSel].dwValue = 0;
+                    }
+
+                    break;
+                }
+                } // switch
+            }
+
+            free (pDlgInstData);
+            EndDialog (hwnd, TRUE);
+            break;
+
+        case IDCANCEL:
+
+            free (pDlgInstData);
+            EndDialog (hwnd, FALSE);
+            break;
+
+// help        case IDC_TB_HELP:
+// help
+// help            MyWinHelp(
+// help                hwnd,
+// help                TRUE,
+// help                HELP_PARTIALKEY,
+// help                (DWORD) aFuncNames[pParamsHeader->FuncIndex]
+// help                );
+// help
+// help            break;
+
+        case IDC_LIST1:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+#else
+            if (HIWORD(lParam) == LBN_SELCHANGE)
+#endif
+            {
+                char buf[MAX_STRING_PARAM_SIZE] = "";
+                LPCSTR lpstr = buf;
+                LONG lSel =
+                    SendDlgItemMessage (hwnd, IDC_LIST1, LB_GETCURSEL, 0, 0);
+
+
+                if (lLastSel != -1)
+                {
+                    //
+                    // Save the old param value
+                    //
+
+                    i = GetDlgItemText(
+                        hwnd,
+                        IDC_COMBO1,
+                        buf,
+                        MAX_STRING_PARAM_SIZE - 1
+                        );
+
+                    switch (pParamsHeader->aParams[lLastSel].dwType)
+                    {
+                    case PT_STRING:
+                    {
+                        LONG lComboSel;
+
+
+                        lComboSel = SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_GETCURSEL,
+                            0,
+                            0
+                            );
+
+                        if (lComboSel == 0) // "NULL pointer"
+                        {
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)0;
+                        }
+                        else if (lComboSel == 2) // "Invalid string pointer"
+                        {
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                                0xffffffff;
+                        }
+                        else // "Valid string pointer" or no sel
+                        {
+                            strncpy(
+                                pParamsHeader->aParams[lLastSel].u.buf,
+                                buf,
+                                MAX_STRING_PARAM_SIZE - 1
+                                );
+
+                            pParamsHeader->aParams[lLastSel].u.buf[MAX_STRING_PARAM_SIZE - 1] = 0;
+
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                                pParamsHeader->aParams[lLastSel].u.buf;
+                        }
+
+                        break;
+                    }
+                    case PT_POINTER:
+                    case PT_DWORD:
+                    case PT_FLAGS:
+                    case PT_CALLPARAMS: // ??? BUGBUG
+                    case PT_FORWARDLIST: // ??? BUGBUG
+                    case PT_ORDINAL:
+                    {
+                        if (!sscanf(
+                                buf,
+                                "%08lx",
+                                &pParamsHeader->aParams[lLastSel].dwValue
+                                ))
+                        {
+                            //
+                            // Default to 0
+                            //
+
+                            pParamsHeader->aParams[lLastSel].dwValue = 0;
+                        }
+
+                        break;
+                    }
+                    } // switch
+                }
+
+
+                SendDlgItemMessage (hwnd, IDC_LIST2, LB_RESETCONTENT, 0, 0);
+                SendDlgItemMessage (hwnd, IDC_COMBO1, CB_RESETCONTENT, 0, 0);
+
+                switch (pParamsHeader->aParams[lSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    char * aszOptions[] =
+                    {
+                        "NULL pointer",
+                        "Valid string pointer",
+                        "Invalid string pointer"
+                    };
+
+
+                    for (i = 0; i < 3; i++)
+                    {
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) aszOptions[i]
+                            );
+                    }
+
+                    if (pParamsHeader->aParams[lSel].dwValue == 0)
+                    {
+                        i = 0;
+                        buf[0] = 0;
+                    }
+                    else if (pParamsHeader->aParams[lSel].dwValue != 0xffffffff)
+                    {
+                        i = 1;
+                        lpstr = (LPCSTR) pParamsHeader->aParams[lSel].dwValue;
+                    }
+                    else
+                    {
+                        i = 2;
+                        buf[0] = 0;
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_SETCURSEL,
+                        (WPARAM) i,
+                        0
+                        );
+
+                    break;
+                }
+                case PT_POINTER:
+                case PT_CALLPARAMS: // ??? BUGBUG
+                case PT_FORWARDLIST: // ??? BUGBUG
+                {
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) "00000000"
+                        );
+
+                    sprintf(
+                        buf,
+                        "%08lx (valid pointer)",
+                        pParamsHeader->aParams[lSel].u.dwDefValue
+                        );
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) buf
+                        );
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) "ffffffff"
+                        );
+
+                    sprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_DWORD:
+                {
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) "0000000"
+                        );
+
+                    if (pParamsHeader->aParams[lSel].u.dwDefValue)
+                    {
+                        //
+                        // Add the default val string to the combo
+                        //
+
+                        sprintf(
+                            buf,
+                            "%08lx",
+                            pParamsHeader->aParams[lSel].u.dwDefValue
+                            );
+
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) buf
+                            );
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) "ffffffff"
+                        );
+
+                    sprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_FLAGS:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].u.pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_LIST2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue &
+                            pLookup[i].dwVal)
+                        {
+                            SendDlgItemMessage(
+                                hwnd,
+                                IDC_LIST2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) "select none"
+                        );
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) "select all"
+                        );
+
+                    sprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_ORDINAL:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].u.pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue ==
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                } //switch
+
+                SetDlgItemText (hwnd, IDC_COMBO1, lpstr);
+
+                pDlgInstData->lLastSel = lSel;
+            }
+            break;
+
+        case IDC_LIST2:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+#else
+            if (HIWORD(lParam) == LBN_SELCHANGE)
+#endif
+            {
+                PLOOKUP pLookup = (PLOOKUP)
+                    pParamsHeader->aParams[lLastSel].u.pLookup;
+                char buf[16];
+                DWORD dwValue = 0;
+                int far *ai;
+                LONG i, lSelCount =
+                    SendDlgItemMessage (hwnd, IDC_LIST2, LB_GETSELCOUNT, 0, 0);
+
+
+                if (lSelCount)
+                {
+                    ai = (int far *) malloc ((size_t)lSelCount * sizeof(int));
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_LIST2,
+                        LB_GETSELITEMS,
+                        (WPARAM) lSelCount,
+                        (LPARAM) ai
+                        );
+
+                    if (pParamsHeader->aParams[lLastSel].dwType == PT_FLAGS)
+                    {
+                        for (i = 0; i < lSelCount; i++)
+                        {
+                            dwValue |= pLookup[ai[i]].dwVal;
+                        }
+                    }
+                    else // if (.dwType == PT_ORDINAL)
+                    {
+                        if (lSelCount == 1)
+                        {
+                            dwValue = pLookup[ai[0]].dwVal;
+                        }
+                        else if (lSelCount == 2)
+                        {
+                            //
+                            // Figure out which item we need to de-select,
+                            // since we're doing ords & only want 1 item
+                            // selected at a time
+                            //
+
+                            GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                            if (sscanf (buf, "%lx", &dwValue))
+                            {
+                                if (pLookup[ai[0]].dwVal == dwValue)
+                                {
+                                    SendDlgItemMessage(
+                                        hwnd,
+                                        IDC_LIST2,
+                                        LB_SETSEL,
+                                        0,
+                                        (LPARAM) ai[0]
+                                        );
+
+                                    dwValue = pLookup[ai[1]].dwVal;
+                                }
+                                else
+                                {
+                                    SendDlgItemMessage(
+                                        hwnd,
+                                        IDC_LIST2,
+                                        LB_SETSEL,
+                                        0,
+                                        (LPARAM) ai[1]
+                                        );
+
+                                    dwValue = pLookup[ai[0]].dwVal;
+                                }
+                            }
+                            else
+                            {
+                                // BUGBUG de-select items???
+
+                                dwValue = 0;
+                            }
+                        }
+                    }
+
+                    free (ai);
+                }
+
+                sprintf (buf, "%08lx", dwValue);
+                SetDlgItemText (hwnd, IDC_COMBO1, buf);
+            }
+            break;
+
+        case IDC_COMBO1:
+
+#ifdef WIN32
+            switch (HIWORD(wParam))
+#else
+            switch (HIWORD(lParam))
+#endif
+            {
+            case CBN_SELCHANGE:
+            {
+                LONG lSel =
+                    SendDlgItemMessage (hwnd, IDC_COMBO1, CB_GETCURSEL, 0, 0);
+
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_POINTER:
+                {
+                    if (lSel == 1)
+                    {
+                        //
+                        // Strip off the "(valid pointer)" in the edit ctrl
+                        //
+
+                        sprintf(
+                            lpszComboText,
+                            "%08lx",
+                            pParamsHeader->aParams[lLastSel].u.ptr
+                            );
+
+                        PostMessage (hwnd, WM_USER+55, 0, 0);
+                    }
+
+                    break;
+                }
+                case PT_FLAGS:
+                {
+                    BOOL bSelect = (lSel ? TRUE : FALSE);
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_LIST2,
+                        LB_SETSEL,
+                        (WPARAM) bSelect,
+                        (LPARAM) -1
+                        );
+
+                    if (bSelect)
+                    {
+                        PLOOKUP pLookup = (PLOOKUP)
+                            pParamsHeader->aParams[lLastSel].u.pLookup;
+                        DWORD dwValue = 0;
+                        int far *ai;
+                        LONG i, lSelCount =
+                            SendDlgItemMessage (hwnd, IDC_LIST2, LB_GETSELCOUNT, 0, 0);
+
+
+                        if (lSelCount)
+                        {
+                            ai = (int far *) malloc ((size_t)lSelCount * sizeof(int));
+
+                            SendDlgItemMessage(
+                                hwnd,
+                                IDC_LIST2,
+                                LB_GETSELITEMS,
+                                (WPARAM) lSelCount,
+                                (LPARAM) ai
+                                );
+
+                            for (i = 0; i < lSelCount; i++)
+                            {
+                                dwValue |= pLookup[ai[i]].dwVal;
+                            }
+
+                            free (ai);
+                        }
+
+                        sprintf (lpszComboText, "%08lx", dwValue);
+
+                    }
+                    else
+                    {
+                        strcpy (lpszComboText, "00000000");
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+                }
+                case PT_STRING:
+
+                    if (lSel == 1)
+                    {
+                        strncpy(
+                            lpszComboText,
+                            pParamsHeader->aParams[lLastSel].u.buf,
+                            MAX_STRING_PARAM_SIZE
+                            );
+
+                        lpszComboText[MAX_STRING_PARAM_SIZE-1] = 0;
+                    }
+                    else
+                    {
+                        lpszComboText[0] = 0;
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+
+                case PT_DWORD:
+
+                    break;
+
+                case PT_CALLPARAMS:
+                {
+                    if (lSel == 1)
+                    {
+#if TAPI_2_0
+                        LPLINECALLPARAMS lpCP = (gbWideStringParams ?
+                                            lpCallParamsW : lpCallParams);
+#else
+                        LPLINECALLPARAMS lpCP = lpCallParams;
+#endif
+                        char *p = (char *) lpCP;
+
+#if TAPI_2_0
+                        char    asz[14][MAX_STRING_PARAM_SIZE];
+                        LPDWORD pdwProxyRequests = (LPDWORD) (((LPBYTE) lpCP) +
+                                    lpCP->dwDevSpecificOffset);
+#else
+                        char asz[7][MAX_STRING_PARAM_SIZE];
+#endif
+                        FUNC_PARAM params[] =
+                        {
+                            { "dwBearerMode",                   PT_FLAGS,  lpCP->dwBearerMode, aBearerModes },
+                            { "dwMinRate",                      PT_DWORD,  lpCP->dwMinRate, NULL },
+                            { "dwMaxRate",                      PT_DWORD,  lpCP->dwMaxRate, NULL },
+                            { "dwMediaMode",                    PT_FLAGS,  lpCP->dwMediaMode, aMediaModes },
+                            { "dwCallParamFlags",               PT_FLAGS,  lpCP->dwCallParamFlags, aCallParamFlags },
+                            { "dwAddressMode",                  PT_ORDINAL,lpCP->dwAddressMode, aAddressModes },
+                            { "dwAddressID",                    PT_DWORD,  lpCP->dwAddressID, NULL },
+                            { "DIALPARAMS.dwDialPause",         PT_DWORD,  lpCP->DialParams.dwDialPause, NULL },
+                            { "DIALPARAMS.dwDialSpeed",         PT_DWORD,  lpCP->DialParams.dwDialSpeed, NULL },
+                            { "DIALPARAMS.dwDigitDuration",     PT_DWORD,  lpCP->DialParams.dwDigitDuration, NULL },
+                            { "DIALPARAMS.dwWaitForDialtone",   PT_DWORD,  lpCP->DialParams.dwWaitForDialtone, NULL },
+                            { "szOrigAddress",                  PT_STRING, (DWORD) asz[0], asz[0] },
+                            { "szDisplayableAddress",           PT_STRING, (DWORD) asz[1], asz[1] },
+                            { "szCalledParty",                  PT_STRING, (DWORD) asz[2], asz[2] },
+                            { "szComment",                      PT_STRING, (DWORD) asz[3], asz[3] },
+                            { "szUserUserInfo",                 PT_STRING, (DWORD) asz[4], asz[4] },
+                            { "szHighLevelComp",                PT_STRING, (DWORD) asz[5], asz[5] },
+                            { "szLowLevelComp",                 PT_STRING, (DWORD) asz[6], asz[6] }
+#if TAPI_2_0
+                             ,
+                            { "dwPredictiveAutoTransferStates", PT_FLAGS,  lpCP->dwPredictiveAutoTransferStates, aCallStates },
+                            { "szTargetAddress",                PT_STRING, (DWORD) asz[7], asz[7] },
+                            { "szSendingFlowspec",              PT_STRING, (DWORD) asz[8], asz[8] },
+                            { "szReceivingFlowspec",            PT_STRING, (DWORD) asz[9], asz[9] },
+                            { "szDeviceClass",                  PT_STRING, (DWORD) asz[10], asz[10] },
+                            { "szDeviceConfig",                 PT_STRING, (DWORD) asz[11], asz[11] },
+                            { "szCallData",                     PT_STRING, (DWORD) asz[12], asz[12] },
+                            { "dwNoAnswerTimeout",              PT_DWORD,  lpCP->dwNoAnswerTimeout, NULL },
+                            { "szCallingPartyID",               PT_STRING, (DWORD) asz[13], asz[13] },
+
+                            { "NumProxyRequests",               PT_DWORD,  lpCP->dwDevSpecificSize / 4, NULL },
+                            { "  ProxyRequest1",                PT_ORDINAL,*pdwProxyRequests, aProxyRequests },
+                            { "  ProxyRequest2",                PT_ORDINAL,*(pdwProxyRequests + 1), aProxyRequests },
+                            { "  ProxyRequest3",                PT_ORDINAL,*(pdwProxyRequests + 2), aProxyRequests },
+                            { "  ProxyRequest4",                PT_ORDINAL,*(pdwProxyRequests + 3), aProxyRequests },
+                            { "  ProxyRequest5",                PT_ORDINAL,*(pdwProxyRequests + 4), aProxyRequests },
+                            { "  ProxyRequest6",                PT_ORDINAL,*(pdwProxyRequests + 5), aProxyRequests },
+                            { "  ProxyRequest7",                PT_ORDINAL,*(pdwProxyRequests + 6), aProxyRequests },
+                            { "  ProxyRequest8",                PT_ORDINAL,*(pdwProxyRequests + 7), aProxyRequests }
+#endif
+                        };
+                        FUNC_PARAM_HEADER paramsHeader =
+                            { 0, lCallParams, params, NULL };
+                        int     i;
+
+                        LPDWORD apXxxSize[] =
+                        {
+                            &lpCP->dwOrigAddressSize,
+                            &lpCP->dwDisplayableAddressSize,
+                            &lpCP->dwCalledPartySize,
+                            &lpCP->dwCommentSize,
+                            &lpCP->dwUserUserInfoSize,
+                            &lpCP->dwHighLevelCompSize,
+                            &lpCP->dwLowLevelCompSize,
+#if TAPI_2_0
+                            &lpCP->dwTargetAddressSize,
+                            &lpCP->dwSendingFlowspecSize,
+                            &lpCP->dwReceivingFlowspecSize,
+                            &lpCP->dwDeviceClassSize,
+                            &lpCP->dwDeviceConfigSize,
+                            &lpCP->dwCallDataSize,
+                            &lpCP->dwCallingPartyIDSize,
+#endif
+                            NULL
+                        };
+                        static DWORD   dwAPIVersion, adwStrParamIndices[] =
+                        {
+                            11, 12, 13, 14, 15, 16, 17,
+#if TAPI_2_0
+                            19, 20, 21, 22, 23, 24, 26,
+#endif
+                            0
+                        };
+
+
+
+                        //
+                        // Init the tmp string params
+                        //
+
+                        for (i = 0; apXxxSize[i]; i++)
+                        {
+                            if (*apXxxSize[i])
+                            {
+#if TAPI_2_0
+                                if (gbWideStringParams)
+                                {
+                                    WideCharToMultiByte(
+                                        CP_ACP,
+                                        0,
+                                        (LPCWSTR) (p + *(apXxxSize[i] + 1)),
+                                        -1,
+                                        asz[i],
+                                        MAX_STRING_PARAM_SIZE,
+                                        NULL,
+                                        NULL
+                                        );
+                                }
+                                else
+                                {
+                                    strcpy (asz[i], p + *(apXxxSize[i] + 1));
+                                }
+#else
+                                strcpy (asz[i], p + *(apXxxSize[i] + 1));
+#endif
+                            }
+                            else
+                            {
+                                asz[i][0] = 0;
+                            }
+                        }
+
+                        if (pDlgInstData->pParamsHeader->FuncIndex == lOpen)
+                        {
+                            dwAPIVersion = pDlgInstData->pParamsHeader->
+                                aParams[3].dwValue;
+                        }
+                        else
+                        {
+#if TAPI_2_0
+                            dwAPIVersion = 0x00020000;
+#else
+                            dwAPIVersion = 0x00010004;
+#endif
+                        }
+
+                        if (dwAPIVersion < 0x00020000)
+                        {
+                            paramsHeader.dwNumParams = 18;
+                            apXxxSize[8] = NULL;
+                        }
+#if TAPI_2_0
+                        else if (pDlgInstData->pParamsHeader->FuncIndex ==
+                                    lOpen)
+                        {
+                            paramsHeader.dwNumParams = 36;
+                        }
+                        else
+                        {
+                            paramsHeader.dwNumParams = 27;
+                        }
+#endif
+                        if (DialogBoxParam(
+                                ghInst,
+                                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG2),
+                                hwnd,
+                                (DLGPROC) ParamsDlgProc,
+                                (LPARAM) &paramsHeader
+                                ))
+                        {
+                            LPDWORD lpdwXxx = &lpCP->dwBearerMode;
+
+
+                            //
+                            // Save the DWORD params
+                            //
+
+                            for (i = 0; i < 11; i++)
+                            {
+                                *(lpdwXxx + i) = params[i].dwValue;
+                            }
+#if TAPI_2_0
+                            if (paramsHeader.dwNumParams > 18)
+                            {
+                                lpCP->dwPredictiveAutoTransferStates =
+                                    params[18].dwValue;
+                                lpCP->dwNoAnswerTimeout = params[25].dwValue;
+
+                                if (paramsHeader.dwNumParams > 27)
+                                {
+                                    lpCP->dwDevSpecificSize =
+                                        4 * params[27].dwValue;
+
+                                    for (i = 0; i < 8; i++)
+                                    {
+                                        *(pdwProxyRequests + i) =
+                                            params[28+i].dwValue;
+                                    }
+                                }
+                            }
+#endif
+
+                            //
+                            // Save the string params
+                            //
+
+                            for (i = 0; apXxxSize[i]; i++)
+                            {
+                                DWORD   length, index = adwStrParamIndices[i];
+
+
+                                if (params[index].dwValue &&
+                                    (params[index].dwValue != 0xffffffff))
+                                {
+#if TAPI_2_0
+                                    if (gbWideStringParams)
+                                    {
+                                        length = MultiByteToWideChar(
+                                            CP_ACP,
+                                            MB_PRECOMPOSED,
+                                            (LPCSTR) asz[i],
+                                            -1,
+                                            (LPWSTR) (p + *(apXxxSize[i] + 1)),
+                                                                     // offset
+                                            MAX_STRING_PARAM_SIZE/2
+                                            );
+
+                                        length *= sizeof (WCHAR);
+                                    }
+                                    else
+                                    {
+                                        strcpy(
+                                            p + *(apXxxSize[i] + 1), // offset
+                                            asz[i]
+                                            );
+
+                                        length = (DWORD) strlen (asz[i]) + 1;
+                                    }
+#else
+                                    strcpy(
+                                        p + *(apXxxSize[i] + 1), // offset
+                                        asz[i]
+                                        );
+
+                                    length = (DWORD) strlen (asz[i]) + 1;
+#endif
+                                }
+                                else
+                                {
+                                    length = 0;
+                                }
+
+                                *apXxxSize[i] = length;
+                            }
+                        }
+
+                        //
+                        // Strip off the "(valid pointer)" in the edit ctrl
+                        //
+
+                        sprintf (lpszComboText, "%08lx", lpCP);
+                        PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                        pParamsHeader->aParams[lLastSel].dwValue =
+                            (DWORD) lpCP;
+                    }
+
+                    break;
+                }
+                case PT_FORWARDLIST:
+                {
+                    if (lSel == 1)
+                    {
+                        char asz[MAX_LINEFORWARD_ENTRIES][2][MAX_STRING_PARAM_SIZE];
+                        FUNC_PARAM params[] =
+                        {
+                            { "dwNumEntries",             PT_DWORD,  0, 0 },
+                            { "[0].dwFowardMode",         PT_FLAGS,  0, aForwardModes },
+                            { "[0].lpszCallerAddress",    PT_STRING, 0, asz[0][0] },
+                            { "[0].dwDestCountryCode",    PT_DWORD,  0, 0 },
+                            { "[0].lpszDestAddress",      PT_STRING, 0, asz[0][1] },
+                            { "[1].dwFowardMode",         PT_FLAGS,  0, aForwardModes },
+                            { "[1].lpszCallerAddress",    PT_STRING, 0, asz[1][0] },
+                            { "[1].dwDestCountryCode",    PT_DWORD,  0, 0 },
+                            { "[1].lpszDestAddress",      PT_STRING, 0, asz[1][1] },
+                            { "[2].dwFowardMode",         PT_FLAGS,  0, aForwardModes },
+                            { "[2].lpszCallerAddress",    PT_STRING, 0, asz[2][0] },
+                            { "[2].dwDestCountryCode",    PT_DWORD,  0, 0 },
+                            { "[2].lpszDestAddress",      PT_STRING, 0, asz[2][1] },
+                            { "[3].dwFowardMode",         PT_FLAGS,  0, aForwardModes },
+                            { "[3].lpszCallerAddress",    PT_STRING, 0, asz[3][0] },
+                            { "[3].dwDestCountryCode",    PT_DWORD,  0, 0 },
+                            { "[3].lpszDestAddress",      PT_STRING, 0, asz[3][1] },
+                            { "[4].dwFowardMode",         PT_FLAGS,  0, aForwardModes },
+                            { "[4].lpszCallerAddress",    PT_STRING, 0, asz[4][0] },
+                            { "[4].dwDestCountryCode",    PT_DWORD,  0, 0 },
+                            { "[4].lpszDestAddress",      PT_STRING, 0, asz[4][1] },
+
+                        };
+                        FUNC_PARAM_HEADER paramsHeader =
+                            { 21, lForwardList, params, NULL };
+
+
+                        memset(
+                            asz,
+                            0,
+                            MAX_LINEFORWARD_ENTRIES*2*MAX_STRING_PARAM_SIZE
+                            );
+
+                        if (DialogBoxParam(
+                                ghInst,
+                                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG2),
+                                hwnd,
+                                (DLGPROC) ParamsDlgProc,
+                                (LPARAM) &paramsHeader
+                                ))
+                        {
+
+                            LPLINEFORWARDLIST lpForwardList =
+                                (LPLINEFORWARDLIST)
+                                    pParamsHeader->aParams[lLastSel].u.ptr;
+                            LPLINEFORWARD lpEntry = lpForwardList->ForwardList;
+                            DWORD dwNumEntriesToInit =
+                                (params[0].dwValue > MAX_LINEFORWARD_ENTRIES ?
+                                    MAX_LINEFORWARD_ENTRIES : params[0].dwValue);
+                            DWORD i, dwFixedSize = sizeof(LINEFORWARDLIST) +
+                                (MAX_LINEFORWARD_ENTRIES-1)*sizeof(LINEFORWARD);
+
+
+                            lpForwardList->dwNumEntries = params[0].dwValue;
+
+                            for (i = 0; i < dwNumEntriesToInit; i++)
+                            {
+                                lpEntry->dwForwardMode =
+                                    params[1 + 4*i].dwValue;
+
+                                if (params[2 + 4*i].dwValue &&
+                                    params[2 + 4*i].dwValue != 0xffffffff)
+                                {
+                                    lpEntry->dwCallerAddressSize =
+                                        strlen (asz[i][0]) + 1;
+
+                                    lpEntry->dwCallerAddressOffset =
+                                        dwFixedSize +
+                                            2*i*MAX_STRING_PARAM_SIZE;
+#if TAPI_2_0
+                                    if (gbWideStringParams)
+                                    {
+                                        lpEntry->dwCallerAddressSize *=
+                                            sizeof (WCHAR);
+
+                                        MultiByteToWideChar(
+                                            CP_ACP,
+                                            MB_PRECOMPOSED,
+                                            (LPCSTR) asz[i][0],
+                                            -1,
+                                            (LPWSTR) ((char *) lpForwardList +
+                                                lpEntry->dwCallerAddressOffset),
+                                            MAX_STRING_PARAM_SIZE / 2
+                                            );
+                                    }
+                                    else
+                                    {
+                                        strcpy(
+                                            (char *) lpForwardList +
+                                                lpEntry->dwCallerAddressOffset,
+                                            asz[i][0]
+                                            );
+                                    }
+#else
+                                    strcpy(
+                                        (char *) lpForwardList +
+                                            lpEntry->dwCallerAddressOffset,
+                                        asz[i][0]
+                                        );
+#endif
+                                }
+
+                                lpEntry->dwDestCountryCode =
+                                    params[3 + 4*i].dwValue;
+
+                                if (params[4 + 4*i].dwValue &&
+                                    params[4 + 4*i].dwValue != 0xffffffff)
+                                {
+                                    lpEntry->dwDestAddressSize =
+                                        strlen (asz[i][1]) + 1;
+
+                                    lpEntry->dwDestAddressOffset =
+                                        dwFixedSize +
+                                            (2*i + 1)*MAX_STRING_PARAM_SIZE;
+
+#if TAPI_2_0
+                                    if (gbWideStringParams)
+                                    {
+                                        lpEntry->dwDestAddressSize *=
+                                            sizeof (WCHAR);
+
+                                        MultiByteToWideChar(
+                                            CP_ACP,
+                                            MB_PRECOMPOSED,
+                                            (LPCSTR) asz[i][1],
+                                            -1,
+                                            (LPWSTR) ((char *) lpForwardList +
+                                                lpEntry->dwDestAddressOffset),
+                                            MAX_STRING_PARAM_SIZE / 2
+                                            );
+                                    }
+                                    else
+                                    {
+                                        strcpy(
+                                            (char *) lpForwardList +
+                                                lpEntry->dwDestAddressOffset,
+                                            asz[i][1]
+                                            );
+                                    }
+#else
+                                    strcpy(
+                                        (char *) lpForwardList +
+                                            lpEntry->dwDestAddressOffset,
+                                        asz[i][1]
+                                        );
+#endif
+                                }
+
+                                lpEntry++;
+                            }
+                        }
+
+                        //
+                        // Strip off the "(valid pointer)" in the edit ctrl
+                        //
+
+                        sprintf(
+                            lpszComboText,
+                            "%08lx",
+                            pParamsHeader->aParams[lLastSel].u.ptr
+                            );
+
+                        PostMessage (hwnd, WM_USER+55, 0, 0);
+                    }
+
+                    break;
+                }
+                case PT_ORDINAL:
+
+                    //
+                    // The only option here is "select none"
+                    //
+
+                    strcpy (lpszComboText, "00000000");
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+                    break;
+
+                } // switch
+
+                break;
+            }
+            case CBN_EDITCHANGE:
+            {
+                //
+                // If user entered text in the edit field then copy the
+                // text to our buffer
+                //
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_STRING)
+                {
+                    char buf[MAX_STRING_PARAM_SIZE];
+
+
+                    GetDlgItemText(
+                        hwnd,
+                        IDC_COMBO1,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    strncpy(
+                        pParamsHeader->aParams[lLastSel].u.buf,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    pParamsHeader->aParams[lLastSel].u.buf
+                        [MAX_STRING_PARAM_SIZE-1] = 0;
+                }
+                break;
+            }
+            } // switch
+
+        } // switch
+
+        break;
+    }
+    case WM_USER+55:
+
+        SetDlgItemText (hwnd, IDC_COMBO1, pDlgInstData->szComboText);
+        break;
+
+#ifdef WIN32
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_STATIC)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    } // switch
+
+    return FALSE;
+}
+
+
+BOOL
+CALLBACK
+IconDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    static HICON hIcon;
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+
+        hIcon = (HICON) lParam;
+
+        break;
+
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        break;
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+#ifdef WIN32
+        MoveToEx (ps.hdc, 6, 6, (LPPOINT) NULL);
+#else
+        MoveTo (ps.hdc, 6, 6);
+#endif
+        LineTo (ps.hdc, 42, 6);
+        LineTo (ps.hdc, 42, 42);
+        LineTo (ps.hdc, 6, 42);
+        LineTo (ps.hdc, 6, 6);
+        DrawIcon (ps.hdc, 8, 8, hIcon);
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+CALLBACK
+UserButtonsDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    static int iButtonIndex;
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        int i;
+        char buf[32];
+
+        if (lParam)
+        {
+            //
+            // The dlg was invoked because someone pressed a user button
+            // that was uninitialized, so only allow chgs on this button
+            //
+
+            iButtonIndex = *((int *) lParam);
+
+            _itoa (iButtonIndex + 1, buf, 10);
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST1,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) buf
+                );
+        }
+        else
+        {
+            //
+            // The dlg was invoked because the user chose a menuitem,
+            // so allow chgs on all buttons
+            //
+
+            iButtonIndex = MAX_USER_BUTTONS;
+
+            for (i = 1; i <= MAX_USER_BUTTONS; i++)
+            {
+                _itoa (i, buf, 10);
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_INSERTSTRING,
+                    (WPARAM) -1,
+                    (LPARAM) buf
+                    );
+            }
+
+        }
+
+        SendDlgItemMessage(
+            hwnd,
+            IDC_LIST1,
+            LB_SETCURSEL,
+            (WPARAM) 0,
+            0
+            );
+
+        for (i = 0; aFuncNames[i]; i++)
+        {
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST2,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) aFuncNames[i]
+                );
+        }
+
+        SendDlgItemMessage(
+            hwnd,
+            IDC_LIST2,
+            LB_INSERTSTRING,
+            (WPARAM) -1,
+            (LPARAM) "<none>"
+            );
+
+        if (!lParam)
+        {
+#ifdef WIN32
+            wParam = (WPARAM) MAKELONG (0, LBN_SELCHANGE);
+#else
+            lParam = (LPARAM) MAKELONG (0, LBN_SELCHANGE);
+#endif
+            goto IDC_LIST1_selchange;
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+        {
+            LONG lFuncSel;
+
+
+            lFuncSel = SendDlgItemMessage(hwnd, IDC_LIST2, LB_GETCURSEL, 0, 0);
+
+            if (lFuncSel == LB_ERR)
+            {
+                MessageBox (hwnd, "Select a function", "", MB_OK);
+                break;
+            }
+
+            if (iButtonIndex == MAX_USER_BUTTONS)
+            {
+                iButtonIndex = (int) SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+            }
+
+            aUserButtonFuncs[iButtonIndex] = (DWORD) lFuncSel;
+
+            if (lFuncSel == MiscBegin)
+            {
+                //
+                // User selected "<none>" option so nullify string
+                //
+
+                aUserButtonsText[iButtonIndex][0] = 0;
+            }
+            else
+            {
+                GetDlgItemText(
+                    hwnd,
+                    IDC_EDIT1,
+                    (LPSTR) &aUserButtonsText[iButtonIndex],
+                    MAX_USER_BUTTON_TEXT_SIZE - 1
+                    );
+
+                aUserButtonsText[iButtonIndex][MAX_USER_BUTTON_TEXT_SIZE - 1] =
+                    0;
+            }
+
+            SetDlgItemText(
+                ghwndMain,
+                IDC_BUTTON13 + iButtonIndex,
+                (LPSTR) &aUserButtonsText[iButtonIndex]
+                );
+
+            // Fall thru to IDCANCEL code
+        }
+        case IDCANCEL:
+
+            EndDialog (hwnd, FALSE);
+            break;
+
+        case IDC_LIST1:
+
+IDC_LIST1_selchange:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+#else
+            if (HIWORD(lParam) == LBN_SELCHANGE)
+#endif
+            {
+                LONG lButtonSel =
+                    SendDlgItemMessage(hwnd, IDC_LIST1, LB_GETCURSEL, 0, 0);
+
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_SETCURSEL,
+                    (WPARAM) aUserButtonFuncs[lButtonSel],
+                    0
+                    );
+
+                SetDlgItemText(
+                    hwnd,
+                    IDC_EDIT1,
+                    aUserButtonsText[lButtonSel]
+                    );
+            }
+            break;
+
+        } // switch
+
+        break;
+
+#ifdef WIN32
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_STATIC)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    } // switch
+
+    return FALSE;
+}
diff --git a/private/tapi/dev/apps/tb/vars.c b/private/tapi/dev/apps/tb/vars.c
new file mode 100644
index 000000000..4df8db092
--- /dev/null
+++ b/private/tapi/dev/apps/tb/vars.c
@@ -0,0 +1,1591 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-96  Microsoft Corporation
+
+Module Name:
+
+    vars.c
+
+Abstract:
+
+    Globals for TAPI Browser util.
+
+Author:
+
+    Dan Knudson (DanKn)    23-Oct-1994
+
+Revision History:
+
+--*/
+
+
+#include <stdio.h>
+#include "tb.h"
+
+#ifdef WIN32
+#define my_far
+#else
+#define my_far _far
+#endif
+
+
+PMYWIDGET   aWidgets = (PMYWIDGET) NULL;
+
+FILE        *hLogFile = (FILE *) NULL;
+HANDLE      ghInst;
+HWND        ghwndMain, ghwndEdit, ghwndList1, ghwndList2;
+BOOL        bShowParams = FALSE;
+BOOL        gbDeallocateCall = FALSE;
+BOOL        gbDisableHandleChecking;
+LPVOID      pBigBuf;
+DWORD       dwBigBufSize;
+DWORD       dwNumPendingMakeCalls = 0;
+DWORD       dwNumPendingDrops = 0;
+DWORD       gdwNumLineDevs = 0;
+DWORD       gdwNumPhoneDevs = 0;
+BOOL        bDumpParams = FALSE;
+BOOL        bTimeStamp;
+DWORD       bNukeIdleMonitorCalls;
+DWORD       bNukeIdleOwnedCalls;
+DWORD       dwDumpStructsFlags;
+
+LPLINECALLPARAMS    lpCallParams;
+
+#if TAPI_2_0
+BOOL        gbWideStringParams = FALSE;
+LPLINECALLPARAMS    lpCallParamsW;
+#endif
+
+DWORD       aUserButtonFuncs[MAX_USER_BUTTONS];
+char        aUserButtonsText[MAX_USER_BUTTONS][MAX_USER_BUTTON_TEXT_SIZE];
+
+PMYLINEAPP  pLineAppSel;
+PMYLINE     pLineSel;
+PMYCALL     pCallSel, pCallSel2;
+PMYPHONEAPP pPhoneAppSel;
+PMYPHONE    pPhoneSel;
+
+char my_far szDefAppName[MAX_STRING_PARAM_SIZE];
+char my_far szDefUserUserInfo[MAX_STRING_PARAM_SIZE];
+char my_far szDefDestAddress[MAX_STRING_PARAM_SIZE];
+char my_far szDefLineDeviceClass[MAX_STRING_PARAM_SIZE];
+char my_far szDefPhoneDeviceClass[MAX_STRING_PARAM_SIZE];
+
+char far   *lpszDefAppName;
+char far   *lpszDefUserUserInfo;
+char far   *lpszDefDestAddress;
+char far   *lpszDefLineDeviceClass;
+char far   *lpszDefPhoneDeviceClass;
+
+char my_far szTab[] = "  ";
+char my_far szCurrVer[] = "1.1";
+
+
+// help char my_far szTapiHlp[256] = "";
+// help char my_far szTspiHlp[256] = "";
+
+DWORD       dwDefAddressID;
+DWORD       dwDefLineAPIVersion;
+DWORD       dwDefBearerMode;
+DWORD       dwDefCountryCode;
+DWORD       dwDefLineDeviceID;
+DWORD       dwDefLineExtVersion;
+DWORD       dwDefMediaMode;
+DWORD       dwDefLinePrivilege;
+DWORD       dwDefPhoneAPIVersion;
+DWORD       dwDefPhoneDeviceID;
+DWORD       dwDefPhoneExtVersion;
+DWORD       dwDefPhonePrivilege;
+
+#if TAPI_2_0
+HANDLE      ghCompletionPort;
+#endif
+
+char aAscii[] =
+{
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+     64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+     80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+     96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
+    112,113,114,115,116,117,118,119,120,121,122,123,124,125,126, 46,
+
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46
+};
+
+
+
+LOOKUP my_far aAddressCapFlags[] =
+{
+    { LINEADDRCAPFLAGS_FWDNUMRINGS      ,"FWDNUMRINGS"      },
+    { LINEADDRCAPFLAGS_PICKUPGROUPID    ,"PICKUPGROUPID"    },
+    { LINEADDRCAPFLAGS_SECURE           ,"SECURE"           },
+    { LINEADDRCAPFLAGS_BLOCKIDDEFAULT   ,"BLOCKIDDEFAULT"   },
+    { LINEADDRCAPFLAGS_BLOCKIDOVERRIDE  ,"BLOCKIDOVERRIDE"  },
+    { LINEADDRCAPFLAGS_DIALED           ,"DIALED"           },
+    { LINEADDRCAPFLAGS_ORIGOFFHOOK      ,"ORIGOFFHOOK"      },
+    { LINEADDRCAPFLAGS_DESTOFFHOOK      ,"DESTOFFHOOK"      },
+    { LINEADDRCAPFLAGS_FWDCONSULT       ,"FWDCONSULT"       },
+    { LINEADDRCAPFLAGS_SETUPCONFNULL    ,"SETUPCONFNULL"    },
+    { LINEADDRCAPFLAGS_AUTORECONNECT    ,"AUTORECONNECT"    },
+    { LINEADDRCAPFLAGS_COMPLETIONID     ,"COMPLETIONID"     },
+    { LINEADDRCAPFLAGS_TRANSFERHELD     ,"TRANSFERHELD"     },
+    { LINEADDRCAPFLAGS_TRANSFERMAKE     ,"TRANSFERMAKE"     },
+    { LINEADDRCAPFLAGS_CONFERENCEHELD   ,"CONFERENCEHELD"   },
+    { LINEADDRCAPFLAGS_CONFERENCEMAKE   ,"CONFERENCEMAKE"   },
+    { LINEADDRCAPFLAGS_PARTIALDIAL      ,"PARTIALDIAL"      },
+    { LINEADDRCAPFLAGS_FWDSTATUSVALID   ,"FWDSTATUSVALID"   },
+    { LINEADDRCAPFLAGS_FWDINTEXTADDR    ,"FWDINTEXTADDR"    },
+    { LINEADDRCAPFLAGS_FWDBUSYNAADDR    ,"FWDBUSYNAADDR"    },
+    { LINEADDRCAPFLAGS_ACCEPTTOALERT    ,"ACCEPTTOALERT"    },
+    { LINEADDRCAPFLAGS_CONFDROP         ,"CONFDROP"         },
+    { LINEADDRCAPFLAGS_PICKUPCALLWAIT   ,"PICKUPCALLWAIT"   },
+#if TAPI_2_0
+    { LINEADDRCAPFLAGS_PREDICTIVEDIALER ,"PREDICTIVEDIALER" },
+    { LINEADDRCAPFLAGS_QUEUE            ,"QUEUE"            },
+    { LINEADDRCAPFLAGS_ROUTEPOINT       ,"ROUTEPOINT"       },
+    { LINEADDRCAPFLAGS_HOLDMAKESNEW     ,"HOLDMAKESNEW"     },
+    { LINEADDRCAPFLAGS_NOINTERNALCALLS  ,"NOINTERNALCALLS"  },
+    { LINEADDRCAPFLAGS_NOEXTERNALCALLS  ,"NOEXTERNALCALLS"  },
+    { LINEADDRCAPFLAGS_SETCALLINGID     ,"SETCALLINGID"     },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aAddressModes[] =
+{
+    { LINEADDRESSMODE_ADDRESSID         ,"ADDRESSID"        },
+    { LINEADDRESSMODE_DIALABLEADDR      ,"DIALABLEADDR"     },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aAddressSharing[] =
+{
+    { LINEADDRESSSHARING_PRIVATE        ,"PRIVATE"          },
+    { LINEADDRESSSHARING_BRIDGEDEXCL    ,"BRIDGEDEXCL"      },
+    { LINEADDRESSSHARING_BRIDGEDNEW     ,"BRIDGEDNEW"       },
+    { LINEADDRESSSHARING_BRIDGEDSHARED  ,"BRIDGEDSHARED"    },
+    { LINEADDRESSSHARING_MONITORED      ,"MONITORED"        },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aAddressStates[] =
+{
+    { LINEADDRESSSTATE_OTHER            ,"OTHER"            },
+    { LINEADDRESSSTATE_DEVSPECIFIC      ,"DEVSPECIFIC"      },
+    { LINEADDRESSSTATE_INUSEZERO        ,"INUSEZERO"        },
+    { LINEADDRESSSTATE_INUSEONE         ,"INUSEONE"         },
+    { LINEADDRESSSTATE_INUSEMANY        ,"INUSEMANY"        },
+    { LINEADDRESSSTATE_NUMCALLS         ,"NUMCALLS"         },
+    { LINEADDRESSSTATE_FORWARD          ,"FORWARD"          },
+    { LINEADDRESSSTATE_TERMINALS        ,"TERMINALS"        },
+#if TAPI_1_1
+    { LINEADDRESSSTATE_CAPSCHANGE       ,"CAPSCHANGE"       },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aAddressFeatures[] =
+{
+    { LINEADDRFEATURE_FORWARD           ,"FORWARD"          },
+    { LINEADDRFEATURE_MAKECALL          ,"MAKECALL"         },
+    { LINEADDRFEATURE_PICKUP            ,"PICKUP"           },
+    { LINEADDRFEATURE_SETMEDIACONTROL   ,"SETMEDIACONTROL"  },
+    { LINEADDRFEATURE_SETTERMINAL       ,"SETTERMINAL"      },
+    { LINEADDRFEATURE_SETUPCONF         ,"SETUPCONF"        },
+    { LINEADDRFEATURE_UNCOMPLETECALL    ,"UNCOMPLETECALL"   },
+    { LINEADDRFEATURE_UNPARK            ,"UNPARK"           },
+#if TAPI_2_0
+    { LINEADDRFEATURE_PICKUPHELD        ,"PICKUPHELD   "    },
+    { LINEADDRFEATURE_PICKUPGROUP       ,"PICKUPGROUP  "    },
+    { LINEADDRFEATURE_PICKUPDIRECT      ,"PICKUPDIRECT "    },
+    { LINEADDRFEATURE_PICKUPWAITING     ,"PICKUPWAITING"    },
+    { LINEADDRFEATURE_FORWARDFWD        ,"FORWARDFWD   "    },
+    { LINEADDRFEATURE_FORWARDDND        ,"FORWARDDND   "    },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+#ifdef TAPI_2_0
+LOOKUP my_far aAgentStates[] =
+{
+    { LINEAGENTSTATE_LOGGEDOFF          ,"LOGGEDOFF"        },
+    { LINEAGENTSTATE_NOTREADY           ,"NOTREADY"         },
+    { LINEAGENTSTATE_READY              ,"READY"            },
+    { LINEAGENTSTATE_BUSYACD            ,"BUSYACD"          },
+    { LINEAGENTSTATE_BUSYINCOMING       ,"BUSYINCOMING"     },
+    { LINEAGENTSTATE_BUSYOUTBOUND       ,"BUSYOUTBOUND"     },
+    { LINEAGENTSTATE_BUSYOTHER          ,"BUSYOTHER"        },
+    { LINEAGENTSTATE_WORKINGAFTERCALL   ,"WORKINGAFTERCALL" },
+    { LINEAGENTSTATE_UNKNOWN            ,"UNKNOWN"          },
+    { LINEAGENTSTATE_UNAVAIL            ,"UNAVAIL"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aAgentStatus[] =
+{
+    { LINEAGENTSTATUS_GROUP             ,"GROUP"            },
+    { LINEAGENTSTATUS_STATE             ,"STATE"            },
+    { LINEAGENTSTATUS_NEXTSTATE         ,"NEXTSTATE"        },
+    { LINEAGENTSTATUS_ACTIVITY          ,"ACTIVITY"         },
+    { LINEAGENTSTATUS_ACTIVITYLIST      ,"ACTIVITYLIST"     },
+    { LINEAGENTSTATUS_GROUPLIST         ,"GROUPLIST"        },
+    { LINEAGENTSTATUS_CAPSCHANGE        ,"CAPSCHANGE"       },
+    { LINEAGENTSTATUS_VALIDSTATES       ,"VALIDSTATES"      },
+    { LINEAGENTSTATUS_VALIDNEXTSTATES   ,"VALIDNEXTSTATES"  },
+    { 0xffffffff                        ,""                 }
+};
+#endif
+
+LOOKUP my_far aAnswerModes[] =
+{
+    { LINEANSWERMODE_NONE               ,"NONE"             },
+    { LINEANSWERMODE_DROP               ,"DROP"             },
+    { LINEANSWERMODE_HOLD               ,"HOLD"             },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aAPIVersions[] =
+{
+    { 0x00010003                        ,"TAPI 1.0"         },
+#if TAPI_1_1
+    { 0x00010004                        ,"TAPI 1.4"         },
+#if TAPI_2_0
+    { 0x00020000                        ,"TAPI 2.0"         },
+#endif
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aBearerModes[] =
+{
+    { LINEBEARERMODE_VOICE              ,"VOICE"            },
+    { LINEBEARERMODE_SPEECH             ,"SPEECH"           },
+    { LINEBEARERMODE_MULTIUSE           ,"MULTIUSE"         },
+    { LINEBEARERMODE_DATA               ,"DATA"             },
+    { LINEBEARERMODE_ALTSPEECHDATA      ,"ALTSPEECHDATA"    },
+    { LINEBEARERMODE_NONCALLSIGNALING   ,"NONCALLSIGNALING" },
+#if TAPI_1_1
+    { LINEBEARERMODE_PASSTHROUGH        ,"PASSTHROUGH"      },
+#if TAPI_2_0
+    { LINEBEARERMODE_RESTRICTEDDATA     ,"RESTRICTEDDATA"   },
+#endif
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aBusyModes[] =
+{
+    { LINEBUSYMODE_STATION              ,"STATION"          },
+    { LINEBUSYMODE_TRUNK                ,"TRUNK"            },
+    { LINEBUSYMODE_UNKNOWN              ,"UNKNOWN"          },
+    { LINEBUSYMODE_UNAVAIL              ,"UNAVAIL"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallComplConds[] =
+{
+    { LINECALLCOMPLCOND_BUSY            ,"BUSY"             },
+    { LINECALLCOMPLCOND_NOANSWER        ,"NOANSWER"         },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallComplModes[] =
+{
+    { LINECALLCOMPLMODE_CAMPON          ,"CAMPON"           },
+    { LINECALLCOMPLMODE_CALLBACK        ,"CALLBACK"         },
+    { LINECALLCOMPLMODE_INTRUDE         ,"INTRUDE"          },
+    { LINECALLCOMPLMODE_MESSAGE         ,"MESSAGE"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallFeatures[] =
+{
+    { LINECALLFEATURE_ACCEPT            ,"ACCEPT"           },
+    { LINECALLFEATURE_ADDTOCONF         ,"ADDTOCONF"        },
+    { LINECALLFEATURE_ANSWER            ,"ANSWER"           },
+    { LINECALLFEATURE_BLINDTRANSFER     ,"BLINDTRANSFER"    },
+    { LINECALLFEATURE_COMPLETECALL      ,"COMPLETECALL"     },
+    { LINECALLFEATURE_COMPLETETRANSF    ,"COMPLETETRANSF"   },
+    { LINECALLFEATURE_DIAL              ,"DIAL"             },
+    { LINECALLFEATURE_DROP              ,"DROP"             },
+    { LINECALLFEATURE_GATHERDIGITS      ,"GATHERDIGITS"     },
+    { LINECALLFEATURE_GENERATEDIGITS    ,"GENERATEDIGITS"   },
+    { LINECALLFEATURE_GENERATETONE      ,"GENERATETONE"     },
+    { LINECALLFEATURE_HOLD              ,"HOLD"             },
+    { LINECALLFEATURE_MONITORDIGITS     ,"MONITORDIGITS"    },
+    { LINECALLFEATURE_MONITORMEDIA      ,"MONITORMEDIA"     },
+    { LINECALLFEATURE_MONITORTONES      ,"MONITORTONES"     },
+    { LINECALLFEATURE_PARK              ,"PARK"             },
+    { LINECALLFEATURE_PREPAREADDCONF    ,"PREPAREADDCONF"   },
+    { LINECALLFEATURE_REDIRECT          ,"REDIRECT"         },
+    { LINECALLFEATURE_REMOVEFROMCONF    ,"REMOVEFROMCONF"   },
+    { LINECALLFEATURE_SECURECALL        ,"SECURECALL"       },
+    { LINECALLFEATURE_SENDUSERUSER      ,"SENDUSERUSER"     },
+    { LINECALLFEATURE_SETCALLPARAMS     ,"SETCALLPARAMS"    },
+    { LINECALLFEATURE_SETMEDIACONTROL   ,"SETMEDIACONTROL"  },
+    { LINECALLFEATURE_SETTERMINAL       ,"SETTERMINAL"      },
+    { LINECALLFEATURE_SETUPCONF         ,"SETUPCONF"        },
+    { LINECALLFEATURE_SETUPTRANSFER     ,"SETUPTRANSFER"    },
+    { LINECALLFEATURE_SWAPHOLD          ,"SWAPHOLD"         },
+    { LINECALLFEATURE_UNHOLD            ,"UNHOLD"           },
+#if TAPI_1_1
+    { LINECALLFEATURE_RELEASEUSERUSERINFO   ,"RELEASEUSERUSERINFO"  },
+#if TAPI_2_0
+    { LINECALLFEATURE_SETTREATMENT      ,"SETTREATMENT"     },
+    { LINECALLFEATURE_SETQOS            ,"SETQOS"           },
+    { LINECALLFEATURE_SETCALLDATA       ,"SETCALLDATA"      },
+#endif
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+#if TAPI_2_0
+LOOKUP my_far aCallFeatures2[] =
+{
+    { LINECALLFEATURE2_NOHOLDCONFERENCE ,"NOHOLDCONFERENCE" },
+    { LINECALLFEATURE2_ONESTEPTRANSFER  ,"ONESTEPTRANSFER " },
+    { LINECALLFEATURE2_COMPLCAMPON      ,"COMPLCAMPON"      },
+    { LINECALLFEATURE2_COMPLCALLBACK    ,"COMPLCALLBACK"    },
+    { LINECALLFEATURE2_COMPLINTRUDE     ,"COMPLINTRUDE"     },
+    { LINECALLFEATURE2_COMPLMESSAGE     ,"COMPLMESSAGE"     },
+    { LINECALLFEATURE2_TRANSFERNORM     ,"TRANSFERNORM"     },
+    { LINECALLFEATURE2_TRANSFERCONF     ,"TRANSFERCONF"     },
+    { LINECALLFEATURE2_PARKDIRECT       ,"PARKDIRECT"       },
+    { LINECALLFEATURE2_PARKNONDIRECT    ,"PARKNONDIRECT"    },
+
+    { 0xffffffff                        ,""                 }
+};
+#endif
+
+LOOKUP my_far aCallInfoStates[] =
+{
+    { LINECALLINFOSTATE_OTHER           ,"OTHER"            },
+    { LINECALLINFOSTATE_DEVSPECIFIC     ,"DEVSPECIFIC"      },
+    { LINECALLINFOSTATE_BEARERMODE      ,"BEARERMODE"       },
+    { LINECALLINFOSTATE_RATE            ,"RATE"             },
+    { LINECALLINFOSTATE_MEDIAMODE       ,"MEDIAMODE"        },
+    { LINECALLINFOSTATE_APPSPECIFIC     ,"APPSPECIFIC"      },
+    { LINECALLINFOSTATE_CALLID          ,"CALLID"           },
+    { LINECALLINFOSTATE_RELATEDCALLID   ,"RELATEDCALLID"    },
+    { LINECALLINFOSTATE_ORIGIN          ,"ORIGIN"           },
+    { LINECALLINFOSTATE_REASON          ,"REASON"           },
+    { LINECALLINFOSTATE_COMPLETIONID    ,"COMPLETIONID"     },
+    { LINECALLINFOSTATE_NUMOWNERINCR    ,"NUMOWNERINCR"     },
+    { LINECALLINFOSTATE_NUMOWNERDECR    ,"NUMOWNERDECR"     },
+    { LINECALLINFOSTATE_NUMMONITORS     ,"NUMMONITORS"      },
+    { LINECALLINFOSTATE_TRUNK           ,"TRUNK"            },
+    { LINECALLINFOSTATE_CALLERID        ,"CALLERID"         },
+    { LINECALLINFOSTATE_CALLEDID        ,"CALLEDID"         },
+    { LINECALLINFOSTATE_CONNECTEDID     ,"CONNECTEDID"      },
+    { LINECALLINFOSTATE_REDIRECTIONID   ,"REDIRECTIONID"    },
+    { LINECALLINFOSTATE_REDIRECTINGID   ,"REDIRECTINGID"    },
+    { LINECALLINFOSTATE_DISPLAY         ,"DISPLAY"          },
+    { LINECALLINFOSTATE_USERUSERINFO    ,"USERUSERINFO"     },
+    { LINECALLINFOSTATE_HIGHLEVELCOMP   ,"HIGHLEVELCOMP"    },
+    { LINECALLINFOSTATE_LOWLEVELCOMP    ,"LOWLEVELCOMP"     },
+    { LINECALLINFOSTATE_CHARGINGINFO    ,"CHARGINGINFO"     },
+    { LINECALLINFOSTATE_TERMINAL        ,"TERMINAL"         },
+    { LINECALLINFOSTATE_DIALPARAMS      ,"DIALPARAMS"       },
+    { LINECALLINFOSTATE_MONITORMODES    ,"MONITORMODES"     },
+#if TAPI_2_0
+    { LINECALLINFOSTATE_TREATMENT       ,"TREATMENT"        },
+    { LINECALLINFOSTATE_QOS             ,"QOS"              },
+    { LINECALLINFOSTATE_CALLDATA        ,"CALLDATA"         },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallOrigins[] =
+{
+    { LINECALLORIGIN_OUTBOUND           ,"OUTBOUND"         },
+    { LINECALLORIGIN_INTERNAL           ,"INTERNAL"         },
+    { LINECALLORIGIN_EXTERNAL           ,"EXTERNAL"         },
+    { LINECALLORIGIN_UNKNOWN            ,"UNKNOWN"          },
+    { LINECALLORIGIN_UNAVAIL            ,"UNAVAIL"          },
+    { LINECALLORIGIN_CONFERENCE         ,"CONFERENCE"       },
+#if TAPI_1_1
+    { LINECALLORIGIN_INBOUND            ,"INBOUND"          },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallParamFlags[] =
+{
+    { LINECALLPARAMFLAGS_SECURE         ,"SECURE"           },
+    { LINECALLPARAMFLAGS_IDLE           ,"IDLE"             },
+    { LINECALLPARAMFLAGS_BLOCKID        ,"BLOCKID"          },
+    { LINECALLPARAMFLAGS_ORIGOFFHOOK    ,"ORIGOFFHOOK"      },
+    { LINECALLPARAMFLAGS_DESTOFFHOOK    ,"DESTOFFHOOK"      },
+#if TAPI_2_0
+    { LINECALLPARAMFLAGS_NOHOLDCONFERENCE   ,"NOHOLDCONFERENCE" },
+    { LINECALLPARAMFLAGS_PREDICTIVEDIAL ,"PREDICTIVEDIAL"   },
+    { LINECALLPARAMFLAGS_ONESTEPTRANSFER,"ONESTEPTRANSFER"  },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallerIDFlags[] =
+{
+    { LINECALLPARTYID_BLOCKED           ,"BLOCKED"          },
+    { LINECALLPARTYID_OUTOFAREA         ,"OUTOFAREA"        },
+    { LINECALLPARTYID_NAME              ,"NAME"             },
+    { LINECALLPARTYID_ADDRESS           ,"ADDRESS"          },
+    { LINECALLPARTYID_PARTIAL           ,"PARTIAL"          },
+    { LINECALLPARTYID_UNKNOWN           ,"UNKNOWN"          },
+    { LINECALLPARTYID_UNAVAIL           ,"UNAVAIL"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallPrivileges[] =
+{
+    { LINECALLPRIVILEGE_NONE            ,"NONE"             },
+    { LINECALLPRIVILEGE_MONITOR         ,"MONITOR"          },
+    { LINECALLPRIVILEGE_OWNER           ,"OWNER"            },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallReasons[] =
+{
+    { LINECALLREASON_DIRECT             ,"DIRECT"           },
+    { LINECALLREASON_FWDBUSY            ,"FWDBUSY"          },
+    { LINECALLREASON_FWDNOANSWER        ,"FWDNOANSWER"      },
+    { LINECALLREASON_FWDUNCOND          ,"FWDUNCOND"        },
+    { LINECALLREASON_PICKUP             ,"PICKUP"           },
+    { LINECALLREASON_UNPARK             ,"UNPARK"           },
+    { LINECALLREASON_REDIRECT           ,"REDIRECT"         },
+    { LINECALLREASON_CALLCOMPLETION     ,"CALLCOMPLETION"   },
+    { LINECALLREASON_TRANSFER           ,"TRANSFER"         },
+    { LINECALLREASON_REMINDER           ,"REMINDER"         },
+    { LINECALLREASON_UNKNOWN            ,"UNKNOWN"          },
+    { LINECALLREASON_UNAVAIL            ,"UNAVAIL"          },
+#if TAPI_1_1
+    { LINECALLREASON_INTRUDE            ,"INTRUDE"          },
+    { LINECALLREASON_PARKED             ,"PARKED"           },
+#if TAPI_2_0
+    { LINECALLREASON_CAMPEDON           ,"CAMPEDON"         },
+    { LINECALLREASON_ROUTEREQUEST       ,"ROUTEREQUEST"     },
+#endif
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallSelects[] =
+{
+    { LINECALLSELECT_LINE               ,"LINE"             },
+    { LINECALLSELECT_ADDRESS            ,"ADDRESS"          },
+    { LINECALLSELECT_CALL               ,"CALL"             },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aCallStates[] =
+{
+    { LINECALLSTATE_IDLE                ,"IDLE"             },
+    { LINECALLSTATE_OFFERING            ,"OFFERING"         },
+    { LINECALLSTATE_ACCEPTED            ,"ACCEPTED"         },
+    { LINECALLSTATE_DIALTONE            ,"DIALTONE"         },
+    { LINECALLSTATE_DIALING             ,"DIALING"          },
+    { LINECALLSTATE_RINGBACK            ,"RINGBACK"         },
+    { LINECALLSTATE_BUSY                ,"BUSY"             },
+    { LINECALLSTATE_SPECIALINFO         ,"SPECIALINFO"      },
+    { LINECALLSTATE_CONNECTED           ,"CONNECTED"        },
+    { LINECALLSTATE_PROCEEDING          ,"PROCEEDING"       },
+    { LINECALLSTATE_ONHOLD              ,"ONHOLD"           },
+    { LINECALLSTATE_CONFERENCED         ,"CONFERENCED"      },
+    { LINECALLSTATE_ONHOLDPENDCONF      ,"ONHOLDPENDCONF"   },
+    { LINECALLSTATE_ONHOLDPENDTRANSFER  ,"ONHOLDPENDTRANSFER" },
+    { LINECALLSTATE_DISCONNECTED        ,"DISCONNECTED"     },
+    { LINECALLSTATE_UNKNOWN             ,"UNKNOWN"          },
+    { 0xffffffff                        ,""                 }
+};
+
+#if TAPI_2_0
+LOOKUP my_far aCallTreatments[] =
+{
+    { LINECALLTREATMENT_SILENCE         ,"SILENCE"          },
+    { LINECALLTREATMENT_RINGBACK        ,"RINGBACK"         },
+    { LINECALLTREATMENT_BUSY            ,"BUSY"             },
+    { LINECALLTREATMENT_MUSIC           ,"MUSIC"            },
+    { 0xffffffff                        ,""                 }
+};
+#endif
+
+LOOKUP my_far aCardOptions[] =
+{
+#if TAPI_1_1
+    { LINECARDOPTION_PREDEFINED         ,"PREDEFINED"       },
+    { LINECARDOPTION_HIDDEN             ,"HIDDEN"           },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aConnectedModes[] =
+{
+#if TAPI_1_1
+    { LINECONNECTEDMODE_ACTIVE          ,"ACTIVE"           },
+    { LINECONNECTEDMODE_INACTIVE        ,"INACTIVE"         },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aDevCapsFlags[] =
+{
+    { LINEDEVCAPFLAGS_CROSSADDRCONF     ,"CROSSADDRCONF"    },
+    { LINEDEVCAPFLAGS_HIGHLEVCOMP       ,"HIGHLEVCOMP"      },
+    { LINEDEVCAPFLAGS_LOWLEVCOMP        ,"LOWLEVCOMP"       },
+    { LINEDEVCAPFLAGS_MEDIACONTROL      ,"MEDIACONTROL"     },
+    { LINEDEVCAPFLAGS_MULTIPLEADDR      ,"MULTIPLEADDR"     },
+    { LINEDEVCAPFLAGS_CLOSEDROP         ,"CLOSEDROP"        },
+    { LINEDEVCAPFLAGS_DIALBILLING       ,"DIALBILLING"      },
+    { LINEDEVCAPFLAGS_DIALQUIET         ,"DIALQUIET"        },
+    { LINEDEVCAPFLAGS_DIALDIALTONE      ,"DIALDIALTONE"     },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aLineDevStatusFlags[] =
+{
+    { LINEDEVSTATUSFLAGS_CONNECTED      ,"CONNECTED"        },
+    { LINEDEVSTATUSFLAGS_MSGWAIT        ,"MSGWAIT"          },
+    { LINEDEVSTATUSFLAGS_INSERVICE      ,"INSERVICE"        },
+    { LINEDEVSTATUSFLAGS_LOCKED         ,"LOCKED"           },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aDialToneModes[] =
+{
+    { LINEDIALTONEMODE_NORMAL           ,"NORMAL"           },
+    { LINEDIALTONEMODE_SPECIAL          ,"SPECIAL"          },
+    { LINEDIALTONEMODE_INTERNAL         ,"INTERNAL"         },
+    { LINEDIALTONEMODE_EXTERNAL         ,"EXTERNAL"         },
+    { LINEDIALTONEMODE_UNKNOWN          ,"UNKNOWN"          },
+    { LINEDIALTONEMODE_UNAVAIL          ,"UNAVAIL"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aDigitModes[] =
+{
+    { LINEDIGITMODE_PULSE               ,"PULSE"            },
+    { LINEDIGITMODE_DTMF                ,"DTMF"             },
+    { LINEDIGITMODE_DTMFEND             ,"DTMFEND"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aDisconnectModes[] =
+{
+    { LINEDISCONNECTMODE_NORMAL         ,"NORMAL"           },
+    { LINEDISCONNECTMODE_UNKNOWN        ,"UNKNOWN"          },
+    { LINEDISCONNECTMODE_REJECT         ,"REJECT"           },
+    { LINEDISCONNECTMODE_PICKUP         ,"PICKUP"           },
+    { LINEDISCONNECTMODE_FORWARDED      ,"FORWARDED"        },
+    { LINEDISCONNECTMODE_BUSY           ,"BUSY"             },
+    { LINEDISCONNECTMODE_NOANSWER       ,"NOANSWER"         },
+    { LINEDISCONNECTMODE_BADADDRESS     ,"BADADDRESS"       },
+    { LINEDISCONNECTMODE_UNREACHABLE    ,"UNREACHABLE"      },
+    { LINEDISCONNECTMODE_CONGESTION     ,"CONGESTION"       },
+    { LINEDISCONNECTMODE_INCOMPATIBLE   ,"INCOMPATIBLE"     },
+    { LINEDISCONNECTMODE_UNAVAIL        ,"UNAVAIL"          },
+#if TAPI_1_1
+    { LINEDISCONNECTMODE_NODIALTONE     ,"NODIALTONE"       },
+#if TAPI_2_0
+    { LINEDISCONNECTMODE_NUMBERCHANGED  ,"NUMBERCHANGED"    },
+    { LINEDISCONNECTMODE_OUTOFORDER     ,"OUTOFORDER"       },
+    { LINEDISCONNECTMODE_TEMPFAILURE    ,"TEMPFAILURE"      },
+    { LINEDISCONNECTMODE_QOSUNAVAIL     ,"QOSUNAVAIL"       },
+    { LINEDISCONNECTMODE_BLOCKED        ,"BLOCKED"          },
+    { LINEDISCONNECTMODE_DONOTDISTURB   ,"DONOTDISTURB"     },
+#endif
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+#if TAPI_2_0
+LOOKUP my_far aInitExOptions[] =
+{
+    { LINEINITIALIZEEXOPTION_USEHIDDENWINDOW
+                                        ,"USEHIDDENWINDOW"  },
+    { LINEINITIALIZEEXOPTION_USEEVENT   ,"USEEVENT"         },
+    { LINEINITIALIZEEXOPTION_USECOMPLETIONPORT
+                                        ,"USECOMPLETIONPORT"},
+    { 0xffffffff                        ,""                 }
+};
+#endif
+
+LOOKUP my_far aLineFeatures[] =
+{
+    { LINEFEATURE_DEVSPECIFIC           ,"DEVSPECIFIC"      },
+    { LINEFEATURE_DEVSPECIFICFEAT       ,"DEVSPECIFICFEAT"  },
+    { LINEFEATURE_FORWARD               ,"FORWARD"          },
+    { LINEFEATURE_MAKECALL              ,"MAKECALL"         },
+    { LINEFEATURE_SETMEDIACONTROL       ,"SETMEDIACONTROL"  },
+    { LINEFEATURE_SETTERMINAL           ,"SETTERMINAL"      },
+#if TAPI_2_0
+    { LINEFEATURE_SETDEVSTATUS          ,"SETDEVSTATUS"     },
+    { LINEFEATURE_FORWARDFWD            ,"FORWARDFWD"       },
+    { LINEFEATURE_FORWARDDND            ,"FORWARDDND"       },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aForwardModes[] =
+{
+    { LINEFORWARDMODE_UNCOND            ,"UNCOND"           },
+    { LINEFORWARDMODE_UNCONDINTERNAL    ,"UNCONDINTERNAL"   },
+    { LINEFORWARDMODE_UNCONDEXTERNAL    ,"UNCONDEXTERNAL"   },
+    { LINEFORWARDMODE_UNCONDSPECIFIC    ,"UNCONDSPECIFIC"   },
+    { LINEFORWARDMODE_BUSY              ,"BUSY"             },
+    { LINEFORWARDMODE_BUSYINTERNAL      ,"BUSYINTERNAL"     },
+    { LINEFORWARDMODE_BUSYEXTERNAL      ,"BUSYEXTERNAL"     },
+    { LINEFORWARDMODE_BUSYSPECIFIC      ,"BUSYSPECIFIC"     },
+    { LINEFORWARDMODE_NOANSW            ,"NOANSW"           },
+    { LINEFORWARDMODE_NOANSWINTERNAL    ,"NOANSWINTERNAL"   },
+    { LINEFORWARDMODE_NOANSWEXTERNAL    ,"NOANSWEXTERNAL"   },
+    { LINEFORWARDMODE_NOANSWSPECIFIC    ,"NOANSWSPECIFIC"   },
+    { LINEFORWARDMODE_BUSYNA            ,"BUSYNA"           },
+    { LINEFORWARDMODE_BUSYNAINTERNAL    ,"BUSYNAINTERNAL"   },
+    { LINEFORWARDMODE_BUSYNAEXTERNAL    ,"BUSYNAEXTERNAL"   },
+    { LINEFORWARDMODE_BUSYNASPECIFIC    ,"BUSYNASPECIFIC"   },
+#if TAPI_1_1
+    { LINEFORWARDMODE_UNKNOWN           ,"UNKNOWN"          },
+    { LINEFORWARDMODE_UNAVAIL           ,"UNAVAIL"          },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aGatherTerms[] =
+{
+    { LINEGATHERTERM_BUFFERFULL         ,"BUFFERFULL"       },
+    { LINEGATHERTERM_TERMDIGIT          ,"TERMDIGIT"        },
+    { LINEGATHERTERM_FIRSTTIMEOUT       ,"FIRSTTIMEOUT"     },
+    { LINEGATHERTERM_INTERTIMEOUT       ,"INTERTIMEOUT"     },
+    { LINEGATHERTERM_CANCEL             ,"CANCEL"           },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aGenerateTerms[] =
+{
+    { LINEGENERATETERM_DONE             ,"DONE"             },
+    { LINEGENERATETERM_CANCEL           ,"CANCEL"           },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP aLineOpenOptions[] =
+{
+    { LINECALLPRIVILEGE_NONE            ,"NONE"             },
+    { LINECALLPRIVILEGE_MONITOR         ,"MONITOR"          },
+    { LINECALLPRIVILEGE_OWNER           ,"OWNER"            },
+    { LINEOPENOPTION_PROXY              ,"PROXY"            },
+    { LINEOPENOPTION_SINGLEADDRESS      ,"SINGLEADDRESS"    },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aLineRoamModes[] =
+{
+    { LINEROAMMODE_UNKNOWN              ,"UNKNOWN"          },
+    { LINEROAMMODE_UNAVAIL              ,"UNAVAIL"          },
+    { LINEROAMMODE_HOME                 ,"HOME"             },
+    { LINEROAMMODE_ROAMA                ,"ROAMA"            },
+    { LINEROAMMODE_ROAMB                ,"ROAMB"            },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aLineStates[] =
+{
+    { LINEDEVSTATE_OTHER                ,"OTHER"            },
+    { LINEDEVSTATE_RINGING              ,"RINGING"          },
+    { LINEDEVSTATE_CONNECTED            ,"CONNECTED"        },
+    { LINEDEVSTATE_DISCONNECTED         ,"DISCONNECTED"     },
+    { LINEDEVSTATE_MSGWAITON            ,"MSGWAITON"        },
+    { LINEDEVSTATE_MSGWAITOFF           ,"MSGWAITOFF"       },
+    { LINEDEVSTATE_INSERVICE            ,"INSERVICE"        },
+    { LINEDEVSTATE_OUTOFSERVICE         ,"OUTOFSERVICE"     },
+    { LINEDEVSTATE_MAINTENANCE          ,"MAINTENANCE"      },
+    { LINEDEVSTATE_OPEN                 ,"OPEN"             },
+    { LINEDEVSTATE_CLOSE                ,"CLOSE"            },
+    { LINEDEVSTATE_NUMCALLS             ,"NUMCALLS"         },
+    { LINEDEVSTATE_NUMCOMPLETIONS       ,"NUMCOMPLETIONS"   },
+    { LINEDEVSTATE_TERMINALS            ,"TERMINALS"        },
+    { LINEDEVSTATE_ROAMMODE             ,"ROAMMODE"         },
+    { LINEDEVSTATE_BATTERY              ,"BATTERY"          },
+    { LINEDEVSTATE_SIGNAL               ,"SIGNAL"           },
+    { LINEDEVSTATE_DEVSPECIFIC          ,"DEVSPECIFIC"      },
+    { LINEDEVSTATE_REINIT               ,"REINIT"           },
+    { LINEDEVSTATE_LOCK                 ,"LOCK"             },
+#if TAPI_1_1
+    { LINEDEVSTATE_CAPSCHANGE           ,"CAPSCHANGE"       },
+    { LINEDEVSTATE_CONFIGCHANGE         ,"CONFIGCHANGE"     },
+    { LINEDEVSTATE_TRANSLATECHANGE      ,"TRANSLATECHANGE"  },
+    { LINEDEVSTATE_COMPLCANCEL          ,"COMPLCANCEL"      },
+    { LINEDEVSTATE_REMOVED              ,"REMOVED"          },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aLocationOptions[] =
+{
+#if TAPI_1_1
+    { LINELOCATIONOPTION_PULSEDIAL      ,"PULSEDIAL"        },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aMediaModes[] =
+{
+    { LINEMEDIAMODE_UNKNOWN             ,"UNKNOWN"          },
+    { LINEMEDIAMODE_INTERACTIVEVOICE    ,"INTERACTIVEVOICE" },
+    { LINEMEDIAMODE_AUTOMATEDVOICE      ,"AUTOMATEDVOICE"   },
+    { LINEMEDIAMODE_DATAMODEM           ,"DATAMODEM"        },
+    { LINEMEDIAMODE_G3FAX               ,"G3FAX"            },
+    { LINEMEDIAMODE_TDD                 ,"TDD"              },
+    { LINEMEDIAMODE_G4FAX               ,"G4FAX"            },
+    { LINEMEDIAMODE_DIGITALDATA         ,"DIGITALDATA"      },
+    { LINEMEDIAMODE_TELETEX             ,"TELETEX"          },
+    { LINEMEDIAMODE_VIDEOTEX            ,"VIDEOTEX"         },
+    { LINEMEDIAMODE_TELEX               ,"TELEX"            },
+    { LINEMEDIAMODE_MIXED               ,"MIXED"            },
+    { LINEMEDIAMODE_ADSI                ,"ADSI"             },
+#if TAPI_1_1
+    { LINEMEDIAMODE_VOICEVIEW           ,"VOICEVIEW"        },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aMediaControls[] =
+{
+    { LINEMEDIACONTROL_NONE             ,"NONE"             },
+    { LINEMEDIACONTROL_START            ,"START"            },
+    { LINEMEDIACONTROL_RESET            ,"RESET"            },
+    { LINEMEDIACONTROL_PAUSE            ,"PAUSE"            },
+    { LINEMEDIACONTROL_RESUME           ,"RESUME"           },
+    { LINEMEDIACONTROL_RATEUP           ,"RATEUP"           },
+    { LINEMEDIACONTROL_RATEDOWN         ,"RATEDOWN"         },
+    { LINEMEDIACONTROL_RATENORMAL       ,"RATENORMAL"       },
+    { LINEMEDIACONTROL_VOLUMEUP         ,"VOLUMEUP"         },
+    { LINEMEDIACONTROL_VOLUMEDOWN       ,"VOLUMEDOWN"       },
+    { LINEMEDIACONTROL_VOLUMENORMAL     ,"VOLUMENORMAL"     },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aOfferingModes[] =
+{
+#if TAPI_1_1
+    { LINEOFFERINGMODE_ACTIVE           ,"ACTIVE"           },
+    { LINEOFFERINGMODE_INACTIVE         ,"INACTIVE"         },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aParkModes[] =
+{
+    { LINEPARKMODE_DIRECTED             ,"DIRECTED"         },
+    { LINEPARKMODE_NONDIRECTED          ,"NONDIRECTED"      },
+    { 0xffffffff                        ,""                 }
+};
+
+#if TAPI_2_0
+LOOKUP my_far aProxyRequests[] =
+{
+    { LINEPROXYREQUEST_SETAGENTGROUP        ,"SETAGENTGROUP"        },
+    { LINEPROXYREQUEST_SETAGENTSTATE        ,"SETAGENTSTATE"        },
+    { LINEPROXYREQUEST_SETAGENTACTIVITY     ,"SETAGENTACTIVITY"     },
+    { LINEPROXYREQUEST_GETAGENTCAPS         ,"GETAGENTCAPS"         },
+    { LINEPROXYREQUEST_GETAGENTSTATUS       ,"GETAGENTSTATUS"       },
+    { LINEPROXYREQUEST_AGENTSPECIFIC        ,"AGENTSPECIFIC"        },
+    { LINEPROXYREQUEST_GETAGENTACTIVITYLIST ,"GETAGENTACTIVITYLIST" },
+    { LINEPROXYREQUEST_GETAGENTGROUPLIST    ,"GETAGENTGROUPLIST"    },
+    { 0xffffffff                            ,""                     }
+};
+#endif
+
+LOOKUP my_far aRemoveFromConfCaps[] =
+{
+    { LINEREMOVEFROMCONF_NONE           ,"NONE"             },
+    { LINEREMOVEFROMCONF_LAST           ,"LAST"             },
+    { LINEREMOVEFROMCONF_ANY            ,"ANY"              },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aRequestModes[] =
+{
+    { LINEREQUESTMODE_MAKECALL          ,"MAKECALL"         },
+    { LINEREQUESTMODE_MEDIACALL         ,"MEDIACALL"        },
+    { LINEREQUESTMODE_DROP              ,"DROP"             },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aRequestModes2[] =
+{
+    { LINEREQUESTMODE_MAKECALL          ,"MAKECALL"         },
+    { LINEREQUESTMODE_MEDIACALL         ,"MEDIACALL"        },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aSpecialInfo[] =
+{
+    { LINESPECIALINFO_NOCIRCUIT         ,"NOCIRCUIT"        },
+    { LINESPECIALINFO_CUSTIRREG         ,"CUSTIRREG"        },
+    { LINESPECIALINFO_REORDER           ,"REORDER"          },
+    { LINESPECIALINFO_UNKNOWN           ,"UNKNOWN"          },
+    { LINESPECIALINFO_UNAVAIL           ,"UNAVAIL"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aTerminalModes[] =
+{
+    { LINETERMMODE_BUTTONS              ,"BUTTONS"          },
+    { LINETERMMODE_LAMPS                ,"LAMPS"            },
+    { LINETERMMODE_DISPLAY              ,"DISPLAY"          },
+    { LINETERMMODE_RINGER               ,"RINGER"           },
+    { LINETERMMODE_HOOKSWITCH           ,"HOOKSWITCH"       },
+    { LINETERMMODE_MEDIATOLINE          ,"MEDIATOLINE"      },
+    { LINETERMMODE_MEDIAFROMLINE        ,"MEDIAFROMLINE"    },
+    { LINETERMMODE_MEDIABIDIRECT        ,"MEDIABIDIRECT"    },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aTollListOptions[] =
+{
+    { LINETOLLLISTOPTION_ADD            ,"ADD"              },
+    { LINETOLLLISTOPTION_REMOVE         ,"REMOVE"           },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aToneModes[] =
+{
+    { LINETONEMODE_CUSTOM               ,"CUSTOM"           },
+    { LINETONEMODE_RINGBACK             ,"RINGBACK"         },
+    { LINETONEMODE_BUSY                 ,"BUSY"             },
+    { LINETONEMODE_BEEP                 ,"BEEP"             },
+    { LINETONEMODE_BILLING              ,"BILLING"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aTransferModes[] =
+{
+    { LINETRANSFERMODE_TRANSFER         ,"TRANSFER"         },
+    { LINETRANSFERMODE_CONFERENCE       ,"CONFERENCE"       },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aTranslateOptions[] =
+{
+    { LINETRANSLATEOPTION_CARDOVERRIDE  ,"CARDOVERRIDE"     },
+#if TAPI_1_1
+    { LINETRANSLATEOPTION_CANCELCALLWAITING ,"CANCELCALLWAITING" },
+    { LINETRANSLATEOPTION_FORCELOCAL    ,"FORCELOCAL" },
+    { LINETRANSLATEOPTION_FORCELD       ,"FORCELD" },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aTranslateResults[] =
+{
+    { LINETRANSLATERESULT_CANONICAL     ,"CANONICAL"        },
+    { LINETRANSLATERESULT_INTERNATIONAL ,"INTERNATIONAL"    },
+    { LINETRANSLATERESULT_LONGDISTANCE  ,"LONGDISTANCE"     },
+    { LINETRANSLATERESULT_LOCAL         ,"LOCAL"            },
+    { LINETRANSLATERESULT_INTOLLLIST    ,"INTOLLLIST"       },
+    { LINETRANSLATERESULT_NOTINTOLLLIST ,"NOTINTOLLLIST"    },
+    { LINETRANSLATERESULT_DIALBILLING   ,"DIALBILLING"      },
+    { LINETRANSLATERESULT_DIALQUIET     ,"DIALQUIET"        },
+    { LINETRANSLATERESULT_DIALDIALTONE  ,"DIALDIALTONE"     },
+    { LINETRANSLATERESULT_DIALPROMPT    ,"DIALPROMPT"       },
+#if TAPI_2_0
+    { LINETRANSLATERESULT_VOICEDETECT   ,"VOICEDETECT"      },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aButtonFunctions[] =
+{
+    { PHONEBUTTONFUNCTION_UNKNOWN       ,"UNKNOWN"          },
+    { PHONEBUTTONFUNCTION_CONFERENCE    ,"CONFERENCE"       },
+    { PHONEBUTTONFUNCTION_TRANSFER      ,"TRANSFER"         },
+    { PHONEBUTTONFUNCTION_DROP          ,"DROP"             },
+    { PHONEBUTTONFUNCTION_HOLD          ,"HOLD"             },
+    { PHONEBUTTONFUNCTION_RECALL        ,"RECALL"           },
+    { PHONEBUTTONFUNCTION_DISCONNECT    ,"DISCONNECT"       },
+    { PHONEBUTTONFUNCTION_CONNECT       ,"CONNECT"          },
+    { PHONEBUTTONFUNCTION_MSGWAITON     ,"MSGWAITON"        },
+    { PHONEBUTTONFUNCTION_MSGWAITOFF    ,"MSGWAITOFF"       },
+    { PHONEBUTTONFUNCTION_SELECTRING    ,"SELECTRING"       },
+    { PHONEBUTTONFUNCTION_ABBREVDIAL    ,"ABBREVDIAL"       },
+    { PHONEBUTTONFUNCTION_FORWARD       ,"FORWARD"          },
+    { PHONEBUTTONFUNCTION_PICKUP        ,"PICKUP"           },
+    { PHONEBUTTONFUNCTION_RINGAGAIN     ,"RINGAGAIN"        },
+    { PHONEBUTTONFUNCTION_PARK          ,"PARK"             },
+    { PHONEBUTTONFUNCTION_REJECT        ,"REJECT"           },
+    { PHONEBUTTONFUNCTION_REDIRECT      ,"REDIRECT"         },
+    { PHONEBUTTONFUNCTION_MUTE          ,"MUTE"             },
+    { PHONEBUTTONFUNCTION_VOLUMEUP      ,"VOLUMEUP"         },
+    { PHONEBUTTONFUNCTION_VOLUMEDOWN    ,"VOLUMEDOWN"       },
+    { PHONEBUTTONFUNCTION_SPEAKERON     ,"SPEAKERON"        },
+    { PHONEBUTTONFUNCTION_SPEAKEROFF    ,"SPEAKEROFF"       },
+    { PHONEBUTTONFUNCTION_FLASH         ,"FLASH"            },
+    { PHONEBUTTONFUNCTION_DATAON        ,"DATAON"           },
+    { PHONEBUTTONFUNCTION_DATAOFF       ,"DATAOFF"          },
+    { PHONEBUTTONFUNCTION_DONOTDISTURB  ,"DONOTDISTURB"     },
+    { PHONEBUTTONFUNCTION_INTERCOM      ,"INTERCOM"         },
+    { PHONEBUTTONFUNCTION_BRIDGEDAPP    ,"BRIDGEDAPP"       },
+    { PHONEBUTTONFUNCTION_BUSY          ,"BUSY"             },
+    { PHONEBUTTONFUNCTION_CALLAPP       ,"CALLAPP"          },
+    { PHONEBUTTONFUNCTION_DATETIME      ,"DATETIME"         },
+    { PHONEBUTTONFUNCTION_DIRECTORY     ,"DIRECTORY"        },
+    { PHONEBUTTONFUNCTION_COVER         ,"COVER"            },
+    { PHONEBUTTONFUNCTION_CALLID        ,"CALLID"           },
+    { PHONEBUTTONFUNCTION_LASTNUM       ,"LASTNUM"          },
+    { PHONEBUTTONFUNCTION_NIGHTSRV      ,"NIGHTSRV"         },
+    { PHONEBUTTONFUNCTION_SENDCALLS     ,"SENDCALLS"        },
+    { PHONEBUTTONFUNCTION_MSGINDICATOR  ,"MSGINDICATOR"     },
+    { PHONEBUTTONFUNCTION_REPDIAL       ,"REPDIAL"          },
+    { PHONEBUTTONFUNCTION_SETREPDIAL    ,"SETREPDIAL"       },
+    { PHONEBUTTONFUNCTION_SYSTEMSPEED   ,"SYSTEMSPEED"      },
+    { PHONEBUTTONFUNCTION_STATIONSPEED  ,"STATIONSPEED"     },
+    { PHONEBUTTONFUNCTION_CAMPON        ,"CAMPON"           },
+    { PHONEBUTTONFUNCTION_SAVEREPEAT    ,"SAVEREPEAT"       },
+    { PHONEBUTTONFUNCTION_QUEUECALL     ,"QUEUECALL"        },
+    { PHONEBUTTONFUNCTION_NONE          ,"NONE"             },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aButtonModes[] =
+{
+    { PHONEBUTTONMODE_DUMMY             ,"DUMMY"            },
+    { PHONEBUTTONMODE_CALL              ,"CALL"             },
+    { PHONEBUTTONMODE_FEATURE           ,"FEATURE"          },
+    { PHONEBUTTONMODE_KEYPAD            ,"KEYPAD"           },
+    { PHONEBUTTONMODE_LOCAL             ,"LOCAL"            },
+    { PHONEBUTTONMODE_DISPLAY           ,"DISPLAY"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aButtonStates[] =
+{
+    { PHONEBUTTONSTATE_UP               ,"UP"               },
+    { PHONEBUTTONSTATE_DOWN             ,"DOWN"             },
+#if TAPI_1_1
+    { PHONEBUTTONSTATE_UNKNOWN          ,"UNKNOWN"          },
+    { PHONEBUTTONSTATE_UNAVAIL          ,"UNAVAIL"          },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+#if TAPI_2_0
+LOOKUP my_far aPhoneFeatures[] =
+{
+    { PHONEFEATURE_GETBUTTONINFO        ,"GETBUTTONINFO"    },
+    { PHONEFEATURE_GETDATA              ,"GETDATA"          },
+    { PHONEFEATURE_GETDISPLAY           ,"GETDISPLAY"       },
+    { PHONEFEATURE_GETGAINHANDSET       ,"GETGAINHANDSET"   },
+    { PHONEFEATURE_GETGAINSPEAKER       ,"GETGAINSPEAKER"   },
+    { PHONEFEATURE_GETGAINHEADSET       ,"GETGAINHEADSET"   },
+    { PHONEFEATURE_GETHOOKSWITCHHANDSET ,"GETHOOKSWITCHHANDSET" },
+    { PHONEFEATURE_GETHOOKSWITCHSPEAKER ,"GETHOOKSWITCHSPEAKER" },
+    { PHONEFEATURE_GETHOOKSWITCHHEADSET ,"GETHOOKSWITCHHEADSET" },
+    { PHONEFEATURE_GETLAMP              ,"GETLAMP"          },
+    { PHONEFEATURE_GETRING              ,"GETRING"          },
+    { PHONEFEATURE_GETVOLUMEHANDSET     ,"GETVOLUMEHANDSET" },
+    { PHONEFEATURE_GETVOLUMESPEAKER     ,"GETVOLUMESPEAKER" },
+    { PHONEFEATURE_GETVOLUMEHEADSET     ,"GETVOLUMEHEADSET" },
+    { PHONEFEATURE_SETBUTTONINFO        ,"SETBUTTONINFO"    },
+    { PHONEFEATURE_SETDATA              ,"SETDATA"          },
+    { PHONEFEATURE_SETDISPLAY           ,"SETDISPLAY"       },
+    { PHONEFEATURE_SETGAINHANDSET       ,"SETGAINHANDSET"   },
+    { PHONEFEATURE_SETGAINSPEAKER       ,"SETGAINSPEAKER"   },
+    { PHONEFEATURE_SETGAINHEADSET       ,"SETGAINHEADSET"   },
+    { PHONEFEATURE_SETHOOKSWITCHHANDSET ,"SETHOOKSWITCHHANDSET" },
+    { PHONEFEATURE_SETHOOKSWITCHSPEAKER ,"SETHOOKSWITCHSPEAKER" },
+    { PHONEFEATURE_SETHOOKSWITCHHEADSET ,"SETHOOKSWITCHHEADSET" },
+    { PHONEFEATURE_SETLAMP              ,"SETLAMP"          },
+    { PHONEFEATURE_SETRING              ,"SETRING"          },
+    { PHONEFEATURE_SETVOLUMEHANDSET     ,"SETVOLUMEHANDSET" },
+    { PHONEFEATURE_SETVOLUMESPEAKER     ,"SETVOLUMESPEAKER" },
+    { PHONEFEATURE_SETVOLUMEHEADSET     ,"SETVOLUMEHEADSET" },
+    { 0xffffffff                        ,""                 }
+};
+#endif
+
+LOOKUP my_far aHookSwitchDevs[] =
+{
+    { PHONEHOOKSWITCHDEV_HANDSET        ,"HANDSET"          },
+    { PHONEHOOKSWITCHDEV_SPEAKER        ,"SPEAKER"          },
+    { PHONEHOOKSWITCHDEV_HEADSET        ,"HEADSET"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aHookSwitchModes[] =
+{
+    { PHONEHOOKSWITCHMODE_ONHOOK        ,"ONHOOK"           },
+    { PHONEHOOKSWITCHMODE_MIC           ,"MIC"              },
+    { PHONEHOOKSWITCHMODE_SPEAKER       ,"SPEAKER"          },
+    { PHONEHOOKSWITCHMODE_MICSPEAKER    ,"MICSPEAKER"       },
+    { PHONEHOOKSWITCHMODE_UNKNOWN       ,"UNKNOWN"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aLampModes[] =
+{
+    { PHONELAMPMODE_DUMMY               ,"DUMMY"            },
+    { PHONELAMPMODE_OFF                 ,"OFF"              },
+    { PHONELAMPMODE_STEADY              ,"STEADY"           },
+    { PHONELAMPMODE_WINK                ,"WINK"             },
+    { PHONELAMPMODE_FLASH               ,"FLASH"            },
+    { PHONELAMPMODE_FLUTTER             ,"FLUTTER"          },
+    { PHONELAMPMODE_BROKENFLUTTER       ,"BROKENFLUTTER"    },
+    { PHONELAMPMODE_UNKNOWN             ,"UNKNOWN"          },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aPhonePrivileges[] =
+{
+    { PHONEPRIVILEGE_MONITOR            ,"MONITOR"          },
+    { PHONEPRIVILEGE_OWNER              ,"OWNER"            },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aPhoneStates[] =
+{
+    { PHONESTATE_OTHER                  ,"OTHER"            },
+    { PHONESTATE_CONNECTED              ,"CONNECTED"        },
+    { PHONESTATE_DISCONNECTED           ,"DISCONNECTED"     },
+    { PHONESTATE_OWNER                  ,"OWNER"            },
+    { PHONESTATE_MONITORS               ,"MONITORS"         },
+    { PHONESTATE_DISPLAY                ,"DISPLAY"          },
+    { PHONESTATE_LAMP                   ,"LAMP"             },
+    { PHONESTATE_RINGMODE               ,"RINGMODE"         },
+    { PHONESTATE_RINGVOLUME             ,"RINGVOLUME"       },
+    { PHONESTATE_HANDSETHOOKSWITCH      ,"HANDSETHOOKSWITCH"},
+    { PHONESTATE_HANDSETVOLUME          ,"HANDSETVOLUME"    },
+    { PHONESTATE_HANDSETGAIN            ,"HANDSETGAIN"      },
+    { PHONESTATE_SPEAKERHOOKSWITCH      ,"SPEAKERHOOKSWITCH"},
+    { PHONESTATE_SPEAKERVOLUME          ,"SPEAKERVOLUME"    },
+    { PHONESTATE_SPEAKERGAIN            ,"SPEAKERGAIN"      },
+    { PHONESTATE_HEADSETHOOKSWITCH      ,"HEADSETHOOKSWITCH"},
+    { PHONESTATE_HEADSETVOLUME          ,"HEADSETVOLUME"    },
+    { PHONESTATE_HEADSETGAIN            ,"HEADSETGAIN"      },
+    { PHONESTATE_SUSPEND                ,"SUSPEND"          },
+    { PHONESTATE_RESUME                 ,"RESUME"           },
+    { PHONESTATE_DEVSPECIFIC            ,"DEVSPECIFIC"      },
+    { PHONESTATE_REINIT                 ,"REINIT"           },
+#if TAPI_1_1
+    { PHONESTATE_CAPSCHANGE             ,"CAPSCHANGE"       },
+    { PHONESTATE_REMOVED                ,"REMOVED"          },
+#endif
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aPhoneStatusFlags[] =
+{
+    { PHONESTATUSFLAGS_CONNECTED        ,"CONNECTED"        },
+    { PHONESTATUSFLAGS_SUSPENDED        ,"SUSPENDED"        },
+    { 0xffffffff                        ,""                 }
+};
+
+LOOKUP my_far aStringFormats[] =
+{
+    { STRINGFORMAT_ASCII                ,"ASCII"            },
+    { STRINGFORMAT_DBCS                 ,"DBCS"             },
+    { STRINGFORMAT_UNICODE              ,"UNICODE"          },
+    { STRINGFORMAT_BINARY               ,"BINARY"           },
+    { 0xffffffff                        ,""                 }
+};
+
+
+char *aszLineErrs[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "BEARERMODEUNAVAIL",
+    "inval err code (0x80000004)",      // 0x80000004 isn't valid err code
+    "CALLUNAVAIL",
+    "COMPLETIONOVERRUN",
+    "CONFERENCEFULL",
+    "DIALBILLING",
+    "DIALDIALTONE",
+    "DIALPROMPT",
+    "DIALQUIET",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALADDRESS",                     // 0x80000010
+    "INVALADDRESSID",
+    "INVALADDRESSMODE",
+    "INVALADDRESSSTATE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBEARERMODE",
+    "INVALCALLCOMPLMODE",
+    "INVALCALLHANDLE",
+    "INVALCALLPARAMS",
+    "INVALCALLPRIVILEGE",
+    "INVALCALLSELECT",
+    "INVALCALLSTATE",
+    "INVALCALLSTATELIST",
+    "INVALCARD",
+    "INVALCOMPLETIONID",
+    "INVALCONFCALLHANDLE",              // 0x80000020
+    "INVALCONSULTCALLHANDLE",
+    "INVALCOUNTRYCODE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEHANDLE",
+    "INVALDIALPARAMS",
+    "INVALDIGITLIST",
+    "INVALDIGITMODE",
+    "INVALDIGITS",
+    "INVALEXTVERSION",
+    "INVALGROUPID",
+    "INVALLINEHANDLE",
+    "INVALLINESTATE",
+    "INVALLOCATION",
+    "INVALMEDIALIST",
+    "INVALMEDIAMODE",
+    "INVALMESSAGEID",                   // 0x80000030
+    "inval err code (0x80000031)",      // 0x80000031 isn't valid err code
+    "INVALPARAM",
+    "INVALPARKID",
+    "INVALPARKMODE",
+    "INVALPOINTER",
+    "INVALPRIVSELECT",
+    "INVALRATE",
+    "INVALREQUESTMODE",
+    "INVALTERMINALID",
+    "INVALTERMINALMODE",
+    "INVALTIMEOUT",
+    "INVALTONE",
+    "INVALTONELIST",
+    "INVALTONEMODE",
+    "INVALTRANSFERMODE",
+    "LINEMAPPERFAILED",                 // 0x80000040
+    "NOCONFERENCE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOREQUEST",
+    "NOTOWNER",
+    "NOTREGISTERED",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "RATEUNAVAIL",
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",
+    "STRUCTURETOOSMALL",
+    "TARGETNOTFOUND",
+    "TARGETSELF",
+    "UNINITIALIZED",                    // 0x80000050
+    "USERUSERINFOTOOBIG",
+    "REINIT",
+    "ADDRESSBLOCKED",
+    "BILLINGREJECTED",
+    "INVALFEATURE",
+    "NOMULTIPLEINSTANCE"
+
+#if TAPI_2_0
+    ,
+    "INVALAGENTID",
+    "INVALAGENTGROUP",
+    "INVALPASSWORD",
+    "INVALAGENTSTATE",
+    "INVALAGENTACTIVITY",
+    "DIALVOICEDETECT"
+#endif
+};
+
+char *aszPhoneErrs[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBUTTONLAMPID",
+    "INVALBUTTONMODE",
+    "INVALBUTTONSTATE",
+    "INVALDATAID",
+    "INVALDEVICECLASS",
+    "INVALEXTVERSION",
+    "INVALHOOKSWITCHDEV",
+    "INVALHOOKSWITCHMODE",              // 0x90000010
+    "INVALLAMPMODE",
+    "INVALPARAM",
+    "INVALPHONEHANDLE",
+    "INVALPHONESTATE",
+    "INVALPOINTER",
+    "INVALPRIVILEGE",
+    "INVALRINGMODE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOTOWNER",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "inval err code (0x9000001E)",      // 0x9000001e isn't valid err code
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",                   // 0x90000020
+    "STRUCTURETOOSMALL",
+    "UNINITIALIZED",
+    "REINIT"
+};
+
+char *aszTapiErrs[] =
+{
+    "SUCCESS",
+    "DROPPED",
+    "NOREQUESTRECIPIENT",
+    "REQUESTQUEUEFULL",
+    "INVALDESTADDRESS",
+    "INVALWINDOWHANDLE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEID",
+    "DEVICECLASSUNAVAIL",
+    "DEVICEIDUNAVAIL",
+    "DEVICEINUSE",
+    "DESTBUSY",
+    "DESTNOANSWER",
+    "DESTUNAVAIL",
+    "UNKNOWNWINHANDLE",
+    "UNKNOWNREQUESTID",
+    "REQUESTFAILED",
+    "REQUESTCANCELLED",
+    "INVALPOINTER"
+};
+
+char *aFuncNames[] =
+{
+    "lineAccept",
+#if TAPI_1_1
+    "lineAddProvider",
+#if TAPI_2_0
+    "lineAddProviderW",
+#endif
+#endif
+    "lineAddToConference",
+#if TAPI_2_0
+    "lineAgentSpecific",
+#endif
+    "lineAnswer",
+    "lineBlindTransfer",
+#if TAPI_2_0
+    "lineBlindTransferW",
+#endif
+    "lineClose",
+    "lineCompleteCall",
+    "lineCompleteTransfer",
+    "lineConfigDialog",
+#if TAPI_2_0
+    "lineConfigDialogW",
+#endif
+#if TAPI_1_1
+    "lineConfigDialogEdit",
+#if TAPI_2_0
+    "lineConfigDialogEditW",
+#endif
+    "lineConfigProvider",
+#endif
+    "lineDeallocateCall",
+    "lineDevSpecific",
+    "lineDevSpecificFeature",
+    "lineDial",
+#if TAPI_2_0
+    "lineDialW",
+#endif
+    "lineDrop",
+    "lineForward",
+#if TAPI_2_0
+    "lineForwardW",
+#endif
+    "lineGatherDigits",
+#if TAPI_2_0
+    "lineGatherDigitsW",
+#endif
+    "lineGenerateDigits",
+#if TAPI_2_0
+    "lineGenerateDigitsW",
+#endif
+    "lineGenerateTone",
+    "lineGetAddressCaps",
+#if TAPI_2_0
+    "lineGetAddressCapsW",
+#endif
+    "lineGetAddressID",
+#if TAPI_2_0
+    "lineGetAddressIDW",
+#endif
+    "lineGetAddressStatus",
+#if TAPI_2_0
+    "lineGetAddressStatusW",
+#endif
+#if TAPI_2_0
+    "lineGetAgentActivityList",
+    "lineGetAgentActivityListW",
+    "lineGetAgentCaps",
+    "lineGetAgentGroupList",
+    "lineGetAgentStatus",
+#endif
+#if TAPI_1_1
+    "lineGetAppPriority",
+#if TAPI_2_0
+    "lineGetAppPriorityW",
+#endif
+#endif
+    "lineGetCallInfo",
+#if TAPI_2_0
+    "lineGetCallInfoW",
+#endif
+    "lineGetCallStatus",
+    "lineGetConfRelatedCalls",
+#if TAPI_1_1
+    "lineGetCountry",
+#if TAPI_2_0
+    "lineGetCountryW",
+#endif
+#endif
+    "lineGetDevCaps",
+#if TAPI_2_0
+    "lineGetDevCapsW",
+#endif
+    "lineGetDevConfig",
+#if TAPI_2_0
+    "lineGetDevConfigW",
+#endif
+    "lineGetIcon",
+#if TAPI_2_0
+    "lineGetIconW",
+#endif
+    "lineGetID",
+#if TAPI_2_0
+    "lineGetIDW",
+#endif
+    "lineGetLineDevStatus",
+#if TAPI_2_0
+    "lineGetLineDevStatusW",
+    "lineGetMessage",
+#endif
+    "lineGetNewCalls",
+    "lineGetNumRings",
+#if TAPI_1_1
+    "lineGetProviderList",
+#if TAPI_2_0
+    "lineGetProviderListW",
+#endif
+#endif
+    "lineGetRequest",
+#if TAPI_2_0
+    "lineGetRequestW",
+#endif
+    "lineGetStatusMessages",
+    "lineGetTranslateCaps",
+#if TAPI_2_0
+    "lineGetTranslateCapsW",
+#endif
+    "lineHandoff",
+#if TAPI_2_0
+    "lineHandoffW",
+#endif
+    "lineHold",
+    "lineInitialize",
+#if TAPI_2_0
+    "lineInitializeEx",
+    "lineInitializeExW",
+#endif
+    "lineMakeCall",
+#if TAPI_2_0
+    "lineMakeCallW",
+#endif
+    "lineMonitorDigits",
+    "lineMonitorMedia",
+    "lineMonitorTones",
+    "lineNegotiateAPIVersion",
+    "lineNegotiateExtVersion",
+    "lineOpen",
+#if TAPI_2_0
+    "lineOpenW",
+#endif
+    "linePark",
+#if TAPI_2_0
+    "lineParkW",
+#endif
+    "linePickup",
+#if TAPI_2_0
+    "linePickupW",
+#endif
+    "linePrepareAddToConference",
+#if TAPI_2_0
+    "linePrepareAddToConferenceW",
+    "lineProxyMessage",
+    "lineProxyResponse",
+#endif
+    "lineRedirect",
+#if TAPI_2_0
+    "lineRedirectW",
+#endif
+    "lineRegisterRequestRecipient",
+#if TAPI_1_1
+    "lineReleaseUserUserInfo",
+#endif
+    "lineRemoveFromConference",
+#if TAPI_1_1
+    "lineRemoveProvider",
+#endif
+    "lineSecureCall",
+    "lineSendUserUserInfo",
+#if TAPI_2_0
+    "lineSetAgentActivity",
+    "lineSetAgentGroup",
+    "lineSetAgentState",
+#endif
+#if TAPI_1_1
+    "lineSetAppPriority",
+#if TAPI_2_0
+    "lineSetAppPriorityW",
+#endif
+#endif
+    "lineSetAppSpecific",
+#if TAPI_2_0
+    "lineSetCallData",
+#endif
+    "lineSetCallParams",
+    "lineSetCallPrivilege",
+#if TAPI_2_0
+    "lineSetCallQualityOfService",
+    "lineSetCallTreatment",
+#endif
+    "lineSetCurrentLocation",
+    "lineSetDevConfig",
+#if TAPI_2_0
+    "lineSetDevConfigW",
+    "lineSetLineDevStatus",
+#endif
+    "lineSetMediaControl",
+    "lineSetMediaMode",
+    "lineSetNumRings",
+    "lineSetStatusMessages",
+    "lineSetTerminal",
+    "lineSetTollList",
+#if TAPI_2_0
+    "lineSetTollListW",
+#endif
+    "lineSetupConference",
+#if TAPI_2_0
+    "lineSetupConferenceW",
+#endif
+    "lineSetupTransfer",
+#if TAPI_2_0
+    "lineSetupTransferW",
+#endif
+    "lineShutdown",
+    "lineSwapHold",
+    "lineTranslateAddress",
+#if TAPI_2_0
+    "lineTranslateAddressW",
+#endif
+#if TAPI_1_1
+    "lineTranslateDialog",
+#if TAPI_2_0
+    "lineTranslateDialogW",
+#endif
+#endif
+    "lineUncompleteCall",
+    "lineUnhold",
+    "lineUnpark",
+#if TAPI_2_0
+    "lineUnparkW",
+#endif
+
+    "phoneClose",
+    "phoneConfigDialog",
+#if TAPI_2_0
+    "phoneConfigDialogW",
+#endif
+    "phoneDevSpecific",
+    "phoneGetButtonInfo",
+#if TAPI_2_0
+    "phoneGetButtonInfoW",
+#endif
+    "phoneGetData",
+    "phoneGetDevCaps",
+#if TAPI_2_0
+    "phoneGetDevCapsW",
+#endif
+    "phoneGetDisplay",
+    "phoneGetGain",
+    "phoneGetHookSwitch",
+    "phoneGetIcon",
+#if TAPI_2_0
+    "phoneGetIconW",
+#endif
+    "phoneGetID",
+#if TAPI_2_0
+    "phoneGetIDW",
+#endif
+    "phoneGetLamp",
+#if TAPI_2_0
+    "phoneGetMessage",
+#endif
+    "phoneGetRing",
+    "phoneGetStatus",
+#if TAPI_2_0
+    "phoneGetStatusW",
+#endif
+    "phoneGetStatusMessages",
+    "phoneGetVolume",
+    "phoneInitialize",
+#if TAPI_2_0
+    "phoneInitializeEx",
+    "phoneInitializeExW",
+#endif
+    "phoneOpen",
+    "phoneNegotiateAPIVersion",
+    "phoneNegotiateExtVersion",
+    "phoneSetButtonInfo",
+#if TAPI_2_0
+    "phoneSetButtonInfoW",
+#endif
+    "phoneSetData",
+    "phoneSetDisplay",
+    "phoneSetGain",
+    "phoneSetHookSwitch",
+    "phoneSetLamp",
+    "phoneSetRing",
+    "phoneSetStatusMessages",
+    "phoneSetVolume",
+    "phoneShutdown",
+
+    "tapiGetLocationInfo",
+#if TAPI_2_0
+    "tapiGetLocationInfoW",
+#endif
+    "tapiRequestDrop",
+    "tapiRequestMakeCall",
+#if TAPI_2_0
+    "tapiRequestMakeCallW",
+#endif
+    "tapiRequestMediaCall",
+#if TAPI_2_0
+    "tapiRequestMediaCallW",
+#endif
+
+    "Open all lines",
+    "Open all phones",
+    "Close handle (comm, etc)",
+    "Dump buffer contents",
+
+    NULL,
+    "Default values",
+    "LINECALLPARAMS",
+    "LINEFORWARDLIST",
+    NULL
+};
diff --git a/private/tapi/dev/apps/tb/vars.h b/private/tapi/dev/apps/tb/vars.h
new file mode 100644
index 000000000..33a072132
--- /dev/null
+++ b/private/tapi/dev/apps/tb/vars.h
@@ -0,0 +1,177 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-96  Microsoft Corporation
+
+Module Name:
+
+    vars.h
+
+Abstract:
+
+    Header file for the TAPI Browser util globals
+
+Author:
+
+    Dan Knudson (DanKn)    23-Oct-1994
+
+Revision History:
+
+--*/
+
+
+#ifdef WIN32
+#define my_far
+#else
+#define my_far _far
+#endif
+
+extern PMYWIDGET   aWidgets;
+
+extern FILE        *hLogFile;
+extern HANDLE      ghInst;
+extern HWND        ghwndMain, ghwndEdit, ghwndList1, ghwndList2;
+extern BOOL        bShowParams;
+extern BOOL        gbDeallocateCall;
+extern BOOL        gbDisableHandleChecking;
+extern LPVOID      pBigBuf;
+extern DWORD       dwBigBufSize;
+extern DWORD       dwNumPendingMakeCalls;
+extern DWORD       dwNumPendingDrops;
+extern DWORD       gdwNumLineDevs;
+extern DWORD       gdwNumPhoneDevs;
+extern BOOL        bDumpParams;
+extern BOOL        bTimeStamp;
+extern DWORD       bNukeIdleMonitorCalls;
+extern DWORD       bNukeIdleOwnedCalls;
+extern DWORD       dwDumpStructsFlags;
+
+extern LPLINECALLPARAMS    lpCallParams;
+
+#if TAPI_2_0
+extern BOOL                gbWideStringParams;
+extern LPLINECALLPARAMS    lpCallParamsW;
+#endif
+
+extern DWORD       aUserButtonFuncs[MAX_USER_BUTTONS];
+extern char        aUserButtonsText[MAX_USER_BUTTONS][MAX_USER_BUTTON_TEXT_SIZE];
+
+extern PMYLINEAPP  pLineAppSel;
+extern PMYLINE     pLineSel;
+extern PMYCALL     pCallSel, pCallSel2;
+extern PMYPHONEAPP pPhoneAppSel;
+extern PMYPHONE    pPhoneSel;
+
+extern char my_far szDefAppName[];
+extern char my_far szDefUserUserInfo[];
+extern char my_far szDefDestAddress[];
+extern char my_far szDefLineDeviceClass[];
+extern char my_far szDefPhoneDeviceClass[];
+
+extern char far   *lpszDefAppName;
+extern char far   *lpszDefUserUserInfo;
+extern char far   *lpszDefDestAddress;
+extern char far   *lpszDefLineDeviceClass;
+extern char far   *lpszDefPhoneDeviceClass;
+
+extern char my_far szTab[];
+extern char my_far szCurrVer[];
+
+// help extern char my_far szTapiHlp[];
+// help extern char my_far szTspiHlp[];
+
+extern DWORD       dwDefAddressID;
+extern DWORD       dwDefLineAPIVersion;
+extern DWORD       dwDefBearerMode;
+extern DWORD       dwDefCountryCode;
+extern DWORD       dwDefLineDeviceID;
+extern DWORD       dwDefLineExtVersion;
+extern DWORD       dwDefMediaMode;
+extern DWORD       dwDefLinePrivilege;
+extern DWORD       dwDefPhoneAPIVersion;
+extern DWORD       dwDefPhoneDeviceID;
+extern DWORD       dwDefPhoneExtVersion;
+extern DWORD       dwDefPhonePrivilege;
+
+#if TAPI_2_0
+extern HANDLE      ghCompletionPort;
+#endif
+
+extern char aAscii[];
+
+extern LOOKUP my_far aButtonFunctions[];
+extern LOOKUP my_far aButtonModes[];
+extern LOOKUP my_far aButtonStates[];
+extern LOOKUP my_far aHookSwitchDevs[];
+extern LOOKUP my_far aHookSwitchModes[];
+extern LOOKUP my_far aLampModes[];
+extern LOOKUP my_far aPhonePrivileges[];
+extern LOOKUP my_far aPhoneStatusFlags[];
+extern LOOKUP my_far aPhoneStates[];
+
+extern LOOKUP my_far aStringFormats[];
+extern LOOKUP my_far aAddressCapFlags[];
+extern LOOKUP my_far aAddressFeatures[];
+extern LOOKUP my_far aAgentStates[];
+extern LOOKUP my_far aAgentStatus[];
+extern LOOKUP my_far aAddressModes[];
+extern LOOKUP my_far aAddressSharing[];
+extern LOOKUP my_far aAddressStates[];
+extern LOOKUP my_far aAnswerModes[];
+extern LOOKUP my_far aAPIVersions[];
+extern LOOKUP my_far aBearerModes[];
+extern LOOKUP my_far aBusyModes[];
+extern LOOKUP my_far aCallComplConds[];
+extern LOOKUP my_far aCallComplModes[];
+extern LOOKUP my_far aCallerIDFlags[];
+extern LOOKUP my_far aCallFeatures[];
+extern LOOKUP my_far aCallFeatures2[];
+extern LOOKUP my_far aCallInfoStates[];
+extern LOOKUP my_far aCallOrigins[];
+extern LOOKUP my_far aCallParamFlags[];
+extern LOOKUP my_far aCallPrivileges[];
+extern LOOKUP my_far aCallReasons[];
+extern LOOKUP my_far aCallSelects[];
+extern LOOKUP my_far aCallStates[];
+extern LOOKUP my_far aCallTreatments[];
+extern LOOKUP my_far aCardOptions[];
+extern LOOKUP my_far aConnectedModes[];
+extern LOOKUP my_far aDevCapsFlags[];
+extern LOOKUP my_far aDialToneModes[];
+extern LOOKUP my_far aDigitModes[];
+extern LOOKUP my_far aDisconnectModes[];
+extern LOOKUP my_far aForwardModes[];
+extern LOOKUP my_far aGatherTerms[];
+extern LOOKUP my_far aGenerateTerms[];
+extern LOOKUP my_far aInitExOptions[];
+extern LOOKUP my_far aLineDevStatusFlags[];
+extern LOOKUP my_far aLineFeatures[];
+extern LOOKUP my_far aLineOpenOptions[];
+extern LOOKUP my_far aLineRoamModes[];
+extern LOOKUP my_far aLineStates[];
+extern LOOKUP my_far aLocationOptions[];
+extern LOOKUP my_far aMediaControls[];
+extern LOOKUP my_far aMediaModes[];
+extern LOOKUP my_far aOfferingModes[];
+extern LOOKUP my_far aParkModes[];
+extern LOOKUP my_far aProxyRequests[];
+extern LOOKUP my_far aRemoveFromConfCaps[];
+extern LOOKUP my_far aRequestModes[];
+extern LOOKUP my_far aRequestModes2[];
+extern LOOKUP my_far aSpecialInfo[];
+extern LOOKUP my_far aTerminalModes[];
+extern LOOKUP my_far aTollListOptions[];
+extern LOOKUP my_far aToneModes[];
+extern LOOKUP my_far aTransferModes[];
+extern LOOKUP my_far aTranslateOptions[];
+extern LOOKUP my_far aTranslateResults[];
+
+#if TAPI_2_0
+extern LOOKUP my_far aPhoneFeatures[];
+#endif
+
+extern char *aszLineErrs[];
+
+extern char *aszPhoneErrs[];
+extern char *aszTapiErrs[];
+
+extern char *aFuncNames[];
diff --git a/private/tapi/dev/apps/tb/widget.c b/private/tapi/dev/apps/tb/widget.c
new file mode 100644
index 000000000..1405c3e72
--- /dev/null
+++ b/private/tapi/dev/apps/tb/widget.c
@@ -0,0 +1,742 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994-95  Microsoft Corporation
+
+Module Name:
+
+    widget.c
+
+Abstract:
+
+    Widget creation/management/deletion support for TAPI Browser util.
+
+Author:
+
+    Dan Knudson (DanKn)    23-Aug-1994
+
+Revision History:
+
+--*/
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <malloc.h>
+#include "tb.h"
+#include "vars.h"
+
+
+
+void
+UpdateWidgetList(
+    void
+    )
+{
+    int         i;
+    LONG        lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+    PMYWIDGET   pWidget = aWidgets, pSelWidget = (PMYWIDGET) NULL;
+
+
+    if (lSel != LB_ERR)
+    {
+        pSelWidget = (PMYWIDGET) SendMessage(
+            ghwndList1,
+            LB_GETITEMDATA,
+            (WPARAM) lSel,
+            0
+            );
+    }
+
+    SendMessage (ghwndList1, LB_RESETCONTENT, 0, 0);
+
+    for (i = 0; pWidget; i++)
+    {
+        char buf[64];
+
+
+        switch (pWidget->dwType)
+        {
+        case WT_LINEAPP:
+
+            sprintf (buf, "LineApp=x%lx", ((PMYLINEAPP) pWidget)->hLineApp);
+            break;
+
+        case WT_LINE:
+        {
+            PMYLINE pLine = (PMYLINE) pWidget;
+
+
+            sprintf(
+                buf,
+                "  Line=x%lx id=%ld ",
+                pLine->hLine,
+                pLine->dwDevID
+                );
+
+            if (pLine->dwPrivileges & LINECALLPRIVILEGE_NONE)
+            {
+                strcat (buf, "DialOut");
+            }
+            else
+            {
+                if (pLine->dwPrivileges & LINECALLPRIVILEGE_OWNER)
+                {
+                    strcat (buf, "DialInOut");
+                }
+
+                if (pLine->dwPrivileges & LINECALLPRIVILEGE_MONITOR)
+                {
+                    strcat (buf, " Monitor");
+                }
+            }
+
+            if (pLine->dwPrivileges & LINEOPENOPTION_PROXY)
+            {
+                strcat (buf, " Proxy");
+            }
+
+            break;
+        }
+        case WT_CALL:
+        {
+            PMYCALL pCall = (PMYCALL) pWidget;
+
+
+            if (pCall->hCall)
+            {
+                int i;
+
+                for (i = 0; aCallStates[i].dwVal != 0xffffffff; i++)
+                {
+                    if (pCall->dwCallState == aCallStates[i].dwVal)
+                    {
+                        break;
+                    }
+                }
+
+                sprintf(
+                    buf,
+                    "    Call=x%lx %s %s",
+                    pCall->hCall,
+                    aCallStates[i].lpszVal,
+                    (pCall->bMonitor ? "Monitor" : "Owner")
+                    );
+            }
+            else
+            {
+                strcpy (buf, "    <MakeCall reply pending>");
+            }
+
+            break;
+        }
+        case WT_PHONEAPP:
+
+            sprintf (buf, "PhoneApp=x%lx", ((PMYPHONEAPP) pWidget)->hPhoneApp);
+            break;
+
+        case WT_PHONE:
+
+            sprintf(
+                buf,
+                "  Phone=x%lx id=%ld",
+                ((PMYPHONE) pWidget)->hPhone,
+                ((PMYPHONE) pWidget)->dwDevID
+                );
+
+            break;
+        }
+
+        SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM) -1, (LPARAM) buf);
+        SendMessage (ghwndList1, LB_SETITEMDATA, (WPARAM) i, (LPARAM) pWidget);
+
+        pWidget = pWidget->pNext;
+    }
+
+
+    //
+    // Restore selection if appropriate
+    //
+
+    if ((lSel != LB_ERR) && ((lSel = (LONG) GetWidgetIndex (pSelWidget)) >= 0))
+    {
+        SendMessage (ghwndList1, LB_SETCURSEL, (WPARAM) lSel, 0);
+    }
+}
+
+
+void
+InsertWidgetInList(
+    PMYWIDGET pNewWidget,
+    PMYWIDGET pWidgetInsertBefore
+    )
+{
+    pNewWidget->pNext = pWidgetInsertBefore;
+
+    if ((aWidgets == NULL) || (pWidgetInsertBefore == aWidgets))
+    {
+        aWidgets = pNewWidget;
+    }
+    else
+    {
+        PMYWIDGET pPrevWidget = aWidgets;
+
+
+        while (pPrevWidget->pNext &&
+               (pPrevWidget->pNext != pWidgetInsertBefore))
+        {
+            pPrevWidget = pPrevWidget->pNext;
+        }
+
+        pPrevWidget->pNext = pNewWidget;
+    }
+
+    UpdateWidgetList();
+}
+
+
+BOOL
+RemoveWidgetFromList(
+    PMYWIDGET pWidgetToRemove
+    )
+{
+    if (aWidgets == NULL)
+    {
+        goto RemoveWidgetFromList_error;
+    }
+
+    if (pWidgetToRemove == aWidgets)
+    {
+        aWidgets = pWidgetToRemove->pNext;
+    }
+    else
+    {
+        PMYWIDGET pPrevWidget = aWidgets;
+
+
+        while (pPrevWidget->pNext && (pPrevWidget->pNext != pWidgetToRemove))
+        {
+            pPrevWidget = pPrevWidget->pNext;
+        }
+
+        if (pPrevWidget->pNext == NULL)
+        {
+            goto RemoveWidgetFromList_error;
+        }
+
+        pPrevWidget->pNext = pWidgetToRemove->pNext;
+    }
+
+    free (pWidgetToRemove);
+
+    UpdateWidgetList();
+
+    return TRUE;
+
+RemoveWidgetFromList_error:
+
+    ShowStr ("Error: pWidget x%lx not found in list", pWidgetToRemove);
+
+    return FALSE;
+}
+
+
+PMYLINEAPP
+AllocLineApp(
+    void
+    )
+{
+    PMYLINEAPP pNewLineApp = (PMYLINEAPP) malloc (sizeof(MYLINEAPP));
+
+
+    if (pNewLineApp)
+    {
+        PMYWIDGET pWidget = aWidgets;
+
+
+        memset (pNewLineApp, 0, sizeof(MYLINEAPP));
+        pNewLineApp->Widget.dwType = WT_LINEAPP;
+
+
+        //
+        // Insert new line app after all existing line apps, lines, & calls,
+        // and before any existing phone apps
+        //
+
+        while (pWidget && (pWidget->dwType != WT_PHONEAPP))
+        {
+            // assert (pWidget->dwType != WT_PHONE)
+
+            pWidget = pWidget->pNext;
+        }
+
+        InsertWidgetInList ((PMYWIDGET) pNewLineApp, pWidget);
+    }
+
+    return pNewLineApp;
+}
+
+
+PMYLINEAPP
+GetLineApp(
+    HLINEAPP hLineApp
+    )
+{
+    PMYWIDGET pWidget = aWidgets;
+
+
+    while (pWidget)
+    {
+        if (pWidget->dwType == WT_LINEAPP)
+        {
+            PMYLINEAPP pLineApp = (PMYLINEAPP) pWidget;
+
+
+            if (pLineApp->hLineApp == hLineApp)
+            {
+                break;
+            }
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PMYLINEAPP) pWidget);
+}
+
+
+VOID
+FreeLineApp(
+    PMYLINEAPP pLineApp
+    )
+{
+    PMYWIDGET pWidget = pLineApp->Widget.pNext;
+
+
+    // BUGBUG chk validity of pLineApp
+
+    if (RemoveWidgetFromList ((PMYWIDGET) pLineApp))
+    {
+        while (pWidget &&
+               (pWidget->dwType != WT_LINEAPP) &&
+               (pWidget->dwType != WT_PHONEAPP))
+        {
+            PMYWIDGET pWidget2 = pWidget->pNext;
+
+
+            // assert (pWidget->dwType != WT_PHONE)
+
+            RemoveWidgetFromList (pWidget);
+            pWidget = pWidget2;
+        }
+    }
+}
+
+
+PMYLINE
+AllocLine(
+    PMYLINEAPP pLineApp
+    )
+{
+    PMYLINE pNewLine = (PMYLINE) malloc (sizeof(MYLINE));
+
+
+    if (pNewLine)
+    {
+        PMYWIDGET pWidget = (PMYWIDGET) pLineApp->Widget.pNext;
+
+
+        memset (pNewLine, 0, sizeof(MYLINE));
+        pNewLine->Widget.dwType = WT_LINE;
+        pNewLine->pLineApp = pLineApp;
+
+
+        //
+        // Insert new line after all existing lines & calls on specfied
+        // line app, but before the next line app or phone app
+        //
+
+        while (pWidget &&
+               (pWidget->dwType != WT_LINEAPP) &&
+               (pWidget->dwType != WT_PHONEAPP))
+        {
+            pWidget = pWidget->pNext;
+        }
+
+        InsertWidgetInList ((PMYWIDGET) pNewLine, pWidget);
+    }
+
+    return pNewLine;
+}
+
+
+PMYLINE
+GetLine(
+    HLINE hLine
+    )
+{
+    PMYWIDGET pWidget = aWidgets;
+
+
+    while (pWidget)
+    {
+        if (pWidget->dwType == WT_LINE)
+        {
+            PMYLINE pLine = (PMYLINE) pWidget;
+
+
+            if (pLine->hLine == hLine)
+            {
+                break;
+            }
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PMYLINE) pWidget);
+}
+
+
+VOID
+FreeLine(
+    PMYLINE pLine
+    )
+{
+    PMYWIDGET pWidget = pLine->Widget.pNext;
+
+
+    if (RemoveWidgetFromList ((PMYWIDGET) pLine))
+    {
+        while (pWidget &&
+               (pWidget->dwType == WT_CALL))
+        {
+            PMYWIDGET pWidget2 = pWidget->pNext;
+
+
+            RemoveWidgetFromList (pWidget);
+            pWidget = pWidget2;
+        }
+    }
+}
+
+
+PMYCALL
+AllocCall(
+    PMYLINE pLine
+    )
+{
+    PMYCALL pNewCall = (PMYCALL) malloc (sizeof(MYCALL));
+
+
+    if (pNewCall)
+    {
+        PMYWIDGET pWidget = (PMYWIDGET) pLine->Widget.pNext;
+
+
+        memset (pNewCall, 0, sizeof(MYCALL));
+        pNewCall->Widget.dwType = WT_CALL;
+        pNewCall->pLine = pLine;
+
+        //
+        // Insert new call after all existing calls on specified line,
+        // and before the next line, line app, or phone app
+        //
+
+        while (pWidget && (pWidget->dwType == WT_CALL))
+        {
+            pWidget = pWidget->pNext;
+        }
+
+        InsertWidgetInList ((PMYWIDGET) pNewCall, pWidget);
+    }
+
+    return pNewCall;
+}
+
+
+PMYCALL
+GetCall(
+    HCALL hCall
+    )
+{
+    PMYWIDGET pWidget = aWidgets;
+
+
+    while (pWidget)
+    {
+        if (pWidget->dwType == WT_CALL)
+        {
+            PMYCALL pCall = (PMYCALL) pWidget;
+
+
+            if (pCall->hCall == hCall)
+            {
+                break;
+            }
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PMYCALL) pWidget);
+}
+
+
+VOID
+FreeCall(
+    PMYCALL pCall
+    )
+{
+    // BUGBUG chk validity of pCall
+
+    RemoveWidgetFromList ((PMYWIDGET) pCall);
+}
+
+
+VOID
+MoveCallToLine(
+    PMYCALL pCall,
+    HLINE hLine
+    )
+{
+    //
+    // This func gets called when a user has invoked an op that requires
+    // creating a call, and we did an AllocCall() based on the currently
+    // selected line/calls, but in the call params dlg the user overrode
+    // the default hLine/hCall, and so we need to move the call widget
+    // in the global list from under the orig specified line widget to
+    // the line widget corresponding to the specified "hLine". (Note that
+    // this is not a simple matter of free-ing & realloc-ing another call,
+    // since TAPI saved the &pCall->hCall.)
+    //
+
+    PMYWIDGET pWidget = aWidgets;
+
+
+    //
+    // Remove call widget from the global list
+    //
+
+    while (pWidget->pNext != (PMYWIDGET) pCall)
+    {
+        pWidget = pWidget->pNext;
+    }
+
+    pWidget->pNext = pCall->Widget.pNext;
+
+
+    //
+    // Find the right place to insert it in list, then insert it
+    //
+
+    pWidget = (PMYWIDGET) GetLine (hLine);
+
+    pCall->pLine = (PMYLINE) pWidget;
+
+    while (pWidget->pNext && (pWidget->pNext->dwType == WT_CALL))
+    {
+        pWidget = pWidget->pNext;
+    }
+
+    pCall->Widget.pNext = pWidget->pNext;
+    pWidget->pNext = (PMYWIDGET) pCall;
+
+    UpdateWidgetList();
+}
+
+
+PMYPHONEAPP
+AllocPhoneApp(
+    void
+    )
+{
+    PMYPHONEAPP pNewPhoneApp = (PMYPHONEAPP) malloc (sizeof(MYPHONEAPP));
+
+
+    if (pNewPhoneApp)
+    {
+        PMYWIDGET pWidget = aWidgets;
+
+
+        memset (pNewPhoneApp, 0, sizeof(MYPHONEAPP));
+        pNewPhoneApp->Widget.dwType = WT_PHONEAPP;
+
+
+        //
+        // Insert new phone app at end of list
+        //
+
+        InsertWidgetInList ((PMYWIDGET) pNewPhoneApp, (PMYWIDGET) NULL);
+    }
+
+    return pNewPhoneApp;
+}
+
+
+PMYPHONEAPP
+GetPhoneApp(
+    HPHONEAPP hPhoneApp
+    )
+{
+    PMYWIDGET pWidget = aWidgets;
+
+
+    while (pWidget)
+    {
+        if (pWidget->dwType == WT_PHONEAPP)
+        {
+            PMYPHONEAPP pPhoneApp = (PMYPHONEAPP) pWidget;
+
+
+            if (pPhoneApp->hPhoneApp == hPhoneApp)
+            {
+                break;
+            }
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PMYPHONEAPP) pWidget);
+}
+
+
+VOID
+FreePhoneApp(
+    PMYPHONEAPP pPhoneApp
+    )
+{
+    PMYWIDGET pWidget = pPhoneApp->Widget.pNext;
+
+
+    if (RemoveWidgetFromList ((PMYWIDGET) pPhoneApp))
+    {
+        while (pWidget && (pWidget->dwType == WT_PHONE))
+        {
+            PMYWIDGET pWidget2 = pWidget->pNext;
+
+
+            RemoveWidgetFromList (pWidget);
+            pWidget = pWidget2;
+        }
+    }
+}
+
+
+PMYPHONE
+AllocPhone(
+    PMYPHONEAPP pPhoneApp
+    )
+{
+    PMYPHONE pNewPhone = (PMYPHONE) malloc (sizeof(MYPHONE));
+
+
+    if (pNewPhone)
+    {
+        PMYWIDGET pWidget = (PMYWIDGET) pPhoneApp->Widget.pNext;
+
+
+        memset (pNewPhone, 0, sizeof(MYPHONE));
+        pNewPhone->Widget.dwType = WT_PHONE;
+        pNewPhone->pPhoneApp = pPhoneApp;
+
+
+        //
+        // Insert new phone after all phones on the specified phone app,
+        // and before the next phone app
+        //
+
+        while (pWidget && (pWidget->dwType == WT_PHONE))
+        {
+            pWidget = pWidget->pNext;
+        }
+
+        InsertWidgetInList ((PMYWIDGET) pNewPhone, pWidget);
+    }
+
+    return pNewPhone;
+}
+
+
+PMYPHONE
+GetPhone(
+    HPHONE hPhone
+    )
+{
+    PMYWIDGET pWidget = aWidgets;
+
+
+    while (pWidget)
+    {
+        if (pWidget->dwType == WT_PHONE)
+        {
+            PMYPHONE pPhone = (PMYPHONE) pWidget;
+
+
+            if (pPhone->hPhone == hPhone)
+            {
+                break;
+            }
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PMYPHONE) pWidget);
+}
+
+
+VOID
+FreePhone(
+    PMYPHONE pPhone
+    )
+{
+    RemoveWidgetFromList ((PMYWIDGET) pPhone);
+}
+
+
+int
+GetWidgetIndex(
+    PMYWIDGET pWidget
+    )
+{
+    int i;
+    PMYWIDGET pWidget2 = aWidgets;
+
+
+    for (i = 0; (pWidget2 && (pWidget != pWidget2)); i++)
+    {
+        pWidget2 = pWidget2->pNext;
+    }
+
+    if (!pWidget2)
+    {
+        i = -1;
+    }
+
+    return i;
+}
+
+
+void
+SelectWidget(
+    PMYWIDGET pWidget
+    )
+{
+    int i;
+    PMYWIDGET pWidget2 = aWidgets;
+
+
+    for (i = 0; pWidget2; i++)
+    {
+        if (pWidget == pWidget2)
+        {
+            SendMessage (ghwndList1, LB_SETCURSEL, (WPARAM) i, 0);
+            break;
+        }
+
+        pWidget2 = pWidget2->pNext;
+    }
+}
diff --git a/private/tapi/dev/apps/tb/win31.mak b/private/tapi/dev/apps/tb/win31.mak
new file mode 100644
index 000000000..95475aeb1
--- /dev/null
+++ b/private/tapi/dev/apps/tb/win31.mak
@@ -0,0 +1,39 @@
+!ifndef  TAPI_1_1
+TAPI_1_1 = 0
+!endif
+
+!ifndef  MYDEBUG
+MYDEBUG = 0
+!endif
+
+!if $(TAPI_1_1)
+TAPI_VER_FLAGS = -DTAPI_1_1
+TAPILIB        = ..\..\lib\i386\tapi.lib
+TAPIINC        = -I..\..\inc
+TARGET         = ..\..\lib\i386\tb1416.exe
+!else
+TAPI_VER_FLAGS =
+TAPILIB        = ..\..\lib\tapi10\tapi.lib
+TAPIINC        = -I..\..\inc\tapi10
+TARGET         = $(BASEDIR)\public\sdk\lib\i386\tb13.exe
+!endif
+
+!if $(MYDEBUG)
+C_FLAGS = -AL -G2s -W3 -GA -GEf -Zp /Od /Oi /Zi
+!else
+C_FLAGS = -AL -G2s -W3 -GA -GEf -Zp /Od /Oi
+!endif
+
+
+OBJS=ui.obj vars.obj tb.obj tb2.obj widget.obj
+
+all : $(TARGET)
+
+.c.obj:
+   cl -c $(TAPI_VER_FLAGS) $(TAPIINC) $(C_FLAGS) $*.c
+
+$(TARGET) : $(OBJS) tb.def tb.rc
+   rc -r -dTB_13=1 $(TAPI_VER_FLAGS) tb.rc
+   link $(OBJS),$(TARGET),tb.map,libw.lib /MAP:FULL /COD /NOD:llibce llibcew commdlg $(TAPILIB),tb.def
+   rc -k tb.res $(TARGET)
+   mapsym tb
diff --git a/private/tapi/dev/client/card.c b/private/tapi/dev/client/card.c
new file mode 100644
index 000000000..9c2de6406
--- /dev/null
+++ b/private/tapi/dev/client/card.c
@@ -0,0 +1,1763 @@
+#if DBG
+#define InternalDebugOut DbgPrt
+#else
+#define InternalDebugOut //
+#endif
+
+
+
+#include <windows.h>
+#include <windowsx.h>
+
+#if WINNT
+#else
+#include <help.h>
+#endif
+
+#include "tchar.h"
+#include "prsht.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "clientr.h"
+#include "client.h"
+#include "private.h"
+#include "card.h"
+#include "location.h"
+#include "general.h"
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL ReadCountries( LPLINECOUNTRYLIST *ppLCL,
+                           UINT nCountryID,
+                           DWORD dwDestCountryID
+                         );
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+DWORD gdwSaveCallingCardID;
+DWORD gdwChangedFlags = 0;
+DWORD *gpnStuff = NULL;
+PCARD gpCardList = NULL;
+PCARD gpCurrentCard = NULL;
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+extern const char    gszNullString[];
+//extern const WCHAR   gszCardsW[];
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+#define  IniIsDigit( ch )                       \
+   (   ((unsigned char)(ch) >= '0')         \
+     && ((unsigned char)(ch) <= '9'))                                   
+
+
+//***************************************************************************
+#define  UtilValidExNumStr( ch )                                \
+   (   (   ((ch) >= '0')                 \
+          && ((ch) <= '9'))                  \
+     || (   ((ch) >= 'a')                    \
+          && ((ch) <= 'h'))                  \
+     || (   ((ch) >= 'A')                    \
+          && ((ch) <= 'H'))                  \
+     || ((ch) == '#')                            \
+     || ((ch) == '*')                            \
+     || (   ((ch) == 't')                    \
+          || ((ch) == 'T'))                  \
+     || (   ((ch) == 'p')                    \
+          || ((ch) == 'P'))                  \
+     || ((ch) == '!')                            \
+     || ((ch) == ',')                            \
+     || (   ((ch) == 'w')                    \
+          || ((ch) == 'W'))                  \
+     || ((ch) == '@')                            \
+     || ((ch) == '$')                            \
+     || ((ch) == '?')                            \
+     || ((ch) == '+')                            \
+     || ((ch) == ' ') )
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+/*--------------------------------------------------------------------------*\
+
+   Function:   UtilGetEditNumStr
+   
+   Purpose:    Get the text from the edit control, and it verifies that it's
+               correct.
+   
+\*--------------------------------------------------------------------------*/
+BOOL  UtilGetEditNumStr( HWND  hWnd,
+                                 UINT  uControl,
+                                 UINT  nExtendNum )
+
+{
+   UINT  uIndex;
+   UINT  wWrnId;
+   BOOL  fResult;
+   PWSTR pszString;
+   PWSTR pszTitle;
+
+
+   pszString = ClientAlloc( 256 * sizeof(WCHAR) );
+
+   GetDlgItemTextW( hWnd, uControl, pszString, 256 );
+
+   switch ( nExtendNum )
+   {
+//      case  UTIL_NUMBER_OR_SPACE:
+//         // 0-9 & SPACE
+//         wWrnId = IDS_WRN_INVALID_NUM;            
+//         for ( uIndex = 0; (IniIsDigit(lpszNumStr[uIndex])||lpszNumStr[uIndex]==' '); uIndex++ )
+//            ;
+//         break;
+//         
+      case  UTIL_NUMBER:
+         // 0-9
+         wWrnId = IDS_WRN_INVALID_NUM;            
+         for ( uIndex = 0; IniIsDigit(pszString[uIndex]); uIndex++ )
+            ;
+         break;
+         
+//      case  UTIL_EXTENED:
+//         // 0 1 2 3 4 5 6 7 8 9 A a B b C c D d * # , ! W w P p T t @ $ ?
+//         wWrnId = CPL_WRN_INVALID_NUM_STR;            
+//         for ( uIndex = 0; UtilValidNumStr(lpszNumStr[uIndex]); uIndex++ )
+//            ;
+//         break;
+         
+      case  UTIL_BIG_EXTENDED:
+      default:
+         // 0 1 2 3 4 5 6 7 8 9 A a B b C c D d E e F f G g H h * # , ! W w P p T t @ $ ?
+         wWrnId = IDS_WRN_INVALID_EX_NUM_STR;
+         for ( uIndex = 0; UtilValidExNumStr(pszString[uIndex]); uIndex++ )
+            ;
+         break;         
+   }
+    
+  
+   if ( pszString[uIndex] == '\0' )      // valid str
+   {
+      fResult = TRUE;           
+   }
+   else                                   // invalid str
+   {
+      pszTitle = ClientAlloc( 256 * sizeof(WCHAR) );
+
+      LoadStringW(ghInst, wWrnId,             pszString, 256);
+      LoadStringW(ghInst, IDS_WRN_TITLE_INVALCHAR, pszTitle, 256);
+
+      MessageBoxW( hWnd,
+                   pszString,
+                   pszTitle,
+                   MB_OK
+                 );
+
+      SetFocus( GetDlgItem( hWnd, uControl ));
+      SendDlgItemMessage( hWnd, uControl, EM_SETSEL, 0, MAKELPARAM( uIndex, uIndex + 1 ));
+
+      ClientFree( pszTitle );
+
+      fResult = FALSE;
+   }
+
+
+   ClientFree( pszString );
+
+   return( fResult );      
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL GetCardIndexFromID( UINT nID,
+                                PCARD pCallersList,
+                                UINT nCallersNumCards )
+{
+   UINT  n;
+
+
+   for (n=0; n < nCallersNumCards; n++)
+   {
+
+InternalDebugOut(10, "comparing <in %ld> with <list entry %ld is %ld>",
+                         (DWORD)nID, (DWORD)n, (DWORD)pCallersList[n].dwID);
+
+      if ( nID == pCallersList[n].dwID )
+      {
+         return (n);
+      }
+   }
+
+   InternalDebugOut(1, "GetListIndexFromID failed!  Looking for 0x%08lx", nID);
+   return (-1);
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void FillCardListbox( HWND hWnd, PCARD *ppCardSpace, LPDWORD *ppnStuff)
+{
+   UINT n;
+   LONG lItemIndex;
+
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_NAME];
+#endif
+
+//bjm11/12   //
+//bjm11/12   // Read in the list of cards
+//bjm11/12   //
+//bjm11/12   ReadCardsEasy( ppCardSpace, ppnStuff );
+//bjm11/12
+//bjm11/12 take above as already done. (It's already done for location stuff..)
+//bjm11/12
+
+
+   //
+   // Make sure we're starting with a clean slate.
+   //
+   SendDlgItemMessage(
+                       hWnd,
+                       IDCC_DR_CARD_NAME,
+                       CB_RESETCONTENT,
+                       0,
+                       0
+                     );
+
+
+   for( n=0; n < (*ppnStuff)[2]; n++ )
+   {
+      //
+      // Has this card been "deleted" ?
+      //
+      if (
+            ((*ppCardSpace)[n].NameW[0] != '\0')
+          &&
+            (0 == ((*ppCardSpace)[n].dwFlags & CARD_HIDE))
+         )
+      {
+
+#ifdef PARTIAL_UNICODE
+         WideCharToMultiByte(
+                              GetACP(),
+                              0,
+                              (*ppCardSpace)[n].NameW,
+                              -1,
+                              szTempString,
+                              MAXLEN_NAME,
+                              NULL,
+                              NULL
+                            );
+
+         lItemIndex = SendDlgItemMessage(
+                                          hWnd,
+                                          IDCC_DR_CARD_NAME,
+                                          CB_ADDSTRING,
+                                          0,
+                                          (LPARAM)szTempString
+                                        );
+#else
+         lItemIndex = SendDlgItemMessageW(
+                                          hWnd,
+                                          IDCC_DR_CARD_NAME,
+                                          CB_ADDSTRING,
+                                          0,
+                                          (LPARAM)( (*ppCardSpace)[n].NameW )
+                                        );
+#endif
+
+         SendDlgItemMessage(
+                             hWnd,
+                             IDCC_DR_CARD_NAME,
+                             CB_SETITEMDATA,
+                             (WPARAM) lItemIndex,
+                             (LPARAM)(DWORD) &((*ppCardSpace)[n])
+                           );
+      }
+   }
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK CopyCallingCardProc( HWND hWnd,
+                                   UINT uMessage,
+                                   WPARAM wParam,
+                                   LPARAM lParam
+                                 )
+{
+   UINT n;
+
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_RULE];
+#endif
+
+   //
+   // table of controls and context-sensitive help IDs
+   //
+   static DWORD aIds[] =
+        {
+        IDCS_CR_RULE_LIST, IDH_TAPI_COPYFROM,
+        IDCL_CR_RULE_LIST, IDH_TAPI_COPYFROM,
+        0, 0
+        };
+    
+
+   switch (uMessage) 
+   {
+      case WM_HELP:
+      {
+         //
+         // Process clicks on controls after Context Help mode selected
+         //
+         WinHelp( ((LPHELPINFO) lParam)->hItemHandle,
+                  "windows.hlp",
+                  HELP_WM_HELP,
+                  (DWORD)(LPSTR) aIds);
+      }
+      break;
+
+
+
+      case WM_CONTEXTMENU:
+      {
+         //
+         // Process right-clicks on controls
+         //
+         WinHelp( (HWND)wParam,
+                  "windows.hlp",
+                  HELP_CONTEXTMENU,
+                  (DWORD)(LPVOID) aIds
+                );
+      }
+      break;
+
+
+
+      case  WM_INITDIALOG:
+      {
+         //
+         // Fill up the listbox with all of the calling cards as appropriate
+         //
+         for( n=0; n<gpnStuff[2]; n++ )
+         {
+            register LONG lItemIndex;
+
+
+            //
+            // Is it dead?
+            //
+            if ( '\0' == gpCardList[n].NameW[0] )
+            {
+               //
+               // Yes.  Skip it.
+               //
+               continue;
+            }
+
+
+#ifdef PARTIAL_UNICODE
+            WideCharToMultiByte(
+                                 GetACP(),
+                                 0,
+                                 gpCardList[n].NameW,
+                                 -1,
+                                 szTempString,
+                                 MAXLEN_NAME,
+                                 NULL,
+                                 NULL
+                               );
+
+            lItemIndex = SendDlgItemMessage(
+                                             hWnd,
+                                             IDCL_CR_RULE_LIST,
+                                             LB_ADDSTRING,
+                                             0,
+                                             (LPARAM)szTempString
+                                           );
+#else
+            lItemIndex = SendDlgItemMessageW(
+                                             hWnd,
+                                             IDCL_CR_RULE_LIST,
+                                             LB_ADDSTRING,
+                                             0,
+                                             (LPARAM) (gpCardList[n].NameW)
+                                           );
+#endif
+
+            SendDlgItemMessage(
+                                hWnd,
+                                IDCL_CR_RULE_LIST,
+                                LB_SETITEMDATA,
+                                (WPARAM) lItemIndex,
+                                (LPARAM)&(gpCardList[n])
+                              );
+         }
+
+      }
+      break;
+
+
+
+      case WM_COMMAND:
+      {
+         switch ( GET_WM_COMMAND_ID( wParam, lParam) )
+         {
+            case IDOK:
+            {
+               register LONG lItemIndex;
+               PCARD pThisCard;
+
+
+               //
+               // Get the currently selected calling card.
+               //
+
+               lItemIndex = SendDlgItemMessage( hWnd,
+                                                IDCL_CR_RULE_LIST,
+                                                LB_GETCURSEL,
+                                                0,
+                                                0
+                                              );
+               pThisCard = (PCARD)SendDlgItemMessage( hWnd,
+                                                      IDCL_CR_RULE_LIST,
+                                                      LB_GETITEMDATA,
+                                                      lItemIndex,
+                                                      0
+                                                    );
+
+
+               wcscpy( gpCurrentCard->LocalRuleW,
+                        pThisCard->LocalRuleW
+                      );
+
+               wcscpy( gpCurrentCard->LDRuleW,
+                        pThisCard->LDRuleW
+                      );
+
+               wcscpy( gpCurrentCard->InternationalRuleW,
+                        pThisCard->InternationalRuleW
+                      );
+
+
+               gdwChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+
+               EndDialog(hWnd, IDOK);
+            }
+            break;
+
+
+            case IDCANCEL:
+            {
+               EndDialog(hWnd, IDCANCEL);
+            }
+            break;
+
+
+            default:
+            break;
+         }
+      }
+      break;
+
+
+
+      default:
+         return 0;
+
+   }
+
+   return 1;
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void ShowRules( HWND hWnd )
+{
+
+#ifdef PARTIAL_UNICODE
+
+   CHAR szTempString[MAXLEN_RULE];
+
+   WideCharToMultiByte(
+                        GetACP(),
+                        0,
+                        gpCurrentCard->LocalRuleW,
+                        -1,
+                        szTempString,
+                        MAXLEN_RULE,
+                        NULL,
+                        NULL
+                      );
+
+   SetDlgItemText(hWnd, IDCE_DR_LOCAL_NUM, szTempString);
+
+
+   WideCharToMultiByte(
+                        GetACP(),
+                        0,
+                        gpCurrentCard->LDRuleW,
+                        -1,
+                        szTempString,
+                        MAXLEN_RULE,
+                        NULL,
+                        NULL
+                      );
+
+   SetDlgItemText(hWnd, IDCE_DR_LONG_NUM, szTempString);
+
+
+   WideCharToMultiByte(
+                        GetACP(),
+                        0,
+                        gpCurrentCard->InternationalRuleW,
+                        -1,
+                        szTempString,
+                        MAXLEN_RULE,
+                        NULL,
+                        NULL
+                      );
+
+   SetDlgItemText(hWnd, IDCE_DR_INTERNATIONAL_NUM, szTempString);
+
+#else
+
+   SetDlgItemTextW(hWnd, IDCE_DR_LOCAL_NUM, gpCurrentCard->LocalRuleW );
+   SetDlgItemTextW(hWnd, IDCE_DR_LONG_NUM, gpCurrentCard->LDRuleW );
+   SetDlgItemTextW(hWnd, IDCE_DR_INTERNATIONAL_NUM, gpCurrentCard->InternationalRuleW );
+
+#endif
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK AdvancedCallingCardProc( HWND hWnd,
+                                       UINT uMessage,
+                                       WPARAM wParam,
+                                       LPARAM lParam
+                                     )
+{
+
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_RULE];
+#endif
+
+   //
+   // table of controls and context-sensitive help IDs
+   //
+   static DWORD aIds[] =
+        {
+        IDCS_DR_LOCAL_NUM, IDH_TAPI_CALLCARD_RULES,
+        IDCE_DR_LOCAL_NUM, IDH_TAPI_CALLCARD_RULES,
+        IDCS_DR_LONG_NUM, IDH_TAPI_CALLCARD_RULES,
+        IDCE_DR_LONG_NUM, IDH_TAPI_CALLCARD_RULES,
+        IDCS_DR_INTERNATIONAL_NUM, IDH_TAPI_CALLCARD_RULES,
+        IDCE_DR_INTERNATIONAL_NUM, IDH_TAPI_CALLCARD_RULES,
+        IDCB_DR_COPY_FROM, IDH_TAPI_COPY_FROM_BUTTON,
+        0, 0
+        };
+    
+
+   switch (uMessage) 
+   {
+      case WM_HELP:
+      {
+         //
+         // Process clicks on controls after Context Help mode selected
+         //
+         WinHelp( ((LPHELPINFO) lParam)->hItemHandle,
+                  "windows.hlp",
+                  HELP_WM_HELP,
+                  (DWORD)(LPSTR) aIds);
+      }
+      break;
+
+
+
+      case WM_CONTEXTMENU:
+      {
+         //
+         // Process right-clicks on controls
+         //
+         WinHelp( (HWND)wParam,
+                  "windows.hlp",
+                  HELP_CONTEXTMENU,
+                  (DWORD)(LPVOID) aIds
+                );
+      }
+      break;
+
+
+
+      case  WM_INITDIALOG:
+      {
+         SendDlgItemMessageW( hWnd,
+                             IDCE_DR_LOCAL_NUM,
+                             EM_LIMITTEXT,
+                             MAXLEN_RULE,
+                             0
+                           );
+
+         SendDlgItemMessageW( hWnd,
+                             IDCE_DR_LONG_NUM,
+                             EM_LIMITTEXT,
+                             MAXLEN_RULE,
+                             0
+                           );
+
+         SendDlgItemMessageW( hWnd,
+                             IDCE_DR_INTERNATIONAL_NUM,
+                             EM_LIMITTEXT,
+                             MAXLEN_RULE,
+                             0
+                           );
+
+         ShowRules( hWnd );
+
+         if ( gpCurrentCard->dwFlags & CARD_BUILTIN )
+         {
+            EnableWindow( GetDlgItem(hWnd, IDCE_DR_LOCAL_NUM), FALSE );
+            EnableWindow( GetDlgItem(hWnd, IDCE_DR_LONG_NUM), FALSE );
+            EnableWindow( GetDlgItem(hWnd, IDCE_DR_INTERNATIONAL_NUM), FALSE );
+
+            EnableWindow( GetDlgItem(hWnd, IDCB_DR_COPY_FROM), FALSE );
+         }
+
+      }
+      break;
+
+
+
+      case WM_COMMAND:
+      {
+
+         switch ( LOWORD(wParam) )
+         {
+
+            case IDCE_DR_LOCAL_NUM:
+            case IDCE_DR_LONG_NUM:
+            case IDCE_DR_INTERNATIONAL_NUM:
+
+               if ( HIWORD(wParam) != EN_CHANGE)
+                   break;
+
+//               lpEditCard = (LPCRDEDIT)GetWindowLong(hWnd, DWL_USER);
+//               if (lpEditCard == NULL)
+//                   {
+//                   uResult = CPL_APP_ERROR;
+//                   goto  LError;
+//                   }
+
+
+               if ( 0 == UtilGetEditNumStr(
+                                            hWnd,
+                                            LOWORD(wParam),
+                                            UTIL_BIG_EXTENDED
+                                          )
+                  )
+               {
+//Um, huh?
+               }
+
+               return TRUE;
+
+               break;
+
+
+            case IDCB_DR_COPY_FROM:
+            {
+               DialogBoxW( ghInst,
+                           MAKEINTRESOURCEW(IDD_COPY_DIAL_RULES),
+                           hWnd,
+                           CopyCallingCardProc
+                        );
+
+               //
+               // Repaint the rule fields in case they changed.
+               //
+               ShowRules( hWnd );
+
+            }
+            break;
+
+
+
+            case IDOK:
+            {
+
+#ifdef PARTIAL_UNICODE
+
+               GetDlgItemText( hWnd,
+                               IDCE_DR_LOCAL_NUM,
+                               szTempString,
+                               MAXLEN_RULE
+                             );
+
+               MultiByteToWideChar(
+                                    GetACP(),
+                                    MB_PRECOMPOSED,
+                                    szTempString,
+                                    -1,
+                                    gpCurrentCard->LocalRuleW,
+                                    MAXLEN_RULE
+                                  );
+
+
+               GetDlgItemText( hWnd,
+                               IDCE_DR_LONG_NUM,
+                               szTempString,
+                               MAXLEN_RULE
+                             );
+
+               MultiByteToWideChar(
+                                    GetACP(),
+                                    MB_PRECOMPOSED,
+                                    szTempString,
+                                    -1,
+                                    gpCurrentCard->LDRuleW,
+                                    MAXLEN_RULE
+                                  );
+
+
+               GetDlgItemText( hWnd,
+                               IDCE_DR_INTERNATIONAL_NUM,
+                               szTempString,
+                               MAXLEN_RULE
+                             );
+
+               MultiByteToWideChar(
+                                    GetACP(),
+                                    MB_PRECOMPOSED,
+                                    szTempString,
+                                    -1,
+                                    gpCurrentCard->InternationalRuleW,
+                                    MAXLEN_RULE
+                                  );
+
+#else
+
+               GetDlgItemTextW( hWnd,
+                               IDCE_DR_LOCAL_NUM,
+                               gpCurrentCard->LocalRuleW,
+                               MAXLEN_RULE
+                             );
+
+               GetDlgItemTextW( hWnd,
+                                IDCE_DR_LONG_NUM,
+                                gpCurrentCard->LDRuleW,
+                                MAXLEN_RULE
+                              );
+
+               GetDlgItemTextW( hWnd,
+                                IDCE_DR_INTERNATIONAL_NUM,
+                                gpCurrentCard->InternationalRuleW,
+                                MAXLEN_RULE
+                              );
+
+#endif
+
+               if (
+                     (0 == UtilGetEditNumStr(
+                                            hWnd,
+                                            IDCE_DR_LOCAL_NUM,
+                                            UTIL_BIG_EXTENDED
+                                          )
+                     )
+                   ||
+                     (0 == UtilGetEditNumStr(
+                                            hWnd,
+                                            IDCE_DR_LONG_NUM,
+                                            UTIL_BIG_EXTENDED
+                                          )
+                     )
+                   ||
+                     (0 == UtilGetEditNumStr(
+                                            hWnd,
+                                            IDCE_DR_INTERNATIONAL_NUM,
+                                            UTIL_BIG_EXTENDED
+                                          )
+                     )
+                  )
+               {
+                   break;
+               }
+
+               gdwChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+
+               EndDialog(hWnd, IDOK);
+            }
+            break;
+
+
+
+            case IDCANCEL:
+            {
+               EndDialog(hWnd, IDCANCEL);
+            }
+            break;
+
+            
+            
+            default:
+            break;
+         }
+      }
+      break;
+
+
+      default:
+         return 0;
+   }
+
+
+   return 1;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK NewCallingCardProc( HWND hWnd,
+                                  UINT uMessage,
+                                  WPARAM wParam,
+                                  LPARAM lParam
+                                )
+{
+
+   PWSTR pTempPtr;
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_NAME];
+#endif
+
+// table of controls and context-sensitive help IDs
+    static DWORD aIds[] = {
+        IDCS_NC_NEW_CARD, IDH_TAPI_CREATE_CARD,
+        IDCE_NC_NEW_CARD, IDH_TAPI_CREATE_CARD,
+        0, 0
+    };
+
+
+   switch ( uMessage )
+   {
+
+
+      case WM_INITDIALOG:
+      {
+         SendDlgItemMessageW( hWnd,
+                             IDCE_NC_NEW_CARD,
+                             EM_LIMITTEXT,
+                             MAXLEN_NAME,
+                             0
+                           );
+
+      }
+      break;
+
+
+
+      case WM_HELP:
+      {
+         // Process clicks on controls after Context Help mode selected
+         InternalDebugOut(50, "  WM_HELP in NewCallingCardProc");
+
+         WinHelp (((LPHELPINFO) lParam)->hItemHandle, "windows.hlp", HELP_WM_HELP, 
+              (DWORD)(LPSTR) aIds);
+      }
+      break;
+
+
+
+      case WM_CONTEXTMENU:
+      {
+         // Process right-clicks on controls            
+         InternalDebugOut(50, "  WM_CONTEXTMENU in NewCallingCardProc");
+
+         WinHelp ((HWND) wParam, "windows.hlp", HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+      }
+      break;
+
+
+
+      case WM_COMMAND:
+      {
+         switch ( GET_WM_COMMAND_ID( wParam, lParam) )
+         {
+            case IDOK:
+            {
+               PCARD pNewCardList;
+               PCARD pNewCard;
+
+
+               InternalDebugOut(50, "  IDOK in NewCallingCardProc");
+
+               //
+               // Create a new card entry
+               //
+
+               pNewCardList = ClientAlloc((gpnStuff[2]+1) * sizeof(CARD));
+
+
+               //
+               // Copy the entire old list to the new buffer
+               //
+               CopyMemory( pNewCardList,
+                       gpCardList,
+                       gpnStuff[2] * sizeof(CARD)
+                     );
+
+
+               //
+               // Fill in the new card with defaults (empties)
+               //
+
+               pNewCard = &(pNewCardList[gpnStuff[2]]);
+               pNewCard->PinW[0] = '\0';
+               pNewCard->dwFlags = 0;
+
+
+               //
+               // Set the new name the user typed in
+               //
+#ifdef PARTIAL_UNICODE
+               GetDlgItemText( hWnd,
+                               IDCE_NC_NEW_CARD,
+                               szTempString,
+                               MAXLEN_NAME
+                             );
+               MultiByteToWideChar(
+                                    GetACP(),
+                                    MB_PRECOMPOSED,
+                                    szTempString,
+                                    -1,
+                                    pNewCard->NameW,
+                                    MAXLEN_NAME
+                                  );
+
+#else
+               GetDlgItemTextW( hWnd,
+                                IDCE_NC_NEW_CARD,
+                                pNewCard->NameW,
+                                MAXLEN_NAME
+                              );
+#endif
+
+               //
+               // If the user clicked w/no text in the name field, we'll
+               // treat it as a cancel.
+               //
+               if ( 0 == lstrlenW( pNewCard->NameW ) )
+               {
+                  ClientFree( pNewCardList );
+                  return 0;
+               }
+
+
+
+               {
+                  LPLINECOUNTRYENTRY  pCountryEntry;
+                  LPLINECOUNTRYLIST   pCountryList;
+
+
+                  if ( ReadCountries( &pCountryList, gpCurrentLocation->dwCountry, 0 ) )
+                  {
+//*** *** ***BUGBUG Handle error condition!")
+                      InternalDebugOut(1, "  GetCountryList failed!");
+                      EndDialog(hWnd, IDCANCEL);
+                  }
+
+                  pCountryEntry = (LPLINECOUNTRYENTRY)
+                         ((LPBYTE) pCountryList +
+                                   pCountryList->dwCountryListOffset);
+
+
+                  //
+                  // Take the rules from the country dialing rules
+                  //
+                  lstrcpyW( 
+                            pNewCard->LocalRuleW,
+                            (PWSTR)((LPBYTE)pCountryList +
+                                    pCountryEntry->dwSameAreaRuleOffset)
+                          );
+
+                  lstrcpyW( 
+                            pNewCard->LDRuleW,
+                            (PWSTR)((LPBYTE)pCountryList +
+                                    pCountryEntry->dwLongDistanceRuleOffset)
+                          );
+
+                  lstrcpyW( 
+                            pNewCard->InternationalRuleW,
+                            (PWSTR)((LPBYTE)pCountryList +
+                                    pCountryEntry->dwInternationalRuleOffset)
+                          );
+
+                  //
+                  // Having "I" in a country LD dialing rule could happen, but it's illegal
+                  // in a calling card dialing rule
+                  //
+                  while ( pTempPtr = wcschr(pNewCard->LDRuleW, L'I') )
+                  {
+                      *pTempPtr = L'F';
+                  }
+                  
+               }
+
+
+
+               //
+               // Get a proper new card ID
+               //
+               AllocNewID( HKEY_CURRENT_USER,
+                           &(pNewCard->dwID) );
+
+               
+               //
+               // The CardList is dead.  Long live the CardList.
+               //
+               ClientFree( gpCardList );
+               gpCardList = pNewCardList;
+
+
+               //
+               // This new card is now the current card for this location.
+               //
+               gpCurrentCard = pNewCard;
+
+               gpCurrentLocation->dwCallingCard = pNewCard->dwID;
+
+
+               gpnStuff[2]++;
+               
+               gdwChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+               EndDialog(hWnd, IDOK);
+            }
+            break;
+
+
+            case IDCANCEL:
+            {
+               EndDialog(hWnd, IDCANCEL);
+            }
+            break;
+
+         }
+      }
+      break;
+
+
+
+      default:
+         return 0;
+
+   }
+
+   return 1;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void DisplayThisCard( HWND hWnd, PCARD pCurrentCard )
+{
+
+#ifdef PARTIAL_UNICODE
+
+   CHAR szTempString[MAXLEN_NAME];
+
+   //
+   // Select the proper card
+   //
+   WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         gpCurrentCard->NameW,
+                         -1,
+                         szTempString,
+                         MAXLEN_NAME,
+                         NULL,
+                         NULL
+                       );
+
+   SendDlgItemMessage(
+                       hWnd,
+                       IDCC_DR_CARD_NAME,
+                       CB_SELECTSTRING,
+                       (WPARAM)-1,
+                       (LPARAM)szTempString
+                     );
+
+   //
+   // Display the Personal Identification Number
+   //
+   WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         gpCurrentCard->PinW,
+                         -1,
+                         szTempString,
+                         MAXLEN_PIN,
+                         NULL,
+                         NULL
+                       );
+
+    SetDlgItemText( hWnd,
+                    IDCE_DR_CARD_NUM,
+                    szTempString
+                  );
+
+#else
+
+   SendDlgItemMessageW(
+                       hWnd,
+                       IDCC_DR_CARD_NAME,
+                       CB_SELECTSTRING,
+                       (WPARAM)-1,
+                       (LPARAM)gpCurrentCard->NameW
+                     );
+
+    SetDlgItemTextW( hWnd,
+                    IDCE_DR_CARD_NUM,
+                    gpCurrentCard->PinW
+                  );
+#endif
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL CALLBACK CallingCardProc( HWND hWnd,
+                               UINT uMessage,
+                               WPARAM wParam,
+                               LPARAM lParam
+                             )
+{
+// table of controls and context-sensitive help IDs
+   static const DWORD aIds[] = {
+        IDCS_DR_CARD_NAME, IDH_TAPI_CALLCARDS,
+        IDCC_DR_CARD_NAME, IDH_TAPI_CALLCARDS,
+        IDCS_DR_CARD_NUM, IDH_TAPI_CALLCARD_NUMBER,
+        IDCE_DR_CARD_NUM, IDH_TAPI_CALLCARD_NUMBER,
+        IDCB_DR_NEW_CARD, IDH_TAPI_CALLCARD_ADD,
+        IDCB_DR_REMOVE_CARD, IDH_TAPI_CALLCARD_REMOVE,
+        IDCB_DR_ADVANCED, IDH_TAPI_CALLCARD_ADV,
+        0, 0
+   };
+
+   UINT n;
+//   static DWORD dwChangedFlags = 0;
+   WCHAR *pbuf1;
+   WCHAR *pbuf2;
+
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_RULE];
+#endif
+
+   switch ( uMessage )
+   {
+      case WM_INITDIALOG:
+      {
+         UINT nCurrentCallingCardID;
+
+
+         SendDlgItemMessage( hWnd,
+                             IDCC_DR_CARD_NAME,
+                             EM_LIMITTEXT,
+                             MAXLEN_NAME,
+                             0
+                           );
+         SendDlgItemMessage( hWnd,
+                             IDCE_DR_CARD_NUM,
+                             EM_LIMITTEXT,
+                             MAXLEN_PIN,
+                             0
+                           );
+
+
+
+         //
+         // Save the current location's calling card in case the user causes
+         // it to change but then changes his mind.
+         //
+         gdwSaveCallingCardID = gpCurrentLocation->dwCallingCard;
+
+
+         FillCardListbox( hWnd, &gpCardList, &gpnStuff );
+
+
+         nCurrentCallingCardID = 
+            gLocationList[
+                           GetLocationIndexFromID(
+                                                    gnCurrentLocationID,
+                                                    gLocationList,
+                                                    gnNumLocations
+                                                 )
+                         ].dwCallingCard;
+
+
+         n =   GetCardIndexFromID(
+                                   nCurrentCallingCardID,
+                                   gpCardList,
+                                   gpnStuff[2]
+                                  );
+                                  
+         if ( (UINT)(-1) == n )
+         {
+            n = 0;
+         }
+         
+                                  
+         gpCurrentCard = &gpCardList[n];
+                                
+
+
+        //
+        // If there's only one card, don't allow the user to delete it
+        //
+        if ( 
+               ( 1 == SendDlgItemMessage( hWnd,
+                                             IDCC_DR_CARD_NAME,
+                                             CB_GETCOUNT,
+                                             0,
+                                             0)
+               )
+            ||
+              (0 == gpCurrentCard->dwID)
+           )
+        {
+           EnableWindow( GetDlgItem(hWnd, IDCB_DR_REMOVE_CARD), FALSE );
+        }
+
+
+        //
+        // If none of the rules have a 'H', don't allow the user to enter
+        // a PIN
+        //
+        if (
+            !(
+                wcschr( gpCurrentCard->LocalRuleW, 'H')
+              ||
+                wcschr( gpCurrentCard->LDRuleW, 'H')
+              ||
+                wcschr( gpCurrentCard->InternationalRuleW, 'H')
+             )
+           )
+        {
+           EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), FALSE );
+           EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), FALSE );
+        }
+
+
+        DisplayThisCard(hWnd, gpCurrentCard);
+      }
+      break;
+
+
+
+      case WM_HELP:
+      {
+         WinHelp (((LPHELPINFO) lParam)->hItemHandle, "windows.hlp", HELP_WM_HELP,
+            (DWORD)(LPSTR) aIds);
+      }
+      break;
+
+
+
+      case WM_CONTEXTMENU:
+      {
+         WinHelp ((HWND) wParam, "windows.hlp", HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+      }
+      break;
+
+
+
+      case WM_COMMAND:
+      {
+         switch ( GET_WM_COMMAND_ID( wParam, lParam) )
+         {
+            case IDCC_DR_CARD_NAME:
+            {
+               if ((GET_WM_COMMAND_CMD(wParam, lParam)) == CBN_SELCHANGE)
+               {
+                  UINT  nThisItemIndex;
+
+
+                  nThisItemIndex = SendDlgItemMessage( hWnd,
+                                                       IDCC_DR_CARD_NAME,
+                                                       CB_GETCURSEL,
+                                                       0,
+                                                       0
+                                                     );
+                  gpCurrentCard = (PCARD)SendDlgItemMessage( hWnd,
+                                                             IDCC_DR_CARD_NAME,
+                                                             CB_GETITEMDATA,
+                                                             nThisItemIndex,
+                                                             0
+                                                           );
+
+
+#ifdef PARTIAL_UNICODE
+                   WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         gpCurrentCard->PinW,
+                         -1,
+                         szTempString,
+                         MAXLEN_PIN,
+                         NULL,
+                         NULL
+                       );
+
+                  //
+                  // Display the Personal Identification Number
+                  //
+                  SetDlgItemText( hWnd,
+                                  IDCE_DR_CARD_NUM,
+                                  szTempString
+                                );
+#else
+                  //
+                  // Display the Personal Identification Number
+                  //
+                  SetDlgItemTextW( hWnd,
+                                  IDCE_DR_CARD_NUM,
+                                  gpCurrentCard->PinW
+                                );
+#endif
+
+                  //
+                  // Put the new calling card ID into the current location
+                  //
+                  gpCurrentLocation->dwCallingCard = gpCurrentCard->dwID;
+
+               }
+               else
+               {
+                  //
+                  // Is the user typing in the name edit field?
+                  //
+                  if (GET_WM_COMMAND_CMD(wParam, lParam) == CBN_EDITCHANGE)
+                  {
+                     //BUGBUG handle this case
+                  }
+               }
+
+               //
+               // If the user is selecting the Magic card, don't allow
+               // him to delete it
+               //
+               if ( 0 == gpCurrentCard->dwID )
+               {
+                  EnableWindow( GetDlgItem(hWnd, IDCB_DR_REMOVE_CARD), FALSE );
+               }
+               else
+               {
+                  EnableWindow( GetDlgItem(hWnd, IDCB_DR_REMOVE_CARD), TRUE );
+               }
+
+               //
+               // If none of the rules have a 'H', don't allow the user to enter
+               // a PIN
+               //
+               if (
+                       wcschr( gpCurrentCard->LocalRuleW, 'H')
+                     ||
+                       wcschr( gpCurrentCard->LDRuleW, 'H')
+                     ||
+                       wcschr( gpCurrentCard->InternationalRuleW, 'H')
+                  )
+               {
+                  EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), TRUE );
+                  EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), TRUE );
+               }
+               else
+               {
+                  EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), FALSE );
+                  EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), FALSE );
+               }
+
+            }
+            break;
+
+
+
+            case IDCE_DR_CARD_NUM:
+            {
+               if ( EN_CHANGE == HIWORD(wParam) )
+               {
+
+#ifdef PARTIAL_UNICODE
+                  GetDlgItemText( hWnd,
+                                  LOWORD(wParam),
+                                  szTempString,
+                                  MAXLEN_PIN
+                                );
+
+                  MultiByteToWideChar(
+                                       GetACP(),
+                                       MB_PRECOMPOSED,
+                                       szTempString,
+                                       -1,
+                                       gpCurrentCard->PinW,
+                                       MAXLEN_PIN
+                                     );
+#else
+                  GetDlgItemTextW( hWnd,
+                                   LOWORD(wParam),
+                                   gpCurrentCard->PinW,
+                                   MAXLEN_PIN
+                                 );
+
+#endif
+
+                  gdwChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+               }
+            }
+            break;
+
+            
+
+            case IDCB_DR_NEW_CARD:
+            {
+               int n;
+
+               n = DialogBoxW( ghInst,
+                               MAKEINTRESOURCEW(IDD_NEW_CARD),
+                               hWnd,
+                               NewCallingCardProc
+                             );
+
+               //
+               // Show the user.
+               //
+
+               FillCardListbox( hWnd, &gpCardList, &gpnStuff );
+
+               DisplayThisCard(hWnd, gpCurrentCard);
+
+//               SetFocus( GetDlgItem( hWnd, IDCE_DR_CARD_NUM ) );
+
+               //
+               // If user pressed OK, get the rules
+               //
+               if ( IDOK == n )
+               {
+                  pbuf1 = ClientAlloc( 256 * sizeof(WCHAR) );
+                  pbuf2 = ClientAlloc( 512 * sizeof(WCHAR) );
+
+                  LoadStringW(ghInst, IDS_WRN_RULESNEEDED,    pbuf1, 512);
+                  LoadStringW(ghInst, DIALINGPROPERTIES_NAME, pbuf2, 256);
+
+                  MessageBoxW( hWnd,
+                               pbuf1,
+                               pbuf2,
+                               MB_OK
+                             );
+
+                  ClientFree( pbuf1 );
+                  ClientFree( pbuf2 );
+
+                  SendMessage( hWnd, WM_COMMAND, IDCB_DR_ADVANCED, 0 );
+                  
+                  //
+                  // We now _know_ we have at least two calling cards and that the
+                  // new one (that currently is selected, _can_ be deleted, so
+                  // make sure the REMOVE button is enabled
+                  // (if the CANCEL was pressed we wouldn't be here and we want to
+                  // leave the button state as-is anyway)
+                  //
+                  EnableWindow( GetDlgItem(hWnd, IDCB_DR_REMOVE_CARD), TRUE );
+               }
+
+            }
+            break;
+
+
+
+            case IDCB_DR_REMOVE_CARD:
+            {
+
+               pbuf1 = ClientAlloc( 512 * sizeof(WCHAR) );
+
+               //
+               // Is the user trying to delete the "None" card?
+               //
+               if ( 0 == gpCurrentCard->dwID )
+               {
+
+                  LoadStringW(ghInst, IDS_WRN_CANT_REMOVE_LAST_CARD, pbuf1, 512 );
+//                  LoadString(ghInst, IDS_WRN_TITLE_SURE, buf2, 512 );
+
+                  MessageBoxW( hWnd,
+                               pbuf1,
+                               L"", //buf2,
+                               MB_OK | MB_ICONWARNING
+                             );
+
+                  ClientFree( pbuf1 );
+
+                  break;
+               }
+
+
+               pbuf2 = ClientAlloc( 512 * sizeof(WCHAR) );
+
+               LoadStringW(ghInst, REMOVE_CARD,        pbuf1, 512);
+               LoadStringW(ghInst, IDS_WRN_TITLE_SURE, pbuf2, 512);
+
+               if ( MessageBoxW( hWnd,
+                                 pbuf1,
+                                 pbuf2,
+                                 MB_YESNO | MB_DEFBUTTON2
+                               )
+                              == IDYES )
+               {
+                  //
+                  // Mark this card as dead
+                  //
+
+                  //
+                  // If it's a "system" card, don't really delete it,
+                  // just "hide" it
+                  //
+                  if ( gpCurrentCard->dwFlags & CARD_BUILTIN )
+                  {
+                     gpCurrentCard->dwFlags |= CARD_HIDE;
+                  }
+                  else
+                  {
+                     gpCurrentCard->NameW[0] = '\0';
+                  }
+
+                  gdwChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+                  //
+                  // Update stuff for the user.
+                  //
+
+                  FillCardListbox( hWnd, &gpCardList, &gpnStuff );
+
+                  //
+                  // The user deleted the current card so let's drop
+                  // back to the Zero'th card as the current one.
+                  //
+                  for ( n=0; n<gpnStuff[2]; n++)
+                  {
+                     if ( gpCardList[n].NameW[0] != '\0' )
+                     {
+                        break;
+                     }
+                  }
+
+                  //
+                  // Make sure the focus is not "stuck" on the remove
+                  // button (in case it's disabled)
+                  //
+                  SetFocus(GetDlgItem(hWnd, IDOK));
+
+                  gpCurrentCard = &gpCardList[n];
+                  gpCurrentLocation->dwCallingCard = gpCurrentCard->dwID;
+
+
+                  //
+                  // If none of the rules have a 'H', don't allow the user to enter
+                  // a PIN
+                  //
+                  if (
+                          wcschr( gpCurrentCard->LocalRuleW, 'H')
+                        ||
+                          wcschr( gpCurrentCard->LDRuleW, 'H')
+                        ||
+                          wcschr( gpCurrentCard->InternationalRuleW, 'H')
+                     )
+                  {
+                     EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), TRUE );
+                     EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), TRUE );
+                  }
+                  else
+                  {
+                     EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), FALSE );
+                     EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), FALSE );
+                  }
+
+
+                  //
+                  // If there's only one card, or if it's the "magic" card,
+                  // don't allow the user to delete it
+                  //
+                  if ( 
+                        (0 == gpCurrentCard->dwID)
+                      ||
+                        (1 == SendDlgItemMessage( hWnd,
+                                                IDCC_DR_CARD_NAME,
+                                                CB_GETCOUNT,
+                                                0,
+                                                0)
+                        )                        
+                     )
+                  {
+                     EnableWindow( GetDlgItem(hWnd, IDCB_DR_REMOVE_CARD), FALSE );
+                  }
+
+                  DisplayThisCard(hWnd, gpCurrentCard);
+
+               }
+
+               ClientFree( pbuf1 );
+               ClientFree( pbuf2 );
+            }
+            break;
+
+
+
+            case IDCB_DR_ADVANCED:
+            {
+               DialogBoxW( ghInst,
+                          MAKEINTRESOURCEW(IDD_DIALING_RULES),
+                          hWnd,
+                          AdvancedCallingCardProc
+                        );
+               //
+               // If none of the rules have a 'H', don't allow the user to enter
+               // a PIN
+               //
+               if (
+                       wcschr( gpCurrentCard->LocalRuleW, 'H')
+                     ||
+                       wcschr( gpCurrentCard->LDRuleW, 'H')
+                     ||
+                       wcschr( gpCurrentCard->InternationalRuleW, 'H')
+                  )
+               {
+                  EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), TRUE );
+                  EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), TRUE );
+               }
+               else
+               {
+                  EnableWindow( GetDlgItem( hWnd, IDCE_DR_CARD_NUM), FALSE );
+                  EnableWindow( GetDlgItem( hWnd, IDCS_DR_CARD_NUM), FALSE );
+               }
+
+            }
+            break;
+
+
+
+            case IDOK:
+            {
+               //
+               // Did we get a PIN if one is needed?
+               //
+               //BUGBUG: If the user has the PIN blank but switches to
+               // another card, we won't catch it cause we only check
+               // the current card
+               //
+               if (
+                     (
+                        (wcschr(gpCurrentCard->LocalRuleW, 'H'))
+                      ||
+                        (wcschr(gpCurrentCard->LDRuleW, 'H'))
+                      ||
+                        (wcschr(gpCurrentCard->InternationalRuleW, 'H'))
+                     )
+                   &&
+                     (lstrlenW(gpCurrentCard->PinW) == 0)
+                  )
+               {
+                  pbuf1 = ClientAlloc( 512 * sizeof(WCHAR) );
+                  pbuf2 = ClientAlloc( 512 * sizeof(WCHAR) );
+
+                  LoadStringW( ghInst,
+                               IDS_WRN_CARD_NUMBER_REQUIRED,
+                               pbuf1,
+                               512
+                             );
+
+                  LoadStringW( ghInst,
+                               IDS_WRN_TITLE_REQUIRED,
+                               pbuf2,
+                               512
+                             );
+
+                  MessageBoxW( hWnd,
+                               pbuf1,
+                               pbuf2,
+                               MB_OK
+                             );
+
+                  SetFocus( GetDlgItem( hWnd, IDCE_DR_CARD_NUM ) );
+
+                  ClientFree( pbuf1 );
+                  ClientFree( pbuf2 );
+
+                  break;
+               }
+
+               WriteCards( gpCardList, gpnStuff[2], gdwChangedFlags);
+               EndDialog(hWnd, IDOK);
+            }
+            break;
+
+
+
+            case IDCANCEL:
+            {
+InternalDebugOut(0, "IDCANCEL");
+
+               gpCurrentLocation->dwCallingCard = gdwSaveCallingCardID;
+
+               EndDialog(hWnd, IDCANCEL);
+            }
+            break;
+
+
+
+            default:
+            break;
+         }
+      }
+      break;
+
+
+
+      default:
+         return 0;
+
+   }
+
+   return 1;
+}
diff --git a/private/tapi/dev/client/card.h b/private/tapi/dev/client/card.h
new file mode 100644
index 000000000..ffbf61938
--- /dev/null
+++ b/private/tapi/dev/client/card.h
@@ -0,0 +1,64 @@
+//***************************************************************************
+typedef struct {
+
+        DWORD dwID;
+
+#define MAXLEN_CARDNAME            96
+        WCHAR NameW[MAXLEN_CARDNAME];
+
+
+#define MAXLEN_PIN                 96
+        WCHAR PinW[MAXLEN_PIN];
+
+
+//Card3=3,"AT&T via 1-800-321-0288","","G","18003210288$TFG$TH","18003210288$T01EFG$TH",1
+
+#define MAXLEN_RULE                128
+        WCHAR LocalRuleW[MAXLEN_RULE];
+        WCHAR LDRuleW[MAXLEN_RULE];
+        WCHAR InternationalRuleW[MAXLEN_RULE];
+
+        DWORD dwFlags;
+             #define CARD_BUILTIN  1
+             #define CARD_HIDE     2
+
+               } CARD, *PCARD;
+
+
+extern PCARD gCardList;
+//extern UINT gnNumCards;
+//UINT gnCurrentCardID = 0;
+
+extern DWORD *gpnStuff;
+extern PCARD gpCardList;
+extern PCARD gpCurrentCard;
+
+
+//***************************************************************************
+//***************************************************************************
+BOOL  UtilGetEditNumStr( HWND  hWnd,
+                                 UINT  uControl,
+                                 UINT  nExtendNum );
+
+//***************************************************************************
+//***************************************************************************
+enum DWORD {
+        UTIL_BIG_EXTENDED,
+        UTIL_NUMBER
+     };
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL ReadCardsEasy(
+                           PCARD  *pCardSpace,
+                           LPUINT *pnStuff );
+
+LONG PASCAL GetCardIndexFromID( UINT nID,
+                                PCARD pCallersList,
+                                UINT nCallersNumCards );
+
+void PASCAL WriteCards( PCARD pCardList, UINT nNumCards,
+                 DWORD dwChangedFlags);
+
diff --git a/private/tapi/dev/client/ccard1.ico b/private/tapi/dev/client/ccard1.ico
new file mode 100644
index 000000000..99f0bf5e8
--- /dev/null
+++ b/private/tapi/dev/client/ccard1.ico
diff --git a/private/tapi/dev/client/client.c b/private/tapi/dev/client/client.c
new file mode 100644
index 000000000..ec2db25b3
--- /dev/null
+++ b/private/tapi/dev/client/client.c
@@ -0,0 +1,14345 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    client.c
+
+Abstract:
+    
+    This module contains the tapi.dll implementation (client-side tapi)
+
+Author:
+
+    Dan Knudson (DanKn)    01-Apr-1995
+
+Revision History:
+
+
+Notes:
+
+    1. Make all funcArg structs STATIC, & just do whatever mov's necessary
+       for the params (saves mov's for flags, pfnPostProcess, funcName, &
+       argTypes)
+
+--*/
+
+
+#include "windows.h"
+#include "wownt32.h"
+#include "stdarg.h"
+#include "stdio.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "client.h"
+#include "private.h"
+#include "tapsrv.h"
+#include "clientr.h"
+#include "prsht.h"
+#include "shellapi.h"
+#include "..\perfdll\tapiperf.h"
+
+
+#undef   lineBlindTransfer
+#undef   lineConfigDialog
+#undef   lineConfigDialogEdit
+#undef   lineDial
+#undef   lineForward
+#undef   lineGatherDigits
+#undef   lineGenerateDigits
+#undef   lineGetAddressCaps
+#undef   lineGetAddressID
+#undef   lineGetAddressStatus
+#undef   lineGetCallInfo
+#undef   lineGetDevCaps
+#undef   lineGetDevConfig
+#undef   lineGetIcon
+#undef   lineGetID
+#undef   lineGetLineDevStatus
+#undef   lineGetRequest
+#undef   lineGetTranslateCaps
+#undef   lineHandoff
+#undef   lineMakeCall
+#undef   lineOpen
+#undef   linePark
+#undef   linePickup
+#undef   linePrepareAddToConference
+#undef   lineRedirect
+#undef   lineSetDevConfig
+#undef   lineSetTollList
+#undef   lineSetupConference
+#undef   lineSetupTransfer
+#undef   lineTranslateAddress
+#undef   lineUnpark
+#undef   phoneConfigDialog
+#undef   phoneGetButtonInfo
+#undef   phoneGetDevCaps
+#undef   phoneGetIcon
+#undef   phoneGetID
+#undef   phoneGetStatus
+#undef   phoneSetButtonInfo
+#undef   tapiGetLocationInfo
+#undef   tapiRequestMakeCall
+#undef   tapiRequestMediaCall
+#undef   lineAddProvider
+#undef   lineGetAppPriority
+#undef   lineGetCountry
+#undef   lineGetProviderList
+#undef   lineSetAppPriority
+#undef   lineTranslateDialog
+
+    
+//
+//
+//
+
+#define ASNYC_MSG_BUF_SIZE 1024
+
+typedef struct _ASYNC_EVENTS_THREAD_PARAMS
+{
+    BOOL    bExitThread;
+
+    DWORD   dwBufSize;
+
+    HANDLE  hTapi32;
+
+    HANDLE  hWow32;
+
+    LPBYTE  pBuf;
+
+} ASYNC_EVENTS_THREAD_PARAMS, *PASYNC_EVENTS_THREAD_PARAMS;
+
+
+//
+// Global vars
+//
+
+BOOL    gbNTVDMClient        = FALSE;
+BOOL    gbResourcesAllocated = FALSE;
+DWORD   gdwNumInits          = 0;
+DWORD   gdwTlsIndex;
+DWORD   gdwNumLineDevices    = 0;
+DWORD   gdwNumPhoneDevices   = 0;
+HANDLE  ghAsyncEventsEvent   = NULL;
+HANDLE  ghInitMutex;
+
+extern BOOL     gbTranslateSimple;
+extern BOOL     gbTranslateSilent;
+
+HINSTANCE  ghInst;
+
+PASYNC_EVENTS_THREAD_PARAMS gpAsyncEventsThreadParams = NULL;
+
+#if DBG
+WCHAR   gszTapi32DebugLevel[] = L"Tapi32DebugLevel";
+#endif
+WCHAR   gszTapi32MaxNumRequestRetries[] = L"Tapi32MaxNumRequestRetries";
+WCHAR   gszTapi32RequestRetryTimeout[] = L"Tapi32RequestRetryTimeout";
+extern WCHAR gszTelephonyKey[];
+
+DWORD   gdwMaxNumRequestRetries;
+DWORD   gdwRequestRetryTimeout;
+
+char    szTapi32WndClass[]    = "Tapi32WndClass";
+    
+CHAR  gszTUISPI_providerConfig[]        = "TUISPI_providerConfig";
+CHAR  gszTUISPI_providerGenericDialog[] = "TUISPI_providerGenericDialog";
+CHAR  gszTUISPI_providerGenericDialogData[] = "TUISPI_providerGenericDialogData";
+CHAR  gszTUISPI_providerInstall[]       = "TUISPI_providerInstall";
+CHAR  gszTUISPI_providerRemove[]        = "TUISPI_providerRemove";
+CHAR  gszTUISPI_lineConfigDialog[]      = "TUISPI_lineConfigDialog";
+CHAR  gszTUISPI_lineConfigDialogEdit[]  = "TUISPI_lineConfigDialogEdit";
+CHAR  gszTUISPI_phoneConfigDialog[]     = "TUISPI_phoneConfigDialog";
+
+//extern WCHAR  gszLocationKeyW[];
+extern WCHAR  gszLocationsW[];
+extern WCHAR  gszNumEntriesW[];
+
+
+HINSTANCE   ghWow32Dll = NULL;
+FARPROC     gpfnWOWGetVDMPointer = NULL;
+
+PUITHREADDATA   gpUIThreadInstances = NULL;
+
+CRITICAL_SECTION        gCriticalSection;
+CRITICAL_SECTION        gUICriticalSection;
+PCONTEXT_HANDLE_TYPE    gphCx = (PCONTEXT_HANDLE_TYPE) NULL;
+
+#if DBG
+char *aszMsgs[] =
+{
+    "LINE_ADDRESSSTATE",
+    "LINE_CALLINFO",
+    "LINE_CALLSTATE",
+    "LINE_CLOSE",
+    "LINE_DEVSPECIFIC",
+    "LINE_DEVSPECIFICFEATURE",
+    "LINE_GATHERDIGITS",
+    "LINE_GENERATE",
+    "LINE_LINEDEVSTATE",
+    "LINE_MONITORDIGITS",
+    "LINE_MONITORMEDIA",
+    "LINE_MONITORTONE",
+    "LINE_REPLY",
+    "LINE_REQUEST",
+    "PHONE_BUTTON",
+    "PHONE_CLOSE",
+    "PHONE_DEVSPECIFIC",
+    "PHONE_REPLY",
+    "PHONE_STATE",
+    "LINE_CREATE",
+    "PHONE_CREATE",
+    "LINE_AGENTSPECIFIC",
+    "LINE_AGENTSTATUS",
+    "LINE_APPNEWCALL",
+    "LINE_PROXYREQUEST",
+    "LINE_REMOVE",
+    "PHONE_REMOVE"
+};
+#endif
+
+LONG gaNoMemErrors[3] =
+{
+    TAPIERR_REQUESTFAILED,
+    LINEERR_NOMEM,
+    PHONEERR_NOMEM
+};
+
+LONG gaInvalHwndErrors[3] =
+{
+    TAPIERR_INVALWINDOWHANDLE,
+    LINEERR_INVALPARAM,
+    PHONEERR_INVALPARAM
+};
+
+LONG gaInvalPtrErrors[3] =
+{
+    TAPIERR_INVALPOINTER,
+    LINEERR_INVALPOINTER,
+    PHONEERR_INVALPOINTER
+};
+
+LONG gaOpFailedErrors[3] =
+{
+    TAPIERR_REQUESTFAILED,
+    LINEERR_OPERATIONFAILED,
+    PHONEERR_OPERATIONFAILED
+};
+
+LONG gaStructTooSmallErrors[3] =
+{
+    TAPIERR_REQUESTFAILED,
+    LINEERR_STRUCTURETOOSMALL,
+    PHONEERR_STRUCTURETOOSMALL
+};
+
+
+#define AllInitExOptions2_0                           \
+        (LINEINITIALIZEEXOPTION_USEHIDDENWINDOW     | \
+        LINEINITIALIZEEXOPTION_USEEVENT             | \
+        LINEINITIALIZEEXOPTION_USECOMPLETIONPORT)
+
+
+//
+// Function prototypes
+//
+
+void
+PASCAL
+lineMakeCallPostProcess(
+    PASYNCEVENTMSG  pMsg
+    );
+
+LONG
+WINAPI
+AllocClientResources(
+    DWORD   dwErrorClass
+    );
+
+BOOL
+WINAPI
+_CRT_INIT(
+    HINSTANCE   hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    );
+
+LONG
+CreateHiddenWindow(
+    HWND   *lphwnd,
+    DWORD   dwErrorClass
+    );
+
+void
+FreeInitData(
+    PINIT_DATA  pInitData
+    );
+
+LONG
+WINAPI
+FreeClientResources(
+    void
+    );
+
+LONG
+CALLBACK
+TUISPIDLLCallback(
+    DWORD   dwObjectID,
+    DWORD   dwObjectType,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    );
+
+BOOL
+CALLBACK
+TranslateDlgProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+void
+UIThread(
+    LPVOID  pParams
+    );
+
+char *
+PASCAL
+MapResultCodeToText(
+    LONG    lResult,
+    char   *pszResult
+    );
+
+void
+PASCAL
+lineDevSpecificPostProcess(
+    PASYNCEVENTMSG pMsg
+    );
+
+LONG
+PASCAL
+xxxShutdown(
+    DWORD   hXXXApp,
+    BOOL    bLineShutdown
+    );
+
+LONG
+PASCAL
+xxxGetMessage(
+    BOOL            bLine,
+    PINIT_DATA      pInitData,
+    LPLINEMESSAGE   pMsg,
+    DWORD           dwTimeout
+    );
+
+
+//
+// The code...
+//
+
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+PWSTR
+PASCAL
+NotSoWideStringToWideString(
+    LPCSTR  lpStr,
+    DWORD   dwLength
+    )
+{
+   DWORD dwSize;
+   PWSTR pwStr;
+
+
+   if (IsBadStringPtrA (lpStr, dwLength))
+   {
+      return NULL;
+   }
+
+   dwSize = MultiByteToWideChar(
+       GetACP(),
+       MB_PRECOMPOSED,
+       lpStr,
+       dwLength,
+       NULL,
+       0
+       );
+
+   pwStr = ClientAlloc( dwSize * sizeof(WCHAR) );
+
+   MultiByteToWideChar(
+       GetACP(),
+       MB_PRECOMPOSED,
+       lpStr,
+       dwLength,
+       pwStr,
+       dwSize
+       );
+
+   return pwStr;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//
+//NOTE: This function requires that lpBase is a pointer to the start of
+//      a TAPI struct that has dwTotalSize as the first DWORD
+//
+void
+PASCAL
+WideStringToNotSoWideString(
+    LPBYTE  lpBase,
+    LPDWORD lpdwXxxSize
+    )
+{
+    DWORD  dwSize;
+    DWORD  dwNewSize;
+    DWORD  dwOffset;
+    DWORD  dwTotalSize;
+    DWORD  dwUsedSize;
+    PWSTR  pString;
+    PSTR   lpszStringA;
+
+
+    if ((dwSize = *lpdwXxxSize) != 0)
+    {
+        dwTotalSize = *((LPDWORD) lpBase);
+
+        dwUsedSize = *(((LPDWORD) lpBase)+2);
+
+        dwOffset = *(lpdwXxxSize + 1);
+
+        pString = (PWSTR)(lpBase + dwOffset);
+
+
+        if (IsBadStringPtrW (pString, dwSize))
+        {
+           DBGOUT((1, "The service provider returned an invalid field in the structure 0x08lx : 0x08lx",
+                          lpBase, lpdwXxxSize));
+
+           *lpdwXxxSize     = 0;
+           *(lpdwXxxSize+1) = 0;
+
+           return;
+        }
+
+        
+        //
+        // Did we get enough chars?
+        //
+
+        if (dwUsedSize > dwOffset )
+        {
+            dwNewSize = WideCharToMultiByte(
+                GetACP(),
+                0,
+                pString,
+                ( dwUsedSize >= (dwOffset+dwSize)) ?
+                    (dwSize/sizeof(WCHAR)) :
+                    (dwUsedSize - dwOffset) / sizeof(WCHAR),
+                NULL,
+                0,
+                NULL,
+                NULL
+                );
+
+            lpszStringA = ClientAlloc( dwNewSize + 1 );
+
+            if ( NULL == lpszStringA )
+            {
+               DBGOUT((1, "Memory alloc failed - alloc(0x%08lx)",
+                                             dwSize));
+               DBGOUT((1, "The service provider returned an invalid field size in the structure 0x08lx : 0x08lx",
+                              dwSize));
+
+               *lpdwXxxSize     = 0;
+               *(lpdwXxxSize+1) = 0;
+
+               return;
+            }
+
+            lpszStringA[dwNewSize]     = '\0';
+
+            WideCharToMultiByte(
+                GetACP(),
+                0,
+                pString,
+//                dwSize,
+                ( dwUsedSize >= (dwOffset+dwSize)) ?
+                    (dwSize/sizeof(WCHAR)) :
+                    (dwUsedSize - dwOffset) / sizeof(WCHAR),
+                lpszStringA,
+                dwNewSize,
+                NULL,
+                NULL
+                );
+
+            //
+            // Copy the new ANSI string back to where the Unicode string was
+            // and write out NULL terminator if possible.
+            //
+
+            CopyMemory ( (LPBYTE) pString,
+                         lpszStringA,
+                         dwNewSize + (
+                                      ((dwNewSize + dwOffset) < dwUsedSize ) ?
+                                      1 :
+                                      0
+                                     )
+                       );
+
+            ClientFree (lpszStringA);
+
+
+            //
+            // Update the number of bytes
+            //
+
+            *lpdwXxxSize = dwNewSize;
+        }
+    }
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+    {
+        ghInst = hDLL;
+
+
+        //
+        // Init CRT
+        //
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            OutputDebugString(
+                "TAPI32.DLL: DLL_PROCESS_ATTACH, _CRT_INIT() failed\n"
+                );
+
+            return FALSE;
+        }
+
+        {
+            HKEY  hKey;
+
+
+#if DBG
+            gdwDebugLevel = 0;
+#endif
+            gdwMaxNumRequestRetries = 40;
+            gdwRequestRetryTimeout = 250; // milliseconds
+
+            if (RegOpenKeyExW(
+                    HKEY_LOCAL_MACHINE,
+                    gszTelephonyKey,
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKey
+
+                    ) == ERROR_SUCCESS)
+            {
+                DWORD dwDataSize = sizeof(DWORD), dwDataType;
+
+#if DBG
+                RegQueryValueExW(
+                    hKey,
+                    gszTapi32DebugLevel,
+                    0,
+                    &dwDataType,
+                    (LPBYTE) &gdwDebugLevel,
+                    &dwDataSize
+                    );
+
+                dwDataSize = sizeof(DWORD);
+#endif
+
+                RegQueryValueExW(
+                    hKey,
+                    gszTapi32MaxNumRequestRetries,
+                    0,
+                    &dwDataType,
+                    (LPBYTE) &gdwMaxNumRequestRetries,
+                    &dwDataSize
+                    );
+
+                RegQueryValueExW(
+                    hKey,
+                    gszTapi32RequestRetryTimeout,
+                    0,
+                    &dwDataType,
+                    (LPBYTE) &gdwRequestRetryTimeout,
+                    &dwDataSize
+                    );
+
+                RegCloseKey (hKey);
+            }
+        }
+
+        DBGOUT((2, "DLL_PROCESS_ATTACH, pid = %ld", GetCurrentProcessId()));
+
+
+        //
+        // Alloc a Tls index
+        //
+
+        if ((gdwTlsIndex = TlsAlloc()) == 0xffffffff)
+        {
+            DBGOUT((1, "DLL_PROCESS_ATTACH, TlsAlloc() failed"));
+
+            return FALSE;
+        }
+
+
+        //
+        // Initialize Tls to NULL for this thread
+        //
+
+        TlsSetValue (gdwTlsIndex, NULL);
+
+
+        //
+        //
+        //
+
+        ghInitMutex = CreateMutex (NULL, FALSE, NULL);
+
+        InitializeCriticalSection (&gCriticalSection);
+        InitializeCriticalSection (&gUICriticalSection);
+
+
+        break;
+    }
+    case DLL_PROCESS_DETACH:
+    {
+        PCLIENT_THREAD_INFO pTls;
+
+
+        DBGOUT((2, "DLL_PROCESS_DETACH, pid = %ld", GetCurrentProcessId()));
+
+
+        //
+        // Clean up any Tls
+        //
+
+        if ((pTls = (PCLIENT_THREAD_INFO) TlsGetValue (gdwTlsIndex)))
+        {
+            if (pTls->pBuf)
+            {
+                ClientFree (pTls->pBuf);
+            }
+
+            ClientFree (pTls);
+        }
+
+
+        FreeClientResources();
+
+        TlsFree (gdwTlsIndex);
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            DBGOUT((1, "_CRT_INIT() failed"));
+        }
+
+        DeleteCriticalSection (&gCriticalSection);
+        DeleteCriticalSection (&gUICriticalSection);
+
+        break;
+    }
+    case DLL_THREAD_ATTACH:
+
+        //
+        // First must init CRT
+        //
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            DBGOUT((1, "_CRT_INIT() failed"));
+
+            return FALSE;
+        }
+
+        DBGOUT((
+            3,
+            "DLL_THREAD_ATTACH, pid = %ld, tid = %ld",
+            GetCurrentProcessId(),
+            GetCurrentThreadId()
+            ));
+
+
+        //
+        // Initialize Tls to NULL for this thread
+        //
+
+        TlsSetValue (gdwTlsIndex, NULL);
+
+        break;
+
+    case DLL_THREAD_DETACH:
+    {
+        PCLIENT_THREAD_INFO pTls;
+
+
+        DBGOUT((
+            3,
+            "DLL_THREAD_DETACH, pid = %ld, tid = %ld",
+            GetCurrentProcessId(),
+            GetCurrentThreadId()
+            ));
+
+
+        //
+        // Clean up any Tls
+        //
+
+        if ((pTls = (PCLIENT_THREAD_INFO) TlsGetValue (gdwTlsIndex)))
+        {
+            if (pTls->pBuf)
+            {
+                ClientFree (pTls->pBuf);
+            }
+
+            ClientFree (pTls);
+        }
+
+
+        //
+        // Finally, alert CRT
+        //
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            DBGOUT((1, "_CRT_INIT() failed"));
+        }
+
+        break;
+    }
+
+    } // switch
+
+    return TRUE;
+}
+
+
+void
+AsyncEventsThread(
+    PASYNC_EVENTS_THREAD_PARAMS pAsyncEventsThreadParams
+    )
+{
+    BOOL           *pbExitThread = &pAsyncEventsThreadParams->bExitThread,
+                    bRetry;
+    DWORD           dwBufSize    = pAsyncEventsThreadParams->dwBufSize;
+    LPBYTE          pBuf         = pAsyncEventsThreadParams->pBuf;
+    PTAPI32_MSG     pMsg         = (PTAPI32_MSG) pBuf;
+    static FARPROC  pPostQueuedCompletionStatus = NULL;
+
+
+    DBGOUT((3, "AsyncEventsThread: enter"));
+
+
+    //
+    // Just loop reading async events/completions from server &
+    // handling them
+    //
+
+    while (1)
+    {
+        DWORD           dwUsedSize, dwNeededSize;
+        PASYNCEVENTMSG  pAsyncEventMsg;
+
+
+        //
+        // Check to see if xxxShutdown or FreeClientResources
+        // is signaling us to exit (we need to check both before
+        // & after the wait to dela with a event setting/resetting
+        // race condition between FreeClientResources & Tapisrv)
+        //
+
+        if (*pbExitThread)
+        {
+            break;
+        }
+
+
+        //
+        // Block until tapisrv signals us that it has some event data for us
+        //
+
+        WaitForSingleObject (ghAsyncEventsEvent, INFINITE);
+
+
+        //
+        // Check to see if xxxShutdown or FreeClientResources
+        // is signaling us to exit
+        //
+
+        if (*pbExitThread)
+        {
+            break;
+        }
+
+
+        //
+        // Retrieve the data from tapisrv
+        //
+
+AsyncEventsThread_clientRequest:
+
+        do
+        {
+            pMsg->u.Req_Func     = xGetAsyncEvents;
+            pMsg->Params[0]      = dwBufSize - sizeof (TAPI32_MSG);
+
+            dwUsedSize = 3 * sizeof (DWORD);
+
+            RpcTryExcept
+            {
+                ClientRequest (gphCx, (char *) pMsg, dwBufSize, &dwUsedSize);
+                bRetry = FALSE;
+            }
+            RpcExcept (1)
+            {
+                bRetry = !(*pbExitThread);
+                DBGOUT((
+                    2,
+                    "AsyncEventsThread: rpc exception %d handled",
+                    RpcExceptionCode()
+                    ));
+                Sleep (10);
+            }
+            RpcEndExcept
+
+        } while (bRetry);
+
+#if DBG
+//        DBGOUT((
+//                84,
+//                "AsyncEventsThread: CliReq ret'd, dwBufSize=0x%08lx usedSize=0x%08lx other=0x%08lx",
+//                dwBufSize,
+//                dwUsedSize,
+//                pMsg->Params[2]
+//            dwUsedSize
+//            ));
+        if ( 
+              ( dwUsedSize > dwBufSize )
+            ||
+              ( pMsg->Params[2] > dwBufSize )
+           )
+        {
+            DBGOUT((1,  "OVERFLOW!!!"));
+
+            DBGOUT((1,  "Watch this..."));
+            ClientFree( ClientAlloc( 0x10000 ) );
+        }
+#endif
+
+        if ((dwUsedSize = pMsg->Params[2]) == 0 &&
+            (dwNeededSize = pMsg->Params[1]) != 0)
+        {
+            //
+            // There's a msg waiting for us that is bigger than our buffer,
+            // so alloc a larger buffer & try again
+            //
+
+            LPBYTE  pNewBuf;
+
+
+            DBGOUT((
+                2,
+                "AsyncEventsThread: allocating larger event buf (size=x%x)",
+                dwNeededSize
+                ));
+
+            if (!(pNewBuf = ClientAlloc (dwNeededSize)))
+            {
+// BUGBUG AsyncEventsThread: handle larger event buf alloc failure
+                goto AsyncEventsThread_clientRequest;
+            }
+
+            dwBufSize = dwNeededSize;
+            ClientFree (pBuf);
+            pBuf = pNewBuf;
+            pMsg = (PTAPI32_MSG) pBuf;
+            goto AsyncEventsThread_clientRequest;
+        }
+
+
+        //
+        // Handle the events
+        //
+
+        pAsyncEventMsg = (PASYNCEVENTMSG) (pBuf + sizeof (TAPI32_MSG));
+
+        while (dwUsedSize)
+        {
+            PINIT_DATA  pInitData = (PINIT_DATA) pAsyncEventMsg->pInitData;
+
+
+            DBGOUT((
+                3,
+                "AsyncEventsThread: msg=%d, hDev=x%x, p1=x%x, p2=x%x, p3=x%x",
+                pAsyncEventMsg->dwMsg,
+                pAsyncEventMsg->hDevice,
+                pAsyncEventMsg->dwParam1,
+                pAsyncEventMsg->dwParam2,
+                pAsyncEventMsg->dwParam3
+                ));
+
+
+            //
+            // Special case for UI msgs (not fwd'd to client)
+            //
+
+            switch (pAsyncEventMsg->dwMsg)
+            {
+            case LINE_CREATEDIALOGINSTANCE:
+            {
+                DWORD           dwThreadID,
+                                dwDataOffset      = pAsyncEventMsg->dwParam1,
+                                dwDataSize        = pAsyncEventMsg->dwParam2,
+                                dwUIDllNameOffset = pAsyncEventMsg->dwParam3;
+                PUITHREADDATA   pUIThreadData;
+
+
+                if (!(pUIThreadData = ClientAlloc (sizeof (UITHREADDATA))))
+                {
+                    goto LINE_CREATEDIALOGINSTANCE_error;
+                }
+
+                if ((pUIThreadData->dwSize = dwDataSize) != 0)
+                {
+                    if (!(pUIThreadData->pParams = ClientAlloc (dwDataSize)))
+                    {
+                        goto LINE_CREATEDIALOGINSTANCE_error;
+                    }
+
+                    CopyMemory(
+                        pUIThreadData->pParams,
+                        ((LPBYTE)pAsyncEventMsg) + dwDataOffset,
+                        dwDataSize
+                        );
+                }
+
+                if (!(pUIThreadData->hUIDll = LoadLibraryW(
+                        (PWSTR)(((LPBYTE) pAsyncEventMsg) +
+                                  dwUIDllNameOffset)
+                        )))
+                {
+                    DBGOUT((
+                        2,
+                        "LoadLibraryW(%ls) failed, err=%d",
+                        ((LPBYTE) pAsyncEventMsg) + dwUIDllNameOffset,
+                        GetLastError()
+                        ));
+
+                    goto LINE_CREATEDIALOGINSTANCE_error;
+                }
+
+                if (!(pUIThreadData->pfnTUISPI_providerGenericDialog =
+                        (TUISPIPROC) GetProcAddress(
+                            pUIThreadData->hUIDll,
+                            (LPCSTR) gszTUISPI_providerGenericDialog
+                            )))
+                {
+                    DBGOUT((
+                        2,
+                        "GetProcAddr(TUISPI_providerGenericDialog) failed"
+                        ));
+
+                    goto LINE_CREATEDIALOGINSTANCE_error;
+                }
+
+                pUIThreadData->pfnTUISPI_providerGenericDialogData =
+                    (TUISPIPROC) GetProcAddress(
+                        pUIThreadData->hUIDll,
+                        (LPCSTR) gszTUISPI_providerGenericDialogData
+                        );
+
+                if (!(pUIThreadData->hEvent = CreateEvent(
+                        (LPSECURITY_ATTRIBUTES) NULL,
+                        TRUE,   // manual reset
+                        FALSE,  // non-signaled
+                        NULL    // unnamed
+                        )))
+                {
+                    goto LINE_CREATEDIALOGINSTANCE_error;
+                }
+
+                pUIThreadData->htDlgInst = (HTAPIDIALOGINSTANCE)
+                    pAsyncEventMsg->hDevice;
+
+
+                //
+                // Safely add this instance to the global list
+                // (check if gdwNumInits == 0, & if so fail)
+                //
+
+                EnterCriticalSection (&gCriticalSection);
+
+                if (gdwNumInits != 0)
+                {
+                    if ((pUIThreadData->pNext = gpUIThreadInstances))
+                    {
+                        pUIThreadData->pNext->pPrev = pUIThreadData;
+                    }
+
+                    gpUIThreadInstances  = pUIThreadData;
+                    LeaveCriticalSection (&gCriticalSection);
+                }
+                else
+                {
+                    LeaveCriticalSection (&gCriticalSection);
+                    goto LINE_CREATEDIALOGINSTANCE_error;
+                }
+
+                if ((pUIThreadData->hThread = CreateThread(
+                        (LPSECURITY_ATTRIBUTES) NULL,
+                        0,
+                        (LPTHREAD_START_ROUTINE) UIThread,
+                        (LPVOID) pUIThreadData,
+                        0,
+                        &dwThreadID
+                        )))
+                {
+                    goto AsyncEventsThread_decrUsedSize;
+                }
+
+
+                //
+                // If here an error occured, so safely remove the ui
+                // thread data struct from the global list
+                //
+
+                EnterCriticalSection (&gCriticalSection);
+
+                if (pUIThreadData->pNext)
+                {
+                    pUIThreadData->pNext->pPrev = pUIThreadData->pPrev;
+                }
+
+                if (pUIThreadData->pPrev)
+                {
+                    pUIThreadData->pPrev->pNext = pUIThreadData->pNext;
+                }
+                else
+                {
+                    gpUIThreadInstances = pUIThreadData->pNext;
+                }
+
+                LeaveCriticalSection (&gCriticalSection);
+
+
+LINE_CREATEDIALOGINSTANCE_error:
+
+                if (pUIThreadData)
+                {
+                    if (pUIThreadData->pParams)
+                    {
+                        ClientFree (pUIThreadData->pParams);
+                    }
+
+                    if (pUIThreadData->hUIDll)
+                    {
+                        FreeLibrary (pUIThreadData->hUIDll);
+                    }
+
+                    if (pUIThreadData->hEvent)
+                    {
+                        CloseHandle (pUIThreadData->hEvent);
+                    }
+
+                    ClientFree (pUIThreadData);
+                }
+
+                {
+                    FUNC_ARGS funcArgs =
+                    {
+                        MAKELONG (LINE_FUNC | SYNC | 1, xFreeDialogInstance),
+
+                        {
+                            (DWORD) pAsyncEventMsg->hDevice
+                        },
+
+                        {
+                            Dword
+                        }
+                    };
+
+
+                    DOFUNC (&funcArgs, "FreeDialogInstance");
+                }
+
+                goto AsyncEventsThread_decrUsedSize;
+            }
+            case LINE_SENDDIALOGINSTANCEDATA:
+            {
+                PUITHREADDATA       pUIThreadData = gpUIThreadInstances;
+                HTAPIDIALOGINSTANCE htDlgInst = (HTAPIDIALOGINSTANCE)
+                                        pAsyncEventMsg->hDevice;
+
+
+                EnterCriticalSection (&gCriticalSection);
+
+                while (pUIThreadData)
+                {
+                    if (pUIThreadData->htDlgInst == htDlgInst)
+                    {
+                        WaitForSingleObject (pUIThreadData->hEvent, INFINITE);
+
+                        (*pUIThreadData->pfnTUISPI_providerGenericDialogData)(
+                            htDlgInst,
+                            ((LPBYTE) pAsyncEventMsg) +
+                                pAsyncEventMsg->dwParam1,   // data offset
+                            pAsyncEventMsg->dwParam2        // data size
+                            );
+
+                        break;
+                    }
+
+                    pUIThreadData = pUIThreadData->pNext;
+                }
+
+                LeaveCriticalSection (&gCriticalSection);
+
+                goto AsyncEventsThread_decrUsedSize;
+            }
+            }
+
+
+            //
+            // Enter the critical section so we've exclusive access
+            // to the init data, & verify it
+            //
+
+            DBGOUT((11, "Trying to grab critical section (0x%08lx)", gCriticalSection));
+            EnterCriticalSection (&gCriticalSection);
+            DBGOUT((11, "Got critical section (0x%08lx)", gCriticalSection));
+
+            try
+            {
+                if ((DWORD) pInitData & 0x7 ||
+                    pInitData->dwKey != INITDATA_KEY)
+                {
+                    DBGOUT((4, "Bad pInitInst, discarding msg"));
+                    goto AsyncEventsThread_leaveCritSec;
+                }
+            }
+            except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                    EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+            {
+                goto AsyncEventsThread_leaveCritSec;
+            }
+
+
+            //
+            // Special case for PROXYREQUEST
+            //
+
+            if (pAsyncEventMsg->dwMsg == LINE_PROXYREQUEST)
+            {
+                PPROXYREQUESTHEADER     pProxyRequestHeader;
+                LPLINEPROXYREQUEST      pProxyRequest = (LPLINEPROXYREQUEST)
+                                            (pAsyncEventMsg + 1),
+                                        pProxyRequestApp;
+
+
+                switch (pProxyRequest->dwRequestType)
+                {
+                case LINEPROXYREQUEST_SETAGENTGROUP:
+                case LINEPROXYREQUEST_SETAGENTSTATE:
+                case LINEPROXYREQUEST_SETAGENTACTIVITY:
+                case LINEPROXYREQUEST_AGENTSPECIFIC:
+
+                    //
+                    // For these msgs the proxy request as received from
+                    // the tapisrv already contains the exact bits we want
+                    // to pass on to the app, so we just alloc a buffer of
+                    // the same size (plus a little extra for the key at
+                    // the head of the buffer) and copy the data to it
+                    //
+
+                    if (!(pProxyRequestHeader = ClientAlloc(
+                            sizeof (PROXYREQUESTHEADER) + pProxyRequest->dwSize
+                            )))
+                    {
+// BUGBUG AsyncEventsThread: handle proxyRequestBuf alloc failure
+                    }
+
+                    pProxyRequestApp = (LPLINEPROXYREQUEST)
+                        (pProxyRequestHeader + 1);
+
+                    CopyMemory(
+                        pProxyRequestApp,
+                        pProxyRequest,
+                        pProxyRequest->dwSize
+                        );
+
+                    break;
+
+                case LINEPROXYREQUEST_GETAGENTCAPS:
+                case LINEPROXYREQUEST_GETAGENTSTATUS:
+                case LINEPROXYREQUEST_GETAGENTACTIVITYLIST:
+                case LINEPROXYREQUEST_GETAGENTGROUPLIST:
+
+                    //
+                    // For these msgs tapisrv only embedded the dwTotalSize
+                    // field of the corresponding structure (to save having
+                    // to send us a bunch of unused bits), so we want to
+                    // increase the pProxyRequest->dwSize by the dwTotalSize
+                    // - sizeof (DWORD), alloc a buffer (including a little
+                    // extra space for the key at the head of the buffer),
+                    // and rebuild the request
+                    //
+
+                    pProxyRequest->dwSize +=
+                        pProxyRequest->GetAgentCaps.AgentCaps.dwTotalSize;
+
+                    if (!(pProxyRequestHeader = ClientAlloc(
+                            sizeof (PROXYREQUESTHEADER) + pProxyRequest->dwSize
+                            )))
+                    {
+// BUGBUG AsyncEventsThread: handle proxyRequestBuf alloc failure
+                    }
+
+                    pProxyRequestApp = (LPLINEPROXYREQUEST)
+                        (pProxyRequestHeader + 1);
+
+
+                    //
+                    // The following will copy the non-union fields in the
+                    // proxy message, as well as the first two DWORD in the
+                    // union (which currently are the dwAddressID and the
+                    // dwTotalSize field of the corresponding structure)
+                    //
+
+                    CopyMemory(
+                        pProxyRequestApp,
+                        pProxyRequest,
+                        9 * sizeof (DWORD)
+                        );
+
+
+                    //
+                    // Relocate the machine & user names to the end of the
+                    // structure
+                    //
+
+                    pProxyRequestApp->dwClientMachineNameOffset =
+                        pProxyRequest->dwSize -
+                            pProxyRequest->dwClientMachineNameSize;
+
+                    lstrcpyW(
+                        (WCHAR *)(((LPBYTE) pProxyRequestApp) +
+                            pProxyRequestApp->dwClientMachineNameOffset),
+                        (WCHAR *)(((LPBYTE) pProxyRequest) +
+                            pProxyRequest->dwClientMachineNameOffset)
+                        );
+
+                    pProxyRequestApp->dwClientUserNameOffset =
+                        pProxyRequestApp->dwClientMachineNameOffset -
+                            pProxyRequest->dwClientUserNameSize;
+
+                    lstrcpyW(
+                        (WCHAR *)(((LPBYTE) pProxyRequestApp) +
+                            pProxyRequestApp->dwClientUserNameOffset),
+                        (WCHAR *)(((LPBYTE) pProxyRequest) +
+                            pProxyRequest->dwClientUserNameOffset)
+                        );
+
+                    break;
+                }
+
+                pProxyRequestHeader->dwKey      = TPROXYREQUESTHEADER_KEY;
+                pProxyRequestHeader->dwInstance = pAsyncEventMsg->dwParam1;
+
+                pAsyncEventMsg->dwParam1 = (DWORD) pProxyRequestApp;
+            }
+
+
+            //
+            // Call the post processing proc if there is one
+            //
+
+            if (pAsyncEventMsg->pfnPostProcessProc)
+            {
+                (*((POSTPROCESSPROC) pAsyncEventMsg->pfnPostProcessProc))(
+                    pAsyncEventMsg
+                    );
+            }
+
+
+            //
+            // If this init instance is using a completion port then
+            // alloc msg struct & post the msg to the completion port,
+            // then jump down below to exit the critsec, etc
+            //
+
+            if (pInitData->dwInitOptions ==
+                    LINEINITIALIZEEXOPTION_USECOMPLETIONPORT)
+            {
+                LPLINEMESSAGE   pMsg;
+
+
+                if (!(pMsg = LocalAlloc (LMEM_FIXED, sizeof (LINEMESSAGE))))
+                {
+// BUGBUG AsyncEventsThread: handle LocalAlloc failure nicely
+                }
+
+                CopyMemory(
+                    pMsg,
+                    &pAsyncEventMsg->hDevice,
+                    sizeof (LINEMESSAGE)
+                    );
+
+                if ( !pPostQueuedCompletionStatus )
+                {
+                    HINSTANCE hInst;
+                    
+                    hInst = GetModuleHandle( "Kernel32.dll" );
+                    
+                    pPostQueuedCompletionStatus = GetProcAddress(
+                                                            hInst,
+                                                            "PostQueuedCompletionStatus"
+                                                            );
+                }
+                
+
+                if (pPostQueuedCompletionStatus && !pPostQueuedCompletionStatus(
+                        pInitData->hCompletionPort,
+                        sizeof (LINEMESSAGE),
+                        pInitData->dwCompletionKey,
+                        (LPOVERLAPPED) pMsg
+                        ))
+                {
+// BUGBUG AsyncEventsThread: handle PostQueuedCompletionStatus failure nicely
+
+                    LocalFree (pMsg);
+
+                    DBGOUT((
+                        1,
+                        "AsyncEventsThread: PostQueuedCompletionStatus " \
+                            "failed, err=%d",
+                        GetLastError()
+                        ));
+                }
+#if DBG
+                else
+                {
+                    DBGOUT((
+                        3,
+                        "AsyncEventsThread: posted complPort msg\n",
+                            "\thDev=x%x, dwInst=x%x, p1=x%x, p2=x%x, p3=x%x",
+                        aszMsgs[pAsyncEventMsg->dwMsg],
+                        pAsyncEventMsg->hDevice,
+                        pAsyncEventMsg->dwCallbackInst,
+                        pAsyncEventMsg->dwParam1,
+                        pAsyncEventMsg->dwParam2,
+                        pAsyncEventMsg->dwParam3
+                        ));
+                }
+#endif
+                goto AsyncEventsThread_leaveCritSec;
+            }
+
+
+            //
+            // See if we need to increase the msg queue size, and if
+            // so alloc a new buf, copy the existing msgs over (careful
+            // to preserve order in a wrapped buffer), free the old buf
+            // and reset the appropriate fields in the init data struct
+            //
+
+            if (pInitData->dwNumTotalEntries ==
+                    pInitData->dwNumUsedEntries)
+            {
+                DWORD               dwNumTotalEntries =
+                                        pInitData->dwNumTotalEntries;
+                PASYNC_EVENT_PARAMS pNewEventBuffer;
+
+
+                if ((pNewEventBuffer = ClientAlloc(
+                        2 * dwNumTotalEntries * sizeof (ASYNC_EVENT_PARAMS)
+                        )))
+                {
+                    DWORD   dwNumWrappedEntries = pInitData->pValidEntry -
+                                pInitData->pEventBuffer;
+
+
+                    CopyMemory(
+                        pNewEventBuffer,
+                        pInitData->pValidEntry,
+                        (dwNumTotalEntries - dwNumWrappedEntries)
+                            * sizeof (ASYNC_EVENT_PARAMS)
+                        );
+
+                    if (dwNumWrappedEntries)
+                    {
+                        CopyMemory(
+                            pNewEventBuffer +
+                                (dwNumTotalEntries - dwNumWrappedEntries),
+                            pInitData->pEventBuffer,
+                            dwNumWrappedEntries * sizeof (ASYNC_EVENT_PARAMS)
+                            );
+                    }
+
+                    ClientFree (pInitData->pEventBuffer);
+
+                    pInitData->pEventBuffer =
+                    pInitData->pValidEntry  = pNewEventBuffer;
+                    pInitData->pFreeEntry   =
+                        pNewEventBuffer + dwNumTotalEntries;
+
+                    pInitData->dwNumTotalEntries *= 2;
+                }
+                else
+                {
+// BUGBUG AsyncEventsThread: handle event buf alloc failure
+                }
+            }
+
+
+            //
+            // Copy the msg to the hidden window's msg queue,
+            // and update that queue's pointers
+            //
+
+            CopyMemory(
+                pInitData->pFreeEntry,
+                &pAsyncEventMsg->hDevice,
+                sizeof (ASYNC_EVENT_PARAMS)
+                );
+
+            pInitData->dwNumUsedEntries++;
+
+            pInitData->pFreeEntry++;
+
+            if (pInitData->pFreeEntry >= (pInitData->pEventBuffer +
+                    pInitData->dwNumTotalEntries))
+            {
+                pInitData->pFreeEntry = pInitData->pEventBuffer;
+            }
+
+
+            //
+            // If this init instance is using events for msg notification
+            // then see if we need to signal the app that there's an
+            // event waiting for it
+            //
+            // Else, post a msg to the hidden window (if there's not
+            // already one outstanding) to alert it that there's some
+            // events it needs to pass on to the app's callback
+            //
+
+            if (pInitData->dwInitOptions == LINEINITIALIZEEXOPTION_USEEVENT)
+            {
+                if (pInitData->dwNumUsedEntries == 1)
+                {
+                    SetEvent (pInitData->hEvent);
+                }
+            }
+            else // HIDDENWINDOW
+            {
+                if (pInitData->bPendingAsyncEventMsg == FALSE)
+                {
+                    DBGOUT((
+                        4,
+                        "AsyncEventsThread: posting msg, hwnd=x%lx",
+                        pInitData->hwnd
+                        ));
+
+                    PostMessage(
+                        pInitData->hwnd,
+                        WM_ASYNCEVENT,
+                        0,
+                        (LPARAM) pInitData
+                        );
+
+                    pInitData->bPendingAsyncEventMsg = TRUE;
+                }
+            }
+
+AsyncEventsThread_leaveCritSec:
+
+            DBGOUT((11, "releasing critical section (0x%08lx)", gCriticalSection));
+            LeaveCriticalSection (&gCriticalSection);
+
+AsyncEventsThread_decrUsedSize:
+
+            dwUsedSize -= pAsyncEventMsg->dwTotalSize;
+
+            pAsyncEventMsg = (PASYNCEVENTMSG)
+                ((LPBYTE) pAsyncEventMsg + pAsyncEventMsg->dwTotalSize);
+#if DBG
+            if ( (LONG)dwUsedSize < 0 )
+            {
+                DBGOUT((1, "dwUsedSize went negative!!!"));
+            }
+#endif
+        }
+    }
+
+    {
+        //
+        // Free our resources, and then exit
+        //
+
+        HANDLE  hTapi32 = pAsyncEventsThreadParams->hTapi32;
+
+
+        if (pAsyncEventsThreadParams->hWow32)
+        {
+            FreeLibrary (pAsyncEventsThreadParams->hWow32);
+        }
+
+        ClientFree (pBuf);
+        ClientFree (pAsyncEventsThreadParams);
+
+        DBGOUT((3, "AsyncEventsThread: exit"));
+
+        FreeLibraryAndExitThread (hTapi32, 0);
+    }
+}
+
+
+BOOL
+PASCAL
+IsBadDwordPtr(
+    LPDWORD p
+    )
+{
+    //
+    // Since IsBadWritePtr won't tell us if "p" is not DWORD-aligned (an
+    // issue on non-x86 platforms), we use the following to determine
+    // if the pointer is good.  Note that DWORD p points at will get
+    // overwritten on successful completion of the request anyway, so
+    // preserving the original value is not important.
+    //
+
+    DWORD dwError;
+
+
+    try
+    {
+        *p = *p + 1;
+    }
+    except ((((dwError = GetExceptionCode()) == EXCEPTION_ACCESS_VIOLATION) ||
+             dwError == EXCEPTION_DATATYPE_MISALIGNMENT) ?
+            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+WINAPI
+GrowBuf(
+    LPBYTE *ppBuf,
+    LPDWORD pdwBufSize,
+    DWORD   dwCurrValidBytes,
+    DWORD   dwBytesToAdd
+    )
+{
+    DWORD   dwCurrBufSize, dwNewBufSize;
+    LPBYTE  pNewBuf;
+
+
+    //
+    // Try to get a new buffer big enough to hold everything
+    //
+
+    for(
+        dwNewBufSize = 2 * (dwCurrBufSize = *pdwBufSize);
+        dwNewBufSize < (dwCurrBufSize + dwBytesToAdd);
+        dwNewBufSize *= 2
+        );
+
+    if (!(pNewBuf = ClientAlloc (dwNewBufSize)))
+    {
+        return FALSE;
+    }
+
+
+    //
+    // Copy the "valid" bytes in the old buf to the new buf,
+    // then free the old buf
+    //
+
+    CopyMemory (pNewBuf, *ppBuf, dwCurrValidBytes);
+
+    ClientFree (*ppBuf);
+
+
+    //
+    // Reset the pointers to the new buf & buf size
+    //
+
+    *ppBuf = pNewBuf;
+    *pdwBufSize = dwNewBufSize;
+
+    return TRUE;
+}
+
+
+PCLIENT_THREAD_INFO
+WINAPI
+GetTls(
+    void
+    )
+{
+    PCLIENT_THREAD_INFO pClientThreadInfo;
+
+
+    if (!(pClientThreadInfo = TlsGetValue (gdwTlsIndex)))
+    {
+        pClientThreadInfo = (PCLIENT_THREAD_INFO)
+            ClientAlloc (sizeof(CLIENT_THREAD_INFO));
+
+        if (!pClientThreadInfo)
+        {
+            return NULL;
+        }
+
+        pClientThreadInfo->pBuf = ClientAlloc (INITIAL_CLIENT_THREAD_BUF_SIZE);
+
+        if (!pClientThreadInfo->pBuf)
+        {
+            ClientFree (pClientThreadInfo);
+
+            return NULL;
+        }
+
+        pClientThreadInfo->dwBufSize = INITIAL_CLIENT_THREAD_BUF_SIZE;
+
+        TlsSetValue (gdwTlsIndex, (LPVOID) pClientThreadInfo);
+    }
+
+    return pClientThreadInfo;
+}
+
+#if DBG
+
+LONG
+WINAPI
+DoFunc(
+    PFUNC_ARGS  pFuncArgs,
+    char       *pszFuncName
+    )
+
+#else
+
+LONG
+WINAPI
+DoFunc(
+    PFUNC_ARGS  pFuncArgs
+    )
+
+#endif
+{
+    DWORD   dwFuncClassErrorIndex = (pFuncArgs->Flags & 0x00000030) >> 4;
+    LONG    lResult;
+    BOOL    bCopyOnSuccess = FALSE;
+    DWORD   i, j, dwValue, dwUsedSize, dwNeededSize;
+
+    PCLIENT_THREAD_INFO pTls;
+
+
+    DBGOUT((11, "About to call %s", pszFuncName));
+
+    //
+    // Check to make sure resources allocated
+    // (TAPISRV started, pipes opened, etc.)
+    //
+
+    if (!gbResourcesAllocated &&
+        ((lResult = AllocClientResources (dwFuncClassErrorIndex))
+            != TAPI_SUCCESS))
+    {
+        goto DoFunc_return;
+    }
+
+
+    //
+    // Get the tls
+    //
+
+    if (!(pTls = GetTls()))
+    {
+        lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+        goto DoFunc_return;
+    }
+
+
+    //
+    // The first arg of all async msg blocks is a remote request id; set
+    // this to zero to indicate that we are a local client (not remotesp)
+    //
+
+    if (pFuncArgs->Flags & ASYNC)
+    {
+        ((PTAPI32_MSG) pTls->pBuf)->Params[0] = 0;
+    }
+
+
+    //
+    // Validate all the func args
+    //
+
+    dwNeededSize = dwUsedSize = sizeof (TAPI32_MSG);
+
+    for(
+        i = 0, j = (pFuncArgs->Flags & ASYNC ? 1 : 0);
+        i < (pFuncArgs->Flags & NUM_ARGS_MASK);
+        i++, j++
+        )
+    {
+        dwValue = ((PTAPI32_MSG) pTls->pBuf)->Params[j] = pFuncArgs->Args[i];
+
+        switch (pFuncArgs->ArgTypes[i])
+        {
+        case Dword:
+
+            //
+            // Nothing to check, just continue
+            //
+
+            continue;
+
+        case lpDword:
+
+            if (IsBadDwordPtr ((LPDWORD) dwValue))
+            {
+                DBGOUT((1, "Bad lpdword in dofunc"));
+                lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                goto DoFunc_return;
+            }
+
+            bCopyOnSuccess = TRUE;
+
+            continue;
+
+
+        case hXxxApp_NULLOK:
+        case hXxxApp:
+        {
+            //
+            // Verify that the hXxxApp is a pointer to a valid InitData
+            // struct, then retrieve the real hXxxApp from that struct.
+            // If the hXxxApp is bad, pass the server 0xffffffff so that
+            // it can figure out whether to return an UNINITIALIZED error
+            // or a INVALAPPHANDLE error.
+            //
+
+            DWORD   dwError;
+
+
+            if ( 
+                  (0 == pFuncArgs->Args[i])
+                &&
+                  (hXxxApp_NULLOK == pFuncArgs->ArgTypes[i])
+               )
+            {
+                //
+                // Looks good to me...
+                //
+                continue;
+            }
+
+            try
+            {
+                PINIT_DATA pInitData = (PINIT_DATA) dwValue;
+
+
+                if (pInitData->dwKey != INITDATA_KEY)
+                {
+                    DBGOUT((1, "Bad hxxxapp in dofunc"));
+                    ((PTAPI32_MSG) pTls->pBuf)->Params[j] = 0xffffffff;
+                }
+                else
+                {
+                  ((PTAPI32_MSG) pTls->pBuf)->Params[j] =
+                      (DWORD) pInitData->hXxxApp;
+                }
+            }
+            except ((((dwError = GetExceptionCode())
+                        == EXCEPTION_ACCESS_VIOLATION) ||
+                     dwError == EXCEPTION_DATATYPE_MISALIGNMENT) ?
+                    EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+            {
+                 DBGOUT((1, "Bad hxxxapp2 in dofunc (0x%08lx)", dwError));
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = 0xffffffff;
+            }
+
+            continue;
+        }
+        case Hwnd:
+
+            if (!IsWindow ((HWND) dwValue))
+            {
+                DBGOUT((1, "Bad hWnd in dofunc"));
+                lResult = gaInvalHwndErrors[dwFuncClassErrorIndex];
+                goto DoFunc_return;
+            }
+
+            continue;
+
+
+//        case lpsz:
+        case lpszW:
+
+            //
+            // Check if dwValue is a valid string ptr and if so
+            // copy the contents of the string to the extra data
+            // buffer passed to the server
+            //
+
+            try
+            {
+                DWORD   n = (lstrlenW((WCHAR *) dwValue) + 1) * sizeof(WCHAR),
+                        nAligned = (n + 3) & 0xfffffffc;
+
+
+                if ((nAligned + dwUsedSize) > pTls->dwBufSize)
+                {
+                    if (!GrowBuf(
+                            &pTls->pBuf,
+                            &pTls->dwBufSize,
+                            dwUsedSize,
+                            nAligned
+                            ))
+                    {
+                        lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+                        goto DoFunc_return;
+                    }
+                }
+
+                CopyMemory (pTls->pBuf + dwUsedSize, (LPBYTE) dwValue, n);
+
+
+                //
+                // Pass the server the offset of the string in the var data
+                // portion of the buffer
+                //
+
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] =
+                    dwUsedSize - sizeof (TAPI32_MSG);
+
+
+                //
+                // Increment the total number of data bytes
+                //
+
+                dwUsedSize   += nAligned;
+                dwNeededSize += nAligned;
+            }
+            except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                    EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+            {
+                lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                goto DoFunc_return;
+            }
+
+            continue;
+
+        case lpGet_Struct:
+        case lpGet_SizeToFollow:
+        {
+            BOOL  bSizeToFollow = (pFuncArgs->ArgTypes[i]==lpGet_SizeToFollow);
+            DWORD dwSize;
+
+
+            if (bSizeToFollow)
+            {
+#if DBG
+                //
+                // Check to make sure the following arg is of type Size
+                //
+
+                if ((i == ((pFuncArgs->Flags & NUM_ARGS_MASK) - 1)) ||
+                    (pFuncArgs->ArgTypes[i + 1] != Size))
+                {
+                    DBGOUT((
+                        2,
+                        "DoFunc: error, lpGet_SizeToFollow !followed by Size"
+                        ));
+
+                    lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                    goto DoFunc_return;
+                }
+#endif
+                dwSize = pFuncArgs->Args[i + 1];
+            }
+            else
+            {
+                DWORD   dwError;
+
+                try
+                {
+                    dwSize = *((LPDWORD) dwValue);
+                }
+                except ((((dwError = GetExceptionCode())
+                            == EXCEPTION_ACCESS_VIOLATION) ||
+                         dwError == EXCEPTION_DATATYPE_MISALIGNMENT) ?
+                        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+                {
+                    DBGOUT((1, "Bad get struct/size in dofunc"));
+                    lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                    goto DoFunc_return;
+                }
+
+            }
+
+            if (IsBadWritePtr ((LPVOID) dwValue, dwSize))
+            {
+                DBGOUT((1, "Bad get size/struct2 in dofunc"));
+                lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                goto DoFunc_return;
+            }
+
+
+            if (bSizeToFollow)
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = TAPI_NO_DATA;
+                ((PTAPI32_MSG) pTls->pBuf)->Params[++j] = pFuncArgs->Args[++i];
+            }
+            else
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = dwSize;
+            }
+
+
+            //
+            // Now set the bCopyOnSuccess flag to indicate that we've data
+            // to copy back on successful completion, and add to the
+            // dwNeededSize field
+            //
+
+            bCopyOnSuccess = TRUE;
+
+            dwNeededSize += dwSize;
+
+            continue;
+        }
+        case lpSet_Struct:
+        case lpSet_SizeToFollow:
+        {
+            BOOL  bSizeToFollow = (pFuncArgs->ArgTypes[i]==lpSet_SizeToFollow);
+            DWORD dwSize, dwError, dwSizeAligned;
+
+#if DBG
+            //
+            // Check to make sure the following arg is of type Size
+            //
+
+            if (bSizeToFollow &&
+                ((i == ((pFuncArgs->Flags & NUM_ARGS_MASK) - 1)) ||
+                (pFuncArgs->ArgTypes[i + 1] != Size)))
+            {
+                DBGOUT((
+                    2,
+                    "DoFunc: error, lpSet_SizeToFollow !followed by Size"
+                    ));
+
+                lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                goto DoFunc_return;
+            }
+#endif
+            try
+            {
+                //
+                // First determine the data size & if the ptr is bad
+                //
+
+                dwSize = (bSizeToFollow ? pFuncArgs->Args[i + 1] :
+                     *((LPDWORD) dwValue));
+
+                if (IsBadReadPtr ((LPVOID) dwValue, dwSize))
+                {
+                    DBGOUT((1, "Bad set size/struct in dofunc"));
+                    lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                    goto DoFunc_return;
+                }
+
+                dwSizeAligned = (dwSize + 3) & 0xfffffffc;
+
+
+                //
+                // Special case if the size isn't even big enough to pass
+                // over a complete DWORD for the dwTotalSize field
+                //
+
+                if (!bSizeToFollow && (dwSize < sizeof (DWORD)))
+                {
+                      static DWORD dwZeroTotalSize = 0;
+
+
+                      dwSize = dwSizeAligned = sizeof (DWORD);
+                      dwValue = (DWORD) &dwZeroTotalSize;
+
+//                    DBGOUT((1, "Bad set size/struct2 in dofunc"));
+//                    lResult = gaStructTooSmallErrors[dwFuncClassErrorIndex];
+//                    goto DoFunc_return;
+                }
+
+
+                //
+                // Grow the buffer if necessary, & do the copy
+                //
+
+                if ((dwSizeAligned + dwUsedSize) > pTls->dwBufSize)
+                {
+                    if (!GrowBuf(
+                            &pTls->pBuf,
+                            &pTls->dwBufSize,
+                            dwUsedSize,
+                            dwSizeAligned
+                            ))
+                    {
+                        DBGOUT((1, "Nomem set size/struct in dofunc"));
+                        lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+                        goto DoFunc_return;
+                    }
+                }
+
+                CopyMemory (pTls->pBuf + dwUsedSize, (LPBYTE) dwValue, dwSize);
+            }
+            except ((((dwError = GetExceptionCode())
+                        == EXCEPTION_ACCESS_VIOLATION) ||
+                     dwError == EXCEPTION_DATATYPE_MISALIGNMENT) ?
+                    EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+            {
+                DBGOUT((1, "Bad pointer in get size/struct in dofunc"));
+                lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                goto DoFunc_return;
+            }
+
+
+            //
+            // Pass the server the offset of the data in the var data
+            // portion of the buffer
+            //
+
+            if (dwSize)
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] =
+                    dwUsedSize - sizeof (TAPI32_MSG);
+            }
+            else
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = TAPI_NO_DATA;
+            }
+
+
+            //
+            // Increment the dwXxxSize vars appropriately
+            //
+
+            dwUsedSize   += dwSizeAligned;
+            dwNeededSize += dwSizeAligned;
+
+
+            //
+            // Since we already know the next arg (Size) just handle
+            // it here so we don't have to run thru the loop again
+            //
+
+            if (bSizeToFollow)
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[++j] = pFuncArgs->Args[++i];
+            }
+
+            continue;
+        }
+#if DBG
+        case Size:
+
+            DBGOUT((2, "DoFunc: error, hit case Size"));
+
+            continue;
+
+        default:
+
+            DBGOUT((2, "DoFunc: error, unknown arg type"));
+
+            continue;
+#endif
+        } // switch
+
+    } // for
+
+
+    //
+    // Now make the request
+    //
+
+    if (dwNeededSize > pTls->dwBufSize)
+    {
+        if (!GrowBuf(
+                &pTls->pBuf,
+                &pTls->dwBufSize,
+                dwUsedSize,
+                dwNeededSize - pTls->dwBufSize
+                ))
+        {
+            lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+            goto DoFunc_return;
+        }
+    }
+
+    ((PTAPI32_MSG) pTls->pBuf)->u.Req_Func = (DWORD)HIWORD(pFuncArgs->Flags);
+
+    {
+        DWORD   dwRetryCount = 0;
+
+
+        do
+        {
+            RpcTryExcept
+            {
+                ClientRequest (gphCx, pTls->pBuf, dwNeededSize, &dwUsedSize);
+                lResult = ((PTAPI32_MSG) pTls->pBuf)->u.Ack_ReturnValue;
+                dwRetryCount = 0;
+            }
+            RpcExcept (1)
+            {
+                unsigned long rpcException = RpcExceptionCode();
+
+                if (rpcException == RPC_S_SERVER_TOO_BUSY)
+                {
+                    if (dwRetryCount++ < gdwMaxNumRequestRetries)
+                    {
+                        Sleep (gdwRequestRetryTimeout);
+                    }
+                    else
+                    {
+                        dwRetryCount = 0;
+                        lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                    }
+                }
+                else
+                {
+                    DBGOUT((1, "DoFunc: rpcException # %d", rpcException));
+                    lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                    dwRetryCount = 0;
+                }
+            }
+            RpcEndExcept
+
+        } while (dwRetryCount != 0);
+    }
+
+// note: 99.99% of the time this result dump will == the one at end of the
+// func (only when ptrs have gone bad will the result differ), no reason
+// to dump 2x unless doing internal dbgging
+//
+    DBGOUT((11, "DoFunc: back from srv- return code=0x%08lx", lResult));
+
+
+    //
+    // If request completed successfully and the bCopyOnSuccess flag
+    // is set then we need to copy data back to client buffer(s)
+    //
+
+    if ((lResult == TAPI_SUCCESS) && bCopyOnSuccess)
+    {
+        for (i = 0, j = 0; i < (pFuncArgs->Flags & NUM_ARGS_MASK); i++, j++)
+        {
+            PTAPI32_MSG pMsg = (PTAPI32_MSG) pTls->pBuf;
+
+
+            switch (pFuncArgs->ArgTypes[i])
+            {
+            case Dword:
+            case Hwnd:
+//            case lpsz:
+            case lpszW:
+            case lpSet_Struct:
+
+                continue;
+
+            case lpDword:
+
+                try
+                {
+                    //
+                    // Fill in the pointer with the return value
+                    //
+
+                    *((LPDWORD) pFuncArgs->Args[i]) = pMsg->Params[j];
+                }
+                except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+                {
+                    // BUGBUG for certain funcs want to lineShutdown, etc.
+
+                    lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                    goto DoFunc_return;
+                }
+
+                continue;
+
+            case lpGet_SizeToFollow:
+
+                try
+                {
+                    //
+                    // Fill in the pointer with the return value
+                    //
+
+                    CopyMemory(
+                        (LPBYTE) pFuncArgs->Args[i],
+                        pTls->pBuf + pMsg->Params[j] + sizeof(TAPI32_MSG),
+                        pMsg->Params[j+1]
+                        );
+                }
+                except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+                {
+                    // BUGBUG for certain funcs want to lineShutdown, etc.
+
+                    lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                    goto DoFunc_return;
+                }
+
+
+                //
+                // Increment i (and j, since Size passed as arg in msg)
+                // to skip following Size arg in pFuncArgs->Args
+                //
+
+                i++;
+                j++;
+
+                continue;
+
+            case lpSet_SizeToFollow:
+
+                //
+                // Increment i (and j, since Size passed as arg in msg)
+                // to skip following Size arg in pFuncArgs->Args
+                //
+
+                i++;
+                j++;
+
+                continue;
+
+            case lpGet_Struct:
+
+                try
+                {
+                    //
+                    // Params[j] contains the offset in the var data
+                    // portion of pTls->pBuf of some TAPI struct.
+                    // Get the dwUsedSize value from this struct &
+                    // copy that many bytes from pTls->pBuf to client buf
+                    //
+
+                    if (pMsg->Params[j] != TAPI_NO_DATA)
+                    {
+
+                        LPDWORD pStruct;
+
+
+                        pStruct = (LPDWORD) (pTls->pBuf + sizeof(TAPI32_MSG) +
+                            pMsg->Params[j]);
+
+                        CopyMemory(
+                            (LPBYTE) pFuncArgs->Args[i],
+                            (LPBYTE) pStruct,
+                            *(pStruct + 2)      // ptr to dwUsedSize field
+                            );
+                    }
+                }
+                except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+                {
+                    // BUGBUG for certain funcs want to lineShutdown, etc.
+
+                    lResult = gaInvalPtrErrors[dwFuncClassErrorIndex];
+                    goto DoFunc_return;
+                }
+
+                continue;
+
+            default:
+
+                continue;
+            }
+        }
+    }
+//    else if ((pFuncArgs->Flags & ASYNC) && (lResult < TAPI_SUCCESS))
+//    {
+//    }
+
+DoFunc_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "%s: result = %s",
+            pszFuncName,
+            MapResultCodeToText (lResult, szResult)
+            ));
+    }
+#endif
+
+    return lResult;
+}
+
+
+LONG
+LoadUIDll(
+    HWND        hwndOwner,
+    DWORD       dwWidgetID,
+    DWORD       dwWidgetType,
+    HANDLE     *phDll,
+    CHAR       *pszTUISPI_xxx,
+    TUISPIPROC *ppfnTUISPI_xxx
+    )
+{
+    LONG    lResult;
+    HANDLE  hDll;
+    WCHAR   szUIDllName[MAX_PATH];
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, xGetUIDllName),
+
+        {
+            (DWORD) dwWidgetID,
+            (DWORD) dwWidgetType,
+            (DWORD) szUIDllName,
+            (DWORD) MAX_PATH
+        },
+
+        {
+            Dword,
+            Dword,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (hwndOwner && !IsWindow (hwndOwner))
+    {
+       lResult = (dwWidgetType == TUISPIDLL_OBJECT_PHONEID ?
+           PHONEERR_INVALPARAM : LINEERR_INVALPARAM);
+
+       goto LoadUIDll_return;
+    }
+
+    if ((lResult = DOFUNC (&funcArgs, "GetUIDllName")) == 0)
+    {
+        if ((hDll = LoadLibraryW(szUIDllName)))
+        {
+            if ((*ppfnTUISPI_xxx = (TUISPIPROC) GetProcAddress(
+                    hDll,
+                    pszTUISPI_xxx
+                    )))
+            {
+                *phDll = hDll;
+                lResult = 0;
+            }
+            else
+            {
+                DBGOUT((
+                    1,
+                    "LoadUIDll: GetProcAddress(%ls,%s) failed, err=%d",
+                    szUIDllName,
+                    pszTUISPI_xxx,
+                    GetLastError()
+                    ));
+
+                FreeLibrary (hDll);
+                lResult = (dwWidgetType == TUISPIDLL_OBJECT_PHONEID ?
+                    PHONEERR_OPERATIONUNAVAIL : LINEERR_OPERATIONUNAVAIL);
+            }
+        }
+        else
+        {
+            DBGOUT((
+                1,
+                "LoadLibraryW(%ls) failed, err=%d",
+                szUIDllName,
+                GetLastError()
+                ));
+
+            lResult = (dwWidgetType == TUISPIDLL_OBJECT_PHONEID ?
+                PHONEERR_OPERATIONFAILED : LINEERR_OPERATIONFAILED);
+        }
+    }
+
+LoadUIDll_return:
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+lineXxxProvider(
+    CHAR   *pszTUISPI_providerXxx,
+    LPCWSTR lpszProviderFilename,
+    HWND    hwndOwner,
+    DWORD   dwPermProviderID,
+    LPDWORD lpdwPermProviderID
+    )
+{
+    BOOL                bAddProvider = (pszTUISPI_providerXxx ==
+                            gszTUISPI_providerInstall);
+    WCHAR               szUIDllName[MAX_PATH];
+    LONG                lResult;
+    HINSTANCE           hDll;
+    TUISPIPROC          pfnTUISPI_providerXxx;
+    HTAPIDIALOGINSTANCE htDlgInst;
+
+
+    if (bAddProvider && IsBadDwordPtr (lpdwPermProviderID))
+    {
+        DBGOUT((1, "Bad lpdwPermProviderID pointer"));
+        return LINEERR_INVALPOINTER;
+    }
+    else if (hwndOwner && !IsWindow (hwndOwner))
+    {
+        DBGOUT((1, "hwndOwner is not a window"));
+        return LINEERR_INVALPARAM;
+    }
+
+    {
+        FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 7, xGetUIDllName),
+
+            {
+                (DWORD) (bAddProvider ? (DWORD) &dwPermProviderID :
+                            dwPermProviderID),
+                (DWORD) TUISPIDLL_OBJECT_PROVIDERID,
+                (DWORD) szUIDllName,
+                (DWORD) MAX_PATH,
+                (DWORD) (bAddProvider ? (DWORD) lpszProviderFilename :
+                            TAPI_NO_DATA),
+                (DWORD) (pszTUISPI_providerXxx==gszTUISPI_providerRemove ?1:0),
+                (DWORD) &htDlgInst
+            },
+
+            {
+                (bAddProvider ? lpDword : Dword),
+                Dword,
+                lpGet_SizeToFollow,
+                Size,
+                (bAddProvider ? lpszW : Dword),
+                Dword,
+                lpDword
+            }
+        };
+
+
+        if ((lResult = DOFUNC (&funcArgs,"lineXxxProvider/GetUIDllName")) != 0)
+        {
+            return lResult;
+        }
+    }
+
+    if ((hDll = LoadLibraryW(szUIDllName)))
+    {
+        if ((pfnTUISPI_providerXxx = (TUISPIPROC) GetProcAddress(
+                hDll,
+                pszTUISPI_providerXxx
+                )))
+        {
+            DBGOUT((3, "Calling %ls...", pszTUISPI_providerXxx));
+
+            lResult = (*pfnTUISPI_providerXxx)(
+                TUISPIDLLCallback,
+                hwndOwner,
+                dwPermProviderID
+                );
+#if DBG
+            {
+                char szResult[32];
+
+
+                DBGOUT((
+                    3,
+                    "%ls: result = %s",
+                    pszTUISPI_providerXxx,
+                    MapResultCodeToText (lResult, szResult)
+                    ));
+            }
+#endif
+        }
+        else
+        {
+            DBGOUT((
+                1,
+                "lineXxxProvider: GetProcAddr(%ls,%ls) failed, err=%d",
+                szUIDllName,
+                pszTUISPI_providerXxx,
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONUNAVAIL;
+        }
+
+        FreeLibrary (hDll);
+    }
+    else
+    {
+        DBGOUT((
+            1,
+            "lineXxxProvider: LoadLibraryW('%ls') failed, err=%d",
+            szUIDllName,
+            GetLastError()
+            ));
+
+        lResult = LINEERR_OPERATIONFAILED;
+    }
+
+    {
+        LONG    lResult2;
+        FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 2, xFreeDialogInstance),
+
+            {
+                (DWORD) htDlgInst,
+                (DWORD) lResult
+            },
+
+            {
+                Dword,
+                Dword
+            }
+        };
+
+
+        //
+        // If TUISPI_providerXxx failed then we want to pass that error back
+        // to the app, else if it succeeded & FreeDlgInst failed then pass
+        // that error back to the app
+        //
+
+        if ((lResult2 = DOFUNC(
+                &funcArgs,
+                "lineXxxProvider/FreeDialogInstance"
+
+                )) == 0)
+        {
+            if (bAddProvider)
+            {
+                *lpdwPermProviderID = dwPermProviderID;
+            }
+        }
+        else if (lResult == 0)
+        {
+            lResult = lResult2;
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+ValidateXxxInitializeParams(
+    DWORD                       dwAPIVersion,
+    BOOL                        bLine,
+    LPLINEINITIALIZEEXPARAMS    pXxxInitExParams,
+    LINECALLBACK                pfnCallback
+    )
+{
+    DWORD dwError;
+
+
+    try
+    {
+        DWORD   dwTotalSize = pXxxInitExParams->dwTotalSize;
+
+
+        if (dwTotalSize < sizeof (LINEINITIALIZEEXPARAMS))
+        {
+            return (bLine ? LINEERR_STRUCTURETOOSMALL :
+                PHONEERR_STRUCTURETOOSMALL);
+        }
+
+        if (IsBadWritePtr (pXxxInitExParams, dwTotalSize))
+        {
+            return (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+        }
+
+
+        //
+        // When checking the dwOptions field be careful about compatibility
+        // with future vers, so we only look at the currently valid bits
+        //
+
+        switch ((pXxxInitExParams->dwOptions & 0xf))
+        {
+        case 0:
+        case LINEINITIALIZEEXOPTION_USEHIDDENWINDOW:
+
+            if (IsBadCodePtr ((FARPROC) pfnCallback))
+            {
+                return (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+            }
+
+        case LINEINITIALIZEEXOPTION_USEEVENT:
+        case LINEINITIALIZEEXOPTION_USECOMPLETIONPORT:
+
+            break;
+
+        default:
+
+            if ( TAPI_VERSION2_0 == dwAPIVersion )
+            {
+                //
+                // This 2.0 app is nuts.
+                //  
+                return (bLine ? LINEERR_INVALPARAM : PHONEERR_INVALPARAM);
+            }
+            else
+            {
+                //
+                // This >2.0 app is asking for something we can't do.
+                //
+                return (bLine ? LINEERR_INCOMPATIBLEAPIVERSION :
+                                PHONEERR_INCOMPATIBLEAPIVERSION);
+            }
+            
+        }
+
+        pXxxInitExParams->dwNeededSize =
+        pXxxInitExParams->dwUsedSize = sizeof (LINEINITIALIZEEXPARAMS);
+    }
+    except ((((dwError = GetExceptionCode()) == EXCEPTION_ACCESS_VIOLATION) ||
+               dwError == EXCEPTION_DATATYPE_MISALIGNMENT) ?
+            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        return (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+    }
+
+    return 0;
+}
+
+
+LONG
+WINAPI
+xxxInitialize(
+    BOOL                        bLine,
+    LPVOID                      phXxxApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                pfnCallback,
+    LPCWSTR                     pszAppName,
+    LPDWORD                     pdwNumDevs,
+    LPDWORD                     pdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    pXxxInitExParams
+#if DBG
+    ,char                      *pszFuncName
+#endif
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG ((bLine ? LINE_FUNC : PHONE_FUNC) | SYNC | 7,
+            (bLine ? lInitialize : pInitialize)),
+
+        {
+            (DWORD) phXxxApp,
+            (DWORD) hInstance,
+            (DWORD) 0,          // pfnCallback, we subst pInitData in here
+            (DWORD) pszAppName,
+            (DWORD) pdwNumDevs,
+            (DWORD) 0,          // pszModuleName
+            (DWORD) TAPI_VERSION1_0
+        },
+
+        {
+            lpDword,
+            Dword,
+            Dword,
+            lpszW,
+            lpDword,
+            lpszW,
+            Dword
+        }
+    };
+    WCHAR       *pszModuleNamePathW = NULL;
+    LONG         lResult;
+    BOOL         bReleaseMutex = FALSE;
+    PINIT_DATA   pInitData = (PINIT_DATA) NULL;
+
+
+    if (phXxxApp == (LPVOID) pdwNumDevs)
+    {
+        DBGOUT((3, "%s: error, lphApp == lpdwNumDevs", pszFuncName));
+        lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+        goto xxxInitialize_return;
+    }
+
+    if (pdwAPIVersion)
+    {
+        if (phXxxApp == (LPVOID) pdwAPIVersion  ||
+            phXxxApp == (LPVOID) pXxxInitExParams  ||
+            pdwNumDevs == pdwAPIVersion  ||
+            pdwNumDevs == (LPDWORD) pXxxInitExParams  ||
+            pdwAPIVersion == (LPDWORD) pXxxInitExParams)
+        {
+            lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+            goto xxxInitialize_return;
+        }
+
+
+        //
+        // line- & phoneInitializeEx both require a valid lpdwAPIVersion
+        // pointer parameter, and the value it points to on the way in
+        // must be >= 0x00020000. (Careful to allow for future vers of TAPI.)
+        //
+
+        if (*pdwAPIVersion < TAPI_VERSION2_0)
+        {
+            DBGOUT((
+                1,
+                "%InitializeEx: error, *lpdwAPIVersion = x%x, " \
+                    "must be set >= 0x20000",
+                *pdwAPIVersion,
+                (bLine ? "line" : "phone")
+                ));
+
+            lResult = (bLine ? LINEERR_INCOMPATIBLEAPIVERSION :
+                PHONEERR_INCOMPATIBLEAPIVERSION);
+            goto xxxInitialize_return;
+        }
+
+
+        //
+        // Validate the InitEx params, or if the pointer is NULL (implying
+        // that app wants to use "old" hidden window scheme) validate
+        // the pfnCallback
+        //
+
+        if (pXxxInitExParams)
+        {
+            if ((lResult = ValidateXxxInitializeParams(
+                    (*pdwAPIVersion) - 1, //local IsBadDwordPtr() hoses it
+                    bLine,
+                    pXxxInitExParams,
+                    pfnCallback
+
+                    ))  != 0)
+            {
+                goto xxxInitialize_return;
+            }
+        }
+        else if (IsBadCodePtr ((FARPROC) pfnCallback))
+        {
+            DBGOUT((1, "%s: bad lpfnCallback", pszFuncName));
+            lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+            goto xxxInitialize_return;
+        }
+
+
+        //
+        // Now fill in *pdwAPIVersion with the version # we support, and
+        // also indicate this in the params we pass to tapisrv.exe (so
+        // it knows it can start sending us 2.0 msgs right away)
+        //
+
+        *pdwAPIVersion = funcArgs.Args[6] = TAPI_VERSION2_0;
+    }
+
+#pragma message("*** *** ***BUGBUG: Use MapHandle()...")
+    else if ((((DWORD) pfnCallback) & 0xffff0000) == 0xffff0000)
+    {
+        //
+        // This is a 16-bit client going through the thunk.  The
+        // pfnCallback var is actually a window handle.
+        //
+        // Note: On NT, 32-bit code can talk to 16-bit HWNDs
+        //       by setting the hi-word to 0xffff.
+        //
+        //       On Win95, 32-bit can talk to 16-bit HWNDs
+        //       by setting the hi-word to 0x0000.
+        //
+
+//<!         ((DWORD) pfnCallback) = HWND_32( pfnCallback );
+//<!         
+//<! //#pragma message("*** *** ***BUGBUG: Use MapHandle()...")
+//<! //        if (GetVersion() & 0x80000000)
+//<! //        {
+//<! //            //
+//<! //            // We're on Win95 so zero the hi-word
+//<! //            //
+//<! //
+//<! //            ((DWORD) pfnCallback) &= 0x0000ffff;
+//<! //        }
+//<! 
+           if (GetVersion() & 0x80000000)
+           {
+               //
+               // We're on Win95 so zero the hi-word
+               //
+   
+               ((DWORD) pfnCallback) &= 0x0000ffff;
+           }
+
+        if (!IsWindow ((HWND) pfnCallback))
+        {
+            //
+            // If here chances are it's a 32-bit app passing in a bad
+            // pfnCallback
+            //
+
+            DBGOUT((1, "%s: bad lpfnCallback", pszFuncName));
+            lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+            goto xxxInitialize_return;
+        }
+
+        if (!ghWow32Dll &&
+
+            !(ghWow32Dll = LoadLibrary ("wow32.dll")))
+        {
+            DBGOUT((
+                1,
+                "%s: LoadLib(wow32.dll) failed, err=%d",
+                pszFuncName,
+                GetLastError()
+                ));
+
+            lResult =
+                (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+            goto xxxInitialize_return;
+        }
+
+        if (!gpfnWOWGetVDMPointer &&
+
+            !(gpfnWOWGetVDMPointer = GetProcAddress(
+                ghWow32Dll,
+                "WOWGetVDMPointer"
+                )))
+        {
+            DBGOUT((
+                1,
+                "%s: GetProcAddr(WOWGetVDMPointer) failed, err=%d",
+                pszFuncName,
+                GetLastError()
+                ));
+
+            lResult =
+                (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+            goto xxxInitialize_return;
+        }
+
+        gbNTVDMClient = TRUE;
+
+
+        //
+        // For 16-bit clients the module name will follow the app name
+        //
+
+        {
+//            char   *pszAppName2 = (char *) pszAppName;
+//
+//
+//            for (; *pszAppName2; pszAppName2++);
+//
+//            pszAppName2++;
+//
+//            funcArgs.Args[5] = (DWORD) pszAppName2;
+
+            funcArgs.Args[5] = (DWORD) &(pszAppName[wcslen(pszAppName)+1]);
+
+            DBGOUT((
+                11,
+                "FName='%ls', MName='%ls'",
+                pszAppName,
+                funcArgs.Args[5]
+                ));
+
+        }
+    }
+    else if (IsBadCodePtr ((FARPROC) pfnCallback))
+    {
+        //
+        // If here a 32-bit app is call line/phoneInitialize
+        //
+
+        DBGOUT((1, "%s: bad lpfnCallback", pszFuncName));
+        lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+        goto xxxInitialize_return;
+    }
+
+
+
+    //
+    // Check to see if hInstance is bad by getting the module name
+    //
+    // Note: We now allow a NULL hInstance (16-bit TAPI didn't)
+    //
+
+    if (gbNTVDMClient == FALSE)
+    {
+        DWORD   dwSize = MAX_PATH, dwLength;
+
+
+alloc_module_name_buf:
+
+        if (!(pszModuleNamePathW = ClientAlloc (dwSize*sizeof(WCHAR))))
+        {
+            lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM);
+            goto xxxInitialize_return;
+        }
+
+        if ((dwLength = GetModuleFileNameW(
+                hInstance,
+                pszModuleNamePathW,
+                dwSize
+
+                )) == 0)
+        {
+            DBGOUT((
+                3,
+                "%s: GetModuleFileName(x%x, ...) failed, err=%d",
+                pszFuncName,
+                hInstance,
+                GetLastError()
+                ));
+
+            lResult = (bLine ? LINEERR_INVALPARAM : PHONEERR_INVALPARAM);
+            goto xxxInitialize_cleanup;
+        }
+        else if (dwLength >= dwSize)
+        {
+            ClientFree (pszModuleNamePathW);
+            dwSize *= 2;
+            goto alloc_module_name_buf;
+        }
+
+        funcArgs.Args[5] = (DWORD) wcsrchr (pszModuleNamePathW, '\\') +
+                                       sizeof(WCHAR);
+
+        if (!pszAppName)
+        {
+            funcArgs.Args[3] = funcArgs.Args[5];
+        }
+    }
+
+    if (!(pInitData = ClientAlloc (sizeof(INIT_DATA))) ||
+
+        !(pInitData->pEventBuffer = ClientAlloc(
+            DEF_NUM_EVENT_BUFFER_ENTRIES * sizeof (ASYNC_EVENT_PARAMS)
+            )))
+    {
+        lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM);
+        goto xxxInitialize_cleanup;
+    }
+
+
+    //
+    // When checking the dwOptions field be careful about compatibility
+    // with future vers, so we only look at the currently valid bits
+    // (The ExOptions are currently ordinals, but we track bits here just in case
+    // we wanna use high bits later.)
+    //
+
+    pInitData->dwInitOptions = (pXxxInitExParams ?
+        (pXxxInitExParams->dwOptions & AllInitExOptions2_0) :
+        LINEINITIALIZEEXOPTION_USEHIDDENWINDOW);
+
+
+    switch (pInitData->dwInitOptions)
+    {
+    case LINEINITIALIZEEXOPTION_USECOMPLETIONPORT:
+
+        //
+        // Be libertarian- if the app wants to hose itself by passing
+        // a bad hCompletionPort then so be it
+        //
+
+        pInitData->hCompletionPort =
+            pXxxInitExParams->Handles.hCompletionPort;
+        pInitData->dwCompletionKey = pXxxInitExParams->dwCompletionKey;
+        break;
+
+    case LINEINITIALIZEEXOPTION_USEEVENT:
+
+        if ((pInitData->hEvent = CreateEvent(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                TRUE,   // manual reset
+                FALSE,  // unsignaled
+                NULL    // unnamed
+
+                )) == NULL)
+        {
+            lResult = (bLine ? LINEERR_OPERATIONFAILED :
+                PHONEERR_OPERATIONFAILED);
+            goto xxxInitialize_cleanup;
+        }
+
+        pXxxInitExParams->Handles.hEvent = pInitData->hEvent;
+        break;
+
+    default: // case LINEINITIALIZEEXOPTION_USEHIDDENWINDOW:
+
+        pInitData->dwInitOptions = LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    
+        if (gbNTVDMClient == FALSE)
+        {
+            if ((lResult = CreateHiddenWindow(
+                    &pInitData->hwnd,
+                    (bLine ? 1 : 2)
+                    )) != 0)
+            {
+                goto xxxInitialize_cleanup;
+            }
+        }
+        else
+        {
+            pInitData->hwnd = (HWND) pfnCallback;
+        }
+
+        pInitData->lpfnCallback          = pfnCallback;
+        pInitData->bPendingAsyncEventMsg = FALSE;
+        break;
+    }
+
+    pInitData->dwKey                 = INITDATA_KEY;
+    pInitData->dwNumTotalEntries     = DEF_NUM_EVENT_BUFFER_ENTRIES;
+    pInitData->dwNumUsedEntries      = 0;
+    pInitData->pValidEntry           =
+    pInitData->pFreeEntry            = pInitData->pEventBuffer;
+
+
+    //
+    // We want to pass TAPISRV pInitData so that later when it does async
+    // completion/event notification it can pass pInitData along too so
+    // we know which init instance to talk to
+    //
+
+    funcArgs.Args[2] = (DWORD) pInitData;
+
+
+    //
+    // BUGBUG Serialize all inits/shutdowns for now so we don't run in
+    //        to problems w/ nuking the wrong AsyncEventsThread, losing
+    //        async msgs, etc
+    //
+
+    WaitForSingleObject (ghInitMutex, INFINITE);
+
+    bReleaseMutex = TRUE;
+
+    lResult = DOFUNC (&funcArgs, pszFuncName);
+
+    // BUGBUG if we AV on var fill-in then we should call lineShutdown
+
+xxxInitialize_cleanup:
+
+    if (pszModuleNamePathW)
+    {
+        ClientFree (pszModuleNamePathW);
+    }
+
+    if (lResult == 0)
+    {
+        //
+        // Save the hLineApp returned by TAPISRV in our InitData struct,
+        // and give the app back a pointer to the InitData struct instead
+        //
+
+        pInitData->hXxxApp = *((HANDLE *) phXxxApp);
+
+        *((PINIT_DATA *) phXxxApp) = pInitData;
+
+
+        //
+        // If total number of init instances is 0 we need to start a
+        // new async events thread
+        //
+
+        if (gdwNumInits == 0)
+        {
+            DWORD   dwThreadID;
+            HANDLE  hThread;
+
+
+            //
+            // Alloc resources for a new async events thread, then
+            // create the thread
+            //
+
+            if ((gpAsyncEventsThreadParams = ClientAlloc(
+                    sizeof (ASYNC_EVENTS_THREAD_PARAMS)
+                    )))
+            {
+                //
+                // Load ourself to increment our usage count. This is
+                // done to give the AsyncEventThread a chance to
+                // terminate cleanly if an app thread calls xxxShutdown
+                // and then immediately unloads tapi32.dll.
+                //
+                // (For a while we were doing a Wait on this thread's
+                // handle in xxxShutdown waiting for it to terminate,
+                // but if xxxShutdown was being called from another DLL's
+                // DllEntryPoint then deadlock occured, because
+                // DllEntryPoint's aren't reentrant.)
+                //
+
+                if ((gpAsyncEventsThreadParams->hTapi32 = LoadLibrary(
+                        "tapi32.dll"
+                        )))
+                {
+                    //
+                    // If we're supporting a 16-bit client we want to inc
+                    // the usage count for wow32 too
+                    //
+
+                    if (ghWow32Dll == NULL ||
+
+                        (gpAsyncEventsThreadParams->hWow32 = LoadLibrary(
+                            "wow32.dll"
+                            )))
+                    {
+                        //
+                        // Create the initial buffer the thread will use for
+                        // retreiving async events
+                        //
+
+                        gpAsyncEventsThreadParams->dwBufSize =
+                            ASNYC_MSG_BUF_SIZE;
+
+                        if ((gpAsyncEventsThreadParams->pBuf = ClientAlloc(
+                                gpAsyncEventsThreadParams->dwBufSize
+                                )))
+                        {
+                            //
+                            // Now that we've all the resources try to exec
+                            // the thread
+                            //
+
+                            if ((hThread = CreateThread(
+                                    NULL,
+                                    0,
+                                    (LPTHREAD_START_ROUTINE) AsyncEventsThread,
+                                    (LPVOID) gpAsyncEventsThreadParams,
+                                    0,
+                                    &dwThreadID
+
+                                    )) != NULL)
+
+                            {
+                                CloseHandle (hThread);
+                                gdwNumInits++;
+                                goto xxxInitialize_releaseMutex;
+                            }
+
+                            ClientFree (gpAsyncEventsThreadParams->pBuf);
+
+                            DBGOUT((
+                                1,
+                                "%s: CreateThread(AsyncEventsThread) " \
+                                    "failed, err=%d",
+                                pszFuncName,
+                                GetLastError()
+                                ));
+                        }
+
+                        if (ghWow32Dll)
+                        {
+                            FreeLibrary (gpAsyncEventsThreadParams->hWow32);
+                        }
+                    }
+
+                    FreeLibrary (gpAsyncEventsThreadParams->hTapi32);
+                }
+                else
+                {
+                    DBGOUT((
+                        1,
+                        "%s: LoadLibrary('tapi32.dll') failed, err=%d",
+                        pszFuncName,
+                        GetLastError()
+                        ));
+                }
+
+                ClientFree (gpAsyncEventsThreadParams);
+            }
+
+            gpAsyncEventsThreadParams = NULL;
+
+            lResult =
+                (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+        }
+        else
+        {
+            gdwNumInits++;
+        }
+    }
+
+    if (lResult != 0)
+    {
+        if (gbNTVDMClient && pInitData)
+        {
+            pInitData->hwnd = (HWND) NULL;
+        }
+
+        FreeInitData (pInitData);
+    }
+
+xxxInitialize_releaseMutex:
+
+    if (bReleaseMutex)
+    {
+        ReleaseMutex (ghInitMutex);
+    }
+
+xxxInitialize_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "%s: exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (lResult, szResult)
+            ));
+    }
+#endif
+
+    return lResult;
+}
+
+
+//
+// --------------------------------- lineXxx ----------------------------------
+//
+
+LONG
+WINAPI
+lineAccept(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lAccept),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpsUserUserInfo,
+            dwSize
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (!lpsUserUserInfo)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1]  = Dword;
+        funcArgs.Args[1]      = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2]  = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineAccept"));
+}
+
+
+LONG
+WINAPI
+lineAddProviderW(
+    LPCWSTR  lpszProviderFilename,
+    HWND     hwndOwner,
+    LPDWORD  lpdwPermanentProviderID
+    )
+{
+    DBGOUT((10, "Entering lineAddProvider"));
+    DBGOUT((11, "  lpszProviderFilename=0x%08lx", lpszProviderFilename));
+
+    if ( IsBadStringPtrW(lpszProviderFilename, (UINT)-1) )
+    {
+        DBGOUT((1, "Bad lpszProviderFilename [0x%lx] passed to lineAddProviderW", lpszProviderFilename));
+        return( LINEERR_INVALPOINTER );
+    }
+    
+    DBGOUT((12, "    *lpszProviderFilename=[%ls]", lpszProviderFilename));
+    DBGOUT((11, "  hwndOwner=0x%08lx", hwndOwner));
+    DBGOUT((11, "  lpdwPermanentProviderID=0x%08lx", lpdwPermanentProviderID));
+
+
+    
+    return (lineXxxProvider(
+        gszTUISPI_providerInstall,  // funcName
+        lpszProviderFilename,       // lpszProviderFilename
+        hwndOwner,                  // hwndOwner
+        0,                          // dwPermProviderID
+        lpdwPermanentProviderID     // lpdwPermProviderID
+        ));
+}
+
+
+LONG
+WINAPI
+lineAddProviderA(
+    LPCSTR  lpszProviderFilename,
+    HWND    hwndOwner,
+    LPDWORD lpdwPermanentProviderID
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+    DBGOUT((3, "lineAddProviderA: enter"));
+    DBGOUT((11, "  lpszProviderFilename=0x%08lx", lpszProviderFilename));
+   
+#if DBG    
+    if (!IsBadStringPtrA(lpszProviderFilename, (UINT)-1) )
+    {
+        DBGOUT((12, "    *lpszProviderFilename=[%s]", lpszProviderFilename));
+    }
+#endif    
+    
+    DBGOUT((11, "  hwndOwner=0x%08lx", hwndOwner));
+    DBGOUT((11, "  lpdwPermanentProviderID=0x%08lx", lpdwPermanentProviderID));
+
+
+    szTempPtr = NotSoWideStringToWideString (lpszProviderFilename, (DWORD) -1);
+
+    lResult = lineAddProviderW (szTempPtr, hwndOwner, lpdwPermanentProviderID);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineAddProvider: result = %s",
+            MapResultCodeToText (lResult, szResult)
+            ));
+    }
+#endif
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineAddProvider(
+    LPCSTR  lpszProviderFilename,
+    HWND    hwndOwner,
+    LPDWORD lpdwPermanentProviderID
+    )
+{
+    return lineAddProviderA(
+               lpszProviderFilename,
+               hwndOwner,
+               lpdwPermanentProviderID
+    );
+}
+
+
+LONG
+WINAPI
+lineAddToConference(
+    HCALL   hConfCall,
+    HCALL   hConsultCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lAddToConference),
+
+        {
+            (DWORD) hConfCall ,
+            (DWORD) hConsultCall
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineAddToConference"));
+}
+
+
+LONG
+WINAPI
+lineAgentSpecific(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentExtensionIDIndex,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lAgentSpecific),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) dwAgentExtensionIDIndex,
+            (DWORD) lpParams,
+            (DWORD) lpParams,
+            (DWORD) dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineAgentSpecific"));
+}
+
+
+LONG
+WINAPI
+lineAnswer(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lAnswer),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpsUserUserInfo,
+            dwSize
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (!lpsUserUserInfo)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1]  = Dword;
+        funcArgs.Args[1]      = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2]  = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineAnswer"));
+}
+
+
+LONG
+WINAPI
+lineBlindTransferW(
+    HCALL   hCall,
+    LPCWSTR lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lBlindTransfer),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpszDestAddress,
+            dwCountryCode
+        },
+
+        {
+            Dword,
+            lpszW,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineBlindTransfer"));
+}
+
+
+LONG
+WINAPI
+lineBlindTransferA(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    szTempPtr = NotSoWideStringToWideString (lpszDestAddress, (DWORD) -1);
+
+    lResult = lineBlindTransferW (hCall, szTempPtr, dwCountryCode);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineBlindTransfer(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    return lineBlindTransferA(
+                hCall,
+                lpszDestAddress,
+                dwCountryCode
+    );
+}   
+
+ 
+LONG
+WINAPI
+lineClose(
+    HLINE   hLine
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 1, lClose),
+
+        {
+            (DWORD) hLine
+        },
+
+        {
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineClose"));
+}
+
+
+void
+PASCAL
+lineCompleteCallPostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    DBGOUT((3, "lineCompleteCallPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD   dwCompletionID   = (DWORD) pMsg->dwParam3;
+        LPDWORD lpdwCompletionID = (LPDWORD) pMsg->dwParam4;
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPDWORD lpdwCompletionIDVDM = (LPDWORD) gpfnWOWGetVDMPointer (
+                    (DWORD) lpdwCompletionID,
+                    sizeof(DWORD),
+                    TRUE // fProtectedMode
+                    );
+
+
+                if (lpdwCompletionIDVDM)
+                {
+                    *lpdwCompletionIDVDM = dwCompletionID;
+                }
+                else
+                {
+                    pMsg->dwParam2 = LINEERR_INVALPOINTER;
+                }
+            }
+            else
+            {
+                *lpdwCompletionID = dwCompletionID;
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineCompleteCall(
+    HCALL   hCall,
+    LPDWORD lpdwCompletionID,
+    DWORD   dwCompletionMode,
+    DWORD   dwMessageID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lCompleteCall),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineCompleteCallPostProcess),
+            (DWORD) hCall,
+            (DWORD) lpdwCompletionID,
+            dwCompletionMode,
+            dwMessageID
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineCompleteCall"));
+}
+
+
+LONG
+WINAPI
+lineCompleteTransfer(
+    HCALL   hCall,
+    HCALL   hConsultCall,
+    LPHCALL lphConfCall,
+    DWORD   dwTransferMode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lCompleteTransfer),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hCall,
+            (DWORD) hConsultCall,
+            (DWORD) lphConfCall,
+            (DWORD) dwTransferMode,
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword: lpDword),
+            Dword,
+        }
+    };
+
+
+    if (dwTransferMode == LINETRANSFERMODE_TRANSFER)
+    {
+        //
+        // lphCall should be ignored
+        //
+
+        funcArgs.Args[0] = 0; // (POSTPROCESSPROC) NULL;
+        funcArgs.ArgTypes[3] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineCompleteTransfer"));
+}
+
+
+LONG
+WINAPI
+lineConfigDialogW(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    LONG        lResult;
+    HANDLE      hDll;
+    TUISPIPROC  pfnTUISPI_lineConfigDialog;
+
+
+    if (lpszDeviceClass && IsBadStringPtrW (lpszDeviceClass, 256))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if ((lResult = LoadUIDll(
+            hwndOwner,
+            dwDeviceID,
+            TUISPIDLL_OBJECT_LINEID,
+            &hDll,
+            gszTUISPI_lineConfigDialog,
+            &pfnTUISPI_lineConfigDialog
+
+            )) == 0)
+    {
+        DBGOUT((3, "Calling TUISPI_lineConfigDialog..."));
+
+        lResult = (*pfnTUISPI_lineConfigDialog)(
+            TUISPIDLLCallback,
+            dwDeviceID,
+            hwndOwner,
+            lpszDeviceClass
+            );
+
+#if DBG
+        {
+            char szResult[32];
+
+
+            DBGOUT((
+                3,
+                "TUISPI_lineConfigDialog: result = %s",
+                MapResultCodeToText (lResult, szResult)
+                ));
+        }
+#endif
+
+        FreeLibrary (hDll);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigDialogA(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    PWSTR szTempString = NULL;
+    LONG  lResult;
+
+
+    if (lpszDeviceClass && IsBadStringPtrA (lpszDeviceClass, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    szTempString = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+
+    lResult = lineConfigDialogW (dwDeviceID, hwndOwner, szTempString);
+
+    if (szTempString)
+    {
+        ClientFree (szTempString);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    return lineConfigDialogA(
+               dwDeviceID,
+               hwndOwner,
+               lpszDeviceClass
+               );
+}   
+
+ 
+LONG
+WINAPI
+lineConfigDialogEditW(
+    DWORD           dwDeviceID,
+    HWND            hwndOwner,
+    LPCWSTR         lpszDeviceClass,
+    LPVOID const    lpDeviceConfigIn,
+    DWORD           dwSize,
+    LPVARSTRING     lpDeviceConfigOut
+    )
+{
+    LONG        lResult;
+    HANDLE      hDll;
+    TUISPIPROC  pfnTUISPI_lineConfigDialogEdit;
+
+
+    if (lpszDeviceClass && IsBadStringPtrW (lpszDeviceClass, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (IsBadReadPtr (lpDeviceConfigIn, dwSize))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (IsBadWritePtr (lpDeviceConfigOut, sizeof (VARSTRING)))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (lpDeviceConfigOut->dwTotalSize < sizeof (VARSTRING))
+    {
+        return LINEERR_STRUCTURETOOSMALL;
+    }
+
+    if (IsBadWritePtr (lpDeviceConfigOut, lpDeviceConfigOut->dwTotalSize))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if ((lResult = LoadUIDll(
+            hwndOwner,
+            dwDeviceID,
+            TUISPIDLL_OBJECT_LINEID,
+            &hDll,
+            gszTUISPI_lineConfigDialogEdit,
+            &pfnTUISPI_lineConfigDialogEdit
+
+            )) == 0)
+    {
+        DBGOUT((3, "Calling TUISPI_lineConfigDialogEdit..."));
+
+        lResult = (*pfnTUISPI_lineConfigDialogEdit)(
+            TUISPIDLLCallback,
+            dwDeviceID,
+            hwndOwner,
+            lpszDeviceClass,
+            lpDeviceConfigIn,
+            dwSize,
+            lpDeviceConfigOut
+            );
+
+#if DBG
+        {
+            char szResult[32];
+
+
+            DBGOUT((
+                3,
+                "TUISPI_lineConfigDialogEdit: result = %s",
+                MapResultCodeToText (lResult, szResult)
+                ));
+        }
+#endif
+        FreeLibrary (hDll);
+    }
+
+lineConfigDialogEdit_return:
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigDialogEditA(
+    DWORD           dwDeviceID,
+    HWND            hwndOwner,
+    LPCSTR          lpszDeviceClass,
+    LPVOID const    lpDeviceConfigIn,
+    DWORD           dwSize,
+    LPVARSTRING     lpDeviceConfigOut
+    )
+{
+    PWSTR szTempString;
+    LONG  lResult;
+
+
+    if (lpszDeviceClass && IsBadStringPtrA (lpszDeviceClass, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    szTempString = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+
+    lResult = lineConfigDialogEditW(
+        dwDeviceID,
+        hwndOwner,
+        szTempString,
+        lpDeviceConfigIn,
+        dwSize,
+        lpDeviceConfigOut
+        );
+
+    if (szTempString)
+    {
+        ClientFree (szTempString);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigDialogEdit(
+    DWORD           dwDeviceID,
+    HWND            hwndOwner,
+    LPCSTR          lpszDeviceClass,
+    LPVOID const    lpDeviceConfigIn,
+    DWORD           dwSize,
+    LPVARSTRING     lpDeviceConfigOut
+    )
+{
+    return lineConfigDialogEditA(
+                    dwDeviceID,
+                    hwndOwner,
+                    lpszDeviceClass,
+                    lpDeviceConfigIn,
+                    dwSize,
+                    lpDeviceConfigOut
+    );
+}   
+
+ 
+LONG
+WINAPI
+lineConfigProvider(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    return (lineXxxProvider(
+        gszTUISPI_providerConfig,   // func name
+        NULL,                       // lpszProviderFilename
+        hwndOwner,                  // hwndOwner
+        dwPermanentProviderID,      // dwPermProviderID
+        NULL                        // lpdwPermProviderID
+        ));
+}
+
+
+LONG
+WINAPI
+lineDeallocateCall(
+    HCALL   hCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 1, lDeallocateCall),
+
+        {
+            (DWORD) hCall
+        },
+
+        {
+            Dword
+        }
+    };
+
+    DBGOUT((3, "lineDeallocateCall: enter on thread: 0x%08lx", GetCurrentThreadId()));
+    DBGOUT((4, "  hCall = 0x%08lx", hCall));
+
+    return (DOFUNC (&funcArgs, "lineDeallocateCall"));
+}
+
+
+void
+PASCAL
+lineDevSpecificPostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineDevSpecificPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD   dwSize  = pMsg->dwParam4;
+        LPBYTE  pParams = (LPBYTE) pMsg->dwParam3;
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPBYTE pParamsVDM = (LPBYTE) gpfnWOWGetVDMPointer(
+                    (DWORD) pParams,
+                    dwSize,
+                    TRUE // fProtectedMode
+                    );
+
+
+                if (pParamsVDM)
+                {
+                    CopyMemory (pParamsVDM, (LPBYTE) (pMsg + 1), dwSize);
+                }
+                else
+                {
+                    pMsg->dwParam2 = LINEERR_INVALPOINTER;
+                }
+            }
+            else
+            {
+                CopyMemory (pParams, (LPBYTE) (pMsg + 1), dwSize);
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineDevSpecific(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lDevSpecific),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLine,
+            dwAddressID,
+            (DWORD) hCall,
+            (DWORD) lpParams, // pass the actual pointer (for post processing)
+            (DWORD) lpParams, // pass data
+            dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size,
+        }
+    };
+
+
+    if (gbNTVDMClient)
+    {
+        if (!gpfnWOWGetVDMPointer  ||
+
+            !(funcArgs.Args[5] = gpfnWOWGetVDMPointer(
+                (DWORD) lpParams,
+                dwSize,
+                TRUE // fProtectedMode
+                )))
+        {
+            return LINEERR_OPERATIONFAILED;
+        }
+    }
+
+    return (DOFUNC (&funcArgs, "lineDevSpecific"));
+}
+
+
+LONG
+WINAPI
+lineDevSpecificFeature(
+    HLINE   hLine,
+    DWORD   dwFeature,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lDevSpecificFeature),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLine,
+            dwFeature,
+            (DWORD) lpParams, // pass the actual pointer (for post processing)
+            (DWORD) lpParams, // pass data
+            dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (gbNTVDMClient)
+    {
+        if (!gpfnWOWGetVDMPointer ||
+
+            !(funcArgs.Args[4] = gpfnWOWGetVDMPointer(
+                (DWORD) lpParams,
+                dwSize,
+                TRUE // fProtectedMode
+                )))
+        {
+            return LINEERR_OPERATIONFAILED;
+        }
+    }
+
+    return (DOFUNC (&funcArgs, "lineDevSpecificFeature"));
+}
+
+
+LONG
+WINAPI
+lineDialW(
+    HCALL   hCall,
+    LPCWSTR lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lDial),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpszDestAddress,
+            dwCountryCode
+        },
+
+        {
+            Dword,
+            lpszW,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineDial"));
+}
+
+
+LONG
+WINAPI
+lineDialA(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    szTempPtr = NotSoWideStringToWideString (lpszDestAddress, (DWORD) -1);
+
+    lResult = lineDialW (hCall, szTempPtr, dwCountryCode);
+
+    ClientFree (szTempPtr);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineDial(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    return lineDialA(
+            hCall,
+            lpszDestAddress,
+            dwCountryCode
+    );
+}   
+
+ 
+LONG
+WINAPI
+lineDrop(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lDrop),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpsUserUserInfo,
+            dwSize
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (!lpsUserUserInfo)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineDrop"));
+}
+
+
+LONG
+WINAPI
+lineForwardW(
+    HLINE   hLine,
+    DWORD   bAllAddresses,
+    DWORD   dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD   dwNumRingsNoAnswer,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 9, lForward),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hLine,
+            bAllAddresses,
+            dwAddressID,
+            (DWORD) lpForwardList,
+            dwNumRingsNoAnswer,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_Struct,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpForwardList)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[4] = Dword;
+        funcArgs.Args[4]     = TAPI_NO_DATA;
+    }
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[7] = Dword;
+        funcArgs.Args[7]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineForwardW"));
+}
+
+
+// void
+// LayDownNewString(
+//     LPBYTE  pOldBase,
+//     LPDWORD pdwOldSizeOffset,
+//     LPBYTE  pNewBase,
+//     LPDWORD pdwNewSizeOffset,
+//     LPDWORD pdwNewOffset
+//     )
+// {
+//     LPBYTE pOldString;
+//     DWORD  dwNewStringSize;
+// 
+// 
+//     pOldString =  pOldBase + *(pdwOldSizeOffset + 1);
+// 
+//     *(pdwNewSizeOffset + 1) = *pdwNewOffset;
+// 
+//     if ( IsBadStringPtr( pOldString, 256) )
+//     {
+//         return;
+//     }
+// 
+//     dwNewStringSize = sizeof(WCHAR) * MultiByteToWideChar(
+//         GetACP(),
+//         MB_PRECOMPOSED,
+//         pOldString,
+//         *pdwOldSizeOffset,
+//         (PWSTR)(pNewBase + *(pdwNewSizeOffset + 1)),
+//         *pdwOldSizeOffset
+//         );
+// 
+//     *pdwNewSizeOffset = dwNewStringSize;
+// 
+//     *pdwNewOffset = (*pdwNewOffset + dwNewStringSize + 3) & 0xfffffffc;
+// }
+
+
+LONG
+WINAPI
+lineForwardA(
+    HLINE   hLine,
+    DWORD   bAllAddresses,
+    DWORD   dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD   dwNumRingsNoAnswer,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LPLINEFORWARDLIST lplfl;
+    LONG lResult;
+    DWORD n;
+    DWORD dwNewOffset;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 9, lForward),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hLine,
+            (DWORD) bAllAddresses,
+            (DWORD) dwAddressID,
+            (DWORD) lpForwardList,
+            (DWORD) dwNumRingsNoAnswer,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (DWORD) GetACP()        // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_Struct,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpForwardList)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[4] = Dword;
+        funcArgs.Args[4]     = TAPI_NO_DATA;
+    }
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[7] = Dword;
+        funcArgs.Args[7]     = TAPI_NO_DATA;
+    }
+
+
+    return (DOFUNC (&funcArgs, "lineForward"));
+}
+
+
+
+LONG
+WINAPI
+lineForward(
+    HLINE   hLine,
+    DWORD   bAllAddresses,
+    DWORD   dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD   dwNumRingsNoAnswer,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    return lineForwardA(
+             hLine,
+             bAllAddresses,
+             dwAddressID,
+             lpForwardList,
+             dwNumRingsNoAnswer,
+             lphConsultCall,
+             lpCallParams
+    );
+}   
+
+ 
+void
+PASCAL
+lineGatherDigitsWPostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    DBGOUT((3, "lineGatherDigitsWPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam1 & (LINEGATHERTERM_BUFFERFULL | LINEGATHERTERM_CANCEL |
+            LINEGATHERTERM_TERMDIGIT | LINEGATHERTERM_INTERTIMEOUT))
+    {
+        LPSTR   lpsDigits = (LPSTR) pMsg->dwParam2;
+        DWORD   dwNumDigits = pMsg->dwParam4;
+
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPSTR lpsDigitsVDM = (LPSTR) gpfnWOWGetVDMPointer(
+                    (DWORD) lpsDigits,
+                    dwNumDigits * sizeof(WCHAR),
+                    TRUE // fProtectedMode
+                    );
+
+
+                if (lpsDigitsVDM)
+                {
+                    CopyMemory(
+                        lpsDigitsVDM,
+                        pMsg + 1,
+                        dwNumDigits * sizeof (WCHAR)
+                        );
+                }
+                else
+                {
+                }
+            }
+            else
+            {
+                CopyMemory (lpsDigits, pMsg + 1, dwNumDigits * sizeof(WCHAR));
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            //
+            // Don't do anything if we GPF
+            //
+        }
+    }
+
+    pMsg->dwParam2 = pMsg->dwParam3 = 0;
+}
+
+
+LONG
+WINAPI
+lineGatherDigitsW(
+    HCALL   hCall,
+    DWORD   dwDigitModes,
+    LPWSTR  lpsDigits,
+    DWORD   dwNumDigits,
+    LPCWSTR lpszTerminationDigits,
+    DWORD   dwFirstDigitTimeout,
+    DWORD   dwInterDigitTimeout
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 8, lGatherDigits),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineGatherDigitsWPostProcess),
+            (DWORD) hCall,
+            dwDigitModes,
+            (DWORD) lpsDigits,
+            dwNumDigits,
+            (DWORD) lpszTerminationDigits,
+            dwFirstDigitTimeout,
+            dwInterDigitTimeout
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpszW,
+            Dword,
+            Dword
+        }
+    };
+
+
+    //
+    // Note: we do the ptr check here rather than in DOFUNC because we're
+    //       not passing any digits data within the context of this func
+    //
+
+    if (lpsDigits && IsBadWritePtr (lpsDigits, dwNumDigits * sizeof (WCHAR)))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (lpszTerminationDigits == (LPCWSTR) NULL)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[5] = Dword;
+        funcArgs.Args[5]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineGatherDigits"));
+}
+
+
+void
+PASCAL
+lineGatherDigitsPostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    DBGOUT((3, "lineGatherDigitsPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    {
+        LPSTR   lpsDigits = (LPSTR) pMsg->dwParam2;
+        DWORD   dwNumDigits = pMsg->dwParam4;
+
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPSTR lpsDigitsVDM = (LPSTR) gpfnWOWGetVDMPointer(
+                    (DWORD) lpsDigits,
+                    dwNumDigits * sizeof(WCHAR),
+                    TRUE // fProtectedMode
+                    );
+
+
+                if (lpsDigitsVDM)
+                {
+                      WideCharToMultiByte(
+                          GetACP(),
+                          0,
+                          (LPCWSTR)(pMsg + 1),
+                          dwNumDigits,
+                          lpsDigitsVDM,
+                          dwNumDigits,
+                          NULL,
+                          NULL
+                          );
+                }
+                else
+                {
+                }
+            }
+            else
+            {
+                  WideCharToMultiByte(
+                      GetACP(),
+                      0,
+                      (LPCWSTR)(pMsg + 1),
+                      dwNumDigits,
+                      lpsDigits,
+                      dwNumDigits,
+                      NULL,
+                      NULL
+                      );
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            //
+            // Don't do anything if we GPF
+            //
+        }
+    }
+
+    pMsg->dwParam2 = pMsg->dwParam2 = 0;
+}
+
+
+LONG
+WINAPI
+lineGatherDigitsA(
+    HCALL   hCall,
+    DWORD   dwDigitModes,
+    LPSTR   lpsDigits,
+    DWORD   dwNumDigits,
+    LPCSTR  lpszTerminationDigits,
+    DWORD   dwFirstDigitTimeout,
+    DWORD   dwInterDigitTimeout
+    )
+{
+    LONG lResult;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 8, lGatherDigits),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineGatherDigitsPostProcess),
+            (DWORD) hCall,
+            dwDigitModes,
+            (DWORD) lpsDigits,
+            dwNumDigits,
+            0,                    // (DWORD) lpszTerminationDigits,
+            dwFirstDigitTimeout,
+            dwInterDigitTimeout
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpszW,
+            Dword,
+            Dword
+        }
+    };
+
+
+    //
+    // Note: we do the ptr check here rather than in DOFUNC because we're
+    //       not passing any digits data within the context of this func
+    //
+
+    if (gbNTVDMClient == FALSE)
+    {
+        if (lpsDigits && IsBadWritePtr (lpsDigits, dwNumDigits))
+        {
+            return LINEERR_INVALPOINTER;
+        }
+    }
+
+    if (lpszTerminationDigits == (LPCSTR) NULL)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[5] = Dword;
+        funcArgs.Args[5]     = TAPI_NO_DATA;
+    }
+    else
+    {
+        funcArgs.Args[5] = (DWORD) NotSoWideStringToWideString(
+            lpszTerminationDigits,
+            (DWORD) -1
+            );
+    }
+
+    lResult = (DOFUNC (&funcArgs, "lineGatherDigits"));
+
+    if ( funcArgs.Args[5] && (funcArgs.Args[5] != TAPI_NO_DATA) )
+    {
+       ClientFree( (LPVOID)funcArgs.Args[5] );
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGatherDigits(
+    HCALL   hCall,
+    DWORD   dwDigitModes,
+    LPSTR   lpsDigits,
+    DWORD   dwNumDigits,
+    LPCSTR  lpszTerminationDigits,
+    DWORD   dwFirstDigitTimeout,
+    DWORD   dwInterDigitTimeout
+    )
+{
+    return lineGatherDigitsA(
+              hCall,
+              dwDigitModes,
+              lpsDigits,
+              dwNumDigits,
+              lpszTerminationDigits,
+              dwFirstDigitTimeout,
+              dwInterDigitTimeout
+    );
+}    
+
+
+LONG
+WINAPI
+lineGenerateDigitsW(
+    HCALL   hCall,
+    DWORD   dwDigitMode,
+    LPCWSTR lpszDigits,
+    DWORD   dwDuration
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGenerateDigits),
+
+        {
+            (DWORD) hCall,
+            dwDigitMode,
+            (DWORD) lpszDigits,
+            dwDuration,
+            0           // dwEndToEndID, remotesp only
+        },
+
+        {
+            Dword,
+            Dword,
+            lpszW,
+            Dword,
+            Dword
+        }
+    };
+
+
+    if (!lpszDigits)
+    {
+        funcArgs.Args[2]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineGenerateDigits"));
+}
+
+
+LONG
+WINAPI
+lineGenerateDigitsA(
+    HCALL   hCall,
+    DWORD   dwDigitMode,
+    LPCSTR  lpszDigits,
+    DWORD   dwDuration
+    )
+{
+    LONG lResult;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGenerateDigits),
+
+        {
+            (DWORD) hCall,
+            dwDigitMode,
+            0,                // (DWORD) lpszDigits,
+            dwDuration,
+            0           // dwEndToEndID, remotesp only
+        },
+
+        {
+            Dword,
+            Dword,
+            lpszW,
+            Dword,
+            Dword
+        }
+    };
+
+
+    if (lpszDigits)
+    {
+        if (IsBadStringPtrA (lpszDigits, (DWORD) -1))
+        {
+            return LINEERR_INVALPOINTER;
+        }
+        else if (!(funcArgs.Args[2] = (DWORD) NotSoWideStringToWideString(
+                    lpszDigits,
+                    (DWORD) -1
+                    )))
+        {
+            return LINEERR_NOMEM;
+        }
+    }
+    else
+    {
+        funcArgs.Args[2]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    lResult = (DOFUNC (&funcArgs, "lineGenerateDigits"));
+
+    if (funcArgs.Args[2] != TAPI_NO_DATA)
+    {
+        ClientFree ((LPVOID) funcArgs.Args[2]);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGenerateDigits(
+    HCALL   hCall,
+    DWORD   dwDigitMode,
+    LPCSTR  lpszDigits,
+    DWORD   dwDuration
+    )
+{
+    return lineGenerateDigitsA(
+              hCall,
+              dwDigitMode,
+              lpszDigits,
+              dwDuration
+    );
+}    
+
+
+LONG
+WINAPI
+lineGenerateTone(
+    HCALL   hCall,
+    DWORD   dwToneMode,
+    DWORD   dwDuration,
+    DWORD   dwNumTones,
+    LPLINEGENERATETONE const lpTones
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 7, lGenerateTone),
+
+        {
+            (DWORD) hCall,
+            dwToneMode,
+            dwDuration,
+            dwNumTones,
+            TAPI_NO_DATA,   // (DWORD) lpTones,
+            0,              // dwNumTones * sizeof(LINEGENERATETONE)
+            0               // dwEndToEndID, remotesp only
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,      // lpSet_SizeToFollow,
+            Dword,      // Size
+            Dword
+        }
+    };
+
+
+    if (dwToneMode == LINETONEMODE_CUSTOM)
+    {
+        //
+        // Set lpTones (& following Size arg) since in this case
+        // they are valid args
+        //
+
+        funcArgs.ArgTypes[4] = lpSet_SizeToFollow;
+        funcArgs.Args[4]     = (DWORD) lpTones;
+        funcArgs.ArgTypes[5] = Size;
+        funcArgs.Args[5]     = dwNumTones * sizeof(LINEGENERATETONE);
+    }
+
+    return (DOFUNC (&funcArgs, "lineGenerateTone"));
+}
+
+
+LONG
+WINAPI
+lineGetAddressCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, lGetAddressCaps),
+
+        {
+            (DWORD) hLineApp,
+            dwDeviceID,
+            dwAddressID,
+            dwAPIVersion,
+            dwExtVersion,
+            (DWORD) lpAddressCaps
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+    if (
+          (IsBadWritePtr( lpAddressCaps, 4))
+        ||
+          (IsBadWritePtr( lpAddressCaps, lpAddressCaps->dwTotalSize))
+       )
+    {
+       DBGOUT((1, "lineGetAddressCaps: Bad lpAddressCaps: 0x%08lx",
+                                     lpAddressCaps));
+
+       return LINEERR_INVALPOINTER;
+    }
+
+    return (DOFUNC (&funcArgs, "lineGetAddressCaps"));
+}
+
+
+LONG
+WINAPI
+lineGetAddressCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+    LONG lResult;
+
+
+    lResult = lineGetAddressCapsW(
+        hLineApp,
+        dwDeviceID,
+        dwAddressID,
+        dwAPIVersion,
+        dwExtVersion,
+        lpAddressCaps
+        );
+
+    if (lResult == 0)
+    {
+        WideStringToNotSoWideString(
+            (LPBYTE)lpAddressCaps,
+            &lpAddressCaps->dwAddressSize
+            );
+/*
+        BUGBUG Hold off on converting this, since the conversion to
+               multibyte of the various completion msgs may not yield
+               consistent sizes
+
+//        WideStringToNotSoWideString(
+//            (LPBYTE)lpAddressCaps,
+//            &lpAddressCaps->dwCompletionMsgTextSize
+//            );
+//
+//        if (lpAddressCaps->dwCompletionMsgTextEntrySize)
+//        {
+//            lpAddressCaps->dwCompletionMsgTextEntrySize /= 2; // BUGBUG???
+//        }
+*/
+        if (dwAPIVersion >= 0x00020000)
+        {
+            WideStringToNotSoWideString(
+                    (LPBYTE)lpAddressCaps,
+                    &lpAddressCaps->dwDeviceClassesSize
+                    );
+        }
+       
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAddressCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+    return lineGetAddressCapsA(
+                         hLineApp,
+                         dwDeviceID,
+                         dwAddressID,
+                         dwAPIVersion,
+                         dwExtVersion,
+                         lpAddressCaps
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetAddressIDW(
+    HLINE   hLine,
+    LPDWORD lpdwAddressID,
+    DWORD   dwAddressMode,
+    LPCWSTR lpsAddress,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGetAddressID),
+
+        {
+            (DWORD) hLine,
+            (DWORD) lpdwAddressID,
+            dwAddressMode,
+            (DWORD) lpsAddress,
+            dwSize
+        },
+
+        {
+            Dword,
+            lpDword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAddressID"));
+}
+
+
+LONG
+WINAPI
+lineGetAddressIDA(
+    HLINE   hLine,
+    LPDWORD lpdwAddressID,
+    DWORD   dwAddressMode,
+    LPCSTR  lpsAddress,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult;
+    DWORD   dwNumChars;
+    PWSTR   szTempPtr;
+
+
+    //
+    // Special case for dwSize = -1 (implies a NULL-terminated string as
+    // far as IsBadStringPtrA is concerned)
+    //
+
+    if (dwSize == 0  ||  IsBadReadPtr (lpsAddress, dwSize))
+    {
+       DBGOUT((1, "lineGetAddressID: Bad lpsAddress or dwSize"));
+       return LINEERR_INVALPOINTER;
+    }
+
+    dwNumChars = MultiByteToWideChar(
+        GetACP(),
+        MB_PRECOMPOSED,
+        lpsAddress,
+        dwSize,
+        NULL,
+        0
+        );
+
+    if (!(szTempPtr = ClientAlloc (dwNumChars * sizeof (WCHAR))))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    MultiByteToWideChar(
+        GetACP(),
+        MB_PRECOMPOSED,
+        lpsAddress,
+        dwSize,
+        szTempPtr,
+        dwNumChars
+        );
+
+    lResult = lineGetAddressIDW(
+        hLine,
+        lpdwAddressID,
+        dwAddressMode,
+        szTempPtr,
+        dwNumChars * sizeof (WCHAR)
+        );
+
+    ClientFree (szTempPtr);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAddressID(
+    HLINE   hLine,
+    LPDWORD lpdwAddressID,
+    DWORD   dwAddressMode,
+    LPCSTR  lpsAddress,
+    DWORD   dwSize
+    )
+{
+    return lineGetAddressIDA(
+              hLine,
+              lpdwAddressID,
+              dwAddressMode,
+              lpsAddress,
+              dwSize
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetAddressStatusW(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetAddressStatus),
+
+        {
+            (DWORD) hLine,
+            dwAddressID,
+            (DWORD) lpAddressStatus
+        },
+
+        {
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAddressStatus"));
+}
+
+
+LONG
+WINAPI
+lineGetAddressStatusA(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr = NULL;
+
+
+    if ( IsBadWritePtr(lpAddressStatus, sizeof(LINEADDRESSSTATUS)) )
+    {
+       DBGOUT((1, "lineGetAddressStatus: Bad lpAddressStatus pointer"));
+       return LINEERR_INVALPOINTER;
+    }
+
+    lResult = lineGetAddressStatusW(
+        hLine,
+        dwAddressID,
+        lpAddressStatus
+        );
+
+
+    if (lResult == 0)
+    {
+        DWORD         i;
+        LPLINEFORWARD lplf;
+
+
+        lplf = (LPLINEFORWARD) (((LPBYTE)lpAddressStatus) +
+                                 lpAddressStatus->dwForwardOffset);
+
+        for (i = 0; i < lpAddressStatus->dwForwardNumEntries;  i++, lplf++)
+        {
+            WideStringToNotSoWideString(
+                (LPBYTE) lpAddressStatus,
+                &(lplf->dwCallerAddressSize)
+                );
+
+            WideStringToNotSoWideString(
+                (LPBYTE) lpAddressStatus,
+                &(lplf->dwDestAddressSize)
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAddressStatus(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    return lineGetAddressStatusA(
+              hLine,
+              dwAddressID,
+              lpAddressStatus
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetAgentActivityListW(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lGetAgentActivityList),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentActivityList,    // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentActivityList     // pass data
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentActivityListW"));
+}
+
+
+void
+PASCAL
+lineGetAgentActivityListAPostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineGetAgentActivityListAPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD                   dwSize  = pMsg->dwParam4;
+        LPLINEAGENTACTIVITYLIST lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                                    pMsg->dwParam3;
+
+
+        try
+        {
+            DWORD                       dw, dwNumEntries;
+            LPLINEAGENTACTIVITYENTRY    lplaae;
+
+
+            //
+            // Note: the agent APIs are not exposed to 16-bit apps, so
+            // there's no reason to special case on gbNTVDMClient like
+            // lineDevSpecificPostProcess does
+            //
+
+            CopyMemory (lpAgentActivityList, (LPBYTE) (pMsg + 1), dwSize);
+
+
+            //
+            // Now some unicode->ascii post processing on embedded strings
+            //
+
+            lplaae = (LPLINEAGENTACTIVITYENTRY)(((LPBYTE)lpAgentActivityList) +
+                lpAgentActivityList->dwListOffset);
+
+            dwNumEntries = lpAgentActivityList->dwNumEntries;
+
+            for (dw = 0; dw < dwNumEntries; dw++, lplaae++)
+            {
+                WideStringToNotSoWideString(
+                    (LPBYTE) lpAgentActivityList,
+                    &(lplaae->dwNameSize)
+                    );
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineGetAgentActivityListA(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lGetAgentActivityList),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineGetAgentActivityListAPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentActivityList,    // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentActivityList     // pass data
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentActivityListA"));
+}
+
+
+LONG
+WINAPI
+lineGetAgentCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lGetAgentCaps),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLineApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAddressID,
+            (DWORD) dwAppAPIVersion,
+            (DWORD) lpAgentCaps,    // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentCaps     // pass data
+        },
+
+        {
+            Dword,
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentCapsW"));
+}
+
+
+void
+PASCAL
+lineGetAgentCapsAPostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineGetAgentCapsAPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD           dwSize  = pMsg->dwParam4;
+        LPLINEAGENTCAPS lpAgentCaps = (LPLINEAGENTCAPS) pMsg->dwParam3;
+
+
+        try
+        {
+            //
+            // Note: the agent APIs are not exposed to 16-bit apps, so
+            // there's no reason to special case on gbNTVDMClient like
+            // lineDevSpecificPostProcess does
+            //
+
+            CopyMemory (lpAgentCaps, (LPBYTE) (pMsg + 1), dwSize);
+
+
+            //
+            // Now some unicode->ascii post processing on embedded strings
+            //
+
+            WideStringToNotSoWideString(
+                (LPBYTE) lpAgentCaps,
+                &lpAgentCaps->dwAgentHandlerInfoSize
+                );
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineGetAgentCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lGetAgentCaps),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineGetAgentCapsAPostProcess),
+            (DWORD) hLineApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAddressID,
+            (DWORD) dwAppAPIVersion,
+            (DWORD) lpAgentCaps,    // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentCaps     // pass data
+        },
+
+        {
+            Dword,
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentCapsA"));
+}
+
+
+LONG
+WINAPI
+lineGetAgentGroupListW(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lGetAgentGroupList),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentGroupList,       // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentGroupList        // pass data
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentGroupListW"));
+}
+
+
+void
+PASCAL
+lineGetAgentGroupListAPostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineGetAgentGroupListAPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD                   dwSize = pMsg->dwParam4;
+        LPLINEAGENTGROUPLIST    lpAgentGroupList = (LPLINEAGENTGROUPLIST)
+                                    pMsg->dwParam3;
+
+
+        try
+        {
+            DWORD                   dw, dwNumEntries;
+            LPLINEAGENTGROUPENTRY   lplage;
+
+
+            //
+            // Note: the agent APIs are not exposed to 16-bit apps, so
+            // there's no reason to special case on gbNTVDMClient like
+            // lineDevSpecificPostProcess does
+            //
+
+            CopyMemory (lpAgentGroupList, (LPBYTE) (pMsg + 1), dwSize);
+
+
+            //
+            // Now some unicode->ascii post processing on embedded strings
+            //
+
+            lplage = (LPLINEAGENTGROUPENTRY)(((LPBYTE) lpAgentGroupList) +
+                lpAgentGroupList->dwListOffset);
+
+            dwNumEntries = lpAgentGroupList->dwNumEntries;
+
+            for (dw = 0; dw < dwNumEntries; dw++, lplage++)
+            {
+                WideStringToNotSoWideString(
+                    (LPBYTE) lpAgentGroupList,
+                    &(lplage->dwNameSize)
+                    );
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineGetAgentGroupListA(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lGetAgentGroupList),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineGetAgentGroupListAPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentGroupList,       // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentGroupList        // pass data
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentGroupListA"));
+}
+
+
+LONG
+WINAPI
+lineGetAgentStatusW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lGetAgentStatus),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineDevSpecificPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentStatus,          // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentStatus           // pass data
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentStatusW"));
+}
+
+
+void
+PASCAL
+lineGetAgentStatusAPostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineGetAgentStatusAPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD               dwSize = pMsg->dwParam4;
+        LPLINEAGENTSTATUS   lpAgentStatus = (LPLINEAGENTSTATUS) pMsg->dwParam3;
+
+
+        try
+        {
+            DWORD                   dw, dwNumEntries;
+            LPLINEAGENTGROUPENTRY   lplage;
+
+
+            //
+            // Note: the agent APIs are not exposed to 16-bit apps, so
+            // there's no reason to special case on gbNTVDMClient like
+            // lineDevSpecificPostProcess does
+            //
+
+            CopyMemory (lpAgentStatus, (LPBYTE) (pMsg + 1), dwSize);
+
+
+            //
+            // Now some unicode->ascii post processing on embedded strings
+            //
+
+            lplage = (LPLINEAGENTGROUPENTRY) (((LPBYTE) lpAgentStatus) +
+                lpAgentStatus->dwGroupListOffset);
+
+            dwNumEntries = lpAgentStatus->dwNumEntries;
+
+            for (dw = 0; dw < dwNumEntries; dw++, lplage++)
+            {
+                WideStringToNotSoWideString(
+                    (LPBYTE)lpAgentStatus,
+                    &(lplage->dwNameSize)
+                    );
+            }
+
+            WideStringToNotSoWideString(
+                (LPBYTE)lpAgentStatus,
+                &lpAgentStatus->dwActivitySize
+                );
+
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineGetAgentStatusA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lGetAgentStatus),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineGetAgentStatusAPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentStatus,          // pass the actual ptr (for ppproc)
+            (DWORD) lpAgentStatus           // pass data
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetAgentStatusA"));
+}
+
+
+LONG
+WINAPI
+lineGetAppPriorityW(
+    LPCWSTR lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPVARSTRING lpExtensionName,
+    LPDWORD lpdwPriority
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 7, lGetAppPriority),
+
+        {
+            (DWORD) lpszAppName,
+            dwMediaMode,
+            0,
+            0,
+            dwRequestMode,
+            0,
+            (DWORD) lpdwPriority
+        },
+
+        {
+            lpszW,      // app name
+            Dword,      // media mode
+            Dword,      // ext id (offset)
+            Dword,      // ext id (size)
+            Dword,      // request mode
+            Dword,      // ext name total size
+            lpDword     // lp pri
+        }
+    };
+
+
+    if (dwMediaMode & 0xff000000)
+    {
+        if ((LPVOID) lpExtensionName == (LPVOID) lpdwPriority)
+        {
+            return LINEERR_INVALPOINTER;
+        }
+
+
+        //
+        // We have to do some arg list munging here (adding an extra arg)
+        //
+
+        //
+        // Set lpExtensionID, the following Size arg,
+        // lpExtensionName, and the following MinSize
+        // Type's and Value appropriately since they're
+        // valid args in this case
+        //
+
+        funcArgs.ArgTypes[2] = lpSet_SizeToFollow;
+        funcArgs.Args[2]     = (DWORD) lpExtensionID;
+        funcArgs.ArgTypes[3] = Size;
+        funcArgs.Args[3]     = sizeof (LINEEXTENSIONID);
+        funcArgs.ArgTypes[5] = lpGet_Struct;
+        funcArgs.Args[5]     = (DWORD) lpExtensionName;
+    }
+
+    return (DOFUNC (&funcArgs, "lineGetAppPriority"));
+}
+
+
+LONG
+WINAPI
+lineGetAppPriorityA(
+    LPCSTR  lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPVARSTRING lpExtensionName,
+    LPDWORD lpdwPriority
+    )
+{
+    LONG lResult;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 7, lGetAppPriority),
+
+        {
+            0,                       //  (DWORD) lpszAppName,
+            dwMediaMode,
+            0,
+            0,
+            dwRequestMode,
+            0,
+            (DWORD) lpdwPriority
+        },
+
+        {
+            lpszW,      // app name
+            Dword,      // media mode
+            Dword,      // ext id (offset)
+            Dword,      // ext id (size)
+            Dword,      // request mode
+            Dword,      // ext name total size
+            lpDword     // lp pri
+        }
+    };
+
+
+    if (dwMediaMode & 0xff000000)
+    {
+        //
+        // We have to do some arg list munging here (adding an extra arg)
+        //
+
+        //
+        // Set lpExtensionID, the following Size arg,
+        // lpExtensionName, and the following MinSize
+        // Type's and Value appropriately since they're
+        // valid args in this case
+        //
+
+        funcArgs.ArgTypes[2] = lpSet_SizeToFollow;
+        funcArgs.Args[2]     = (DWORD) lpExtensionID;
+        funcArgs.ArgTypes[3] = Size;
+        funcArgs.Args[3]     = sizeof (LINEEXTENSIONID);
+        funcArgs.ArgTypes[5] = lpGet_Struct;
+        funcArgs.Args[5]     = (DWORD) lpExtensionName;
+    }
+
+    funcArgs.Args[0] = (DWORD) NotSoWideStringToWideString(
+        lpszAppName,
+        (DWORD) -1
+        );
+
+    lResult = (DOFUNC (&funcArgs, "lineGetAppPriority"));
+
+    if (funcArgs.Args[0])
+    {
+        ClientFree ((LPVOID) funcArgs.Args[0]);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAppPriority(
+    LPCSTR  lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPVARSTRING lpExtensionName,
+    LPDWORD lpdwPriority
+    )
+{
+    return lineGetAppPriorityA(
+              lpszAppName,
+              dwMediaMode,
+              lpExtensionID,
+              dwRequestMode,
+              lpExtensionName,
+              lpdwPriority
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetCallInfoW(
+    HCALL   hCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetCallInfo),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpCallInfo
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetCallInfo"));
+}
+
+
+LONG
+WINAPI
+lineGetCallInfoA(
+    HCALL   hCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    LONG lResult;
+
+    lResult = lineGetCallInfoW(
+                    hCall,
+                    lpCallInfo
+                    );
+
+    if ( 0 == lResult )
+    {
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwCallerIDSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwCallerIDNameSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwCalledIDSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwCalledIDNameSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwConnectedIDSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwConnectedIDNameSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwRedirectionIDSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwRedirectionIDSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwRedirectingIDSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwRedirectingIDNameSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwAppNameSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwDisplayableAddressSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwCalledPartySize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwCommentSize)
+            );
+
+/*
+        //
+        // Note: per TNixon (3/21/96), none of the following are guaranteed
+        //       to be in ascii format, so we don't want to convert them
+        //
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwDisplaySize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwHighLevelCompSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwLowLevelCompSize)
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpCallInfo,
+            &(lpCallInfo->dwChargingInfoSize)
+            );
+*/
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetCallInfo(
+    HCALL   hCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    return lineGetCallInfoA(
+              hCall,
+              lpCallInfo
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetCallStatus(
+    HCALL   hCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetCallStatus),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpCallStatus
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetCallStatus"));
+}
+
+
+LONG
+WINAPI
+lineGetConfRelatedCalls(
+    HCALL   hCall,
+    LPLINECALLLIST  lpCallList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC| 2, lGetConfRelatedCalls),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpCallList
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetConfRelatedCalls"));
+}
+
+
+LONG
+WINAPI
+lineGetCountryW(
+    DWORD   dwCountryID,
+    DWORD   dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lGetCountry),
+
+        {
+            dwCountryID,
+            dwAPIVersion,
+            0,
+            (DWORD) lpLineCountryList
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    if (
+          ( TAPI_CURRENT_VERSION != dwAPIVersion )
+        &&
+          ( 0x00010004 != dwAPIVersion )
+        &&
+          ( 0x00010003 != dwAPIVersion )
+       )
+    {
+       DBGOUT((1, "lineGetCountryW - bad API version 0x%08lx", dwAPIVersion));
+       return LINEERR_INCOMPATIBLEAPIVERSION;
+    }
+
+    return (DOFUNC (&funcArgs, "lineGetCountry"));
+}
+
+
+LONG
+WINAPI
+lineGetCountryA(
+    DWORD   dwCountryID,
+    DWORD   dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+    LONG    lResult;
+    DWORD   n;
+
+
+    lResult = lineGetCountryW (dwCountryID, dwAPIVersion, lpLineCountryList);
+
+    if (lResult == 0)
+    {
+        //
+        // Go through the list of countries and change from Unicode to ANSI
+        //
+
+        LPLINECOUNTRYENTRY lpce;
+
+
+        lpce = (LPLINECOUNTRYENTRY) (((LPBYTE) lpLineCountryList) +
+            lpLineCountryList->dwCountryListOffset);
+
+        for (n = 0; n < lpLineCountryList->dwNumCountries; n++, lpce++)
+        {
+            WideStringToNotSoWideString(
+                (LPBYTE)lpLineCountryList,
+                &lpce->dwCountryNameSize
+                );
+
+            WideStringToNotSoWideString(
+                (LPBYTE)lpLineCountryList,
+                &lpce->dwSameAreaRuleSize
+                );
+
+            WideStringToNotSoWideString(
+                (LPBYTE)lpLineCountryList,
+                &lpce->dwLongDistanceRuleSize
+                );
+
+            WideStringToNotSoWideString(
+                (LPBYTE)lpLineCountryList,
+                &lpce->dwInternationalRuleSize
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetCountry(
+    DWORD   dwCountryID,
+    DWORD   dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+    return lineGetCountryA(
+              dwCountryID,
+              dwAPIVersion,
+              lpLineCountryList
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetDevCapsW(
+    HLINEAPP        hLineApp,
+    DWORD           dwDeviceID,
+    DWORD           dwAPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGetDevCaps),
+
+        {
+            (DWORD) hLineApp,
+            dwDeviceID,
+            dwAPIVersion,
+            dwExtVersion,
+            (DWORD) lpLineDevCaps
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetDevCaps"));
+}
+
+
+LONG
+WINAPI
+lineGetDevCapsA(
+    HLINEAPP        hLineApp,
+    DWORD           dwDeviceID,
+    DWORD           dwAPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    LONG lResult;
+
+    lResult = lineGetDevCapsW(
+                    hLineApp,
+                    dwDeviceID,
+                    dwAPIVersion,
+                    dwExtVersion,
+                    lpLineDevCaps
+                    );
+
+
+    if (lResult == 0)
+    {
+        WideStringToNotSoWideString(
+            (LPBYTE)lpLineDevCaps,
+            &lpLineDevCaps->dwProviderInfoSize
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpLineDevCaps,
+            &lpLineDevCaps->dwSwitchInfoSize
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpLineDevCaps,
+            &lpLineDevCaps->dwLineNameSize
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE)lpLineDevCaps,
+            &lpLineDevCaps->dwTerminalTextSize
+            );
+
+        if (lpLineDevCaps->dwTerminalTextEntrySize)
+        {
+            lpLineDevCaps->dwTerminalTextEntrySize /= sizeof(WCHAR); // BUGBUG???
+        }
+
+        if (dwAPIVersion >= 0x00020000)
+        {
+            WideStringToNotSoWideString(
+                (LPBYTE) lpLineDevCaps,
+                &lpLineDevCaps->dwDeviceClassesSize
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetDevCaps(
+    HLINEAPP        hLineApp,
+    DWORD           dwDeviceID,
+    DWORD           dwAPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    return lineGetDevCapsA(
+                 hLineApp,
+                 dwDeviceID,
+                 dwAPIVersion,
+                 dwExtVersion,
+                 lpLineDevCaps
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetDevConfigW(
+    DWORD   dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCWSTR  lpszDeviceClass
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetDevConfig),
+
+        {
+            dwDeviceID,
+            (DWORD) lpDeviceConfig,
+            (DWORD) lpszDeviceClass
+        },
+
+        {
+            Dword,
+            lpGet_Struct,
+            lpszW
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetDevConfig"));
+}
+
+
+LONG
+WINAPI
+lineGetDevConfigA(
+    DWORD   dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG lResult;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetDevConfig),
+
+        {
+            dwDeviceID,
+            (DWORD) lpDeviceConfig,
+            0                        //  (DWORD) lpszDeviceClass
+        },
+
+        {
+            Dword,
+            lpGet_Struct,
+            lpszW
+        }
+    };
+
+
+    funcArgs.Args[2] = (DWORD) NotSoWideStringToWideString(
+        lpszDeviceClass,
+        (DWORD) -1
+        );
+
+    lResult = (DOFUNC (&funcArgs, "lineGetDevConfig"));
+
+    if ((LPVOID)funcArgs.Args[2])
+    {
+        ClientFree ((LPVOID)funcArgs.Args[2]);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetDevConfig(
+    DWORD   dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    return lineGetDevConfigA(
+              dwDeviceID,
+              lpDeviceConfig,
+              lpszDeviceClass
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetIconW(
+    DWORD   dwDeviceID,
+    LPCWSTR lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    HICON   hIcon;
+    LONG    lResult;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetIcon),
+
+        {
+            dwDeviceID,
+            (DWORD) lpszDeviceClass,
+            (DWORD) &hIcon
+        },
+
+        {
+            Dword,
+            lpszW,
+            lpDword
+        }
+    };
+
+
+    if (IsBadDwordPtr ((LPDWORD) lphIcon))
+    {
+        DBGOUT((1, "lphIcon is an invalid pointer!"));
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (lpszDeviceClass == (LPCWSTR) NULL)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+    }
+
+    if ((lResult = DOFUNC (&funcArgs, "lineGetIcon")) == 0)
+    {
+        if (gbNTVDMClient == FALSE)
+        {
+            *lphIcon = hIcon;
+        }
+        else
+        {
+// BUGBUG lineGetIcon: map 32-bit hIcon to 16-bit
+        }
+    }
+
+    return lResult;
+}
+
+
+
+LONG
+WINAPI
+lineGetIconA(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (lpszDeviceClass  &&  IsBadStringPtrA (lpszDeviceClass, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    szTempPtr = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+    
+    lResult = lineGetIconW (dwDeviceID, szTempPtr, lphIcon);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+
+LONG
+WINAPI
+lineGetIcon(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    return lineGetIconA(
+              dwDeviceID,
+              lpszDeviceClass,
+              lphIcon
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetIDW(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, lGetID),
+
+        {
+            (DWORD) hLine,
+            dwAddressID,
+            (DWORD) hCall,
+            dwSelect,
+            (DWORD) lpDeviceID,
+            (DWORD) lpszDeviceClass
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct,
+            lpszW
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetID"));
+}
+
+
+LONG
+WINAPI
+lineGetIDA(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    szTempPtr = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+
+    lResult = lineGetIDW(
+        hLine,
+        dwAddressID,
+        hCall,
+        dwSelect,
+        lpDeviceID,
+        szTempPtr
+        );
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetID(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    return lineGetIDA(
+              hLine,
+              dwAddressID,
+              hCall,
+              dwSelect,
+              lpDeviceID,
+              lpszDeviceClass
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetLineDevStatusW(
+    HLINE   hLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetLineDevStatus),
+
+        {
+            (DWORD) hLine,
+            (DWORD) lpLineDevStatus
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetLineDevStatus"));
+}
+
+
+LONG
+WINAPI
+lineGetLineDevStatusA(
+    HLINE   hLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    DWORD   dwAPIVersion;
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetLineDevStatus),
+
+        {
+            (DWORD) hLine,
+            (DWORD) lpLineDevStatus,
+            (DWORD) &dwAPIVersion
+        },
+
+        {
+            Dword,
+            lpGet_Struct,
+            lpDword
+        }
+    };
+    LONG lResult;
+
+
+    if ((lResult = DOFUNC (&funcArgs, "lineGetLineDevStatus")) == 0)
+    {
+        if (dwAPIVersion >= 0x00020000)
+        {
+            DWORD           i;
+            LPLINEAPPINFO   lplai;
+
+
+            lplai = (LPLINEAPPINFO) (((LPBYTE)lpLineDevStatus) +
+                lpLineDevStatus->dwAppInfoOffset);
+
+            for (i = 0; i < lpLineDevStatus->dwNumOpens; i++, lplai++)
+            {
+                WideStringToNotSoWideString(
+                    (LPBYTE) lpLineDevStatus,
+                    &lplai->dwMachineNameSize
+                    );
+
+                WideStringToNotSoWideString(
+                    (LPBYTE) lpLineDevStatus,
+                    &lplai->dwUserNameSize
+                    );
+
+                WideStringToNotSoWideString(
+                    (LPBYTE) lpLineDevStatus,
+                    &lplai->dwModuleFilenameSize
+                    );
+
+                WideStringToNotSoWideString(
+                    (LPBYTE) lpLineDevStatus,
+                    &lplai->dwFriendlyNameSize
+                    );
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetLineDevStatus(
+    HLINE   hLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    return lineGetLineDevStatusA(
+              hLine,
+              lpLineDevStatus
+    );
+}
+
+
+LONG
+WINAPI
+lineGetMessage(
+    HLINEAPP        hLineApp,
+    LPLINEMESSAGE   lpMessage,
+    DWORD           dwTimeout
+    )
+{
+    return (xxxGetMessage (TRUE, (PINIT_DATA) hLineApp, lpMessage, dwTimeout));
+}
+
+
+LONG
+WINAPI
+lineGetNewCalls(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    DWORD   dwSelect,
+    LPLINECALLLIST  lpCallList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lGetNewCalls),
+
+        {
+            (DWORD) hLine,
+            dwAddressID,
+            dwSelect,
+            (DWORD) lpCallList
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetNewCalls"));
+}
+
+
+LONG
+WINAPI
+lineGetNumRings(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPDWORD lpdwNumRings
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetNumRings),
+
+        {
+            (DWORD) hLine,
+            dwAddressID,
+            (DWORD) lpdwNumRings
+        },
+
+        {
+            Dword,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetNumRings"));
+}
+
+
+LONG
+WINAPI
+lineGetProviderListW(
+    DWORD   dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetProviderList),
+
+        {
+            dwAPIVersion,
+            (DWORD) lpProviderList
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineGetProviderList"));
+}
+
+
+LONG
+WINAPI
+lineGetProviderListA(
+    DWORD   dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+    LONG lResult;
+    lResult = lineGetProviderListW(
+                  dwAPIVersion,
+                  lpProviderList
+                  );
+    
+
+    if (lResult == 0)
+    {
+        DWORD               i;
+        LPLINEPROVIDERENTRY lplpe;
+
+
+        lplpe = (LPLINEPROVIDERENTRY) (((LPBYTE)lpProviderList) +
+            lpProviderList->dwProviderListOffset);
+
+        for (i = 0; i < lpProviderList->dwNumProviders; i++, lplpe++)
+        {
+            WideStringToNotSoWideString(
+                (LPBYTE)lpProviderList,
+                &(lplpe->dwProviderFilenameSize)
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetProviderList(
+    DWORD   dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+    return lineGetProviderListA(
+              dwAPIVersion,
+              lpProviderList
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetRequestW(
+    HLINEAPP    hLineApp,
+    DWORD       dwRequestMode,
+    LPVOID      lpRequestBuffer
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lGetRequest),
+
+        {
+            (DWORD) hLineApp,
+            dwRequestMode,
+            (DWORD) lpRequestBuffer,
+            0
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (dwRequestMode == LINEREQUESTMODE_MAKECALL)
+    {
+        //
+        // Set the size param appropriately
+        //
+
+        funcArgs.Args[3] = sizeof(LINEREQMAKECALLW);
+    }
+    else if (dwRequestMode == LINEREQUESTMODE_MEDIACALL)
+    {
+        //
+        // Set the size param appropriately
+        //
+
+        funcArgs.Args[3] = sizeof(LINEREQMEDIACALLW);
+    }
+
+    return (DOFUNC (&funcArgs, "lineGetRequest"));
+}
+
+
+LONG
+WINAPI
+lineGetRequestA(
+    HLINEAPP    hLineApp,
+    DWORD       dwRequestMode,
+    LPVOID      lpRequestBuffer
+    )
+{
+    LONG lResult;
+    LPVOID szTempPtr;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lGetRequest),
+
+        {
+            (DWORD) hLineApp,
+            dwRequestMode,
+            0,                //  (DWORD) lpRequestBuffer,
+            0
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (IsBadWritePtr(
+            lpRequestBuffer,
+            (dwRequestMode == LINEREQUESTMODE_MAKECALL ?
+                sizeof (LINEREQMAKECALL) : sizeof (LINEREQMEDIACALL))
+            ))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (dwRequestMode == LINEREQUESTMODE_MAKECALL)
+    {
+        //
+        // Set the size param appropriately
+        //
+
+        funcArgs.Args[3] = sizeof(LINEREQMAKECALLW);
+
+        szTempPtr = ClientAlloc( sizeof(LINEREQMAKECALLW) );
+    }
+    else if (dwRequestMode == LINEREQUESTMODE_MEDIACALL)
+    {
+        //
+        // Set the size param appropriately
+        //
+
+        funcArgs.Args[3] = sizeof(LINEREQMEDIACALLW);
+
+        szTempPtr = ClientAlloc( sizeof(LINEREQMEDIACALLW) );
+    }
+
+    funcArgs.Args[2] = (DWORD)szTempPtr;
+
+
+    lResult = (DOFUNC (&funcArgs, "lineGetRequest"));
+
+
+    if ( 0 == lResult )
+    {
+        if (dwRequestMode == LINEREQUESTMODE_MAKECALL)
+        {
+            LPLINEREQMAKECALLW lplrmc = szTempPtr;
+    
+            WideCharToMultiByte(
+                GetACP(),
+                0,
+                lplrmc->szDestAddress,
+                -1,
+                ((LPLINEREQMAKECALL)lpRequestBuffer)->szDestAddress,
+                TAPIMAXDESTADDRESSSIZE,
+                NULL,
+                NULL
+                );
+
+            WideCharToMultiByte(
+                GetACP(),
+                0,
+                lplrmc->szAppName,
+                -1,
+                ((LPLINEREQMAKECALL)lpRequestBuffer)->szAppName,
+                TAPIMAXAPPNAMESIZE,
+                NULL,
+                NULL
+                );
+
+            WideCharToMultiByte(
+                GetACP(),
+                0,
+                lplrmc->szCalledParty,
+                -1,
+                ((LPLINEREQMAKECALL)lpRequestBuffer)->szCalledParty,
+                TAPIMAXCALLEDPARTYSIZE,
+                NULL,
+                NULL
+                );
+
+            WideCharToMultiByte(
+                GetACP(),
+                0,
+                lplrmc->szComment,
+                -1,
+                ((LPLINEREQMAKECALL)lpRequestBuffer)->szComment,
+                TAPIMAXCOMMENTSIZE,
+                NULL,
+                NULL
+                );
+
+        }
+        else
+        {
+
+        // We don't currently support this...
+
+//typedef struct linereqmediacallW_tag
+//{
+//    HWND        hWnd;
+//    WPARAM      wRequestID;
+//    WCHAR       szDeviceClass[TAPIMAXDEVICECLASSSIZE];
+//    unsigned char   ucDeviceID[TAPIMAXDEVICEIDSIZE];
+//    DWORD       dwSize;
+//    DWORD       dwSecure;
+//    WCHAR       szDestAddress[TAPIMAXDESTADDRESSSIZE];
+//    WCHAR       szAppName[TAPIMAXAPPNAMESIZE];
+//    WCHAR       szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+//    WCHAR       szComment[TAPIMAXCOMMENTSIZE];
+//}
+
+        }
+    }
+
+
+    ClientFree( (LPVOID)funcArgs.Args[2] );
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetRequest(
+    HLINEAPP    hLineApp,
+    DWORD       dwRequestMode,
+    LPVOID      lpRequestBuffer
+    )
+{
+    return lineGetRequestA(
+                 hLineApp,
+                 dwRequestMode,
+                 lpRequestBuffer
+    );
+}    
+
+
+LONG
+WINAPI
+lineGetStatusMessages(
+    HLINE hLine,
+    LPDWORD lpdwLineStates,
+    LPDWORD lpdwAddressStates
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetStatusMessages),
+
+        {
+            (DWORD) hLine,
+            (DWORD) lpdwLineStates,
+            (DWORD) lpdwAddressStates
+        },
+
+        {
+            Dword,
+            lpDword,
+            lpDword
+        }
+    };
+
+
+    if (lpdwLineStates == lpdwAddressStates)
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    return (DOFUNC (&funcArgs, "lineGetStatusMessages"));
+}
+
+
+
+LONG
+WINAPI
+lineHandoffW(
+    HCALL   hCall,
+    LPCWSTR lpszFileName,
+    DWORD   dwMediaMode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lHandoff),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpszFileName,
+            dwMediaMode
+        },
+
+        {
+            Dword,
+            lpszW,
+            Dword
+        }
+    };
+
+
+    if (lpszFileName == (LPCWSTR) NULL)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineHandoff"));
+}
+
+
+LONG
+WINAPI
+lineHandoffA(
+    HCALL   hCall,
+    LPCSTR  lpszFileName,
+    DWORD   dwMediaMode
+    )
+{
+    LONG    lResult;
+    LPWSTR  pTempPtr;
+
+
+    if (lpszFileName)
+    {
+        if (IsBadStringPtrA (lpszFileName, (DWORD) -1))
+        {
+            return LINEERR_INVALPOINTER;
+        }
+        else if (!(pTempPtr = NotSoWideStringToWideString(
+                        lpszFileName,
+                        (DWORD) -1
+                        )))
+        {
+            return LINEERR_NOMEM;
+        }
+    }
+    else
+    {
+        pTempPtr = NULL;
+    }
+
+    lResult = lineHandoffW (hCall, pTempPtr, dwMediaMode);
+
+    if (pTempPtr)
+    {
+        ClientFree (pTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineHandoff(
+    HCALL   hCall,
+    LPCSTR  lpszFileName,
+    DWORD   dwMediaMode
+    )
+{
+    return lineHandoffA(
+              hCall,
+              lpszFileName,
+              dwMediaMode
+    );
+}    
+
+
+LONG
+WINAPI
+lineHold(
+    HCALL   hCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 1, lHold),
+
+        {
+            (DWORD) hCall
+        },
+
+        {
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineHold"));
+}
+
+
+PWSTR
+PASCAL
+MultiToWide(
+    LPCSTR  lpStr
+    )
+{
+    DWORD dwSize;
+    PWSTR szTempPtr;
+
+
+    dwSize = MultiByteToWideChar(
+        GetACP(),
+        MB_PRECOMPOSED,
+        lpStr,
+        -1,
+        NULL,
+        0
+        );
+
+    if ((szTempPtr = ClientAlloc ((dwSize + 1) * sizeof (WCHAR))))
+    {
+        MultiByteToWideChar(
+            GetACP(),
+            MB_PRECOMPOSED,
+            lpStr,
+            -1,
+            szTempPtr,
+            dwSize + 1
+            );
+    }
+
+    return szTempPtr;
+}
+
+
+// Don't need this 'cause 2.0 apps must use lineInitializeEx()
+//
+//LONG
+//WINAPI
+//lineInitializeW(
+//    LPHLINEAPP      lphLineApp,
+//    HINSTANCE       hInstance,
+//    LINECALLBACK    lpfnCallback,
+//    LPCWSTR         lpszAppName,
+//    LPDWORD         lpdwNumDevs
+//    )
+//{
+//    return (xxxInitialize(
+//        TRUE,
+//        (LPVOID) lphLineApp,
+//        hInstance,
+//        lpfnCallback,
+//        lpszAppName,
+//        lpdwNumDevs,
+//        NULL,
+//        NULL
+//#if DBG
+//        ,"lineInitializeW"
+//#endif
+//        ));
+//}
+
+
+LONG
+WINAPI
+lineInitialize(
+    LPHLINEAPP      lphLineApp,
+    HINSTANCE       hInstance,
+    LINECALLBACK    lpfnCallback,
+    LPCSTR          lpszAppName,
+    LPDWORD         lpdwNumDevs
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (lpszAppName )
+    {
+        if ( IsBadStringPtrA (lpszAppName, (DWORD) -1))
+        {
+           DBGOUT((1, "lineInitialize: Bad lpszAddName pointer"));
+           return LINEERR_INVALPOINTER;
+        }
+
+        szTempPtr = NotSoWideStringToWideString (lpszAppName, (DWORD) -1);
+    }
+    else
+    {
+        szTempPtr = NULL;
+    }
+    
+    
+    lResult = (xxxInitialize(
+        TRUE,
+        (LPVOID) lphLineApp,
+        hInstance,
+        lpfnCallback,
+        szTempPtr,
+        lpdwNumDevs,
+        NULL,
+        NULL
+#if DBG
+        ,"lineInitialize"
+#endif
+        ));
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineInitializeExW(
+    LPHLINEAPP                  lphLineApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                lpfnCallback,
+    LPCWSTR                     lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams
+    )
+{
+    if (IsBadDwordPtr (lpdwAPIVersion))
+    {
+        DBGOUT((
+            1,
+            "lineInitializeExW: bad lpdwAPIVersion pointer (x%x)",
+            lpdwAPIVersion
+            ));
+
+        return LINEERR_INVALPOINTER;
+    }
+
+    return (xxxInitialize(
+        TRUE,
+        (LPVOID) lphLineApp,
+        hInstance,
+        lpfnCallback,
+        lpszFriendlyAppName,
+        lpdwNumDevs,
+        lpdwAPIVersion,
+        (LPVOID) lpLineInitializeExParams
+#if DBG
+        ,"lineInitializeExW"
+#endif
+        ));
+}
+
+
+LONG
+WINAPI
+lineInitializeExA(
+    LPHLINEAPP                  lphLineApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                lpfnCallback,
+    LPCSTR                      lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams
+    )
+{
+    LONG    lResult;
+    WCHAR  *pszFriendlyAppNameW;
+
+
+    if (lpszFriendlyAppName)
+    {
+        if (IsBadStringPtrA (lpszFriendlyAppName, (DWORD) -1))
+        {
+            DBGOUT((
+                1,
+                "lineInitializeEx: bad lpszFriendlyAppName (x%x)",
+                lpszFriendlyAppName
+                ));
+
+            return LINEERR_INVALPOINTER;
+        }
+
+        if (!(pszFriendlyAppNameW = MultiToWide (lpszFriendlyAppName)))
+        {
+            return LINEERR_INVALPOINTER;
+        }
+    }
+    else
+    {
+        pszFriendlyAppNameW = NULL;
+    }
+
+    lResult = lineInitializeExW(
+        lphLineApp,
+        hInstance,
+        lpfnCallback,
+        pszFriendlyAppNameW,
+        lpdwNumDevs,
+        lpdwAPIVersion,
+        lpLineInitializeExParams
+        );
+
+    if (pszFriendlyAppNameW)
+    {
+        ClientFree (pszFriendlyAppNameW);
+    }
+
+    return lResult;
+}
+
+
+void
+PASCAL
+lineMakeCallPostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    DBGOUT((3, "lineMakeCallPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        HCALL   hCall   = (HCALL) pMsg->dwParam3;
+        LPHCALL lphCall = (LPHCALL) pMsg->dwParam4;
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPHCALL lphCallVDM = (LPHCALL) gpfnWOWGetVDMPointer (
+                    (DWORD) lphCall,
+                    sizeof(HCALL),
+                    TRUE // fProtectedMode
+                    );
+
+
+                if (lphCallVDM)
+                {
+                    *lphCallVDM = hCall;
+                }
+                else
+                {
+                    pMsg->dwParam2 = LINEERR_INVALPOINTER;
+                }
+            }
+            else
+            {
+                *lphCall = hCall;
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+
+            // BUGBUG drop/dealloc
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineMakeCallW(
+    HLINE   hLine,
+    LPHCALL lphCall,
+    LPCWSTR lpszDestAddress,
+    DWORD   dwCountryCode,
+    LPLINECALLPARAMS const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lMakeCall),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hLine,
+            (DWORD) lphCall,
+            (DWORD) lpszDestAddress,
+            (DWORD) dwCountryCode,
+            (DWORD) lpCallParams,
+            (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpszW,
+            Dword,
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpszDestAddress)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[5] = Dword;
+        funcArgs.Args[5]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineMakeCall"));
+}
+
+
+LONG
+WINAPI
+lineMakeCallA(
+    HLINE   hLine,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode,
+    LPLINECALLPARAMS const lpCallParams
+    )
+{
+    LONG    lResult;
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lMakeCall),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hLine,
+            (DWORD) lphCall,
+            (DWORD) 0,
+            (DWORD) dwCountryCode,
+            (DWORD) lpCallParams,
+            (DWORD) GetACP()        // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpszW,
+            Dword,
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpszDestAddress)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+    else if (IsBadStringPtrA (lpszDestAddress, (DWORD) -1))
+    {
+       DBGOUT((1, "lineMakeCall: Bad lpszDestAddress pointer"));
+       return LINEERR_INVALPOINTER;
+    }
+    else  if (!(funcArgs.Args[3] = (DWORD) NotSoWideStringToWideString(
+                    lpszDestAddress,
+                    (DWORD) -1
+                    )))
+    {
+       return LINEERR_OPERATIONFAILED; // really either NOMEM. INVALPOINTER
+    }
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[5] = Dword;
+        funcArgs.Args[5]     = TAPI_NO_DATA;
+    }
+
+    lResult = DOFUNC (&funcArgs, "lineMakeCall");
+
+    if (funcArgs.Args[3] != TAPI_NO_DATA)
+    {
+       ClientFree ((LPVOID) funcArgs.Args[3]);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineMakeCall(
+    HLINE   hLine,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode,
+    LPLINECALLPARAMS const lpCallParams
+    )
+{
+    return lineMakeCallA(
+              hLine,
+              lphCall,
+              lpszDestAddress,
+              dwCountryCode,
+              lpCallParams
+    );
+}    
+
+
+LONG
+WINAPI
+lineMonitorDigits(
+    HCALL   hCall,
+    DWORD   dwDigitModes
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lMonitorDigits),
+
+        {
+            (DWORD) hCall,
+            dwDigitModes
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineMonitorDigits"));
+}
+
+
+LONG
+WINAPI
+lineMonitorMedia(
+    HCALL   hCall,
+    DWORD   dwMediaModes
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lMonitorMedia),
+
+        {
+            (DWORD) hCall,
+            dwMediaModes
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineMonitorMedia"));
+}
+
+
+LONG
+WINAPI
+lineMonitorTones(
+    HCALL   hCall,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD   dwNumEntries
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lMonitorTones),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpToneList,
+            dwNumEntries * sizeof(LINEMONITORTONE),
+            0     // dwToneListID, remotesp only
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size,
+            Dword
+        }
+    };
+
+
+    if (!lpToneList)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineMonitorTones"));
+}
+
+
+LONG
+WINAPI
+lineNegotiateAPIVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 7, lNegotiateAPIVersion),
+
+        {
+            (DWORD) hLineApp,
+            dwDeviceID,
+            dwAPILowVersion,
+            dwAPIHighVersion,
+            (DWORD) lpdwAPIVersion,
+            (DWORD) lpExtensionID,
+            (DWORD) sizeof(LINEEXTENSIONID)
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            lpDword,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if ((LPVOID) lpdwAPIVersion == (LPVOID) lpExtensionID)
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    return (DOFUNC (&funcArgs, "lineNegotiateAPIVersion"));
+}
+
+
+LONG
+WINAPI
+lineNegotiateExtVersion(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtLowVersion,
+    DWORD       dwExtHighVersion,
+    LPDWORD     lpdwExtVersion
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, lNegotiateExtVersion),
+
+        {
+            (DWORD) hLineApp,
+            dwDeviceID,
+            dwAPIVersion,
+            dwExtLowVersion,
+            dwExtHighVersion,
+            (DWORD) lpdwExtVersion
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineNegotiateExtVersion"));
+}
+
+
+LONG
+WINAPI
+lineOpenW(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    LPHLINE                 lphLine,
+    DWORD                   dwAPIVersion,
+    DWORD                   dwExtVersion,
+    DWORD                   dwCallbackInstance,
+    DWORD                   dwPrivileges,
+    DWORD                   dwMediaModes,
+    LPLINECALLPARAMS const  lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 11, lOpen),
+
+        {
+            (DWORD) hLineApp,
+            (DWORD) dwDeviceID,
+            (DWORD) lphLine,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) dwCallbackInstance,
+            (DWORD) dwPrivileges,
+            (DWORD) dwMediaModes,
+            (DWORD) lpCallParams,
+            (DWORD) 0xffffffff,     // dwAsciiCallParamsCodePage
+            0                       // LINEOPEN_PARAMS.hRemoteLine
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            lpDword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_Struct,
+            Dword,
+            Dword
+        }
+    };
+
+
+    if (dwDeviceID != LINEMAPPER &&
+        !(dwPrivileges & (LINEOPENOPTION_PROXY|LINEOPENOPTION_SINGLEADDRESS)))
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[8] = Dword;
+        funcArgs.Args[8]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineOpen"));
+}
+
+
+LONG
+WINAPI
+lineOpenA(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    LPHLINE                 lphLine,
+    DWORD                   dwAPIVersion,
+    DWORD                   dwExtVersion,
+    DWORD                   dwCallbackInstance,
+    DWORD                   dwPrivileges,
+    DWORD                   dwMediaModes,
+    LPLINECALLPARAMS const  lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 11, lOpen),
+
+        {
+            (DWORD) hLineApp,
+            (DWORD) dwDeviceID,
+            (DWORD) lphLine,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) dwCallbackInstance,
+            (DWORD) dwPrivileges,
+            (DWORD) dwMediaModes,
+            (DWORD) lpCallParams,
+            (DWORD) GetACP(),       // dwAsciiCallParamsCodePage
+            (DWORD) 0               // LINEOPEN_PARAMS.hRemoteLine
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            lpDword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_Struct,
+            Dword,
+            Dword
+        }
+    };
+
+
+    if (dwDeviceID != LINEMAPPER &&
+        !(dwPrivileges & (LINEOPENOPTION_PROXY|LINEOPENOPTION_SINGLEADDRESS)))
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[8] = Dword;
+        funcArgs.Args[8]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineOpen"));
+}
+
+
+LONG
+WINAPI
+lineOpen(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    LPHLINE                 lphLine,
+    DWORD                   dwAPIVersion,
+    DWORD                   dwExtVersion,
+    DWORD                   dwCallbackInstance,
+    DWORD                   dwPrivileges,
+    DWORD                   dwMediaModes,
+    LPLINECALLPARAMS const  lpCallParams
+    )
+{
+    return lineOpenA(
+                hLineApp,
+                dwDeviceID,
+                lphLine,
+                dwAPIVersion,
+                dwExtVersion,
+                dwCallbackInstance,
+                dwPrivileges,
+                dwMediaModes,
+                lpCallParams
+    );
+}    
+
+
+void
+PASCAL
+lineParkAPostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    DBGOUT((3, "lineParkAPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD       dwSize = pMsg->dwParam4;
+        LPVARSTRING pNonDirAddress = (LPVARSTRING) pMsg->dwParam3;
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPVARSTRING pNonDirAddressVDM = (LPVARSTRING)
+                    gpfnWOWGetVDMPointer(
+                        (DWORD) pNonDirAddress,
+                        dwSize,
+                        TRUE // fProtectedMode
+                        );
+
+
+                if (pNonDirAddressVDM)
+                {
+                    CopyMemory(
+                        pNonDirAddressVDM,
+                        (LPBYTE) (pMsg + 1),
+                        dwSize
+                        );
+
+                    if (pNonDirAddressVDM->dwUsedSize >= sizeof (VARSTRING)  &&
+                        pNonDirAddressVDM->dwStringSize != 0)
+                    {
+                        char     *p;
+                        DWORD     dwStringSize =
+                                      pNonDirAddressVDM->dwStringSize /
+                                          sizeof (WCHAR);
+
+
+                        if ((p = ClientAlloc(pNonDirAddressVDM->dwStringSize)))
+                        {
+                            pNonDirAddressVDM->dwStringFormat =
+                                STRINGFORMAT_ASCII;
+                            pNonDirAddressVDM->dwStringSize =
+                                dwStringSize;
+
+                            WideCharToMultiByte(
+                                GetACP(),
+                                0,
+                                (LPCWSTR) (((LPBYTE) pNonDirAddressVDM) +
+                                    pNonDirAddressVDM->dwStringOffset),
+                                dwStringSize,
+                                (LPSTR) p,
+                                dwStringSize,
+                                NULL,
+                                NULL
+                                );
+
+                            CopyMemory(
+                                (((LPBYTE) pNonDirAddressVDM) +
+                                    pNonDirAddressVDM->dwStringOffset),
+                                p,
+                                dwStringSize
+                                );
+
+                            ClientFree (p);
+                        }
+                    }
+                }
+                else
+                {
+                    pMsg->dwParam2 = LINEERR_INVALPOINTER;
+                }
+            }
+            else
+            {
+                CopyMemory (pNonDirAddress, (LPBYTE) (pMsg + 1), dwSize);
+
+                if (pNonDirAddress->dwUsedSize >= sizeof (VARSTRING)  &&
+                    pNonDirAddress->dwStringSize != 0)
+                {
+                      char     *p;
+                      DWORD     dwStringSize = pNonDirAddress->dwStringSize /
+                                    sizeof (WCHAR);
+
+
+                      if ((p = ClientAlloc (pNonDirAddress->dwStringSize)))
+                      {
+                          pNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+                          pNonDirAddress->dwStringSize = dwStringSize;
+
+                          WideCharToMultiByte(
+                              GetACP(),
+                              0,
+                              (LPCWSTR) (((LPBYTE) pNonDirAddress) +
+                                  pNonDirAddress->dwStringOffset),
+                              dwStringSize,
+                              (LPSTR) p,
+                              dwStringSize,
+                              NULL,
+                              NULL
+                              );
+
+                          CopyMemory(
+                              (((LPBYTE) pNonDirAddress) +
+                                  pNonDirAddress->dwStringOffset),
+                              p,
+                              dwStringSize
+                              );
+
+                          ClientFree (p);
+                      }
+                }
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineParkW(
+    HCALL   hCall,
+    DWORD   dwParkMode,
+    LPCWSTR lpszDirAddress,
+    LPVARSTRING lpNonDirAddress
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+            MAKELONG (LINE_FUNC | ASYNC | 6, lPark),
+
+            {
+            (DWORD) 0,               // post process proc
+            (DWORD) hCall,
+            (DWORD) dwParkMode,
+            (DWORD) TAPI_NO_DATA, //lpszDirAddress,
+            (DWORD) lpNonDirAddress, // pass ptr as Dword for post processing
+            (DWORD) TAPI_NO_DATA, //lpNonDirAddress  // pass ptr as lpGet_Xx for IsValPtr chk
+            },
+
+            {
+            Dword,
+            Dword,
+            Dword,
+            Dword, // lpszW,
+            Dword,
+            Dword, // lpGet_Struct
+            }
+    };
+
+
+    if (dwParkMode == LINEPARKMODE_DIRECTED)
+    {
+            funcArgs.ArgTypes[3] = lpszW;
+            funcArgs.Args[3]     = (DWORD) lpszDirAddress;
+    }
+    else if (dwParkMode == LINEPARKMODE_NONDIRECTED)
+    {
+            //
+            // Set post process proc
+            //
+
+            funcArgs.Args[0] = (DWORD)
+                ((POSTPROCESSPROC) lineDevSpecificPostProcess);
+
+            funcArgs.ArgTypes[5] = lpGet_Struct;
+            funcArgs.Args[5]     = (DWORD) lpNonDirAddress;
+    }
+
+    return (DOFUNC (&funcArgs, "linePark"));
+}
+
+
+LONG
+WINAPI
+lineParkA(
+    HCALL   hCall,
+    DWORD   dwParkMode,
+    LPCSTR  lpszDirAddress,
+    LPVARSTRING lpNonDirAddress
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lPark),
+
+        {
+            (DWORD) 0,               // post process proc
+            (DWORD) hCall,
+            (DWORD) dwParkMode,
+            (DWORD) TAPI_NO_DATA,    // lpszDirAddress,
+            (DWORD) lpNonDirAddress, // pass ptr as Dword for post processing
+            (DWORD) TAPI_NO_DATA,    // lpNonDirAddress, pass ptr as lpGet_Xx
+                                     //   for IsValPtr chk
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword, // lpszW,
+            Dword,
+            Dword, // lpGet_Struct
+        }
+    };
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (dwParkMode == LINEPARKMODE_DIRECTED)
+    {
+        if (IsBadStringPtrA (lpszDirAddress, (DWORD) -1))
+        {
+            return LINEERR_INVALPOINTER;
+        }
+
+        szTempPtr = NotSoWideStringToWideString (lpszDirAddress, (DWORD) -1);
+        funcArgs.ArgTypes[3] = lpszW;
+        funcArgs.Args[3]     = (DWORD) szTempPtr;
+    }
+    else
+    {
+        if (dwParkMode == LINEPARKMODE_NONDIRECTED)
+        {
+            //
+            // Set post process proc
+            //
+
+            funcArgs.Args[0] = (DWORD)((POSTPROCESSPROC) lineParkAPostProcess);
+            funcArgs.ArgTypes[5] = lpGet_Struct;
+
+            if (gbNTVDMClient == FALSE)
+            {
+                funcArgs.Args[5] = (DWORD) lpNonDirAddress;
+            }
+            else
+            {
+                if (!gpfnWOWGetVDMPointer  ||
+
+                    !(funcArgs.Args[5] = gpfnWOWGetVDMPointer(
+                        (DWORD) lpNonDirAddress,
+                        sizeof (VARSTRING),     // what if it's > sizeof(VARS)?
+                        TRUE // fProtectedMode
+                        )))
+                {
+                    return LINEERR_OPERATIONFAILED;
+                }
+            }
+        }
+
+        szTempPtr = NULL;
+    }
+
+    lResult = (DOFUNC (&funcArgs, "linePark"));
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+linePark(
+    HCALL   hCall,
+    DWORD   dwParkMode,
+    LPCSTR  lpszDirAddress,
+    LPVARSTRING lpNonDirAddress
+    )
+{
+    return lineParkA(
+              hCall,
+              dwParkMode,
+              lpszDirAddress,
+              lpNonDirAddress
+          );
+}    
+
+
+LONG
+WINAPI
+linePickupW(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCWSTR lpszDestAddress,
+    LPCWSTR lpszGroupID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lPickup),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lphCall,
+            (DWORD) lpszDestAddress,
+            (DWORD) lpszGroupID
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpszW,
+            lpszW
+        }
+    };
+
+
+    if (!lpszDestAddress)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[4] = Dword;
+        funcArgs.Args[4]     = TAPI_NO_DATA;
+    }
+
+    if (!lpszGroupID)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[5] = Dword;
+        funcArgs.Args[5]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "linePickup"));
+}
+
+
+LONG
+WINAPI
+linePickupA(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszGroupID
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+    PWSTR   szTempPtr2;
+
+
+    if ((lpszDestAddress && IsBadStringPtrA (lpszDestAddress, (DWORD) -1)) ||
+        (lpszGroupID && IsBadStringPtrA (lpszGroupID, (DWORD) -1)))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    szTempPtr = NotSoWideStringToWideString (lpszDestAddress, (DWORD) -1);
+    szTempPtr2 = NotSoWideStringToWideString (lpszGroupID, (DWORD) -1);
+
+    lResult = linePickupW (hLine, dwAddressID, lphCall, szTempPtr, szTempPtr2);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    if (szTempPtr2)
+    {
+        ClientFree (szTempPtr2);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+linePickup(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszGroupID
+    )
+{
+    return linePickupA(
+              hLine,
+              dwAddressID,
+              lphCall,
+              lpszDestAddress,
+              lpszGroupID
+    );
+}    
+
+
+LONG
+WINAPI
+linePrepareAddToConferenceW(
+    HCALL   hConfCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lPrepareAddToConference),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hConfCall,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "linePrepareAddToConferenceW"));
+}
+
+
+LONG
+WINAPI
+linePrepareAddToConferenceA(
+    HCALL   hConfCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lPrepareAddToConference),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hConfCall,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (DWORD) GetACP()        // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "linePrepareAddToConference"));
+}
+
+
+LONG
+WINAPI
+linePrepareAddToConference(
+    HCALL   hConfCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    return linePrepareAddToConferenceA(
+              hConfCall,
+              lphConsultCall,
+              lpCallParams
+    );
+}    
+
+
+LONG
+WINAPI
+lineProxyMessage(
+    HLINE               hLine,
+    HCALL               hCall,
+    DWORD               dwMsg,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, lProxyMessage),
+
+        {
+            (DWORD) hLine,
+            (DWORD) hCall,
+            (DWORD) dwMsg,
+            (DWORD) dwParam1,
+            (DWORD) dwParam2,
+            (DWORD) dwParam3
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineProxyMessage"));
+}
+
+
+LONG
+WINAPI
+lineProxyResponse(
+    HLINE               hLine,
+    LPLINEPROXYREQUEST  lpProxyRequest,
+    DWORD               dwResult
+    )
+{
+    LONG    lResult = 0;
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lProxyResponse),
+
+        {
+            (DWORD) hLine,
+            (DWORD) 0,
+            (DWORD) lpProxyRequest,
+            (DWORD) dwResult
+        },
+
+        {
+            Dword,
+            Dword,
+            lpSet_Struct,
+            Dword
+        }
+    };
+    PPROXYREQUESTHEADER pProxyRequestHeader;
+
+
+    //
+    // The following is not the most thorough checking, but it's close
+    // enough that a client app won't get a totally unexpected value
+    // back
+    //
+
+    if (dwResult != 0  &&
+        (dwResult < LINEERR_ALLOCATED  ||
+            dwResult > LINEERR_DIALVOICEDETECT))
+    {
+        return LINEERR_INVALPARAM;
+    }
+
+
+    //
+    // Backtrack a little bit to get the pointer to what ought to be
+    // the proxy header, and then make sure we're dealing with a valid
+    // proxy request
+    //
+
+    pProxyRequestHeader = (PPROXYREQUESTHEADER)
+        (((LPBYTE) lpProxyRequest) - sizeof (PROXYREQUESTHEADER));
+
+    try
+    {
+        //
+        // Make sure we've a valid pProxyRequestHeader, then invalidate
+        // the key so subsequent attempts to call lineProxyResponse with
+        // the same lpProxyRequest fail
+        //
+
+        if ((DWORD) pProxyRequestHeader & 0x7 ||
+            pProxyRequestHeader->dwKey != TPROXYREQUESTHEADER_KEY)
+        {
+            lResult = LINEERR_INVALPOINTER;
+        }
+
+        pProxyRequestHeader->dwKey = 0xefefefef;
+
+        funcArgs.Args[1] = pProxyRequestHeader->dwInstance;
+
+
+        //
+        // See if this is one of the requests that don't require
+        // any data to get passed back & reset the appropriate
+        // params if so
+        //
+
+        switch (lpProxyRequest->dwRequestType)
+        {
+        case LINEPROXYREQUEST_SETAGENTGROUP:
+        case LINEPROXYREQUEST_SETAGENTSTATE:
+        case LINEPROXYREQUEST_SETAGENTACTIVITY:
+
+            funcArgs.Args[2]     = TAPI_NO_DATA;
+            funcArgs.ArgTypes[2] = Dword;
+
+            break;
+        }
+    }
+    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+
+
+    if (lResult == 0)
+    {
+        lResult = DOFUNC (&funcArgs, "lineProxyResponse");
+
+
+        //
+        // If we've gotten this far we want to free the buffer
+        // unconditionally
+        //
+
+        ClientFree (pProxyRequestHeader);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineRedirectW(
+    HCALL   hCall,
+    LPCWSTR lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lRedirect),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpszDestAddress,
+            dwCountryCode
+        },
+
+        {
+            Dword,
+            lpszW,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineRedirect"));
+}
+
+
+LONG
+WINAPI
+lineRedirectA(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (IsBadStringPtrA (lpszDestAddress, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    szTempPtr = NotSoWideStringToWideString (lpszDestAddress, (DWORD) -1);
+
+    lResult = lineRedirectW (hCall, szTempPtr, dwCountryCode);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineRedirect(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    return lineRedirectA(
+              hCall,
+              lpszDestAddress,
+              dwCountryCode
+    );
+}    
+
+
+LONG
+WINAPI
+lineRegisterRequestRecipient(
+    HLINEAPP    hLineApp,
+    DWORD       dwRegistrationInstance,
+    DWORD       dwRequestMode,
+    DWORD       bEnable
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lRegisterRequestRecipient),
+
+        {
+            (DWORD) hLineApp,
+            dwRegistrationInstance,
+            dwRequestMode,
+            bEnable
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineRegisterRequestRecipient"));
+}
+
+
+LONG
+WINAPI
+lineReleaseUserUserInfo(
+    HCALL   hCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 1, lReleaseUserUserInfo),
+
+        {
+            (DWORD) hCall
+        },
+
+        {
+            Dword,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineReleaseUserUserInfo"));
+}
+
+
+LONG
+WINAPI
+lineRemoveFromConference(
+    HCALL   hCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 1, lRemoveFromConference),
+
+        {
+            (DWORD) hCall
+        },
+
+        {
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineRemoveFromConference"));
+}
+
+
+LONG
+WINAPI
+lineRemoveProvider(
+    DWORD   dwPermanentProviderID,
+    HWND    hwndOwner
+    )
+{
+    return (lineXxxProvider(
+        gszTUISPI_providerRemove,   // func name
+        NULL,                       // lpszProviderFilename
+        hwndOwner,                  // hwndOwner
+        dwPermanentProviderID,      // dwPermProviderID
+        NULL                        // lpdwPermProviderID
+        ));
+}
+
+
+LONG
+WINAPI
+lineSecureCall(
+    HCALL hCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 1, lSecureCall),
+
+        {
+            (DWORD) hCall
+        },
+
+        {
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSecureCall"));
+}
+
+
+LONG
+WINAPI
+lineSendUserUserInfo(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSendUserUserInfo),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpsUserUserInfo,
+            dwSize
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (!lpsUserUserInfo)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSendUserUserInfo"));
+}
+
+
+LONG
+WINAPI
+lineSetAgentActivity(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    DWORD   dwActivityID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSetAgentActivity),
+
+        {
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) dwActivityID
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetAgentActivity"));
+}
+
+
+LONG
+WINAPI
+lineSetAgentGroup(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+    static LINEAGENTGROUPLIST EmptyGroupList =
+    {
+        sizeof (LINEAGENTGROUPLIST),    // dwTotalSize
+        sizeof (LINEAGENTGROUPLIST),    // dwNeededSize
+        sizeof (LINEAGENTGROUPLIST),    // dwUsedSize
+        0,                              // dwNumEntries
+        0,                              // dwListSize
+        0                               // dwListOffset
+    };
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSetAgentGroup),
+
+        {
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lpAgentGroupList
+        },
+
+        {
+            Dword,
+            Dword,
+            lpSet_Struct
+        }
+    };
+
+
+    if (!lpAgentGroupList)
+    {
+        funcArgs.Args[2] = (DWORD) &EmptyGroupList;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetAgentGroup"));
+}
+
+
+LONG
+WINAPI
+lineSetAgentState(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    DWORD   dwAgentState,
+    DWORD   dwNextAgentState
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lSetAgentState),
+
+        {
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) dwAgentState,
+            (DWORD) dwNextAgentState
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetAgentState"));
+}
+
+
+LONG
+WINAPI
+lineSetAppPriorityW(
+    LPCWSTR lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPCWSTR lpszExtensionName,
+    DWORD   dwPriority
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 7, lSetAppPriority),
+
+        {
+            (DWORD) lpszAppName,
+            dwMediaMode,
+            (DWORD) TAPI_NO_DATA,    // (DWORD) lpExtensionID,
+            0,                  // (DWORD) sizeof(LINEEXTENSIONID),
+            dwRequestMode,
+            (DWORD) TAPI_NO_DATA,    // (DWORD) lpszExtensionName,
+            dwPriority
+        },
+
+        {
+            lpszW,
+            Dword,
+            Dword,  // lpSet_SizeToFollow,
+            Dword,  // Size,
+            Dword,
+            Dword,  // lpsz,
+            Dword
+        }
+    };
+
+
+    if (dwMediaMode & 0xff000000)
+    {
+        //
+        // Reset lpExtensionID (& following Size) Arg & ArgType
+        // since it's a valid param in this case
+        //
+
+        funcArgs.ArgTypes[2] = lpSet_SizeToFollow;
+        funcArgs.Args[2]     = (DWORD) lpExtensionID;
+        funcArgs.ArgTypes[3] = Size;
+        funcArgs.Args[3]     = sizeof(LINEEXTENSIONID);
+
+        if (lpszExtensionName)
+        {
+            //
+            // Reset lpszExtensionName Arg & ArgType since it's
+            // a valid param in this case
+            //
+
+            funcArgs.ArgTypes[5] = lpszW;
+            funcArgs.Args[5]     = (DWORD) lpszExtensionName;
+        }
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetAppPriority"));
+}
+
+
+LONG
+WINAPI
+lineSetAppPriorityA(
+    LPCSTR  lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPCSTR  lpszExtensionName,
+    DWORD   dwPriority
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+    PWSTR   szTempPtr2;
+
+
+    if (IsBadStringPtrA (lpszAppName, (DWORD) -1) ||
+        ((dwMediaMode & 0xff000000) && lpszExtensionName &&
+            IsBadStringPtrA (lpszExtensionName, (DWORD) -1)))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    szTempPtr = NotSoWideStringToWideString (lpszAppName, (DWORD) -1);
+    szTempPtr2 = NotSoWideStringToWideString (lpszExtensionName, (DWORD) -1);
+
+    lResult = lineSetAppPriorityW(
+        szTempPtr,
+        dwMediaMode,
+        lpExtensionID,
+        dwRequestMode,
+        szTempPtr2,
+        dwPriority
+        );
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    if (szTempPtr2)
+    {
+        ClientFree (szTempPtr2);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetAppPriority(
+    LPCSTR  lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPCSTR  lpszExtensionName,
+    DWORD   dwPriority
+    )
+{
+    return lineSetAppPriorityA(
+              lpszAppName,
+              dwMediaMode,
+              lpExtensionID,
+              dwRequestMode,
+              lpszExtensionName,
+              dwPriority
+    );
+}    
+
+
+LONG
+WINAPI
+lineSetAppSpecific(
+    HCALL   hCall,
+    DWORD   dwAppSpecific
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lSetAppSpecific),
+
+        {
+            (DWORD) hCall,
+            dwAppSpecific
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetAppSpecific"));
+}
+
+
+LONG
+WINAPI
+lineSetCallData(
+    HCALL   hCall,
+    LPVOID  lpCallData,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSetCallData),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpCallData,
+            (DWORD) dwSize
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (dwSize == 0)
+    {
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[1] =
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetCallData"));
+}
+
+
+LONG
+WINAPI
+lineSetCallParams(
+    HCALL   hCall,
+    DWORD   dwBearerMode,
+    DWORD   dwMinRate,
+    DWORD   dwMaxRate,
+    LPLINEDIALPARAMS const lpDialParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lSetCallParams),
+
+        {
+            (DWORD) hCall,
+            dwBearerMode,
+            dwMinRate,
+            dwMaxRate,
+            (DWORD) lpDialParams,
+            sizeof(LINEDIALPARAMS)
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (!lpDialParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[4] = Dword;
+        funcArgs.Args[4]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[5] = Dword;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetCallParams"));
+}
+
+
+LONG
+WINAPI
+lineSetCallPrivilege(
+    HCALL   hCall,
+    DWORD   dwCallPrivilege
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lSetCallPrivilege),
+
+        {
+            (DWORD) hCall,
+            dwCallPrivilege
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetCallPrivilege"));
+}
+
+
+LONG
+WINAPI
+lineSetCallQualityOfService(
+    HCALL   hCall,
+    LPVOID  lpSendingFlowspec,
+    DWORD   dwSendingFlowspecSize,
+    LPVOID  lpReceivingFlowspec,
+    DWORD   dwReceivingFlowspecSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lSetCallQualityOfService),
+
+        {
+            (DWORD) hCall,
+            (DWORD) lpSendingFlowspec,
+            (DWORD) dwSendingFlowspecSize,
+            (DWORD) lpReceivingFlowspec,
+            (DWORD) dwReceivingFlowspecSize
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size,
+            lpSet_SizeToFollow,
+            Size,
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetCallQualityOfService"));
+}
+
+
+LONG
+WINAPI
+lineSetCallTreatment(
+    HCALL   hCall,
+    DWORD   dwTreatment
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lSetCallTreatment),
+
+        {
+            (DWORD) hCall,
+            (DWORD) dwTreatment
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetCallTreatment"));
+}
+
+
+LONG
+WINAPI
+lineSetDevConfigW(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lSetDevConfig),
+
+        {
+            dwDeviceID,
+            (DWORD) lpDeviceConfig,
+            dwSize,
+            (DWORD) lpszDeviceClass
+        },
+
+        {
+            Dword,
+            lpSet_SizeToFollow,
+            Size,
+            lpszW
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetDevConfig"));
+}
+
+
+LONG
+WINAPI
+lineSetDevConfigA(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (IsBadStringPtrA (lpszDeviceClass, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+    else if (!(szTempPtr = NotSoWideStringToWideString(
+                lpszDeviceClass,
+                (DWORD) -1
+                )))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    lResult = lineSetDevConfigW(
+        dwDeviceID,
+        lpDeviceConfig,
+        dwSize,
+        szTempPtr
+        );
+
+    ClientFree (szTempPtr);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetDevConfig(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    return lineSetDevConfigA(
+              dwDeviceID,
+              lpDeviceConfig,
+              dwSize,
+              lpszDeviceClass
+    );
+}    
+
+
+LONG
+WINAPI
+lineSetLineDevStatus(
+    HLINE   hLine,
+    DWORD   dwStatusToChange,
+    DWORD   fStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSetLineDevStatus),
+
+        {
+            (DWORD) hLine,
+            (DWORD) dwStatusToChange,
+            (DWORD) fStatus
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetLineDevStatus"));
+}
+
+
+LONG
+WINAPI
+lineSetMediaControl(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    LPLINEMEDIACONTROLDIGIT const lpDigitList,
+    DWORD   dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA const lpMediaList,
+    DWORD   dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE  const lpToneList,
+    DWORD   dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD   dwCallStateNumEntries
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 12, lSetMediaControl),
+
+        {
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) hCall,
+            (DWORD) dwSelect,
+            (DWORD) TAPI_NO_DATA,
+            (DWORD) dwDigitNumEntries * sizeof(LINEMEDIACONTROLDIGIT),
+            (DWORD) TAPI_NO_DATA,
+            (DWORD) dwMediaNumEntries * sizeof(LINEMEDIACONTROLMEDIA),
+            (DWORD) TAPI_NO_DATA,
+            (DWORD) dwToneNumEntries * sizeof(LINEMEDIACONTROLTONE),
+            (DWORD) TAPI_NO_DATA,
+            (DWORD) dwCallStateNumEntries * sizeof(LINEMEDIACONTROLCALLSTATE)
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,   
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    //
+    // If lpXxxList is non-NULL reset Arg & ArgType, and check
+    // to see that dwXxxNumEntries is not unacceptably large
+    //
+
+    if (lpDigitList)
+    {
+            if (dwDigitNumEntries >
+                    (0x1000000 / sizeof (LINEMEDIACONTROLDIGIT)))
+            {
+            return LINEERR_INVALPOINTER;
+            }
+
+            funcArgs.ArgTypes[4] = lpSet_SizeToFollow;
+            funcArgs.Args[4]     = (DWORD) lpDigitList;
+            funcArgs.ArgTypes[5] = Size;
+    }
+
+    if (lpMediaList)
+    {
+            if (dwMediaNumEntries >
+                    (0x1000000 / sizeof (LINEMEDIACONTROLMEDIA)))
+            {
+            return LINEERR_INVALPOINTER;
+            }
+
+            funcArgs.ArgTypes[6] = lpSet_SizeToFollow;
+            funcArgs.Args[6]     = (DWORD) lpMediaList;
+            funcArgs.ArgTypes[7] = Size;
+    }
+
+    if (lpToneList)
+    {
+            if (dwToneNumEntries >
+                    (0x1000000 / sizeof (LINEMEDIACONTROLTONE)))
+            {
+            return LINEERR_INVALPOINTER;
+            }
+
+            funcArgs.ArgTypes[8] = lpSet_SizeToFollow;
+            funcArgs.Args[8]     = (DWORD) lpToneList;
+            funcArgs.ArgTypes[9] = Size;
+    }
+
+    if (lpCallStateList)
+    {
+            if (dwCallStateNumEntries >
+                    (0x1000000 / sizeof (LINEMEDIACONTROLCALLSTATE)))
+            {
+            return LINEERR_INVALPOINTER;
+            }
+
+            funcArgs.ArgTypes[10] = lpSet_SizeToFollow;
+            funcArgs.Args[10]     = (DWORD) lpCallStateList;
+            funcArgs.ArgTypes[11] = Size;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetMediaControl"));
+}
+
+
+LONG
+WINAPI
+lineSetMediaMode(
+    HCALL   hCall,
+    DWORD   dwMediaModes
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lSetMediaMode),
+
+        {
+            (DWORD) hCall,
+            dwMediaModes
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetMediaMode"));
+}
+
+
+LONG
+WINAPI
+lineSetNumRings(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    DWORD   dwNumRings
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lSetNumRings),
+
+        {
+            (DWORD) hLine,
+            dwAddressID,
+            dwNumRings
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetNumRings"));
+}
+
+
+LONG
+WINAPI
+lineSetStatusMessages(
+    HLINE hLine,
+    DWORD dwLineStates,
+    DWORD dwAddressStates
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lSetStatusMessages),
+
+        {
+            (DWORD) hLine,
+            dwLineStates,
+            dwAddressStates
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetStatusMessages"));
+}
+
+
+LONG
+WINAPI
+lineSetTerminal(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    DWORD   dwTerminalModes,
+    DWORD   dwTerminalID,
+    DWORD   bEnable
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lSetTerminal),
+
+        {
+            (DWORD) hLine,
+            dwAddressID,
+            (DWORD) hCall,
+            dwSelect,
+            dwTerminalModes,
+            dwTerminalID,
+            bEnable
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineSetTerminal"));
+}
+
+
+void
+PASCAL
+lineSetupConferencePostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineSetupConfPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        HCALL   hConfCall      = (HCALL) pMsg->dwParam3,
+                hConsultCall   = (HCALL) *(&pMsg->dwParam4 + 1);
+        LPHCALL lphConfCall    = (LPHCALL) pMsg->dwParam4,
+                lphConsultCall = (LPHCALL) *(&pMsg->dwParam4 + 2);
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPHCALL lphConfCallVDM = (LPHCALL) gpfnWOWGetVDMPointer(
+                            (DWORD) lphConfCall,
+                            sizeof (HCALL),
+                            TRUE // fProtectedMode
+                            ),
+                        lphConsultCallVDM = (LPHCALL) gpfnWOWGetVDMPointer(
+                            (DWORD) lphConsultCall,
+                            sizeof (HCALL),
+                            TRUE // fProtectedMode
+                            );
+
+                if (lphConfCallVDM && lphConsultCallVDM)
+                {
+                    *lphConfCallVDM = hConfCall;
+                    *lphConsultCallVDM = hConsultCall;
+                }
+                else
+                {
+                    pMsg->dwParam2 = LINEERR_INVALPOINTER;
+                }
+            }
+            else
+            {
+                *lphConfCall = hConfCall;
+                *lphConsultCall = hConsultCall;
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = LINEERR_INVALPOINTER;
+
+            // BUGBUG drop/dealloc
+        }
+    }
+}
+
+
+LONG
+WINAPI
+lineSetupConferenceW(
+    HCALL   hCall,
+    HLINE   hLine,
+    LPHCALL lphConfCall,
+    LPHCALL lphConsultCall,
+    DWORD   dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 8, lSetupConference),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineSetupConferencePostProcess),
+            (DWORD) hCall,
+            (DWORD) hLine,
+            (DWORD) lphConfCall,
+            (DWORD) lphConsultCall,
+            (DWORD) dwNumParties,
+            (DWORD) lpCallParams,
+            (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            (gbNTVDMClient ? Dword : lpDword),
+            Dword,
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (lphConfCall == lphConsultCall)
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[6] = Dword;
+        funcArgs.Args[6]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetupConferenceW"));
+}
+
+
+LONG
+WINAPI
+lineSetupConferenceA(
+    HCALL   hCall,
+    HLINE   hLine,
+    LPHCALL lphConfCall,
+    LPHCALL lphConsultCall,
+    DWORD   dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 8, lSetupConference),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineSetupConferencePostProcess),
+            (DWORD) hCall,
+            (DWORD) hLine,
+            (DWORD) lphConfCall,
+            (DWORD) lphConsultCall,
+            (DWORD) dwNumParties,
+            (DWORD) lpCallParams,
+            (DWORD) GetACP()        // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            (gbNTVDMClient ? Dword : lpDword),
+            Dword,
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (lphConfCall == lphConsultCall)
+    {
+        return LINEERR_INVALPOINTER;
+    }
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[6] = Dword;
+        funcArgs.Args[6]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetupConference"));
+}
+
+
+LONG
+WINAPI
+lineSetupConference(
+    HCALL   hCall,
+    HLINE   hLine,
+    LPHCALL lphConfCall,
+    LPHCALL lphConsultCall,
+    DWORD   dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    return lineSetupConferenceA(
+              hCall,
+              hLine,
+              lphConfCall,
+              lphConsultCall,
+              dwNumParties,
+              lpCallParams
+    );
+}    
+
+
+LONG
+WINAPI
+lineSetupTransferW(
+    HCALL   hCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lSetupTransfer),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hCall,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetupTransferW"));
+}
+
+
+LONG
+WINAPI
+lineSetupTransferA(
+    HCALL   hCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lSetupTransfer),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hCall,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (DWORD) GetACP()        // dwAsciiCallParamsCodePage
+        },
+
+        {
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpSet_Struct,
+            Dword
+        }
+    };
+
+
+    if (!lpCallParams)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "lineSetupTransferW"));
+}
+
+
+LONG
+WINAPI
+lineSetupTransfer(
+    HCALL   hCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    return lineSetupTransferA(
+              hCall,
+              lphConsultCall,
+              lpCallParams
+    );
+}
+
+
+LONG
+WINAPI
+lineShutdown(
+    HLINEAPP    hLineApp
+    )
+{
+    return (xxxShutdown ((DWORD) hLineApp, TRUE));
+}
+
+
+LONG
+WINAPI
+lineSwapHold(
+    HCALL   hActiveCall,
+    HCALL   hHeldCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lSwapHold),
+
+        {
+            (DWORD) hActiveCall,
+            (DWORD) hHeldCall
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+    return (DOFUNC (&funcArgs, "lineSwapHold"));
+}
+
+
+LONG
+WINAPI
+lineUncompleteCall(
+    HLINE   hLine,
+    DWORD   dwCompletionID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lUncompleteCall),
+
+        {
+            (DWORD) hLine,
+            dwCompletionID
+        },
+
+        {
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineUncompleteCall"));
+}
+
+
+LONG
+WINAPI
+lineUnhold(
+    HCALL   hCall
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 1, lUnhold),
+
+        {
+            (DWORD) hCall
+        },
+
+        {
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineUnhold"));
+}
+
+
+LONG
+WINAPI
+lineUnparkW(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCWSTR lpszDestAddress
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lUnpark),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) lineMakeCallPostProcess),
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lphCall,
+            (DWORD) lpszDestAddress
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            (gbNTVDMClient ? Dword : lpDword),
+            lpszW
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "lineUnpark"));
+}
+
+
+LONG
+WINAPI
+lineUnparkA(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (IsBadStringPtrA (lpszDestAddress, (DWORD) -1))
+    {
+        return LINEERR_INVALPOINTER;
+    }
+    else if (!(szTempPtr = NotSoWideStringToWideString(
+                    lpszDestAddress,
+                    (DWORD) -1
+                    )))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    lResult = lineUnparkW (hLine, dwAddressID, lphCall, szTempPtr);
+
+    ClientFree (szTempPtr);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineUnpark(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress
+    )
+{
+    return  lineUnparkA(
+                hLine,
+                dwAddressID,
+                lphCall,
+                lpszDestAddress
+    );
+    
+}    
+
+//
+// ------------------------------- phoneXxx -----------------------------------
+//
+
+LONG
+WINAPI
+phoneClose(
+    HPHONE  hPhone
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 1, pClose),
+
+        {
+            (DWORD) hPhone
+        },
+
+        {
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneClose"));
+}
+
+
+LONG
+WINAPI
+phoneConfigDialogW(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    LONG        lResult;
+    HANDLE      hDll;
+    TUISPIPROC  pfnTUISPI_phoneConfigDialog;
+
+
+    if (lpszDeviceClass && IsBadStringPtrW (lpszDeviceClass, (DWORD) -1))
+    {
+        return PHONEERR_INVALPOINTER;
+    }
+
+    if ((lResult = LoadUIDll(
+            hwndOwner,
+            dwDeviceID,
+            TUISPIDLL_OBJECT_PHONEID,
+            &hDll,
+            gszTUISPI_phoneConfigDialog,
+            &pfnTUISPI_phoneConfigDialog
+
+            )) == 0)
+    {
+        DBGOUT((3, "Calling TUISPI_phoneConfigDialog..."));
+
+        lResult = (*pfnTUISPI_phoneConfigDialog)(
+            TUISPIDLLCallback,
+            dwDeviceID,
+            hwndOwner,
+            lpszDeviceClass
+            );
+
+#if DBG
+        {
+            char szResult[32];
+
+
+            DBGOUT((
+                3,
+                "TUISPI_phoneConfigDialog: result = %s",
+                MapResultCodeToText (lResult, szResult)
+                ));
+        }
+#endif
+        FreeLibrary (hDll);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneConfigDialogA(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG  lResult;
+    PWSTR szTempString;
+
+
+    if (lpszDeviceClass && IsBadStringPtrA (lpszDeviceClass, (DWORD) -1))
+    {
+        return PHONEERR_INVALPOINTER;
+    }
+
+    szTempString = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+
+    lResult = phoneConfigDialogW (dwDeviceID, hwndOwner, szTempString);
+
+    if (szTempString)
+    {
+        ClientFree (szTempString);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    return phoneConfigDialogA(
+              dwDeviceID,
+              hwndOwner,
+              lpszDeviceClass
+    );
+}    
+
+
+void
+PASCAL
+phoneDevSpecificPostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "phoneDevSpecificPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD   dwSize  = pMsg->dwParam4;
+        LPBYTE  pParams = (LPBYTE) pMsg->dwParam3;
+
+        try
+        {
+            if (gbNTVDMClient)
+            {
+                //
+                // BUGBUG For Win9x compatibility we probably ought to
+                // use WOWGetVDMPointerFix & WOWGetVDMPointerUnfix
+                //
+
+                LPVARSTRING pParamsVDM = (LPVARSTRING) gpfnWOWGetVDMPointer(
+                    (DWORD) pParams,
+                    dwSize,
+                    TRUE // fProtectedMode
+                    );
+
+
+                if (pParamsVDM)
+                {
+                    CopyMemory (pParamsVDM, (LPBYTE) (pMsg + 1), dwSize);
+                }
+                else
+                {
+                    pMsg->dwParam2 = PHONEERR_INVALPOINTER;
+                }
+            }
+            else
+            {
+                CopyMemory (pParams, (LPBYTE) (pMsg + 1), dwSize);
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            pMsg->dwParam2 = PHONEERR_INVALPOINTER;
+        }
+    }
+}
+
+
+LONG
+WINAPI
+phoneDevSpecific(
+    HPHONE  hPhone,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 5, pDevSpecific),
+
+        {
+            (DWORD) ((POSTPROCESSPROC) phoneDevSpecificPostProcess),
+            (DWORD) hPhone,
+            (DWORD) lpParams, // passed as Dword for post processing
+            (DWORD) lpParams, // passed as LpSet_Xxx for IsValidPtr chk
+            (DWORD) dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if (gbNTVDMClient)
+    {
+        if (!gpfnWOWGetVDMPointer  ||
+
+            !(funcArgs.Args[3] = gpfnWOWGetVDMPointer(
+                (DWORD) lpParams,
+                dwSize,
+                TRUE // fProtectedMode
+                )))
+        {
+            return PHONEERR_OPERATIONFAILED;
+        }
+    }
+
+    return (DOFUNC (&funcArgs, "phoneDevSpecific"));
+}
+
+
+LONG
+WINAPI
+phoneGetButtonInfoW(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetButtonInfo),
+
+        {
+            (DWORD) hPhone,
+            dwButtonLampID,
+            (DWORD) lpButtonInfo
+        },
+
+        {
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetButtonInfo"));
+}
+
+
+LONG
+WINAPI
+phoneGetButtonInfoA(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    LONG lResult;
+
+
+    lResult = phoneGetButtonInfoW (hPhone, dwButtonLampID, lpButtonInfo);
+
+    if ( 0 == lResult )
+    {
+        WideStringToNotSoWideString(
+            (LPBYTE)lpButtonInfo,
+            &lpButtonInfo->dwButtonTextSize
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetButtonInfo(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    return phoneGetButtonInfoA(
+              hPhone,
+              dwButtonLampID,
+              lpButtonInfo
+    );
+}    
+
+
+LONG
+WINAPI
+phoneGetData(
+    HPHONE  hPhone,
+    DWORD   dwDataID,
+    LPVOID  lpData,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 4, pGetData),
+
+        {
+            (DWORD) hPhone,
+            dwDataID,
+            (DWORD) lpData,
+            dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetData"));
+}
+
+
+LONG
+WINAPI
+phoneGetDevCapsW(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 5, pGetDevCaps),
+
+        {
+            (DWORD) hPhoneApp,
+            dwDeviceID,
+            dwAPIVersion,
+            dwExtVersion,
+            (DWORD) lpPhoneCaps
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetDevCaps"));
+}
+
+
+LONG
+WINAPI
+phoneGetDevCapsA(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    LONG lResult;
+
+
+    lResult = phoneGetDevCapsW(
+        hPhoneApp,
+        dwDeviceID,
+        dwAPIVersion,
+        dwExtVersion,
+        lpPhoneCaps
+        );
+
+    if (lResult == 0)
+    {
+        WideStringToNotSoWideString(
+            (LPBYTE) lpPhoneCaps,
+            &lpPhoneCaps->dwProviderInfoSize
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE) lpPhoneCaps,
+            &lpPhoneCaps->dwPhoneInfoSize
+            );
+
+        WideStringToNotSoWideString(
+            (LPBYTE) lpPhoneCaps,
+            &lpPhoneCaps->dwPhoneNameSize
+            );
+
+        if (dwAPIVersion >= 0x00020000)
+        {
+            WideStringToNotSoWideString(
+                (LPBYTE) lpPhoneCaps,
+                &lpPhoneCaps->dwDeviceClassesSize
+                );
+        }
+    }
+
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetDevCaps(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    return phoneGetDevCapsA(
+                    hPhoneApp,
+                    dwDeviceID,
+                    dwAPIVersion,
+                    dwExtVersion,
+                    lpPhoneCaps
+    );
+}    
+
+
+LONG
+WINAPI
+phoneGetDisplay(
+    HPHONE  hPhone,
+    LPVARSTRING lpDisplay
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 2, pGetDisplay),
+
+        {
+            (DWORD) hPhone,
+            (DWORD) lpDisplay
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetDisplay"));
+}
+
+
+LONG
+WINAPI
+phoneGetGain(
+    HPHONE hPhone,
+    DWORD dwHookSwitchDev,
+    LPDWORD lpdwGain
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetGain),
+
+        {
+            (DWORD) hPhone,
+            dwHookSwitchDev,
+            (DWORD) lpdwGain
+        },
+
+        {
+            Dword,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetGain"));
+}
+
+
+LONG
+WINAPI
+phoneGetHookSwitch(
+    HPHONE hPhone,
+    LPDWORD lpdwHookSwitchDevs
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 2, pGetHookSwitch),
+
+        {
+            (DWORD) hPhone,
+            (DWORD) lpdwHookSwitchDevs
+        },
+
+        {
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetHookSwitch"));
+}
+
+
+LONG
+WINAPI
+phoneGetIconW(
+    DWORD   dwDeviceID,
+    LPCWSTR lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    HICON   hIcon;
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetIcon),
+
+        {
+            dwDeviceID,
+            (DWORD) lpszDeviceClass,
+            (DWORD) &hIcon
+        },
+
+        {
+            Dword,
+            lpszW,
+            lpDword
+        }
+    };
+    LONG    lResult;
+
+
+    if (IsBadDwordPtr ((LPDWORD) lphIcon))
+    {
+        return PHONEERR_INVALPOINTER;
+    }
+
+    if (lpszDeviceClass == (LPCWSTR) NULL)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+    }
+
+    if ((lResult = DOFUNC (&funcArgs, "phoneGetIcon")) == 0)
+    {
+        if (gbNTVDMClient == FALSE)
+        {
+            *lphIcon = hIcon;
+        }
+        else
+        {
+// BUGBUG phoneGetIcon: need to convert 32-bit HICON to 16-bit HICON
+        }
+    }
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetIconA(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (lpszDeviceClass)
+    {
+        if (IsBadStringPtrA (lpszDeviceClass, (DWORD) (DWORD) -1))
+        {
+            return PHONEERR_INVALPOINTER;
+        }
+
+        szTempPtr = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+    }
+    else
+    {
+        szTempPtr = NULL;
+    }
+
+    lResult = phoneGetIconW (dwDeviceID, szTempPtr, lphIcon);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetIcon(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    return phoneGetIconA(
+              dwDeviceID,
+              lpszDeviceClass,
+              lphIcon
+    );
+}    
+
+
+LONG
+WINAPI
+phoneGetIDW(
+    HPHONE      hPhone,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetID),
+
+        {
+            (DWORD) hPhone,
+            (DWORD) lpDeviceID,
+            (DWORD) lpszDeviceClass
+        },
+
+        {
+            Dword,
+            lpGet_Struct,
+            lpszW
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetID"));
+}
+
+
+LONG
+WINAPI
+phoneGetIDA(
+    HPHONE      hPhone,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    szTempPtr = NotSoWideStringToWideString (lpszDeviceClass, (DWORD) -1);
+
+    lResult = phoneGetIDW (hPhone, lpDeviceID, szTempPtr);
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetID(
+    HPHONE      hPhone,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass
+    )
+{
+    return phoneGetIDA(
+                  hPhone,
+                  lpDeviceID,
+                  lpszDeviceClass
+    );
+}    
+
+
+LONG
+WINAPI
+phoneGetLamp(
+    HPHONE hPhone,
+    DWORD dwButtonLampID,
+    LPDWORD lpdwLampMode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetLamp),
+
+        {
+            (DWORD) hPhone,
+            dwButtonLampID,
+            (DWORD) lpdwLampMode
+        },
+
+        {
+            Dword,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetLamp"));
+}
+
+
+
+LONG
+WINAPI
+phoneGetMessage(
+    HPHONEAPP       hPhoneApp,
+    LPPHONEMESSAGE  lpMessage,
+    DWORD           dwTimeout
+    )
+{
+    return (xxxGetMessage(
+        FALSE,
+        (PINIT_DATA) hPhoneApp,
+        (LPLINEMESSAGE) lpMessage,
+        dwTimeout
+        ));
+}
+
+
+LONG
+WINAPI
+phoneGetRing(
+    HPHONE hPhone,
+    LPDWORD lpdwRingMode,
+    LPDWORD lpdwVolume
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetRing),
+
+        {
+            (DWORD) hPhone,
+            (DWORD) lpdwRingMode,
+            (DWORD) lpdwVolume
+        },
+
+        {
+            Dword,
+            lpDword,
+            lpDword
+        }
+    };
+
+
+    if (lpdwRingMode == lpdwVolume)
+    {
+        return PHONEERR_INVALPOINTER;
+    }
+
+    return (DOFUNC (&funcArgs, "phoneGetRing"));
+}
+
+
+LONG
+WINAPI
+phoneGetStatusW(
+    HPHONE hPhone,
+    LPPHONESTATUS lpPhoneStatus
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 2, pGetStatus),
+
+        {
+            (DWORD) hPhone,
+            (DWORD) lpPhoneStatus
+        },
+
+        {
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetStatus"));
+}
+
+
+LONG
+WINAPI
+phoneGetStatusA(
+    HPHONE hPhone,
+    LPPHONESTATUS lpPhoneStatus
+    )
+{
+    LONG lResult;
+
+
+    lResult = phoneGetStatusW (hPhone, lpPhoneStatus);
+
+    if (lResult == 0)
+    {
+        WideStringToNotSoWideString(
+            (LPBYTE)lpPhoneStatus,
+            &lpPhoneStatus->dwOwnerNameSize
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetStatus(
+    HPHONE hPhone,
+    LPPHONESTATUS lpPhoneStatus
+    )
+{
+    return phoneGetStatusA(
+             hPhone,
+             lpPhoneStatus
+    );
+}    
+
+
+LONG
+WINAPI
+phoneGetStatusMessages(
+    HPHONE hPhone,
+    LPDWORD lpdwPhoneStates,
+    LPDWORD lpdwButtonModes,
+    LPDWORD lpdwButtonStates
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 4, pGetStatusMessages),
+
+        {
+            (DWORD) hPhone,
+            (DWORD) lpdwPhoneStates,
+            (DWORD) lpdwButtonModes,
+            (DWORD) lpdwButtonStates
+        },
+
+        {
+            Dword,
+            lpDword,
+            lpDword,
+            lpDword
+        }
+    };
+
+
+    if (lpdwPhoneStates == lpdwButtonModes  ||
+        lpdwPhoneStates == lpdwButtonStates  ||
+        lpdwButtonModes == lpdwButtonStates)
+    {
+        return PHONEERR_INVALPOINTER;
+    }
+
+    return (DOFUNC (&funcArgs, "phoneGetStatusMessages"));
+}
+
+
+LONG
+WINAPI
+phoneGetVolume(
+    HPHONE hPhone,
+    DWORD dwHookSwitchDev,
+    LPDWORD lpdwVolume
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetVolume),
+
+        {
+            (DWORD) hPhone,
+            dwHookSwitchDev,
+            (DWORD) lpdwVolume
+        },
+
+        {
+            Dword,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneGetVolume"));
+}
+
+
+LONG
+WINAPI
+phoneInitialize(
+    LPHPHONEAPP     lphPhoneApp,
+    HINSTANCE       hInstance,
+    PHONECALLBACK   lpfnCallback,
+    LPCSTR          lpszFriendlyAppName,
+    LPDWORD         lpdwNumDevs
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr;
+
+
+    if (lpszFriendlyAppName)
+    {
+        if (IsBadStringPtrA (lpszFriendlyAppName, (DWORD) -1))
+        {
+            DBGOUT((
+                1,
+                "phoneInitialize: bad lpszFriendlyAppName (x%x)",
+                lpszFriendlyAppName
+                ));
+
+            return PHONEERR_INVALPOINTER;
+        }
+
+        szTempPtr = NotSoWideStringToWideString(
+            lpszFriendlyAppName,
+            (DWORD) -1
+            );
+    }
+    else
+    {
+        szTempPtr = NULL;
+    }
+
+    lResult = (xxxInitialize(
+        FALSE,
+        (LPVOID) lphPhoneApp,
+        hInstance,
+        lpfnCallback,
+        szTempPtr,
+        lpdwNumDevs,
+        NULL,
+        NULL
+#if DBG
+        ,"phoneInitialize"
+#endif
+        ));
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneInitializeExW(
+    LPHPHONEAPP                 lphPhoneApp,
+    HINSTANCE                   hInstance,
+    PHONECALLBACK               lpfnCallback,
+    LPCWSTR                     lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams
+    )
+{
+    if (IsBadDwordPtr (lpdwAPIVersion))
+    {
+        DBGOUT((
+            1,
+            "phoneInitializeExW: bad lpdwAPIVersion (x%x)",
+            lpdwAPIVersion
+            ));
+
+        return PHONEERR_INVALPOINTER;
+    }
+
+    return (xxxInitialize(
+        FALSE,
+        (LPVOID) lphPhoneApp,
+        hInstance,
+        lpfnCallback,
+        lpszFriendlyAppName,
+        lpdwNumDevs,
+        lpdwAPIVersion,
+        (LPVOID) lpPhoneInitializeExParams
+#if DBG
+        ,"phoneInitializeExW"
+#endif
+        ));
+}
+
+
+LONG
+WINAPI
+phoneInitializeExA(
+    LPHPHONEAPP                 lphPhoneApp,
+    HINSTANCE                   hInstance,
+    PHONECALLBACK               lpfnCallback,
+    LPCSTR                      lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr = NULL;
+
+
+    if (lpszFriendlyAppName)
+    {
+        if (IsBadStringPtrA (lpszFriendlyAppName, (DWORD) -1))
+        {
+            DBGOUT((
+                1,
+                "phoneInitializeExA: bad lpszFriendlyAppName (x%x)",
+                lpszFriendlyAppName
+                ));
+
+            return PHONEERR_INVALPOINTER;
+        }
+
+        szTempPtr = NotSoWideStringToWideString(
+            lpszFriendlyAppName,
+            (DWORD) -1
+            );
+    }
+    else
+    {
+        szTempPtr = NULL;
+    }
+
+    lResult = phoneInitializeExW(
+        lphPhoneApp,
+        hInstance,
+        lpfnCallback,
+        szTempPtr,
+        lpdwNumDevs,
+        lpdwAPIVersion,
+        lpPhoneInitializeExParams
+        );
+
+    if (szTempPtr)
+    {
+        ClientFree (szTempPtr);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneNegotiateAPIVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 7, pNegotiateAPIVersion),
+
+        {
+            (DWORD) hPhoneApp,
+            dwDeviceID,
+            dwAPILowVersion,
+            dwAPIHighVersion,
+            (DWORD) lpdwAPIVersion,
+            (DWORD) lpExtensionID,
+            sizeof(PHONEEXTENSIONID)
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            lpDword,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    if ((LPVOID) lpdwAPIVersion == (LPVOID) lpExtensionID)
+    {
+        return PHONEERR_INVALPOINTER;
+    }
+
+    return (DOFUNC (&funcArgs, "phoneNegotiateAPIVersion"));
+}
+
+
+LONG
+WINAPI
+phoneNegotiateExtVersion(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtLowVersion,
+    DWORD       dwExtHighVersion,
+    LPDWORD     lpdwExtVersion
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 6, pNegotiateExtVersion),
+
+        {
+            (DWORD) hPhoneApp,
+            dwDeviceID,
+            dwAPIVersion,
+            dwExtLowVersion,
+            dwExtHighVersion,
+            (DWORD) lpdwExtVersion
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneNegotiateExtVersion"));
+}
+
+
+LONG
+WINAPI
+phoneOpen(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    LPHPHONE    lphPhone,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    DWORD       dwCallbackInstance,
+    DWORD       dwPrivilege
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 8, pOpen),
+
+        {
+            (DWORD) hPhoneApp,
+            dwDeviceID,
+            (DWORD) lphPhone,
+            dwAPIVersion,
+            dwExtVersion,
+            dwCallbackInstance,
+            dwPrivilege,
+            0,                  // PHONEOPEN_PARAMS.hRemotePhone
+        },
+
+        {
+            hXxxApp,
+            Dword,
+            lpDword,
+            Dword,
+            Dword,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneOpen"));
+}
+
+
+LONG
+WINAPI
+phoneSetButtonInfoW(
+    HPHONE hPhone,
+    DWORD dwButtonLampID,
+    LPPHONEBUTTONINFO const lpButtonInfo
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 3, pSetButtonInfo),
+
+        {
+            (DWORD) hPhone,
+            dwButtonLampID,
+            (DWORD) lpButtonInfo
+        },
+
+        {
+            Dword,
+            Dword,
+            lpSet_Struct
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetButtonInfo"));
+}
+
+
+LONG
+WINAPI
+phoneSetButtonInfoA(
+    HPHONE hPhone,
+    DWORD dwButtonLampID,
+    LPPHONEBUTTONINFO const lpButtonInfo
+    )
+{
+    LONG                lResult;
+    LPPHONEBUTTONINFO   lppbi;
+
+
+    if (IsBadReadPtr( lpButtonInfo, sizeof(PHONEBUTTONINFO)) ||
+        IsBadReadPtr( lpButtonInfo, lpButtonInfo->dwTotalSize))
+    {
+        DBGOUT((1, "Bad lpButtonInfo - not at least sizeof(PHONEBUTTONINFO)"));
+        return PHONEERR_INVALPOINTER;
+    }
+
+
+    //
+    // See if there's a need to do this, first
+    //
+
+    if ( lpButtonInfo->dwButtonTextSize )
+    {
+       DWORD dwNewStringSize;
+
+       //
+       // Assume the worst for size...
+       //
+
+       lppbi = ClientAlloc( lpButtonInfo->dwTotalSize * sizeof(WCHAR) );
+
+       CopyMemory( lppbi, lpButtonInfo, lpButtonInfo->dwTotalSize );
+
+
+       //
+       // We _KNOW_ that the old structure was as big as the dwTotalSize
+       // so we can put our rebuilt string starting there.
+       //
+
+       dwNewStringSize = sizeof(WCHAR) * MultiByteToWideChar(
+            GetACP(),
+            MB_PRECOMPOSED,
+            (LPBYTE)lpButtonInfo + lpButtonInfo->dwButtonTextOffset,
+            lpButtonInfo->dwButtonTextSize,
+            (PWSTR)((LPBYTE)lppbi + lpButtonInfo->dwTotalSize),
+            lpButtonInfo->dwButtonTextSize
+            );
+
+       lppbi->dwTotalSize += dwNewStringSize;
+
+       lppbi->dwButtonTextSize   = dwNewStringSize;
+       lppbi->dwButtonTextOffset = lpButtonInfo->dwTotalSize;
+    }
+    else
+    {
+        lppbi = NULL;
+    }
+
+
+    lResult = phoneSetButtonInfoW(
+        hPhone,
+        dwButtonLampID,
+        lppbi ? lppbi : lpButtonInfo
+        );
+
+    if (lppbi)
+    {
+        ClientFree (lppbi);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetButtonInfo(
+    HPHONE hPhone,
+    DWORD dwButtonLampID,
+    LPPHONEBUTTONINFO const lpButtonInfo
+    )
+{
+    return phoneSetButtonInfoA(
+             hPhone,
+             dwButtonLampID,
+             lpButtonInfo
+    );
+}    
+
+
+LONG
+WINAPI
+phoneSetData(
+    HPHONE  hPhone,
+    DWORD   dwDataID,
+    LPVOID  const lpData,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetData),
+
+        {
+            (DWORD) hPhone,
+            dwDataID,
+            (DWORD) lpData,
+            dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetData"));
+}
+
+
+LONG
+WINAPI
+phoneSetDisplay(
+    HPHONE  hPhone,
+    DWORD   dwRow,
+    DWORD   dwColumn,
+    LPCSTR  lpsDisplay,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 5, pSetDisplay),
+
+        {
+            (DWORD) hPhone,
+            dwRow,
+            dwColumn,
+            (DWORD) lpsDisplay,
+            dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetDisplay"));
+}
+
+
+LONG
+WINAPI
+phoneSetGain(
+    HPHONE  hPhone,
+    DWORD   dwHookSwitchDev,
+    DWORD   dwGain
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 3, pSetGain),
+
+        {
+            (DWORD) hPhone,
+            dwHookSwitchDev,
+            dwGain
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetGain"));
+}
+
+
+LONG
+WINAPI
+phoneSetHookSwitch(
+    HPHONE hPhone,
+    DWORD  dwHookSwitchDevs,
+    DWORD  dwHookSwitchMode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 3, pSetHookSwitch),
+
+        {
+            (DWORD) hPhone,
+            dwHookSwitchDevs,
+            dwHookSwitchMode
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    if (!(dwHookSwitchDevs & AllHookSwitchDevs) ||
+        (dwHookSwitchDevs & (~AllHookSwitchDevs)))
+    {
+        return PHONEERR_INVALHOOKSWITCHDEV;
+    }
+
+    if (!IsOnlyOneBitSetInDWORD (dwHookSwitchMode) ||
+        (dwHookSwitchMode & ~AllHookSwitchModes))
+    {
+        return PHONEERR_INVALHOOKSWITCHMODE;
+    }
+
+    return (DOFUNC (&funcArgs, "phoneSetHookSwitch"));
+}
+
+
+LONG
+WINAPI
+phoneSetLamp(
+    HPHONE hPhone,
+    DWORD  dwButtonLampID,
+    DWORD  dwLampMode
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 3, pSetLamp),
+
+        {
+            (DWORD) hPhone,
+            dwButtonLampID,
+            dwLampMode
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetLamp"));
+}
+
+
+LONG
+WINAPI
+phoneSetRing(
+    HPHONE hPhone,
+    DWORD  dwRingMode,
+    DWORD  dwVolume
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 3, pSetRing),
+
+        {
+            (DWORD) hPhone,
+            dwRingMode,
+            dwVolume
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetRing"));
+}
+
+
+LONG
+WINAPI
+phoneSetStatusMessages(
+    HPHONE hPhone,
+    DWORD  dwPhoneStates,
+    DWORD  dwButtonModes,
+    DWORD  dwButtonStates
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 4, pSetStatusMessages),
+
+        {
+            (DWORD) hPhone,
+            dwPhoneStates,
+            dwButtonModes,
+            dwButtonStates
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "phoneSetStatusMessages"));
+}
+
+
+LONG
+WINAPI
+phoneSetVolume(
+    HPHONE hPhone,
+    DWORD  dwHookSwitchDev,
+    DWORD  dwVolume
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 3, pSetVolume),
+
+        {
+            (DWORD) hPhone,
+            dwHookSwitchDev,
+            dwVolume
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+return (DOFUNC (&funcArgs, "phoneSetVolume"));
+}
+
+
+LONG
+WINAPI
+phoneShutdown(
+    HPHONEAPP hPhoneApp
+    )
+{
+    return (xxxShutdown ((DWORD) hPhoneApp, FALSE));
+}
+
+
+//
+// ------------------------------- tapiXxx ------------------------------------
+//
+
+LONG
+WINAPI
+tapiRequestDrop(
+    HWND    hWnd,
+    WPARAM  wRequestID
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (TAPI_FUNC | SYNC | 2, tRequestDrop),
+
+        {
+            (DWORD) hWnd,
+            (DWORD) wRequestID
+        },
+
+        {
+            Hwnd,
+            Dword
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "tapiRequestDrop"));
+}
+
+
+LONG
+WINAPI
+tapiRequestMakeCallW(
+    LPCWSTR  lpszDestAddress,
+    LPCWSTR  lpszAppName,
+    LPCWSTR  lpszCalledParty,
+    LPCWSTR  lpszComment
+    )
+{
+    LONG        lResult;
+    DWORD       hRequestMakeCallAttempted, dwProxyListSize = 512;
+    LPVARSTRING pProxyList;
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (TAPI_FUNC | SYNC | 7, tRequestMakeCall),
+
+        {
+            (DWORD) lpszDestAddress,
+            (DWORD) lpszAppName,
+            (DWORD) lpszCalledParty,
+            (DWORD) lpszComment,
+            (DWORD) 0,
+            (DWORD) 0,
+            (DWORD) &hRequestMakeCallAttempted
+        },
+
+        {
+            lpszW,
+            lpszW,
+            lpszW,
+            lpszW,
+            lpGet_Struct,
+            Dword,
+            lpDword
+        }
+    };
+
+
+    // BUGBUG some of the err codes here need to be tweeked
+
+    if (IsBadStringPtrW (lpszDestAddress, (DWORD) -1) ||
+        (lstrlenW (lpszDestAddress) + 1) > TAPIMAXDESTADDRESSSIZE)
+    {
+        return TAPIERR_INVALDESTADDRESS;
+    }
+
+    if (!lpszAppName)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+    }
+
+    if (!lpszCalledParty)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[2] = Dword;
+        funcArgs.Args[2]     = TAPI_NO_DATA;
+    }
+
+    if (!lpszComment)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[3] = Dword;
+        funcArgs.Args[3]     = TAPI_NO_DATA;
+    }
+
+
+    //
+    //
+    //
+
+    if (!(pProxyList = ClientAlloc (dwProxyListSize)))
+    {
+        return TAPIERR_NOREQUESTRECIPIENT;
+    }
+
+    pProxyList->dwTotalSize = dwProxyListSize;
+
+    funcArgs.Args[4] = (DWORD) pProxyList;
+
+    if ((lResult = DOFUNC (&funcArgs, "tapiRequestMakeCall")) == 0)
+    {
+        //
+        //
+        //
+
+        if (hRequestMakeCallAttempted != 0)
+        {
+            WCHAR  *pszProxyName, *pszNextProxyName;
+            BOOL    bLastAppInList = FALSE, bStartedProxy = FALSE;
+
+
+            pszProxyName =
+            pszNextProxyName =
+                (WCHAR *)(((LPBYTE) pProxyList) + pProxyList->dwStringOffset);
+
+
+            while (!bLastAppInList)
+            {
+                while (1)
+                {
+                    if (*pszNextProxyName == 0)
+                    {
+                        bLastAppInList = TRUE;
+                        break;
+                    }
+                    else if (*pszNextProxyName == ',')
+                    {
+                        *pszNextProxyName = 0;
+                        pszNextProxyName++;
+                        break;
+                    }
+
+                    pszNextProxyName++;
+                }
+
+                //
+                // Fake layer to get a local struct
+                //
+                {
+                    FARPROC pShellExecuteExW = NULL;
+                    HINSTANCE hInst;
+                
+                    SHELLEXECUTEINFOW sei =
+                    {
+                        sizeof(SHELLEXECUTEINFOW),
+                        0,
+                        0, // hWnd!!!  BUGBUG: Should it be GetFocus() ??? 
+                        NULL, //"Open"
+                        pszProxyName,
+                        NULL,
+                        NULL, //Directory
+                        SW_MINIMIZE,
+                        NULL   //hProcess - huh?
+                    };
+
+
+                    hInst = LoadLibrary( "shell32.dll" );
+                    pShellExecuteExW = GetProcAddress( hInst, "ShellExecuteExW" );
+
+                    if (pShellExecuteExW && pShellExecuteExW (&sei) == TRUE)
+                    {
+                        bStartedProxy = TRUE;
+                        break;
+                    }
+#if DBG
+                    else
+                    {
+                        DBGOUT((
+                            3,
+                            "tapiRequestMakeCall: ShellExecuteExW(%ls) error - x%x",
+                            pszProxyName,
+                            GetLastError()
+                            ));
+                    }
+#endif
+                    FreeLibrary( hInst );
+                }
+
+                pszProxyName = pszNextProxyName;
+            }
+
+            if (bStartedProxy == FALSE)
+            {
+                //
+                // Alert tapisrv that it needs to free the ReqMakeCall inst
+                //
+
+                FUNC_ARGS funcArgs =
+                {
+                    MAKELONG (TAPI_FUNC | SYNC | 7, tRequestMakeCall),
+
+                    {
+                        (DWORD) 0,
+                        (DWORD) 0,
+                        (DWORD) 0,
+                        (DWORD) 0,
+                        (DWORD) 0,
+                        (DWORD) hRequestMakeCallAttempted,
+                        (DWORD) 0
+                    },
+
+                    {
+                        Dword,
+                        Dword,
+                        Dword,
+                        Dword,
+                        Dword,
+                        Dword,
+                        Dword,
+                    }
+                };
+
+
+                DBGOUT((
+                    1,
+                    "tapiRequestMakeCall: failed to start proxy, " \
+                        "deleting request"
+                    ));
+
+                lResult = DOFUNC (&funcArgs, "tapiRequestMakeCall_cleanup");
+            }
+        }
+    }
+
+    ClientFree (pProxyList);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiRequestMakeCallA(
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszAppName,
+    LPCSTR  lpszCalledParty,
+    LPCSTR  lpszComment
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr1;
+    PWSTR   szTempPtr2;
+    PWSTR   szTempPtr3;
+    PWSTR   szTempPtr4;
+
+
+    if (IsBadStringPtrA (lpszDestAddress, (DWORD) -1) ||
+        (lstrlenA (lpszDestAddress) + 1) > TAPIMAXDESTADDRESSSIZE)
+    {
+        return TAPIERR_INVALDESTADDRESS;
+    }
+
+    if ((lpszAppName && IsBadStringPtrA (lpszAppName, (DWORD) -1)) ||
+        (lpszCalledParty && IsBadStringPtrA (lpszCalledParty, (DWORD) -1)) ||
+        (lpszComment && IsBadStringPtrA (lpszComment, (DWORD) -1)))
+    {
+        return TAPIERR_INVALPOINTER;
+    }
+
+    szTempPtr1= NotSoWideStringToWideString (lpszDestAddress, (DWORD) -1);
+    szTempPtr2= NotSoWideStringToWideString (lpszAppName, (DWORD) -1);
+    szTempPtr3= NotSoWideStringToWideString (lpszCalledParty, (DWORD) -1);
+    szTempPtr4= NotSoWideStringToWideString (lpszComment, (DWORD) -1);
+
+    lResult = tapiRequestMakeCallW(
+        szTempPtr1,
+        szTempPtr2,
+        szTempPtr3,
+        szTempPtr4
+        );
+
+    ClientFree (szTempPtr1);
+
+    if (szTempPtr2)
+    {
+        ClientFree (szTempPtr2);
+    }
+
+    if (szTempPtr3)
+    {
+        ClientFree (szTempPtr3);
+    }
+
+    if (szTempPtr4)
+    {
+        ClientFree (szTempPtr4);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiRequestMakeCall(
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszAppName,
+    LPCSTR  lpszCalledParty,
+    LPCSTR  lpszComment
+    )
+{
+    return tapiRequestMakeCallA(
+              lpszDestAddress,
+              lpszAppName,
+              lpszCalledParty,
+              lpszComment
+    );
+}    
+
+
+LONG
+WINAPI
+tapiRequestMediaCallW(
+    HWND    hWnd,
+    WPARAM  wRequestID,
+    LPCWSTR lpszDeviceClass,
+    LPCWSTR lpDeviceID,
+    DWORD   dwSize,
+    DWORD   dwSecure,
+    LPCWSTR lpszDestAddress,
+    LPCWSTR lpszAppName,
+    LPCWSTR lpszCalledParty,
+    LPCWSTR lpszComment
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (TAPI_FUNC | SYNC | 10, tRequestMediaCall),
+
+        {
+            (DWORD) hWnd,
+            (DWORD) wRequestID,
+            (DWORD) lpszDeviceClass,
+            (DWORD) lpDeviceID,
+            dwSize,
+            dwSecure,
+            (DWORD) lpszDestAddress,
+            (DWORD) lpszAppName,
+            (DWORD) lpszCalledParty,
+            (DWORD) lpszComment,
+        },
+
+        {
+            Hwnd,
+            Dword,
+            lpszW,
+            lpGet_SizeToFollow,
+            Size,
+            Dword,
+            lpszW,
+            lpszW,
+            lpszW,
+            lpszW
+        }
+    };
+
+
+    if (IsBadStringPtrW (lpszDeviceClass, (UINT) -1) ||
+        (lstrlenW (lpszDeviceClass) + 1) > TAPIMAXDEVICECLASSSIZE)
+    {
+        return TAPIERR_INVALDEVICECLASS;
+    }
+
+    if (IsBadWritePtr ((LPVOID) lpDeviceID, dwSize) ||
+        dwSize > (TAPIMAXDEVICEIDSIZE * sizeof (WCHAR)))
+    {
+        return TAPIERR_INVALDEVICEID;
+    }
+
+    if (IsBadStringPtrW (lpszDestAddress, (UINT) -1) ||
+        (lstrlenW (lpszDestAddress) + 1) > TAPIMAXDESTADDRESSSIZE)
+    {
+        return TAPIERR_INVALDESTADDRESS;
+    }
+
+    if (!lpszAppName)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[7] = Dword;
+        funcArgs.Args[7]     = TAPI_NO_DATA;
+    }
+
+    if (!lpszCalledParty)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[8] = Dword;
+        funcArgs.Args[8]     = TAPI_NO_DATA;
+    }
+
+    if (!lpszComment)
+    {
+        //
+        // Reset Arg & ArgType so no inval ptr err, & TAPI_NO_DATA is indicated
+        //
+
+        funcArgs.ArgTypes[9] = Dword;
+        funcArgs.Args[9]     = TAPI_NO_DATA;
+    }
+
+    return (DOFUNC (&funcArgs, "tapiRequestMediaCall"));
+}
+
+
+LONG
+WINAPI
+tapiRequestMediaCallA(
+    HWND    hWnd,
+    WPARAM  wRequestID,
+    LPCSTR  lpszDeviceClass,
+    LPCSTR  lpDeviceID,
+    DWORD   dwSize,
+    DWORD   dwSecure,
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszAppName,
+    LPCSTR  lpszCalledParty,
+    LPCSTR  lpszComment
+    )
+{
+    LONG    lResult;
+    PWSTR   szTempPtr1, szTempPtr2, szTempPtr3,
+            szTempPtr4, szTempPtr5, szTempPtr6;
+
+
+    if (IsBadStringPtrA (lpszDeviceClass, (UINT) -1) ||
+        (lstrlenA (lpszDeviceClass) + 1) > TAPIMAXDEVICECLASSSIZE)
+    {
+        return TAPIERR_INVALDEVICECLASS;
+    }
+    else
+    {
+        szTempPtr1 = NotSoWideStringToWideString(
+            lpszDeviceClass,
+            (DWORD) -1
+            );
+    }
+
+    if (IsBadWritePtr ((LPVOID) lpDeviceID, dwSize) ||
+        dwSize > TAPIMAXDEVICEIDSIZE)
+    {
+        return TAPIERR_INVALDEVICEID;
+    }
+    else
+    {
+        dwSize *= 2;
+        szTempPtr2 = ClientAlloc (dwSize);
+    }
+
+    if (IsBadStringPtrA (lpszDestAddress, (UINT) -1) ||
+        (lstrlenA (lpszDestAddress) + 1) > TAPIMAXDESTADDRESSSIZE)
+    {
+        return TAPIERR_INVALDESTADDRESS;
+    }
+    else
+    {
+        szTempPtr3 = NotSoWideStringToWideString(
+            lpszDestAddress,
+            (DWORD) -1
+            );
+    }
+
+    if ((lpszAppName && IsBadStringPtrA (lpszAppName, (UINT) -1)) ||
+        (lpszCalledParty && IsBadStringPtrA (lpszCalledParty, (UINT) -1)) ||
+        (lpszComment && IsBadStringPtrA (lpszComment, (UINT) -1)))
+    {
+        return TAPIERR_INVALPOINTER;
+    }
+
+    szTempPtr4 = NotSoWideStringToWideString (lpszAppName, (DWORD) -1);
+    szTempPtr5 = NotSoWideStringToWideString (lpszCalledParty, (DWORD) -1);
+    szTempPtr6 = NotSoWideStringToWideString (lpszComment, (DWORD) -1);
+
+    lResult = tapiRequestMediaCallW(
+        hWnd,
+        wRequestID,
+        szTempPtr1,
+        szTempPtr2,
+        dwSize,
+        dwSecure,
+        szTempPtr3,
+        szTempPtr4,
+        szTempPtr5,
+        szTempPtr6
+        );
+
+    if (szTempPtr1)
+    {
+        ClientFree (szTempPtr1);
+    }
+
+    if (szTempPtr2)
+    {
+        ClientFree (szTempPtr2);
+    }
+
+    if (szTempPtr3)
+    {
+        ClientFree (szTempPtr3);
+    }
+
+    if (szTempPtr4)
+    {
+        ClientFree (szTempPtr4);
+    }
+
+    if (szTempPtr5)
+    {
+        ClientFree (szTempPtr5);
+    }
+
+    if (szTempPtr6)
+    {
+        ClientFree (szTempPtr6);
+    }
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiRequestMediaCall(
+    HWND    hWnd,
+    WPARAM  wRequestID,
+    LPCSTR  lpszDeviceClass,
+    LPCSTR  lpDeviceID,
+    DWORD   dwSize,
+    DWORD   dwSecure,
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszAppName,
+    LPCSTR  lpszCalledParty,
+    LPCSTR  lpszComment
+    )
+{
+    return  tapiRequestMediaCallA(
+                 hWnd,
+                 wRequestID,
+                 lpszDeviceClass,
+                 lpDeviceID,
+                 dwSize,
+                 dwSecure,
+                 lpszDestAddress,
+                 lpszAppName,
+                 lpszCalledParty,
+                 lpszComment
+    );
+}
+
+
+//
+// ----------------------------------------------------------------------------
+//
+
+LONG
+WINAPI
+GetTapi16CallbackMsg(
+    PINIT_DATA  pInitData,
+    LPDWORD     pMsg
+    )
+{
+    LONG lResult = 0;
+
+
+    DBGOUT((3, "GetTapi16CallbackMsg: enter"));
+
+    EnterCriticalSection (&gCriticalSection);
+
+    try
+    {
+        if ((DWORD) pInitData & 0x7 || pInitData->dwKey != INITDATA_KEY)
+        {
+            goto GetTapi16CallbackMsg_leaveCritSec;
+        }
+    }
+    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        goto GetTapi16CallbackMsg_leaveCritSec;
+    }
+
+    if (pInitData->dwNumUsedEntries > 0)
+    {
+        CopyMemory(
+            pMsg,
+            pInitData->pValidEntry,
+            sizeof(ASYNC_EVENT_PARAMS)
+            );
+
+        pInitData->pValidEntry++;
+
+        if (pInitData->pValidEntry >= (pInitData->pEventBuffer +
+                pInitData->dwNumTotalEntries))
+        {
+            pInitData->pValidEntry = pInitData->pEventBuffer;
+        }
+
+        pInitData->dwNumUsedEntries--;
+
+        if (pInitData->dwNumUsedEntries == 0)
+        {
+            pInitData->bPendingAsyncEventMsg = FALSE;
+        }
+
+        lResult = 1;
+    }
+
+GetTapi16CallbackMsg_leaveCritSec:
+
+    LeaveCriticalSection (&gCriticalSection);
+
+    DBGOUT((3, "GetTapi16CallbackMsg: exit (result=x%x)", lResult));
+
+    return lResult;
+}
+
+
+
+
+//
+// ----------------------- Private support routines ---------------------------
+//
+
+void
+FreeInitData(
+    PINIT_DATA  pInitData
+    )
+{
+    if (pInitData)
+    {
+        EnterCriticalSection (&gCriticalSection);
+
+        pInitData->dwKey = 0xefefefef;
+
+        LeaveCriticalSection (&gCriticalSection);
+
+        if (pInitData->dwInitOptions == LINEINITIALIZEEXOPTION_USEEVENT)
+        {
+            if (pInitData->hEvent)
+            {
+                //
+                // Signal the event to release any threads which might
+                // be waiting on it, then close the handle
+                //
+
+                SetEvent (pInitData->hEvent);
+                CloseHandle (pInitData->hEvent);
+            }
+        }
+        else if (pInitData->dwInitOptions ==
+                    LINEINITIALIZEEXOPTION_USEHIDDENWINDOW)
+        {
+            // NOTE: let thunk destroy it's own window
+
+            if (pInitData->hwnd && !gbNTVDMClient)
+            {
+                DestroyWindow (pInitData->hwnd);
+            }
+        }
+
+        if (pInitData->pEventBuffer)
+        {
+            ClientFree (pInitData->pEventBuffer);
+        }
+
+        ClientFree (pInitData);
+    }
+}
+
+
+LONG
+CreateHiddenWindow(
+    HWND   *lphwnd,
+    DWORD   dwErrorClass
+    )
+{
+    LONG lResult = 0;
+
+
+    if (!gbResourcesAllocated)
+    {
+        if ((lResult = AllocClientResources (dwErrorClass)) != 0)
+        {
+            return lResult;
+        }
+    }
+
+    if (!(*lphwnd = CreateWindow(
+            szTapi32WndClass,   // class name
+            gszNullString,      // title
+            0,                  // style
+            0,                  // x
+            0,                  // y
+            0,                  // width
+            0,                  // height
+            (HWND) NULL,        // parent wnd
+            (HMENU) NULL,       // menu
+            ghInst,             // instance
+            NULL                // params
+            )))
+    {
+        DBGOUT((1, "CreateWindow failed, err=%ld", GetLastError()));
+
+        lResult = gaOpFailedErrors[dwErrorClass];
+    }
+
+    return lResult;
+}
+
+
+BOOL
+CALLBACK
+TAPIWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_ASYNCEVENT:
+    {
+        BOOL                bFirstPass = TRUE, bPostMsg;
+        PINIT_DATA          pInitData = (PINIT_DATA) lParam;
+
+
+        DBGOUT((3, "TAPIWndProc: received WM_ASYNCEVENT, hwnd=x%lx", hwnd));
+
+        while (1)
+        {
+            //
+            // Enter the critical section, verify the pInitData, and
+            // see if there are any events in in the queue to process.
+            // If so, remove an event from the queue, adjust the
+            // ptrs & count, leave the critical section, and call
+            // the callback.
+            //
+            // Note that there is some tricky stuff below to insure
+            // that there is always another outstanding WM_ASYNCEVENT
+            // msg prior to calling the app's callback (if there are)
+            // any more events inthe queue.  This is necessary because
+            // some ill-behaved apps have msg loops (to synchronously
+            // wait for async request results, etc) within their
+            // callbacks, and we don't want to block sending any msgs
+            // to them.
+            //
+
+            DBGOUT((11, "Trying to grab critical section (0x%08lx) in wndproc", gCriticalSection));
+            EnterCriticalSection (&gCriticalSection);
+            DBGOUT((11, "Got critical section (0x%08lx) in wndproc", gCriticalSection));
+
+            try
+            {
+                if (pInitData->dwKey != INITDATA_KEY)
+                {
+                    DBGOUT((4, "TAPIWndProc: bad pInitInst (x%x)", pInitData));
+                    DBGOUT((11, "releasing critical section (0x%08lx) in wndproc1", gCriticalSection));
+                    LeaveCriticalSection (&gCriticalSection);
+                    break;
+                }
+            }
+            except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                    EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+            {
+                DBGOUT((4, "TAPIWndProc: bad pInitInst (x%x)", pInitData));
+                DBGOUT((11, "releasing critical section (0x%08lx) in wndproc2", gCriticalSection));
+                LeaveCriticalSection (&gCriticalSection);
+                break;
+            }
+
+            if (bFirstPass)
+            {
+                pInitData->bPendingAsyncEventMsg = FALSE;
+                bFirstPass = FALSE;
+            }
+
+            if (pInitData->dwNumUsedEntries != 0)
+            {
+                ASYNC_EVENT_PARAMS   event;
+
+
+                CopyMemory(
+                    &event,
+                    pInitData->pValidEntry,
+                    sizeof (ASYNC_EVENT_PARAMS)
+                    );
+
+                pInitData->pValidEntry++;
+
+                if (pInitData->pValidEntry >= (pInitData->pEventBuffer +
+                        pInitData->dwNumTotalEntries))
+                {
+                    pInitData->pValidEntry = pInitData->pEventBuffer;
+                }
+
+                pInitData->dwNumUsedEntries--;
+
+                if (pInitData->dwNumUsedEntries != 0 &&
+                    pInitData->bPendingAsyncEventMsg == FALSE)
+                {
+                    bPostMsg = TRUE;
+                    pInitData->bPendingAsyncEventMsg = TRUE;
+                }
+
+                DBGOUT((11, "releasing critical section (0x%08lx) in wndproc3", gCriticalSection));
+                LeaveCriticalSection (&gCriticalSection);
+
+                DBGOUT((
+                    3,
+                    "Calling app's callback, hDev=x%x, "\
+                        "Msg=%d, dwInst=x%lx P1=x%lx, P2=x%x P3=x%lx",
+                    event.hDevice,
+                    event.dwMsg,
+                    event.dwCallbackInstance,
+                    event.dwParam1,
+                    event.dwParam2,
+                    event.dwParam3
+                    ));
+
+                if (bPostMsg)
+                {
+                    PostMessage (hwnd, WM_ASYNCEVENT, wParam, lParam);
+                }
+
+                (*pInitData->lpfnCallback)(
+                    event.hDevice,
+                    event.dwMsg,
+                    event.dwCallbackInstance,
+                    event.dwParam1,
+                    event.dwParam2,
+                    event.dwParam3
+                    );
+            }
+            else
+            {
+                DBGOUT((11, "No entries - spurious entry."));
+                DBGOUT((11, "releasing critical section (0x%08lx) in wndproc4", gCriticalSection));
+
+                LeaveCriticalSection (&gCriticalSection);
+
+                break;
+            }
+        }
+
+        return FALSE;
+    }
+    default:
+
+        break;
+    }
+
+    return (DefWindowProc (hwnd, msg, wParam, lParam));
+}
+
+
+void __RPC_FAR * __RPC_API midl_user_allocate(size_t len)
+{
+    DBGOUT((11, "midl_user_allocate: enter, size=x%x", len));
+
+    return (ClientAlloc (len));
+}
+
+
+void __RPC_API midl_user_free(void __RPC_FAR * ptr)
+{
+    DBGOUT((11, "midl_user_free: enter, p=x%x", ptr));
+
+    ClientFree (ptr);
+}
+
+
+
+LONG
+WINAPI
+AllocClientResources(
+    DWORD dwErrorClass
+    )
+{
+    DWORD           dwExceptionCount = 0;
+    LONG            lResult = gaOpFailedErrors[dwErrorClass];
+    SC_HANDLE       hSCMgr, hTapiSrv;
+
+
+//    DBGOUT((3, "AllocClientResources: enter"));
+
+
+    if (gbResourcesAllocated)
+    {
+        return TAPI_SUCCESS;
+    }
+
+
+    //
+    // Serialize the following init code
+    //
+
+    WaitForSingleObject (ghInitMutex, INFINITE);
+
+    if (gbResourcesAllocated)
+    {
+        lResult = TAPI_SUCCESS;
+
+        goto AllocClientResources_return;
+    }
+
+
+    //
+    // Register the hidden window class
+    //
+
+    {
+        DWORD       dwError;
+        WNDCLASS    wndclass;
+
+
+        ZeroMemory(&wndclass, sizeof(WNDCLASS));
+
+        wndclass.lpfnWndProc   = (WNDPROC) TAPIWndProc;
+        wndclass.hInstance     = ghInst;
+        wndclass.lpszClassName = szTapi32WndClass;
+
+        if (!RegisterClass (&wndclass) &&
+            ((dwError = GetLastError()) != ERROR_CLASS_ALREADY_EXISTS))
+        {
+           DBGOUT((
+               3,
+               "AllocClientResources: RegisterClass failed, err=%d",
+               dwError
+               ));
+        }
+    }
+
+
+    //
+    // Start the TAPISRV.EXE service
+    //
+
+    if (!(GetVersion() & 0x80000000)) // Win NT
+    {
+        if ((hSCMgr = OpenSCManager(
+                NULL,               // local machine
+                NULL,               // ServicesActive database
+                SC_MANAGER_CONNECT  // desired access
+                )) == NULL)
+        {
+            DBGOUT((1, "OpenSCManager failed, err=%d", GetLastError()));
+
+            goto AllocClientResources_return;
+        }
+
+        if ((hTapiSrv = OpenService(
+                hSCMgr,                 // SC mgr handle
+                (LPCTSTR) "TAPISRV",    // name of service to open
+                SERVICE_START |         // desired access
+                    SERVICE_QUERY_STATUS
+                )) == NULL)
+        {
+            DBGOUT((1, "OpenService failed, err=%d", GetLastError()));
+
+            goto AllocClientResources_cleanup1;
+        }
+
+AllocClientResources_queryServiceStatus:
+
+        {
+            #define MAX_NUM_SECONDS_TO_WAIT_FOR_TAPISRV 180
+
+            DWORD   dwNumSecondsSleptStartPending = 0,
+                    dwNumSecondsSleptStopPending = 0;
+
+            while (1)
+            {
+                SERVICE_STATUS  status;
+
+                
+                QueryServiceStatus (hTapiSrv, &status);
+
+                switch (status.dwCurrentState)
+                {
+                case SERVICE_RUNNING:
+
+                    DBGOUT((3, "Tapisrv running"));
+                    goto AllocClientResources_attachToServer;
+
+                case SERVICE_START_PENDING:
+
+                    Sleep (1000);
+
+                    if (++dwNumSecondsSleptStartPending >
+                            MAX_NUM_SECONDS_TO_WAIT_FOR_TAPISRV)
+                    {
+                        DBGOUT((
+                            1,
+                            "ERROR: Tapisrv stuck SERVICE_START_PENDING"
+                            ));
+
+                        goto AllocClientResources_cleanup2;
+                    }
+
+                    break;
+
+                case SERVICE_STOP_PENDING:
+
+                    Sleep (1000);
+
+                    if (++dwNumSecondsSleptStopPending >
+                            MAX_NUM_SECONDS_TO_WAIT_FOR_TAPISRV)
+                    {
+                        DBGOUT((
+                            1,
+                            "ERROR: Tapisrv stuck SERVICE_STOP_PENDING"
+                            ));
+
+                        goto AllocClientResources_cleanup2;
+                    }
+
+                    break;
+
+                case SERVICE_STOPPED:
+
+                    DBGOUT((3, "Starting tapisrv (NT)..."));
+
+                    if (!StartService(
+                            hTapiSrv,   // service handle
+                            0,          // num args
+                            NULL        // args
+                            ))
+                    {
+                        DWORD dwLastError = GetLastError();
+
+
+                        if (dwLastError != ERROR_SERVICE_ALREADY_RUNNING)
+                        {
+                            DBGOUT((
+                                1,
+                                "StartService(TapiSrv) failed, err=%d",
+                                dwLastError
+                                ));
+
+                            goto AllocClientResources_cleanup2;
+                        }
+                    }
+
+                    break;
+
+                default:
+
+                    DBGOUT((
+                        1,
+                        "error, service status=%d",
+                        status.dwCurrentState
+                        ));
+
+                    goto AllocClientResources_cleanup2;
+                }
+            }
+        }
+    }
+    else // Win95
+    {
+        HANDLE  hMutex, hEvent;
+
+
+        //
+        // First grab the global mutex that serializes the following
+        // across all instances of tapi32.dll
+        //
+
+        if (!(hMutex = CreateMutex (NULL, FALSE, "StartTapiSrv")))
+        {
+            DBGOUT((
+                3,
+                "CreateMutex ('StartTapiSrv') failed, err=%d",
+                GetLastError()
+                ));
+        }
+
+        WaitForSingleObject (hMutex, INFINITE);
+
+
+        //
+        // Try to open the event that tells us tapisrv has inited
+        //
+
+        if (!(hEvent = OpenEvent (EVENT_ALL_ACCESS, TRUE, "TapiSrvInited")))
+        {
+            //
+            // OpenEvent failed, so tapisrv hasn't been started yet.  Start
+            // tapisrv, and then get the event handle.
+            //
+
+            STARTUPINFO startupInfo;
+            PROCESS_INFORMATION processInfo;
+
+
+            DBGOUT((
+                3,
+                "OpenEvent ('TapiSrvInited') failed, err=%d",
+                GetLastError()
+                ));
+
+            ZeroMemory(&startupInfo, sizeof (STARTUPINFO));
+
+            startupInfo.cb = sizeof (STARTUPINFO);
+
+            DBGOUT((4, "Starting tapisrv (Win95)..."));
+
+            if (!CreateProcess(
+                    NULL,                   // image name
+                    "tapisrv.exe",          // cmd line
+                    NULL,                   // process security attrs
+                    NULL,                   // thread security attrs
+                    FALSE,                  // inherit handles
+                    NORMAL_PRIORITY_CLASS,  // create opts
+                    NULL,                   // environment
+                    NULL,                   // curr dir
+                    &startupInfo,
+                    &processInfo
+                    ))
+            {
+                DBGOUT((
+                    1,
+                    "CreateProcess('tapisrv.exe') failed, err=%d",
+                    GetLastError()
+                    ));
+            }
+            else
+            {
+                CloseHandle (processInfo.hProcess);
+                CloseHandle (processInfo.hThread);
+            }
+
+            if (!(hEvent = CreateEvent (NULL, TRUE, FALSE, "TapiSrvInited")))
+            {
+                DBGOUT((
+                    1,
+                    "CreateEvent ('TapiSrvInited') failed, err=%d",
+                    GetLastError()
+                    ));
+            }
+
+        }
+
+
+        //
+        // Now wait on the event (it's will be signaled when tapisrv has
+        // completed it's initialization).  Then clean up.
+        //
+
+        WaitForSingleObject (hEvent, INFINITE);
+        CloseHandle (hEvent);
+
+        ReleaseMutex (hMutex);
+        CloseHandle (hMutex);
+    }
+
+
+    //
+    // Init the RPC connection
+    //
+
+AllocClientResources_attachToServer:
+
+    {
+        #define CNLEN              25   // computer name length
+        #define UNCLEN        CNLEN+2   // \\computername
+        #define PATHLEN           260   // Path
+        #define MAXPROTSEQ         20   // protocol sequence "ncacn_np"
+
+        BOOL            bException = FALSE;
+        RPC_STATUS      status;
+        unsigned char   pszNetworkAddress[UNCLEN+1];
+        unsigned char *pszUuid          = NULL;
+        unsigned char *pszOptions       = NULL;
+        unsigned char *pszStringBinding = NULL;
+        DWORD          dwProcessID = GetCurrentProcessId(), dwSize = 256;
+        WCHAR         *pszUserName = ClientAlloc (dwSize * sizeof(WCHAR) );
+
+
+        pszNetworkAddress[0] = '\0';
+
+        status = RpcStringBindingCompose(
+            pszUuid,
+            "ncalrpc",
+            pszNetworkAddress,
+            "tapsrvlpc",
+            pszOptions,
+            &pszStringBinding
+            );
+
+        if (status)
+        {
+            DBGOUT((
+                1,
+                "RpcStringBindingCompose failed: err=%d, szNetAddr='%s'",
+                status,
+                pszNetworkAddress
+                ));
+        }
+
+        status = RpcBindingFromStringBinding(
+            pszStringBinding,
+            &hTapSrv
+            );
+
+        if (status)
+        {
+            DBGOUT((
+                1,
+                "RpcBindingFromStringBinding failed, err=%d, szBinding='%s'",
+                status,
+                pszStringBinding
+                ));
+        }
+
+        GetUserNameW(pszUserName, &dwSize);
+
+        RpcTryExcept
+        {
+            DBGOUT((4, "AllocCliRes: calling ClientAttach..."));
+
+            lResult = ClientAttach(
+                (PCONTEXT_HANDLE_TYPE *) &gphCx,
+                dwProcessID,
+                (long *) &ghAsyncEventsEvent,
+                pszUserName,
+                L""
+                );
+
+            DBGOUT((4, "AllocCliRes: ClientAttach returned x%x", lResult));
+        }
+        RpcExcept (1)
+        {
+            DBGOUT((
+                4,
+                "AllocCliRes: ClientAttach caused except=%d",
+                RpcExceptionCode()
+                ));
+            bException = TRUE;
+        }
+        RpcEndExcept
+
+        ClientFree (pszUserName);
+
+        RpcBindingFree (&hTapSrv);
+        
+//            DBGOUT((
+//                3,
+//                "AllocCliRes: gphCx=x%x, PID=x%x, hAEEvent=x%x",
+//                gphCx,
+//                dwProcessID,
+//                ghAsyncEventsEvent
+//                ));
+
+        RpcStringFree(&pszStringBinding);
+
+        if (bException)
+        {
+            //
+            // If here chances are that we started the service and it's
+            // not ready to receive rpc requests. So we'll give it a
+            // little time to get rolling and then try again.
+            //
+
+            if (dwExceptionCount < gdwMaxNumRequestRetries)
+            {
+                Sleep ((++dwExceptionCount > 1 ? gdwRequestRetryTimeout : 0));
+                goto AllocClientResources_queryServiceStatus;
+            }
+            else
+            {
+                DBGOUT((
+                    1,
+                    "AllocCliRes: ClientAttach failed, result=x%x",
+                    gaOpFailedErrors[dwErrorClass]
+                    ));
+
+                lResult = gaOpFailedErrors[dwErrorClass];
+            }
+        }
+    }
+
+    if (lResult == 0)
+    {
+        gbResourcesAllocated = TRUE;
+    }
+
+
+AllocClientResources_cleanup2:
+
+    if (!(GetVersion() & 0x80000000)) // Win NT
+    {
+        CloseServiceHandle (hTapiSrv);
+    }
+
+AllocClientResources_cleanup1:
+
+    if (!(GetVersion() & 0x80000000)) // Win NT
+    {
+        CloseServiceHandle (hSCMgr);
+    }
+
+AllocClientResources_return:
+
+    ReleaseMutex (ghInitMutex);
+
+//    DBGOUT((3, "AllocClientResources: exit, returning x%x", lResult));
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+xxxShutdown(
+    DWORD   hXXXApp,
+    BOOL    bLineShutdown
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 1, (bLineShutdown ? lShutdown: pShutdown)),
+
+        {
+            hXXXApp
+        },
+
+        {
+            hXxxApp
+        }
+    };
+    LONG lResult;
+
+
+    //
+    // BUGBUG Sync all inits & shutdowns for now (so we don't have problems
+    //        with the async msgs thread going away)
+    //
+
+    WaitForSingleObject (ghInitMutex, INFINITE);
+
+    lResult = DOFUNC(
+        &funcArgs,
+        (bLineShutdown ? "lineShutdown" : "phoneShutdown")
+        );
+
+    if (lResult == 0)
+    {
+        FreeInitData ((PINIT_DATA) hXXXApp);
+
+        gdwNumInits--;
+
+        if (gdwNumInits == 0)
+        {
+            //
+            // Tell the async events thread to quit
+            //
+
+            gpAsyncEventsThreadParams->bExitThread = TRUE;
+            SetEvent (ghAsyncEventsEvent);
+            gpAsyncEventsThreadParams = NULL;
+
+
+            //
+            // Safely close any existing generic dialog instances
+            //
+
+            EnterCriticalSection (&gCriticalSection);
+
+            if (gpUIThreadInstances)
+            {
+                PUITHREADDATA   pUIThreadData, pNextUIThreadData;
+
+
+                pUIThreadData = gpUIThreadInstances;
+
+                while (pUIThreadData)
+                {
+                    //
+                    // Grab a ptr to the next UIThreadData while it's still
+                    // safe, wait until the ui dll has indicated that it
+                    // is will to receive generic dlg data, then pass it
+                    // NULL/0 to tell it to shutdown the dlg inst
+                    //
+
+                    pNextUIThreadData = pUIThreadData->pNext;
+
+                    WaitForSingleObject (pUIThreadData->hEvent, INFINITE);
+
+                    DBGOUT((
+                        3,
+                        "xxxShutdown: calling " \
+                            "TUISPI_providerGenericDialogData..."
+                        ));
+
+                    (*pUIThreadData->pfnTUISPI_providerGenericDialogData)(
+                        pUIThreadData->htDlgInst,
+                        NULL,
+                        0
+                        );
+
+                    DBGOUT((
+                        3,
+                        "xxxShutdown: " \
+                            "TUISPI_providerGenericDialogData returned"
+                        ));
+
+                    pUIThreadData = pNextUIThreadData;
+                }
+            }
+
+            LeaveCriticalSection (&gCriticalSection);
+        }
+    }
+
+    ReleaseMutex (ghInitMutex);
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+xxxGetMessage(
+    BOOL            bLine,
+    PINIT_DATA      pInitData,
+    LPLINEMESSAGE   pMsg,
+    DWORD           dwTimeout
+    )
+{
+    LONG    lResult;
+    BOOL    bInCriticalSection = FALSE;
+
+
+// BUGBUG xxxGetMessage: spec a new TIMEOUT error?
+// BUGBUG xxxGetMessage: no difference in keys between lineApp & phoneApp
+
+    if (IsBadWritePtr (pMsg, sizeof (LINEMESSAGE)))
+    {
+        lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+        goto xxxGetMessage_return;
+    }
+
+    try
+    {
+        if (((DWORD) pInitData) & 0x7  ||  pInitData->dwKey != INITDATA_KEY)
+        {
+            lResult = (bLine ? LINEERR_INVALAPPHANDLE :
+                PHONEERR_INVALAPPHANDLE);
+            goto xxxGetMessage_return;
+        }
+
+        if (pInitData->dwInitOptions != LINEINITIALIZEEXOPTION_USEEVENT)
+        {
+            lResult = (bLine ? LINEERR_INVALAPPHANDLE :
+                PHONEERR_INVALAPPHANDLE);
+            goto xxxGetMessage_return;
+        }
+
+        if (pInitData->dwNumUsedEntries)
+        {
+            EnterCriticalSection (&gCriticalSection);
+            bInCriticalSection = TRUE;
+
+            if (pInitData->dwKey == INITDATA_KEY)
+            {
+                if (pInitData->dwNumUsedEntries)
+                {
+                    CopyMemory(
+                        pMsg,
+                        pInitData->pValidEntry,
+                        sizeof (ASYNC_EVENT_PARAMS)
+                        );
+
+                    pInitData->pValidEntry++;
+
+                    if (pInitData->pValidEntry >= (pInitData->pEventBuffer +
+                            pInitData->dwNumTotalEntries))
+                    {
+                        pInitData->pValidEntry = pInitData->pEventBuffer;
+                    }
+
+                    pInitData->dwNumUsedEntries--;
+
+
+                    //
+                    // If the buffer is empty then reset the event
+                    // to nonsignaled
+                    //
+
+                    if (pInitData->dwNumUsedEntries == 0)
+                    {
+                        ResetEvent (pInitData->hEvent);
+                    }
+
+                    lResult = 0;
+                }
+                else
+                {
+                    lResult = (bLine ? LINEERR_OPERATIONFAILED :
+                        PHONEERR_OPERATIONFAILED);
+                }
+            }
+            else
+            {
+                lResult = (bLine ? LINEERR_INVALAPPHANDLE :
+                    PHONEERR_INVALAPPHANDLE);
+            }
+
+            LeaveCriticalSection (&gCriticalSection);
+            bInCriticalSection = FALSE;
+        }
+        else
+        {
+            lResult = (bLine ? LINEERR_OPERATIONFAILED :
+                PHONEERR_OPERATIONFAILED);
+        }
+
+        if (dwTimeout != 0 && lResult != 0)
+        {
+xxxGetMessage_wait:
+
+            switch (WaitForSingleObject (pInitData->hEvent, dwTimeout))
+            {
+            case WAIT_OBJECT_0:
+
+                EnterCriticalSection (&gCriticalSection);
+                bInCriticalSection = TRUE;
+
+                if (pInitData->dwKey == INITDATA_KEY)
+                {
+                    if (pInitData->dwNumUsedEntries)
+                    {
+                        CopyMemory(
+                            pMsg,
+                            pInitData->pValidEntry,
+                            sizeof (ASYNC_EVENT_PARAMS)
+                            );
+
+                        pInitData->pValidEntry++;
+
+                        if (pInitData->pValidEntry >= (pInitData->pEventBuffer+
+                                pInitData->dwNumTotalEntries))
+                        {
+                            pInitData->pValidEntry = pInitData->pEventBuffer;
+                        }
+
+                        pInitData->dwNumUsedEntries--;
+
+
+                        //
+                        // If the buffer is empty then reset the event
+                        // to nonsignaled
+                        //
+
+                        if (pInitData->dwNumUsedEntries == 0)
+                        {
+                            ResetEvent (pInitData->hEvent);
+                        }
+                    
+                        //
+                        // Everything looks good, now.
+                        //
+                        lResult = 0;
+                    }
+                    else if (dwTimeout == INFINITE)
+                    {
+// BUGBUG xxxGetMessage: might want to decr dwTimeout in non-INFINITE case
+
+                        LeaveCriticalSection (&gCriticalSection);
+                        bInCriticalSection = FALSE;
+                        goto xxxGetMessage_wait;
+                    }
+                }
+                else
+                {
+                    lResult = (bLine ? LINEERR_INVALAPPHANDLE :
+                        PHONEERR_INVALAPPHANDLE);
+                }
+
+                LeaveCriticalSection (&gCriticalSection);
+                bInCriticalSection = FALSE;
+
+                break;
+
+            case WAIT_TIMEOUT:
+            default:
+
+                lResult = (bLine ? LINEERR_OPERATIONFAILED :
+                    PHONEERR_OPERATIONFAILED);
+            }
+        }
+    }
+    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        if (bInCriticalSection)
+        {
+            LeaveCriticalSection (&gCriticalSection);
+        }
+
+        lResult = (bLine ? LINEERR_INVALAPPHANDLE : PHONEERR_INVALAPPHANDLE);
+    }
+
+xxxGetMessage_return:
+
+#if DBG
+    {
+        char    szResult[32],
+               *pszFuncName = (bLine ? "lineGetMessage" : "phoneGetMessage");
+
+
+        if (lResult == 0)
+        {
+            DBGOUT((
+                3,
+                "%s: exit, returning msg=%s\n",
+                    "\thDev=x%x, dwInst=x%x, p1=x%x, p2=x%x, p3=x%x",
+                aszMsgs[pMsg->dwMessageID],
+                pMsg->hDevice,
+                pMsg->dwCallbackInstance,
+                pMsg->dwParam1,
+                pMsg->dwParam2,
+                pMsg->dwParam3
+                ));
+        }
+        else
+        {
+            DBGOUT((
+                3,
+                "%s: exit, result=%s",
+                pszFuncName,
+                MapResultCodeToText (lResult, szResult)
+                ));
+        }
+    }
+#endif
+
+    return lResult;
+}
+
+
+LPVOID
+WINAPI
+ClientAlloc(
+    DWORD   dwSize
+    )
+{
+    LPBYTE  p;
+    LPDWORD pAligned;
+
+
+    //
+    // Alloc 16 extra bytes so we can make sure the pointer we pass back
+    // is 64-bit aligned & have space to store the original pointer
+    //
+
+    if ((p = (LPBYTE) LocalAlloc (LPTR, dwSize + 16)))
+    {
+        pAligned = (LPDWORD) (p + 8 - (((DWORD) p) & 0x7));
+        *pAligned = (DWORD) p;
+        pAligned++;
+        pAligned++;
+    }
+    else
+    {
+        DBGOUT((
+            1,
+            "ClientAlloc: LocalAlloc (x%lx) failed, err=x%lx",
+            dwSize,
+            GetLastError())
+            );
+
+        pAligned = NULL;
+    }
+
+    return ((LPVOID) pAligned);
+}
+
+
+void
+WINAPI
+ClientFree(
+    LPVOID  p
+    )
+{
+    if (p != NULL)
+    {
+        LPVOID  pOrig = (LPVOID) *(((LPDWORD) p) - 2);
+
+
+        LocalFree (pOrig);
+    }
+#if DBG
+    else
+    {
+        DBGOUT((4,"----- ClientFree: ptr = NULL!"));
+    }
+#endif
+}
+
+
+UINT
+WINAPI
+ClientSize(
+    LPVOID  p
+    )
+{
+    if (p != NULL)
+    {
+        return (LocalSize ((LPVOID) *(((LPDWORD) p) - 2)) - 16);
+    }
+
+    DBGOUT((4,"----- ClientSize: ptr = NULL!"));
+    return 0;
+}
+
+
+LONG
+WINAPI
+FreeClientResources(
+    void
+    )
+{
+    //
+    // If ghTapi32 is non-NULL it means the AsyncEventsThread is
+    // still running (an ill-behaved app is trying to unload us
+    // without calling shutdown) so go thru the motions of getting
+    // the thread to terminate (like we do in xxxShutdown)
+    //
+    // Otherwise close our handle to the shared event
+    //
+
+    if (gpAsyncEventsThreadParams)
+    {
+        gpAsyncEventsThreadParams->bExitThread = TRUE;
+        SetEvent (ghAsyncEventsEvent);
+        gpAsyncEventsThreadParams = NULL;
+
+// BUGBUG FreeCliRes: clean up cli-side resources (list of xApps?)
+
+    }
+    else if (gphCx)
+    {
+        CloseHandle (ghAsyncEventsEvent);
+    }
+
+
+    //
+    // If we've made an rpc connection with tapisrv then cleanly detach
+    //
+
+    if (gphCx)
+    {
+        RpcTryExcept
+        {
+            ClientDetach (&gphCx);
+        }
+        RpcExcept(1)
+        {
+            // do something?
+        }
+        RpcEndExcept
+
+        gphCx = NULL;
+    }
+
+
+    //
+    // Free up any other resources we were using
+    //
+
+    CloseHandle (ghInitMutex);
+
+    if (ghWow32Dll)
+    {
+        FreeLibrary (ghWow32Dll);
+        ghWow32Dll = NULL;
+    }
+
+    return 0;
+}
+
+
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[1280] = "TAPI32: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[8],
+                   lpszFormat,
+                   ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
+
+
+LONG
+CALLBACK
+TUISPIDLLCallback(
+    DWORD   dwObjectID,
+    DWORD   dwObjectType,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, xUIDLLCallback),
+
+        {
+            (DWORD) dwObjectID,
+            (DWORD) dwObjectType,
+            (DWORD) lpParams,
+            (DWORD) dwSize,
+            (DWORD) lpParams,
+            (DWORD) dwSize
+        },
+
+        {
+            Dword,
+            Dword,
+            lpSet_SizeToFollow,
+            Size,
+            lpGet_SizeToFollow,
+            Size
+        }
+    };
+
+
+    return (DOFUNC (&funcArgs, "UIDLLCallback"));
+}
+
+
+void
+UIThread(
+    LPVOID  pParams
+    )
+{
+    DWORD           dwThreadID =  GetCurrentThreadId();
+    HANDLE          hTapi32;
+    PUITHREADDATA   pUIThreadData = (PUITHREADDATA) pParams;
+
+
+    DBGOUT((3, "UIThread: enter (tid=%d)", dwThreadID));
+
+
+    //
+    // Call LoadLibrary to increment the reference count in case this
+    // thread is still running when this dll gets unloaded
+    //
+
+    hTapi32 = LoadLibrary ("tapi32.dll");
+
+    DBGOUT((3, "UIThread: calling TUISPI_providerGenericDialog..."));
+
+    (*pUIThreadData->pfnTUISPI_providerGenericDialog)(
+        TUISPIDLLCallback,
+        pUIThreadData->htDlgInst,
+        pUIThreadData->pParams,
+        pUIThreadData->dwSize,
+        pUIThreadData->hEvent
+        );
+
+    DBGOUT((
+        3,
+        "UIThread: TUISPI_providerGenericDialog returned (tid=%d)",
+        dwThreadID
+        ));
+
+
+    //
+    // Remove the ui thread data struct from the global list
+    //
+
+    EnterCriticalSection (&gCriticalSection);
+
+    if (pUIThreadData->pNext)
+    {
+        pUIThreadData->pNext->pPrev = pUIThreadData->pPrev;
+    }
+
+    if (pUIThreadData->pPrev)
+    {
+        pUIThreadData->pPrev->pNext = pUIThreadData->pNext;
+    }
+    else
+    {
+        gpUIThreadInstances = pUIThreadData->pNext;
+    }
+
+    LeaveCriticalSection (&gCriticalSection);
+
+
+    //
+    // Free the library & buffers, then alert tapisrv
+    //
+
+    FreeLibrary (pUIThreadData->hUIDll);
+
+    CloseHandle (pUIThreadData->hThread);
+
+    CloseHandle (pUIThreadData->hEvent);
+
+    if (pUIThreadData->pParams)
+    {
+        ClientFree (pUIThreadData->pParams);
+    }
+
+    {
+        FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 1, xFreeDialogInstance),
+
+            {
+                (DWORD) pUIThreadData->htDlgInst
+            },
+
+            {
+                Dword
+            }
+        };
+
+
+        DOFUNC (&funcArgs, "FreeDialogInstance");
+    }
+
+    ClientFree (pUIThreadData);
+
+    DBGOUT((3, "UIThread: exit (tid=%d)", dwThreadID));
+
+    FreeLibraryAndExitThread (hTapi32, 0);
+}
+
+
+LONG
+//WINAPI
+CALLBACK
+LAddrParamsInited(
+    LPDWORD lpdwInited
+    )
+{
+    HKEY  hKey;
+    HKEY  hKey2;
+    DWORD dwDataSize;
+    DWORD dwDataType;
+
+
+    //
+    // This is called by the modem setup wizard to determine
+    // whether they should put up TAPI's Wizard page.
+    //
+
+    RegOpenKeyExW(
+                  HKEY_LOCAL_MACHINE,
+                  gszTelephonyKey,
+                  0,
+                  KEY_READ,
+                  &hKey2
+                );
+
+    RegOpenKeyExW(
+                  hKey2,
+                  gszLocationsW,
+                  0,
+                  KEY_READ,
+                  &hKey
+                );
+
+    dwDataSize = sizeof(DWORD);
+    *lpdwInited=0;
+
+    RegQueryValueExW(
+                     hKey,
+                     gszNumEntriesW,
+                     0,
+                     &dwDataType,
+                     (LPBYTE)lpdwInited,
+                     &dwDataSize
+                   );
+
+    RegCloseKey( hKey );
+    RegCloseKey( hKey2);
+
+    //
+    // Return a "proper" code
+    //
+    if ( *lpdwInited > 1 )
+    {
+       *lpdwInited = 1;
+    }
+
+    return 0;
+}
+
+
+LONG
+WINAPI
+lineTranslateDialogA(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    HWND        hwndOwner,
+    LPCSTR      lpszAddressIn
+    );
+
+
+LONG
+CALLBACK
+//WINAPI
+//BUGBUG MAKE THIS A UNICODE ENTRY POINT! (LOpenDialAsst)
+LOpenDialAsst(
+               HWND hwnd,
+               LPCSTR lpszAddressIn,
+               BOOL fSimple,
+               BOOL fSilentInstall
+             )
+{
+
+//   lineTranslateDialog(hLineApp, 0, 0x00020000, hwnd, lpszAddressIn );
+
+    gbTranslateSimple = fSimple;
+    gbTranslateSilent = fSilentInstall; 
+
+   return lineTranslateDialogA( NULL, 0, 0x00020000, hwnd, lpszAddressIn );
+}
+
+
+/////////////////////////////////////////////////////////////////////
+// internalPerformance
+//   tapiperf.dll calls this function to get performance data
+//   this just calls into tapisrv
+/////////////////////////////////////////////////////////////////////
+LONG
+WINAPI
+internalPerformance(PPERFBLOCK pPerfBlock)
+{
+        FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 2, tPerformance),
+
+            {
+                (DWORD)pPerfBlock,
+                sizeof(PERFBLOCK)
+            },
+
+            {
+                lpGet_SizeToFollow,
+                Size
+            }
+        };
+
+
+        return (DOFUNC (&funcArgs, "PerfDataCall"));
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+#if DBG
+
+char *aszLineErrors[] =
+{
+    NULL,
+    "ALLOCATED",
+    "BADDEVICEID",
+    "BEARERMODEUNAVAIL",
+    "inval err value (0x80000004)",      // 0x80000004 isn't valid err code
+    "CALLUNAVAIL",
+    "COMPLETIONOVERRUN",
+    "CONFERENCEFULL",
+    "DIALBILLING",
+    "DIALDIALTONE",
+    "DIALPROMPT",
+    "DIALQUIET",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALADDRESS",                     // 0x80000010
+    "INVALADDRESSID",
+    "INVALADDRESSMODE",
+    "INVALADDRESSSTATE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBEARERMODE",
+    "INVALCALLCOMPLMODE",
+    "INVALCALLHANDLE",
+    "INVALCALLPARAMS",
+    "INVALCALLPRIVILEGE",
+    "INVALCALLSELECT",
+    "INVALCALLSTATE",
+    "INVALCALLSTATELIST",
+    "INVALCARD",
+    "INVALCOMPLETIONID",
+    "INVALCONFCALLHANDLE",              // 0x80000020
+    "INVALCONSULTCALLHANDLE",
+    "INVALCOUNTRYCODE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEHANDLE",
+    "INVALDIALPARAMS",
+    "INVALDIGITLIST",
+    "INVALDIGITMODE",
+    "INVALDIGITS",
+    "INVALEXTVERSION",
+    "INVALGROUPID",
+    "INVALLINEHANDLE",
+    "INVALLINESTATE",
+    "INVALLOCATION",
+    "INVALMEDIALIST",
+    "INVALMEDIAMODE",
+    "INVALMESSAGEID",                   // 0x80000030
+    "inval err value (0x80000031)",      // 0x80000031 isn't valid err code
+    "INVALPARAM",
+    "INVALPARKID",
+    "INVALPARKMODE",
+    "INVALPOINTER",
+    "INVALPRIVSELECT",
+    "INVALRATE",
+    "INVALREQUESTMODE",
+    "INVALTERMINALID",
+    "INVALTERMINALMODE",
+    "INVALTIMEOUT",
+    "INVALTONE",
+    "INVALTONELIST",
+    "INVALTONEMODE",
+    "INVALTRANSFERMODE",
+    "LINEMAPPERFAILED",                 // 0x80000040
+    "NOCONFERENCE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOREQUEST",
+    "NOTOWNER",
+    "NOTREGISTERED",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "RATEUNAVAIL",
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",
+    "STRUCTURETOOSMALL",
+    "TARGETNOTFOUND",
+    "TARGETSELF",
+    "UNINITIALIZED",                    // 0x80000050
+    "USERUSERINFOTOOBIG",
+    "REINIT",
+    "ADDRESSBLOCKED",
+    "BILLINGREJECTED",
+    "INVALFEATURE",
+    "NOMULTIPLEINSTANCE",
+    "INVALAGENTID",
+    "INVALAGENTGROUP",
+    "INVALPASSWORD",
+    "INVALAGENTSTATE",
+    "INVALAGENTACTIVITY",
+    "DIALVOICEDETECT"
+};
+
+char *aszPhoneErrors[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBUTTONLAMPID",
+    "INVALBUTTONMODE",
+    "INVALBUTTONSTATE",
+    "INVALDATAID",
+    "INVALDEVICECLASS",
+    "INVALEXTVERSION",
+    "INVALHOOKSWITCHDEV",
+    "INVALHOOKSWITCHMODE",              // 0x90000010
+    "INVALLAMPMODE",
+    "INVALPARAM",
+    "INVALPHONEHANDLE",
+    "INVALPHONESTATE",
+    "INVALPOINTER",
+    "INVALPRIVILEGE",
+    "INVALRINGMODE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOTOWNER",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "inval err value (0x9000001e)",      // 0x9000001e isn't valid err code
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",                   // 0x90000020
+    "STRUCTURETOOSMALL",
+    "UNINITIALIZED",
+    "REINIT"
+};
+
+char *aszTapiErrors[] =
+{
+    "SUCCESS",
+    "DROPPED",
+    "NOREQUESTRECIPIENT",
+    "REQUESTQUEUEFULL",
+    "INVALDESTADDRESS",
+    "INVALWINDOWHANDLE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEID",
+    "DEVICECLASSUNAVAIL",
+    "DEVICEIDUNAVAIL",
+    "DEVICEINUSE",
+    "DESTBUSY",
+    "DESTNOANSWER",
+    "DESTUNAVAIL",
+    "UNKNOWNWINHANDLE",
+    "UNKNOWNREQUESTID",
+    "REQUESTFAILED",
+    "REQUESTCANCELLED",
+    "INVALPOINTER"
+};
+
+
+char *
+PASCAL
+MapResultCodeToText(
+    LONG    lResult,
+    char   *pszResult
+    )
+{
+    if (lResult == 0)
+    {
+        wsprintf (pszResult, "SUCCESS");
+    }
+    else if (lResult > 0)
+    {
+        wsprintf (pszResult, "x%x (completing async)", lResult);
+    }
+    else if (((DWORD) lResult) <= LINEERR_DIALVOICEDETECT)
+    {
+        lResult &= 0x0fffffff;
+
+        wsprintf (pszResult, "LINEERR_%s", aszLineErrors[lResult]);
+    }
+    else if (((DWORD) lResult) <= PHONEERR_REINIT)
+    {
+        if (((DWORD) lResult) >= PHONEERR_ALLOCATED)
+        {
+            lResult &= 0x0fffffff;
+
+            wsprintf (pszResult, "PHONEERR_%s", aszPhoneErrors[lResult]);
+        }
+        else
+        {
+            goto MapResultCodeToText_badErrorCode;
+        }
+    }
+    else if (((DWORD) lResult) <= ((DWORD) TAPIERR_DROPPED) &&
+             ((DWORD) lResult) >= ((DWORD) TAPIERR_INVALPOINTER))
+    {
+        lResult = ~lResult + 1;
+
+        wsprintf (pszResult, "TAPIERR_%s", aszTapiErrors[lResult]);
+    }
+    else
+    {
+
+MapResultCodeToText_badErrorCode:
+
+        wsprintf (pszResult, "inval error value (x%x)");
+    }
+
+    return pszResult;
+}
+
+#endif
diff --git a/private/tapi/dev/client/client.h b/private/tapi/dev/client/client.h
new file mode 100644
index 000000000..fa811632d
--- /dev/null
+++ b/private/tapi/dev/client/client.h
@@ -0,0 +1,445 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    client.h
+
+Abstract:
+
+    Header file for tapi client module
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1994
+
+Revision History:
+
+--*/
+
+
+#define TAPI_VERSION1_0           0x00010003
+#define TAPI_VERSION1_4           0x00010004
+#define TAPI_VERSION2_0           0x00020000
+#define TAPI_VERSION_CURRENT      TAPI_VERSION2_0
+
+#define NUM_ARGS_MASK             0x0000000f
+
+#define LINE_FUNC                 0x00000010
+#define PHONE_FUNC                0x00000020
+#define TAPI_FUNC                 0x00000000
+
+#define ASYNC                     0x00000040
+#define SYNC                      0x00000000
+
+#define INITDATA_KEY              ((DWORD) 'INIT')
+#define TPROXYREQUESTHEADER_KEY   ((DWORD) 'REQH')
+
+#define WM_ASYNCEVENT             (WM_USER+111)
+
+#define DEF_NUM_EVENT_BUFFER_ENTRIES    16
+
+#define TAPI_SUCCESS                    0
+#define TAPI_NO_DATA                         0xffffffff
+#define MAX_TAPI_FUNC_ARGS              12
+
+#define INITIAL_CLIENT_THREAD_BUF_SIZE  512
+#define WM_TAPI16_CALLBACKMSG           (WM_USER+101)
+
+#define IsOnlyOneBitSetInDWORD(dw) (dw && !(((DWORD)dw) & (((DWORD)dw) - 1)))
+
+#define AllCallSelect                \
+    (LINECALLSELECT_CALL           | \
+    LINECALLSELECT_ADDRESS         | \
+    LINECALLSELECT_LINE)
+
+#define AllDigitModes                \
+    (LINEDIGITMODE_PULSE           | \
+    LINEDIGITMODE_DTMF             | \
+    LINEDIGITMODE_DTMFEND)
+
+#define AllForwardModes              \
+    (LINEFORWARDMODE_UNCOND        | \
+    LINEFORWARDMODE_UNCONDINTERNAL | \
+    LINEFORWARDMODE_UNCONDEXTERNAL | \
+    LINEFORWARDMODE_UNCONDSPECIFIC | \
+    LINEFORWARDMODE_BUSY           | \
+    LINEFORWARDMODE_BUSYINTERNAL   | \
+    LINEFORWARDMODE_BUSYEXTERNAL   | \
+    LINEFORWARDMODE_BUSYSPECIFIC   | \
+    LINEFORWARDMODE_NOANSW         | \
+    LINEFORWARDMODE_NOANSWINTERNAL | \
+    LINEFORWARDMODE_NOANSWEXTERNAL | \
+    LINEFORWARDMODE_NOANSWSPECIFIC | \
+    LINEFORWARDMODE_BUSYNA         | \
+    LINEFORWARDMODE_BUSYNAINTERNAL | \
+    LINEFORWARDMODE_BUSYNAEXTERNAL | \
+    LINEFORWARDMODE_BUSYNASPECIFIC)
+
+#define AllTerminalModes             \
+    (LINETERMMODE_BUTTONS          | \
+    LINETERMMODE_LAMPS             | \
+    LINETERMMODE_DISPLAY           | \
+    LINETERMMODE_RINGER            | \
+    LINETERMMODE_HOOKSWITCH        | \
+    LINETERMMODE_MEDIATOLINE       | \
+    LINETERMMODE_MEDIAFROMLINE     | \
+    LINETERMMODE_MEDIABIDIRECT)
+
+#define AllToneModes                 \
+    (LINETONEMODE_CUSTOM           | \
+    LINETONEMODE_RINGBACK          | \
+    LINETONEMODE_BUSY              | \
+    LINETONEMODE_BEEP              | \
+    LINETONEMODE_BILLING)
+
+#define AllHookSwitchDevs            \
+    (PHONEHOOKSWITCHDEV_HANDSET    | \
+    PHONEHOOKSWITCHDEV_SPEAKER     | \
+    PHONEHOOKSWITCHDEV_HEADSET)
+
+#define AllHookSwitchModes           \
+    (PHONEHOOKSWITCHMODE_ONHOOK    | \
+    PHONEHOOKSWITCHMODE_MIC        | \
+    PHONEHOOKSWITCHMODE_SPEAKER    | \
+    PHONEHOOKSWITCHMODE_MICSPEAKER)
+
+#define AllLampModes                 \
+    (PHONELAMPMODE_BROKENFLUTTER   | \
+    PHONELAMPMODE_FLASH            | \
+    PHONELAMPMODE_FLUTTER          | \
+    PHONELAMPMODE_OFF              | \
+    PHONELAMPMODE_STEADY           | \
+    PHONELAMPMODE_WINK             | \
+    PHONELAMPMODE_DUMMY)
+
+#define AllMediaModes                \
+    (LINEMEDIAMODE_UNKNOWN         | \
+    LINEMEDIAMODE_INTERACTIVEVOICE | \
+    LINEMEDIAMODE_AUTOMATEDVOICE   | \
+    LINEMEDIAMODE_DIGITALDATA      | \
+    LINEMEDIAMODE_G3FAX            | \
+    LINEMEDIAMODE_G4FAX            | \
+    LINEMEDIAMODE_DATAMODEM        | \
+    LINEMEDIAMODE_TELETEX          | \
+    LINEMEDIAMODE_VIDEOTEX         | \
+    LINEMEDIAMODE_TELEX            | \
+    LINEMEDIAMODE_MIXED            | \
+    LINEMEDIAMODE_TDD              | \
+    LINEMEDIAMODE_ADSI             | \
+    LINEMEDIAMODE_VOICEVIEW)
+
+
+typedef enum
+{
+    xGetAsyncEvents,
+    xGetUIDllName,
+    xUIDLLCallback,
+    xFreeDialogInstance,
+
+    lAccept,
+    lAddToConference,
+    lAgentSpecific,
+    lAnswer,
+    lBlindTransfer,
+    lClose,
+    lCompleteCall,
+    lCompleteTransfer,
+    lDeallocateCall,
+    lDevSpecific,
+    lDevSpecificFeature,
+    lDial,
+    lDrop,
+    lForward,
+    lGatherDigits,
+    lGenerateDigits,
+    lGenerateTone,
+    lGetAddressCaps,
+    lGetAddressID,
+    lGetAddressStatus,
+    lGetAgentActivityList,
+    lGetAgentCaps,
+    lGetAgentGroupList,
+    lGetAgentStatus,
+    lGetAppPriority,
+    lGetCallAddressID,          // remotesp only
+    lGetCallInfo,
+    lGetCallStatus,
+    lGetConfRelatedCalls,
+    lGetCountry,
+    lGetDevCaps,
+    lGetDevConfig,
+    lGetIcon,
+    lGetID,
+    lGetLineDevStatus,
+    lGetNewCalls,
+    lGetNumAddressIDs,          // remotesp only
+    lGetNumRings,
+    lGetProviderList,
+    lGetRequest,
+    lGetStatusMessages,
+//In TAPI32.DLL now:    lGetTranslateCaps,
+    lHandoff,
+    lHold,
+    lInitialize,
+    lMakeCall,
+    lMonitorDigits,
+    lMonitorMedia,
+    lMonitorTones,
+    lNegotiateAPIVersion,
+    lNegotiateExtVersion,
+    lOpen,
+    lPark,
+    lPickup,
+    lPrepareAddToConference,
+    lProxyMessage,
+    lProxyResponse,
+    lRedirect,
+    lRegisterRequestRecipient,
+    lReleaseUserUserInfo,
+    lRemoveFromConference,
+    lSecureCall,
+    lSendUserUserInfo,
+    lSetAgentActivity,
+    lSetAgentGroup,
+    lSetAgentState,
+    lSetAppPriority,
+    lSetAppSpecific,
+    lSetCallData,
+    lSetCallParams,
+    lSetCallPrivilege,
+    lSetCallQualityOfService,
+    lSetCallTreatment,
+//In TAPI32.DLL now:    lSetCurrentLocation,
+    lSetDefaultMediaDetection,  // remotesp only
+    lSetDevConfig,
+    lSetLineDevStatus,
+    lSetMediaControl,
+    lSetMediaMode,
+    lSetNumRings,
+    lSetStatusMessages,
+    lSetTerminal,
+//In TAPI32.DLL now:    lSetTollList,
+    lSetupConference,
+    lSetupTransfer,
+    lShutdown,
+    lSwapHold,
+//In TAPI32.DLL now:    lTranslateAddress,
+    lUncompleteCall,
+    lUnhold,
+    lUnpark,
+
+    pClose,
+    pDevSpecific,
+    pGetButtonInfo,
+    pGetData,
+    pGetDevCaps,
+    pGetDisplay,
+    pGetGain,
+    pGetHookSwitch,
+    pGetID,
+    pGetIcon,
+    pGetLamp,
+    pGetRing,
+    pGetStatus,
+    pGetStatusMessages,
+    pGetVolume,
+    pInitialize,
+    pOpen,
+    pNegotiateAPIVersion,
+    pNegotiateExtVersion,
+    pSetButtonInfo,
+    pSetData,
+    pSetDisplay,
+    pSetGain,
+    pSetHookSwitch,
+    pSetLamp,
+    pSetRing,
+    pSetStatusMessages,
+    pSetVolume,
+    pShutdown,
+
+//In TAPI32.DLL now:    tGetLocationInfo,
+    tRequestDrop,
+    tRequestMakeCall,
+    tRequestMediaCall,
+//    tMarkLineEvent,
+    tReadLocations,
+    tWriteLocations,
+    tAllocNewID,
+    tPerformance
+
+} FUNC_TYPE;
+
+
+
+typedef struct _CLIENT_THREAD_INFO
+{
+    LPBYTE  pBuf;
+
+    DWORD   dwBufSize;
+
+} CLIENT_THREAD_INFO, *PCLIENT_THREAD_INFO;
+
+
+typedef struct _TAPI32_MSG
+{
+    //
+    // The following union is used:
+    //
+    //   1. by requests from client to server to specify a function type
+    //   2. by acks from server to client to specify a return value
+    //   3. by async msgs from server to client to specify msg type
+    //
+
+    union
+    {
+        DWORD   Req_Func;
+
+        LONG    Ack_ReturnValue;
+
+        DWORD   Msg_Type;
+
+    } u;
+
+
+    //
+    // The following...
+    //
+
+    DWORD       hRpcClientInst;
+
+
+    //
+    // Function paramters
+    //
+
+    DWORD       Params[MAX_TAPI_FUNC_ARGS];
+
+} TAPI32_MSG, *PTAPI32_MSG;
+
+
+typedef struct _ASYNCEVENTMSG
+{
+    DWORD                   dwTotalSize;
+
+    DWORD                   pInitData;
+
+    DWORD                   pfnPostProcessProc;
+
+    DWORD                   hDevice;
+
+    DWORD                   dwMsg;
+
+    DWORD                   dwCallbackInst;
+
+    DWORD                   dwParam1;
+
+    DWORD                   dwParam2;
+
+    DWORD                   dwParam3;
+
+    DWORD                   dwParam4;
+
+} ASYNCEVENTMSG, *PASYNCEVENTMSG;
+
+
+typedef void (PASCAL *POSTPROCESSPROC)(PASYNCEVENTMSG pMsg);
+
+
+typedef struct _ASYNC_EVENT_PARAMS
+{
+    DWORD                   hDevice;
+
+    DWORD                   dwMsg;
+
+    DWORD                   dwCallbackInstance;
+
+    DWORD                   dwParam1;
+
+    DWORD                   dwParam2;
+
+    DWORD                   dwParam3;
+
+} ASYNC_EVENT_PARAMS, *PASYNC_EVENT_PARAMS;
+
+
+typedef LONG (PASCAL *TUISPIPROC)();
+
+
+typedef struct _UITHREADDATA
+{
+    HTAPIDIALOGINSTANCE     htDlgInst;
+
+    HINSTANCE               hUIDll;
+
+    HANDLE                  hThread;
+
+    HANDLE                  hEvent;
+
+    LPVOID                  pParams;
+
+    DWORD                   dwSize;
+
+    TUISPIPROC              pfnTUISPI_providerGenericDialog;
+
+    TUISPIPROC              pfnTUISPI_providerGenericDialogData;
+
+    struct _UITHREADDATA   *pPrev;
+
+    struct _UITHREADDATA   *pNext;
+
+} UITHREADDATA, *PUITHREADDATA;
+
+
+typedef struct _PROXYREQUESTHEADER
+{
+    DWORD                   dwKey;
+
+    DWORD                   dwInstance;
+
+} PROXYREQUESTHEADER, *PPROXYREQUESTHEADER;
+
+
+#if DBG
+extern char    gszDebug[];
+#endif
+//extern const char    gszLocation[];
+//extern const char    gszLocations[];
+extern const char    gszCurrentLocation[];
+extern const char    gszNullString[];
+
+
+
+LPVOID
+WINAPI
+ClientAlloc(
+    DWORD   dwSize
+    );
+
+UINT
+WINAPI
+ClientSize(
+    LPVOID  lp
+    );
+
+void
+WINAPI
+ClientFree(
+    LPVOID  lp
+    );
+
+
+
+LONG
+WINAPI
+MarkLineEvent(
+    DWORD           dwApiVersion,
+    DWORD           ptLine,
+    DWORD           ptLineClientToExclude,
+    DWORD           dwMsg,
+    DWORD           dwParam1,
+    DWORD           dwParam2,
+    DWORD           dwParam3
+    );
diff --git a/private/tapi/dev/client/client.rc b/private/tapi/dev/client/client.rc
new file mode 100644
index 000000000..b741b50f7
--- /dev/null
+++ b/private/tapi/dev/client/client.rc
@@ -0,0 +1,308 @@
+#include "windows.h"
+#include "prsht.h"
+#include "clientr.h"
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+//
+// Default line and phone icons
+//
+// these icons taken from VB\ICONS\COMM
+// REVIEW: these should be replaced with something better
+// 
+//
+
+
+#if WINNT
+TAPILINE        ICON    DISCARDABLE     "NET09A.ICO"
+TAPIPHONE       ICON    DISCARDABLE     "PHONE03.ICO"
+CALLCARD        ICON    DISCARDABLE     "CCARD1.ICO"
+IDCL_LOC_BMP    BITMAP  DISCARDABLE     "LOC.BMP"
+IDCL_LOC_SIMPLE_BMP BITMAP  DISCARDABLE "LOCSIMP.BMP"
+#else
+TAPILINE        ICON    DISCARDABLE     "..\\NET09A.ICO"
+TAPIPHONE       ICON    DISCARDABLE     "..\\PHONE03.ICO"
+CALLCARD        ICON    DISCARDABLE     "..\\CCARD1.ICO"
+IDCL_LOC_BMP    BITMAP  DISCARDABLE     "..\\LOC.BMP"
+IDCL_LOC_SIMPLE_BMP BITMAP  DISCARDABLE "..\\LOCSIMP.BMP"
+#endif
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+IDD_DEFINE_LOCATION DIALOG DISCARDABLE  10, 10, 265, 217
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU //| DS_3DLOOK
+CAPTION "My Locations"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "I am &dialing from:",IDCS_DL_NAME,10,11,56,10
+    COMBOBOX        IDCC_DL_NAME,70,9,83,50,CBS_DROPDOWN | 
+                    CBS_SORT | WS_VSCROLL | WS_TABSTOP | CBS_AUTOHSCROLL
+    PUSHBUTTON      "&New...",IDCB_DL_NEW_LOCATION,160,9,41,14
+    PUSHBUTTON      "&Remove",IDCB_DL_REMOVE_LOCATION,205,9,41,14
+    GROUPBOX        "Where I am:",IDC_STATIC,7,26,250,57
+    LTEXT           "The area &code is:",IDCS_DL_AREACODE,15,40,59,10
+    EDITTEXT        IDCE_DL_AREACODE,76,38,40,14,ES_AUTOHSCROLL
+    LTEXT           "",IDC_STATIC+1,120,40,56,10
+    LTEXT           "&I am in:",IDCS_DL_COUNTRY,15,59,51,10
+    COMBOBOX        IDCC_DL_COUNTRY,76,58,128,128,CBS_DROPDOWNLIST | 
+                    CBS_SORT | WS_VSCROLL | WS_TABSTOP
+    GROUPBOX        "How I dial from this location:",IDC_STATIC+2,7,88,250,90
+    LTEXT           "To access an &outside line, first dial:",IDCS_DL_OUTSIDE,
+                    15,104,114,10
+    EDITTEXT        IDCE_DL_OUTSIDEACCESS,130,102,15,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    LTEXT           "for local,",IDCS_DL_OUTSIDEACCESS,147,104,30,10
+    EDITTEXT        IDCE_DL_LONGDISTANCEACCESS,181,102,15,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    LTEXT           "for long distance.",IDCS_DL_LONGDISTANCEACCESS,198,104,55,10
+    CONTROL         "Dial &using Calling Card:",IDCK_DL_CALLINGCARD,"Button",
+                    BS_AUTOCHECKBOX | WS_TABSTOP,15,120,88,13
+/* removed to temporarily fix bug 1156; following "LTEXT" is replacement
+    CONTROL         "",IDCE_DL_CALLINGCARD,"Static",SS_LEFTNOWORDWRAP | 
+                    SS_NOPREFIX | WS_DISABLED | WS_GROUP,104,120,98,14
+*/
+    LTEXT           "",IDCE_DL_CALLINGCARD,104,122,98,12,SS_NOPREFIX | SS_LEFTNOWORDWRAP
+    PUSHBUTTON      "C&hange...",IDCB_DL_CHANGE_CARD,208,120,42,14
+    CONTROL         "This location has call &waiting. To disable it, dial:",
+                    IDCK_DL_CALLWAITING,"Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,15,141,168,10
+    COMBOBOX        IDCC_DL_CALLWAITING,190,140,42,90,CBS_DROPDOWN |
+                    WS_VSCROLL | WS_TABSTOP
+
+    LTEXT           "The phone system at this location uses:",IDCS_PULSE,15,160,159,10
+    RADIOBUTTON     "&Tone dialing",IDCR_TONE,145,157,55,14,WS_GROUP
+    RADIOBUTTON     "&Pulse dialing",IDCR_PULSE,200,157,55,14
+
+    LTEXT           "Number to be dialed:",IDCS_DIAL_NUMBER_TEXT,15,184,70,10
+    LTEXT           "",IDCS_DL_DIAL_NUMBER,86,184,165,17,SS_NOPREFIX
+    CONTROL         "Dial as a &long distance call",IDCK_DL_IN_LOCAL,
+                    "Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,203,98,10
+END
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+IDD_CALLING_CARD_CHANGE DIALOG DISCARDABLE  10, 10, 293, 130
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Change Calling Card"
+FONT 8, "MS Shell Dlg"
+BEGIN
+//    LTEXT           "Calling Card to &use:",IDCS_DR_CARD_NAME,54,22,67,10
+    DEFPUSHBUTTON   "OK",IDOK,236,9,50,14
+    LTEXT           "Calling Card to &use:",IDCS_DR_CARD_NAME,54,22,67,10
+    COMBOBOX        IDCC_DR_CARD_NAME,124,19,96,120,CBS_DROPDOWN | CBS_SORT | 
+                    WS_VSCROLL | WS_TABSTOP | CBS_AUTOHSCROLL
+    LTEXT           "&Calling Card number:",IDCS_DR_CARD_NUM,54,43,68,10
+    EDITTEXT        IDCE_DR_CARD_NUM,123,41,96,14,ES_AUTOHSCROLL
+    PUSHBUTTON      "&New...",IDCB_DR_NEW_CARD,54,99,52,14
+    PUSHBUTTON      "&Remove",IDCB_DR_REMOVE_CARD,110,99,52,14
+//    PUSHBUTTON      "&Advanced...",IDCB_DR_ADVANCED,166,99,53,14
+    PUSHBUTTON      "Ru&les...",IDCB_DR_ADVANCED,166,99,53,14
+    PUSHBUTTON      "Cancel",IDCANCEL,236,27,50,14
+    GROUPBOX        "",IDC_STATIC,7,5,222,118
+    ICON            "CALLCARD",IDC_STATIC,17,19,18,20
+/*    CONTROL         "",IDC_STATIC,"Static",SS_BLACKRECT,45,10,2,112 */
+END
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+IDD_DIALING_RULES DIALOG DISCARDABLE  10, 10, 220, 106
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Dialing Rules"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Calls within the same area code:",IDCS_DR_LOCAL_NUM,7,
+                    7,117,10
+    EDITTEXT        IDCE_DR_LOCAL_NUM,7,18,140,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    LTEXT           "&Long distance calls:",IDCS_DR_LONG_NUM,7,38,73,10
+    EDITTEXT        IDCE_DR_LONG_NUM,7,49,140,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    LTEXT           "&International calls:",IDCS_DR_INTERNATIONAL_NUM,7,68,
+                    68,10
+    EDITTEXT        IDCE_DR_INTERNATIONAL_NUM,7,78,140,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    PUSHBUTTON      "Close",IDOK,159,7,54,14
+//    PUSHBUTTON      "Cancel",IDCANCEL,159,25,54,14
+    PUSHBUTTON      "Copy &From...",IDCB_DR_COPY_FROM,159,25,54,14
+END
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+IDD_NEW_CARD DIALOG DISCARDABLE  10, 10, 160, 63
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Create New Calling Card"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Create a new calling card named:",IDCS_NC_NEW_CARD,10,
+                    9,120,10
+    EDITTEXT        IDCE_NC_NEW_CARD,10,20,139,14,ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "OK",IDOK,44,39,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,99,39,50,14
+END
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+IDD_COPY_DIAL_RULES DIALOG DISCARDABLE  10, 10, 160, 140
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_CONTEXTHELP
+CAPTION "Copy Dialing Rules"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Select the calling card from which to copy:",
+                    IDCS_CR_RULE_LIST,10,10,140,10
+    LISTBOX         IDCL_CR_RULE_LIST,10,21,140,90,LBS_SORT | WS_VSCROLL | 
+                    WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,45,116,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,100,116,50,14
+END
+
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+/* If any (non-size related) changes are made to this dialog, be sure to
+ * propagate them to the IDD_WIZ_DIALINFO dialog too. That is used by
+ * the RNA guys in their Modems wizard.
+ */
+IDD_DEFINE_LOCATION_SIMPLE DIALOG DISCARDABLE  10, 10, 303, 199
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | DS_3DLOOK
+CAPTION "Location Information"
+FONT 8, "MS Shell Dlg"
+BEGIN
+
+    LTEXT           "&What country are you in now?",IDC_STATIC,107,35,109,10
+    COMBOBOX        IDCC_DL_COUNTRY,107,47,180,68,CBS_DROPDOWNLIST | 
+                    CBS_SORT | WS_VSCROLL | WS_TABSTOP
+
+    LTEXT           "What area (or city) &code are you in now?",IDC_STATIC,
+                    107,65,181,10
+
+    EDITTEXT        IDCE_DL_AREACODE,107,77,40,12,ES_AUTOHSCROLL
+    CONTROL         IDCL_LOC_SIMPLE_BMP,IDCS_LOC_BMP,"Static",SS_BITMAP,10,10,100,33
+/*    CONTROL         "",IDCS_LOC_BMP,"Static",0xe,10,10,100,33 */
+    LTEXT           "Please provide information about your current location so that your calls can be dialed correctly.",
+//    LTEXT           "Please enter the following so that your calls can be dialed correctly.",
+                    IDCS_DL_SILENTTEXT,107,15,188,17
+    LTEXT           "If you dial a number to access an &outside line, what is it?",
+                    IDCS_DL_OUTSIDEACCESS,107,95,189,10
+    EDITTEXT        IDCE_DL_OUTSIDEACCESS,107,107,40,12,ES_AUTOHSCROLL | ES_UPPERCASE
+
+    LTEXT           "The phone system at this location uses:",
+                                 IDCS_PULSE,107,125,159,10
+    RADIOBUTTON     "&Tone dialing",IDCR_TONE,107,135,57,14,WS_GROUP
+    RADIOBUTTON     "&Pulse dialing",IDCR_PULSE,175,135,57,14
+
+    LTEXT           "",IDCS_DL_AREACODE,0,165,310,10,NOT WS_GROUP
+    DEFPUSHBUTTON   "Close",IDOK,246,175,50,14
+//    DEFPUSHBUTTON   "OK",IDOK,185,175,50,14
+//    PUSHBUTTON      "Cancel",IDCANCEL,246,175,50,14
+
+END
+
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+/* If any (non-size related) changes are made to this dialog, be sure to
+ * propagate them to the IDD_DEFINE_LOCATION_SIMPLE dialog too. That is
+ * used by Tapi to prompt the user for information when the dialing
+ * rules have never been initialized before.
+ */
+IDD_WIZ_DIALINFO DIALOG DISCARDABLE  0, 0, WIZ_CXDLG, WIZ_CYDLG
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Location Information"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&What country are you in now?",IDC_STATIC,92,22,109,10
+    COMBOBOX        IDCC_DL_COUNTRY,92,33,177,68,CBS_DROPDOWNLIST | 
+                    CBS_SORT | WS_VSCROLL | WS_TABSTOP
+
+    LTEXT           "What area (or city) &code are you in now?",IDC_STATIC,
+                    92,54,181,10
+    EDITTEXT        IDCE_DL_AREACODE,92,65,40,14,ES_AUTOHSCROLL
+
+    CONTROL         IDCL_LOC_SIMPLE_BMP,IDCS_LOC_BMP,"Static",SS_BITMAP,0,0,
+                             WIZ_CXBMP,WIZ_CYDLG
+
+    LTEXT           "Please provide information about your current location so that your calls can be dialed correctly.",
+                    IDC_STATIC,92,0,177,18
+
+    LTEXT           "If you dial a number to access an &outside line, what is it?",
+                    IDCS_DL_OUTSIDEACCESS,92,88,189,10
+    EDITTEXT        IDCE_DL_OUTSIDEACCESS,92,99,40,14,ES_AUTOHSCROLL | ES_UPPERCASE
+
+    LTEXT           "The phone system at this location uses:",
+                                 IDCS_PULSE,92,121,159,10
+
+    RADIOBUTTON     "&Tone dialing",IDCR_TONE,92,130,55,12,WS_GROUP
+    RADIOBUTTON     "&Pulse dialing",IDCR_PULSE,155,130,55,12
+
+END
+
+
+
+// /////////////////////////////////////////////////////////////////////////
+
+#include "general.rc"
+
+// /////////////////////////////////////////////////////////////////////////
+
+
+
+STRINGTABLE DISCARDABLE
+BEGIN
+
+DIALINGPROPERTIES_NAME "Dialing Properties"
+
+IDS_NEWLOCATION "New Location"
+
+IDS_NOCALLINGCARD "None (Direct Dial)"
+
+IDS_WRN_CANT_REMOVE_LAST_CARD  "This calling card cannot be removed"
+REMOVE_CARD                    "Are you sure you want to remove the selected calling card?"
+REMOVE_LOCATION                "Are you sure you want to remove the selected location?"
+IDCS_DL_CREATED_LOCATION       "A new location was created"
+IDS_WRN_TITLE_SURE             "Are You Sure?"
+IDS_WRN_TITLE_REQUIRED         "Required Entry Not Made"
+IDS_WRN_CARD_NUMBER_REQUIRED   "The calling card you have selected requires a card number (PIN) to be entered."
+IDS_WRN_AREA_CODE_REQUIRED     "Locations in the selected country must specify an area (city) code. Please enter one."
+
+IDS_MSG_SIMPLEMSG_MDMINSTALLED "Your modem has been installed.  Please enter the following so that your calls can be dialed correctly."
+
+IDS_WRN_TITLE_INVALCHAR        "Improper Character Entered"
+
+IDS_WRN_RULESNEEDED            "You now must enter dialing ""rules"" for this calling card. These rules will define how a phone number is dialed using this calling card. If this is not done correctly, the calling card may not be used in making calls."
+IDS_DL_DUP_NAME                "The name you have entered matches another name already in use.  Please enter a unique name."
+IDS_DL_DUP_NAME_CAPTION        "Name in Use"
+IDS_DL_NULL_NAME               "A valid location name is required for the current location."
+IDS_DL_NULL_NAME_CAPTION       "Required Entry Not Made"
+END
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony API Client DLL"
+#define VER_INTERNALNAME_STR        "tapi32"
+#define VER_ORIGINALFILENAME_STR    "TAPI32.DLL"
+//#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  Portions Copyright Intel/Microsoft 1992-93.  All Rights Reserved."
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1996.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
+#include "..\cpl\telephon.rc"
+
+#include "tapini.rc"
+#include "tapierr.rc"
diff --git a/private/tapi/dev/client/clientr.h b/private/tapi/dev/client/clientr.h
new file mode 100644
index 000000000..d3265db98
--- /dev/null
+++ b/private/tapi/dev/client/clientr.h
@@ -0,0 +1,331 @@
+//
+// (c) 1995 Microsoft Corporation.  Portions Copyright Intel/Microsoft 1992-93.  All Rights Reserved."
+//
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by TELEPHON.RC
+//
+#define IDS_DC_GL_DRIVER_SETUP          1
+#define IDS_DT_GL_DRIVER_LIST           2
+#define IDCL_CR_HELP                    3
+#define IDS_DC_GL_LOCATION              4
+#define ID_CURRENT                      4
+#define IDS_DT_GL_LOC_LIST              5
+#define IDS_DC_GL_CALL_CARD             6
+#define ID_NEW                          6
+#define IDS_DT_GL_CARD_LIST             7
+#define IDS_TITLE                       8
+#define IDS_STATUS_LINE                 9
+#define IDHELP                          9
+#define IDS_HELP_FILE                   10
+#define IDS_CLOSE                       11
+#define IDS_CUSTOMIZE                   12
+#define IDS_ADD_LOCATION                13
+#define IDS_EDIT_LOCATION               14
+#define IDS_WRN_REMOVE_CARD             15
+#define IDS_ERR_APPLICATION             16
+#define IDS_ERR_MEMORY                  17
+#define IDS_ERR_ALREADY_IN_LIST         18
+#define IDS_ERR_READ_PRIV_INI           19
+#define IDS_ERR_WRITE_INI               20
+#define IDS_ERR_INVALID_INI             21
+#define IDS_ERR_WRITE_WIN_INI           22
+#define IDS_WRN_INVALID_STR             23
+#define IDS_WRN_INVALID_EX_NUM_STR      24
+#define IDS_WRN_INVALID_NUM             25
+#define IDS_ERR_INVALID_TAPIADDR        26
+#define IDS_WRN_INI_READ_ONLY           27
+#define IDS_DT_DS_NO_DRIVER             28
+#define IDS_ERR_NO_DRIVER               29
+#define IDS_ERR_BAD_DRIVER              30
+#define IDS_NONE                        31
+#define IDS_ADD_CALLING_CARD            32
+#define IDS_EDIT_CALLING_CARD           33
+
+#define IDS_CARD_REMOVE_OR_STUPID       34
+#define REMOVE_CARD       IDS_CARD_REMOVE_OR_STUPID
+#define IDS_LOCATION_REMOVE_OR_STUPID   35
+#define REMOVE_LOCATION   IDS_LOCATION_REMOVE_OR_STUPID
+
+#define IDS_DRIVER_REMOVE_OR_STUPID     36
+#define IDS_ERR_INVALID_INI_LOCATIONS   37
+#define IDS_ERR_INVALID_INI_CARDS       38
+#define IDD_BROWSE_TEMPLATE             38
+#define IDS_ERR_INVALID_INI_DRIVERS     39
+
+#ifndef CHICAGO
+#define IDS_ERR_INVALID_INI_COUNTRIES   40
+#endif
+
+#define IDS_WRN_AREA_CODE_REQUIRED      41
+#define IDS_WRN_INVALID_NUM_STR         42
+#define IDS_WRN_INVALID_LOCATION_CARD   43
+#define IDS_WRN_DRIVER_IN_USE           44
+#define IDS_ERR_DRIVER_FAILED           45
+#define IDS_ERR_MULTIPLE_INST           46
+
+#define IDS_DIAL_ASST                   47
+#define IDS_ERR_UPDATE_LOCATION          48
+#define IDS_ERR_UPDATE_CARD              49
+#define IDS_WRN_LOCATION_NAME_REQUIRED  50
+#define IDS_WRN_CANNOT_CHANGE_DEF_LOC   51
+#define IDS_WRN_LOCATION_NAME_REQUIRED  50
+
+#define IDS_PROVIDERERROR_NOT_AN_SP     52
+#define IDS_PROVIDERERROR_TOO_OLD       53
+#define IDS_PROVIDERERROR_FAILED_INIT   54
+#define IDS_WRN_CARD_NAME_REQUIRED  	 55
+#define IDS_WRN_QUITING_WIZ            56
+
+#define IDS_WRN_CANT_REMOVE_LAST_CARD   57
+
+#define IDS_WRN_CARD_NUMBER_REQUIRED    58
+#define IDS_MSG_SIMPLEMSG_MDMINSTALLED  59
+#define IDS_NOCALLINGCARD               60
+#define IDS_DL_DUP_NAME                 61
+#define IDS_DL_NULL_NAME                62
+#define IDS_DL_DUP_NAME_CAPTION         63
+#define IDS_DL_NULL_NAME_CAPTION        64
+
+#define IDD_TELEPHONY                   101
+#define IDD_GENERIC_LIST                102
+#define IDD_TOLL_LIST                   104
+#define IDD_CREDIT_CARD                 105
+#define IDD_DIALING_RULES               106
+#define IDI_TELEPHONY                   108
+#define IDD_COPY_DIAL_RULES             109
+#define IDD_ADD_DRIVER                  111
+#define IDD_DEFINE_LOCATION             112
+#define IDD_DEFINE_LOCATION_SIMPLE      113
+#define IDD_DRIVER_SETUP                116
+#define IDD_INSTALL_DRIVER              117
+#define IDB_BITMAP1                     120
+#define IDD_DEBUG_OUT                   121
+#define ID_LIST                         303
+#define LB_UNLISTED                     306
+
+#define IDS_WRN_TITLE_WARNING           350
+#define IDS_WRN_TITLE_NAMEINUSE         351
+#define IDS_WRN_TITLE_INVALCHAR         352
+#define IDS_WRN_TITLE_SURE              353
+#define IDS_WRN_TITLE_REQUIRED          354
+#define IDS_WRN_RULESNEEDED             355
+
+#define IDCC_TM_CURR_LOCATION           1000
+#define IDD_INSERT_DISK                 1000
+#define IDD_BROWSE                      1001
+#define IDD_UNLISTED_DRIVERS            1002
+#define IDD_UPDATE                      1003
+#define IDD_RESTART                     1004
+#define IDD_EXISTS                      1005
+#define IDCB_TM_MULT_LOCATIONS          1007
+#define IDCB_TM_DRIVER_SETUP            1008
+#define IDCB_TM_HELP                    1009
+#define IDCB_GL_REMOVE                  1011
+#define IDCB_TL_REMOVE                  1012
+#define IDCB_TL_ADD                     1013
+#define IDCB_TL_HELP                    1014
+#define IDCK_TL_USE_AREA_CODE           1015
+#define IDCT_GL_LIST_TEXT               1017
+#define IDCB_CC_CUSTOMIZE               1018
+#define IDCB_CC_HELP                    1019
+#define IDCE_CC_CARD_NAME               1020
+#define IDCE_CC_CARD_NUM                1021
+#define IDCB_DR_COPY_FROM               1022
+#define IDCE_CC_PASSWORD_CARD_NUM       1022
+#define IDCB_DR_HELP                    1023
+#define IDCE_DR_LOCAL_NUM               1024
+#define IDCE_DR_LONG_NUM                1025
+#define IDCE_DR_INTERNATIONAL_NUM       1026
+#define IDCL_CR_RULE_LIST               1031
+#define IDCB_AD_ADD                     1032
+#define IDCB_AD_BROWSE                  1033
+#define IDCH_AD_HELP                    1034
+#define IDCE_DL_NAME                    1035
+#define IDCE_DL_OUTSIDEACCESS           1036
+#define IDCE_DL_LONGDISTANCEACCESS      1037
+#define IDCE_DL_AREACODE                1038
+#define psh15                           0x040e
+#define IDCC_DL_COUNTRY                 1039
+#define IDCC_DL_CALLING_CARD            1040
+#define chx1                            0x0410
+#define IDCB_DL_TOLL_LIST               1041
+#define IDCL_AD_DRIVER_LIST             1042
+#define IDCB_DL_CALLCARD_SETUP          1052
+#define IDCB_DL_HELP                    1053
+#define IDCC_TL_TOLL_LIST               1055
+#define IDCB_DS_EDIT                    1056
+#define IDCL_DS_LIST                    1057
+#define IDCB_DS_ADD                     1058
+#define IDCB_DS_REMOVE                  1059
+#define IDCB_DS_HELP                    1060
+#define IDCK_DR_HIDE_CARD               1061
+#define IDCS_TM_LOCAL_CALLS             1062
+#define IDCS_TM_LONG_DIST_CALLS         1063
+#define IDCS_TM_AREA_CODE               1064
+#define IDCS_TM_COUNTRY_CODE            1065
+#define IDCS_TM_CALLING_CARD            1066
+#define IDCB_INSTALL_BROWSE             1067
+#define IDC_BUTTON2                     1068
+#define IDCB_ID_HELP                    1068
+#define IDC_EDIT1                       1069
+#define IDCE_PATHNAME                   1069
+#define IDT_DEBUG                       1070
+#define IDCB_TM_CALLCARD_SETUP          1081
+#define IDCB_GL_EDIT                    1083
+#define stc1                            0x0440
+#define stc2                            0x0441
+#define IDCB_GL_ADD                     1109
+#define IDCB_GL_HELP                    1112
+#define lst1                            0x0460
+#define IDCL_GL_LIST                    1121
+#define lst2                            0x0461
+#define cmb1                            0x0470
+#define cmb2                            0x0471
+#define edt1                            0x0480
+#define ctlLast                         0x04ff
+#define IDS_NAME                        2001
+#define IDS_NAME2                       2002
+#define IDS_NOINF                       2003
+#define IDS_NOINF2                      2004
+#define IDS_OUTOFDISK                   2005
+#define IDS_NOINF3                      2006
+#define IDS_NAME3                       2007
+#define IDS_RESTARTTEXT                 2015
+#define IDS_UPDATED                     2031
+#define IDS_UNLISTED                    2034
+#define IDS_UNABLE_TOINSTALL            2049
+#define IDS_FILEINUSEADD                2053
+#define IDS_FILEINUSEREM                2055
+#define IDS_FILEINUSEREM2               2056
+#define IDS_DRIVER_EXISTS               2058
+#define IDS_DIAL_ASST_NOT_SET                2059
+#define IDS_WRN_DIAL_ASST_NOT_SET        2060
+#define ID_STATUS2                      4002
+#define IDS_FILENOTINDIR                0x2001
+#define IDS_DISKMSG                     0x2002
+#define IDS_FILEMSG                     0x2003
+#define IDS_DISKFILEMSG                 0x2004
+#define IDH_DLG_ADD_UNKNOWN             8803
+#define IDD_PATH                        0x3002
+#define IDD_TEXT                        0x3003
+#define IDD_ICON                        0x3004
+#define IDS_NEWLOCATION                 0x3005
+#define IDC_STATIC                      -1
+
+#define IDCC_DL_NAME                5000
+#define IDCB_DL_NEW_LOCATION                 5001
+#define IDCK_DL_IN_LOCAL                     5002
+#define IDCB_DL_REMOVE_LOCATION          5003
+#define IDCB_DL_CHANGE_CARD              5004
+#define IDCK_DL_CALLINGCARD              5005
+#define IDCK_DL_CALLWAITING             5006
+#define IDCK_DL_PULSE_DIAL               5007
+#define IDCC_DL_CALLWAITING             5008
+#define IDCE_DL_CALLINGCARD              5009
+#define IDCS_DL_NAME                     5010
+#define IDCS_DL_AREACODE                 5011
+#define IDCS_DL_COUNTRY                  5012
+#define IDCS_DL_OUTSIDE                  5013
+#define IDCS_DL_OUTSIDEACCESS            5014
+#define IDCS_DL_LONGDISTANCEACCESS       5015
+
+#define IDCS_DL_SILENTTEXT               5016
+#define IDCS_DL_CREATED_LOCATION         5017
+
+
+#define IDCC_DR_CARD_NAME               6000
+#define IDCE_DR_CARD_NUM                6001
+#define IDCK_DR_IN_LOCAL                     6002
+#define IDCB_DR_NEW_CARD                     6003
+#define IDCB_DR_REMOVE_CARD              6004
+#define IDCB_DR_ADVANCED                     6005
+#define IDCS_DR_CARD_NAME                   6006
+#define IDCS_DR_CARD_NUM                    6007
+#define IDCS_DR_LOCAL_NUM                   6008
+#define IDCS_DR_LONG_NUM                    6009
+#define IDCS_DR_INTERNATIONAL_NUM           6010
+#define IDCB_DR_DUMMY						     6011
+
+
+
+#define IDCR_PULSE                          6050
+#define IDCR_TONE                           6051
+#define IDCS_PULSE                          6052
+#define IDCS_TONE                           6053
+
+#define IDD_NEW_LOCATION                    7000
+#define IDCE_NL_NEW_LOCATION                7001
+#define IDCS_NL_NEW_LOCATION                7002
+
+#define IDD_NEW_CARD                        8000
+#define IDCE_NC_NEW_CARD                    8001
+#define IDCS_NC_NEW_CARD                    8002
+#define IDCS_CR_RULE_LIST                   8003
+
+#define IDCS_DIAL_NUMBER_TEXT               9000
+#define IDCS_DL_DIAL_NUMBER                 9001
+#define IDCS_DR_DIAL_NUMBER                 9002
+#define IDCS_LOC_BMP                        9100
+#define IDCL_LOC_BMP                        9101
+#define IDCL_LOC_SIMPLE_BMP                 9102
+
+#define IDD_CALLING_CARD_CHANGE             9150
+
+/* ALERT! Do NOT change this value. It is used by the RNA guys
+ * to identify the Dialing info dialog for their Modems Wizard.
+ */
+#define IDD_WIZ_DIALINFO					400
+
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        122
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1071
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
+
+
+#define RC_CARD_ID_BASE         15800
+#define RC_COUNTRY_ID_BASE      16000
+
+#define DIALINGPROPERTIES_NAME 4446
+
+
+
+
+#if WINNT
+
+// id's for TAPI Dial Helper (5100-5199)
+
+// (copied from HELP.H)
+
+#define IDH_TAPI_ACCESS_LINE            5100
+#define IDH_TAPI_AREA_CODE              5101
+#define IDH_TAPI_CALLCARD_ADD           5102
+#define IDH_TAPI_CALLCARD_ADV           5103
+#define IDH_TAPI_CALLCARD_NUMBER        5104
+#define IDH_TAPI_CALLCARD_REMOVE        5105
+#define IDH_TAPI_CALLCARD_RULES         5106
+#define IDH_TAPI_CALLCARDS              5107
+#define IDH_TAPI_COPY_FROM_BUTTON       5108
+#define IDH_TAPI_COPYFROM               5109
+#define IDH_TAPI_COUNTRY                5110
+#define IDH_TAPI_CREATE_CARD            5111
+#define IDH_TAPI_CREATE_LOCATION        5112
+#define IDH_TAPI_LOCATION_CALL_WAIT     5113
+#define IDH_TAPI_LOCATION_CARD          5114
+#define IDH_TAPI_LOCATION_CARD_CHANGE   5115
+#define IDH_TAPI_LOCATION_NEW           5116
+#define IDH_TAPI_LOCATION_PHONE         5117
+#define IDH_TAPI_LOCATION_PULSE         5118
+#define IDH_TAPI_LOCATION_REMOVE        5119
+#define IDH_TAPI_LOCATIONS              5120
+#define IDH_TAPI_LONG_DISTANCE          5121
+
+#endif
diff --git a/private/tapi/dev/client/depend.mk b/private/tapi/dev/client/depend.mk
new file mode 100644
index 000000000..f79e836ad
--- /dev/null
+++ b/private/tapi/dev/client/depend.mk
@@ -0,0 +1,38 @@
+.\client.obj: ..\client.c ..\client.h ..\private.h ..\tapsrv.h \
+              ..\..\inc\tapi.x ..\clientr.h
+
+.\tapsrv_c.obj: ..\tapsrv.h ..\tapsrv_c.c
+
+.\dial.obj: ..\dial.c ..\clientr.h ..\card.h ..\location.h ..\client.h
+
+.\card.obj: ..\card.c ..\clientr.h ..\card.h ..\location.h
+
+.\general.obj: ..\general.c
+
+.\client.res: ..\client.rc ..\..\cpl\telephon.rc
+
+
+
+.\copy.obj: ..\..\cpl\copy.c
+
+.\cpl.obj: ..\..\cpl\cpl.c
+
+.\init.obj: ..\..\cpl\init.c
+
+.\debug.obj: ..\..\cpl\debug.c
+
+.\drv.obj: ..\..\cpl\drv.c ..\..\cpl\drv.h
+
+.\exe.obj: ..\..\cpl\exe.c ..\..\cpl\drv.h
+
+.\filecopy.obj: ..\..\cpl\filecopy.c ..\..\cpl\drv.h
+
+.\inf.obj: ..\..\cpl\inf.c
+
+.\insdisk.obj: ..\..\cpl\insdisk.c
+
+.\mmdriver.obj: ..\..\cpl\mmdriver.c  ..\..\cpl\drv.h
+
+.\util.obj: ..\..\cpl\util.c
+
+
diff --git a/private/tapi/dev/client/dial.c b/private/tapi/dev/client/dial.c
new file mode 100644
index 000000000..2da2290f1
--- /dev/null
+++ b/private/tapi/dev/client/dial.c
@@ -0,0 +1,8926 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    dial.c
+
+Abstract:
+
+    Dialhelper
+
+Author:
+
+
+
+Revision History:
+
+--*/
+
+#if DBG
+#define InternalDebugOut(_x_) DbgPrt _x_
+#else
+#define InternalDebugOut(_x_)
+#endif
+
+
+#include <windows.h>
+#include <windowsx.h>
+
+#if WINNT
+#else
+#include <help.h>
+#endif
+
+#include "tchar.h"
+#include "prsht.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "clientr.h"
+#include "client.h"
+#include "private.h"
+#include "card.h"
+#include "location.h"
+#include "general.h"
+
+
+
+#undef   lineBlindTransfer
+#undef   lineConfigDialog
+#undef   lineConfigDialogEdit
+#undef   lineDial
+#undef   lineForward
+#undef   lineGatherDigits
+#undef   lineGenerateDigits
+#undef   lineGetAddressCaps
+#undef   lineGetAddressID
+#undef   lineGetAddressStatus
+#undef   lineGetCallInfo
+#undef   lineGetDevCaps
+#undef   lineGetDevConfig
+#undef   lineGetIcon
+#undef   lineGetID
+#undef   lineGetLineDevStatus
+#undef   lineGetRequest
+#undef   lineGetTranslateCaps
+#undef   lineHandoff
+#undef   lineMakeCall
+#undef   lineOpen
+#undef   linePark
+#undef   linePickup
+#undef   linePrepareAddToConference
+#undef   lineRedirect
+#undef   lineSetDevConfig
+#undef   lineSetTollList
+#undef   lineSetupConference
+#undef   lineSetupTransfer
+#undef   lineTranslateAddress
+#undef   lineUnpark
+#undef   phoneConfigDialog
+#undef   phoneGetButtonInfo
+#undef   phoneGetDevCaps
+#undef   phoneGetIcon
+#undef   phoneGetID
+#undef   phoneGetStatus
+#undef   phoneSetButtonInfo
+#undef   tapiGetLocationInfo
+#undef   tapiRequestMakeCall
+#undef   tapiRequestMediaCall
+#undef   lineAddProvider
+#undef   lineGetAppPriority
+#undef   lineGetCountry
+#undef   lineGetProviderList
+#undef   lineSetAppPriority
+#undef   lineTranslateDialog
+
+
+//***************************************************************************
+//***************************************************************************
+extern BOOL CALLBACK CallingCardProc( HWND, UINT, WPARAM, LPARAM );
+
+
+//***************************************************************************
+//***************************************************************************
+#define IsWDigit(c) (((WCHAR)(c)) >= (WCHAR)'0' && ((WCHAR)(c)) <= (WCHAR)'9')
+#define IsDigit(c) (((CHAR)(c)) >= (CHAR)'0' && ((CHAR)(c)) <= (CHAR)'9')
+
+
+
+//***************************************************************************
+extern HINSTANCE            ghInst;
+extern CRITICAL_SECTION     gUICriticalSection;
+
+
+//***************************************************************************
+
+BOOL    gbInternalTranslate = FALSE;
+BOOL    gbTranslateSimple = FALSE;
+BOOL    gbTranslateSilent = FALSE;
+
+PWSTR gpszAddress = NULL;
+
+PLOCATION gLocationList = NULL;
+UINT gnNumLocations = 0;
+UINT gnCurrentLocationID = 0;
+
+
+
+PLOCATION gpCurrentLocation = NULL;
+
+
+
+const WCHAR   gszLocationW[]          = L"Location";
+const WCHAR    gszLocationsW[]        = L"Locations";
+const CHAR    gszNullString[]         = "";
+WCHAR   gszNullStringW[]        = L"";
+
+WCHAR gszNameW[]               = L"Name";
+WCHAR gszIDW[]                 = L"ID";
+WCHAR gszAreaCodeW[]           = L"AreaCode";
+WCHAR gszCountryW[]            = L"Country";
+WCHAR gszOutsideAccessW[]      = L"OutsideAccess";
+WCHAR gszLongDistanceAccessW[] = L"LongDistanceAccess";
+WCHAR gszFlagsW[]              = L"Flags";
+WCHAR gszCallingCardW[]        = L"CallingCard";
+WCHAR gszDisableCallWaitingW[] = L"DisableCallWaiting";
+WCHAR gszTollListW[]           = L"TollList";
+
+WCHAR gszCardW[]               = L"Card";
+WCHAR gszPinW[]                = L"Pin";
+const WCHAR gszCardsW[]        = L"Cards";
+WCHAR gszLocalRuleW[]          = L"LocalRule";
+WCHAR gszLDRuleW[]             = L"LDRule";
+WCHAR gszInternationalRuleW[]  = L"InternationalRule";
+
+WCHAR gszNumEntriesW[]         = L"NumEntries";
+WCHAR gszCurrentIDW[]          = L"CurrentID";
+WCHAR gszNextIDW[]             = L"NextID";
+
+
+const WCHAR gszTelephonyKey[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony";
+//const WCHAR gszCardKeyW[]     = L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Cards";
+//const WCHAR gszLocationKeyW[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations";
+
+
+//char __based(__segname("DIALAGE")) csSCANTO[] = "|^\r";
+const WCHAR  csSCANTO[]      = L"|^\r";
+const WCHAR  csSPECIAL[]     = L"$@W?";
+const WCHAR  csBADCO[]       = L"AaBbCcDdPpTtWw*#!,@$?;()";
+const WCHAR  csDISPSUPRESS[] = L"TtPp,Ww@?!$";
+
+#define CITY_MANDATORY (1)
+#define CITY_OPTIONAL (-1)
+#define CITY_NONE (0)
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL IsThisAPIVersionInvalid( DWORD dwAPIVersion )
+{
+   if (
+         ( 0x00010003 != dwAPIVersion )
+       &&
+         ( 0x00010004 != dwAPIVersion )
+       &&
+         ( 0x00020000 != dwAPIVersion )
+      )
+   {
+      return LINEERR_INCOMPATIBLEAPIVERSION;
+   }
+
+   return 0;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//
+//   Copies a string (up to endC).  Returns NULL on error. If source
+//   is null, returns lpDest.
+//
+LPWSTR CopyStringToChar( LPWSTR lpSrc,
+                                WCHAR endC,
+                                LPWSTR lpDest,
+                                LPWSTR lpEnd
+                              )
+{
+   if (lpSrc != NULL && lpDest != NULL)
+   {
+      while (*lpSrc != endC)
+      {
+         if ( lpDest < lpEnd )
+            *lpDest = *lpSrc;
+
+//         if ( IsDBCSLeadByte((BYTE)*lpSrc) )
+//         {
+//            if ( lpDest < lpEnd )
+//               *(++lpDest) = *(++lpSrc);
+//         }
+
+         lpSrc++;
+         lpDest++;
+      }
+   }
+   return lpDest;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+/*--------------------------------------------------------------------------*\
+
+    Function:   Unscrambler
+    
+    Purpose:    
+      This is the UN version of Scrambler
+
+\*--------------------------------------------------------------------------*/
+UINT WINAPI Unscrambler( DWORD  dwKey,
+                         LPWSTR  lpszSrc,
+                         LPWSTR  lpszDst )
+
+{
+   UINT  uIndex;
+   UINT  uSubKey;
+   UINT  uNewKey;
+   UINT  uResult = 0;
+
+   InternalDebugOut((50, "Entering Unscrambler"));
+   if ( !lpszSrc || !lpszDst )
+      {
+//      uResult = INI_ERR_INVALID_ARG;
+      goto  done;
+      }
+             
+   uNewKey = (UINT)dwKey & 0x7FFF;
+   uSubKey = (UINT)dwKey % 10;
+             
+   for ( uIndex = 1; *lpszSrc ; lpszSrc++, lpszDst++, uIndex++ )
+      {
+      if ( IsWDigit( *lpszSrc ))
+         {
+         // do the unscramble thang
+         //------------------------
+         uSubKey  = ((*lpszSrc - (WCHAR)'0') - ((uSubKey + uIndex + uNewKey) % 10) + 10) % 10;
+         *lpszDst = (WCHAR)(uSubKey + (WCHAR)'0');
+         }
+      else         
+         *lpszDst = *lpszSrc;    // just save the byte
+      }
+      
+//   uResult = INI_SUCCESS;
+    
+done:
+    *lpszDst = (WCHAR)'\0';
+    InternalDebugOut((60, "Leaving Unscrambler"));
+    return( uResult );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//   Copies an unscrambled version of string to lpDest.
+//   NOTE: we have modified Toby's algorithm to avoid 32 bit MOD, by taking
+//   dwKey MOD 32768 as our key.
+
+//LPTSTR PASCAL CopyScrambled( LPTSTR lpszSrc,
+void PASCAL CopyScrambled( LPWSTR lpszSrc,
+                            LPWSTR lpszDst,
+                            DWORD  dwKey
+                          )
+{
+   UINT  uIndex;
+   UINT  uSubKey;
+   UINT  uNewKey;
+   UINT  uResult = 0;
+
+   InternalDebugOut((50, "Entering IniScrambler"));
+   if ( !lpszSrc || !lpszDst )
+      {
+//      uResult = INI_ERR_INVALID_ARG;
+      goto  done;
+      }  // end if
+
+   uNewKey = (UINT)dwKey & 0x7FFF;
+   uSubKey = (UINT)dwKey % 10;
+             
+   for ( uIndex = 1; *lpszSrc ; lpszSrc++, lpszDst++, uIndex++ )
+      {
+      if ( IsWDigit( *lpszSrc ))
+         {
+         // do the scramble thang
+         //----------------------
+         *lpszDst = (WCHAR)(((uSubKey + (*lpszSrc - (WCHAR)'0') + uIndex + uNewKey) % 10) + (WCHAR)'0');
+         uSubKey = (UINT)(*lpszSrc - (WCHAR)'0');
+         }
+      else         
+         *lpszDst = *lpszSrc;    // just save the byte
+      }  // end for
+
+//   uResult = INI_SUCCESS;
+
+    
+done:
+
+    *lpszDst = (WCHAR)'\0';
+    InternalDebugOut((60, "Leaving IniScrambler"));
+
+    return; //( uResult );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+DWORD GetNumberOfCards()
+{
+    DWORD dwNumCards;
+
+    HKEY hKey;
+    HKEY hKey2;
+    DWORD dwDataType;
+    DWORD dwDataSize;
+
+//*** *** ***BUGBUG
+//should do a read of an entire key and get the # of cards from there -
+//no need to keep a separate # cards field (name of subkeys is name of card?)
+
+    RegOpenKeyExW(
+                  HKEY_CURRENT_USER,
+                  gszTelephonyKey,
+                  0,
+                  KEY_READ,
+                  &hKey2
+                );
+
+    RegOpenKeyExW(
+                  hKey2,
+                  gszCardsW,
+                  0,
+                  KEY_READ,
+                  &hKey
+                );
+
+    dwDataSize = sizeof(dwNumCards);
+    dwNumCards = 0;
+    RegQueryValueExW(
+                     hKey,
+                     gszNumEntriesW,
+                     0,
+                     &dwDataType,
+                     (LPBYTE)&dwNumCards,
+                     &dwDataSize
+                   );
+
+
+//*** *** ***BUGBUG It's _REALLY_ bad if dwNumCards is zero for any
+// reason.  Should probably fail the function on the spot...
+//
+
+    RegCloseKey( hKey );
+    RegCloseKey( hKey2);
+
+
+    return dwNumCards;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+void CheckCards()
+{
+    DWORD dwNumCards;
+    DWORD n;
+    HKEY hKey;
+    HKEY hKey2;
+    HKEY hKey3;
+    WCHAR szCurrentCardKey[256];
+    WCHAR pBuf[512];
+    PWSTR pBufTempPtr;
+
+
+    if ( 0 == GetNumberOfCards() )
+    {
+    
+    DWORD dwDisposition;
+
+    LoadString( ghInst, RC_CARD_ID_BASE, (LPSTR)szCurrentCardKey, sizeof(szCurrentCardKey)/sizeof(WCHAR) );
+
+    dwNumCards = atoi( (LPSTR)szCurrentCardKey );
+
+
+    RegCreateKeyExW(
+              HKEY_CURRENT_USER,
+              gszTelephonyKey,
+              0,
+              gszNullStringW,   //Class - what class?
+              REG_OPTION_NON_VOLATILE,
+              KEY_ALL_ACCESS,
+              0,
+              &hKey3,
+              &dwDisposition
+            );
+
+
+    RegCreateKeyExW(
+              hKey3,
+              gszCardsW,
+              0,
+              gszNullStringW,   //Class - what class?
+              REG_OPTION_NON_VOLATILE,
+              KEY_ALL_ACCESS,
+              0,
+              &hKey2,
+              &dwDisposition
+            );
+
+
+    RegSetValueExW(
+                   hKey2,
+                   gszNumEntriesW,
+                   0,
+                   REG_DWORD,
+                   (LPBYTE)&dwNumCards,
+                   sizeof(DWORD)
+                 );
+
+    RegSetValueExW(
+                   hKey2,
+                   gszNextIDW,
+                   0,
+                   REG_DWORD,
+                   (LPBYTE)&dwNumCards,
+                   sizeof(DWORD)
+                 );
+
+
+          for (n = 0; n < dwNumCards; n++)
+          {
+              DWORD dwDisposition;
+
+              PWSTR pName;
+              PWSTR pPin;
+              PWSTR pLocalRule;
+              PWSTR pLDRule;
+              PWSTR pInternationalRule;
+              DWORD dwFlags;
+
+
+
+
+              wsprintfW(szCurrentCardKey, L"%ls%d",
+                                          gszCardW,
+                                          n
+                                          );
+
+
+
+              LoadStringW( ghInst,
+                           RC_CARD_ID_BASE + n + 1,
+                           pBuf,
+                           sizeof(pBuf) / sizeof(WCHAR)
+                         );
+
+
+              pName = (wcschr( pBuf, L'"' )) + 1;
+
+              pBufTempPtr = wcschr( pName, L'"' );
+
+              *pBufTempPtr = L'\0';
+
+
+              pPin = (wcschr( pBufTempPtr+1, L'"' )) + 1;
+
+              pBufTempPtr = wcschr( pPin, L'"' );
+
+              *pBufTempPtr = L'\0';
+
+
+              pLocalRule = wcschr( pBufTempPtr+1, L'"') + 1;
+
+              pBufTempPtr = wcschr( pLocalRule, L'"' );
+
+              *pBufTempPtr = L'\0';
+
+
+              pLDRule = wcschr( pBufTempPtr+1, L'"') + 1;
+
+              pBufTempPtr = wcschr( pLDRule, L'"' );
+
+              *pBufTempPtr = L'\0';
+
+
+              pInternationalRule = wcschr( pBufTempPtr+1, L'"') + 1;
+
+              pBufTempPtr = wcschr( pInternationalRule, L'"' );
+
+              *pBufTempPtr = L'\0';
+
+
+              {
+                 DWORD dwSize;
+                 PSTR  pszTemp;
+
+                 dwSize = WideCharToMultiByte(
+                            GetACP(),
+                            0,
+                            (pBufTempPtr + 2),
+                            -1,
+                            NULL,
+                            0,
+                            NULL,
+                            NULL
+                          );
+
+                 pszTemp = ClientAlloc( dwSize );
+
+                 WideCharToMultiByte(
+                            GetACP(),
+                            0,
+                            (pBufTempPtr + 2),
+                            -1,
+                            pszTemp,
+                            dwSize,
+                            NULL,
+                            NULL
+                          );
+
+                 dwFlags = atoi( pszTemp );
+
+                 ClientFree( pszTemp );
+              }
+
+
+              RegCreateKeyExW(
+                              hKey2,
+                              szCurrentCardKey,
+                              0,
+                              gszNullStringW,   //Class - what class?
+                              REG_OPTION_NON_VOLATILE,
+                              KEY_ALL_ACCESS,
+                              0,
+                              &hKey,
+                              &dwDisposition
+                            );
+
+
+              RegSetValueExW(
+                             hKey,
+                             gszIDW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&n,
+                             sizeof(DWORD)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszNameW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)pName,
+                             (lstrlenW(pName)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszPinW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)pPin,
+                             (lstrlenW(pPin)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszLocalRuleW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)pLocalRule,
+                             (lstrlenW(pLocalRule)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszLDRuleW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)pLDRule,
+                             (lstrlenW(pLDRule)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszInternationalRuleW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)pInternationalRule,
+                             (lstrlenW(pInternationalRule)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszFlagsW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&dwFlags,
+                             sizeof(DWORD)
+                           );
+
+
+              RegCloseKey(
+                           hKey
+                         );
+
+          }
+
+
+    RegCloseKey( hKey2);
+    RegCloseKey( hKey3);
+
+
+    }
+
+    return;
+}
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL ReadCards( PCARD pCardSpace, PUINT pnStuff )
+{
+    UINT n;
+    WCHAR szCurrentCardKey[256];  // Holds "CARDxx" during reads
+    PCARD pCardList;
+    UINT nNumCards;
+    LONG lResult = 0;
+
+    HKEY hKey;
+    HKEY hKey2;
+    DWORD dwDataType;
+    DWORD dwDataSize;
+
+
+    CheckCards();
+
+    nNumCards = GetNumberOfCards();
+
+InternalDebugOut((40, "NumCards=%d",
+                     nNumCards ));
+
+    //
+    // Did the caller pass in a buffer he wants loaded?
+    //
+    if ( pCardSpace )
+    {
+       //
+       // Does the caller know what he's doing?
+       //
+       if ( *(LPDWORD)pCardSpace < nNumCards )
+       {
+          InternalDebugOut((1, "ReadCards: Buffer too small!"));
+
+          *(LPDWORD)pCardSpace = nNumCards;
+
+          lResult = LINEERR_STRUCTURETOOSMALL;
+
+          goto CLEANUP_ERROR;
+       }
+       else
+       {
+          //
+          // Ok, it _looks_ like he's allocated enough space...
+          //
+          pCardList = pCardSpace;
+       }
+    }
+    else
+    {
+       pCardList = ClientAlloc(sizeof(CARD) * nNumCards);
+
+       if (!pCardList)
+       {
+           goto CLEANUP_ERROR;
+       }
+    }
+
+    RegOpenKeyExW(
+                   HKEY_CURRENT_USER,
+                   gszTelephonyKey,
+                   0,
+                   KEY_READ,
+                   &hKey2
+                 );
+
+    for (n = 0; n < nNumCards; n++)
+    {
+        PCARD ThisCard = &pCardList[n];
+
+        wsprintfW(szCurrentCardKey, L"%ls\\%ls%d", gszCardsW, gszCardW, n);
+
+
+        RegOpenKeyExW(
+                      hKey2,
+                      szCurrentCardKey,
+                      0,
+                      KEY_READ,
+                      &hKey
+                    );
+
+        dwDataSize = sizeof(ThisCard->dwID);
+        ThisCard->dwID = 0;
+        RegQueryValueExW(
+                         hKey,
+                         gszIDW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)&ThisCard->dwID,
+                         &dwDataSize
+                       );
+
+
+        dwDataSize = sizeof(ThisCard->NameW);
+        ThisCard->NameW[0] = '\0';
+        RegQueryValueExW(
+                         hKey,
+                         gszNameW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)ThisCard->NameW,
+                         &dwDataSize
+                       );
+//BUGBUG THIS SHOULD NOT BE NECESSARY!!!
+        ThisCard->NameW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+//        {
+//            TCHAR cTemp[MAXLEN_PIN];
+//
+//            dwDataSize = sizeof(ThisCard->PinW);
+//            cTemp[0] = '\0';
+            dwDataSize = sizeof(ThisCard->PinW);
+            ThisCard->PinW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszPinW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisCard->PinW,
+                             &dwDataSize
+                           );
+            ThisCard->PinW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+//            Unscrambler(   ThisCard->dwID,
+//                           cTemp,
+//                           ThisCard->Pin
+//                         );
+   //Unscramble in place
+
+            Unscrambler(   ThisCard->dwID,
+                           ThisCard->PinW,
+                           ThisCard->PinW
+                         );
+
+//        }
+
+
+
+
+//{
+//   TCHAR cTemp[] = "123";
+//   TCHAR cTemp2[sizeof(cTemp)] = "";
+//
+//   InternalDebugOut((0, "Starting with: %s %s", cTemp, cTemp2));
+//            CopyScrambled( cTemp,
+//                           cTemp2,
+//                           9
+//                         );
+//   InternalDebugOut((0, " Called scram: %s %s", cTemp, cTemp2));
+//            Unscrambler( 9,
+//                           cTemp2,
+//                           cTemp
+//                         );
+//   InternalDebugOut((0, "Called uscram: %s %s", cTemp, cTemp2));
+//}
+
+
+
+
+
+
+        dwDataSize = sizeof(ThisCard->LocalRuleW);
+        ThisCard->LocalRuleW[0] = '\0';
+        RegQueryValueExW(
+                         hKey,
+                         gszLocalRuleW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)ThisCard->LocalRuleW,
+                         &dwDataSize
+                       );
+        ThisCard->LocalRuleW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+        dwDataSize = sizeof(ThisCard->LDRuleW);
+        ThisCard->LDRuleW[0] = '\0';
+        RegQueryValueExW(
+                         hKey,
+                         gszLDRuleW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)ThisCard->LDRuleW,
+                         &dwDataSize
+                       );
+        ThisCard->LDRuleW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+        dwDataSize = sizeof(ThisCard->InternationalRuleW);
+        ThisCard->InternationalRuleW[0] = '\0';
+        RegQueryValueExW(
+                         hKey,
+                         gszInternationalRuleW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)ThisCard->InternationalRuleW,
+                         &dwDataSize
+                       );
+        ThisCard->InternationalRuleW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+        dwDataSize = sizeof(ThisCard->dwFlags);
+        ThisCard->dwFlags = 0;
+        RegQueryValueExW(
+                         hKey,
+                         gszFlagsW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)&ThisCard->dwFlags,
+                         &dwDataSize
+                       );
+
+        RegCloseKey( hKey );
+
+InternalDebugOut((10, "getting card entry %d is %d [%ls]",
+                     n,
+                     ThisCard->dwID,
+                     ThisCard->NameW));
+
+    }
+
+
+    RegCloseKey( hKey2);
+
+    //
+    // Did the caller give us a place to put this stuff?
+    //
+    if ( pnStuff )
+    {
+       pnStuff[0] = 0;
+       pnStuff[1] = (UINT)pCardList;
+       pnStuff[2] = nNumCards;
+    }
+//    else
+//    {
+//       gnCurrentCardID = 0;
+//       gCardList = pCardList;
+//       gnNumCards = nNumCards;
+//    }
+
+
+    return lResult;
+
+
+CLEANUP_ERROR:
+
+
+//    Free_gCardList();
+
+    return lResult;
+
+}
+
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL ReadCardsEasy( 
+                           PCARD  *pCardSpace,
+                           LPUINT *pnStuff )
+{
+   UINT n;
+
+   n = 0;
+   ReadCards((PCARD)&n, NULL);
+
+
+   //
+   // Alloc space needed.  Add size of DWORD in case there are 0 cards.
+   //
+   *pCardSpace = ClientAlloc( (n * sizeof(CARD)) + sizeof(DWORD));
+
+   if ( NULL == *pCardSpace )
+   {
+      //*** *** ***BUGBUG Handle the error (msg anyway...)
+
+      return LINEERR_NOMEM;
+   }
+
+
+   *(PUINT)*pCardSpace = n;
+
+   *pnStuff = ClientAlloc( 3 * sizeof(DWORD) );
+
+   if ( NULL == *pnStuff )
+   {
+      ClientFree( *pCardSpace );
+
+      //*** *** ***BUGBUG Handle the error (msg anyway...)
+
+      return LINEERR_NOMEM;
+   }
+
+   return ReadCards( *pCardSpace, *pnStuff );
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL WriteCards( PCARD pCardList, UINT nNumCards,
+                 DWORD dwChangedFlags)
+{
+    UINT n;
+    UINT nCurrentCard;
+    WCHAR szCurrentCardKey[256];  // Holds "CARDx" string
+    HKEY  hKey;
+    HKEY  hKey2;
+    DWORD dwDisposition;
+
+
+//*** *** ***BUGBUG
+// should we wipe out all of the old ones first?
+
+
+InternalDebugOut((40, "In writecards"));
+
+    //
+    // Has _anything_ changed?
+    //
+    if ( dwChangedFlags )
+    {
+
+       //
+       // Has anything changed that should cause us to write out all
+       // of the card info?
+       //
+
+       if ( dwChangedFlags & CHANGEDFLAGS_REALCHANGE )
+       {
+
+InternalDebugOut((40, "About to write %d cards", nNumCards));
+
+          //
+          // This var will be the # of the current card as opposed to the
+          // # in mem - if a user deleted one, we can't write CARDx ...
+          //
+          nCurrentCard = 0;
+
+          RegCreateKeyExW(
+                          HKEY_CURRENT_USER,
+                          gszTelephonyKey,
+                          0,
+                          gszNullStringW,   //Class - what class?
+                          REG_OPTION_NON_VOLATILE,
+                          KEY_ALL_ACCESS,
+                          0,
+                          &hKey2,
+                          &dwDisposition
+                        );
+
+          for (n = 0; n < nNumCards; n++)
+          {
+              PCARD ThisCard = &(pCardList[n]);
+
+
+              //
+              // If the user Removed this card, don't write it.
+              //
+              if ( (WCHAR)'\0' == ThisCard->NameW[0] )
+              {
+                 continue;  // skipit
+              }
+
+InternalDebugOut((50, "About to write Card#%d - %ls",
+                    nCurrentCard,
+                    ThisCard->NameW));
+
+
+              wsprintfW(szCurrentCardKey, L"%ls\\%ls%d",
+                                          gszCardsW,
+                                          gszCardW,
+                                          nCurrentCard);
+
+              {
+
+              RegCreateKeyExW(
+                              hKey2,
+                              szCurrentCardKey,
+                              0,
+                              gszNullStringW,   //Class - what class?
+                              REG_OPTION_NON_VOLATILE,
+                              KEY_ALL_ACCESS,
+                              0,
+                              &hKey,
+                              &dwDisposition
+                            );
+
+              RegSetValueExW(
+                             hKey,
+                             gszIDW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&ThisCard->dwID,
+                             sizeof(DWORD)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszNameW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisCard->NameW,
+                             (lstrlenW(ThisCard->NameW)+1)*sizeof(WCHAR)
+                           );
+
+
+            {
+            WCHAR wTemp[MAXLEN_PIN];
+
+            CopyScrambled( ThisCard->PinW,
+                           wTemp,
+                           ThisCard->dwID
+                         );
+
+              RegSetValueExW(
+                             hKey,
+                             gszPinW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)wTemp,
+                             (lstrlenW(ThisCard->PinW)+1)*sizeof(WCHAR)
+                           );
+            }
+
+              RegSetValueExW(
+                             hKey,
+                             gszLocalRuleW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisCard->LocalRuleW,
+                             (lstrlenW(ThisCard->LocalRuleW)+1)*sizeof(WCHAR)
+                           );
+
+
+              RegSetValueExW(
+                             hKey,
+                             gszLDRuleW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisCard->LDRuleW,
+                             (lstrlenW(ThisCard->LDRuleW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszInternationalRuleW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisCard->InternationalRuleW,
+                             (lstrlenW(ThisCard->InternationalRuleW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszFlagsW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&ThisCard->dwFlags,
+                             sizeof(DWORD)
+                           );
+
+              RegCloseKey( hKey );
+
+              }
+
+
+              nCurrentCard++;
+
+          }
+
+
+          //
+          // If we "deleted" one or more calling cards, they're still hanging
+          // around.  Delete them now.
+          //
+          for (n = nCurrentCard; n < nNumCards; n++)
+          {
+             wsprintfW(szCurrentCardKey, L"%ls\\%ls%d",
+                                         gszCardsW,
+                                         gszCardW,
+                                         n);
+
+             RegDeleteKeyW( hKey2,
+                            szCurrentCardKey
+                         );
+          }
+
+
+
+          RegOpenKeyExW(
+                        hKey2,
+                        gszCardsW,
+                        0,
+                        KEY_ALL_ACCESS,
+                        &hKey
+                      );
+
+
+          RegSetValueExW(
+                         hKey,
+                         gszNumEntriesW,
+                         0,
+                         REG_DWORD,
+                         (LPBYTE)&nCurrentCard,
+                         sizeof(DWORD)
+                       );
+
+          RegCloseKey( hKey );
+
+          RegCloseKey( hKey2);
+
+       }
+
+
+    }
+
+
+    return;
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL GetLocationIndexFromID( UINT nID, PLOCATION pCallersList, UINT nCallersNumLocations )
+{
+   UINT n;
+   PLOCATION pLocationList;
+   UINT nNumLocations;
+
+
+   //
+   // If the caller passed in his own list, use his info
+   //
+   if ( pCallersList )
+   {
+      pLocationList = pCallersList;
+      nNumLocations = nCallersNumLocations;
+   }
+   else
+   {
+      pLocationList = gLocationList;
+      nNumLocations = gnNumLocations;
+   }
+
+
+   for (n=0; n < nNumLocations; n++)
+   {
+
+InternalDebugOut((10, "comparing <in %ld> with <list entry %ld is %ld>",
+                         (DWORD)nID, (DWORD)n, (DWORD)pLocationList[n].dwID));
+
+      if ( nID == pLocationList[n].dwID )
+      {
+         return (n);
+      }
+   }
+
+   InternalDebugOut((1, "GetLocationIndexFromID failed!  Looking for 0x%08lx", nID));
+   return (-1);
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void GetThisLocation( PLOCATION pLocation, UINT nLocationID, PLOCATION pLocationList, UINT nNumLocations )
+{
+   UINT n;
+
+   n = GetLocationIndexFromID( nLocationID,
+                           pLocationList,
+                           nNumLocations);
+
+//bjm10/31   pLocation->Name               = pLocationList[n].Name;
+//bjm10/31   pLocation->AreaCode           = pLocationList[n].AreaCode;
+//bjm10/31   pLocation->dwCountry          = pLocationList[n].dwCountry;
+//bjm10/31   pLocation->OutsideAccess      = pLocationList[n].OutsideAccess;
+//bjm10/31   pLocation->LongDistanceAccess = pLocationList[n].LongDistanceAccess;
+//bjm10/31   pLocation->dwFlags            = pLocationList[n].dwFlags;
+//bjm10/31   pLocation->dwCallingCard      = pLocationList[n].dwCallingCard;
+//bjm10/31   pLocation->dwID               = pLocationList[n].dwID;
+//bjm10/31   pLocation->DisableCallWaiting = pLocationList[n].DisableCallWaiting;
+//bjm10/31   pLocation->TollList           = pLocationList[n].TollList;
+
+   CopyMemory( pLocation,
+           &pLocationList[n],
+           sizeof(LOCATION)
+         );
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL ReadCountries( LPLINECOUNTRYLIST *ppLCL,
+                           UINT nCountryID,
+                           DWORD dwDestCountryID
+                         )
+{
+    LONG lTapiResult;
+    UINT nBufSize = 0x8000;   //Start with a buffer of 16K
+    UINT n;
+    LPLINECOUNTRYLIST pNewLCL;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lGetCountry),
+
+        {
+            0,
+            TAPI_VERSION_CURRENT,
+            dwDestCountryID,
+            0
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+
+    //
+    // Try until success or the buffer is huge
+    //
+    for ( lTapiResult = 1, n = 0;
+          lTapiResult && (n < 5);
+          n++ )
+    {
+
+        pNewLCL = (LPLINECOUNTRYLIST)ClientAlloc( nBufSize );
+
+
+        pNewLCL->dwTotalSize = nBufSize;
+
+
+        //
+        // Put new values in structure for TAPISRV
+        //
+        funcArgs.Args[0] = nCountryID;
+        funcArgs.Args[3] = (DWORD)pNewLCL;
+
+
+        //
+        // Call TAPISRV to get the country list
+        //
+        lTapiResult =  DOFUNC (&funcArgs, "lineGetCountry");
+
+
+        //
+        // If the call succeeded, but the buffer was too small, or if the
+        // call failed, do it again...
+        //
+        if (
+              (lTapiResult == LINEERR_STRUCTURETOOSMALL)
+            ||
+              (pNewLCL->dwNeededSize > nBufSize)
+           )
+        {
+            //
+            // Complain to anyone who'll listen that this should be tuned
+            // to start with a larger buffer so we don't have to do this multiple
+            // times....
+            //
+            InternalDebugOut((10, "  TUNING PROBLEM: We're about to call lineGetCountry()"));
+            InternalDebugOut((10, "                  _again_ because the buffer wasn't big enough"));
+            InternalDebugOut((10, "                  the last time.  FIX THIS!!!"));
+
+
+lTapiResult = 1; // Force error condition if size was bad...
+            nBufSize += 0x4000;  // Try a bit bigger
+            ClientFree( pNewLCL );
+        }
+        else
+        {
+           //
+           // We didn't work for some other reason
+           //
+           break;
+        }
+    }
+
+    *ppLCL = pNewLCL;
+
+    return lTapiResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL FillCountriesListbox( HWND hWnd )
+{
+    UINT n;
+    UINT                nNumCountries;
+    LPLINECOUNTRYENTRY  pCountryEntry;
+    /*static*/ LPLINECOUNTRYLIST   pCountryList;
+    LONG lItemIndex;
+
+
+    if ( ReadCountries( &pCountryList, 0, 0 ) )
+    {
+//*** *** ***BUGBUG Handle error condition!")
+        InternalDebugOut((1, "  GetCountryList failed!"));
+    }
+
+    pCountryEntry = (LPLINECOUNTRYENTRY)
+           (((LPBYTE) pCountryList) + pCountryList->dwCountryListOffset);
+
+    nNumCountries = pCountryList->dwNumCountries;
+
+    //
+    // Run through all countries and toss 'em in the listbox
+    //
+    for (n = 0; n < nNumCountries; n++)
+    {
+#ifdef PARTIAL_UNICODE
+       CHAR szTempString[256];
+
+       WideCharToMultiByte(
+                            GetACP(),
+                            0,
+                            (PWSTR)(((LPBYTE) pCountryList) +
+                                       pCountryEntry->dwCountryNameOffset),
+                            -1,
+                            szTempString,
+                            sizeof(szTempString),
+                            NULL,
+                            NULL
+                          );
+#endif
+
+
+        lItemIndex =
+#ifdef PARTIAL_UNICODE
+            SendDlgItemMessage(
+#else
+            SendDlgItemMessageW(
+#endif
+               hWnd,
+               IDCC_DL_COUNTRY,
+               CB_ADDSTRING,
+               0,
+#ifdef PARTIAL_UNICODE
+               (LPARAM)szTempString
+#else
+               (LPARAM)(PWSTR)(((LPBYTE)pCountryList) +
+                          pCountryEntry->dwCountryNameOffset)
+#endif
+               );
+
+        SendDlgItemMessage(
+            hWnd,
+            IDCC_DL_COUNTRY,
+            CB_SETITEMDATA,
+            (WPARAM) lItemIndex,
+            (LPARAM) pCountryEntry->dwCountryID
+            );
+
+        pCountryEntry++;
+    }
+    
+    ClientFree( pCountryList );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void Free_gLocationList( void )
+{
+//    PLOCATION ThisLocation;
+//    UINT n;
+
+    InternalDebugOut((80, "Freeing gLocationList"));
+
+    //
+    // Free all mem that was allocated
+    //
+    if (gLocationList)
+    {
+       ClientFree(gLocationList);
+
+       gLocationList = NULL;
+    }
+
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void WriteCurrentLocationValue( HWND hWnd, UINT nLocationID )
+{
+    DWORD dwNewLocation;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, tWriteLocations),
+        {
+            0,
+            CHANGEDFLAGS_CURLOCATIONCHANGED,
+            0,    // dwNewLocation
+            0
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            Dword
+        }
+    };
+
+
+
+   //
+   // If the user passed in an hWnd, get the new current loc from
+   // the selection box.  Otherwise, use gnCurrentLocation which
+   // should have been updated before calling here.
+   //
+   if ( hWnd )
+   {
+      PLOCATION pThisLocation;
+      UINT nThisItemIndex;
+
+      nThisItemIndex = SendDlgItemMessage( hWnd,
+                                           IDCC_DL_NAME,
+                                           CB_GETCURSEL,
+                                           0,
+                                           0);
+if (nThisItemIndex == -1 )
+{
+DBGOUT((10, "Found one(0)!!!!"));
+}
+      pThisLocation = (PLOCATION)SendDlgItemMessage( hWnd,
+                                                     IDCC_DL_NAME,
+                                                     CB_GETITEMDATA,
+                                                     nThisItemIndex,
+                                                     0);
+
+      dwNewLocation = pThisLocation->dwID;
+   }
+   else
+   {
+      dwNewLocation = nLocationID;
+   }
+
+
+   InternalDebugOut((10, "Updating curlocation value (%ld)", dwNewLocation));
+
+
+   funcArgs.Args[2] = dwNewLocation;
+
+   DOFUNC (&funcArgs, "TWriteLocations");
+
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL  WriteLocations( PLOCATION  pLocationList,
+                             UINT       nNumLocations,
+                             DWORD      dwChangedFlags,
+                             PLOCATION  pCurrentLocation
+                           )
+{
+    PWSTR     pString;
+    UINT  n;
+    PBYTE pNewLocationList;
+    LONG  lResult;
+
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, tWriteLocations),
+        {
+            nNumLocations,
+            dwChangedFlags,
+            pCurrentLocation->dwID,
+            0   //pNewLocationList
+        },
+
+        {
+            Dword,
+            Dword,
+            Dword,
+            lpSet_Struct
+        }
+    };
+
+
+    if ( NULL == (pNewLocationList = ClientAlloc( sizeof(DWORD) * 3 + 
+                         sizeof(LOCATION) * nNumLocations)) )
+    {
+       DBGOUT((1, "MEM ALLOC (0x%08lx) FAILED!! WriteLoc",
+          (nNumLocations * sizeof(LOCATION)) + (sizeof(DWORD) * 3) ));
+
+       return LINEERR_NOMEM;
+    }
+
+    funcArgs.Args[3] = (DWORD)pNewLocationList;
+
+
+    CopyMemory( (PBYTE)pNewLocationList + ( 3 * sizeof(DWORD) ),
+                pLocationList,
+                nNumLocations * sizeof(LOCATION)
+              );
+
+    //
+    // Set "dwTotalSize"
+    //
+    ((LPDWORD)pNewLocationList)[0] = (3 * sizeof(DWORD)) +
+                (nNumLocations * sizeof(LOCATION));
+
+
+    lResult =  (DOFUNC (&funcArgs, "TWriteLocations"));
+
+    if ( 0 != lResult )
+    {
+        ClientFree( pNewLocationList );
+        goto WL_ERROR;
+    }
+
+
+    pString = ClientAlloc( 256 * sizeof(WCHAR) );
+
+    for ( n = 0;  n < nNumLocations;  n++)
+    {
+        PLOCATION ThisLocation;
+        DWORD     dwDisposition;
+        DWORD     dwDataType;
+        DWORD     dwDataSize;
+        HKEY      hKey;
+        HKEY      hKey2;
+
+
+        ThisLocation = &(pLocationList[n]);
+
+
+        wsprintfW( pString, L"%ls\\%ls%ld",
+                               gszLocationsW,
+                               gszLocationW,
+                               n );
+
+        //
+        // Now write the card ID to the CURRENT USER section
+        //
+        RegCreateKeyExW(
+                        HKEY_CURRENT_USER,
+                        gszTelephonyKey,
+                        0,
+                        gszNullStringW,   //Class - what class?
+                        REG_OPTION_NON_VOLATILE,
+                        KEY_ALL_ACCESS,
+                        0,
+                        &hKey2,
+                        &dwDisposition
+                      );
+
+        RegCreateKeyExW(
+                        hKey2,
+                        pString,
+                        0,
+                        gszNullStringW,   //Class - what class?
+                        REG_OPTION_NON_VOLATILE,
+                        KEY_ALL_ACCESS,
+                        0,
+                        &hKey,
+                        &dwDisposition
+                      );
+
+        RegSetValueExW(
+                       hKey,
+                       gszCallingCardW,
+                       0,
+                       REG_DWORD,
+                       (LPBYTE)&ThisLocation->dwCallingCard,
+                       sizeof(DWORD)
+                     );
+
+        RegCloseKey( hKey );
+        RegCloseKey( hKey2);
+
+    }
+
+    ClientFree( pString );
+    ClientFree( pNewLocationList );
+
+WL_ERROR:
+
+    return lResult;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL ReadLocations( PLOCATION *pLocationSpace,
+                           PUINT *pnStuff,
+                           HLINEAPP hLineApp,
+                           DWORD dwDeviceID,
+                           DWORD dwAPIVersion,
+                           DWORD dwParmsToCheckFlags
+                         )
+{
+    FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, tReadLocations),
+
+        {
+            (DWORD)hLineApp,
+
+            dwDeviceID,
+
+            dwAPIVersion,
+
+            dwParmsToCheckFlags,
+
+            0     // (DWORD) pLocationSpace
+        },
+
+        {
+            hXxxApp_NULLOK,
+            Dword,
+            Dword,
+            Dword,
+            lpGet_Struct
+        }
+    };
+
+    PBYTE pTemp;
+    PBYTE pNewBuf;
+    LONG  lResult;
+    PBYTE pNewLocationSpace;
+    UINT  n;
+    PWSTR pString;
+
+
+    //
+    // A quick check to see if this is pointless
+    //
+    if (
+          (NULL == pLocationSpace)
+        &&
+          (gLocationList)
+       )
+    {
+        return 0;
+    }
+    
+    
+    //
+    // Do it once to get the dwNeededSize (if there are less than 5 locations
+    // this will be the only call we'll need to make)
+    //
+    // ( sizeof(DWORD) * 6 is for dwTotalsize, usedsize&needed size & pnstuff )
+    //
+    pTemp = ClientAlloc( (sizeof(DWORD) * 6) +
+                         (sizeof(LOCATION) * 4)
+                       );
+
+
+    if ( NULL == pTemp )
+    {
+        DBGOUT((1, "Mem alloc (0x%08lx) Failed! ReadLoc",
+          (sizeof(DWORD) * 6 ) + (sizeof(LOCATION) * 4) ));
+          
+        lResult = LINEERR_NOMEM;
+        goto RL_ERROR;
+    }
+        
+    ((LPDWORD)pTemp)[DWTOTALSIZE] = (sizeof(DWORD) * 6) +
+                                   (sizeof(LOCATION) * 4);
+
+    funcArgs.Args[4] = (DWORD)pTemp;
+
+    lResult =  (DOFUNC (&funcArgs, "TReadLocations"));
+
+    if ( 0 != lResult )
+    {
+        ClientFree( pTemp );
+        goto RL_ERROR;
+    }
+
+
+    //
+    // Did we have enough room?
+    //
+    if ( ((LPDWORD)pTemp)[DWTOTALSIZE]  <  ((LPDWORD)pTemp)[DWNEEDEDSIZE] )
+    {
+        //
+        // No, do it to really get the struct
+        //
+        pNewBuf = ClientAlloc( ((LPDWORD)pTemp)[DWNEEDEDSIZE] );
+
+        if ( NULL == pTemp )
+        {
+            DBGOUT((1, "Mem alloc (0x%08lx) Failed! ReadLoc2",
+                       ((LPDWORD)pTemp)[1] ));
+          
+            lResult = LINEERR_NOMEM;
+            goto RL_ERROR;
+        }
+        
+        ((LPDWORD)pNewBuf)[DWTOTALSIZE] = ((LPDWORD)pTemp)[DWNEEDEDSIZE];
+
+        ClientFree( pTemp );
+
+        funcArgs.Args[4] = (DWORD)pNewBuf;
+
+        lResult =  (DOFUNC (&funcArgs, "TReadLocations"));
+
+        if ( 0 != lResult )
+        {
+            ClientFree( pNewBuf );
+            goto RL_ERROR;
+        }
+    }
+    else
+    {
+        //
+        // Do as if we didn't make it...
+        //
+        pNewBuf = pTemp;
+    }
+
+
+    pNewLocationSpace = ClientAlloc( ((LPDWORD)pNewBuf)[DWNEEDEDSIZE] - (sizeof(DWORD) * 6) );
+
+    CopyMemory( pNewLocationSpace,
+                pNewBuf + (sizeof(DWORD) * 6),
+                ((LPDWORD)pNewBuf)[DWNEEDEDSIZE] - (sizeof(DWORD) * 6)
+              );
+
+    if ( pLocationSpace )
+    {
+       *pLocationSpace = (PLOCATION)pNewLocationSpace;
+    }
+
+
+
+#pragma message("where should this be?")
+// Can't be in TAPISRV because it doesn't know HKEY_CURRENT_USER (well, it could impersonate...)
+
+    pString = ClientAlloc( 256 * sizeof(WCHAR) );
+
+    //
+    // For each location, get the current loc from HKEY_CURRENT_USER
+    //
+    for ( n = 0;  n < ((LPUINT)pNewBuf)[5];  n++)
+    {
+        PLOCATION ThisLocation;
+        DWORD     dwDataType;
+        DWORD     dwDataSize;
+        HKEY      hKey;
+        HKEY      hKey2;
+
+        ThisLocation = &(((PLOCATION)pNewLocationSpace)[n]);
+
+        wsprintfW( pString, L"%ls\\%ls%ld",
+                               gszLocationsW,
+                               gszLocationW,
+                               n );
+
+
+        //
+        // Now get the card ID from the CURRENT USER section
+        //
+        RegOpenKeyExW(
+                      HKEY_CURRENT_USER,
+                      gszTelephonyKey,
+                      0,
+                      KEY_READ,
+                      &hKey2
+                    );
+
+        RegOpenKeyExW(
+                      hKey2,
+                      pString,
+                      0,
+                      KEY_READ,
+                      &hKey
+                    );
+
+        dwDataSize = sizeof(DWORD);
+        ThisLocation->dwCallingCard = 0;
+        RegQueryValueExW(
+                         hKey,
+                         gszCallingCardW,
+                         0,
+                         &dwDataType,
+                         (LPBYTE)&ThisLocation->dwCallingCard,
+                         &dwDataSize
+                       );
+
+        RegCloseKey( hKey );
+        RegCloseKey( hKey2);
+
+    }
+
+    ClientFree( pString );
+
+
+    //
+    // Did the caller give us a place to put this stuff?
+    //
+    if ( pnStuff )
+    {
+       *pnStuff = ClientAlloc( 3 * sizeof(UINT) );
+
+       (*pnStuff)[0] = ((LPUINT)pNewBuf)[3];
+       (*pnStuff)[1] = (UINT)pNewLocationSpace;
+       (*pnStuff)[2] = ((LPUINT)pNewBuf)[5];
+    }
+    else
+    {
+       gnCurrentLocationID =   ((LPUINT)pNewBuf)[3];
+       gLocationList =         (PLOCATION)pNewLocationSpace;
+       gnNumLocations =        ((LPUINT)pNewBuf)[5];
+    }
+
+
+    ClientFree( pNewBuf );
+
+
+RL_ERROR:
+
+    return lResult;
+}
+
+
+
+// //***************************************************************************
+// //***************************************************************************
+// //***************************************************************************
+// LONG PASCAL ReadLocationsEasy( 
+//                                PLOCATION *pLocationSpace,
+//                                LPUINT *pnStuff )
+// {
+//    UINT n;
+// 
+// 
+// //BUGBUG:PERFORMANCE: Start with space for 3 locations
+// 
+//    n = 0;
+//    ReadLocations( (PLOCATION)&n, NULL);
+// 
+// 
+//    *pLocationSpace = ClientAlloc( (n * sizeof(LOCATION)) + sizeof(DWORD) );
+// 
+//    if ( NULL == *pLocationSpace )
+//    {
+//       //*** *** ***BUGBUG Handle the error
+//    }
+// 
+// 
+//    *(PUINT)*pLocationSpace = n;
+// 
+//    *pnStuff = ClientAlloc( 3 * sizeof(DWORD) );
+// 
+//    if ( NULL == *pnStuff )
+//    {
+//       ClientFree( *pLocationSpace );
+// 
+//       return LINEERR_NOMEM;
+//    }
+// 
+//    return ReadLocations( *pLocationSpace, *pnStuff );
+// }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL AddLocationToListbox( HWND hWnd, UINT nIndex)
+{
+   LONG lItemIndex;
+
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_NAME];
+
+
+   WideCharToMultiByte(
+                        GetACP(),
+                        0,
+                        gLocationList[nIndex].NameW,
+                        -1,
+                        szTempString,
+                        sizeof(szTempString),
+                        NULL,
+                        NULL
+                      );
+#endif
+
+   lItemIndex =
+#ifdef PARTIAL_UNICODE
+      SendDlgItemMessage(
+#else
+      SendDlgItemMessageW(
+#endif
+       hWnd,
+       IDCC_DL_NAME,
+       CB_ADDSTRING,
+       0,
+#ifdef PARTIAL_UNICODE
+       (LPARAM)szTempString
+#else
+       (LPARAM)gLocationList[nIndex].NameW
+#endif
+       );
+
+   SendDlgItemMessage(
+       hWnd,
+       IDCC_DL_NAME,
+       CB_SETITEMDATA,
+       (WPARAM) lItemIndex,
+       (LPARAM)(DWORD) &(gLocationList[nIndex])
+       );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void RedoLocationListbox( HWND hWnd,
+                          PLOCATION pLocationList,
+                          UINT nNumLocations,
+                          PLOCATION pCurrentLocation)
+{
+   //
+   // sledgehammer - refill the listbox
+   //
+   UINT n;
+#ifdef PARTIAL_UNICODE
+   CHAR szTempString[MAXLEN_NAME];
+#endif
+
+   SendDlgItemMessage(
+                       hWnd,
+                       IDCC_DL_NAME,
+                       CB_RESETCONTENT,
+                       0,
+                       0
+                     );
+
+   for ( n=0; n<nNumLocations; n++ )
+   {
+      if ( pLocationList[n].NameW[0] != '\0' )
+         AddLocationToListbox( hWnd, n);
+   }
+
+
+#ifdef PARTIAL_UNICODE
+   WideCharToMultiByte(
+                        GetACP(),
+                        0,
+                        pCurrentLocation->NameW,
+                        -1,
+                        szTempString,
+                        sizeof(szTempString),
+                        NULL,
+                        NULL
+                      );
+#endif
+
+   //
+   // Select the proper location
+   //
+#ifdef PARTIAL_UNICODE
+   SendDlgItemMessage(
+#else
+   SendDlgItemMessageW(
+#endif
+       hWnd,
+       IDCC_DL_NAME,
+       CB_SELECTSTRING,
+       (WPARAM)-1,
+#ifdef PARTIAL_UNICODE
+       (LPARAM)szTempString
+#else
+       (LPARAM)pCurrentLocation->NameW
+#endif
+       );
+
+            
+          SendDlgItemMessage(
+                                 hWnd,
+                                 IDCC_DL_NAME,
+                                 CB_SETEDITSEL,
+                                 0,
+                                 MAKELPARAM(-2,-2)
+                             );
+
+}
+
+
+//////////////////////////////////////////////////////////////////
+//  CheckForDupLocation - check dialing locations list box
+//  to see if there is a duplicate
+//  return FALSE is there is a bad entry and TRUE if there 
+//  is not
+//////////////////////////////////////////////////////////////////
+BOOL CheckForDupLocation(HWND hWnd,
+                         int  iLastEdit)
+{                        
+  WCHAR   szTempString1[MAXLEN_NAME];
+  WCHAR   szTempString2[MAXLEN_NAME];
+  int     count, n;
+
+  if (iLastEdit != -1)
+  {
+      // get text that was last edited
+      SendDlgItemMessageW(hWnd,
+                         IDCC_DL_NAME,
+                         CB_GETLBTEXT,
+                         (WPARAM)iLastEdit,
+                         (LPARAM)(LPTSTR)szTempString1);
+
+      // get total locations in list box
+      count = SendDlgItemMessage(hWnd,
+                                 IDCC_DL_NAME,
+                                 CB_GETCOUNT,
+                                 0,
+                                 0);
+
+      // cycle through and if 2 match, then it's a dup
+      for (n = 0; n < count; n++)
+      {
+          if (n == iLastEdit)
+          {
+              continue;
+          }
+
+          SendDlgItemMessageW(hWnd,
+                             IDCC_DL_NAME,
+                             CB_GETLBTEXT,
+                             (WPARAM)n,
+                             (LPARAM)(LPTSTR)szTempString2);
+
+          if (!lstrcmpiW(szTempString1, szTempString2))
+          {
+               PWSTR buf1;
+               PWSTR buf2;
+
+               // put up messagebox
+               buf1 = ClientAlloc( 512 * sizeof(WCHAR));
+               buf2 = ClientAlloc( 512 * sizeof(WCHAR));
+
+               LoadStringW(ghInst, IDS_DL_DUP_NAME, buf1, 512 );
+               LoadStringW(ghInst, IDS_DL_DUP_NAME_CAPTION, buf2, 512 );
+
+               MessageBoxW( hWnd,
+                            buf1,
+                            buf2,
+                            MB_OK
+                          );
+
+               ClientFree( buf1 );
+               ClientFree( buf2 );
+
+               // set selection back
+              SendDlgItemMessageW(hWnd,
+                                 IDCC_DL_NAME,
+                                 CB_SETCURSEL,
+                                 (WPARAM)iLastEdit,
+                                 0);
+
+              // set edit control back to display correct text
+              SetDlgItemTextW(hWnd,
+                             IDCC_DL_NAME,
+                             szTempString1);
+
+              // set focus
+              SetFocus(GetDlgItem(hWnd,
+                                  IDCC_DL_NAME));
+              
+              return FALSE;
+          }
+      }
+  }
+
+  return TRUE;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL FillLocationsListbox( HWND hWnd )
+{
+    UINT n;
+    LONG lResult;
+
+
+    if ( 0 != ( lResult = ReadLocations( NULL, NULL, 0, 0, 0, 0)) )
+    {
+       return lResult;
+    }
+
+
+    //
+    // Put the location names in the location listbox
+    //
+    for (n = 0; n < gnNumLocations; n++)
+    {
+       AddLocationToListbox( hWnd, n);
+    }
+
+
+    return 0;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL FillDisableCallWaitingListbox( HWND hWnd )
+{
+    UINT  n;
+    UINT  nNumStrings;
+#ifdef PARTIAL_UNICODE
+    CHAR key[32];
+    CHAR buf[MAXLEN_DISABLECALLWAITING];
+#else
+    WCHAR buf[MAXLEN_DISABLECALLWAITING];
+    WCHAR key[32];
+#endif
+    HKEY  hKey;
+    HKEY  hKey2;
+    DWORD dwDataType;
+    DWORD dwDataSize;
+
+
+    RegOpenKeyExW(
+                  HKEY_LOCAL_MACHINE,
+                  gszTelephonyKey,
+                  0,
+                  KEY_READ,
+                  &hKey2
+                );
+
+    RegOpenKeyExW(
+                  hKey2,
+                  gszLocationsW,
+                  0,
+                  KEY_READ,
+                  &hKey
+                );
+
+    dwDataSize = sizeof(nNumStrings);
+    nNumStrings = 0;
+    RegQueryValueExW(
+                   hKey,
+                   gszDisableCallWaitingW,
+                   0,
+                   &dwDataType,
+                   (LPBYTE)&nNumStrings,
+                   &dwDataSize
+                 );
+
+//BUGBUG if # == 0, pull from RES and write to Reg
+
+
+    //
+    // Put the strings in the DisableCallWaiting listbox
+    //
+    for (n = 0; n < nNumStrings; n++)
+    {
+#ifdef PARTIAL_UNICODE
+        wsprintf(key, "%ls%d", gszDisableCallWaitingW, n);
+#else
+        wsprintfW(key, L"%ls%d", gszDisableCallWaitingW, n);
+#endif
+
+        dwDataSize = sizeof(buf);
+        buf[0] = '\0';
+#ifdef PARTIAL_UNICODE
+        RegQueryValueEx(
+#else
+        RegQueryValueExW(
+#endif
+                       hKey,
+                       key,
+                       0,
+                       &dwDataType,
+                       (LPBYTE)buf,
+                       &dwDataSize
+                     );
+        buf[dwDataSize/sizeof(WCHAR)] = '\0';
+
+#ifdef PARTIAL_UNICODE
+   SendDlgItemMessage(
+#else
+   SendDlgItemMessageW(
+#endif
+                       hWnd,
+                       IDCC_DL_CALLWAITING,
+                       CB_ADDSTRING,
+                       0,
+                       (LPARAM)buf
+                       );
+
+    }
+
+    RegCloseKey( hKey );
+    RegCloseKey( hKey2);
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL FillDialingPropertyDialog( HWND hWnd, PLOCATION CurrentLocation)
+{
+    LONG lCurCountry;
+    LONG nNumCountries;
+    LONG n;
+#ifdef PARTIAL_UNICODE
+    CHAR szTempString[MAXLEN_NAME];
+#endif
+
+
+#ifdef PARTIAL_UNICODE
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         CurrentLocation->NameW,
+                         -1,
+                         szTempString,
+                         sizeof(szTempString),
+                         NULL,
+                         NULL
+                       );
+#endif
+
+
+    //
+    // Select the proper location
+    //
+#ifdef PARTIAL_UNICODE
+    SendDlgItemMessage(
+#else
+    SendDlgItemMessageW(
+#endif
+        hWnd,
+        IDCC_DL_NAME,
+        CB_SELECTSTRING,
+        (WPARAM)-1,
+#ifdef PARTIAL_UNICODE
+        (LPARAM)szTempString
+#else
+        (LPARAM)CurrentLocation->NameW
+#endif
+        );
+
+
+#ifdef PARTIAL_UNICODE
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         CurrentLocation->AreaCodeW,
+                         -1,
+                         szTempString,
+                         sizeof(szTempString),
+                         NULL,
+                         NULL
+                       );
+#endif
+
+    //
+    // Set the Area Code field
+    //
+#ifdef PARTIAL_UNICODE
+    SetDlgItemText(
+#else
+    SetDlgItemTextW(
+#endif
+                    hWnd,
+                    IDCE_DL_AREACODE,
+#ifdef PARTIAL_UNICODE
+                    szTempString);
+#else
+                    CurrentLocation->AreaCodeW);
+#endif
+
+
+    //
+    // Set the correct country
+    //
+    nNumCountries = SendDlgItemMessage( hWnd,
+                        IDCC_DL_COUNTRY,
+                        CB_GETCOUNT,
+                        0,
+                        0);
+
+    lCurCountry = (LONG)CurrentLocation->dwCountry;
+
+    //
+    // Run through the country list looking for a match
+    //
+    for (n=0; n < nNumCountries; n++)
+    {
+        LONG lCountryID;
+
+        lCountryID = SendDlgItemMessage( hWnd,
+                        IDCC_DL_COUNTRY,
+                        CB_GETITEMDATA,
+                        (WPARAM)n,
+                        0);
+
+        if ( lCountryID == lCurCountry )
+        {
+           break;
+        }
+    }
+
+    SendDlgItemMessage( hWnd,
+                        IDCC_DL_COUNTRY,
+                        CB_SETCURSEL,
+                        (WPARAM)n,
+                        0);
+
+
+
+#ifdef PARTIAL_UNICODE
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         CurrentLocation->OutsideAccessW,
+                         -1,
+                         szTempString,
+                         sizeof(szTempString),
+                         NULL,
+                         NULL
+                       );
+#endif
+
+    //
+    // Set the Outside Access field
+    //
+#ifdef PARTIAL_UNICODE
+    SetDlgItemText(
+#else
+    SetDlgItemTextW(
+#endif
+                    hWnd,
+                    IDCE_DL_OUTSIDEACCESS,
+#ifdef PARTIAL_UNICODE
+                    szTempString);
+#else
+                    CurrentLocation->OutsideAccessW);
+#endif
+
+
+#ifdef PARTIAL_UNICODE
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         CurrentLocation->LongDistanceAccessW,
+                         -1,
+                         szTempString,
+                         sizeof(szTempString),
+                         NULL,
+                         NULL
+                       );
+#endif
+
+    // Set the Long Distance Access field
+    //
+#ifdef PARTIAL_UNICODE
+    SetDlgItemText(
+#else
+    SetDlgItemTextW(
+#endif
+                    hWnd,
+                    IDCE_DL_LONGDISTANCEACCESS,
+#ifdef PARTIAL_UNICODE
+                    szTempString);
+#else
+                    CurrentLocation->LongDistanceAccessW);
+#endif
+
+
+    //
+    // Set the Tone & Pulse buttons
+    //
+    CheckRadioButton( hWnd,
+                      IDCR_PULSE,
+                      IDCR_TONE,
+                      (CurrentLocation->dwFlags & LOCATION_USETONEDIALING) ?
+                               IDCR_TONE :
+                               IDCR_PULSE);
+
+
+
+    //
+    // Set the calling card checkbox and calling card name field
+    //
+    CheckDlgButton( hWnd,
+                    IDCK_DL_CALLINGCARD,
+                    (CurrentLocation->dwFlags & LOCATION_USECALLINGCARD) );
+
+
+    n = GetCardIndexFromID( CurrentLocation->dwCallingCard,
+                            gpCardList,
+                            gpnStuff[2]
+                          );
+
+    if ( (LONG)(-1) == n )
+    {
+        n = 0;
+    }
+    
+
+#ifdef PARTIAL_UNICODE
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         gpCardList[n].NameW,
+                         -1,
+                         szTempString,
+                         MAXLEN_NAME,
+                         NULL,
+                         NULL
+                       );
+#endif
+
+#ifdef PARTIAL_UNICODE
+    SetDlgItemText(
+#else
+    SetDlgItemTextW(
+#endif
+                    hWnd,
+                    IDCE_DL_CALLINGCARD,
+#ifdef PARTIAL_UNICODE
+                    szTempString
+#else
+                    gpCardList[n].NameW
+#endif
+                  );
+
+
+    //
+    // Does this location use a calling card?
+    //
+    if ( CurrentLocation->dwFlags & LOCATION_USECALLINGCARD )
+    {
+       EnableWindow( GetDlgItem(hWnd, IDCE_DL_CALLINGCARD), TRUE );
+    }
+    else
+    {
+       //
+       // Disable the Calling Card name field
+       //
+       EnableWindow( GetDlgItem(hWnd, IDCE_DL_CALLINGCARD), FALSE );
+    }
+
+
+    //
+    // Set the callwaiting checkbox and callwaiting string
+    //
+    CheckDlgButton( hWnd,
+                    IDCK_DL_CALLWAITING,
+                    (CurrentLocation->dwFlags & LOCATION_HASCALLWAITING) );
+
+
+    EnableWindow( GetDlgItem(hWnd, IDCC_DL_CALLWAITING), 
+                        (CurrentLocation->dwFlags & LOCATION_HASCALLWAITING) ?
+                             TRUE :
+                             FALSE
+                        );
+
+
+#ifdef PARTIAL_UNICODE
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         CurrentLocation->DisableCallWaitingW,
+                         -1,
+                         szTempString,
+                         sizeof(szTempString),
+                         NULL,
+                         NULL
+                       );
+#endif
+
+    //
+    // Set the Outside Access field  (even if the field is disabled.  We
+    // wanna show what it was, or would be, or clear it out from the last
+    // location.)
+    //
+#ifdef PARTIAL_UNICODE
+    SetDlgItemText(
+#else
+    SetDlgItemTextW(
+#endif
+                    hWnd,
+                    IDCC_DL_CALLWAITING,
+#ifdef PARTIAL_UNICODE
+                    szTempString);
+#else
+                    CurrentLocation->DisableCallWaitingW);
+#endif
+
+
+    return;
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL ToneDialingIsDefault( void )
+{
+   TCHAR sBuffer[8];  // In case the string is "PULSE" instead of "P"
+   LONG lBuffLen = sizeof(sBuffer);
+   LONG lBuffType = 0;
+   LONG lRetCode;
+   HKEY hKey;
+
+
+   lRetCode = RegOpenKey( HKEY_CURRENT_USER,
+                           "Control Panel\\International",
+                              &hKey);
+
+   lRetCode = RegQueryValueEx( hKey,
+                                 "DefaultDialMode",
+                                 NULL,
+                                 &lBuffType,
+                                 sBuffer,
+                                 &lBuffLen);
+
+   lRetCode = RegCloseKey( hKey );
+
+
+   //
+   // If the type is a STRING, _and_ the first char is 'P', then 
+   // we set the tone/pulse default to PULSE.  Otherwise, the
+   // default is TONE.
+   if (
+         ( lBuffType == REG_SZ )
+         &&
+         ( sBuffer[0] == 'P' )
+      )
+   {
+      return FALSE;
+   }
+
+   return TRUE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL IsBadCountryCode( UINT nCountryCode )
+{
+  LONG lResult;
+  LPLINECOUNTRYLIST pLCL;
+
+  lResult =  ReadCountries( &pLCL, nCountryCode, 0 );
+
+  if ( pLCL )
+     ClientFree( pLCL );
+
+  return lResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+static TCHAR gszInternationalSec[] = "intl";
+static TCHAR gszCountryEntry[]     = "iCountry";
+
+UINT GetCountryCodeFromiCountry()
+{
+  UINT nCountryCode;
+
+
+  nCountryCode = GetProfileInt( gszInternationalSec, 
+                                gszCountryEntry, 
+                                1 );
+
+
+  InternalDebugOut((20, "Entering GetCountryCodeFromiCountry"));
+  //
+  // Verify that we believe that the iCountry setting is a country
+  // code _we_ know about as well.
+  //
+  if ( IsBadCountryCode(nCountryCode) )
+  {
+     //
+     // This don't seem like a valid country code.
+     //*** *** ***Spit out a debug message, (maybe a msgbox for users?).
+     //
+     InternalDebugOut((1, "IsBadCountryCode, nCountryCode= 0x%08lx", (DWORD)nCountryCode));
+     nCountryCode = 1;
+  }
+
+  InternalDebugOut((20, "Leaving GetCountryCodeFromiCountry, nCountryCode= 0x%08lx", (DWORD)nCountryCode));
+  return nCountryCode;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void AllocNewID( HKEY MainKey, LPDWORD lpdw )
+{
+    LONG lResult;
+      
+    //
+    // Is this a new LocationID?
+    //
+    if ( HKEY_LOCAL_MACHINE == MainKey )
+    {
+        FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 1, tAllocNewID),
+            {
+                (DWORD)lpdw
+            },
+
+            {
+                lpDword
+            }
+        };
+
+       //
+       // Yes, let TAPISRV do it without danger of AV interruption from
+       // another thread
+       //
+
+       lResult = DOFUNC (&funcArgs, "TAllocNewID");
+       
+    }
+    else
+    {
+
+       HKEY  hKey;
+       HKEY  hKey2;
+       DWORD dwDataSize;
+       DWORD dwDataType;
+       DWORD dwNewID;
+       DWORD dwDisposition;
+
+       RegCreateKeyExW(
+                     HKEY_CURRENT_USER,
+                     gszTelephonyKey,
+                     0,
+                     gszNullStringW,
+                     REG_OPTION_NON_VOLATILE,
+                     KEY_READ,
+                     0,
+                     &hKey2,
+                     &dwDisposition
+                   );
+
+       RegCreateKeyExW(
+                     hKey2,
+                     gszCardsW,
+                     0,
+                     gszNullStringW,
+                     REG_OPTION_NON_VOLATILE,
+                     KEY_ALL_ACCESS,
+                     0,
+                     &hKey,
+                     &dwDisposition
+                   );
+
+       dwDataSize = sizeof(DWORD);
+
+       //
+       // Use 1 as the first ID.
+       //
+       *lpdw = 1;
+       RegQueryValueExW(
+                        hKey,
+                        gszNextIDW,
+                        0,
+                        &dwDataType,
+                        (LPBYTE)lpdw,
+                        &dwDataSize
+                      );
+
+
+       dwNewID = *lpdw + 1;
+
+       RegSetValueExW(
+                      hKey,
+                      gszNextIDW,
+                      0,
+                      REG_DWORD,
+                      (LPBYTE)&dwNewID,
+                      sizeof(DWORD)
+                    );
+
+       RegCloseKey( hKey );
+       RegCloseKey( hKey2);
+    }
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL PASCAL SimpleProcessing(
+                              HWND hWnd,
+                              PLOCATION pThisLocation
+                            )
+{
+    LPLINECOUNTRYLIST pLCL;
+    UINT n;
+
+    n = ReadCountries( &pLCL, pThisLocation->dwCountry, 0 );
+
+    if (
+        ( 0 == lstrlenW( pThisLocation->AreaCodeW ) )
+      &&
+        ( 0 == n )
+     )
+    {
+        LPLINECOUNTRYENTRY pCountryEntry;
+
+        pCountryEntry = (LPLINECOUNTRYENTRY)
+              (((LPBYTE) pLCL) + pLCL->dwCountryListOffset);
+
+        //
+        // Does this country HAVE TO have an area code?
+        //
+        if ( wcschr ( (PWSTR)((LPBYTE)pLCL +
+                   pCountryEntry->dwLongDistanceRuleOffset),
+                   'F' ) )
+        {
+           PWSTR buf1;
+           PWSTR buf2;
+
+           buf1 = ClientAlloc( 512 * sizeof(WCHAR));
+           buf2 = ClientAlloc( 512 * sizeof(WCHAR));
+
+           LoadStringW(ghInst, IDS_WRN_AREA_CODE_REQUIRED, buf1, 512 );
+           LoadStringW(ghInst, DIALINGPROPERTIES_NAME, buf2, 512 );
+
+           MessageBoxW( hWnd,
+                        buf1,
+                        buf2,
+                        MB_OK
+                      );
+
+           ClientFree( buf1 );
+           ClientFree( buf2 );
+
+           SetFocus(GetDlgItem(hWnd, IDCE_DL_AREACODE));
+
+           SetWindowLong( hWnd, DWL_MSGRESULT, TRUE );
+
+           ClientFree( pLCL );
+           
+           return TRUE;
+        }
+    }
+    
+    if ( pLCL )
+    {
+        ClientFree( pLCL );
+    }
+    
+    return FALSE;
+}
+                  
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+/*--------------------------------------------------------------------------*\
+
+   Function:   LocDefineDlgSimple
+   
+   Purpose:
+   
+\*--------------------------------------------------------------------------*/
+
+BOOL CALLBACK  LocDefineDlgSimple( HWND  hWnd, 
+                          UINT  uMessage, 
+                          WPARAM  wParam, 
+                          LPARAM  lParam )
+{
+    UINT  uResult=TRUE;
+    WPARAM wCmdId=0;
+    WPARAM wCmdCbn=0;
+    LONG  lResult=0;
+    LONG  n;
+    LONG  nNumCountries;
+    LONG  nCurrentCountry;
+    LONG  nCountryID;
+
+    LONG lThisCountryIndex;
+    static PLOCATION pThisLocation = NULL;
+
+#ifdef PARTIAL_UNICODE
+    CHAR szTempString[MAXLEN_NAME];
+#endif
+
+// table of controls and context-sensitive help IDs
+
+    static DWORD aIds[] = 
+        {
+        IDCS_DL_AREACODE, IDH_TAPI_AREA_CODE,
+        IDCE_DL_AREACODE, IDH_TAPI_AREA_CODE,
+        IDCS_DL_COUNTRY, IDH_TAPI_COUNTRY,
+        IDCC_DL_COUNTRY, IDH_TAPI_COUNTRY,
+        IDCE_DL_OUTSIDEACCESS, IDH_TAPI_ACCESS_LINE,
+        IDCS_DL_OUTSIDEACCESS, IDH_TAPI_ACCESS_LINE,
+        IDCR_PULSE, IDH_TAPI_LOCATION_PULSE,
+        IDCR_TONE, IDH_TAPI_LOCATION_PULSE,
+        0, 0
+        };
+
+    
+    switch (uMessage) 
+    {
+        // Process clicks on controls after Context Help mode selected
+        case WM_HELP:
+            InternalDebugOut((50, "  WM_HELP in LocDefineDlgSimple"));
+            WinHelp (((LPHELPINFO) lParam)->hItemHandle, "windows.hlp", HELP_WM_HELP, 
+                                        (DWORD)(LPSTR) aIds);
+            uResult = FALSE;
+            break;
+
+
+        // Process right-clicks on controls            
+        case WM_CONTEXTMENU:
+            InternalDebugOut((50, "  WM_CONTEXTMENU in LocDefineDlgSimple"));
+            WinHelp ((HWND) wParam, "windows.hlp", HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+            uResult = FALSE;
+            break;
+
+
+        case  WM_INITDIALOG:
+
+        InternalDebugOut((50, "  WM_INITDIALOG in LocDefineDlgSimple"));
+
+
+        //
+        // Don't let a user cancel out of here
+        //
+        //(Do one for simple, one for wiz...
+        //
+        EnableWindow( GetDlgItem(hWnd, IDCANCEL), FALSE);
+        EnableWindow( GetDlgItem(GetParent(hWnd), IDCANCEL), FALSE);
+
+
+        pThisLocation = ClientAlloc( sizeof(LOCATION) );
+
+        if ( NULL == pThisLocation )
+        {
+           InternalDebugOut((1, "Memory alloc failed!"));
+           return LINEERR_NOMEM;
+        }
+
+        //
+        // Fill in some default fields
+        //
+        LoadStringW(
+                    ghInst,
+                    IDS_NEWLOCATION,
+                    pThisLocation->NameW,
+                    MAXLEN_NAME
+                  );
+
+        pThisLocation->dwFlags = ToneDialingIsDefault() ?
+                                    LOCATION_USETONEDIALING :
+                                    0;
+
+
+        AllocNewID( HKEY_LOCAL_MACHINE,
+                    &(pThisLocation->dwID) );
+
+        FillCountriesListbox( hWnd );
+
+
+        nCurrentCountry = GetCountryCodeFromiCountry();
+
+        //
+        // Set the correct country
+        //
+        nNumCountries = SendDlgItemMessage( hWnd,
+                                            IDCC_DL_COUNTRY,
+                                            CB_GETCOUNT,
+                                            0,
+                                            0
+                                          );
+
+        //
+        // Run through the country list looking for a match
+        //
+        for (n=0; n < nNumCountries; n++)
+        {
+            nCountryID = SendDlgItemMessage( hWnd,
+                            IDCC_DL_COUNTRY,
+                            CB_GETITEMDATA,
+                            (WPARAM)n,
+                            0);
+
+            if ( nCountryID == nCurrentCountry )
+            {
+               break;
+            }
+        }
+
+        //
+        // Did we find a hit?
+        //
+        if ( n == nNumCountries )
+        {
+           //
+           // No.  Use the top country.
+           //
+           n = 0;
+        }
+
+        SendDlgItemMessage( hWnd,
+                            IDCC_DL_COUNTRY,
+                            CB_SETCURSEL,
+                            (WPARAM)n,
+                            0);
+
+        pThisLocation->dwCountry = SendDlgItemMessage(
+                                      hWnd,
+                                      IDCC_DL_COUNTRY,
+                                      CB_GETITEMDATA,
+                                      n,
+                                      0);
+
+
+
+//            EnableWindow( GetDlgItem(hWnd, IDCANCEL), FALSE );
+
+       //
+       // Set some limits on the edit fields
+       //
+       SendDlgItemMessage(
+                hWnd,
+                IDCC_DL_NAME,
+                EM_LIMITTEXT,
+                MAXLEN_NAME,
+                0);
+       SendDlgItemMessage(
+                hWnd,
+                IDCE_DL_AREACODE,
+                EM_LIMITTEXT,
+                MAXLEN_AREACODE,
+                0);
+       SendDlgItemMessage(
+                hWnd,
+                IDCE_DL_OUTSIDEACCESS,
+                EM_LIMITTEXT,
+                MAXLEN_OUTSIDEACCESS,
+                0);
+
+
+//11/19            if ((uResult = CntrySetFocus( hWnd, IDCC_DL_COUNTRY_CODE, (LpLocGetDefault())->dwCountryCode )) != CPL_SUCCESS )
+//11/19                goto  LError;
+
+            SetDlgItemText( hWnd, IDCE_DL_OUTSIDEACCESS, NULL );
+
+            SetDlgItemText( hWnd, IDCE_DL_AREACODE, NULL );
+
+
+            CheckRadioButton( hWnd,
+                              IDCR_PULSE,
+                              IDCR_TONE,
+                              ToneDialingIsDefault() ?
+                                               IDCR_TONE
+                                             : IDCR_PULSE );
+
+
+            //
+            // Is an area code required?
+            //
+//BUGBUG: Disable CLOSE button until user enters a valid area code (if req'd)
+
+
+            //
+            // Should we use the "Your modem's been inited" text instead?
+            //
+            if ( lParam )
+            {
+#ifdef PARTIAL_UNICODE
+               LPSTR lpString;
+#else
+               LPWSTR lpString;
+#endif
+
+               lpString = ClientAlloc(1524);
+               
+               if ( NULL != lpString )
+               {
+#ifdef PARTIAL_UNICODE
+                  LoadString( 
+#else
+                  LoadStringW(
+#endif
+                              ghInst,
+                              IDS_MSG_SIMPLEMSG_MDMINSTALLED,
+                              lpString,
+                              ClientSize(lpString) / sizeof(WCHAR) );
+
+#ifdef PARTIAL_UNICODE
+                  SetDlgItemText(
+#else
+                  SetDlgItemTextW(
+#endif
+                                  hWnd,
+                                  IDCS_DL_SILENTTEXT,
+                                  lpString
+                                );
+
+                  ClientFree(lpString);
+               }
+            }
+
+            uResult = TRUE;
+
+            break;
+
+         
+
+        case  WM_NOTIFY:
+        {
+           NMHDR *pnm;
+
+           InternalDebugOut((50, "  WM_NOTIFY in LocDefineDlgSimple"));
+
+           pnm = (NMHDR *)lParam;
+
+           switch(pnm->code)
+           {
+//              case PSN_APPLY:
+              case PSN_KILLACTIVE:
+              {
+                 if ( SimpleProcessing( hWnd, pThisLocation ) )
+                 {
+                    return TRUE;
+                 }   
+                 
+                 WriteLocations(
+                                 pThisLocation,
+                                 1,
+                                 CHANGEDFLAGS_REALCHANGE |
+                                    CHANGEDFLAGS_CURLOCATIONCHANGED,
+                                 pThisLocation
+                               );
+
+                 ClientFree( pThisLocation );
+                 
+// Need this??                 EndDialog( hWnd, 0);
+              }
+              break;
+
+
+              case PSN_SETACTIVE:
+              {
+                   // Only allow the Next button.  The user cannot go back and
+                   // change the settings.
+                   PropSheet_SetWizButtons(GetParent(hWnd), PSWIZB_NEXT);
+              }
+              break;
+
+           }
+
+        }
+        break;
+
+
+
+        case  WM_COMMAND:
+            InternalDebugOut((50, "  WM_COMMAND in LocDefineDlgSimple"));
+
+            switch ( wCmdId = GET_WM_COMMAND_ID( wParam, lParam) )
+            {
+               case IDOK:
+               {
+                  if ( SimpleProcessing( hWnd, pThisLocation ) )
+                  {
+                     return TRUE;
+                  }   
+                 
+                  WriteLocations(
+                                  pThisLocation,
+                                  1,
+                                  CHANGEDFLAGS_REALCHANGE |
+                                  CHANGEDFLAGS_CURLOCATIONCHANGED,
+                                  pThisLocation
+                                );
+
+                  ClientFree( pThisLocation );
+
+                  EndDialog( hWnd, 0);
+
+               }
+               break;
+
+
+//               case IDCANCEL:
+//               {
+//                  PTCHAR pText;
+//                  PTCHAR pTitle;
+//
+//                  pText  = ClientAlloc(1024);
+//                  pTitle = ClientAlloc(1024);
+//
+//                  if (!LoadString( ghInst,
+//                               IDS_WRN_QUITING_WIZ,
+//                               pText,
+//                               ClientSize(pText) ) )
+//                  {
+////11/19                     UtilErrorRpt( NULL, CPL_ERR_LOAD_STRING );
+//                  }
+//
+//                  if (!LoadString( ghInst,
+//                               IDS_WRN_TITLE_WARNING,
+//                               pTitle,
+//                               ClientSize(pTitle) ) )
+//                  {
+////11/19                     UtilErrorRpt( NULL, CPL_ERR_LOAD_STRING );
+//                  }
+//
+//                  if ( IDNO == MessageBox( hWnd, 
+//                                       pText, 
+//                                       pTitle, 
+//                                       MB_YESNO | MB_DEFBUTTON2 | MB_TASKMODAL ) )
+//                  {
+//                     break;
+//                  }
+//
+//                  ClientFree( pText );
+//                  ClientFree( pTitle );
+//
+//                  EndDialog( hWnd, 0);
+//
+//
+//                  if ( pThisLocation )
+//                     ClientFree( pThisLocation );
+//
+//               }
+//               break;
+
+
+
+               case    IDCR_PULSE:
+               case    IDCR_TONE:
+               {
+                    pThisLocation->dwFlags ^= LOCATION_USETONEDIALING;
+
+                    CheckRadioButton( hWnd, IDCR_PULSE, IDCR_TONE, wCmdId );
+               }
+               break;
+
+
+
+               case  IDCC_DL_COUNTRY:
+               {
+                  if ( GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELCHANGE )
+                  {
+                     lThisCountryIndex = SendDlgItemMessage(
+                                                   hWnd,
+                                                   IDCC_DL_COUNTRY,
+                                                   CB_GETCURSEL,
+                                                   0,
+                                                   0);
+
+                     pThisLocation->dwCountry = SendDlgItemMessage(
+                                                   hWnd,
+                                                   IDCC_DL_COUNTRY,
+                                                   CB_GETITEMDATA,
+                                                   lThisCountryIndex,
+                                                   0);
+                  }
+               }
+               break;
+
+
+
+               case  IDCE_DL_AREACODE:
+               {
+                  if ( EN_CHANGE == HIWORD(wParam) )
+                  {
+
+                     if ( 0 == UtilGetEditNumStr(
+                                                  hWnd,
+                                                  IDCE_DL_AREACODE,
+                                                  UTIL_NUMBER
+                                                )
+                        )
+                     {
+//BUGBUG: Disable CLOSE button until user enters a valid area code
+                         SetDlgItemTextW(
+                                         hWnd,
+                                         LOWORD(wParam),
+                                         pThisLocation->AreaCodeW);
+                         break;
+                     }
+
+
+#ifdef PARTIAL_UNICODE
+                     GetDlgItemText(
+#else
+                     GetDlgItemTextW(
+#endif
+                                     hWnd,
+                                     LOWORD(wParam),
+#ifdef PARTIAL_UNICODE
+                                     szTempString,
+#else
+                                     pThisLocation->AreaCodeW,
+#endif
+                                     MAXLEN_AREACODE);
+
+#ifdef PARTIAL_UNICODE
+                     MultiByteToWideChar(
+                                          GetACP(),
+                                          MB_PRECOMPOSED,
+                                          szTempString,
+                                          -1,
+                                          pThisLocation->AreaCodeW,
+                                          MAXLEN_AREACODE
+                                        );
+#endif
+
+                  }
+               }
+               break;
+
+
+
+               case IDCE_DL_OUTSIDEACCESS:
+               {
+                  //
+                  // Get the new value
+                  //
+                  if ( EN_CHANGE == HIWORD(wParam) )
+                  {
+#ifdef PARTIAL_UNICODE
+                     GetDlgItemText( hWnd,
+                                     IDCE_DL_OUTSIDEACCESS,
+                                     szTempString,
+                                     MAXLEN_OUTSIDEACCESS
+                                   );
+#else
+                     GetDlgItemTextW( hWnd,
+                                     IDCE_DL_OUTSIDEACCESS,
+                                     pThisLocation->OutsideAccessW,
+                                     MAXLEN_OUTSIDEACCESS
+                                   );
+#endif
+
+
+#ifdef PARTIAL_UNICODE
+                     MultiByteToWideChar(
+                                          GetACP(),
+                                          MB_PRECOMPOSED,
+                                          szTempString,
+                                          -1,
+                                          pThisLocation->OutsideAccessW,
+                                          MAXLEN_OUTSIDEACCESS
+                                        );
+#endif
+
+                     //
+                     // We'll _assume_ that the LD is the same access
+                     //
+                     lstrcpyW( pThisLocation->LongDistanceAccessW,
+                             pThisLocation->OutsideAccessW);
+
+                  }
+               }
+               break;
+
+
+
+            }
+            break;
+
+
+
+        default:
+            uResult = FALSE;
+
+    }
+      
+    return( uResult );
+
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL
+CALLBACK
+LocWizardDlgProc(
+                  HWND  hWnd, 
+                  UINT  uMessage, 
+                  WPARAM  wParam, 
+                  LPARAM  lParam
+                )
+{
+   return LocDefineDlgSimple( hWnd, 
+                              uMessage, 
+                              wParam, 
+                              lParam
+                            );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//   Returns pointer to matching prefix within (cached) current location entry
+//   or NULL, if the subscriber number's prefix isn't in the list.
+//
+LPWSTR PASCAL InPrefixList(LPWSTR lpSubscriberW, PLOCATION pLocation)
+{
+   //BUGBUG: assumption - that a toll prefix is 3 tchars
+   WCHAR pTempW[] = L",XXX,";
+
+   if (
+         (!IsBadStringPtrW(lpSubscriberW, 512))
+       &&
+         (lstrlenW(lpSubscriberW) > 2)
+      )
+   {
+      //   
+      // We _assume_ that the tolllist is of the form:
+      // ",nnn,nnn,nnn," then this routine is simply:
+      //
+      pTempW[1] = lpSubscriberW[0];
+      pTempW[2] = lpSubscriberW[1];
+      pTempW[3] = lpSubscriberW[2];
+
+      InternalDebugOut((11, "Looking for [%ls] in [%ls]", pTempW, pLocation->TollListW));
+
+      return wcsstr( pLocation->TollListW, pTempW);
+   }
+   else
+   {
+      return NULL;
+   }
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL BreakupCanonicalW( LPWSTR  pAddressIn,
+                               LPWSTR  *pCountry,
+                               LPWSTR  *pCity,
+                               LPWSTR  *pSubscriber
+                             )
+{
+   LONG  lResult = 0;
+   BOOL  fInCityCode = FALSE;
+
+
+   //
+   // Get past any (illegal) leading spaces
+   //
+   while ( *pAddressIn == ' ' )
+   {
+      pAddressIn++;
+   }
+
+
+   //
+   // Leading zeros are very bad.  Don't allow them.
+   // We're now at the first non-space.  Better not be a '0'.
+   //
+   if ( *pAddressIn == '0' )
+   {
+      //
+      // There are leading zeros!
+      //
+      DBGOUT((1, "   Canonical numbers are not allowed to have leading zeros"));
+      lResult = LINEERR_INVALADDRESS;
+      goto cleanup;
+   }
+
+
+//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   //
+   // Parse the canonical number into its component pieces
+   //
+
+   //
+   // Do country first
+   //
+   *pCountry = pAddressIn;
+
+   //
+   // Now get to past this
+   //
+   while ( IsWDigit(*pAddressIn) )
+   {
+      pAddressIn++;
+   }
+
+   //
+   // We hit something that's not a digit...
+   // Make sure it's not the end of the string...
+   //
+   if ( *pAddressIn != '\0' )
+   {
+      //
+      // Remember whether this was the open paren of a city code
+      //
+      if ( *pAddressIn == '(' )
+      {
+         fInCityCode = TRUE;
+      }
+
+
+      //
+      // Make this a little stringlet
+      //
+      *pAddressIn = '\0';
+      pAddressIn++;
+   }
+
+
+   //
+   // Now get past any junk to the next set
+   //
+
+
+   //
+   // Ignore any spaces
+   //*** *** ***BUGBUG This will also skip GARBAGE!!!
+   //
+   while ( (!IsWDigit(*pAddressIn)) && (*pAddressIn != (WCHAR)NULL) &&
+               (*pAddressIn != ')') && (*pAddressIn != '(') )
+   {
+      pAddressIn++;
+   }
+
+
+   //
+   // If the previous char is a paren, this must be a city code
+   // Or, if we've previously hit the open paren, we're there as well...
+   //
+   if ( *(pAddressIn-1) == '(' || (*pAddressIn == '(') || fInCityCode )
+   {
+      //
+      // Ignore any spaces
+      //*** *** ***BUGBUG This will also skip GARBAGE!!!
+      //
+      while ( (!IsWDigit(*pAddressIn)) && (*pAddressIn != (WCHAR)NULL) && (*pAddressIn != ')') )
+      {
+         pAddressIn++;
+      }
+
+      //
+      // We just hit a digit
+      //
+      *pCity = pAddressIn;
+
+
+      //
+      // Now get to past this
+      //
+      while ( IsWDigit(*pAddressIn) )
+      {
+         pAddressIn++;
+      }
+
+      //
+      // We hit somthing that's not a digit...
+      // Make sure it's not the end of the string...
+      //
+      if ( (WCHAR)NULL != *pAddressIn)
+      {
+
+//*** *** ***BUGBUG Do we have to verify the ')' ?
+
+         //
+         // Make this a little stringlet
+         //
+         *pAddressIn = '\0';
+         pAddressIn++;
+      }
+
+      //
+      // Ignore any spaces
+      //*** *** ***BUGBUG This will also skip GARBAGE!!!
+      //
+      while ( (!IsWDigit(*pAddressIn)) && (*pAddressIn != (WCHAR)NULL) && (*pAddressIn != ')') )
+      {
+         pAddressIn++;
+      }
+
+   }
+   else
+   {
+      //
+      // There seems to be no city code.  Ok, go straight to
+      // subscriber number
+      //
+      *pCity = NULL;
+   }
+
+
+   //
+   // Nothing left to do but put the icing on the cake
+   //
+   *pSubscriber = pAddressIn;
+
+   if (
+         IsBadStringPtrW( *pSubscriber, 512 )
+       ||
+         lstrlenW( *pSubscriber ) == 0
+      )
+   {
+      //
+      // Obviously not canonical
+      //
+      DBGOUT((1, "   Canonical numbers must have a subscriber number"));
+      lResult = LINEERR_INVALADDRESS;
+      goto cleanup;
+   }
+
+
+cleanup:
+
+     return lResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+void UpdateNumberField( HWND hWnd, LPCWSTR lpszAddressIn );
+
+
+
+BOOL
+CALLBACK
+LocationsDlgProc(
+    HWND    hWnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    UINT n;
+    UINT nCurrent;
+    BOOL fFoundACleanNumber;
+    PWSTR buf1;
+    PWSTR buf2;
+
+    // static index of last location name that was edited
+    static int      iStaticLastNameEdited = -1;
+
+    //
+    // table of controls and context-sensitive help IDs
+    //
+    static DWORD aIds[] = {
+//#if WINNT
+// These codes aren't in the NT help.h yet...
+//#else
+        IDCS_DL_NAME, IDH_TAPI_LOCATIONS,
+        IDCC_DL_NAME, IDH_TAPI_LOCATIONS,
+        IDCB_DL_NEW_LOCATION, IDH_TAPI_LOCATION_NEW,
+        IDCB_DL_REMOVE_LOCATION, IDH_TAPI_LOCATION_REMOVE,
+        IDCS_DL_AREACODE, IDH_TAPI_AREA_CODE,
+        IDCE_DL_AREACODE, IDH_TAPI_AREA_CODE,
+        IDCS_DL_COUNTRY, IDH_TAPI_COUNTRY,
+        IDCC_DL_COUNTRY, IDH_TAPI_COUNTRY,
+        IDCS_DL_OUTSIDE, IDH_TAPI_ACCESS_LINE,
+        IDCE_DL_OUTSIDEACCESS, IDH_TAPI_ACCESS_LINE,
+        IDCS_DL_OUTSIDEACCESS, IDH_TAPI_ACCESS_LINE,
+        IDCE_DL_LONGDISTANCEACCESS, IDH_TAPI_ACCESS_LINE,
+        IDCS_DL_LONGDISTANCEACCESS, IDH_TAPI_ACCESS_LINE,
+        IDCK_DL_CALLINGCARD, IDH_TAPI_LOCATION_CARD,
+        IDCE_DL_CALLINGCARD, IDH_TAPI_LOCATION_CARD,
+        IDCB_DL_CHANGE_CARD, IDH_TAPI_LOCATION_CARD_CHANGE,
+        IDCK_DL_CALLWAITING, IDH_TAPI_LOCATION_CALL_WAIT,
+        IDCC_DL_CALLWAITING, IDH_TAPI_LOCATION_CALL_WAIT,
+        IDCR_PULSE, IDH_TAPI_LOCATION_PULSE,
+        IDCR_TONE, IDH_TAPI_LOCATION_PULSE,
+        IDCS_DIAL_NUMBER_TEXT, IDH_TAPI_LOCATION_PHONE,
+        IDCS_DL_DIAL_NUMBER, IDH_TAPI_LOCATION_PHONE,
+        IDCK_DL_IN_LOCAL, IDH_TAPI_LONG_DISTANCE,
+        IDC_STATIC+2, (DWORD)-1,
+//#endif
+        0, 0
+    };
+
+    static LPWSTR pAddressIn = NULL;
+    static LPWSTR pCountry = NULL;
+    static LPWSTR pCity = NULL;
+    static LPWSTR pSubscriber = NULL;
+
+#ifdef PARTIAL_UNICODE
+    CHAR szTempString[MAXLEN_NAME];
+#endif
+
+    static BOOL  fInInit;
+
+    static DWORD dwDialChangedFlags;
+    //
+    // gpCurrentLocation is needed because when a user types in the
+    // name field, we get no notification that it's about to happen
+    // (CBN_EDITUPDATE happens before the screen update, but AFTER the
+    // listbox has been updated)  (it's also used in the calling card
+    // dialog proc)
+    //
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+
+       InternalDebugOut((10, "  WM_INITDIALOG"));
+
+       fInInit = TRUE;
+
+       //
+       // Read in the cards once.  And leave them in mem until
+       // we leave.
+       //
+
+       ReadCardsEasy( &gpCardList, &gpnStuff );
+
+
+       //
+       // Set some limits on the edit fields
+       //
+       SendDlgItemMessage(
+                hWnd,
+                IDCC_DL_NAME,
+                EM_LIMITTEXT,
+                MAXLEN_NAME,
+                0);
+       SendDlgItemMessage(
+                hWnd,
+                IDCE_DL_AREACODE,
+                EM_LIMITTEXT,
+                MAXLEN_AREACODE,
+                0);
+       SendDlgItemMessage(
+                hWnd,
+                IDCE_DL_OUTSIDEACCESS,
+                EM_LIMITTEXT,
+                MAXLEN_OUTSIDEACCESS,
+                0);
+       SendDlgItemMessage(
+                hWnd,
+                IDCE_DL_LONGDISTANCEACCESS,
+                EM_LIMITTEXT,
+                MAXLEN_LONGDISTANCEACCESS,
+                0);
+
+
+
+       FillCountriesListbox( hWnd );
+
+       FillLocationsListbox( hWnd );
+
+       FillDisableCallWaitingListbox( hWnd );
+
+       //
+       // Ok, now fill in everything else (ie: the things that
+       // _might_ change)
+       //
+       gpCurrentLocation = &gLocationList[GetLocationIndexFromID(gnCurrentLocationID, NULL, 0)];
+       FillDialingPropertyDialog( hWnd, gpCurrentLocation );
+
+InternalDebugOut((80, " WM_INIT gpCurrentLocation=0x%08lx", (DWORD)gpCurrentLocation));
+InternalDebugOut((80, " WM_INIT gpCurrentLocation->Name=%ls", gpCurrentLocation->NameW));
+
+       //
+       // Start with a clean slate...
+       //
+       dwDialChangedFlags = 0;
+
+
+
+       //
+       // If we didn't get an address, don't display the phone number fields
+       //
+       if (
+             (NULL == gpszAddress)
+           ||
+             (gpszAddress[0] == '\0')
+           ||
+             (IsBadStringPtrW(gpszAddress, 512))
+          )
+       {
+          ShowWindow( GetDlgItem( hWnd, IDCS_DIAL_NUMBER_TEXT), SW_HIDE);
+          ShowWindow( GetDlgItem( hWnd, IDCS_DL_DIAL_NUMBER), SW_HIDE);
+          ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+       }
+       else
+       {
+          UpdateNumberField( hWnd, gpszAddress);
+
+          pAddressIn = ClientAlloc( (lstrlenW(gpszAddress) + 1) *sizeof(WCHAR));
+          lstrcpyW( pAddressIn, gpszAddress );
+      
+          //
+          //WARNING!! CODE BELOW DEPENDS ON 'n' BEING PRESERVED!!!!
+          //
+          n = BreakupCanonicalW( pAddressIn+1,
+                                 &pCountry,
+                                 &pCity,
+                                 &pSubscriber
+                               );
+
+//          //
+//          // If the caller is really trying to annoy us, let's ignore what
+//          // he's saying
+//          //
+//          if ( n )
+//          {
+//             ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+//             ShowWindow( GetDlgItem( hWnd, IDCS_DIAL_NUMBER_TEXT), SW_HIDE);
+//             ShowWindow( GetDlgItem( hWnd, IDCS_DL_DIAL_NUMBER), SW_HIDE);
+//             ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+//          }
+
+          if ( gpCurrentLocation->dwCountry != 1 )
+          {
+             ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+          }
+          else
+          {
+
+             // Set or clear the "Dial as long distance" button as appropriate
+             // (Or maybe don't show it at all...)
+
+             //
+             // We're in the US - we require area codes, if this is not one,
+             // or the dialing number area code is different from the current,
+             // or if the canonical breakup failed, this is not a canonical
+             // number and _can't_ have the option of being in the Tolllist
+             //
+             if (
+                   (pCity == NULL)
+                 ||
+                   (n != 0)
+                 ||
+                   ( lstrcmpiW( pCity, gpCurrentLocation->AreaCodeW ) )
+                )
+             {
+                ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+             }
+             else
+             {
+                if ( InPrefixList(pSubscriber, gpCurrentLocation) )
+                {
+                   CheckDlgButton( hWnd, IDCK_DL_IN_LOCAL, TRUE );
+                }
+             }
+      
+          }
+       }
+
+       //
+       // If there is only one location, disable the remove button
+       //
+       n = SendDlgItemMessage(
+              hWnd,
+              IDCC_DL_NAME,
+              CB_GETCOUNT,
+              0,
+              0
+              );
+
+       if ( n < 2 ) // (use < 2 not == 1 "just in case")
+       {
+          EnableWindow( GetDlgItem(hWnd, IDCB_DL_REMOVE_LOCATION), FALSE );
+       }
+
+
+       fInInit = FALSE;
+    }
+    break;
+
+
+    // Process clicks on controls after Context Help mode selected
+    case WM_HELP:
+        InternalDebugOut((50, "  WM_HELP in LocDefineDlg"));
+        WinHelp (((LPHELPINFO) lParam)->hItemHandle, "windows.hlp", HELP_WM_HELP, 
+                                        (DWORD)(LPSTR) aIds);
+//        uResult = FALSE;
+        break;
+
+
+    // Process right-clicks on controls            
+    case WM_CONTEXTMENU:
+        InternalDebugOut((50, "  WM_CONTEXT_MENU in LocationsDlgProc"));
+        WinHelp ((HWND) wParam, "windows.hlp", HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+//         uResult = FALSE;
+        break;
+
+
+    case WM_NOTIFY:
+        {
+        LPNMHDR lpnm = (LPNMHDR)lParam;
+
+        switch ( lpnm->code )
+        {
+
+            case PSN_APPLY: /* case IDOK */
+            {
+               LPLINECOUNTRYLIST pLCL;
+ 
+               InternalDebugOut((80, "  PSN_APPLY - Locations"));
+
+               if (!CheckForDupLocation(hWnd,
+                                        iStaticLastNameEdited))
+               {
+                   SetWindowLong( hWnd, DWL_MSGRESULT, TRUE );
+                   return TRUE;
+               }
+               
+               //
+               // Is the user just trying to annoy us?
+               //
+               if ( 0 == UtilGetEditNumStr(
+                                            hWnd,
+                                            IDCE_DL_AREACODE,
+                                            UTIL_BIG_EXTENDED
+                                          )
+                  )
+               {
+                   SetWindowLong( hWnd, DWL_MSGRESULT, TRUE );
+                   return TRUE;
+               }
+                  
+                  
+               //
+               // Does this country require an area code and is one supplied?
+               //   
+               if ( SimpleProcessing( hWnd, gpCurrentLocation ) )
+               {
+                   return( TRUE );
+               }   
+                 
+
+               //
+               // Write locations info out (in case they changed)
+               //
+
+               EnterCriticalSection( &gUICriticalSection );
+
+               WriteLocations( gLocationList, gnNumLocations,
+                        dwDialChangedFlags, gpCurrentLocation );
+
+               dwDialChangedFlags = 0;
+
+
+               //
+               // Did the user press OK? (As opposed to APPLY)
+               //
+               if ( ((LPPSHNOTIFY)lpnm)->lParam )
+               {
+                  //
+                  // Yes.  Let's free this stuff.
+                  //
+                  Free_gLocationList();
+                  
+
+                  if (gpCardList)
+                     ClientFree(gpCardList);
+                     
+                  if (gpnStuff)
+                     ClientFree(gpnStuff);
+
+                  if ( pAddressIn )
+                     ClientFree( pAddressIn );
+               }
+               else
+               {
+                  //
+                  // If the user checked the "disable call waiting" box,
+                  // but didn't enter anything, disable it again
+                  //
+                  CheckDlgButton( hWnd,
+                                  IDCK_DL_CALLWAITING,
+                                  (gpCurrentLocation->dwFlags & LOCATION_HASCALLWAITING) );
+
+                  EnableWindow( GetDlgItem(hWnd, IDCC_DL_CALLWAITING), 
+                                      (gpCurrentLocation->dwFlags & LOCATION_HASCALLWAITING) ?
+                                           TRUE :
+                                           FALSE
+                                      );
+
+               }
+
+
+               LeaveCriticalSection( &gUICriticalSection );
+
+            }
+            break;
+
+
+
+            case  PSN_RESET:        /* case IDCANCEL: */
+            {
+               InternalDebugOut((80, "  PSN_RESET - Locations"));
+               //
+               // Yes.  Let's free this stuff.
+               //
+               Free_gLocationList();
+
+               if (gpCardList)
+                  ClientFree(gpCardList);
+               if (gpnStuff)
+                  ClientFree(gpnStuff);
+
+               if ( pAddressIn )
+                  ClientFree( pAddressIn );
+            }
+            break;
+
+     
+#if DBG
+            case PSN_SETACTIVE:
+               InternalDebugOut((80, "  PSN_SETACTIVE - Locations"));
+               break;
+
+
+            case PSN_KILLACTIVE:
+               InternalDebugOut((80, "  PSN_KILLACTIVE - Locations"));
+               break;
+#endif
+
+
+        }
+        }
+        break;
+
+
+    case WM_COMMAND:
+        {
+        LONG lThisItemIndex;
+        PLOCATION pThisLocation;
+
+
+//       InternalDebugOut((80, "  dwDialChangedFlags=0x%08lx",(DWORD)dwDialChangedFlags));
+
+
+        //
+        // Get our pointer to the location struct
+        //
+        pThisLocation = gpCurrentLocation;
+
+#if DBG
+if ( gLocationList )
+{
+InternalDebugOut((11, "  pThisLocation    ->%ls", (LPSTR)pThisLocation->NameW));
+//DBGOUT((0, "  gpCurrentLocation ->%s", (LPSTR)gpCurrentLocation->Name));
+}
+else
+{
+InternalDebugOut((10, " --- gLocationList has been freed! Why am I here?"));
+}
+#endif
+
+        switch (LOWORD(wParam))
+        {
+            case IDCB_DL_CHANGE_CARD:
+            {
+
+               //
+               // Compare calling card before and after
+               //
+               n = pThisLocation->dwCallingCard;
+
+#ifdef PARTIAL_UNICODE
+               DialogBox(
+                          ghInst,
+                          MAKEINTRESOURCE(IDD_CALLING_CARD_CHANGE),
+                          hWnd,
+                          CallingCardProc
+                        );
+#else
+               DialogBoxW(
+                          ghInst,
+                          MAKEINTRESOURCEW(IDD_CALLING_CARD_CHANGE),
+                          hWnd,
+                          CallingCardProc
+                        );
+#endif
+
+               if ( n != pThisLocation->dwCallingCard )
+               {
+                  //
+                  // Update the calingcard name field in case it changed
+                  //
+                  n = GetCardIndexFromID( pThisLocation->dwCallingCard,
+                                          gpCardList,
+                                          gpnStuff[2]
+                                        );
+                                        
+                  if ( (UINT)(-1) == n )
+                  {
+                      n = 0;
+                  }
+    
+#ifdef PARTIAL_UNICODE
+                  WideCharToMultiByte(
+                           GetACP(),
+                           0,
+                           gpCardList[n].NameW,
+                           -1,
+                           szTempString,
+                           MAXLEN_NAME,
+                           NULL,
+                           NULL
+                         );
+#endif
+
+
+#ifdef PARTIAL_UNICODE
+                  SetDlgItemText( 
+#else
+                  SetDlgItemTextW( 
+#endif
+                                  hWnd,
+                                  IDCE_DL_CALLINGCARD,
+#ifdef PARTIAL_UNICODE
+                                  szTempString
+#else
+                                  gpCardList[n].NameW
+#endif
+                                );
+
+
+                  dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+                  UpdateNumberField( hWnd, gpszAddress);
+
+                  //
+                  // Activate the APPLY button if not already done
+                  //
+                  PropSheet_Changed(GetParent(hWnd), hWnd);
+               }
+
+            }
+            break;
+
+
+
+            case IDCB_DL_NEW_LOCATION:
+            {
+               PLOCATION pTemp;
+
+
+               //
+               //
+               //BUGBUG performance(minor): Should first scan for deleted location entries
+               pTemp = ClientAlloc( (gnNumLocations+1)*sizeof(LOCATION) );
+
+               if ( pTemp )
+               {
+                  //
+                  // Fill in with the old contents
+                  //
+                  CopyMemory( pTemp,
+                          gLocationList,
+                          gnNumLocations * sizeof(LOCATION)
+                        );
+
+
+
+                  //
+                  // Fill in with the defaults of the current location
+                  //
+                  CopyMemory( &pTemp[gnNumLocations],
+                          gpCurrentLocation,
+                          sizeof(LOCATION)
+                        );
+
+
+            EnterCriticalSection( &gUICriticalSection );
+
+                  //
+                  // gLocationList is dead.  Long live gLocationList
+                  //
+                  ClientFree( gLocationList );
+                  gLocationList = pTemp;
+
+            LeaveCriticalSection( &gUICriticalSection );
+
+
+                  //
+                  // Make this new location the current location
+                  //
+                  gpCurrentLocation = &gLocationList[gnNumLocations];
+
+                  //
+                  // Get a proper new location ID
+                  //
+                  AllocNewID( HKEY_LOCAL_MACHINE,
+                              &(gpCurrentLocation->dwID) );
+
+
+                  dwDialChangedFlags |= ( CHANGEDFLAGS_CURLOCATIONCHANGED |
+                                          CHANGEDFLAGS_TOLLLIST );
+
+//BUGBUG Should this really be done?
+                  gnCurrentLocationID = gpCurrentLocation->dwID;
+
+                  gnNumLocations++;
+
+                  UpdateNumberField( hWnd, gpszAddress);
+
+
+                  if (
+                        (gpCurrentLocation->dwCountry == 1)
+                      &&
+                        (NULL != gpszAddress)
+                      &&
+                        (gpszAddress[0] != '\0')
+                     )
+                  {
+                     ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_SHOW);
+                  }
+                  else
+                  {
+                     ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+                  }
+
+                  buf1 = ClientAlloc( sizeof(gpCurrentLocation->NameW) );
+
+                  //
+                  // Get in the default name
+                  //
+                  LoadStringW( ghInst,
+                               IDS_NEWLOCATION,
+                               buf1,
+                               MAXLEN_NAME);
+
+                  //
+                  // First, look for the vanilla name
+                  //
+                  lstrcpyW( gpCurrentLocation->NameW, buf1 );
+
+
+                  //
+                  // Make sure we don't duplicate the name
+                  //
+
+                  n = 1;
+                  fFoundACleanNumber = FALSE;
+
+                  while( FALSE == fFoundACleanNumber )
+                  {
+
+//DBGOUT((1, "gnNumLocations=0x%08lx", gnNumLocations));
+
+                     //
+                     // Is this number in the list?
+                     //
+                     for (
+                           nCurrent=0;
+                           nCurrent < gnNumLocations;
+                           nCurrent++
+                         )
+                     {
+
+//DBGOUT((1, "gLocation[nCurrent]=0x%08lx   gpCurrentloc=0x%08lx", 
+//&(gLocationList[nCurrent]), gpCurrentLocation));
+
+                        //
+                        // Don't check the new location
+                        //
+                        if ( &(gLocationList[nCurrent]) != gpCurrentLocation )
+                        {
+
+//DBGOUT((1, "loclist[n]=[%ls]  curloc->name=[%ls]",
+//                                               gLocationList[nCurrent].NameW,
+//                                               gpCurrentLocation->NameW ));
+
+                           //
+                           // Is it in the list already?
+                           //
+                           if ( 0 == lstrcmpiW(
+                                               gLocationList[nCurrent].NameW,
+                                               gpCurrentLocation->NameW
+                                             )
+                              )
+                           {
+                              break;
+                           }
+                        }
+                     }
+
+                     if ( nCurrent == gnNumLocations )
+                     {
+                        fFoundACleanNumber = TRUE;
+                        continue;
+                     }
+
+                     //
+                     // Set up the string for the next contestant
+                     //
+                     n++;
+                     wsprintfW(
+                               gpCurrentLocation->NameW,
+                               L"%ls (%ld)",
+                               buf1,
+                               n
+                             );
+                  }
+
+                  RedoLocationListbox( hWnd,
+                                       gLocationList,
+                                       gnNumLocations,
+                                       gpCurrentLocation
+                                     );
+
+                  //
+                  // We just added a location, so we _KNOW_ there are at
+                  // least 2 locations...
+                  //
+                  EnableWindow( GetDlgItem(hWnd, IDCB_DL_REMOVE_LOCATION), TRUE );
+
+                  //
+                  // Update the dialog box
+                  //
+                  FillDialingPropertyDialog( hWnd, gpCurrentLocation);
+
+                  //
+                  // We've already allocated buf1, so just get buf2 here.
+                  //
+                  buf2 = ClientAlloc( sizeof(gpCurrentLocation->NameW) );
+
+                  LoadStringW(ghInst, IDCS_DL_CREATED_LOCATION, buf1, 512 );
+                  LoadStringW(ghInst, DIALINGPROPERTIES_NAME, buf2, 512 );
+
+                  MessageBoxW( hWnd,
+                               buf1,
+                               buf2,
+                               MB_OK
+                             );
+
+                  ClientFree( buf1 );
+                  ClientFree( buf2 );
+
+                  SetFocus(GetDlgItem(hWnd, IDCC_DL_NAME));
+               }
+#if DBG
+               else
+               {
+                  InternalDebugOut((1, "Out of mem for new location!"));
+               }
+#endif
+            }
+            break;
+
+
+            case IDCB_DL_REMOVE_LOCATION:
+               {
+
+               //
+               // Ask the user if he's sure
+               //
+
+               buf1 = ClientAlloc( 512 * sizeof(WCHAR) );
+               buf2 = ClientAlloc( 512 * sizeof(WCHAR) );
+
+               LoadStringW(ghInst, REMOVE_LOCATION,    buf1, 512 );
+               LoadStringW(ghInst, IDS_WRN_TITLE_SURE, buf2, 512 );
+
+               if ( MessageBoxW( hWnd,
+                                 buf1,
+                                 buf2,
+                                 MB_YESNO | MB_DEFBUTTON2
+                               )
+                              == IDYES )
+               {
+
+                  //
+                  // Activate the APPLY button if not already done
+                  //
+                  PropSheet_Changed(GetParent(hWnd), hWnd);
+
+
+                  dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+
+                  //
+                  // Mark this location as being "dead"
+                  //
+                  pThisLocation->NameW[0] = '\0';
+
+
+                  lThisItemIndex = SendDlgItemMessage(
+                                             hWnd,
+                                             IDCC_DL_NAME,
+                                             CB_GETCURSEL,
+                                             0,
+                                             0);
+if (lThisItemIndex == -1 )
+{
+DBGOUT((0, "Found one(2)!!!!"));
+}
+
+                  SendDlgItemMessage(
+                         hWnd,
+                         IDCC_DL_NAME,
+                         CB_DELETESTRING,
+                         (WPARAM)lThisItemIndex,
+                         0
+                         );
+
+                  SendDlgItemMessage(
+                                      hWnd,
+                                      IDCC_DL_NAME,
+                                      CB_SETCURSEL,
+                                      0,
+                                      0
+                                    );
+
+                  dwDialChangedFlags |= CHANGEDFLAGS_CURLOCATIONCHANGED;
+                  //
+                  // Get our pointer to the location struct
+                  //
+                  gpCurrentLocation = (PLOCATION)(SendDlgItemMessage(
+                                                    hWnd,
+                                                    IDCC_DL_NAME,
+                                                    CB_GETITEMDATA,
+                                                    0,
+                                                    0));
+                  pThisLocation = gpCurrentLocation;
+
+                  UpdateNumberField( hWnd, gpszAddress);
+
+
+                  if (
+                        (gpCurrentLocation->dwCountry == 1)
+                      &&
+                        (NULL != gpszAddress)
+                      &&
+                        (gpszAddress[0] != '\0')
+                     )
+                  {
+                     ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_SHOW);
+                  }
+                  else
+                  {
+                     ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+                  }
+
+
+                  //
+                  // If the user deletes a location and there's only one left,
+                  // disable the remove button
+                  //
+                  lThisItemIndex = SendDlgItemMessage(
+                         hWnd,
+                         IDCC_DL_NAME,
+                         CB_GETCOUNT,
+                         0,
+                         0
+                         );
+
+                  if ( lThisItemIndex < 2 ) // (use < 2 not == 1 "just in case")
+                  {
+                     EnableWindow( GetDlgItem(hWnd, IDCB_DL_REMOVE_LOCATION), FALSE );
+                  }
+
+               }
+
+               ClientFree( buf1 );
+               ClientFree( buf2 );
+
+               }
+               break;
+
+
+            case IDCE_DL_AREACODE:
+               {
+               //
+               // But only do this stuff if something changed...
+               //
+               if ( EN_CHANGE == HIWORD(wParam) && !fInInit )
+               {
+
+                  if ( 0 == UtilGetEditNumStr(
+                                               hWnd,
+                                               LOWORD(wParam),
+                                               UTIL_NUMBER
+                                             )
+                     )
+                  {
+//BUGBUG: Disable CLOSE button until user enters a valid area code?
+                      break;
+                  }
+
+
+                  dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+//BUGBUG: Need to warn the user that he's about to throw away his tolllist!!
+
+                  pThisLocation->TollListW[0] = (WCHAR)'\0';
+                  
+                  //
+                  // Activate the APPLY button if not already done
+                  //
+                  PropSheet_Changed(GetParent(hWnd), hWnd);
+
+#ifdef PARTIAL_UNICODE
+                  GetDlgItemText( 
+#else
+                  GetDlgItemTextW( 
+#endif
+                                  hWnd,
+                                  LOWORD(wParam),
+#ifdef PARTIAL_UNICODE
+                                  szTempString,
+#else
+                                  pThisLocation->AreaCodeW,
+#endif
+                                  MAXLEN_AREACODE);
+
+#ifdef PARTIAL_UNICODE
+                  MultiByteToWideChar(
+                                       GetACP(),
+                                       MB_PRECOMPOSED,
+                                       szTempString,
+                                       -1,
+                                       pThisLocation->AreaCodeW,
+                                       MAXLEN_AREACODE
+                                     );
+#endif
+
+                  ShowWindow(
+                              GetDlgItem( hWnd, IDCK_DL_IN_LOCAL),
+                              lstrcmpiW(pCity, gpCurrentLocation->AreaCodeW) ?
+                                  SW_HIDE :
+                                  SW_SHOW
+                            );
+
+                  UpdateNumberField( hWnd, gpszAddress);
+
+               }
+               }
+               break;
+
+
+            case IDCE_DL_OUTSIDEACCESS:
+            case IDCE_DL_LONGDISTANCEACCESS:
+               {
+
+               //
+               // But only do this stuff if something changed...
+               //
+               if ( EN_CHANGE == HIWORD(wParam) )
+               {
+                  dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+                  //
+                  // Activate the APPLY button if not already done
+                  //
+                  PropSheet_Changed(GetParent(hWnd), hWnd);
+
+
+#ifdef PARTIAL_UNICODE
+                  GetDlgItemText( 
+#else
+                  GetDlgItemTextW( 
+#endif
+                                  hWnd,
+                                  LOWORD(wParam),
+#ifdef PARTIAL_UNICODE
+                                  szTempString,
+#else
+                                  LOWORD(wParam) == IDCE_DL_OUTSIDEACCESS ?
+                                     pThisLocation->OutsideAccessW :
+                                     pThisLocation->LongDistanceAccessW,
+#endif
+                                  MAXLEN_OUTSIDEACCESS);
+
+#ifdef PARTIAL_UNICODE
+                  MultiByteToWideChar(
+                                       GetACP(),
+                                       MB_PRECOMPOSED,
+                                       szTempString,
+                                       -1,
+                                       LOWORD(wParam) == IDCE_DL_OUTSIDEACCESS ?
+                                          pThisLocation->OutsideAccessW :
+                                          pThisLocation->LongDistanceAccessW,
+                                       MAXLEN_OUTSIDEACCESS
+                                     );
+#endif
+
+                  UpdateNumberField( hWnd, gpszAddress);
+
+                  }
+               }
+               break;
+
+
+        case IDCK_DL_CALLWAITING:
+            {
+            dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+            pThisLocation->dwFlags ^= LOCATION_HASCALLWAITING;
+
+
+            //
+            // if box is now checked, enable dropdown
+            //
+
+            EnableWindow( GetDlgItem(hWnd, IDCC_DL_CALLWAITING),
+                     (pThisLocation->dwFlags & LOCATION_HASCALLWAITING) ?
+                                   TRUE :
+                                   FALSE );
+
+
+            //
+            // Activate the APPLY button if not already done
+            //
+            PropSheet_Changed(GetParent(hWnd), hWnd);
+
+            UpdateNumberField( hWnd, gpszAddress);
+
+            }
+            break;
+
+
+        case IDCC_DL_CALLWAITING:
+            {
+            //
+            // Process only when something changes
+            //
+            if ( CBN_EDITCHANGE == HIWORD(wParam) )
+            {
+
+               dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+#ifdef PARTIAL_UNICODE
+               GetDlgItemText( 
+#else
+               GetDlgItemTextW( 
+#endif
+                               hWnd,
+                               LOWORD(wParam),
+#ifdef PARTIAL_UNICODE
+                               szTempString,
+#else
+                               pThisLocation->DisableCallWaitingW,
+#endif
+                               MAXLEN_DISABLECALLWAITING);
+
+#ifdef PARTIAL_UNICODE
+                  MultiByteToWideChar(
+                                       GetACP(),
+                                       MB_PRECOMPOSED,
+                                       szTempString,
+                                       -1,
+                                       pThisLocation->DisableCallWaitingW,
+                                       MAXLEN_DISABLECALLWAITING
+                                     );
+#endif
+
+               UpdateNumberField( hWnd, gpszAddress);
+
+               PropSheet_Changed(GetParent(hWnd), hWnd);
+
+            }
+            else
+            {
+               if ( CBN_SELCHANGE  == HIWORD(wParam) )
+               {
+
+                  //
+                  // Get our pointer to the location struct
+                  //
+                  n = SendDlgItemMessage(
+                                                    hWnd,
+                                                    IDCC_DL_CALLWAITING,
+                                                    CB_GETCURSEL,
+                                                    0,
+                                                    0);
+#ifdef PARTIAL_UNICODE
+                  SendDlgItemMessage(
+#else
+                  SendDlgItemMessageW(
+#endif
+                                      hWnd,
+                                      IDCC_DL_CALLWAITING,
+                                      CB_GETLBTEXT,
+                                      n,
+#ifdef PARTIAL_UNICODE
+                                      (LPARAM)szTempString
+#else
+                                      (LPARAM)pThisLocation->DisableCallWaitingW
+#endif
+                                    );
+
+#ifdef PARTIAL_UNICODE
+                  MultiByteToWideChar(
+                                       GetACP(),
+                                       MB_PRECOMPOSED,
+                                       szTempString,
+                                       -1,
+                                       pThisLocation->DisableCallWaitingW,
+                                       MAXLEN_AREACODE
+                                     );
+#endif
+
+InternalDebugOut((20, " Presto-changeo - %ls", pThisLocation->DisableCallWaitingW));
+
+               UpdateNumberField( hWnd, gpszAddress);
+
+               PropSheet_Changed(GetParent(hWnd), hWnd);
+               }
+            }
+
+            }
+            break;
+
+
+        case IDCK_DL_IN_LOCAL:
+            {
+            LPWSTR pPrefixLocation = NULL;
+
+//            LPTSTR pCountry = NULL;
+//            LPTSTR pCity = NULL;
+//            LPTSTR pSubscriber = NULL;
+//            LPTSTR pAddressIn;
+//
+//            pAddressIn = ClientAlloc( lstrlen(gpszAddress) + 1);
+//            lstrcpy( pAddressIn, gpszAddress );
+//
+//
+//            //
+//            // Need to pass the pointer to Breakup pointer past the '+'
+//            //
+//            if ( *pAddressIn == '+' )
+//            {
+//               pAddressIn++;
+//            }
+//
+//
+//            BreakupCanonical( pAddressIn,
+//                               &pCountry,
+//                               &pCity,
+//                               &pSubscriber
+//                             );
+
+
+            pPrefixLocation = InPrefixList(pSubscriber, gpCurrentLocation);
+
+            if ( IsDlgButtonChecked(hWnd, IDCK_DL_IN_LOCAL) )
+            {
+               //
+               // Make sure this prefix is in the list (add if necessary)
+               //
+               if ( pPrefixLocation == NULL )
+               {
+                  //
+                  // If this is the first entry, start the list off right
+                  //
+                  if ( pThisLocation->TollListW[0] == (WCHAR)'\0' )
+                  {
+                     lstrcatW( pThisLocation->TollListW, L",");
+                  }
+
+
+                  //
+                  // The entry is not in the list.  Add it.
+                  //
+
+                  //
+                  // Ok, the data's valid.  We won't need to use
+                  // pSubscriber again, so we'll trash it a bit.
+                  //
+//BUGBUG: assumption - that a toll prefix is 3 tchars
+                  pSubscriber[3] = ',';
+                  pSubscriber[4] = '\0';
+
+
+                  lstrcatW( gpCurrentLocation->TollListW, pSubscriber );
+               }
+            }
+            else
+            {
+               //
+               // Make sure this prefix is not in the list (remove if necessary)
+               //
+               if (
+                     (pPrefixLocation != NULL)
+                   &&
+                     (lstrlenW(pPrefixLocation) > 1)
+                  )
+               {
+                  lstrcpyW( pPrefixLocation, wcschr( pPrefixLocation+1, ',') );
+               }
+            }
+
+
+//            ClientFree( pAddressIn );
+
+
+            dwDialChangedFlags |= CHANGEDFLAGS_TOLLLIST;
+
+            UpdateNumberField( hWnd, gpszAddress);
+
+            //
+            // Activate the APPLY button if not already done
+            //
+            PropSheet_Changed(GetParent(hWnd), hWnd);
+
+            }
+            break;
+
+
+
+        case IDCK_DL_CALLINGCARD:
+            {
+            dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+            pThisLocation->dwFlags ^= LOCATION_USECALLINGCARD;
+
+            //if this box is being checked, and
+            //if the user has no calling card selected, he must choose one now
+            //if the user cancels out of choosing the calling card, this
+            //check box should be unchecked
+
+
+            //
+            // Does this location use a calling card?
+            //
+            if ( pThisLocation->dwFlags & LOCATION_USECALLINGCARD )
+            {
+               EnableWindow( GetDlgItem(hWnd, IDCE_DL_CALLINGCARD), TRUE );
+            }
+            else
+            {
+               //
+               // Disable the Calling Card name field
+               //
+               EnableWindow( GetDlgItem(hWnd, IDCE_DL_CALLINGCARD), FALSE );
+            }
+
+
+            //
+            // Activate the APPLY button if not already done
+            //
+            PropSheet_Changed(GetParent(hWnd), hWnd);
+
+            UpdateNumberField( hWnd, gpszAddress);
+
+            }
+            break;
+
+
+        case IDCR_TONE:
+        case IDCR_PULSE:
+            {
+            dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+            pThisLocation->dwFlags ^= LOCATION_USETONEDIALING;
+            FillDialingPropertyDialog( hWnd, pThisLocation );
+
+//            UpdateNumberField( hWnd, gpszAddress);
+
+            //
+            // Activate the APPLY button if not already done
+            //
+            PropSheet_Changed(GetParent(hWnd), hWnd);
+
+            }
+            break;
+
+
+        case IDCC_DL_COUNTRY:
+            {
+            LONG lThisCountryIndex;
+
+            //
+            // Only process if something is changing
+            //
+            switch  HIWORD(wParam)
+            {
+               case  CBN_SELCHANGE:
+               {
+
+                  dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+                  lThisCountryIndex = SendDlgItemMessage(
+                                                hWnd,
+                                                IDCC_DL_COUNTRY,
+                                                CB_GETCURSEL,
+                                                0,
+                                                0);
+
+                  pThisLocation->dwCountry = SendDlgItemMessage(
+                                                hWnd,
+                                                IDCC_DL_COUNTRY,
+                                                CB_GETITEMDATA,
+                                                lThisCountryIndex,
+                                                0);
+
+
+                  UpdateNumberField( hWnd, gpszAddress);
+
+
+                  if (
+                        (gpCurrentLocation->dwCountry == 1)
+                      &&
+                        (NULL != gpszAddress)
+                      &&
+                        (gpszAddress[0] != '\0')
+                     )
+                  {
+                     ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_SHOW);
+                  }
+                  else
+                  {
+                     ShowWindow( GetDlgItem( hWnd, IDCK_DL_IN_LOCAL), SW_HIDE);
+                  }
+
+
+                  //
+                  // Activate the APPLY button if not already done
+                  //
+                  PropSheet_Changed(GetParent(hWnd), hWnd);
+               }
+
+            }
+            }
+            break;
+
+
+        case IDCC_DL_NAME:
+            {
+            switch (HIWORD(wParam))
+            {
+
+               case  CBN_EDITCHANGE:
+               {
+                  WCHAR szTempString1[MAXLEN_NAME];
+               
+                  //
+                  // The user is typing in the name edit area
+                  //
+
+                  // Get the new name
+                  GetDlgItemTextW( 
+                                  hWnd,
+                                  IDCC_DL_NAME,
+                                  szTempString1,
+                                  MAXLEN_NAME
+                                );
+
+                  // check for null name
+                  if (szTempString1[0] == L'\0')
+                  {
+                      PWSTR buf1;
+                      PWSTR buf2;
+
+                      buf1 = ClientAlloc( 512 * sizeof(WCHAR));
+                      buf2 = ClientAlloc( 512 * sizeof(WCHAR));
+
+                      // put up dialog
+                      LoadStringW(ghInst, IDS_DL_NULL_NAME, buf1, 512 );
+                      LoadStringW(ghInst, IDS_DL_NULL_NAME_CAPTION, buf2, 512 );
+
+                      MessageBoxW( hWnd,
+                                   buf1,
+                                   buf2,
+                                   MB_OK
+                                 );
+
+                      ClientFree( buf1 );
+                      ClientFree( buf2 );
+
+                      // redo the listbox to get what was there
+                      // before the item was made null
+                      SendDlgItemMessage(
+                                         hWnd,
+                                         IDCC_DL_NAME,
+                                         CB_GETEDITSEL,
+                                         (DWORD)&n,
+                                         (DWORD)&nCurrent);
+
+                      RedoLocationListbox( hWnd,
+                                           gLocationList,
+                                           gnNumLocations,
+                                           gpCurrentLocation);
+
+                      SendDlgItemMessage(
+                                         hWnd,
+                                         IDCC_DL_NAME,
+                                         CB_SETEDITSEL,
+                                         0,
+                                         MAKELPARAM( n, nCurrent) );
+
+                      iStaticLastNameEdited = SendDlgItemMessage(hWnd,
+                          IDCC_DL_NAME,
+                          CB_GETCURSEL,
+                          0,
+                          0);
+
+                      // set the focus too
+                      SetFocus(GetDlgItem(hWnd,
+                                          IDCC_DL_NAME));
+
+
+                      return FALSE;
+
+                  }
+                  
+                  // copy sztempstring1 to pThisLocation
+#ifdef PARTIAL_UNICODE
+                  MultiByteToWideChar(
+                                      GetACP(),
+                                      MB_PRECOMPOSED,
+                                      szTempString1,
+                                      -1,
+                                      pThisLocation->NameW,
+                                      MAXLEN_NAME
+                                     );
+#else
+                  lstrcpyW(pThisLocation->NameW, szTempString1);
+#endif
+
+                  SendDlgItemMessage(
+                                          hWnd,
+                                          IDCC_DL_NAME,
+                                          CB_GETEDITSEL,
+                                          (DWORD)&n,
+                                          (DWORD)&nCurrent);
+
+                  RedoLocationListbox( hWnd,
+                                       gLocationList,
+                                       gnNumLocations,
+                                       gpCurrentLocation);
+
+                  SendDlgItemMessage(
+                                          hWnd,
+                                          IDCC_DL_NAME,
+                                          CB_SETEDITSEL,
+                                          0,
+                                          MAKELPARAM( n, nCurrent) );
+
+                  iStaticLastNameEdited = SendDlgItemMessage(hWnd,
+                                                             IDCC_DL_NAME,
+                                                             CB_GETCURSEL,
+                                                             0,
+                                                             0);
+
+                  dwDialChangedFlags |= CHANGEDFLAGS_REALCHANGE;
+
+                  PropSheet_Changed(GetParent(hWnd), hWnd);
+               }
+               break;
+
+            case CBN_SELCHANGE:
+                {
+//              if the name is a dupe.
+//                 tell user and "reselect" "current" item
+
+                    if (!CheckForDupLocation(hWnd,
+                                            iStaticLastNameEdited))
+                    {
+                       return 0;
+                    }
+
+        //
+        // Get the current (or being-changed-to) location index
+        //
+        lThisItemIndex = SendDlgItemMessage(
+                hWnd,
+                IDCC_DL_NAME,
+                CB_GETCURSEL,
+                0,
+                0);
+if (lThisItemIndex == -1 )
+{
+DBGOUT((0, "Found one(3)!!!!"));
+}
+
+        //
+        // Get our pointer to the location struct
+        //
+        pThisLocation = (PLOCATION)(SendDlgItemMessage(
+                                          hWnd,
+                                          IDCC_DL_NAME,
+                                          CB_GETITEMDATA,
+                                          lThisItemIndex,
+                                          0));
+        if ( pThisLocation == (PLOCATION)-1 )
+{ //this is a test
+                  // Get the new name
+#ifdef PARTIAL_UNICODE
+                  GetDlgItemText( 
+#else
+                  GetDlgItemTextW( 
+#endif
+                                  hWnd,
+                                  IDCC_DL_NAME,
+#ifdef PARTIAL_UNICODE
+                                  szTempString,
+#else
+                                  pThisLocation->NameW,
+#endif
+                                  MAXLEN_NAME
+                                );
+
+#ifdef PARTIAL_UNICODE
+                  MultiByteToWideChar(
+                                       GetACP(),
+                                       MB_PRECOMPOSED,
+                                       szTempString,
+                                       -1,
+                                       pThisLocation->NameW,
+                                       MAXLEN_NAME
+                                     );
+#endif
+
+
+                  RedoLocationListbox( hWnd,
+                                       gLocationList,
+                                       gnNumLocations,
+                                       gpCurrentLocation);
+           pThisLocation = gpCurrentLocation;
+}
+
+                //
+                // Update our "local global static location" pointer
+                //
+                gpCurrentLocation = pThisLocation;
+
+
+InternalDebugOut((10, "New name->%ls", pThisLocation->NameW));
+
+                dwDialChangedFlags |= CHANGEDFLAGS_CURLOCATIONCHANGED;
+
+                //
+                // Since we're going to do something that's going to cause
+                // the dialog box to update, let's save the _real_
+                // changedflags state and restore after the turmoil.
+                //
+                {
+                   DWORD dwTemp;
+
+                   dwTemp = dwDialChangedFlags;
+                   FillDialingPropertyDialog( hWnd, pThisLocation );
+                   dwDialChangedFlags = dwTemp;
+                }
+
+
+//this should be a "new location" button press
+
+                //
+                // If there is only one location, disable the remove button
+                //
+                n = SendDlgItemMessage(
+                       hWnd,
+                       IDCC_DL_NAME,
+                       CB_GETCOUNT,
+                       0,
+                       0
+                       );
+
+                if ( n < 2 )
+                {
+                   EnableWindow( GetDlgItem(hWnd, IDCB_DL_REMOVE_LOCATION), FALSE );
+                }
+                else
+                {
+                   EnableWindow( GetDlgItem(hWnd, IDCB_DL_REMOVE_LOCATION), TRUE );
+                }
+
+
+                UpdateNumberField( hWnd, gpszAddress);
+
+                //
+                // Activate the APPLY button if not already done
+                //
+                PropSheet_Changed(GetParent(hWnd), hWnd);
+
+                }
+
+            break;
+            }
+            }
+
+        }
+        }
+        break;
+
+
+    }
+
+    return FALSE;
+}
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL AddAPropertyPage( 
+#ifdef PARTIAL_UNICODE
+                              PROPSHEETHEADER  *ppsh,
+#else
+                              PROPSHEETHEADERW *ppsh,
+#endif
+                              DLGPROC dlgproc,
+                              DWORD dwTemplate,
+                              LPARAM lParam
+                            )
+{
+#ifdef PARTIAL_UNICODE
+    PROPSHEETPAGE  psp;
+#else
+    PROPSHEETPAGEW  psp;
+#endif
+
+    psp.dwSize      = sizeof(psp);
+    psp.dwFlags     = PSP_DEFAULT;
+    psp.hInstance   = ghInst;  //GetModuleHandle (NULL);
+#ifdef PARTIAL_UNICODE
+    psp.pszTemplate = MAKEINTRESOURCE(dwTemplate);
+#else
+    psp.pszTemplate = MAKEINTRESOURCEW(dwTemplate);
+#endif
+    psp.pfnDlgProc  = dlgproc;
+
+    psp.lParam      = lParam;
+
+#ifdef PARTIAL_UNICODE
+    ppsh->phpage[ppsh->nPages] = CreatePropertySheetPage(&psp);
+#else
+    ppsh->phpage[ppsh->nPages] = CreatePropertySheetPageW(&psp);
+#endif
+
+    if (ppsh->phpage[ppsh->nPages])
+    {                  
+       ppsh->nPages++;
+    }
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineTranslateDialogW(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    HWND        hwndOwner,
+    LPCWSTR     lpszAddressIn
+    )
+{
+
+    HPROPSHEETPAGE   rPages[MAXPROPPAGES];
+    PROPSHEETPAGE    psp;
+#ifdef PARTIAL_UNICODE
+    CHAR             szCaption[128];
+    PROPSHEETHEADER  psh;
+#else
+    WCHAR            szCaption[128];
+    PROPSHEETHEADERW psh;
+#endif
+    LONG             lResult;
+    UINT             uUpdated;
+
+    PLOCATION  MyLocationList = NULL;
+//    PCARD  MyCardList = NULL;
+    PUINT pnStuff = NULL;
+
+
+
+    if (!gbInternalTranslate)
+    {
+        lResult = IsThisAPIVersionInvalid( dwAPIVersion );
+        if ( lResult )
+        {
+            DBGOUT((1, "Bad dwAPIVersion - 0x%08lx", dwAPIVersion));
+            return lResult;
+        }
+    }
+
+
+    if ( lpszAddressIn && IsBadStringPtrW(lpszAddressIn, (UINT)-1) )
+    {
+        DBGOUT((1, "Bad lpszAddressIn pointer (0x%08lx)", lpszAddressIn));
+        return( LINEERR_INVALPOINTER);
+    }
+    
+
+    CheckCards();
+
+
+    if (hwndOwner && !IsWindow (hwndOwner))
+    {
+        InternalDebugOut((1, "  hwndOwner is bogus"));
+        return LINEERR_INVALPARAM;
+    }
+
+
+
+    lResult = ReadLocations( &MyLocationList,
+                             &pnStuff,
+                             hLineApp,
+                             dwDeviceID,
+                             dwAPIVersion,
+                             CHECKPARMS_DWHLINEAPP |
+                                 CHECKPARMS_DWDEVICEID |
+                                 CHECKPARMS_DWAPIVERSION
+                           );
+    if (
+          (0 != lResult)
+        &&
+          ( lResult != LINEERR_INIFILECORRUPT )
+       )
+    {
+       InternalDebugOut((1, "Leaving lineTranslateDialogW result=0x%08lx", lResult));
+       return lResult;
+    }
+
+
+
+//   pdwStuff[2] = nNumLocations;
+
+    if (
+          (lResult == LINEERR_INIFILECORRUPT)
+        ||
+          (0 == pnStuff[2])
+        ||
+          gbTranslateSimple
+       )
+    {
+#ifdef PARTIAL_UNICODE
+               DialogBoxParam(
+                     ghInst,
+                     MAKEINTRESOURCE(IDD_DEFINE_LOCATION_SIMPLE),
+                     hwndOwner,
+                     LocDefineDlgSimple,
+                     gbTranslateSilent
+                   );
+#else
+               DialogBoxParamW(
+                     ghInst,
+                     MAKEINTRESOURCEW(IDD_DEFINE_LOCATION_SIMPLE),
+                     hwndOwner,
+                     LocDefineDlgSimple,
+                     gbTranslateSilent
+                   );
+#endif
+
+               if (gbTranslateSimple)
+               {
+                   gbTranslateSimple = FALSE;
+                   gbTranslateSilent = FALSE;
+                   return 0;
+               }
+
+//          return 0;
+//          After displaying the MiniDialHelper, fall through to the main
+//          DialingProperties
+
+    }
+
+
+    gpszAddress = (PWSTR)lpszAddressIn;
+
+
+    //*** *** ***BUGBUG set event so no other process starts one of these
+
+    psh.dwSize      = sizeof(psh);
+    psh.dwFlags     = PSH_DEFAULT;  //PSH_NOAPPLYNOW;
+    psh.hwndParent  = hwndOwner; //GetFocus(); //NULL; //hwnd;
+    psh.hInstance   = ghInst; //GetModuleHandle(NULL);
+
+#ifdef PARTIAL_UNICODE
+    LoadString(
+#else
+    LoadStringW(
+#endif
+                ghInst,
+                DIALINGPROPERTIES_NAME,
+                szCaption,
+                sizeof(szCaption) / sizeof(WCHAR)
+              );
+
+    psh.pszCaption  = szCaption;
+    psh.nPages      = 0;
+    psh.nStartPage  = 0;
+    psh.phpage      = rPages;
+
+
+//    psp.dwSize      = sizeof(psp);
+//    psp.dwFlags     = PSP_DEFAULT;
+//    psp.hInstance   = ghInst;  //GetModuleHandle (NULL);
+//    psp.pszTemplate = MAKEINTRESOURCE(IDD_DEFINE_LOCATION);
+//    psp.pfnDlgProc  = (DLGPROC) LocationsDlgProc;
+//    psp.lParam      = (LPARAM)lpszAddressIn; //(LPARAM) NULL; // lpszAddressIn;
+//
+//    psh.phpage[psh.nPages] = CreatePropertySheetPage (&psp);
+//
+//    if (psh.phpage[psh.nPages])
+//    {
+//        psh.nPages++;
+//    }
+
+    AddAPropertyPage(
+                      &psh,
+                      LocationsDlgProc,
+                      IDD_DEFINE_LOCATION,
+                      (LPARAM)lpszAddressIn
+                    );
+
+/*
+BUGBUG: This is removed until the story is worked out...
+
+    AddAPropertyPage(
+                      &psh,
+                      GeneralDlgProc,
+                      IDD_GENERAL,
+                      0
+                    );
+*/
+
+/*******************************************************************
+********************************************************************
+NOTE: lineTranslateDialog no longer brings up the ConfigureProviders
+      tab, since that is only for the telephony cpl.  A new internal
+      entry point has been added to do both the dialing properties and
+      configure providers - internalConfigure(HWND)
+*******************************************************************/
+
+    if (gbInternalTranslate)
+    {
+
+        {
+#include "..\cpl\resource.h"
+#include "..\cpl\drv.h"
+
+            //
+            // Now build the drivers tab
+            //
+
+            extern CPL   gCPL;       // app global
+
+            // init global static data    
+            //------------------------
+            gCPL.hCplInst     = ghInst;
+            gCPL.uCplApplets  = 0;
+            gCPL.uInstances   = 0;
+            gCPL.hCtl3DInst   = NULL;
+
+            lResult = CplInit( hwndOwner, TRUE, &uUpdated );
+
+
+            //       psp.dwSize = sizeof(psp);
+            //       psp.dwFlags = PSP_DEFAULT;
+            //       psp.hInstance = ghInst;
+            //       psp.pszTemplate = MAKEINTRESOURCE(IDD_DRIVER_SETUP);
+            //       psp.pfnDlgProc = (DLGPROC)FDlgDriverList;
+            ////       psp.lParam = lParam;
+            //       psp.lParam = 0;
+            //
+            //
+            //       psh.phpage[psh.nPages] = CreatePropertySheetPage(&psp);
+            //
+            //
+            //       if (psh.phpage[psh.nPages])
+            //       {
+            //           psh.nPages++;
+            //       }
+
+            AddAPropertyPage(
+                             &psh,
+                             FDlgDriverList,
+                             IDD_DRIVER_SETUP,
+                             0
+                            );
+
+
+        }
+
+        gbInternalTranslate = FALSE;
+
+    } // if bInternalTranslate
+
+
+#ifdef PARTIAL_UNICODE
+    if (PropertySheet(&psh) < 0)
+#else
+    if (PropertySheetW(&psh) < 0)
+#endif
+    {
+//        lRetval = LINEERR_OPERATIONFAILED;
+        InternalDebugOut((1, "  PropertySheet(&psh) returns <0 (OPERATION FAILED)"));
+    }
+    else
+    {
+//        lRetval = 0L;
+    }
+
+
+    if (MyLocationList)
+       ClientFree( MyLocationList );
+    if (pnStuff)
+       ClientFree( pnStuff );
+
+
+    return (0);
+}
+
+///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////
+//  internalConfigure now does exactly what lineTranslateDialog used
+//  to do - bring up both dialing properties and configure providers
+///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////
+
+LONG
+WINAPI
+internalConfig(HWND hwndOwner)
+{
+    gbInternalTranslate = TRUE;
+    return (lineTranslateDialogW(0,
+                                 0,
+                                 TAPI_VERSION2_0,
+                                 hwndOwner,
+                                 NULL));
+
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineTranslateDialogA(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    HWND        hwndOwner,
+    LPCSTR      lpszAddressIn
+    )
+{
+   PWSTR szAddressInW = NULL;
+   LONG  lResult;
+
+
+   if ( lpszAddressIn && IsBadStringPtr(lpszAddressIn, 512) )
+   {
+      DBGOUT((1, "Bad string pointer passed to lineTranslateDialog"));
+      return LINEERR_INVALPOINTER;
+   }
+   else
+   {
+      szAddressInW = MultiToWide( lpszAddressIn );
+   }
+
+   lResult = lineTranslateDialogW(
+                                   hLineApp,
+                                   dwDeviceID,
+                                   dwAPIVersion,
+                                   hwndOwner,
+                                   szAddressInW
+                                 );
+
+    if ( szAddressInW )
+    {
+       ClientFree( szAddressInW );
+    }
+
+    return lResult;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineTranslateDialog(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    HWND        hwndOwner,
+    LPCSTR      lpszAddressIn
+    )
+{
+    return lineTranslateDialogA(
+                 hLineApp,
+                 dwDeviceID,
+                 dwAPIVersion,
+                 hwndOwner,
+                 lpszAddressIn
+    );
+}    
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL LayDownString( LPCWSTR pInString,
+                           LPSTR  pBuffer,
+                           LPSTR *ppCurrentIndex,
+                           LPDWORD pSize     // this is the Len & Offset pair
+                         )
+{
+   UINT nTemp;
+   LPSTR pTempString;
+
+   InternalDebugOut((70, "putstring [%ls] at: pbuf:0x%08lx *currind:0x%08lx currind:0x%08lx pSize:0x%08lx",
+                         pInString, (DWORD)pBuffer, (DWORD)*ppCurrentIndex,
+                         ppCurrentIndex, pSize));
+
+
+   nTemp =  lstrlenW( pInString );
+
+   //
+   // Get some space in which to convert Unicode to local
+   //
+   pTempString = ClientAlloc( nTemp + 2);
+
+
+   //
+   // Also copy and count the NULL terminator
+   //
+   pSize[0] = nTemp + 1;
+
+
+   //
+   // Ultra paranoid because of PPC alignment problems
+   // Make sure we're starting on a DWORD boundry
+   //
+   *ppCurrentIndex = (LPSTR) ((DWORD)( *ppCurrentIndex + 3 )  &  ( ~3 ));
+      
+
+   pSize[1] = *ppCurrentIndex - pBuffer;
+
+InternalDebugOut((71, "Offset= 0x%08lx", (DWORD)pSize[1]));
+
+   if ( nTemp != 0 )
+   {
+      WideCharToMultiByte(
+                           GetACP(),
+                           0,
+                           pInString,
+                           -1,
+                           pTempString,
+                           nTemp+1,
+                           NULL,
+                           NULL
+                         );
+
+      lstrcpy( *ppCurrentIndex, pTempString );
+      *ppCurrentIndex += nTemp;
+   }
+
+   //
+   // Let's not forget to account for the NULL shall we?
+   //
+   **ppCurrentIndex = '\0';
+   (LPBYTE)*ppCurrentIndex += 1;
+
+   ClientFree(pTempString);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void PASCAL LayDownStringW(LPCWSTR pInString,
+                           LPWSTR  pBuffer,
+                           LPWSTR *ppCurrentIndex,
+                           LPDWORD pSize     // this is the Len & Offset pair
+                         )
+{
+   UINT nTemp;
+
+
+   InternalDebugOut((70, "putstring [%ls] at: pbuf:0x%08lx *currind:0x%08lx currind:0x%08lx pSize:0x%08lx",
+                         pInString, (DWORD)pBuffer, (DWORD)*ppCurrentIndex,
+                         ppCurrentIndex, pSize));
+
+
+   nTemp =  lstrlenW( pInString );
+
+   //
+   // Also copy and count the NULL terminator
+   //
+   pSize[0] = (nTemp + 1) * sizeof(WCHAR);
+
+
+   //
+   // Ultra paranoid because of PPC alignment problems (and future)
+   // Make sure we're starting on a double DWORD boundry
+   //
+   *ppCurrentIndex = (LPWSTR) ((DWORD)( *ppCurrentIndex + 7 )  &  ( ~7 ));
+      
+
+   pSize[1] = (LPBYTE)*ppCurrentIndex - (LPBYTE)pBuffer;
+
+InternalDebugOut((71, "Offset= 0x%08lx", (DWORD)pSize[1]));
+
+   if ( nTemp != 0 )
+   {
+      lstrcpyW( *ppCurrentIndex, pInString );
+      *ppCurrentIndex += nTemp;
+   }
+
+   //
+   // Let's not forget to account for the NULL shall we?
+   //
+   **ppCurrentIndex = '\0';
+   (LPBYTE)*ppCurrentIndex += 1;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineGetTranslateCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+
+    LONG  lResult = 0;
+    PLOCATION  MyLocationList = NULL;
+    PCARD  MyCardList = NULL;
+    PUINT pnStuff = NULL;
+    PUINT pnCardStuff = NULL;
+    PBYTE pCurrentIndex;
+    PBYTE pMyBuffer = NULL;
+    register UINT nTemp;
+    UINT nFinalSize;
+
+    UINT nLocationsSize;
+    UINT nLocationsStart;
+    UINT nCardsSize;
+    UINT nCardsStart;
+
+
+    lResult = IsThisAPIVersionInvalid( dwAPIVersion );
+    if ( lResult )
+    {
+       DBGOUT((1, "Bad dwAPIVersion - 0x%08lx", dwAPIVersion));
+       return lResult;
+    }
+
+
+    if ( IsBadWritePtr(lpTranslateCaps, sizeof(DWORD)*3) )
+    {
+        InternalDebugOut((1, "lpTranslateCaps not a valid pointer"));
+        return LINEERR_INVALPOINTER;
+    }
+
+
+    if ( lpTranslateCaps->dwTotalSize < sizeof(LINETRANSLATECAPS))
+    {
+        InternalDebugOut((1, "Not even enough room for the fixed portion"));
+        lResult = LINEERR_STRUCTURETOOSMALL;
+    }
+    else 
+    {
+        PCARD              pThisCard;
+        LINECARDENTRY     *pThisCardEntry;
+        PLOCATION          pThisLocation;
+        LINELOCATIONENTRY *pThisLocationEntry;
+        UINT n;
+
+
+        lResult = ReadLocations( &MyLocationList,
+                                 &pnStuff,
+                                 hLineApp,
+                                 0,
+                                 dwAPIVersion,
+                                 CHECKPARMS_DWHLINEAPP |
+                                     CHECKPARMS_DWAPIVERSION
+                               );
+        if ( 0 != lResult )
+        {
+           InternalDebugOut((1, "Leaving lineGetTranslateCapsW result=0x%08lx", lResult));
+           return lResult;
+        }
+
+
+        ReadCardsEasy( &MyCardList, &pnCardStuff );
+
+//*** *** ***BUGBUG (dial.c GetTranslateCaps) Need to check return code!
+
+
+//   pdwStuff[0] = nCurrentLocationID;
+//   pdwStuff[1] = pLocationList;
+//   pdwStuff[2] = nNumLocations;
+
+
+        //
+        // Allocate a temp buffer to put the data into.
+        // Prepare for worst case
+        //
+        pMyBuffer = ClientAlloc( (pnStuff[2] *
+                                    (sizeof(LINELOCATIONENTRY) +
+                                        (MAXLEN_NAME *sizeof(WCHAR)) +
+                                        (MAXLEN_AREACODE *sizeof(WCHAR)) +
+                                        (MAXLEN_OUTSIDEACCESS *sizeof(WCHAR)) +
+                                        (MAXLEN_LONGDISTANCEACCESS *sizeof(WCHAR)) +
+                                        (MAXLEN_DISABLECALLWAITING *sizeof(WCHAR)) +
+                                        (MAXLEN_TOLLLIST*sizeof(WCHAR)) +
+                                        100   //mmmm fudge...
+                                    )
+                                 )
+                                +
+                                   ( pnCardStuff[2] *
+                                     (sizeof(LINECARDENTRY) +
+                                         (MAXLEN_CARDNAME *sizeof(WCHAR)) +
+                                         (MAXLEN_PIN  *sizeof(WCHAR)) +
+                                         (MAXLEN_RULE*sizeof(WCHAR)) +      //Local
+                                         MAXLEN_RULE*sizeof(WCHAR) +      //LongDistance
+                                         MAXLEN_RULE*sizeof(WCHAR) +      //International
+                                        100   //mmmm fudge...
+                                     )
+                                   )
+                               );
+
+InternalDebugOut((70, "Ptr=0x%08lx Size is:0x%ld",
+                   pMyBuffer, (DWORD)ClientSize( pMyBuffer )));
+
+        if ( NULL == pMyBuffer )
+        {
+           InternalDebugOut((1, "  Secondary memory alloc failed!"));
+           lResult = LINEERR_NOMEM;
+           goto cleanup;
+        }
+
+
+        //
+        // Start filling in after the main struct
+        //
+
+
+        //
+        // Do the Location Entries first
+        //
+
+
+        pThisLocation = MyLocationList;
+        pThisLocationEntry = (LPLINELOCATIONENTRY)((LPBYTE)pMyBuffer +
+                                                    sizeof(LINETRANSLATECAPS));
+
+        nLocationsStart = sizeof(LINETRANSLATECAPS);
+
+        //
+        // Ok, we'll fill in locationentries below.  So, now we offset
+        // out pointer so we're pointing to where we'll start copying strings.
+        //
+        pCurrentIndex = (LPBYTE)pThisLocationEntry +
+                        (sizeof(LINELOCATIONENTRY) * pnStuff[2]);
+
+//BUGBUG Backward compatibility! Fix for version 1.3!
+
+        for ( n = 0;  n < pnStuff[2];  n++ )
+        {
+
+
+InternalDebugOut((70, "pThisLoc=0x%08lx pThisLocEntry=0x%08lx pCurIndex=0x%08lx offset=0x%08lx",
+                (DWORD)pThisLocation,
+                (DWORD)pThisLocationEntry,
+                (DWORD)pCurrentIndex,
+                (DWORD)((LPBYTE)pCurrentIndex - pMyBuffer) ));
+
+           //
+           // Is this the current location?
+           //
+           if ( pThisLocation->dwID == pnStuff[0] )
+           {
+               //
+               // Yes.  Get the CallingCard ID of this location.
+               //
+               ((LPLINETRANSLATECAPS)pMyBuffer)->dwCurrentPreferredCardID =
+                             pThisLocation->dwCallingCard;
+           }
+
+
+           pThisLocationEntry->dwPermanentLocationID = pThisLocation->dwID;
+
+           LayDownStringW( pThisLocation->NameW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisLocationEntry->dwLocationNameSize));
+
+           pThisLocationEntry->dwCountryCode = pThisLocation->dwCountry;
+
+           LayDownStringW( pThisLocation->AreaCodeW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisLocationEntry->dwCityCodeSize));
+
+           //
+           // Only give a CC ID if the "Use Calling Card" flag is set
+           //
+           if ( LOCATION_USECALLINGCARD & pThisLocation->dwFlags )
+           {
+               pThisLocationEntry->dwPreferredCardID = pThisLocation->dwCallingCard;
+           }
+           else
+           {
+               pThisLocationEntry->dwPreferredCardID = 0;
+           }
+           
+
+
+//*** *** ***BUGBUG 1.3!
+//if > ver 1.3
+           LayDownStringW( pThisLocation->OutsideAccessW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisLocationEntry->dwLocalAccessCodeSize));
+
+           LayDownStringW( pThisLocation->LongDistanceAccessW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisLocationEntry->dwLongDistanceAccessCodeSize));
+
+           LayDownStringW( pThisLocation->TollListW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisLocationEntry->dwTollPrefixListSize));
+
+           pThisLocationEntry->dwCountryID = pThisLocation->dwCountry;
+
+           pThisLocationEntry->dwOptions =  !(pThisLocation->dwFlags &
+                                              LOCATION_USETONEDIALING);
+
+           LayDownStringW( pThisLocation->DisableCallWaitingW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisLocationEntry->dwCancelCallWaitingSize));
+
+//endif ver > 1.3
+
+           pThisLocation++;
+           pThisLocationEntry++;
+        }
+
+
+//WHAT THE HELL WAS THE +16 FOR?nLocationsSize = pCurrentIndex - pMyBuffer+16;
+        nLocationsSize = pCurrentIndex - (pMyBuffer+nLocationsStart);
+
+
+
+        pThisCard = MyCardList;
+
+        //
+        // Make sure this is double DWORD aligned for PPC (and future)
+        //
+        pThisCardEntry = (LINECARDENTRY*)((DWORD)(pCurrentIndex + 7) & (~7)) ;
+
+        nCardsStart = (LPSTR)pThisCardEntry - pMyBuffer;
+
+
+        //
+        // Update the offset pointer to write strings after the CARD structs
+        //
+        pCurrentIndex = (LPSTR)pThisCardEntry + ( sizeof(LINECARDENTRY) *
+                                                  pnCardStuff[2] );
+
+        for ( n = 0;  n < pnCardStuff[2];  n++ )
+        {
+
+
+InternalDebugOut((70, "  pThisCard=0x%08lx pCurrentIndex=0x%08lx offset=0x%08lx",
+                (DWORD)pThisCard,
+                (DWORD)pCurrentIndex,
+                (DWORD)((LPBYTE)pCurrentIndex - pMyBuffer) ));
+
+           pThisCardEntry->dwPermanentCardID = pThisCard->dwID;
+
+           LayDownStringW( pThisCard->NameW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisCardEntry->dwCardNameSize));
+
+           LayDownStringW( pThisCard->LocalRuleW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisCardEntry->dwSameAreaRuleSize));
+
+           LayDownStringW( pThisCard->LDRuleW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisCardEntry->dwLongDistanceRuleSize));
+
+           LayDownStringW( pThisCard->InternationalRuleW,
+                           (PWSTR)pMyBuffer,
+                           (PWSTR *)&pCurrentIndex,
+                           &(pThisCardEntry->dwInternationalRuleSize));
+
+           pThisCardEntry->dwCardNumberDigits = lstrlenW(pThisCard->PinW);
+
+
+           pThisCardEntry->dwOptions =  pThisCard->dwFlags;
+
+
+           pThisCard++;
+           pThisCardEntry++;
+        }
+
+
+        nCardsSize = pCurrentIndex - (pMyBuffer+nCardsStart);
+
+
+//BUGBUG What's the "+16" for?
+        nFinalSize = pCurrentIndex - pMyBuffer + 16;
+
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwTotalSize = lpTranslateCaps->dwTotalSize;
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwNeededSize = nFinalSize;
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwNumLocations = pnStuff[2];
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwLocationListSize = nFinalSize - sizeof(LINETRANSLATECAPS);
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwLocationListOffset =
+                                                sizeof(LINETRANSLATECAPS);
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwCurrentLocationID = pnStuff[0];
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwNumCards = pnCardStuff[2];
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwCardListSize = nCardsSize;
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwCardListOffset = nCardsStart;
+
+
+        if ( lpTranslateCaps->dwTotalSize < nFinalSize )
+        {
+InternalDebugOut((1, "Not enough space to copy the entire buffer"));
+InternalDebugOut((1, "Needed %ld, but had %ld available",
+                             nFinalSize, lpTranslateCaps->dwTotalSize));
+
+            ((LPLINETRANSLATECAPS)pMyBuffer)->dwUsedSize   = sizeof(LINETRANSLATECAPS);
+            CopyMemory(
+                        lpTranslateCaps,
+                        pMyBuffer,
+                        sizeof(LINETRANSLATECAPS)
+                      );
+        }
+        else
+        {
+            ((LPLINETRANSLATECAPS)pMyBuffer)->dwUsedSize   = nFinalSize;
+            CopyMemory(
+                        lpTranslateCaps,
+                        pMyBuffer,
+                        nFinalSize
+                      );
+        }
+
+    }
+
+
+
+cleanup:
+
+    if (pMyBuffer)
+       ClientFree( pMyBuffer );
+
+    if (MyLocationList)
+       ClientFree( MyLocationList );
+    if (MyCardList)
+       ClientFree( MyCardList );
+
+    if (pnCardStuff)
+       ClientFree( pnCardStuff );
+    if (pnStuff)
+       ClientFree( pnStuff );
+
+
+
+
+InternalDebugOut((1, "  Leaving lineGetTranslateCapsW result=0x%08lx", lResult));
+    return (lResult);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineGetTranslateCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+    LONG  lResult = 0;
+    PLOCATION  MyLocationList = NULL;
+    PCARD  MyCardList = NULL;
+    PUINT pnStuff = NULL;
+    PUINT pnCardStuff = NULL;
+    PBYTE pCurrentIndex;
+    PBYTE pMyBuffer = NULL;
+    register UINT nTemp;
+    UINT nFinalSize;
+
+    UINT nCardsSize;
+    UINT nCardsStart;
+
+    UINT uLocationEntrySize;
+    UINT uCardEntrySize;
+    
+
+    lResult = IsThisAPIVersionInvalid( dwAPIVersion );
+    if ( lResult )
+    {
+       DBGOUT((1, "Bad dwAPIVersion - 0x%08lx", dwAPIVersion));
+       return lResult;
+    }
+
+
+    if ( IsBadWritePtr(lpTranslateCaps, sizeof(DWORD)*3) )
+    {
+        InternalDebugOut((1, "lpTranslateCaps not a valid pointer"));
+        return LINEERR_INVALPOINTER;
+    }
+
+
+    if ( TAPI_VERSION1_0 == dwAPIVersion )
+    {
+        uLocationEntrySize = 28;
+        uCardEntrySize = 12;
+    }
+    else
+    {
+        uLocationEntrySize = sizeof(LINELOCATIONENTRY);
+        uCardEntrySize = sizeof(LINECARDENTRY);
+    }
+    
+    
+
+
+    if ( lpTranslateCaps->dwTotalSize < sizeof(LINETRANSLATECAPS))
+    {
+        InternalDebugOut((1, "Not even enough room for the fixed portion"));
+        lResult = LINEERR_STRUCTURETOOSMALL;
+    }
+    else 
+    {
+        PCARD              pThisCard;
+        LINECARDENTRY     *pThisCardEntry;
+        PLOCATION          pThisLocation;
+        LINELOCATIONENTRY *pThisLocationEntry;
+        UINT n;
+
+
+        lResult = ReadLocations( &MyLocationList,
+                                 &pnStuff,
+                                 hLineApp,
+                                 0,
+                                 dwAPIVersion,
+                                 CHECKPARMS_DWAPIVERSION |
+                                     CHECKPARMS_DWHLINEAPP
+                               );
+        if ( 0 != lResult )
+        {
+           InternalDebugOut((1, "Leaving lineGetTranslateCaps  result=0x%08lx", lResult));
+           return lResult;
+        }
+
+
+        ReadCardsEasy( &MyCardList, &pnCardStuff );
+
+//*** *** ***BUGBUG (dial.c GetTranslateCaps) Need to check return code!
+
+
+//   pdwStuff[0] = nCurrentLocationID;
+//   pdwStuff[1] = pLocationList;
+//   pdwStuff[2] = nNumLocations;
+
+
+        //
+        // Allocate a temp buffer to put the data into.
+        // Prepare for worst case
+        //
+        pMyBuffer = ClientAlloc( (pnStuff[2] *
+                                    (sizeof(LINELOCATIONENTRY) +
+                                        MAXLEN_NAME +
+                                        MAXLEN_AREACODE +
+                                        MAXLEN_OUTSIDEACCESS +
+                                        MAXLEN_LONGDISTANCEACCESS +
+                                        MAXLEN_DISABLECALLWAITING +
+                                        MAXLEN_TOLLLIST +
+                                        100   //mmmm fudge...
+                                    )
+                                 )
+                                +
+                                   ( pnCardStuff[2] *
+                                     (sizeof(LINECARDENTRY) +
+                                         MAXLEN_CARDNAME +
+                                         MAXLEN_PIN  +
+                                         MAXLEN_RULE +      //Local
+                                         MAXLEN_RULE +      //LongDistance
+                                         MAXLEN_RULE +      //International
+                                        100   //mmmm fudge...
+                                     )
+                                   )
+                               );
+
+InternalDebugOut((70, "Ptr=0x%08lx Size is:0x%ld",
+                   pMyBuffer, (DWORD)ClientSize( pMyBuffer )));
+
+        if ( NULL == pMyBuffer )
+        {
+           InternalDebugOut((1, "  Secondary memory alloc failed!"));
+           lResult = LINEERR_NOMEM;
+           goto cleanup;
+        }
+
+
+        //
+        // Start filling in after the main struct
+        //
+
+
+        //
+        // Do the Location Entries first
+        //
+
+
+        pThisLocation = MyLocationList;
+        pThisLocationEntry = (LPLINELOCATIONENTRY)((LPBYTE)pMyBuffer +
+                                                    sizeof(LINETRANSLATECAPS));
+
+        //
+        // Ok, we'll fill in locationentries below.  So, now we offset
+        // out pointer so we're pointing to where we'll start copying strings.
+        //
+        pCurrentIndex = (LPBYTE)pThisLocationEntry +
+                        (uLocationEntrySize * pnStuff[2]);
+
+
+        for ( n = 0;  n < pnStuff[2];  n++ )
+        {
+
+
+InternalDebugOut((70, "pThisLoc=0x%08lx pThisLocEntry=0x%08lx pCurIndex=0x%08lx offset=0x%08lx",
+                (DWORD)pThisLocation,
+                (DWORD)pThisLocationEntry,
+                (DWORD)pCurrentIndex,
+                (DWORD)((LPBYTE)pCurrentIndex - pMyBuffer) ));
+
+           pThisLocationEntry->dwPermanentLocationID = pThisLocation->dwID;
+
+           LayDownString( pThisLocation->NameW,
+                           pMyBuffer,
+                           &pCurrentIndex,
+                           &(pThisLocationEntry->dwLocationNameSize));
+
+           pThisLocationEntry->dwCountryCode = pThisLocation->dwCountry;
+
+           LayDownString( pThisLocation->AreaCodeW,
+                           pMyBuffer,
+                           &pCurrentIndex,
+                           &(pThisLocationEntry->dwCityCodeSize));
+
+           //
+           // Only give a CC ID if the "Use Calling Card" flag is set
+           //
+           if ( LOCATION_USECALLINGCARD & pThisLocation->dwFlags )
+           {
+               pThisLocationEntry->dwPreferredCardID = pThisLocation->dwCallingCard;
+           }
+           else
+           {
+               pThisLocationEntry->dwPreferredCardID = 0;
+           }
+           
+           
+           //
+           // Is this the current location?
+           //
+           if ( pThisLocation->dwID == pnStuff[0] )
+           {
+               //
+               // Yes.  Get the CallingCard ID of this location.
+               //
+               ((LPLINETRANSLATECAPS)pMyBuffer)->dwCurrentPreferredCardID =
+                             pThisLocation->dwCallingCard;
+           }
+
+
+           if ( dwAPIVersion != TAPI_VERSION1_0 )
+           {
+               LayDownString( pThisLocation->OutsideAccessW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisLocationEntry->dwLocalAccessCodeSize));
+
+               LayDownString( pThisLocation->LongDistanceAccessW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisLocationEntry->dwLongDistanceAccessCodeSize));
+
+               LayDownString( pThisLocation->TollListW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisLocationEntry->dwTollPrefixListSize));
+
+               pThisLocationEntry->dwCountryID = pThisLocation->dwCountry;
+
+               pThisLocationEntry->dwOptions =  !(pThisLocation->dwFlags &
+                                                  LOCATION_USETONEDIALING);
+
+               LayDownString( pThisLocation->DisableCallWaitingW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisLocationEntry->dwCancelCallWaitingSize));
+               
+           }
+           
+           
+           pThisLocation++;
+           (LPBYTE)pThisLocationEntry += uLocationEntrySize;
+        }
+
+
+
+
+        pThisCard = MyCardList;
+
+        //
+        // Make sure this is double DWORD aligned for PPC (and future)
+        //
+        pThisCardEntry = (LINECARDENTRY*)((DWORD)(pCurrentIndex + 7) & (~7)) ;
+
+        nCardsStart = (LPSTR)pThisCardEntry - pMyBuffer;
+
+
+        //
+        // Update the offset pointer to write strings after the CARD structs
+        //
+        pCurrentIndex = (LPSTR)pThisCardEntry + ( uCardEntrySize *
+                                                  pnCardStuff[2] );
+
+        for ( n = 0;  n < pnCardStuff[2];  n++ )
+        {
+
+
+InternalDebugOut((70, "  pThisCard=0x%08lx pCurrentIndex=0x%08lx offset=0x%08lx",
+                (DWORD)pThisCard,
+                (DWORD)pCurrentIndex,
+                (DWORD)((LPBYTE)pCurrentIndex - pMyBuffer) ));
+
+           pThisCardEntry->dwPermanentCardID = pThisCard->dwID;
+
+           LayDownString( pThisCard->NameW,
+                           pMyBuffer,
+                           &pCurrentIndex,
+                           &(pThisCardEntry->dwCardNameSize));
+
+
+           if ( TAPI_VERSION1_0 != dwAPIVersion )
+           {
+               LayDownString( pThisCard->LocalRuleW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisCardEntry->dwSameAreaRuleSize));
+
+               LayDownString( pThisCard->LDRuleW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisCardEntry->dwLongDistanceRuleSize));
+
+               LayDownString( pThisCard->InternationalRuleW,
+                               pMyBuffer,
+                               &pCurrentIndex,
+                               &(pThisCardEntry->dwInternationalRuleSize));
+
+               pThisCardEntry->dwCardNumberDigits = lstrlenW(pThisCard->PinW);
+
+
+               pThisCardEntry->dwOptions =  pThisCard->dwFlags;
+
+           }
+           
+           
+           pThisCard++;
+           (LPBYTE)pThisCardEntry += uCardEntrySize;
+        }
+
+
+        nCardsSize = pCurrentIndex - (pMyBuffer+nCardsStart);
+
+
+//BUGBUG What's the "+16" for?
+        nFinalSize = pCurrentIndex - pMyBuffer + 16;
+
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwTotalSize = lpTranslateCaps->dwTotalSize;
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwNeededSize = nFinalSize;
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwNumLocations = pnStuff[2];
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwLocationListSize = nFinalSize - sizeof(LINETRANSLATECAPS);
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwLocationListOffset =
+                                                sizeof(LINETRANSLATECAPS);
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwCurrentLocationID = pnStuff[0];
+
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwNumCards = pnCardStuff[2];
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwCardListSize = nCardsSize;
+        ((LPLINETRANSLATECAPS)pMyBuffer)->dwCardListOffset = nCardsStart;
+
+
+        if ( lpTranslateCaps->dwTotalSize < nFinalSize )
+        {
+InternalDebugOut((1, "Not enough space to copy the entire buffer"));
+InternalDebugOut((1, "Needed %ld, but had %ld available",
+                             nFinalSize, lpTranslateCaps->dwTotalSize));
+
+            ((LPLINETRANSLATECAPS)pMyBuffer)->dwUsedSize   = sizeof(LINETRANSLATECAPS);
+            CopyMemory(
+                        lpTranslateCaps,
+                        pMyBuffer,
+                        sizeof(LINETRANSLATECAPS)
+                      );
+        }
+        else
+        {
+            ((LPLINETRANSLATECAPS)pMyBuffer)->dwUsedSize   = nFinalSize;
+            CopyMemory(
+                        lpTranslateCaps,
+                        pMyBuffer,
+                        nFinalSize
+                      );
+        }
+
+    }
+
+
+
+cleanup:
+
+    if (pMyBuffer)
+       ClientFree( pMyBuffer );
+
+    if (MyLocationList)
+       ClientFree( MyLocationList );
+    if (MyCardList)
+       ClientFree( MyCardList );
+
+    if (pnCardStuff)
+       ClientFree( pnCardStuff );
+    if (pnStuff)
+       ClientFree( pnStuff );
+
+
+
+InternalDebugOut((1, "  Leaving lineGetTranslateCaps  result=0x%08lx", lResult));
+    return (lResult);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineGetTranslateCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+    return lineGetTranslateCapsA(
+                 hLineApp,
+                 dwAPIVersion,
+                 lpTranslateCaps
+    );
+}    
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//   Copy a char into lpDest, reserving *lpEnd for '\0'.  Returns NULL on overrun.
+//   Returns next character else.
+//   NOTE: depends on there being at least one char in lpDest at first call.
+//
+//   Returns
+//   ptr to next char on success
+//   NULL on failure
+LPWSTR NEAR CopyChar(WCHAR c, LPWSTR lpDest, LPWSTR lpEnd)
+{
+   if (lpDest == NULL || lpDest >= lpEnd)
+   {
+      InternalDebugOut((1, "  Spillage in CopyChar!"));
+      return NULL;
+   }
+
+
+//  *lpDest = c;
+//  if ( isDBCSLeadByte( (BYTE)*lpDest ) )
+//  *lpDest = c or two bytes
+//*** *** ***
+//  lpDest = AnsiNext( lpDest );
+
+   *lpDest++ = c;
+
+   return lpDest;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//   Copies only digits up to end of string. (simply end of string
+//   if pNext is NULL.) if lpSrc is NULL returns lpDest.
+
+LPWSTR PASCAL CopyDigits( LPWSTR lpSrc,
+                          LPWSTR lpDest,
+                          LPWSTR lpEnd,
+                          BOOL fAndModifiers
+                        )
+{
+   if (lpSrc != NULL)
+   {
+      while (*lpSrc != '\0')
+      {
+
+         if ( IsWDigit(*lpSrc) || ( fAndModifiers && wcschr(csBADCO, *lpSrc)))
+         {
+            lpDest = CopyChar(*lpSrc,lpDest,lpEnd);
+         }
+
+//don't need now that it's Unicode...      lpSrc = CharNext( lpSrc );
+         lpSrc++;
+      }
+   }
+   return lpDest;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//   Matches JUST the digits in lpSegment and lpPrefix, returning TRUE if 
+//   lpSegment starts with lpPrefix.  if matches, lpTail will be the next 
+//   character after the match.  lpPrefix is 0 length (starts with '\0' 
+//   or otherDelimiter) returns FALSE unless lpSegment is NULL.  if lpPrefix
+//   is not 0 length, returns FALSE if lpSegment is NULL.
+//   if commas are not allowed in prefix (dialing rules allow commas, toll 
+//   prefixes do not), pass ',' for otherDelimiter, else 0.
+//   NOTE: lpPrefix is a dialing rule or toll list so it must be terminated
+//      by " or ,
+//   NOTE: if lpSegment or plpTail is NULL, lpTail is not returned
+//
+BOOL PASCAL PrefixMatch( LPWSTR lpSegment,
+                         LPWSTR lpPrefix,
+                         LPWSTR *plpTail,
+                         WCHAR  otherDelimiter,
+                         BOOL   fNeedExactMatch
+                       )
+{
+   BOOL returnResult = TRUE;
+   LPWSTR lpPre = lpPrefix;
+   
+   if (lpSegment != NULL)
+   {
+      while (   *lpSegment != '\0' && 
+            *lpPre != '\0' && 
+            *lpPre != otherDelimiter)
+      {
+         if (IsWDigit(*lpSegment))
+         {
+            if (IsWDigit(*lpPre))
+            {
+               if (*lpSegment != *lpPre)
+               {
+                  returnResult = FALSE;
+                  goto cleanup;
+               }
+               lpSegment++;
+               lpPre++;
+            }
+            else lpPre++;
+         }
+         else
+         {
+            lpSegment++;
+            if (!IsDigit(*lpPre))
+              lpPre++;
+         }
+      }
+
+      if (plpTail)
+        *plpTail = lpSegment;
+
+      returnResult = (lpPre != lpPrefix);
+   }
+   returnResult = returnResult && (*lpPre == '\0' || *lpPre == otherDelimiter);
+
+
+  if ( fNeedExactMatch && lpSegment)
+  {
+     returnResult &= !(IsDigit(*lpSegment));
+  }
+
+
+cleanup:
+   return returnResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//   Returns CITY_MANDATORY if rule contains an F (ie city code mandatory),
+//   Returns CITY_OPTIONAL if rule contains an I (ie city code optional)
+//   Returns CITY_NONE if rule contains neither  
+//   NOTE: Rules terminate in " character, not '\0'
+//
+int IsCityRule(LPWSTR lpRule)
+{
+   WCHAR c;
+   
+   while ((c = *lpRule++) != '\0')
+   {
+      if (c == 'F') return CITY_MANDATORY;
+      if (c == 'I') return CITY_OPTIONAL;
+   }
+   return CITY_NONE;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+//   Implements 7.5.7 in TAPIADDR spec.  Returns the relevant bits in a DWORD,
+//   suitable for ORing with dwTranslateResults.
+//   NOTE: due to misspecification of input numbers, any of the subcomponents
+//   may be NULL.
+DWORD PASCAL CategorizeNumber(   
+                        DWORD dwPCCode,
+                        LPWSTR lpCity,
+                        LPWSTR lpSubscriber,
+                        PLOCATION pCurrentLocation,
+                        LPLINECOUNTRYLIST lpCountryList
+                      )
+{ 
+   DWORD dwTranslateResults = 0;
+   LPWSTR lpLDRule = NULL;
+   LPWSTR lpNewDestCityCode = NULL;        // Win95C 10057
+   LPWSTR lpNewCurCityCode = NULL;         // Win95C 10057
+
+   LPLINECOUNTRYENTRY lplce;
+
+
+   lplce = (LPLINECOUNTRYENTRY)
+                ((LPBYTE)lpCountryList + lpCountryList->dwCountryListOffset);
+
+    
+//   If destination country and current country don't match, this is an
+//   international call.  If they do and current country uses city codes
+//   and city codes don't match, then this is long distance.  Otherwise
+//   it is local and for North America, we check toll list and set proper
+//   bits.   
+   if (lplce->dwCountryCode != dwPCCode)
+   {
+      dwTranslateResults = LINETRANSLATERESULT_INTERNATIONAL;
+   }
+   else
+   {
+
+      lpLDRule = (LPWSTR)( (LPBYTE)lpCountryList +
+                          lplce->dwLongDistanceRuleOffset);
+
+
+      //
+      // WIN95C 10057 - If the user's typed in the LD prefix as if it were
+      // part of the city code, give 'em a break and let it slide.
+      //       (different comment on the same thing)
+      // WIN95C 10057 - If the current city code has the long distance
+      // prefix attached to it (because the user is clueless), ensure we
+      // do a good compare
+      //
+      // At this point, we know this is not an international call, so we can
+      // use the lpLDRule to compare
+      //
+      if (
+            (lpCity != NULL)
+          &&
+            lpLDRule
+          &&
+            (*lpLDRule == *lpCity)
+         )
+      {
+         lpNewDestCityCode = lpCity + 1;
+      }
+      else
+      {
+         lpNewDestCityCode = lpCity;
+      }
+
+
+      //
+      // WIN95C 10057 - If the current city code has the long distance
+      // prefix attached to it (because the user is clueless), ensure we
+      // do a good compare
+      //
+      // At this point, we know this is not an international call, so we can
+      // use the lpLDRule to compare
+      //
+      // This is the same logic as above but the above code handles the
+      // dest address, and this is for the current location
+      //
+      if (
+            ( *lpLDRule == *pCurrentLocation->AreaCodeW )
+         )
+      {
+         lpNewCurCityCode = (LPWSTR)(pCurrentLocation->AreaCodeW)+1;
+      }
+      else
+      {
+         lpNewCurCityCode = (LPWSTR)(pCurrentLocation->AreaCodeW);
+      }
+
+
+
+
+      if (
+            (
+               (IsCityRule(lpLDRule) == CITY_OPTIONAL)
+             ||
+               (
+                  (IsCityRule(lpLDRule) == CITY_MANDATORY)
+                &&
+                  (lpNewDestCityCode != NULL)
+               )
+            )
+          && 
+         !PrefixMatch(lpNewDestCityCode, lpNewCurCityCode, NULL, 0, TRUE)
+        )
+      {
+         dwTranslateResults = LINETRANSLATERESULT_LONGDISTANCE;
+      }
+      else
+      {
+         dwTranslateResults = LINETRANSLATERESULT_LOCAL;
+
+#define CC_NORTHAMERICA (1)
+
+         if ( pCurrentLocation->dwCountry == CC_NORTHAMERICA && lpSubscriber)
+         {
+            dwTranslateResults |= 
+               InPrefixList(lpSubscriber, pCurrentLocation ) != NULL ?
+                  LINETRANSLATERESULT_INTOLLLIST : 
+                  LINETRANSLATERESULT_NOTINTOLLLIST;
+         }
+      }
+   }
+
+   return dwTranslateResults;      
+      
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//   Computes the Dialable and Displayable strings, as per 7.5.8.
+//   NOTE: dwCard has been vetted by TranslateAddress() so that it should be
+//   fine (unless someone wrote on ini file behind our backs)
+//   NOTE: due to misspecification of input numbers, any of the subcomponents
+//   may be NULL.
+//
+LONG PASCAL BuildDialAndDisplay( PCARD pCard,
+                                 DWORD dwTranslateResults,
+                                 DWORD dwTranslateOptions,
+                                 LPWSTR lpDestCountry,
+                                 LPWSTR lpDestCity,
+                                 LPWSTR lpDestSubscriber,
+                                 LPWSTR lpDialable,
+                                 LPWSTR lpDisplayable,
+                                 UINT strSize,
+                                 PLOCATION pThisLocation,
+                                 LPLINECOUNTRYLIST lpCountryList
+                                )
+{
+   BOOL fNeedBlank = FALSE;
+   LPWSTR lpRuleToUse = NULL;
+   LPWSTR lpDialEnd = lpDialable+strSize-1;
+   LPWSTR lpDisplayEnd = lpDisplayable+strSize-1;
+   LPWSTR lpNextSegment = NULL;
+   BOOL haveNonBlank = FALSE;
+//   BOOL disableF = FALSE;  bjm 2/10/96 - not needed anymore
+   LONG errorReturn = 0;
+   DWORD dwDestPCCode;
+   LPWSTR pAccessPrefix = gszNullStringW;
+
+   LPLINECOUNTRYENTRY lplce;
+
+#if DBG
+   LPWSTR lpDialableSAVE = lpDialable;
+   LPWSTR lpDisplayableSAVE = lpDisplayable;
+#endif
+
+   InternalDebugOut((10, "Entering BuildDialAndDisplay"));
+   InternalDebugOut((11, "   lpDestCountry=0x%08lx", lpDestCountry));
+   InternalDebugOut((11, "   lpDestCity=0x%08lx", lpDestCity ? lpDestCity : L"NULL"));
+   InternalDebugOut((11, "   lpDestSubscriber=0x%08lx", lpDestSubscriber));
+   InternalDebugOut((11, "   lpDialable=0x%08lx", lpDialable));
+   InternalDebugOut((11, "   lpDisplayable=0x%08lx", lpDisplayable));
+   InternalDebugOut((11, "   strSize=%ld", strSize));
+
+
+   dwDestPCCode = _wtoi(lpDestCountry);
+
+
+   lplce = (LPLINECOUNTRYENTRY)
+                ((LPBYTE)lpCountryList + lpCountryList->dwCountryListOffset);
+
+
+   if (LINETRANSLATERESULT_INTERNATIONAL & dwTranslateResults)
+   {
+      //
+      // If we're using a card, use that rule, otherwise use the country
+      // dialing rule.
+      //
+      lpRuleToUse = (pCard && pCard->dwID) ?
+                        pCard->InternationalRuleW :
+                        (LPWSTR)( (LPBYTE)lpCountryList + 
+                                     lplce->dwInternationalRuleOffset
+                               );
+
+       pAccessPrefix = &(pThisLocation->LongDistanceAccessW[0]);
+
+InternalDebugOut((10, "Going with the international rule  [%ls]", lpRuleToUse));
+   }
+   else
+   {
+
+      if (
+            (  (LINETRANSLATERESULT_LONGDISTANCE & dwTranslateResults)
+             ||
+               (LINETRANSLATEOPTION_FORCELD      & dwTranslateOptions)
+            )
+          &&
+            (!(LINETRANSLATEOPTION_FORCELOCAL   & dwTranslateOptions)  )
+         )
+      {
+         //
+         // If we're using a card, use that rule, otherwise use the country
+         // dialing rule.
+         //
+         lpRuleToUse = (pCard && pCard->dwID) ?
+                           pCard->LDRuleW :
+                           (LPWSTR)( (LPBYTE)lpCountryList +
+                                            lplce->dwLongDistanceRuleOffset
+                                  );
+       pAccessPrefix = &(pThisLocation->LongDistanceAccessW[0]);
+
+InternalDebugOut((10, "Going with the LD rule"));
+      }
+      else
+      {
+
+         pAccessPrefix = &(pThisLocation->OutsideAccessW[0]);
+
+         if ( (LINETRANSLATERESULT_INTOLLLIST & dwTranslateResults) &&
+              (!(LINETRANSLATEOPTION_FORCELOCAL   & dwTranslateOptions)  )    )
+         {
+//BUGBUG: what's this for?  - bjm 2/10/96 not needed anymore
+//*** *** ***            disableF = locArgs[LOC_INI_INSERTAC].dwArg == 0;
+
+            // Well, it's the same area code, but it's a toll call.
+
+            //
+            // If we're using a card, use that rule, otherwise use the
+            // country dialing rule.
+            //
+            lpRuleToUse = (pCard && pCard->dwID) ?
+                              pCard->LocalRuleW :
+                              (LPWSTR)( (LPBYTE)lpCountryList +
+                                               lplce->dwLongDistanceRuleOffset
+                                     );
+InternalDebugOut((10, "Going with the .LD rule"));
+         }
+         else
+         {
+            // The last choice of the last choice - local call.
+
+
+            //
+            // If we're using a card, use that rule, otherwise use the
+            // country dialing rule.
+            //
+            lpRuleToUse = (pCard && pCard->dwID) ?
+                              pCard->LocalRuleW :
+                              (LPWSTR)( (LPBYTE)lpCountryList +
+                                               lplce->dwSameAreaRuleOffset
+                                     );
+InternalDebugOut((1, "Going with the local rule"));
+         }
+      }
+   }
+
+ 
+   //
+	// Do we have a "Disable call waiting" prefix that the caller wants
+   // to use?
+   //
+   if (
+         (dwTranslateOptions & LINETRANSLATEOPTION_CANCELCALLWAITING)
+       &&
+         (pThisLocation->dwFlags & LOCATION_HASCALLWAITING)
+       &&
+         ( lstrlenW(pThisLocation->DisableCallWaitingW) )
+      )
+   {
+      lpDisplayable = CopyStringToChar(
+                                        pThisLocation->DisableCallWaitingW,
+                                        '\0',
+                                        lpDisplayable,
+                                        lpDisplayEnd
+                                      );
+
+      lpDialable = CopyStringToChar(
+                                     pThisLocation->DisableCallWaitingW,
+                                     '\0',
+                                     lpDialable,
+                                     lpDialEnd
+                                   );
+
+      lpDialable = CopyChar(' ',lpDialable,lpDialEnd);
+      lpDisplayable = CopyChar(' ',lpDisplayable,lpDisplayEnd);
+   }
+
+   //
+   // If we have to do something special for outside access, do it.
+   //
+   if ( 0 != lstrlenW( pAccessPrefix ) )
+   {
+      lpDisplayable = CopyStringToChar(pAccessPrefix,'\0',lpDisplayable,lpDisplayEnd);
+      lpDialable = CopyStringToChar(pAccessPrefix,'\0',lpDialable,lpDialEnd);
+      haveNonBlank = fNeedBlank = TRUE;
+   }
+
+
+   //
+   // TAPISDK 1361 - if we're calling from Mexico(52) to US(1), 
+   // hack the string.
+//BUGBUG: Make this special case (Mexico(52) to US(1)) extensible)
+   //
+   if ( 
+         (pThisLocation->dwCountry == 52)
+       &&
+         (LINETRANSLATERESULT_INTERNATIONAL & dwTranslateResults)
+       &&
+         (dwDestPCCode == 1)
+      )
+   {
+      lpRuleToUse = L"95FG";
+   }
+
+
+   InternalDebugOut((1, "RuleToUse:[%ls]", lpRuleToUse));
+
+   while ( lpDisplayable && lpDialable && (*lpRuleToUse != '\0') )
+   {
+
+      InternalDebugOut((10, "  Displayable so far: %ls", lpDisplayableSAVE));
+      InternalDebugOut((10, "  Dialable so far   : %ls", lpDialableSAVE));
+
+      switch (*lpRuleToUse)
+      {
+      case 'E':
+         if (lpDestCountry && (*lpDestCountry != '\0'))
+            {
+            if (fNeedBlank)
+               {
+               lpDialable = CopyChar(' ',lpDialable,lpDialEnd);
+               lpDisplayable = CopyChar(' ',lpDisplayable,lpDisplayEnd);
+               }
+
+            lpDialable = CopyDigits(lpDestCountry,lpDialable,lpDialEnd, FALSE);
+
+            lpDisplayable = CopyDigits(lpDestCountry,lpDisplayable,lpDisplayEnd, FALSE);
+
+            haveNonBlank = fNeedBlank = TRUE;
+            }
+          break;
+
+
+
+      case 'F':
+      case 'I':
+         if (lpDestCity != NULL && (*lpDestCity != '\0') ) 
+                             // bjm 2/10/96 - not needed anymore && !disableF)
+         {
+            LPWSTR lpNewDestCity;   //Win95C 10057
+
+
+            if (fNeedBlank)
+            {
+               lpDialable = CopyChar (' ',lpDialable,lpDialEnd);
+               lpDisplayable = CopyChar(' ',lpDisplayable,lpDisplayEnd);
+            }
+
+
+            //
+            // Win95C 10057 - if the first digit of the city code is the
+            // same as the LD prefix, then strip it off the city code.
+            //
+            // We have to check the long distance rule of the destination
+            // country.  Eg: If a user from a country which adds its ld
+            // prefix in the city code, and that user goes on the road, all
+            // the phone #s in his address book have the ld prefix on the
+            // city code.
+            //
+            {
+               LPWSTR lpDestCountryLDRule = NULL;
+               LPLINECOUNTRYLIST lpDestCountryList;
+               LPLINECOUNTRYENTRY lplceDest;
+
+               if ( 0 != ReadCountries( &lpDestCountryList,
+                                        dwDestPCCode,
+                                        0
+                                       )
+                  )
+               {
+                  InternalDebugOut((1, "Error reading country [%ld]", dwDestPCCode));
+                  return LINEERR_INVALCOUNTRYCODE;
+               }
+
+               lplceDest = (LPLINECOUNTRYENTRY) ((LPBYTE)lpDestCountryList
+                                    + lpDestCountryList->dwCountryListOffset);
+
+               lpDestCountryLDRule = (LPWSTR)((LPBYTE)lpDestCountryList +
+                                     lplceDest->dwLongDistanceRuleOffset);
+
+               //
+               // Does the first character of the city code match the
+               // longdistance dialing digit?
+               //
+               if ( *lpDestCity == *lpDestCountryLDRule)
+               {
+                  //
+                  // Yes.  Ok, so don't use that prefix digit.
+                  //
+                  lpNewDestCity = lpDestCity + 1;
+               }
+               else
+               {
+                  //
+                  // Nope.  Use the city code as-is.
+                  //
+                  lpNewDestCity = lpDestCity;
+               }
+
+               ClientFree( lpDestCountryList );
+            }
+
+
+	        lpDialable = CopyDigits(lpNewDestCity,lpDialable,lpDialEnd, FALSE);
+
+	        lpDisplayable = CopyDigits(lpNewDestCity,lpDisplayable,lpDisplayEnd, FALSE);
+            
+            haveNonBlank = fNeedBlank = TRUE;
+         }
+//
+// These lines are commented out because whether a country REALLY uses
+// city codes is unknown (regardless of what the "rule" says...)
+//         
+//         else
+//         {
+//            //
+//            // If we're required to have an area code, but we didn't get one,
+//            // we signal an error.
+//            //
+//            if ( 'F' == *lpRuleToUse )
+//            {
+//               errorReturn = LINEERR_INVALADDRESS;
+//               goto cleanup;
+//            }
+//         }
+         break;
+
+
+
+      case 'G':
+         if (lpDestSubscriber != NULL && (*lpDestSubscriber != '\0'))
+         {
+            if (fNeedBlank)
+            {
+               lpDialable = CopyChar(' ',lpDialable,lpDialEnd);
+               lpDisplayable = CopyChar(' ',lpDisplayable,lpDisplayEnd);
+            }
+
+            lpDialable = CopyDigits(lpDestSubscriber,lpDialable,lpDialEnd, TRUE);
+
+            lpDisplayable = CopyStringToChar(lpDestSubscriber,'\0',lpDisplayable,lpDisplayEnd);
+            haveNonBlank = fNeedBlank = TRUE;
+         }
+         break;
+
+
+
+      case 'H':
+         if (pCard != NULL)
+         {
+            if (fNeedBlank)
+            {
+               lpDialable = CopyChar(' ',lpDialable,lpDialEnd);
+               lpDisplayable = CopyChar(' ',lpDisplayable,lpDisplayEnd);
+            }
+
+// This is now being done on read and write.
+//bjm11/15            lpDialable = CopyScrambled( pCard->Pin,
+//bjm11/15                                        lpDialable,
+//bjm11/15                                        pCard->dwID
+//bjm11/15                                      );
+            lpDialable = CopyDigits(pCard->PinW, lpDialable, lpDialEnd, FALSE);
+
+            lpDisplayable = CopyChar('[',lpDisplayable,lpDisplayEnd);
+
+            lpDisplayable = CopyStringToChar( pCard->NameW,
+                                              '\0',
+                                              lpDisplayable,
+                                              lpDisplayEnd
+                                            );
+            lpDisplayable = CopyChar(']',lpDisplayable,lpDisplayEnd);
+
+            haveNonBlank = fNeedBlank = TRUE;
+         }
+         break;
+
+
+
+      default:
+         if (fNeedBlank && haveNonBlank)
+         {
+            lpDialable = CopyChar(' ',lpDialable,lpDialEnd);
+            lpDisplayable = CopyChar(' ',lpDisplayable,lpDisplayEnd);
+         }
+
+         fNeedBlank = TRUE;
+         haveNonBlank = FALSE;
+         lpDialable = CopyChar(*lpRuleToUse,lpDialable,lpDialEnd);
+
+         if (!wcschr(csDISPSUPRESS,*lpRuleToUse))
+            lpDisplayable = CopyChar(*lpRuleToUse,lpDisplayable,lpDisplayEnd);
+
+
+         break;
+
+      }
+
+      lpRuleToUse++;
+
+   }
+
+   InternalDebugOut((10, "  Now done, displayable: %ls", lpDisplayableSAVE));
+   InternalDebugOut((10, "  Now done, dialable   : %ls", lpDialableSAVE));
+
+//   If we over flowed our string buffers, return LINEERR_INVALADDRESS.
+//   NOTE: this is a questionable return result, but what's better?
+   if (lpDisplayable == NULL || lpDialable == NULL)
+   {
+      errorReturn = LINEERR_INVALADDRESS;
+   }
+   else
+   {
+      *lpDisplayable = '\0';
+      *lpDialable = '\0';
+   }
+
+
+cleanup:
+
+   return errorReturn;   
+}
+
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG PASCAL TranslateTheAddress( LPCWSTR     lpszAddressIn,
+                                 LPWSTR     *pDialableAddressPointer,
+                                 LPWSTR     *pDisplayableAddressPointer,
+                                 DWORD      dwTranslateOptions,
+                                 LPDWORD    lpdwTranslateResults,
+                                 LPDWORD    lpdwCountry,
+                                 PCARD      pCard,
+                                 PLOCATION  pLocation
+                               )
+{
+   WCHAR *pDialable;
+   WCHAR *pDisplayable;
+   WCHAR *pAddressIn;
+   WCHAR *pAddressInSAVE;
+   LONG  lResult = 0;
+
+
+   *lpdwTranslateResults = 0;
+
+
+   pDialable = ClientAlloc( 500 * sizeof(WCHAR) );
+   if (!pDialable)
+   {
+      DBGOUT((1, "Memory allocation failed"));
+      return LINEERR_NOMEM;
+   }
+
+   pDisplayable = ClientAlloc( 500 * sizeof(WCHAR) );
+   if (!pDisplayable)
+   {
+      DBGOUT((1, "Memory allocation failed2"));
+
+      ClientFree(pDialable);
+
+      return LINEERR_NOMEM;
+   }
+
+   pAddressInSAVE = pAddressIn = ClientAlloc( (lstrlenW(lpszAddressIn)+1) * sizeof(WCHAR));
+   if ( !pAddressIn )
+   {
+      DBGOUT((1, "Memory allocation failed3"));
+
+      ClientFree(pDialable);
+      ClientFree(pDisplayable);
+
+      return LINEERR_NOMEM;
+   }
+
+
+   *pDialableAddressPointer = pDialable;
+   *pDisplayableAddressPointer = pDisplayable;
+
+
+   //
+   // Copy the string to our local buffer so we can mangle it
+   //
+   lstrcpyW( pAddressIn, lpszAddressIn );
+
+
+   //
+   // Mark off the end
+   //
+   // Isolate the piece of lpAddressIn that we will operate upon in
+   // szAddressIn.  This piece stops at first !,^,CR or \0.
+   //
+   pAddressIn[wcscspn(pAddressIn,csSCANTO)] = '\0';
+
+
+   //
+   // Easy case: first put the T or P in the beginning of the
+   // dialable string
+   //
+   if ( pLocation->dwFlags & LOCATION_USETONEDIALING )
+   {
+      *pDialable = 'T';
+   }
+   else
+   {
+      *pDialable = 'P';
+   }
+
+   pDialable++;
+
+
+//---------------------------------------------------------------------------
+   //
+   // Now, do we have a canonical number to deal with, or is it junk?
+   //
+   if ( lpszAddressIn && (*lpszAddressIn == '+') )  // Check the real _first_ char
+   {
+      //
+      // Ok, it's canonical
+      //
+
+      WCHAR *pDestCountry;
+      WCHAR *pDestCity;
+      WCHAR *pDestSubscriber;
+      LPLINECOUNTRYLIST lpCountryList = NULL;
+
+
+      //
+      // Skip the plus
+      //
+      pAddressIn++;
+
+
+      lResult = BreakupCanonicalW( pAddressIn,
+                                   &pDestCountry,
+                                   &pDestCity,
+                                   &pDestSubscriber
+                                 );
+
+      if ( lResult )
+      {
+         return lResult;
+      }
+
+
+      DBGOUT((70, "Country:%ls  City:%ls  Subscriber:%ls",
+                pDestCountry    ? pDestCountry    : L"NULL",
+                pDestCity       ? pDestCity       : L"NULL",
+                pDestSubscriber ? pDestSubscriber : L"NULL"
+            ));
+
+
+      *lpdwTranslateResults |= LINETRANSLATERESULT_CANONICAL;
+
+
+
+      //
+      // Put the dest country into the dest place
+      //
+      *lpdwCountry = _wtoi(pDestCountry);
+
+
+      //
+      // Ok, now build the strings
+      //
+
+
+      if ( 0 != ReadCountries( &lpCountryList,
+                               pLocation->dwCountry,
+                               (*lpdwCountry != pLocation->dwCountry) ?
+                                   *lpdwCountry :
+                                   0
+                             )
+         )
+      {
+         InternalDebugOut((1, "Error reading country [%ld]", pLocation->dwCountry));
+         return LINEERR_INVALCOUNTRYCODE;
+      }
+
+
+      *lpdwTranslateResults |= CategorizeNumber( 
+                                    *lpdwCountry,
+                                    pDestCity,
+                                    pDestSubscriber,
+                                    pLocation,
+                                    lpCountryList
+                                    );
+                                    
+
+      lResult = BuildDialAndDisplay(  pCard,
+                            *lpdwTranslateResults,
+                            dwTranslateOptions,
+                            pDestCountry,
+                            pDestCity,
+                            pDestSubscriber,
+                            pDialable,
+                            pDisplayable,
+                            ClientSize(pDisplayable) -1, // We inc'ed pDialable for the 'T' or 'P'
+                            pLocation,
+                            lpCountryList
+                         );
+
+
+      ClientFree( lpCountryList );
+
+   }
+//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   else
+   {
+      //
+      // Nope, it's not canonical
+      //
+
+
+      //
+      // Leading spaces are strange.  Skip them.
+      //
+      while ( *pAddressIn == ' ' )
+      {
+         pAddressIn++;
+      }
+
+
+      //
+      // Make sure there's not already a T or P at the beginning.
+      //
+
+      //
+      // If the first non-space char (we've already skipped past the spaces
+      // in the code before the "if"...) is T or P, just skip over it. 
+      // (we don't
+      // care if it jibes with what the user selected for this location.)
+      //
+      if ( *pAddressIn == 'T' || *pAddressIn == 'P' )
+      {
+         pAddressIn++;
+      }
+
+
+//*      {
+//*      LPSTR pDest, pSource;
+//*
+//*//      pDest = (LPSTR)pDialable+lstrlen(pDestCountry) + 1 +lstrlen(pDestCity) + 1;
+//*      pDest = (LPSTR)pDialable;
+//*      pSource = pSubscriber;
+//*
+//*      while (*pSource)
+//*      {
+//*//         //BUGBUG *** *** ***This also filters garbage! (is that good or bad?)
+//*//         if ( IsDigit(*pSource) )
+//*//         {
+//*//            *pDest = *pSource;
+//*//         }
+//*
+//*           if ( *pSource != '-' && *pSource != ' ')
+//*           {
+//*              *pDest = *pSource;
+//*              pDest++;
+//*           }
+//*
+//*           pSource++;
+//*      }
+//*      }
+//*
+//*      pDisplayable+= lstrlen(lpszAddressIn+1);
+//*      pDialable+=lstrlen(pCountry)+lstrlen(pCity)+lstrlen(pSubscriber);
+
+
+      //
+      // Let's do our own strcpy, cause we can probably save a couple
+      // of cycles (only one pass through original string)
+      //
+      {
+      register WCHAR ch;
+
+      while ( ch = *pAddressIn )
+      {
+//*** *** ***BUGBUG performance: The compiler is turning this into two reads and two 
+//                  writes.  Change this code so the compiler does it right.
+//         *pDialable = *pDisplayable = *pAddressIn;
+         *pDialable = *pDisplayable = ch;
+
+         pDialable++;
+         pDisplayable++;
+         pAddressIn++;
+      }
+      }
+
+      //
+      // Null-terminate the strings
+      //
+      *pDialable = '\0';
+      *pDisplayable = '\0';
+
+   }
+
+
+//cleanup:
+
+
+   ClientFree(pAddressInSAVE);
+
+
+   return lResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void UpdateNumberField( HWND hWnd, LPCWSTR lpszAddressIn )
+{
+   LPWSTR    pDialableAddress;
+   LPWSTR    pDisplayableAddress;
+   DWORD     dwCountry;
+   DWORD     dwTranslateResults;
+   PCARD     pCard;
+
+#ifdef PARTIAL_UNICODE
+   LPWSTR    pTempString;
+#endif
+
+   if ( NULL == lpszAddressIn )
+   {
+      return;
+   }
+
+   if ( gpCurrentLocation->dwFlags & LOCATION_USECALLINGCARD )
+   {
+      DWORD n;
+      
+      n = GetCardIndexFromID( gpCurrentLocation->dwCallingCard,
+                              gpCardList,
+                              gpnStuff[2]
+                            );
+                            
+      if ( (LONG)(-1) == n )
+      {
+          n = 0;
+      }
+    
+      pCard = &(gpCardList[n]);
+   }
+   else
+   {
+      pCard = NULL;
+   }
+
+   //
+   // If the "Dial as long distance" button is checked, add one more
+   // option
+   //
+
+   TranslateTheAddress( lpszAddressIn,
+                        &pDialableAddress,
+                        &pDisplayableAddress,
+                        LINETRANSLATEOPTION_CANCELCALLWAITING
+                          | (IsDlgButtonChecked(hWnd, IDCK_DL_IN_LOCAL) ?
+                              LINETRANSLATEOPTION_FORCELD :
+                              0),
+                        &dwTranslateResults,
+                        &dwCountry,
+                        pCard,
+                        gpCurrentLocation
+                      );
+
+#ifdef PARTIAL_UNICODE
+    pTempString = ClientAlloc((lstrlenW(pDisplayableAddress)+2)* sizeof(WCHAR));
+
+
+    WideCharToMultiByte(
+                         GetACP(),
+                         0,
+                         pDisplayableAddress,
+                         -1,
+                         pTempString,
+                         lstrlenW(pDisplayableAddress)+1,
+                         NULL,
+                         NULL
+                       );
+
+    SetDlgItemTextW( hWnd, IDCS_DL_DIAL_NUMBER, pTempString);
+
+    ClientFree( pTempString );
+#else
+    SetDlgItemTextW( hWnd, IDCS_DL_DIAL_NUMBER, pDisplayableAddress );
+#endif
+
+//Huh? Why was this here?    CheckDlgButton( hWnd, IDCK_DL_IN_LOCAL, FALSE );
+//
+//    //
+//    // If this country is "1" and this _should_ be a local call and
+//    // the prefix is in the list, then we'll check the "dial as ld" box
+//    //
+//    if ( 
+//          (gpCurrentLocation->dwCountry == 1)
+//        &&
+//          (dwTranslateResults & LINETRANSLATERESULT_LOCAL)
+//       )
+//    {
+//       LPSTR pCountry;
+//       LPSTR pCity;
+//       LPSTR pSubscriber;
+//       LPSTR pAddressIn;
+//
+//       pAddressIn = ClientAlloc( lstrlen(lpszAddressIn) + 1);
+//       lstrcpy( pAddressIn, lpszAddressIn );
+//
+//       BreakupCanonical( pAddressIn,
+//                          &pCountry,
+//                          &pCity,
+//                          &pSubscriber
+//                        );
+//
+//       if ( InPrefixList(pSubscriber, gpCurrentLocation) )
+//       {
+//          CheckDlgButton( hWnd, IDCK_DL_IN_LOCAL, TRUE );
+//       }
+//
+//       ClientFree( pAddressIn );
+//    }
+
+    if ( pDisplayableAddress )
+       ClientFree( pDisplayableAddress );
+    if ( pDialableAddress )
+       ClientFree( pDialableAddress );
+
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+//Get the current location
+//xlate the number based on that
+LONG
+WINAPI
+lineTranslateAddressW(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCWSTR                 lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+    UINT n;
+    LONG lResult;
+    LPWSTR   lpszDialable = NULL;
+    LPWSTR   lpszDisplayable = NULL;
+    DWORD   dwDialableSize = 0;
+    DWORD   dwDisplayableSize = 0;
+    DWORD   dwTranslateResults = 0;
+    DWORD   dwCountry = 0;
+
+    PUINT      pnStuff = NULL;
+    PLOCATION  MyLocationList = NULL;
+    PLOCATION  pThisLocation;
+
+    PUINT      pnCardStuff = NULL;
+    PCARD      MyCardList = NULL;
+    PCARD      pThisCard = NULL;
+
+
+#if DBG       
+    DBGOUT((2,  "Entering lineTranslateAddress"));
+    DBGOUT((20, "  lpszAddressIn: 0x%08lx", lpszAddressIn));
+    if (!IsBadStringPtrW(lpszAddressIn, 256))
+       DBGOUT((21, "  *lpszAddressIn: [%ls]", lpszAddressIn));
+    DBGOUT((20, "  lpTranslateOutput: 0x%08lx", lpTranslateOutput));
+    DBGOUT((21, "  lpTranslateOutput->dwTotalSize: 0x%08lx", lpTranslateOutput->dwTotalSize));
+#endif
+
+
+    lResult = IsThisAPIVersionInvalid( dwAPIVersion );
+    if ( lResult )
+    {
+       DBGOUT((1, "Bad dwAPIVersion - 0x%08lx", dwAPIVersion));
+       return lResult;
+    }
+
+
+    if ( IsBadStringPtrW(lpszAddressIn,256) )
+    {
+       DBGOUT((1,  "Invalid pointer - lpszAddressInW"));
+       lResult = LINEERR_INVALPOINTER;
+       goto cleanup;
+    }
+
+
+    if ( dwTranslateOptions & 
+              ~(LINETRANSLATEOPTION_CARDOVERRIDE |
+                LINETRANSLATEOPTION_CANCELCALLWAITING |
+                LINETRANSLATEOPTION_FORCELOCAL |
+                LINETRANSLATEOPTION_FORCELD) )
+    {
+       DBGOUT((1, "  Invalid dwTranslateOptions (unknown flag set)"));
+       lResult = LINEERR_INVALPARAM;
+       goto cleanup;
+    } 
+
+
+    if (  ( dwTranslateOptions & ( LINETRANSLATEOPTION_FORCELOCAL |
+                              LINETRANSLATEOPTION_FORCELD) )
+       ==
+         ( LINETRANSLATEOPTION_FORCELOCAL |
+           LINETRANSLATEOPTION_FORCELD)
+      )
+    {
+       DBGOUT((1, "  Invalid dwTranslateOptions (both FORCELOCAL & FORCELD set!)"));
+       lResult = LINEERR_INVALPARAM;
+       goto cleanup;
+    } 
+
+
+    //
+    // Is the caller passing in a bogus version #?
+    //
+    if (
+          (dwAPIVersion != TAPI_VERSION2_0)
+        &&
+          (dwAPIVersion != TAPI_VERSION1_4)
+        &&
+          (dwAPIVersion != TAPI_VERSION1_0)
+       )
+    {
+       DBGOUT((1, "  Invalid dwAPIVersion"));
+       lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+       goto cleanup;
+    }
+
+
+//*** *** ***BUGBUG Put in a check for length of lpszAddressIn.  Restrict
+// it to < 256 bytes (TCHARs?)
+
+
+//   if (IsValidLineApp (hLineApp) ) //), pParams->ptClient))
+    {
+       DWORD   dwNeededSize;
+
+
+       //
+       // Is the structure at least a minimum size?
+       //
+       if (  IsBadWritePtr(lpTranslateOutput, sizeof(LINETRANSLATEOUTPUT))
+           ||
+             (lpTranslateOutput->dwTotalSize < sizeof(LINETRANSLATEOUTPUT))
+          )
+       {
+          InternalDebugOut((1, "  Leaving lineTranslateAddress  STRUCTURETOOSMALL"));
+          return (LINEERR_STRUCTURETOOSMALL);
+       }
+
+
+       lResult = ReadLocations( &MyLocationList,
+                                &pnStuff,
+                                hLineApp,
+                                dwDeviceID,
+                                dwAPIVersion,
+                                CHECKPARMS_DWHLINEAPP |
+                                    CHECKPARMS_DWDEVICEID |
+                                    CHECKPARMS_DWAPIVERSION
+                              );
+       if ( 0 != lResult )
+       {
+          InternalDebugOut((1, "  Leaving lineTranslateAddress  result=0x%08lx", lResult));
+          return lResult;
+       }
+
+
+//   pnStuff[0] = nCurrentLocationID;
+//   pnStuff[1] = pLocationList;
+//   pnStuff[2] = nNumLocations;
+
+InternalDebugOut((0, "  Calling getlocationindex..."));
+InternalDebugOut((0, "  with lookingfor=0x%08lx  list@0x%08lx num=0x%08lx",
+                         pnStuff[0], MyLocationList, pnStuff[2]));
+
+       pThisLocation = &MyLocationList[GetLocationIndexFromID(pnStuff[0],
+                                                              MyLocationList,
+                                                              pnStuff[2])
+                                      ];
+
+InternalDebugOut((0, "  back from getlocationindex..."));
+
+
+       ReadCardsEasy( &MyCardList, &pnCardStuff);
+
+
+
+       //
+       // If there is no override, and this location does not
+       // use a calling card, use no card.
+       //
+       if ( 
+             (  
+                (LINETRANSLATEOPTION_CARDOVERRIDE & dwTranslateOptions)
+              &&
+                (dwCard != 0)
+             )
+           ||
+             (pThisLocation->dwFlags & LOCATION_USECALLINGCARD)
+          )
+       {
+          //
+          // If caller wants to override the default calling card for
+          // this location, do it.  Otherwise, use the default card for
+          // this location.
+          //
+          n = GetCardIndexFromID( (dwTranslateOptions &
+                                   LINETRANSLATEOPTION_CARDOVERRIDE) ?
+                                      dwCard :
+                                      pThisLocation->dwCallingCard,
+                                  MyCardList,
+                                  pnCardStuff[2]
+                                );
+
+
+          //
+          // n is the zero-offset index into the list
+          //
+          if ( n >= pnCardStuff[2] )
+          {
+             lResult = LINEERR_INVALCARD;
+             goto cleanup;
+          }
+
+
+          pThisCard = &MyCardList[ n ];
+
+       }
+       //
+       //else
+       //   pThisCard is already NULL
+       //
+
+
+       lResult = TranslateTheAddress( lpszAddressIn,
+                                      &lpszDialable,
+                                      &lpszDisplayable,
+                                      dwTranslateOptions,
+                                      &dwTranslateResults,
+                                      &dwCountry,
+                                      pThisCard,
+                                      pThisLocation
+                                    );
+       if (lResult)
+       {
+          goto cleanup;
+       }
+
+
+       dwDialableSize = sizeof(WCHAR) * (lstrlenW(lpszDialable) + 1);
+       dwDisplayableSize = sizeof(WCHAR) * (lstrlenW(lpszDisplayable) + 1);
+
+       dwNeededSize = dwDialableSize +
+                      dwDisplayableSize +
+                      3 + // For potential alignment problem
+                      sizeof(LINETRANSLATEOUTPUT);
+
+
+       lpTranslateOutput->dwNeededSize = dwNeededSize;
+
+
+       //
+       // We checked above if the passed-in buffer is at least as
+       // large as the fixed-len size.  If we got here, it is.
+       //
+
+       lpTranslateOutput->dwDialableStringSize      = dwDialableSize;
+
+       lpTranslateOutput->dwDialableStringOffset    =
+                             sizeof(LINETRANSLATEOUTPUT);
+
+       lpTranslateOutput->dwDisplayableStringSize   = dwDisplayableSize;
+
+       lpTranslateOutput->dwDisplayableStringOffset =
+                    sizeof(LINETRANSLATEOUTPUT) + dwDialableSize;
+//       lpTranslateOutput->dwDisplayableStringOffset =
+//                  (sizeof(LINETRANSLATEOUTPUT) + dwDialableSize
+//                          + 3) & 0xfffffffc;
+
+       lpTranslateOutput->dwCurrentCountry          =
+                             pThisLocation->dwCountry;
+
+       lpTranslateOutput->dwDestCountry             = dwCountry;
+
+       lpTranslateOutput->dwTranslateResults        = dwTranslateResults;
+
+
+       //
+       // Only copy the strings if there's enough room
+       //
+       if (lpTranslateOutput->dwTotalSize < dwNeededSize)
+       {
+           DBGOUT((1, "lpTranslateOutput->dwTotalSize(%ld) < neededsize(%ld)",
+                            lpTranslateOutput->dwTotalSize, dwNeededSize));
+           lpTranslateOutput->dwUsedSize = sizeof(LINETRANSLATEOUTPUT);
+       }
+       else
+       {
+            lpTranslateOutput->dwUsedSize = dwNeededSize;
+
+            lstrcpyW ((WCHAR *)(lpTranslateOutput + 1), lpszDialable);
+
+            //
+            // Be ultra paranoid and make sure the string is DWORD aligned
+            //
+            lstrcpyW ((LPWSTR)((DWORD)( (LPBYTE)(lpTranslateOutput + 1) +
+                              dwDialableSize )),
+//                              + 3 )     & 0xfffffffc)
+                     lpszDisplayable);
+       }
+
+    }
+
+
+cleanup:
+
+
+    if ( MyCardList )
+       ClientFree( MyCardList );
+    if ( pnCardStuff )
+       ClientFree( pnCardStuff );
+    if ( MyLocationList )
+       ClientFree( MyLocationList );
+    if ( pnStuff )
+       ClientFree( pnStuff );
+    if ( lpszDisplayable )
+       ClientFree( lpszDisplayable );
+    if ( lpszDialable )
+       ClientFree( lpszDialable );
+
+return (lResult);
+}
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineTranslateAddressA(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+   WCHAR szTempStringW[512];
+   LONG  lResult;
+
+
+   if ( IsBadStringPtr(lpszAddressIn, 512) )
+   {
+      DBGOUT((1, "Invalid pszAddressIn pointer passed into lineTranslateAddress"));
+      return LINEERR_INVALPOINTER;
+   }
+
+   MultiByteToWideChar(
+                         GetACP(),
+                         MB_PRECOMPOSED,
+                         lpszAddressIn,
+                         -1,
+                         szTempStringW,
+                         512
+                       );
+
+   lResult = lineTranslateAddressW(
+                         hLineApp,
+                         dwDeviceID,
+                         dwAPIVersion,
+                         szTempStringW,
+                         dwCard,
+                         dwTranslateOptions,
+                         lpTranslateOutput
+                       );
+
+   if ( 0 == lResult )
+   {
+      WideStringToNotSoWideString( (LPBYTE)lpTranslateOutput, 
+                       &lpTranslateOutput->dwDialableStringSize );
+      WideStringToNotSoWideString( (LPBYTE)lpTranslateOutput, 
+                       &lpTranslateOutput->dwDisplayableStringSize );
+   }
+
+   return lResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineTranslateAddress(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+    return lineTranslateAddressA(
+                    hLineApp,
+                    dwDeviceID,
+                    dwAPIVersion,
+                    lpszAddressIn,
+                    dwCard,
+                    dwTranslateOptions,
+                    lpTranslateOutput
+    );
+}    
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineSetCurrentLocation(
+    HLINEAPP    hLineApp,
+    DWORD       dwLocationID
+    )
+{
+
+    UINT n;
+    PUINT pnStuff;
+    PLOCATION MyLocationList;
+    LONG lResult = 0;
+
+
+    InternalDebugOut((1, "Entering lineSetCurrentLocation"));
+
+
+    lResult = ReadLocations( &MyLocationList,
+                             &pnStuff,
+                             hLineApp,
+                             0,
+                             0,
+                             CHECKPARMS_DWHLINEAPP
+                           );
+    if ( 0 != lResult )
+    {
+       InternalDebugOut((1, "Exiting lineSetCurrentLocation - result=0x%08lx",
+                            lResult));
+       return lResult;
+    }
+
+//   pdwStuff[0] = nCurrentLocationID;
+//   pdwStuff[1] = pLocationList;
+//   pdwStuff[2] = nNumLocations;
+
+
+    n = GetLocationIndexFromID( dwLocationID, MyLocationList, pnStuff[2]);
+
+    //
+    // Did we find it?
+    //
+    if ( -1 == n )
+    {
+       //
+       // Nope.  The caller's on drugs.
+       //
+
+       DBGOUT((1, "lineSetCurrentLocation: Location ID [%d] not found!", dwLocationID));
+
+       lResult = LINEERR_INVALLOCATION;
+
+       goto CLEANUP;
+    }
+
+
+    //
+    // Update gCurrentLocation and gnCurrentLocationID
+    //
+//actually, no, don't do this
+//    SetCurrentLocation( dwLocationID );
+
+
+    //
+    // Save for all eternity
+    //
+
+    //
+    // First, let's make sure we don't shoot ourselves in the foot.
+    //
+    EnterCriticalSection( &gUICriticalSection );
+
+
+//    WriteLocations( MyLocationList, pnStuff[2],
+//                         CHANGEDFLAGS_CURLOCATIONCHANGED, gpCurrentLocation );
+
+//WRONG!    WriteCurrentLocationValue( NULL, pnStuff[0] );
+    WriteCurrentLocationValue( NULL, dwLocationID );
+
+
+    LeaveCriticalSection( &gUICriticalSection );
+
+
+CLEANUP:
+
+    ClientFree( MyLocationList );
+    ClientFree( pnStuff );
+
+    InternalDebugOut((1, "Leaving lineSetCurrentLocation"));
+    return lResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineSetTollListW(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    LPCWSTR     lpszAddressInW,
+    DWORD       dwTollListOption
+    )
+{
+    LONG  lResult = 0;
+    PLOCATION pLocationList;
+    PUINT pnStuff;
+    UINT  nThisLocation;
+    LPWSTR pTollListW;
+    LPWSTR pEntryInListW;
+
+    LPWSTR pCountry;
+    LPWSTR pCity;
+    LPWSTR pSubscriber;
+    LPWSTR pAddressIn;
+    DWORD dwChangeFlags = 0;
+
+
+    InternalDebugOut((1, "Entering lineSetTollListW"));
+
+
+  //*** *** ***BUGBUG More cases!  
+  //   We declare success (NOOP) if:
+  //   1.   number isn't local call
+  //   2.   number is in toll list already and this is add
+  //   3.   number isn't in toll list and this is remove
+  //
+
+
+    //
+    // Is the caller an idiot?
+    //
+    if ((dwTollListOption != LINETOLLLISTOPTION_ADD) &&
+        (dwTollListOption != LINETOLLLISTOPTION_REMOVE))
+    {
+        DBGOUT((1, "Bad dwTollListOption in lineSetTollListW"));
+        return LINEERR_INVALPARAM;
+    }
+
+
+    if ( IsBadStringPtrW(lpszAddressInW, 256) )
+    {
+       DBGOUT((1, "Bad lpszAddressIn (0x%08lx)in lineSetTollListW", lpszAddressInW));
+       return LINEERR_INVALPOINTER;
+    }
+
+    pAddressIn = ClientAlloc( (lstrlenW(lpszAddressInW) + 1) * sizeof(WCHAR));
+    if ( !pAddressIn )
+    {
+       DBGOUT((1, "Memory allocation failed3"));
+       return LINEERR_NOMEM;
+    }
+
+
+   //
+   // Now, do we have a canonical number to deal with, or is it junk?
+   //
+   if ( *lpszAddressInW != (WCHAR)'+' )  // Check the first char
+   {
+      //
+      // Nope, not canonical
+      //
+      lResult = LINEERR_INVALADDRESS;
+      goto cleanup;
+   }
+
+
+    //
+    // Copy the string to our local buffer so we can mangle it
+    //
+    lstrcpyW( pAddressIn, lpszAddressInW + 1 );
+
+
+    //
+    // Pick out the juicy bits
+    //
+    if ( lResult = BreakupCanonicalW( pAddressIn,
+                        &pCountry,
+                        &pCity,
+                        &pSubscriber
+                      )
+       )
+    {
+       goto cleanup;
+    }
+
+
+    //*** *** ***BUGBUG Really(!) need to check return code!
+
+    DBGOUT((71, "Country:%ls  City:%ls  Subscriber:%ls",
+             pCountry,   pCity,   pSubscriber));
+
+
+    //
+    // Do another check on the phone number to make _really_ sure it's
+    // canonical
+    //
+//BUGBUG: assumption - that a toll prefix is 3 tchars
+    if ( ! ( IsWDigit(pSubscriber[0]) &&
+             IsWDigit(pSubscriber[1]) &&
+             IsWDigit(pSubscriber[2])
+//             &&
+//             pSubscriber[3] == '-'
+           )
+       )
+    {
+       //
+       // AAHA!  Caught ya, ya bastard.
+       //
+       DBGOUT((1, "lineSetTollListW: The prefix is not valid"));
+       lResult = LINEERR_INVALADDRESS;
+       goto cleanup;
+    }
+
+    
+    //
+    // Build our own location stuff.
+    //
+    lResult = ReadLocations( &pLocationList,
+                             &pnStuff,
+                             hLineApp,
+                             dwDeviceID,
+                             0,
+                             CHECKPARMS_DWHLINEAPP |
+                             CHECKPARMS_DWDEVICEID
+                           );
+    if ( 0 != lResult )
+    {
+       goto cleanup;
+    }
+
+
+    nThisLocation = GetLocationIndexFromID( pnStuff[0],
+                                            pLocationList,
+                                            pnStuff[2]
+                                          );
+
+
+    //
+    // So, is this number in the same country and area code?
+    //
+
+    {
+    PWSTR pszTemp;
+
+    pszTemp = ClientAlloc( 10 * sizeof(WCHAR) );
+
+    wsprintfW( pszTemp, L"%ld", pLocationList[nThisLocation].dwCountry );
+
+    if ( lstrcmpiW( pCountry, pszTemp ) )
+    {
+       DBGOUT((4, "This country ID [%ls] is different from the current country [%ld]",
+                        pCountry, pLocationList[nThisLocation].dwCountry));
+
+       ClientFree( pszTemp );
+
+       return 0;
+    }
+
+       ClientFree( pszTemp );
+    }
+
+
+    if ( lstrcmpiW( pCity, pLocationList[nThisLocation].AreaCodeW))
+    {
+       DBGOUT((4, "This city code [%ls] is different from the current city code [%ls]",
+                        pCity, pLocationList[nThisLocation].AreaCodeW));
+
+       return 0;
+    }
+
+
+    //
+    // Ok, the data's valid.  We won't need to use pSubscriber again,
+    // so we'll trash it a bit.
+    //
+//BUGBUG: assumption - that a toll prefix is 3 tchars
+    pSubscriber[3] = ',';
+    pSubscriber[4] = '\0';
+
+
+    pTollListW = &(pLocationList[nThisLocation].TollListW[0]);
+
+
+    //
+    // Is the entry in the list?
+    //
+    pEntryInListW = wcsstr(pTollListW, pSubscriber);
+
+
+    //
+    // So, what are we here for?
+    //
+    if ( dwTollListOption == LINETOLLLISTOPTION_ADD )
+    {
+        //
+        // Ok, the caller wants to add this prefix.  Is it already there?
+        //
+        if ( NULL == pEntryInListW )
+        {
+
+            //
+            // If the tolllist is empty, start it off right.
+            //
+            if ( pTollListW[0] == '\0' )
+            {
+               pTollListW[0] = ',';
+               pTollListW[1] = '\0';
+            }
+
+
+            //
+            // Now, we hafta do the work
+            //
+            lstrcatW( pTollListW, pSubscriber );
+
+            dwChangeFlags |= CHANGEDFLAGS_TOLLLIST;
+        }
+//        else
+//        {
+//            //
+//            // Yes, it's already there.  Do nothing.
+//            //
+//        }
+
+    }
+    else
+    {
+        //
+        // Ok, the caller wants to delete this prefix.  Is it even there?
+        //
+        if ( pEntryInListW )
+        {
+            //
+            // Yes, it's there.  Ok, remove it.  (copy from the first ',' past the start)
+            //
+            lstrcpyW( pEntryInListW, wcschr(pEntryInListW, ',')+1 );
+
+            dwChangeFlags |= CHANGEDFLAGS_TOLLLIST;
+        }
+//        else
+//        {
+//            //
+//            // Nope, it's not there. Do nothing.
+//            //
+//        }
+
+    }
+
+
+    //
+    // Ok, now save the new string (if appropriate)
+    //
+
+    EnterCriticalSection( &gUICriticalSection );
+
+    WriteLocations( pLocationList, pnStuff[2],
+                       dwChangeFlags, &pLocationList[nThisLocation] );
+
+    LeaveCriticalSection( &gUICriticalSection );
+
+
+    if (pnStuff)
+       ClientFree( pnStuff );
+
+    if (pLocationList)
+       ClientFree( pLocationList );
+
+
+cleanup:
+
+    ClientFree( pAddressIn );
+
+
+    InternalDebugOut((1, "Leaving lineSetCurrentLocation  result=0x%08lx",
+                         lResult));
+    return lResult;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineSetTollListA(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    LPCSTR      lpszAddressIn,
+    DWORD       dwTollListOption
+    )
+{
+   WCHAR  szAddressInW[512];
+
+   if ( IsBadStringPtr(lpszAddressIn, 512) )
+   {
+      DBGOUT((1, "Bad string pointer passed to lineSetTollList"));
+      return LINEERR_INVALPOINTER;
+   }
+
+   MultiByteToWideChar(
+                        GetACP(),
+                        MB_PRECOMPOSED,
+                        lpszAddressIn,
+                        -1,
+                        szAddressInW,
+                        512
+                      );
+
+   return lineSetTollListW(
+                           hLineApp,
+                           dwDeviceID,
+                           szAddressInW,
+                           dwTollListOption
+                         );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+lineSetTollList(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    LPCSTR      lpszAddressIn,
+    DWORD       dwTollListOption
+    )
+{
+    return lineSetTollListA(
+                    hLineApp,
+                    dwDeviceID,
+                    lpszAddressIn,
+                    dwTollListOption
+    );
+}    
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfoW(
+    LPWSTR   lpszCountryCode,
+    LPWSTR   lpszCityCode
+    )
+{
+    PLOCATION pLocationList;
+    LOCATION  Location;
+    PUINT     pnStuff;
+    LONG      lResult = 0;
+
+    if (IsBadWritePtr( lpszCountryCode, 16) )
+    {
+       DBGOUT((1, "tapiGetLocationInfoW: lpszCountryCode is not a valid, 8-byte pointer"));
+       //*** *** ***BUGBUG is this the right error code?  - docs say it's the only legal one...
+       return TAPIERR_REQUESTFAILED;
+    }
+
+
+    if (IsBadWritePtr( lpszCityCode, 16) )
+    {
+       DBGOUT((1, "tapiGetLocationInfoW: lpszCityCode is not a valid, 8-byte pointer"));
+       //*** *** ***BUGBUG is this the right error code?  - docs say it's the only legal one...
+       return TAPIERR_REQUESTFAILED;
+    }
+
+
+    lResult = ReadLocations( &pLocationList,
+                             &pnStuff,
+                             0,
+                             0,
+                             0,
+                             0
+                           );
+    if ( 0 != lResult )
+    {
+       //BUGBUG Should we throw up the mini dialhelper for the caller since
+       //the only return code we're "allowed" to return is so generic, the
+       //caller won't know what to do (besides, it's called "simple" tapi)
+
+       return TAPIERR_REQUESTFAILED;
+    }
+
+
+//       pnStuff[0] = nCurrentLocationID;
+//       pnStuff[1] = (UINT)pLocationList;
+//       pnStuff[2] = nNumLocations;
+
+    GetThisLocation( &Location, pnStuff[0], pLocationList, pnStuff[2] );
+    //*** *** ***BUGBUG Need to check return code
+
+
+    wsprintfW( lpszCountryCode, L"%d", Location.dwCountry );
+
+    wsprintfW(lpszCityCode, L"%ls", Location.AreaCodeW );
+
+
+    ClientFree( pLocationList );
+    ClientFree( pnStuff );
+    
+    return 0;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfoA(
+    LPSTR   lpszCountryCode,
+    LPSTR   lpszCityCode
+    )
+{
+
+   WCHAR szCountryCodeW[8];
+   WCHAR szCityCodeW[8];
+   LONG lResult;
+
+
+   if (IsBadWritePtr( lpszCountryCode, 8) )
+   {
+      DBGOUT((1, "tapiGetLocationInfo: lpszCountryCode is not a valid, 8-byte pointer"));
+      //*** *** ***BUGBUG is this the right error code?  - docs say it's the only legal one...
+      return TAPIERR_REQUESTFAILED;
+   }
+
+
+   if (IsBadWritePtr( lpszCityCode, 8) )
+   {
+      DBGOUT((1, "tapiGetLocationInfo: lpszCityCode is not a valid, 8-byte pointer"));
+      //*** *** ***BUGBUG is this the right error code?  - docs say it's the only legal one...
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   lResult = tapiGetLocationInfoW(
+                                   szCountryCodeW,
+                                   szCityCodeW
+                                  );
+
+   if ( 0 == lResult )
+   {
+      WideCharToMultiByte(
+                           GetACP(),
+                           0,
+                           szCountryCodeW,
+                           -1,
+                           lpszCountryCode,
+                           8,
+                           NULL,
+                           NULL
+                         );
+
+      WideCharToMultiByte(
+                           GetACP(),
+                           0,
+                           szCityCodeW,
+                           -1,
+                           lpszCityCode,
+                           8,
+                           NULL,
+                           NULL
+                         );
+   }
+
+   return lResult;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfo(
+    LPSTR   lpszCountryCode,
+    LPSTR   lpszCityCode
+    )
+{
+    return tapiGetLocationInfoA(
+               lpszCountryCode,
+               lpszCityCode
+    );
+}    
+    
+    
+    
+    
+#ifndef NORASPRIVATES
+
+/*----------------------------------------------------------------------------
+** Private entry points used by RAS
+**----------------------------------------------------------------------------
+**
+** RASDLG.DLL uses these to create, rename, and delete TAPI locations for it's
+** down-level prefix/suffix phone number modifiers.  These privates depend on
+** the following TAPI routines:
+**
+**     AllocNewID
+**     ClientAlloc
+**     ClientFree
+**     ReadLocations
+**     WriteLocations
+**
+** The routines are named internalXxx to make it clear to relocation-table
+** scanners that the APIs were not intended to be published.
+**
+** 03/09/96 Steve Cobb (reviewed by BernieM)
+*/
+
+LOCATION*
+LocationFromID(
+    IN LOCATION* pLocs,
+    IN UINT      cLocs,
+    IN DWORD     dwID )
+
+    /* Returns address of the location in array 'pLocs' with ID 'dwId' or NULL
+    ** if not found.  'CLocs' is the number of locations in 'pLocs'.
+    */
+{
+    LOCATION* pLoc;
+    UINT      i;
+
+    for (i = 0, pLoc = pLocs; i < cLocs; ++i, ++pLoc)
+    {
+        if (pLoc->dwID == dwID)
+            return pLoc;
+    }
+
+    return NULL;
+}
+
+
+LOCATION*
+LocationFromName(
+    IN LOCATION* pLocs,
+    IN UINT      cLocs,
+    IN WCHAR*    pszName )
+
+    /* Returns address of the location in array 'pLocs' with name 'pszName' or
+    ** NULL if not found.  'CLocs' is the number of locations in 'pLocs'.
+    */
+{
+    LOCATION* pLoc;
+    UINT      i;
+
+    for (i = 0, pLoc = pLocs; i < cLocs; ++i, ++pLoc)
+    {
+        if (lstrcmpW( pLoc->NameW, pszName ) == 0)
+            return pLoc;
+    }
+
+    return NULL;
+}
+
+
+DWORD APIENTRY
+internalNewLocationW(
+    IN WCHAR* pszName )
+
+    /* Create a new TAPI location that is a clone of the current location but
+    ** with name 'pszName'.  The new location is assigned it's own unique ID
+    ** by this routine.
+    **
+    ** Returns 0 if succesful, or an error code.
+    */
+{
+    DWORD     dwErr;
+    LOCATION* pLocs;
+    LOCATION* pCurLoc;
+    LOCATION* pNewLocs;
+    LOCATION* pNewLoc;
+    UINT*     punStuff;
+    UINT      cLocs;
+    DWORD     dwCurID;
+
+    /* Validate argument.
+    */
+    if (!pszName || lstrlenW( pszName ) > MAXLEN_NAME)
+        return LINEERR_INVALPARAM;
+
+    pLocs = NULL;
+    pNewLocs = NULL;
+    punStuff = NULL;
+
+    /* Retrieve the location array.
+    */
+    dwErr = ReadLocations( &pLocs, &punStuff, 0, 0, 0, 0 );
+    if (dwErr != 0)
+        return dwErr;
+
+    do
+    {
+        /* Extract the current location's ID and the location count from the
+        ** returned "stuff" array.
+        */
+        dwCurID = punStuff[ 0 ];
+        cLocs = punStuff[ 2 ];
+
+        /* Allocate a new array one larger.
+        */
+        pNewLocs = ClientAlloc( (cLocs + 1) * sizeof(LOCATION) );
+        if (!pNewLocs)
+        {
+            dwErr = ERROR_NOT_ENOUGH_MEMORY;
+            break;
+        }
+
+        /* Copy the old array to the new array.
+        */
+        CopyMemory( pNewLocs, pLocs, cLocs * sizeof(LOCATION) );
+
+        /* Copy the current location in the old array over the extra location
+        ** in the new array.
+        */
+        pCurLoc = LocationFromID( pLocs, cLocs, dwCurID );
+        if (!pCurLoc)
+        {
+            dwErr = LINEERR_INVALLOCATION;
+            break;
+        }
+
+        pNewLoc = pNewLocs + cLocs;
+        CopyMemory( pNewLoc, pCurLoc, sizeof(LOCATION) );
+
+        /* Give the new location a unique ID and caller's chosen name.
+        */
+        AllocNewID( HKEY_LOCAL_MACHINE, &pNewLoc->dwID );
+        lstrcpyW( pNewLoc->NameW, pszName );
+
+        /* Write the new array.
+        */
+        WriteLocations(
+            pNewLocs, cLocs + 1,
+            CHANGEDFLAGS_REALCHANGE | CHANGEDFLAGS_TOLLLIST, pCurLoc );
+    }
+    while (FALSE);
+
+    /* Clean up.
+    */
+    if (pLocs)
+        ClientFree( pLocs );
+    if (punStuff)
+        ClientFree( punStuff );
+    if (pNewLocs)
+        ClientFree( pNewLocs );
+
+    return dwErr;
+}
+
+
+DWORD APIENTRY
+internalRemoveLocation(
+    IN DWORD dwID )
+
+    /* Removes the TAPI location with ID 'dwID'.
+    **
+    ** Returns 0 if successful, or an error code.
+    */
+{
+    DWORD     dwErr;
+    LOCATION* pLocs;
+    LOCATION* pCurLoc;
+    LOCATION* pLoc;
+    UINT*     punStuff;
+    UINT      cLocs;
+    DWORD     dwCurID;
+    DWORD     dwFlags;
+
+    pLocs = NULL;
+    punStuff = NULL;
+
+    /* Retrieve the location array.
+    */
+    dwErr = ReadLocations( &pLocs, &punStuff, 0, 0, 0, 0 );
+    if (dwErr != 0)
+        return dwErr;
+
+    do
+    {
+        /* Extract the current location's ID and the location count from the
+        ** returned "stuff" array.
+        */
+        dwCurID = punStuff[ 0 ];
+        cLocs = punStuff[ 2 ];
+
+        /* Can't delete the last location.
+        */
+        if (cLocs < 2)
+        {
+            dwErr = LINEERR_INVALPARAM;
+            break;
+        }
+
+        /* Set the name of the location to "" which causes WriteLocations to
+        ** delete it.
+        */
+        pLoc = LocationFromID( pLocs, cLocs, dwID );
+        if (!pLoc)
+        {
+            dwErr = LINEERR_INVALLOCATION;
+            break;
+        }
+        pLoc->NameW[ 0 ] = L'\0';
+
+        /* If we're deleting the current location make the first location the
+        ** current location, or if we're deleting the first the second.
+        */
+        dwFlags = CHANGEDFLAGS_REALCHANGE;
+        if (dwCurID == dwID)
+        {
+            if (pLocs->dwID == dwID)
+                pCurLoc = pLocs + 1;
+            else
+                pCurLoc = pLocs;
+            dwFlags |= CHANGEDFLAGS_CURLOCATIONCHANGED;
+        }
+        else
+        {
+            pCurLoc = LocationFromID( pLocs, cLocs, dwCurID );
+            if (!pCurLoc)
+            {
+                dwErr = LINEERR_INVALLOCATION;
+                break;
+            }
+        }
+
+        /* Write the changed array.
+        */
+        WriteLocations( pLocs, cLocs, dwFlags, pCurLoc );
+    }
+    while (FALSE);
+
+    /* Clean up.
+    */
+    if (pLocs)
+        ClientFree( pLocs );
+    if (punStuff)
+        ClientFree( punStuff );
+
+    return dwErr;
+}
+
+
+DWORD APIENTRY
+internalRenameLocationW(
+    IN WCHAR* pszOldName,
+    IN WCHAR* pszNewName )
+
+    /* Renames TAPI location with name 'pszOldName' to 'pszNewName'.
+    **
+    ** Returns 0 if successful, or an error code.
+    */
+{
+    DWORD     dwErr;
+    LOCATION* pLocs;
+    LOCATION* pLoc;
+    UINT*     punStuff;
+    UINT      cLocs;
+
+    /* Validate argument.
+    */
+    if (!pszOldName || !pszNewName || lstrlenW( pszNewName ) > MAXLEN_NAME)
+        return LINEERR_INVALPARAM;
+
+    pLocs = NULL;
+    punStuff = NULL;
+
+    /* Retrieve the location array.
+    */
+    dwErr = ReadLocations( &pLocs, &punStuff, 0, 0, 0, 0 );
+    if (dwErr != 0)
+        return dwErr;
+
+    do
+    {
+        /* Extract the current location count from the returned "stuff" array.
+        */
+        cLocs = punStuff[ 2 ];
+
+        /* Find the old location and change it's name.
+        */
+        pLoc = LocationFromName( pLocs, cLocs, pszOldName );
+        if (!pLoc)
+        {
+            dwErr = LINEERR_INVALPARAM;
+            break;
+        }
+
+        lstrcpyW( pLoc->NameW, pszNewName );
+
+        /* Write the changed array.
+        */
+        WriteLocations( pLocs, cLocs, CHANGEDFLAGS_REALCHANGE, pLoc );
+    }
+    while (FALSE);
+
+    /* Clean up.
+    */
+    if (pLocs)
+        ClientFree( pLocs );
+    if (punStuff)
+        ClientFree( punStuff );
+
+    return dwErr;
+}
+
+
+#endif // !NORASPRIVATES
+
diff --git a/private/tapi/dev/client/general.c b/private/tapi/dev/client/general.c
new file mode 100644
index 000000000..03b220f5b
--- /dev/null
+++ b/private/tapi/dev/client/general.c
@@ -0,0 +1,759 @@
+
+
+#include <windows.h>
+#include <windowsx.h>
+
+#if WINNT
+#else
+#include <help.h>
+#endif
+
+#include "tchar.h"
+#include "prsht.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "clientr.h"
+#include "client.h"
+#include "private.h"
+
+#include "general.h"
+
+
+
+#if DBG
+#define InternalDebugOut(_x_) DbgPrt _x_
+garbage;
+#else
+#define InternalDebugOut(_x_)
+#endif
+
+
+//***************************************************************************
+
+TCHAR gszCurrentProfileKey[] = "System\\CurrentControlSet\\Control\\Telephony";
+TCHAR gszStaticProfileKey[]  = "Config\\%04d\\System\\CurrentControlSet\\Control\\Telephony";
+TCHAR gszAutoLaunchKey[]     = "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony";
+TCHAR gszAutoLaunchValue[]   = "AutoLaunchFlags";
+TCHAR gszAutoLocationID[]    = "AutoLocationID";
+
+
+UINT  gnNumConfigProfiles = 0;
+DWORD gdwConfigProfiles[MAX_CONFIGPROFILES];
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//Purpose: Gets the appropriately sized translate caps structure
+//         from TAPI.  Return TRUE if successful
+
+
+#define LOCATION_GROW   4
+//#define TAPI_API_VERSION  0x00020000
+#define TAPI_API_VERSION  0x00010004
+
+
+BOOL GetTranslateCaps(
+    LPLINETRANSLATECAPS FAR * pptc)
+{
+    LONG lineErr;
+    LPLINETRANSLATECAPS ptc;
+    DWORD cbSize;
+
+    cbSize = sizeof(*ptc) * LOCATION_GROW + 200;
+    ptc = (LPLINETRANSLATECAPS)GlobalAllocPtr(GPTR, cbSize);
+    if (ptc)
+        {
+        // Get the translate devcaps
+        ptc->dwTotalSize = cbSize;
+        lineErr = lineGetTranslateCaps(NULL, TAPI_API_VERSION, ptc);
+        if (LINEERR_STRUCTURETOOSMALL == lineErr ||
+            ptc->dwNeededSize > ptc->dwTotalSize)
+            {
+            // Provided structure was too small, resize and try again
+            cbSize = ptc->dwNeededSize;
+            GlobalFreePtr(ptc);
+            ptc = (LPLINETRANSLATECAPS)GlobalAllocPtr(GPTR, cbSize);
+            if (ptc)
+                {
+                ptc->dwTotalSize = cbSize;
+                lineErr = lineGetTranslateCaps(NULL, TAPI_API_VERSION, ptc);
+                if (0 != lineErr)
+                    {
+                    // Failure
+                    GlobalFreePtr(ptc);
+                    ptc = NULL;
+                    }
+                }
+            }
+        else if (0 != lineErr)
+            {
+            // Failure
+            GlobalFreePtr(ptc);
+            ptc = NULL;
+            }
+        }
+
+    *pptc = ptc;
+
+    return NULL != *pptc;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//
+// WARNING  WARNING  WARNING  WARNING  WARNING  WARNING  WARNING  WARNING  
+// Returns 1 if a problem, 0 if no problem
+// Code below assumes that this function ONLY returns 0 or 1 (but I think
+// it would be confusing to have the rettype be BOOL, since we want a
+// return of '1' on a problem...)
+//
+LONG FillConfigProfileBox( HWND hWnd,
+                           DWORD dwControl,
+                           LPLINETRANSLATECAPS ptc)
+{
+   UINT n;
+   DWORD nProfileNumberZ;
+   WPARAM wIndex;
+   LINELOCATIONENTRY *ple;
+   HKEY hKey;
+   TCHAR szValueName[40];
+   TCHAR buf[256];
+   DWORD dwType;
+   DWORD dwDataSize;
+   LPSTR lpstrProfileLocation = NULL;
+   LONG  lResult;
+
+
+   //
+   // Get the zero-based Config Profile Number
+   //
+   nProfileNumberZ = dwControl - IDCB_DL_PROFILE1;
+
+
+   //
+   // Get the profile's name.  If this fails, we assume we've run out
+   // of configs
+   //
+   RegOpenKeyEx(
+                   HKEY_LOCAL_MACHINE,
+                   "System\\CurrentControlSet\\Control\\IDConfigDB",
+                   0,
+                   KEY_ALL_ACCESS,
+                   &hKey
+                 );
+
+   wsprintf( szValueName, "FriendlyName%04d", nProfileNumberZ + 1);
+
+   dwDataSize = sizeof(buf);
+
+   lResult = RegQueryValueEx(
+                              hKey,
+                              szValueName,
+                              0,
+                              &dwType,
+                              buf,
+                              &dwDataSize
+                            );
+
+   RegCloseKey( hKey );
+
+
+   //
+   // Did we find a name for it?
+   //
+   if ( ERROR_SUCCESS != lResult )
+   {
+      return (1);
+   }
+
+   //
+   // Put whatever we found into the field
+   //
+   SendMessage( GetDlgItem( hWnd, IDCS_DL_PROFILE1 + nProfileNumberZ ),
+                WM_SETTEXT,
+                0,
+                (LPARAM)&buf
+              );
+
+
+   //
+   // Read what location ID is currently specified for this profile
+   //
+   wsprintf( buf, gszStaticProfileKey, nProfileNumberZ + 1);
+
+   RegOpenKeyEx(
+                   HKEY_LOCAL_MACHINE,
+                   buf,
+                   0,
+                   KEY_ALL_ACCESS,
+                   &hKey
+                 );
+
+   dwDataSize = sizeof(DWORD);
+
+   lResult = RegQueryValueEx(
+                           hKey,
+                           gszAutoLocationID,
+                           0,
+                           &dwType,
+                           (LPBYTE)&gdwConfigProfiles[ nProfileNumberZ ],
+                           &dwDataSize
+                         );
+
+   RegCloseKey( hKey );
+
+
+   //
+   // If there's no value (maybe it's the first run), use current location
+   //
+   if (lResult != ERROR_SUCCESS)
+   {
+      gdwConfigProfiles[nProfileNumberZ] = ptc->dwCurrentLocationID;
+   }
+
+
+   for (n=0; n<ptc->dwNumLocations; n++)
+   {
+      ple = (LINELOCATIONENTRY*) ((LPSTR)ptc + ptc->dwLocationListOffset);
+
+      wIndex = SendMessage( GetDlgItem(hWnd, dwControl),
+                   CB_ADDSTRING,
+                   0,
+                   (LPARAM)((LPSTR)ptc + ple[n].dwLocationNameOffset));
+
+      SendMessage( GetDlgItem( hWnd, dwControl),
+                   CB_SETITEMDATA,
+                   wIndex,
+                   ple[n].dwPermanentLocationID
+                 );
+
+
+//{
+////   UINT temp;
+//
+//   wsprintf( buf, "prof=%d loop=%d   s=%s  dw=%ld seek=%ld",
+//                   nProfileNumberZ,
+//                   n,
+//                   (LPARAM)((LPSTR)ptc + ple[n].dwLocationNameOffset),
+//                   (DWORD)ple[n].dwPermanentLocationID,
+//                   (DWORD)gdwConfigProfiles[nProfileNumberZ]);
+//
+//   MessageBox(GetFocus(), buf, "", MB_OK);
+//}
+
+
+      //
+      // If this location is the one this profile wants, select it
+      //
+      if ( gdwConfigProfiles[nProfileNumberZ] == ple[n].dwPermanentLocationID )
+      {
+//MessageBox(GetFocus(), "Found profile locationID", "", MB_OK);
+
+         lpstrProfileLocation = (LPSTR)((LPSTR)ptc + ple[n].dwLocationNameOffset);
+      }
+
+   }
+
+
+//{
+////   UINT temp;
+//
+//   wsprintf( buf, "profile=%ld loop=%ld   s=%s",
+//                   (DWORD)nProfileNumberZ,
+//                   (DWORD)n,
+//                   (LPARAM)((LPSTR)ptc + ple[n].dwLocationNameOffset));
+//   MessageBox(GetFocus(), buf, "", MB_OK);
+//}
+
+
+   SendMessage( GetDlgItem( hWnd, dwControl),
+                CB_SELECTSTRING,
+                (WPARAM)-1,
+                (LPARAM)lpstrProfileLocation
+              );
+
+
+   return ERROR_SUCCESS;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+BOOL
+CALLBACK
+GeneralDlgProc(
+    HWND    hWnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static DWORD aIds[] = {
+        0, 0
+    };
+
+    UINT n;
+    LONG lResult;
+    HKEY hKey;
+    static DWORD dwType;
+    static DWORD dwDataSize;
+
+    static DWORD dwTapiTNAFlags = 0;
+// these values are in GENERAL.H
+//       #define FLAG_AUTOLAUNCH            0x00000001
+//       #define FLAG_AUTOLOCATIONID        0x00000002
+//       #define FLAG_PROMPTAUTOLOCATIONID  0x00000004
+//       #define FLAG_ANNOUNCEAUTOLOCATIONID   0x00000008
+
+    LPLINETRANSLATECAPS ptc;
+
+
+
+    switch (msg)
+    {
+       case WM_INITDIALOG:
+       {
+
+          GetTranslateCaps(&ptc);
+          //BUGBUG What if this fails?
+
+
+//BUGBUG If the number of hardware configs == 1, don't bother showing these
+          //
+          // Fill up the Hardware config boxes
+          //
+
+          if ( ptc )
+          {
+             lResult = ERROR_SUCCESS;
+
+             for (
+                   n=0;
+                   (n<MAX_CONFIGPROFILES) && (ERROR_SUCCESS == lResult);
+                   n++
+                 )
+             {
+                lResult = FillConfigProfileBox( hWnd,
+                                                IDCB_DL_PROFILE1 + n,
+                                                ptc );
+             }
+
+             gnNumConfigProfiles = n - lResult;
+
+             GlobalFreePtr( ptc );
+          }
+
+
+          //
+          // Now go disable all the stuff not being used
+          // 
+          for ( n=gnNumConfigProfiles; n<MAX_CONFIGPROFILES; n++)
+          {
+             ShowWindow( GetDlgItem( hWnd, IDCB_DL_PROFILE1 + n),
+                         SW_HIDE
+                       );
+             ShowWindow( GetDlgItem( hWnd, IDCS_DL_PROFILE1 + n),
+                         SW_HIDE
+                       );
+          }
+
+
+          //
+          // Get the TapiTNA flags
+          //
+
+          lResult = RegOpenKeyEx(
+                      HKEY_LOCAL_MACHINE,
+                      gszAutoLaunchKey,
+                      0,
+                      KEY_ALL_ACCESS,
+                      &hKey
+                    );
+
+
+          dwDataSize = sizeof(dwTapiTNAFlags);
+
+          lResult = RegQueryValueEx(
+                                     hKey,
+                                     gszAutoLaunchValue,
+                                     0,
+                                     &dwType,
+                                     (LPBYTE)&dwTapiTNAFlags,
+                                     &dwDataSize
+                                   );
+
+          RegCloseKey( hKey );
+
+
+          //
+          // Now check the boxes as appropriate
+          //
+
+          if ( dwTapiTNAFlags & FLAG_AUTOLAUNCH )
+          {
+             CheckDlgButton( hWnd,
+                             IDCK_DL_LAUNCHTAPITNA,
+                             TRUE
+                           );
+          }
+
+          if ( dwTapiTNAFlags & FLAG_AUTOLOCATIONID )
+          {
+             CheckDlgButton( hWnd,
+                             IDCK_DL_AUTOLOCATIONID,
+                             TRUE
+                           );
+          }
+
+          if ( dwTapiTNAFlags & FLAG_UPDATEONSTARTUP )
+          {
+             CheckDlgButton( hWnd,
+                             IDCK_DL_UPDATEONSTARTUP,
+                             TRUE
+                           );
+          }
+
+          if ( dwTapiTNAFlags & FLAG_PROMPTAUTOLOCATIONID )
+          {
+             CheckDlgButton( hWnd,
+                             IDCK_DL_PROMPTAUTOLOCATIONID,
+                             TRUE
+                           );
+          }
+
+          if ( dwTapiTNAFlags & FLAG_ANNOUNCEAUTOLOCATIONID )
+          {
+             CheckDlgButton( hWnd,
+                             IDCK_DL_ANNOUNCEAUTOLOCATIONID,
+                             TRUE
+                           );
+          }
+
+
+          //
+          // Disable the two checkboxes dependent on this one,
+          // but keep the settings
+          //
+          if ( dwTapiTNAFlags & FLAG_AUTOLOCATIONID )
+          {
+             EnableWindow( GetDlgItem(hWnd, IDCK_DL_PROMPTAUTOLOCATIONID),
+                           TRUE
+                         );
+             EnableWindow( GetDlgItem(hWnd, IDCK_DL_ANNOUNCEAUTOLOCATIONID),
+                           TRUE
+                         );
+          }
+          else
+          {
+             EnableWindow( GetDlgItem(hWnd, IDCK_DL_PROMPTAUTOLOCATIONID),
+                           FALSE
+                         );
+             EnableWindow( GetDlgItem(hWnd, IDCK_DL_ANNOUNCEAUTOLOCATIONID),
+                           FALSE
+                         );
+          }
+
+
+       }
+       break;
+
+
+       // Process clicks on controls after Context Help mode selected
+       case WM_HELP:
+           InternalDebugOut((50, "  WM_HELP in LocDefineDlg"));
+           WinHelp (((LPHELPINFO) lParam)->hItemHandle, "windows.hlp", HELP_WM_HELP, 
+                                           (DWORD)(LPSTR) aIds);
+           break;
+
+
+       // Process right-clicks on controls            
+       case WM_CONTEXTMENU:
+           InternalDebugOut((50, "  WM_CONTEXT_MENU in LocationsDlgProc"));
+           WinHelp ((HWND) wParam, "windows.hlp", HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+           break;
+
+
+       case WM_NOTIFY:
+       {
+          LPNMHDR lpnm = (LPNMHDR)lParam;
+
+          switch ( lpnm->code )
+          {
+
+             case PSN_APPLY: /* case IDOK */
+             {
+                DWORD dwDisposition;   // Don't really care about this...
+
+
+                InternalDebugOut((0, "  PSN_APPLY - General"));
+
+                if ( ((LPPSHNOTIFY)lpnm)->lParam )
+                   InternalDebugOut((0, "     (actually, it was the OK button)"));
+
+
+                //
+                // Write out the new flags
+                //
+
+                lResult = RegCreateKeyEx(
+                                          HKEY_LOCAL_MACHINE,
+                                          gszAutoLaunchKey,
+                                          0,
+                                          "", //Class?  Who cares?
+                                          REG_OPTION_NON_VOLATILE,
+                                          KEY_ALL_ACCESS,
+                                          NULL,
+                                          &hKey,
+                                          &dwDisposition
+                                        );
+
+
+                lResult = RegSetValueEx(
+                                          hKey,
+                                          gszAutoLaunchValue,
+                                          0,
+                                          dwType,
+                                          (LPBYTE)&dwTapiTNAFlags,
+                                          dwDataSize
+                                        );
+
+                RegCloseKey( hKey );
+
+
+
+
+                for ( n=0;  n < gnNumConfigProfiles; n++)
+                {
+                   DWORD dwTemp;
+                   TCHAR szKeyName[128];
+
+
+                   wsprintf ( szKeyName, gszStaticProfileKey, n+1);
+
+                   RegCreateKeyEx(
+                                   HKEY_LOCAL_MACHINE,
+                                   szKeyName,
+                                   0,
+                                   "",
+                                   REG_OPTION_NON_VOLATILE,
+                                   KEY_ALL_ACCESS,
+                                   NULL,
+                                   &hKey,
+                                   &dwTemp
+                                 );
+
+                   RegSetValueEx(
+                                    hKey,
+                                    gszAutoLocationID,
+                                    0,
+                                    REG_DWORD,
+                                    (LPBYTE)&gdwConfigProfiles[n],
+                                    sizeof(DWORD)
+                               );
+
+                   RegCloseKey( hKey );
+
+                }
+
+                break;
+             }
+
+
+             case  PSN_RESET:        /* case IDCANCEL: */
+                InternalDebugOut((0, "  PSN_RESET - General"));
+                break;
+
+
+#if DBG     
+             case PSN_SETACTIVE:
+                InternalDebugOut((0, "  PSN_SETACTIVE - General"));
+                break;
+
+
+             case PSN_KILLACTIVE:
+                InternalDebugOut((0, "  PSN_KILLACTIVE - General"));
+                break;
+
+#endif
+
+          }
+       }
+       break;
+
+
+       case WM_COMMAND:
+       {
+          switch (LOWORD(wParam))
+          {
+
+             case IDCB_DL_PROFILE1:
+             case IDCB_DL_PROFILE2:
+             case IDCB_DL_PROFILE3:
+             case IDCB_DL_PROFILE4:
+             {
+
+                //
+                // Only process if something is changing
+                //
+                switch  HIWORD(wParam)
+                {
+                   case  CBN_SELCHANGE:
+                   {
+                      UINT m;
+
+
+                      gdwConfigProfiles[LOWORD(wParam) - IDCB_DL_PROFILE1] =
+                            n = SendMessage( GetDlgItem( hWnd, LOWORD(wParam)),
+                                         CB_GETITEMDATA,
+                                       ( m= SendMessage(
+                                                      GetDlgItem( hWnd,
+                                                                  LOWORD(wParam)),
+                                                      CB_GETCURSEL,
+                                                      0,
+                                                      0
+                                                    ) ) ,
+                                         0
+                                       );
+
+//{
+//   TCHAR Buffer[256];
+//   wsprintf( Buffer, "wParam=0x%08lx lParam=0x%08lx data=0x%08lx m=0x%08lx",
+//                     (DWORD)wParam,
+//                     (DWORD)lParam,
+//                     (DWORD)n,
+//                     (DWORD)m
+//           );
+//   MessageBox(GetFocus(), Buffer, "", MB_OK);
+//}
+
+                      //
+                      // Activate the APPLY button if not already done
+                      //
+                      PropSheet_Changed(GetParent(hWnd), hWnd);
+                   }
+                }
+             }
+             break;
+
+
+             case IDCK_DL_LAUNCHTAPITNA:
+             {
+                dwTapiTNAFlags ^= FLAG_AUTOLAUNCH;
+
+                //
+                // Activate the APPLY button if not already done
+                //
+                PropSheet_Changed(GetParent(hWnd), hWnd);
+             }
+             break;
+
+
+             case IDCK_DL_AUTOLOCATIONID:
+             {
+                dwTapiTNAFlags ^= FLAG_AUTOLOCATIONID;
+
+                //
+                // Disable the two checkboxes dependent on this one,
+                // but keep the settings
+                //
+                if ( dwTapiTNAFlags & FLAG_AUTOLOCATIONID )
+                {
+                   EnableWindow( GetDlgItem(hWnd, IDCK_DL_PROMPTAUTOLOCATIONID),
+                                 TRUE
+                               );
+                   EnableWindow( GetDlgItem(hWnd, IDCK_DL_ANNOUNCEAUTOLOCATIONID),
+                                 TRUE
+                               );
+//                   EnableWindow( GetDlgItem(hWnd, IDCS_DL_PROMPTAUTOLOCATIONID),
+//                                 TRUE
+//                               );
+//                   EnableWindow( GetDlgItem(hWnd, IDCS_DL_ANNOUNCEAUTOLOCATIONID),
+//                                 TRUE
+//                               );
+                }
+                else
+                {
+                   EnableWindow( GetDlgItem(hWnd, IDCK_DL_PROMPTAUTOLOCATIONID),
+                                 FALSE
+                               );
+                   EnableWindow( GetDlgItem(hWnd, IDCK_DL_ANNOUNCEAUTOLOCATIONID),
+                                 FALSE
+                               );
+//                   EnableWindow( GetDlgItem(hWnd, IDCS_DL_PROMPTAUTOLOCATIONID),
+//                                 FALSE
+//                               );
+//                   EnableWindow( GetDlgItem(hWnd, IDCS_DL_ANNOUNCEAUTOLOCATIONID),
+//                                 FALSE
+//                               );
+                }
+
+
+                //
+                // Activate the APPLY button if not already done
+                //
+                PropSheet_Changed(GetParent(hWnd), hWnd);
+             }
+             break;
+
+
+             case IDCK_DL_PROMPTAUTOLOCATIONID:
+             {
+                dwTapiTNAFlags ^= FLAG_PROMPTAUTOLOCATIONID;
+
+                //
+                // Activate the APPLY button if not already done
+                //
+                PropSheet_Changed(GetParent(hWnd), hWnd);
+             }
+             break;
+
+
+             case IDCK_DL_UPDATEONSTARTUP:
+             {
+                dwTapiTNAFlags ^= FLAG_UPDATEONSTARTUP;
+
+                //
+                // Activate the APPLY button if not already done
+                //
+                PropSheet_Changed(GetParent(hWnd), hWnd);
+             }
+             break;
+
+
+             case IDCK_DL_ANNOUNCEAUTOLOCATIONID:
+             {
+                dwTapiTNAFlags ^= FLAG_ANNOUNCEAUTOLOCATIONID;
+
+                //
+                // Activate the APPLY button if not already done
+                //
+                PropSheet_Changed(GetParent(hWnd), hWnd);
+             }
+             break;
+
+
+             default:
+             {
+             }
+             break;
+
+          }
+       }
+       break;
+
+
+       default:
+       break;
+
+    }
+
+    return FALSE;
+}
+
diff --git a/private/tapi/dev/client/general.h b/private/tapi/dev/client/general.h
new file mode 100644
index 000000000..7936c4574
--- /dev/null
+++ b/private/tapi/dev/client/general.h
@@ -0,0 +1,49 @@
+#define FLAG_AUTOLAUNCH               0x00000001
+#define FLAG_AUTOLOCATIONID           0x00000002
+#define FLAG_PROMPTAUTOLOCATIONID     0x00000004
+#define FLAG_ANNOUNCEAUTOLOCATIONID   0x00000008
+#define FLAG_UPDATEONSTARTUP          0x00000010
+
+BOOL
+CALLBACK
+GeneralDlgProc(
+    HWND    hWnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+
+#define MAX_CONFIGPROFILES 4
+
+#define IDC_STATIC                      -1
+
+
+#define IDD_GENERAL                     114
+
+
+
+//WARNING GENERAL.C _ASSUMES_ that the defines for the profile comboboxes are
+//sequential
+#define IDCS_DL_PROFILETEXT              5017
+#define IDCB_DL_PROFILE1                 5018
+#define IDCB_DL_PROFILE2                 5019
+#define IDCB_DL_PROFILE3                 5020
+#define IDCB_DL_PROFILE4                 5021
+
+//WARNING GENERAL.C _ASSUMES_ that the defines for the profile texts are
+//sequential
+#define IDCS_DL_PROFILE1                 5024
+#define IDCS_DL_PROFILE2                 5025
+#define IDCS_DL_PROFILE3                 5026
+#define IDCS_DL_PROFILE4                 5027
+
+
+#define IDCK_DL_LAUNCHTAPITNA               6012
+#define IDCK_DL_AUTOLOCATIONID              6013
+#define IDCK_DL_PROMPTAUTOLOCATIONID        6014
+#define IDCK_DL_ANNOUNCEAUTOLOCATIONID      6015
+#define IDCK_DL_UPDATEONSTARTUP             6018
+
+#define IDCS_DL_PROMPTAUTOLOCATIONID        6016
+#define IDCS_DL_ANNOUNCEAUTOLOCATIONID         6017
diff --git a/private/tapi/dev/client/general.rc b/private/tapi/dev/client/general.rc
new file mode 100644
index 000000000..2db456eed
--- /dev/null
+++ b/private/tapi/dev/client/general.rc
@@ -0,0 +1,66 @@
+#include "windows.h"
+#include "general.h"
+#include "clientr.h"
+
+// /////////////////////////////////////////////////////////////////////////
+
+IDD_GENERAL  DIALOG DISCARDABLE  10, 10, 265, 217
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU //| DS_3DLOOK
+CAPTION "General"
+FONT 8, "MS Shell Dlg"
+BEGIN
+//    CONTROL         "",
+//                    IDCK_DL_LAUNCHTAPITNA,"Button",BS_AUTOCHECKBOX | 
+//                    WS_TABSTOP,12,10,10,10
+//    LTEXT         "Launch the Telephony Location Selection thingy\r\n when a Telephony app runs",
+//                    IDC_STATIC, 25,10,200,25
+
+
+    CONTROL       "",
+                    IDCK_DL_UPDATEONSTARTUP,
+                    "Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,25,20,10,10
+    LTEXT         "Update Telephony Location upon startup and power-resume"
+                  IDC_STATIC, 38, 20, 200, 25
+
+
+    LTEXT         "Take one or more of the following actions when I dock or undock:"
+                    IDC_STATIC, 25,38,220,30
+
+    CONTROL         "",
+                    IDCK_DL_AUTOLOCATIONID,
+                    "Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,42,55,10,10
+    LTEXT         "Automatically change telephony location when I dock or undock"
+                    IDC_STATIC, 55,55,200,30
+
+    CONTROL         "",
+                    IDCK_DL_ANNOUNCEAUTOLOCATIONID,
+                    "Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,42,75,10,10
+    LTEXT         "Inform me that the telephony location has automatically changed as a result of docking or undocking.",
+                    IDCS_DL_ANNOUNCEAUTOLOCATIONID,
+                    55,75,200,30
+
+//    CONTROL         "",
+//                    IDCK_DL_PROMPTAUTOLOCATIONID,
+//                    "Button",BS_AUTOCHECKBOX | 
+//                    WS_TABSTOP,42,95,10,10
+//    LTEXT         "Prompt me to change telephony locations when I dock or undock."
+//                    IDCS_DL_PROMPTAUTOLOCATIONID,
+//                    55,95,200,30
+
+
+
+    LTEXT         "Set to this location when I change hardware configuration:",
+                IDCS_DL_PROFILETEXT,   55, 100, 200, 30
+    LTEXT         "", IDCS_DL_PROFILE1, 1, 116, 135, 20, SS_RIGHT | WS_GROUP
+    LTEXT         "", IDCS_DL_PROFILE2, 1, 131, 135, 20, SS_RIGHT | WS_GROUP
+    LTEXT         "", IDCS_DL_PROFILE3, 1, 146, 135, 20, SS_RIGHT | WS_GROUP
+    LTEXT         "", IDCS_DL_PROFILE4, 1, 161, 135, 20, SS_RIGHT | WS_GROUP
+    COMBOBOX       IDCB_DL_PROFILE1, 150, 115, 100, 80, CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+    COMBOBOX       IDCB_DL_PROFILE2, 150, 130, 100, 80, CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+    COMBOBOX       IDCB_DL_PROFILE3, 150, 145, 100, 80, CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+    COMBOBOX       IDCB_DL_PROFILE4, 150, 160, 100, 80, CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+END
+
diff --git a/private/tapi/dev/client/loc.bmp b/private/tapi/dev/client/loc.bmp
new file mode 100644
index 000000000..3e2aaa75e
--- /dev/null
+++ b/private/tapi/dev/client/loc.bmp
diff --git a/private/tapi/dev/client/loc_comn.h b/private/tapi/dev/client/loc_comn.h
new file mode 100644
index 000000000..b12ac8a91
--- /dev/null
+++ b/private/tapi/dev/client/loc_comn.h
@@ -0,0 +1,63 @@
+//***************************************************************************
+typedef struct {
+
+#define MAXLEN_NAME                96
+        WCHAR NameW[MAXLEN_NAME];
+
+#define MAXLEN_AREACODE            16
+        WCHAR AreaCodeW[MAXLEN_AREACODE];
+
+        DWORD dwCountry;
+
+#define MAXLEN_OUTSIDEACCESS       16
+        WCHAR OutsideAccessW[MAXLEN_OUTSIDEACCESS];
+// There is one instance where code assumes outside & ld are same size
+// (the code that reads in the text from the control)
+
+#define MAXLEN_LONGDISTANCEACCESS  16
+        WCHAR LongDistanceAccessW[MAXLEN_LONGDISTANCEACCESS];
+
+        DWORD dwFlags;
+             #define LOCATION_USETONEDIALING 0x00000001
+             #define LOCATION_USECALLINGCARD 0x00000002
+             #define LOCATION_HASCALLWAITING 0x00000004
+
+        DWORD dwCallingCard;
+
+        DWORD dwID;
+
+#define MAXLEN_DISABLECALLWAITING  16
+        WCHAR DisableCallWaitingW[MAXLEN_DISABLECALLWAITING];
+
+// Allow all prefixes to be toll. (Yes, even 911.)  String is "xxx,"
+#define MAXLEN_TOLLLIST     (1000*4 + 1)
+        WCHAR TollListW[MAXLEN_TOLLLIST];
+
+       } LOCATION, *PLOCATION;
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+#define CHANGEDFLAGS_CURLOCATIONCHANGED      0x00000001
+#define CHANGEDFLAGS_REALCHANGE              0x00000002
+#define CHANGEDFLAGS_TOLLLIST                0x00000004
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+//
+// These bits decide which params TAPISRV will check on READLOCATION and
+// WRITELOCATION operations
+//
+#define CHECKPARMS_DWHLINEAPP         1
+#define CHECKPARMS_DWDEVICEID         2
+#define CHECKPARMS_DWAPIVERSION       4
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+#define DWTOTALSIZE  0
+#define DWNEEDEDSIZE 1
+#define DWUSEDSIZE   2
+
diff --git a/private/tapi/dev/client/location.h b/private/tapi/dev/client/location.h
new file mode 100644
index 000000000..617ef45c1
--- /dev/null
+++ b/private/tapi/dev/client/location.h
@@ -0,0 +1,13 @@
+#include "loc_comn.h"
+
+extern PLOCATION gLocationList;
+extern PLOCATION gpCurrentLocation;
+extern UINT gnNumLocations;
+extern UINT gnCurrentLocationID;
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+LONG PASCAL GetLocationIndexFromID( UINT nID, PLOCATION pCallersList, UINT nCallersNumLocations );
+
diff --git a/private/tapi/dev/client/locsimp.bmp b/private/tapi/dev/client/locsimp.bmp
new file mode 100644
index 000000000..7abcd296f
--- /dev/null
+++ b/private/tapi/dev/client/locsimp.bmp
diff --git a/private/tapi/dev/client/makefile b/private/tapi/dev/client/makefile
new file mode 100644
index 000000000..690a91eba
--- /dev/null
+++ b/private/tapi/dev/client/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tapi32.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/client/makefile.def b/private/tapi/dev/client/makefile.def
new file mode 100644
index 000000000..2740beba7
--- /dev/null
+++ b/private/tapi/dev/client/makefile.def
@@ -0,0 +1,81 @@
+##############################################################################
+#
+#   tapi32.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+WANT_C932=1
+#WANT_C1032=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+BUILDDLL=1
+DLLENTRY=DllMain
+
+DEPENDNAME=..\depend.mk
+
+CLEANLIST=*.dll
+
+TARGETS=tapi32.dll $(SDKLIB)\tapi32.lib tapi32.sym
+
+ALTSRCDIR=..\..\cpl
+SRCDIR=..
+
+BUILD_COFF=1
+
+
+L32EXE=tapi32.dll		# Name of exe.
+L32DEF=..\tapi32.def              # Our def file.
+L32MAP=tapi32.map		# Our map file.
+L32LIBS=$(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\comctl32.lib                \
+        $(W32LIBID)\advapi32.lib                \
+        $(W32LIBID)\version.lib                 \
+        $(W32LIBID)\comdlg32.lib                \
+        $(W32LIBID)\comctl32.lib                \
+        $(W32LIBID)\shell32.lib                \
+        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+        $(ROOT)\dev\tools\c932\lib\libc.lib     \
+        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib
+
+
+#        $(ROOT)\dev\tools\c932\lib\msvcrt.lib \
+
+
+L32RES=client.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = client.obj tapsrv_c.obj dial.obj card.obj general.obj\
+          copy.obj cpl.obj init.obj drv.obj exe.obj \
+          filecopy.obj inf.obj insdisk.obj  util.obj  mmdriver.obj 
+
+
+L32FLAGS=-MAP -IMPLIB:tapi32.lib -def:$(L32DEF)
+
+
+!include $(ROOT)\dev\master.mk
+
+
+INCLUDE=$(INCLUDE);..\..\cpl
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc -GD
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Ox
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
+
+
+$(SDKLIB)\tapi32.lib: tapi32.dll
+   copy tapi32.lib $(SDKLIB)\tapi32.lib
+   copy tapi32.lib ..\..\lib\tapi32.lib
diff --git a/private/tapi/dev/client/makefile.inc b/private/tapi/dev/client/makefile.inc
new file mode 100644
index 000000000..1c922223d
--- /dev/null
+++ b/private/tapi/dev/client/makefile.inc
@@ -0,0 +1,34 @@
+copy.c: ..\cpl\copy.c
+    copy $** $@
+
+cpl.c: ..\cpl\cpl.c
+    copy $** $@
+
+init.c: ..\cpl\init.c
+    copy $** $@
+
+drv.c: ..\cpl\drv.c
+    copy $** $@
+
+exe.c: ..\cpl\exe.c
+    copy $** $@
+
+filecopy.c: ..\cpl\filecopy.c
+    copy $** $@
+
+inf.c: ..\cpl\inf.c
+    copy $** $@
+
+insdisk.c: ..\cpl\insdisk.c
+    copy $** $@
+
+mmdriver.c: ..\cpl\mmdriver.c
+    copy $** $@
+
+util.c: ..\cpl\util.c
+    copy $** $@
+
+tapierr.rc: tapierr.mc
+    mc -d tapierr.mc
+
+client.rc: tapierr.rc
diff --git a/private/tapi/dev/client/net09a.ico b/private/tapi/dev/client/net09a.ico
new file mode 100644
index 000000000..275cbc6e9
--- /dev/null
+++ b/private/tapi/dev/client/net09a.ico
diff --git a/private/tapi/dev/client/perfctr.h b/private/tapi/dev/client/perfctr.h
new file mode 100644
index 000000000..9308e5329
--- /dev/null
+++ b/private/tapi/dev/client/perfctr.h
@@ -0,0 +1,22 @@
+//
+//  Offset definition file for extensible counter objects and counters
+//
+//  These "relative" offsets must start at 0 and be multiples of 2 (i.e.
+//  even numbers). In the Open Procedure, they will be added to the 
+//  "First Counter" and "First Help" values for the device they belong to, 
+//  in order to determine the absolute location of the counter and 
+//  object names and corresponding Explain text in the registry.
+//
+//  This file is used by the extensible counter DLL code as well as the 
+//  counter name and Explain text definition file (.INI) file that is used
+//  by LODCTR to load the names into the registry.
+//
+#define TAPIOBJ                 0
+#define NUMLINES                2
+#define CURRENTOPENS            4
+#define TOTALOUTGOINGCALLS      6
+#define TOTALINCOMINGCALLS      8
+
+
+  
+  
diff --git a/private/tapi/dev/client/phone03.ico b/private/tapi/dev/client/phone03.ico
new file mode 100644
index 000000000..1d71d3d94
--- /dev/null
+++ b/private/tapi/dev/client/phone03.ico
diff --git a/private/tapi/dev/client/private.h b/private/tapi/dev/client/private.h
new file mode 100644
index 000000000..70ee38f7e
--- /dev/null
+++ b/private/tapi/dev/client/private.h
@@ -0,0 +1,131 @@
+extern HINSTANCE ghInst;
+//extern const WCHAR     gszCardKeyW[];
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void AllocNewID( HKEY MainKey, LPDWORD lpdw );
+void PASCAL WideStringToNotSoWideString( LPBYTE lpBase, LPDWORD lpdwThing );
+PWSTR PASCAL MultiToWide( LPCSTR  lpStr );
+PWSTR PASCAL NotSoWideStringToWideString( LPCSTR lpStr, DWORD dwLength );
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+typedef enum
+{
+    Dword,
+    lpDword,
+    hXxxApp,
+    hXxxApp_NULLOK,
+//    lpsz,
+    lpszW,
+    lpGet_SizeToFollow,
+    lpSet_SizeToFollow,
+    lpSet_Struct,
+    lpGet_Struct,
+    Size,
+    Hwnd
+
+} ARG_TYPE;
+
+
+typedef struct _FUNC_ARGS
+{
+    DWORD               Flags;
+
+    DWORD               Args[MAX_TAPI_FUNC_ARGS];
+
+    BYTE                ArgTypes[MAX_TAPI_FUNC_ARGS];
+
+} FUNC_ARGS, *PFUNC_ARGS;
+
+
+typedef struct _UI_REQUEST_THREAD_PARAMS
+{
+    BOOL                bRequestCompleted;
+
+    PFUNC_ARGS          pFuncArgs;
+
+    LONG                lResult;
+
+} UI_REQUEST_THREAD_PARAMS, *PUI_REQUEST_THREAD_PARAMS;
+
+
+typedef struct _INIT_DATA
+{
+    DWORD               dwKey;
+
+    DWORD               dwInitOptions;
+
+    union
+    {
+        HWND            hwnd;
+
+        HANDLE          hEvent;
+
+        HANDLE          hCompletionPort;
+    };
+
+    union
+    {
+        LINECALLBACK    lpfnCallback;
+
+        DWORD           dwCompletionKey;
+    };
+
+    HANDLE              hXxxApp;
+
+    BOOL                bPendingAsyncEventMsg;
+
+    DWORD               dwNumTotalEntries;
+
+    DWORD               dwNumUsedEntries;
+
+    PASYNC_EVENT_PARAMS pEventBuffer;
+
+    PASYNC_EVENT_PARAMS pValidEntry;
+
+    PASYNC_EVENT_PARAMS pFreeEntry;
+
+} INIT_DATA, *PINIT_DATA;
+
+
+
+#if DBG
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+DWORD   gdwDebugLevel;
+
+#define DOFUNC(arg1,arg2) DoFunc(arg1,arg2)
+
+LONG
+WINAPI
+DoFunc(
+    PFUNC_ARGS  pFuncArgs,
+    char       *pszFuncName
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#define DOFUNC(arg1,arg2) DoFunc(arg1)
+
+LONG
+WINAPI
+DoFunc(
+    PFUNC_ARGS  pFuncArgs
+    );
+
+#endif
diff --git a/private/tapi/dev/client/rules.mk b/private/tapi/dev/client/rules.mk
new file mode 100644
index 000000000..2c36f3323
--- /dev/null
+++ b/private/tapi/dev/client/rules.mk
@@ -0,0 +1,5 @@
+# @@ COPY_RIGHT_HERE
+# @@ ROADMAP :: The Rules.mk for the Network Control Panel Applet
+#
+
+!include ..\rules.mk
diff --git a/private/tapi/dev/client/sources b/private/tapi/dev/client/sources
new file mode 100644
index 000000000..362e73cbb
--- /dev/null
+++ b/private/tapi/dev/client/sources
@@ -0,0 +1,76 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tapi32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib   \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib   \
+           $(BASEDIR)\public\sdk\lib\*\version.lib   \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=..\cpl;..\server;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+NTTARGETFILES=
+
+SOURCES=client.c  \
+        tapsrv_c.c \
+        dial.c \
+        card.c \
+        client.rc \
+ copy.c \
+ cpl.c \
+ init.c \
+ drv.c \
+ exe.c \
+ filecopy.c \
+ inf.c \
+ insdisk.c \
+ mmdriver.c \
+ util.c
+
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/client/tapi32.def b/private/tapi/dev/client/tapi32.def
new file mode 100644
index 000000000..45e3e2c29
--- /dev/null
+++ b/private/tapi/dev/client/tapi32.def
@@ -0,0 +1,269 @@
+LIBRARY   TAPI32
+
+DATA      READ WRITE
+
+EXPORTS
+
+    lineAccept
+    lineAddToConference
+    lineAnswer
+    lineBlindTransfer
+    lineBlindTransferA
+    lineBlindTransferW
+    lineClose
+    lineCompleteCall
+    lineCompleteTransfer
+    lineConfigDialog
+    lineConfigDialogA
+    lineConfigDialogW
+    lineConfigDialogEdit
+    lineConfigDialogEditA
+    lineConfigDialogEditW
+    lineDeallocateCall
+    lineDevSpecific
+    lineDevSpecificFeature
+    lineDial
+    lineDialA
+    lineDialW
+    lineDrop
+    lineForward
+    lineForwardA
+    lineForwardW
+    lineGatherDigits
+    lineGatherDigitsA
+    lineGatherDigitsW
+    lineGenerateDigits
+    lineGenerateDigitsA
+    lineGenerateDigitsW
+    lineGenerateTone
+    lineGetAddressCaps
+    lineGetAddressCapsA
+    lineGetAddressCapsW
+    lineGetAddressID
+    lineGetAddressIDA
+    lineGetAddressIDW
+    lineGetAddressStatus
+    lineGetAddressStatusA
+    lineGetAddressStatusW
+    lineGetCallInfo
+    lineGetCallInfoA
+    lineGetCallInfoW
+    lineGetCallStatus
+    lineGetConfRelatedCalls
+    lineGetDevCaps
+    lineGetDevCapsA
+    lineGetDevCapsW
+    lineGetDevConfig
+    lineGetDevConfigA
+    lineGetDevConfigW
+    lineGetIcon
+    lineGetIconA
+    lineGetIconW
+    lineGetID
+    lineGetIDA
+    lineGetIDW
+    lineGetLineDevStatus
+    lineGetLineDevStatusA
+    lineGetLineDevStatusW
+    lineGetMessage
+    lineGetNewCalls
+    lineGetNumRings
+    lineGetRequest
+    lineGetRequestA
+    lineGetRequestW
+    lineGetStatusMessages
+    lineGetTranslateCaps
+    lineGetTranslateCapsA
+    lineGetTranslateCapsW
+    lineHandoff
+    lineHandoffA
+    lineHandoffW
+    lineHold
+    lineInitialize
+    lineInitializeExA
+    lineInitializeExW
+    lineMakeCall
+    lineMakeCallA
+    lineMakeCallW
+    lineMonitorDigits
+    lineMonitorMedia
+    lineMonitorTones
+    lineNegotiateAPIVersion
+    lineNegotiateExtVersion
+    lineOpen
+    lineOpenA
+    lineOpenW
+    linePark
+    lineParkA
+    lineParkW
+    linePickup
+    linePickupA
+    linePickupW
+    linePrepareAddToConference
+    linePrepareAddToConferenceA
+    linePrepareAddToConferenceW
+    lineRedirect
+    lineRedirectA
+    lineRedirectW
+    lineRegisterRequestRecipient
+    lineReleaseUserUserInfo
+    lineRemoveFromConference
+    lineSecureCall
+    lineSendUserUserInfo
+    lineSetAppSpecific
+    lineSetCallParams
+    lineSetCallPrivilege
+    lineSetCurrentLocation
+    lineSetDevConfig
+    lineSetDevConfigA
+    lineSetDevConfigW
+    lineSetMediaControl
+    lineSetMediaMode
+    lineSetNumRings
+    lineSetStatusMessages
+    lineSetTerminal
+    lineSetTollList
+    lineSetTollListA
+    lineSetTollListW
+    lineSetupConference
+    lineSetupConferenceA
+    lineSetupConferenceW
+    lineSetupTransfer
+    lineSetupTransferA
+    lineSetupTransferW
+    lineShutdown
+    lineSwapHold
+    lineTranslateAddress
+    lineTranslateAddressA
+    lineTranslateAddressW
+    lineUncompleteCall
+    lineUnhold
+    lineUnpark
+    lineUnparkA
+    lineUnparkW
+
+    phoneClose
+    phoneConfigDialog
+    phoneConfigDialogA
+    phoneConfigDialogW
+    phoneDevSpecific
+    phoneGetButtonInfo
+    phoneGetButtonInfoA
+    phoneGetButtonInfoW
+    phoneGetData
+    phoneGetDevCaps
+    phoneGetDevCapsA
+    phoneGetDevCapsW
+    phoneGetDisplay
+    phoneGetGain
+    phoneGetHookSwitch
+    phoneGetIcon
+    phoneGetIconA
+    phoneGetIconW
+    phoneGetID
+    phoneGetIDA
+    phoneGetIDW
+    phoneGetLamp
+    phoneGetMessage
+    phoneGetRing
+    phoneGetStatus
+    phoneGetStatusA
+    phoneGetStatusW
+    phoneGetStatusMessages
+    phoneGetVolume
+    phoneInitialize
+    phoneInitializeExA
+    phoneInitializeExW
+    phoneOpen
+    phoneNegotiateAPIVersion
+    phoneNegotiateExtVersion
+    phoneSetButtonInfo
+    phoneSetButtonInfoA
+    phoneSetButtonInfoW
+    phoneSetData
+    phoneSetDisplay
+    phoneSetGain
+    phoneSetHookSwitch
+    phoneSetLamp
+    phoneSetRing
+    phoneSetStatusMessages
+    phoneSetVolume
+    phoneShutdown
+
+    tapiGetLocationInfo
+    tapiGetLocationInfoA
+    tapiGetLocationInfoW
+    tapiRequestDrop
+    tapiRequestMakeCall
+    tapiRequestMakeCallA
+    tapiRequestMakeCallW
+    tapiRequestMediaCall
+    tapiRequestMediaCallA
+    tapiRequestMediaCallW
+
+    lineAddProvider
+    lineAddProviderA
+    lineAddProviderW
+    lineConfigProvider
+    lineGetAppPriority
+    lineGetAppPriorityA
+    lineGetAppPriorityW
+    lineGetCountry
+    lineGetCountryA
+    lineGetCountryW
+    lineGetProviderList
+    lineGetProviderListA
+    lineGetProviderListW
+    lineRemoveProvider
+    lineSetAppPriority
+    lineSetAppPriorityA
+    lineSetAppPriorityW
+    lineTranslateDialog
+    lineTranslateDialogA
+    lineTranslateDialogW
+
+    lineAgentSpecific
+    lineGetAgentActivityListA
+    lineGetAgentActivityListW
+    lineGetAgentCapsA
+    lineGetAgentCapsW
+    lineGetAgentGroupListA
+    lineGetAgentGroupListW
+    lineGetAgentStatusA
+    lineGetAgentStatusW
+    lineProxyMessage
+    lineProxyResponse
+    lineSetAgentActivity
+    lineSetAgentGroup
+    lineSetAgentState
+    lineSetCallData
+    lineSetCallQualityOfService
+    lineSetCallTreatment
+    lineSetLineDevStatus
+
+    GetTapi16CallbackMsg
+    TAPIWndProc
+    TUISPIDLLCallback
+
+    LAddrParamsInited
+    LOpenDialAsst
+    LocWizardDlgProc
+
+
+
+
+          FDlgDriverList
+          FDlgAddDriver
+          FDlgAddUnlisted
+          
+          wsExistDlg
+          InsertDiskDlg
+          BrowseHookProc
+
+
+    internalNewLocationW
+    internalRemoveLocation
+    internalRenameLocationW
+    internalConfig
+
+    internalPerformance
diff --git a/private/tapi/dev/client/tapierr.mc b/private/tapi/dev/client/tapierr.mc
new file mode 100644
index 000000000..fd422679c
--- /dev/null
+++ b/private/tapi/dev/client/tapierr.mc
@@ -0,0 +1,742 @@
+; tapierr.mc - messages file for tapi
+;
+;  NOTE:  Whenever new error constants are added to TAPI
+;         new messages must be added here
+;
+;  CONVERSIONS:
+;
+;        TAPIERR : Negative numbers
+;            Map to : strip off high WORD
+;            Example: 0xFFFFFFFF (-1) becomes 0x0000FFFF
+;        LINEERR : Start at 0x80000000
+;            Map to : strip off 0x80000000 and add 0xE000
+;            Example: 0x80000004 becomes 0x0000E004
+;        PHONEERR: Start at 0x90000000
+;            Map to : strip off 0x90000000 and add 0xF000
+;            Example: 0x9000000A becomes 0x0000F00A
+
+
+MessageId=0xE000 SymbolicName=LINEERR_SUCCESS
+Language=English
+The operation completed successfully.
+.
+
+MessageId=0xE001 SymbolicName=LINEERR_ALLOCATED
+Language=English
+The line device is already in use
+.
+
+MessageId=0xE002 SymbolicName=LINEERR_BADDEVICEID
+Language=English
+Invalid line device ID
+.
+
+MessageId=0xE003 SymbolicName=LINEERR_BEARERMODEUNAVAIL
+Language=English
+The requested bearer mode is unavailable
+.
+
+MessageId=0xE005 SymbolicName=LINEERR_CALLUNAVAIL
+Language=English
+No call appearance available
+.
+
+MessageId=0xE006 SymbolicName=LINEERR_COMPLETIONOVERRUN
+Language=English
+Too many call completions outstanding
+.
+
+MessageId=0xE007 SymbolicName=LINEERR_CONFERENCEFULL
+Language=English
+The conference is full
+.
+
+MessageId=0xE008 SymbolicName=LINEERR_DIALBILLING
+Language=English
+The '$' dial modifier is not supported
+.
+
+MessageId=0xE009 SymbolicName=LINEERR_DIALDIALTONE
+Language=English
+The 'W' dial modifier is not supported
+.
+
+MessageId=0xE00A SymbolicName=LINEERR_DIALPROMPT
+Language=English
+The '?' dial modifier is not supported
+.
+
+MessageId=0xE00B SymbolicName=LINEERR_DIALQUIET
+Language=English
+The '@' dial modifier is not supported
+.
+
+MessageId=0xE00C SymbolicName=LINEERR_INCOMPATIBLEAPIVERSION
+Language=English
+Incompatible API version
+.
+
+MessageId=0xE00D SymbolicName=LINEERR_INCOMPATIBLEEXTVERSION
+Language=English
+Incompatible extension version
+.
+
+MessageId=0xE00E SymbolicName=LINEERR_INIFILECORRUPT
+Language=English
+The TAPI configuration information is unusable
+.
+
+MessageId=0xE00F SymbolicName=LINEERR_INUSE
+Language=English
+The line device is already in use
+.
+
+MessageId=0xE010 SymbolicName=LINEERR_INVALADDRESS
+Language=English
+The phone number is invalid or not properly formatted
+.
+
+MessageId=0xE011 SymbolicName=LINEERR_INVALADDRESSID
+Language=English
+Invalid address ID
+.
+
+MessageId=0xE012 SymbolicName=LINEERR_INVALADDRESSMODE
+Language=English
+Invalid address mode
+.
+
+MessageId=0xE013 SymbolicName=LINEERR_INVALADDRESSSTATE
+Language=English
+Operation not permitted in current address state
+.
+
+MessageId=0xE014 SymbolicName=LINEERR_INVALAPPHANDLE
+Language=English
+Invalid TAPI line application handle
+.
+
+MessageId=0xE015 SymbolicName=LINEERR_INVALAPPNAME
+Language=English
+Invalid application name
+.
+
+MessageId=0xE016 SymbolicName=LINEERR_INVALBEARERMODE
+Language=English
+Invalid bearer mode
+.
+
+MessageId=0xE017 SymbolicName=LINEERR_INVALCALLCOMPLMODE
+Language=English
+Invalid call completion mode
+.
+
+MessageId=0xE018 SymbolicName=LINEERR_INVALCALLHANDLE
+Language=English
+Invalid call handle
+.
+
+MessageId=0xE019 SymbolicName=LINEERR_INVALCALLPARAMS
+Language=English
+Invalid LINECALLPARAMS structure
+.
+
+MessageId=0xE01A SymbolicName=LINEERR_INVALCALLPRIVILEGE
+Language=English
+Invalid call privilege
+.
+
+MessageId=0xE01B SymbolicName=LINEERR_INVALCALLSELECT
+Language=English
+Invalid call select parameter
+.
+
+MessageId=0xE01C SymbolicName=LINEERR_INVALCALLSTATE
+Language=English
+Operation not permitted in current call state
+.
+
+MessageId=0xE01D SymbolicName=LINEERR_INVALCALLSTATELIST
+Language=English
+Invalid call state list
+.
+
+MessageId=0xE01E SymbolicName=LINEERR_INVALCARD
+Language=English
+Invalid calling card ID
+.
+
+MessageId=0xE01F SymbolicName=LINEERR_INVALCOMPLETIONID
+Language=English
+Invalid call completion ID
+.
+
+MessageId=0xE020 SymbolicName=LINEERR_INVALCONFCALLHANDLE
+Language=English
+Invalid conference call handle
+.
+
+MessageId=0xE021 SymbolicName=LINEERR_INVALCONSULTCALLHANDLE
+Language=English
+Invalid consultation call handle
+.
+
+MessageId=0xE022 SymbolicName=LINEERR_INVALCOUNTRYCODE
+Language=English
+Invalid country code
+.
+
+MessageId=0xE023 SymbolicName=LINEERR_INVALDEVICECLASS
+Language=English
+Invalid device class identifier
+.
+
+MessageId=0xE024 SymbolicName=LINEERR_INVALDEVICEHANDLE
+Language=English
+Invalid device handle
+.
+
+MessageId=0xE025 SymbolicName=LINEERR_INVALDIALPARAMS
+Language=English
+Invalid dialing parameters
+.
+
+MessageId=0xE026 SymbolicName=LINEERR_INVALDIGITLIST
+Language=English
+Invalid digit list
+.
+
+MessageId=0xE027 SymbolicName=LINEERR_INVALDIGITMODE
+Language=English
+Invalid digit mode
+.
+
+MessageId=0xE028 SymbolicName=LINEERR_INVALDIGITS
+Language=English
+Invalid digits
+.
+
+MessageId=0xE029 SymbolicName=LINEERR_INVALEXTVERSION
+Language=English
+Invalid extension version
+.
+
+MessageId=0xE02A SymbolicName=LINEERR_INVALGROUPID
+Language=English
+Invalid group pickup ID
+.
+
+MessageId=0xE02B SymbolicName=LINEERR_INVALLINEHANDLE
+Language=English
+Invalid line handle
+.
+
+MessageId=0xE02C SymbolicName=LINEERR_INVALLINESTATE
+Language=English
+Operation not permitted in current line state
+.
+
+MessageId=0xE02D SymbolicName=LINEERR_INVALLOCATION
+Language=English
+Invalid location ID
+.
+
+MessageId=0xE02E SymbolicName=LINEERR_INVALMEDIALIST
+Language=English
+Invalid media list
+.
+
+MessageId=0xE02F SymbolicName=LINEERR_INVALMEDIAMODE
+Language=English
+Invalid media mode
+.
+
+MessageId=0xE030 SymbolicName=LINEERR_INVALMESSAGEID
+Language=English
+Invalid message ID
+.
+
+MessageId=0xE032 SymbolicName=LINEERR_INVALPARAM
+Language=English
+Invalid parameter
+.
+
+MessageId=0xE033 SymbolicName=LINEERR_INVALPARKID
+Language=English
+Invalid park ID
+.
+
+MessageId=0xE034 SymbolicName=LINEERR_INVALPARKMODE
+Language=English
+Invalid park mode
+.
+
+MessageId=0xE035 SymbolicName=LINEERR_INVALPOINTER
+Language=English
+Invalid pointer
+.
+
+MessageId=0xE036 SymbolicName=LINEERR_INVALPRIVSELECT
+Language=English
+Invalid call privilege selection
+.
+
+MessageId=0xE037 SymbolicName=LINEERR_INVALRATE
+Language=English
+Invalid rate
+.
+
+MessageId=0xE038 SymbolicName=LINEERR_INVALREQUESTMODE
+Language=English
+Invalid request mode
+.
+
+MessageId=0xE039 SymbolicName=LINEERR_INVALTERMINALID
+Language=English
+Invalid terminal ID
+.
+
+MessageId=0xE03A SymbolicName=LINEERR_INVALTERMINALMODE
+Language=English
+Invalid terminal mode
+.
+
+MessageId=0xE03B SymbolicName=LINEERR_INVALTIMEOUT
+Language=English
+Invalid timeout value
+.
+
+MessageId=0xE03C SymbolicName=LINEERR_INVALTONE
+Language=English
+Invalid tone
+.
+
+MessageId=0xE03D SymbolicName=LINEERR_INVALTONELIST
+Language=English
+Invalid tone list
+.
+
+MessageId=0xE03E SymbolicName=LINEERR_INVALTONEMODE
+Language=English
+Invalid tone mode
+.
+
+MessageId=0xE03F SymbolicName=LINEERR_INVALTRANSFERMODE
+Language=English
+Invalid transfer mode
+.
+
+MessageId=0xE040 SymbolicName=LINEERR_LINEMAPPERFAILED
+Language=English
+No device matches the specified requirements
+.
+
+MessageId=0xE041 SymbolicName=LINEERR_NOCONFERENCE
+Language=English
+The call is not part of a conference
+.
+
+MessageId=0xE042 SymbolicName=LINEERR_NODEVICE
+Language=English
+The device was removed, or the device class is not recognized
+.
+
+MessageId=0xE043 SymbolicName=LINEERR_NODRIVER
+Language=English
+The service provider was removed
+.
+
+MessageId=0xE044 SymbolicName=LINEERR_NOMEM
+Language=English
+Insufficient memory available to complete the operation
+.
+
+MessageId=0xE045 SymbolicName=LINEERR_NOREQUEST
+Language=English
+No Assisted Telephony requests are pending
+.
+
+MessageId=0xE046 SymbolicName=LINEERR_NOTOWNER
+Language=English
+The application is does not have OWNER privilege on the call
+.
+
+MessageId=0xE047 SymbolicName=LINEERR_NOTREGISTERED
+Language=English
+The application is not registered to handle requests
+.
+
+MessageId=0xE048 SymbolicName=LINEERR_OPERATIONFAILED
+Language=English
+The operation failed for unspecified reasons
+.
+
+MessageId=0xE049 SymbolicName=LINEERR_OPERATIONUNAVAIL
+Language=English
+The operation is not supported by the underlying service provider
+.
+
+MessageId=0xE04A SymbolicName=LINEERR_RATEUNAVAIL
+Language=English
+The requested data rate is not available
+.
+
+MessageId=0xE04B SymbolicName=LINEERR_RESOURCEUNAVAIL
+Language=English
+A resource needed to fulfill the request is not available
+.
+
+MessageId=0xE04C SymbolicName=LINEERR_REQUESTOVERRUN
+Language=English
+The request queue is already full
+.
+
+MessageId=0xE04D SymbolicName=LINEERR_STRUCTURETOOSMALL
+Language=English
+The application failed to allocate sufficient memory for the minimum structure size
+.
+
+MessageId=0xE04E SymbolicName=LINEERR_TARGETNOTFOUND
+Language=English
+The call handoff failed because the specified target was not found
+.
+
+MessageId=0xE04F SymbolicName=LINEERR_TARGETSELF
+Language=English
+No higher priority target exists for the call handoff
+.
+
+MessageId=0xE050 SymbolicName=LINEERR_UNINITIALIZED
+Language=English
+The telephony service has not been initialized
+.
+
+MessageId=0xE051 SymbolicName=LINEERR_USERUSERINFOTOOBIG
+Language=English
+The amount of user-user info exceeds the maximum permitted
+.
+
+MessageId=0xE052 SymbolicName=LINEERR_REINIT
+Language=English
+The operation cannot be completed until all TAPI applications call lineShutdown
+.
+
+MessageId=0xE053 SymbolicName=LINEERR_ADDRESSBLOCKED
+Language=English
+You are not permitted to call this number
+.
+
+MessageId=0xE054 SymbolicName=LINEERR_BILLINGREJECTED
+Language=English
+The calling card number or other billing information was rejected
+.
+
+MessageId=0xE055 SymbolicName=LINEERR_INVALFEATURE
+Language=English
+Invalid device-specific feature
+.
+
+MessageId=0xE056 SymbolicName=LINEERR_NOMULTIPLEINSTANCE
+Language=English
+You cannot have two instances of the same service provider
+.
+
+MessageId=0xE057 SymbolicName=LINEERR_INVALAGENTID
+Language=English
+Invalid agent ID
+.
+
+MessageId=0xE058 SymbolicName=LINEERR_INVALAGENTGROUP
+Language=English
+Invalid agent group
+.
+
+MessageId=0xE059 SymbolicName=LINEERR_INVALPASSWORD
+Language=English
+Invalid agent password
+.
+
+MessageId=0xE05A SymbolicName=LINEERR_INVALAGENTSTATE
+Language=English
+Invalid agent state
+.
+
+MessageId=0xE05B SymbolicName=LINEERR_INVALAGENTACTIVITY
+Language=English
+Invalid agent activity
+.
+
+MessageId=0xE05C SymbolicName=LINEERR_DIALVOICEDETECT
+Language=English
+The ':' dial modifier is not supported
+.
+
+MessageId=0xF000 SymbolicName=PHONEERR_SUCCESS
+Language=English
+The operation completed successfully
+.
+
+MessageId=0xF001 SymbolicName=PHONEERR_ALLOCATED
+Language=English
+The phone device is already in use
+.
+
+MessageId=0xF002 SymbolicName=PHONEERR_BADDEVICEID
+Language=English
+Invalid phone device ID
+.
+
+MessageId=0xF003 SymbolicName=PHONEERR_INCOMPATIBLEAPIVERSION
+Language=English
+Incompatible API version
+.
+
+MessageId=0xF004 SymbolicName=PHONEERR_INCOMPATIBLEEXTVERSION
+Language=English
+Incompatible extension version
+.
+
+MessageId=0xF005 SymbolicName=PHONEERR_INIFILECORRUPT
+Language=English
+The TAPI configuration information is unusable
+.
+
+MessageId=0xF006 SymbolicName=PHONEERR_INUSE
+Language=English
+The phone device is already in use
+.
+
+MessageId=0xF007 SymbolicName=PHONEERR_INVALAPPHANDLE
+Language=English
+Invalid TAPI phone application handle
+.
+
+MessageId=0xF008 SymbolicName=PHONEERR_INVALAPPNAME
+Language=English
+Invalid application name
+.
+
+MessageId=0xF009 SymbolicName=PHONEERR_INVALBUTTONLAMPID
+Language=English
+Invalid button or lamp ID
+.
+
+MessageId=0xF00A SymbolicName=PHONEERR_INVALBUTTONMODE
+Language=English
+Invalid button mode
+.
+
+MessageId=0xF00B SymbolicName=PHONEERR_INVALBUTTONSTATE
+Language=English
+Invalid button state
+.
+
+MessageId=0xF00C SymbolicName=PHONEERR_INVALDATAID
+Language=English
+Invalid data segment ID
+.
+
+MessageId=0xF00D SymbolicName=PHONEERR_INVALDEVICECLASS
+Language=English
+Invalid device class identifier
+.
+
+MessageId=0xF00E SymbolicName=PHONEERR_INVALEXTVERSION
+Language=English
+Invalid extension version
+.
+
+MessageId=0xF00F SymbolicName=PHONEERR_INVALHOOKSWITCHDEV
+Language=English
+Invalid hookswitch device ID
+.
+
+MessageId=0xF010 SymbolicName=PHONEERR_INVALHOOKSWITCHMODE
+Language=English
+Invalid hookswitch mode
+.
+
+MessageId=0xF011 SymbolicName=PHONEERR_INVALLAMPMODE
+Language=English
+Invalid lamp mode
+.
+
+MessageId=0xF012 SymbolicName=PHONEERR_INVALPARAM
+Language=English
+Invalid parameter
+.
+
+MessageId=0xF013 SymbolicName=PHONEERR_INVALPHONEHANDLE
+Language=English
+Invalid phone handle
+.
+
+MessageId=0xF014 SymbolicName=PHONEERR_INVALPHONESTATE
+Language=English
+Operation not permitted in current phone state
+.
+
+MessageId=0xF015 SymbolicName=PHONEERR_INVALPOINTER
+Language=English
+Invalid pointer
+.
+
+MessageId=0xF016 SymbolicName=PHONEERR_INVALPRIVILEGE
+Language=English
+Invalid privilege
+.
+
+MessageId=0xF017 SymbolicName=PHONEERR_INVALRINGMODE
+Language=English
+Invalid ring mode
+.
+
+MessageId=0xF018 SymbolicName=PHONEERR_NODEVICE
+Language=English
+The device was removed, or the device class is not recognized
+.
+
+MessageId=0xF019 SymbolicName=PHONEERR_NODRIVER
+Language=English
+The service provider was removed
+.
+
+MessageId=0xF01A SymbolicName=PHONEERR_NOMEM
+Language=English
+Insufficient memory available to complete the operation
+.
+
+MessageId=0xF01B SymbolicName=PHONEERR_NOTOWNER
+Language=English
+The application is does not have OWNER privilege on the phone
+.
+
+MessageId=0xF01C SymbolicName=PHONEERR_OPERATIONFAILED
+Language=English
+The operation failed for unspecified reasons
+.
+
+MessageId=0xF01D SymbolicName=PHONEERR_OPERATIONUNAVAIL
+Language=English
+The operation is not supported by the underlying service provider
+.
+
+MessageId=0xF01F SymbolicName=PHONEERR_RESOURCEUNAVAIL
+Language=English
+A resource needed to fulfill the request is not available
+.
+
+MessageId=0xF020 SymbolicName=PHONEERR_REQUESTOVERRUN
+Language=English
+The request queue is already full
+.
+
+MessageId=0xF021 SymbolicName=PHONEERR_STRUCTURETOOSMALL
+Language=English
+The application failed to allocate sufficient memory for the minimum structure size
+.
+
+MessageId=0xF022 SymbolicName=PHONEERR_UNINITIALIZED
+Language=English
+The telephony service has not been initialized
+.
+
+MessageId=0xF023 SymbolicName=PHONEERR_REINIT
+Language=English
+The operation cannot be completed until all TAPI applications call phoneShutdown
+.
+
+MessageId=0 SymbolicName=TAPIERR_CONNECTED
+Language=English
+The request was accepted
+.
+
+MessageId=0xFFFF SymbolicName=TAPIERR_DROPPED
+Language=English
+The call was disconnected
+.
+
+MessageId=0xFFFE SymbolicName=TAPIERR_NOREQUESTRECIPIENT
+Language=English
+No program is available to handle the request
+.
+
+MessageId=0xFFFD SymbolicName=TAPIERR_REQUESTQUEUEFULL
+Language=English
+The queue of call requests is full
+.
+
+MessageId=0xFFFC SymbolicName=TAPIERR_INVALDESTADDRESS
+Language=English
+The phone number is invalid or improperly formatted
+.
+
+MessageId=0xFFFB SymbolicName=TAPIERR_INVALWINDOWHANDLE
+Language=English
+Invalid window handle
+.
+
+MessageId=0xFFFA SymbolicName=TAPIERR_INVALDEVICECLASS
+Language=English
+Invalid device class
+.
+
+MessageId=0xFFF9 SymbolicName=TAPIERR_INVALDEVICEID
+Language=English
+Invalid device ID
+.
+
+MessageId=0xFFF8 SymbolicName=TAPIERR_DEVICECLASSUNAVAIL
+Language=English
+The device class is unavailable
+.
+
+MessageId=0xFFF7 SymbolicName=TAPIERR_DEVICEIDUNAVAIL
+Language=English
+The specified device is unavailable
+.
+
+MessageId=0xFFF6 SymbolicName=TAPIERR_DEVICEINUSE
+Language=English
+The device is already in use
+.
+
+MessageId=0xFFF5 SymbolicName=TAPIERR_DESTBUSY
+Language=English
+The called number is busy
+.
+
+MessageId=0xFFF4 SymbolicName=TAPIERR_DESTNOANSWER
+Language=English
+The called party does not answer
+.
+
+MessageId=0xFFF3 SymbolicName=TAPIERR_DESTUNAVAIL
+Language=English
+The called number could not be reached
+.
+
+MessageId=0xFFF2 SymbolicName=TAPIERR_UNKNOWNWINHANDLE
+Language=English
+Unknown window handle
+.
+
+MessageId=0xFFF1 SymbolicName=TAPIERR_UNKNOWNREQUESTID
+Language=English
+Unknown request ID
+.
+
+MessageId=0xFFF0 SymbolicName=TAPIERR_REQUESTFAILED
+Language=English
+The request failed for unspecified reasons
+.
+
+MessageId=0xFFEF SymbolicName=TAPIERR_REQUESTCANCELLED
+Language=English
+The request was cancelled
+.
+
+MessageId=0xFFEE SymbolicName=TAPIERR_INVALPOINTER
+Language=English
+Invalid pointer
+.
diff --git a/private/tapi/dev/client/tapini.rc b/private/tapi/dev/client/tapini.rc
new file mode 100644
index 000000000..cf4c63a91
--- /dev/null
+++ b/private/tapi/dev/client/tapini.rc
@@ -0,0 +1,33 @@
+//
+// (c) 1995 Microsoft Corporation.  Portions Copyright Intel/Microsoft 1992-93.  All Rights Reserved."
+//
+
+STRINGTABLE DISCARDABLE
+BEGIN
+RC_CARD_ID_BASE +  0   "23"
+RC_CARD_ID_BASE +  1   "0,""None (Direct Dial)"","""","""","""","""",1\0"
+RC_CARD_ID_BASE +  2   "1,""AT&T Direct Dial via 10ATT1"","""",""G"",""102881FG"",""10288011EFG"",1\0"
+RC_CARD_ID_BASE +  3   "2,""AT&T via 10ATT0"","""",""G"",""102880FG$TH"",""1028801EFG$TH"",1\0"
+RC_CARD_ID_BASE +  4   "3,""AT&T via 1-800-321-0288"","""",""G"",""18003210288$TFG$TH"",""18003210288$T01EFG$TH"",1\0"
+RC_CARD_ID_BASE +  5   "4,""MCI Direct Dial via 102221"","""",""G"",""102221FG"",""10222011EFG"",1\0"
+RC_CARD_ID_BASE +  6   "5,""MCI via 102220"","""",""G"",""102220FG$TH"",""1022201EFG$TH"",1\0"
+RC_CARD_ID_BASE +  7   "6,""MCI via 1-800-888-8000"","""",""G"",""18008888000,,,,,,TH,,FG"",""18008888000,,,,,,TH,,011EFG"",1\0"
+RC_CARD_ID_BASE +  8   "7,""MCI via 1-800-674-0700"","""",""G"",""18006740700,,,,,,TH,,FG"",""18006740700,,,,,,TH,,011EFG"",1\0"
+RC_CARD_ID_BASE +  9   "8,""MCI via 1-800-674-7000"","""",""G"",""18006747000,,,,,,TH,,FG"",""18006747000,,,,,,TH,,011EFG"",1\0"
+RC_CARD_ID_BASE + 10   "9,""US Sprint Direct Dial via 103331"","""",""G"",""103331FG"",""10333011EFG"",1\0"
+RC_CARD_ID_BASE + 11   "10,""US Sprint via 103330"","""",""G"",""103330FG$TH"",""1033301EFG$TH"",1\0"
+RC_CARD_ID_BASE + 12   "11,""US Sprint via 1-800-877-8000"","""",""G"",""18008778000,,,T0FG,,H"",""18008778000,,,T01EFG#,H"",1\0"
+RC_CARD_ID_BASE + 13   "12,""Calling Card via 0"","""",""G"",""0FG$TH"",""01EFG$TH"",1\0"
+
+RC_CARD_ID_BASE + 14   "13,""Carte France Telecom"","""",""T3610,H,G#"",""T3610,H,16,FG#"",""T3610,H,19,EFG#"",1\0"
+RC_CARD_ID_BASE + 15   "14,""Mercury (UK)"","""",""0500800800$TH,0FG"",""0500800800$TH,0FG"",""0500800800$TH,0FG"",1"
+RC_CARD_ID_BASE + 16   "15,""British Telecom (UK)"","""",""144$H,0FG"",""144$H,0FG"",""144$H,010EFG"",1\0"
+RC_CARD_ID_BASE + 17   "16,""CLEAR Communications (New Zealand)"","""",""0502333$TH,0FG"",""0502333$TH,0FG"",""0502333$TH,00EFG"",1\0"
+RC_CARD_ID_BASE + 18   "17,""Telecom New Zealand"","""",""012,0FG?H"",""012,0FG?H"",""012,00EFG?H"",1\0"
+RC_CARD_ID_BASE + 19   "18,""Global Card (Taiwan to USA)"","""",""G"",""0FG"",""0080,102880$TFG$H"",1\0"
+RC_CARD_ID_BASE + 20   "19,""Telecom Australia via 1818 (voice)"","""",""1818$TH,FG#"",""1818$TH,FG#"",""1818$TH,0011EFG#"",1\0"
+RC_CARD_ID_BASE + 21   "20,""Telecom Australia via 1818 (fax)"","""",""1818$TH,FG#"",""1818$TH,FG#"",""1818$TH,0015EFG#"",1\0"
+RC_CARD_ID_BASE + 22   "21,""Optus (Australia) via 1812"","""",""FG"",""FG"",""1812@TH,0011EFG"",1\0"
+RC_CARD_ID_BASE + 23   "22,""Optus (Australia) via 008551812"","""",""FG"",""FG"",""008551812@TH,0011EFG"",1\0"
+END
+
diff --git a/private/tapi/dev/client/unitest/depend.mk b/private/tapi/dev/client/unitest/depend.mk
new file mode 100644
index 000000000..729fa050a
--- /dev/null
+++ b/private/tapi/dev/client/unitest/depend.mk
@@ -0,0 +1 @@
+.\unitest.obj: ..\unitest.c ..\unitest.h ..\resource.h
diff --git a/private/tapi/dev/client/unitest/makefile b/private/tapi/dev/client/unitest/makefile
new file mode 100644
index 000000000..31081c457
--- /dev/null
+++ b/private/tapi/dev/client/unitest/makefile
@@ -0,0 +1,23 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/client/unitest/makefile.def b/private/tapi/dev/client/unitest/makefile.def
new file mode 100644
index 000000000..bdfd8be0b
--- /dev/null
+++ b/private/tapi/dev/client/unitest/makefile.def
@@ -0,0 +1,37 @@
+!ifdef WIN32
+all: cleanit unit32.exe
+!else
+all: cleanit unitest.exe
+!endif
+
+
+!ifdef WIN32
+APP_compile = -c -Zpie -W2 -Od /Fc
+!else
+APP_compile = -c -AM -Gw -Zpie -W2 -Od /Fc
+!endif
+APP_link = /CO /NOD /NOE
+
+unitest.obj: $*.c $*.h
+     cl $(APP_compile) $*.c
+
+unitest.res: $*.rc $*.h
+     rc -r $*.rc
+
+
+!ifdef WIN32
+unit32.exe: unitest.obj unit32.def unitest.res
+     link /DEF:unit32.def /MAP /MACHINE:IX86 /SUBSYSTEM:Windows /Defaultlib:user32.lib,gdi32.lib,tapi32.lib  unitest.obj unitest.res
+!else
+unitest.exe: unitest.obj unitest.def unitest.res
+     link $(APP_link) $*, $*, $*/map/li /align:16, libw ..\tapi.lib mlibcew, $*.def
+!endif
+     rc unitest.res
+     mapsym $*
+
+
+
+cleanit:
+     del unitest.obj
+     del unitest.res
+
diff --git a/private/tapi/dev/client/unitest/resource.h b/private/tapi/dev/client/unitest/resource.h
new file mode 100644
index 000000000..17cfe015f
--- /dev/null
+++ b/private/tapi/dev/client/unitest/resource.h
@@ -0,0 +1,16 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by initTEST.RC
+//
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/client/unitest/sources b/private/tapi/dev/client/unitest/sources
new file mode 100644
index 000000000..57b3518ff
--- /dev/null
+++ b/private/tapi/dev/client/unitest/sources
@@ -0,0 +1,28 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=unit32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMENTRY =winmain
+
+USE_CRTDLL=1
+
+SOURCES=unitest.c   \
+        unitest.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/client/unitest/unit32.def b/private/tapi/dev/client/unitest/unit32.def
new file mode 100644
index 000000000..53c13f0c4
--- /dev/null
+++ b/private/tapi/dev/client/unitest/unit32.def
@@ -0,0 +1,13 @@
+NAME         unit32
+
+DESCRIPTION  'Microsoft Windows Unicode TAPI Tests'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/dev/client/unitest/unitest.c b/private/tapi/dev/client/unitest/unitest.c
new file mode 100644
index 000000000..a20bfe251
--- /dev/null
+++ b/private/tapi/dev/client/unitest/unitest.c
@@ -0,0 +1,613 @@
+/****************************************************************************
+
+    PROGRAM:  UniTest.c
+
+    PURPOSE:   
+
+    FUNCTIONS:
+
+         WinMain() - calls uniialization function, processes message loop
+         MainWndProc() - processes messages
+         About() - processes messages for "About" dialog box
+         UniApplication() - uniializes window data and registers window
+         UniInstance() - saves instance handle and creates main window
+         TestProc1() - First test procedure.
+         TestProc2() - Second test procedure.
+         TestProc3() - Third test procedure
+         TestProc4() - Fourth test procedure
+       TestCase() runs a single test case
+
+****************************************************************************/
+
+#include "windows.h"
+#include <tapi.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "unitest.h"
+
+
+
+#ifndef WIN32
+#define MoveToEx( hdc, x, y, z )   MoveTo( hdc, x, y )
+#endif
+
+
+
+//void FAR _cdecl _DebugOutput( UINT flags, LPCSTR lpszFmt, ... );
+
+
+int PASCAL WinMain( HINSTANCE, HINSTANCE, LPSTR, int );
+//long FAR PASCAL MainWndProc( HWND, unsigned, WORD, LONG );
+LRESULT CALLBACK MainWndProc( HWND, UINT, WPARAM, LPARAM );
+BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );
+static BOOL UniApplication( HANDLE );
+static BOOL UniInstance( HANDLE, int );
+long TestCase ( BOOL );
+
+
+long   NumOfDevices;
+HANDLE ghInstance;
+static HANDLE hInst;
+static HWND   hwnd;            /* handle to main window */
+static BOOL Bailout = FALSE;
+
+
+HLINEAPP ghLineApp = NULL;
+
+
+
+//****************************************************************************
+//****************************************************************************
+#define RandomNumber(min,max) ((UINT) ( (long)rand()*(max-min) / (long)RAND_MAX ) + min)
+
+
+
+/***********************************************************************/
+/***********************************************************************/
+VOID CALLBACK FAR PASCAL MyCallback( HANDLE hDevice,
+                                       DWORD  dwMsg,
+                                       DWORD  dwCallbackInstance,
+                                       DWORD  dwParam1,
+                                       DWORD  dwParam2,
+                                       DWORD  dwParam3 )
+{
+    return;
+}
+
+
+/****************************************************************************
+
+    FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
+
+    PURPOSE: calls uniialization function, processes message loop
+
+****************************************************************************/
+
+int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                    LPSTR lpCmdLine,  int nCmdShow)
+    {
+    MSG msg;
+    DWORD dwNumDevs;
+    
+    
+    //* Save a copy of the hInstance
+   ghInstance = hInstance;
+    
+    if (hPrevInstance == 0)
+        if (UniApplication(hInstance) == 0)
+        {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "uniapp failed Lasterr=0x%08lx", err);
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                        "Error",
+                        MB_OK
+                      );
+            return (FALSE);
+        }
+
+    if (UniInstance(hInstance, nCmdShow) == 0)
+    {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "uniapp failed Lasterr=0x%08lx", err );
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                    "Error",
+                    MB_OK
+                  );
+        return (FALSE);
+    }
+
+
+  
+
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+        {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        }
+
+
+  
+    return (msg.wParam);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: UniApplication(HANDLE)
+
+    PURPOSE: Uniializes window data and registers window class
+
+****************************************************************************/
+
+static BOOL UniApplication(HANDLE hInstance)
+    {
+    WNDCLASS  wc;
+    char      szMenu[26], szClass[26];
+
+    LoadString (hInstance, ID_MENUSTR, szMenu, sizeof (szMenu));
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+
+    wc.style          = 0;
+    wc.lpfnWndProc    = MainWndProc;
+    wc.cbClsExtra     = 0;
+    wc.cbWndExtra     = 0;
+    wc.hInstance      = hInstance;
+    wc.hIcon          = LoadIcon(0, IDI_APPLICATION);
+    wc.hCursor        = LoadCursor(0, IDC_ARROW);
+    wc.hbrBackground  = GetStockObject(WHITE_BRUSH);
+    wc.lpszMenuName   = (LPSTR)szMenu;
+    wc.lpszClassName  = (LPSTR)szClass;
+
+    return (RegisterClass(&wc));
+    }
+
+
+/****************************************************************************
+
+    FUNCTION:  UniInstance(HANDLE, int)
+
+    PURPOSE:  Saves instance handle and creates main window
+
+****************************************************************************/
+
+static BOOL UniInstance(HANDLE hInstance, int nCmdShow)
+    {
+    char szClass[16], szTitle[40];
+
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+    LoadString (hInstance, ID_CAPTIONSTR, szTitle, sizeof (szTitle));
+
+    hInst = hInstance;
+
+    hwnd = CreateWindow(
+             szClass,
+             szTitle,
+             WS_OVERLAPPEDWINDOW,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             280,
+             70,
+             0,
+             0,
+             hInstance,
+             0 );
+
+    if (hwnd == 0 )
+        return ( FALSE );
+
+    ShowWindow(hwnd, nCmdShow);
+    UpdateWindow(hwnd);
+    return (TRUE);
+    }
+
+
+
+
+
+
+
+
+
+void WriteNums( HWND hWnd, DWORD dwPass, DWORD NumDevices)
+{
+   char szOutput[100];
+   int len;
+   HDC hdc;
+
+   len = wsprintf( szOutput, 
+#ifdef WIN32
+   "I32-%08ld Devs:%03d"
+#else
+   "I16-%08ld Devs:%03d"
+#endif
+   ,dwPass,NumDevices);
+
+   hdc = GetDC( hWnd );
+
+   MoveToEx( hdc, 10, 10, NULL );
+
+   TextOut( hdc, 0, 0, szOutput, len );
+
+   ReleaseDC( hWnd, hdc );
+
+   SetWindowText( hWnd, szOutput );
+
+   return;
+}
+
+
+
+
+
+
+
+
+
+
+
+/****************************************************************************
+
+    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages
+
+    MESSAGES:
+
+        WM_COMMAND    - application menu (About dialog box)
+        WM_DESTROY    - destroy window
+
+    COMMENTS:
+
+
+****************************************************************************/
+
+LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,
+                              WPARAM wParam, LPARAM lParam)
+{
+
+    FARPROC  lpProcAbout;
+    char szDlgBox[9], szMsgBoxCap[12], szStatus1[14], szStatus2[14];
+
+    char szAddress[20];
+    WORD uUniPrefix;
+    DWORD n;
+    MSG localmsg;
+
+
+
+    LoadString (hInst, ID_DLGBOX, szDlgBox, sizeof (szDlgBox));
+    LoadString (hInst, ID_MSGBOXCAP, szMsgBoxCap, sizeof (szMsgBoxCap));
+    LoadString (hInst, ID_STATUS1, szStatus1, sizeof (szStatus1));
+    LoadString (hInst, ID_STATUS2, szStatus2, sizeof (szStatus2));
+
+    switch ( message )
+        {
+        case WM_COMMAND:
+            switch ( wParam )
+                {
+                case IDM_ABOUT:
+//                    lpProcAbout = MakeProcInstance( About, hInst );
+                    DialogBox(hInst, szDlgBox, hWnd, (DLGPROC)About);
+//                    FreeProcInstance( lpProcAbout );
+                    break;
+
+
+                case IDM_STOPTEST:
+                    Bailout = TRUE;
+                    break;
+
+
+                case IDM_TEST1:
+                case IDM_TEST2:
+                case IDM_TEST5:
+                case IDM_TESTA:
+                {
+//DebugBreak();
+                   lineTranslateDialog(
+                                        NULL,
+                                        0,
+                                        0x00020000,
+                                        hWnd,
+                                        "+1 (206) 936-2446"
+                                      );
+/*
+                   lineTranslateDialogA(
+                                        NULL,
+                                        0,
+                                        0x00020000,
+                                        hWnd,
+                                        "+1 (206) 936-2446"
+                                      );
+                   lineTranslateDialogW(
+                                        NULL,
+                                        0,
+                                        0x00020000,
+                                        hWnd,
+                                        L"+1 (206) 936-2446"
+                                      );
+*/
+                }
+                break;
+
+
+                case IDM_TESTB:
+                {
+                   CHAR szCountryCode[8];
+                   CHAR szCityCode[8];
+                   WCHAR szCountryCodeW[8];
+                   WCHAR szCityCodeW[8];
+
+//DebugBreak();
+                   tapiGetLocationInfo( szCountryCode, szCityCode );
+/*
+                   tapiGetLocationInfoA( szCountryCode, szCityCode );
+
+                   tapiGetLocationInfoW( szCountryCodeW, szCityCodeW );
+*/
+                }
+                break;
+
+
+                case IDM_TESTC:
+                   {
+                      HLINEAPP hLineApp;
+
+                      lineInitialize(
+                                                 &hLineApp,
+                                                 ghInstance,
+                                                 (LINECALLBACK)&MyCallback,
+                                                 "UniTEST",
+                                                 &NumOfDevices
+                                               );
+/*
+//DebugBreak();
+                      lineSetTollList(
+                                       hLineApp,
+                                       0,
+                                       "+1 (206) 935-2446",
+                                       LINETOLLLISTOPTION_ADD
+                                     );
+
+                      lineSetTollListA(
+                                       hLineApp,
+                                       0,
+                                       "+1 (206) 936-2446",
+                                       LINETOLLLISTOPTION_ADD
+                                     );
+
+                      lineShutdown( hLineApp );
+
+
+                      lineInitializeW(
+                                                 &hLineApp,
+                                                 ghInstance,
+                                                 (LINECALLBACK)&MyCallback,
+                                                 L"UniTEST",
+                                                 &NumOfDevices
+                                               );
+
+                      lineSetTollListW(
+                                       hLineApp,
+                                       0,
+                                       L"+1 (206) 937-2446",
+                                       LINETOLLLISTOPTION_ADD
+                                     );
+*/
+                      lineShutdown( hLineApp );
+
+                   }
+                   break;
+
+
+                case IDM_TESTD:
+                {
+                   CHAR szOut[8];
+                   WCHAR szIn[8] = L"AB\0CD\0E";
+
+DebugBreak();
+                   WideCharToMultiByte(
+                       GetACP(),
+                       0,
+                       szIn,
+                       lstrlenW(szIn) + 1,
+                       szOut,
+                       lstrlenW(szIn) + 1,
+                       NULL,
+                       NULL
+                       );
+
+                }
+                break;
+
+
+                case IDM_TESTE:
+                   {
+                      HLINEAPP hLineApp;
+                      LPLINEDEVCAPS pLineDevCaps;
+
+                      lineInitialize(
+                                                 &hLineApp,
+                                                 ghInstance,
+                                                 (LINECALLBACK)&MyCallback,
+                                                 "UniTEST",
+                                                 &NumOfDevices
+                                               );
+
+//                      lineOpen(
+//                                hLineApp,
+//                                0, 
+//                                &hLine,
+//                                0x00020000,
+//                                0,
+//                                MyCallback,
+//                                LINECALLPRIVILEGE_OWNER,
+//                                LINEMEDIAMODE_INTERACTIVEVOICE,
+//                                NULL
+//                              );
+
+DebugBreak();
+                      pLineDevCaps = LocalAlloc( LPTR, 4096 );
+
+                      pLineDevCaps->dwTotalSize = 4096;
+
+                      lineGetDevCapsW( hLineApp,
+                                      0,
+                                      0x00020000,
+                                      0,
+                                      pLineDevCaps
+                                    );
+
+                      lineShutdown( hLineApp );
+
+                   }
+                   break;
+
+
+                }//*switch
+            break;
+
+        case WM_DESTROY:
+
+            Bailout = TRUE;
+
+            PostQuitMessage(0);
+            break;
+
+        default:
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+        }
+    return (FALSE);
+}
+
+
+/****************************************************************************
+
+    FUNCTION: About(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages for "About" dialog box
+
+    MESSAGES:
+
+        WM_UniDIALOG - uniialize dialog box
+        WM_COMMAND    - Input received
+
+****************************************************************************/
+
+BOOL FAR PASCAL About(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
+    {
+    switch (message)
+        {
+        case WM_INITDIALOG:
+            return (TRUE);
+
+        case WM_COMMAND:
+            if (wParam == IDOK || wParam == IDCANCEL)
+                {
+                EndDialog(hDlg, TRUE);
+                return (TRUE);
+                }
+            break;
+        }
+    return (FALSE);
+    }
+
+
+//*************************************************
+//* Run the TestCase once per call.
+//* Case currently consists of :
+//* 
+//*   lineInitialize
+//*   lineOpen   
+//* lineClose
+//* lineShutdown
+//*************************************************
+long TestCase ( BOOL fOpenLines )
+{
+   long result       = 0L;
+   long errcode       = 0L;
+   HLINEAPP hLineApp    = 0L;
+//   DWORD   deviceID    = 0L;
+   LONG   deviceID    = 0L;
+   char   errstr[256];
+   HLINE   lineArray[30];   
+
+//* LineInitialize 
+
+   errcode =  lineInitialize(&hLineApp, ghInstance, (LINECALLBACK)&MyCallback, "UniTEST", &NumOfDevices);
+   if (errcode != 0L)
+   {
+      result = errcode;
+      sprintf( errstr,"lineInitialize Failed   error=0x%lx",errcode );
+      MessageBox(GetFocus(), errstr, "Error", MB_OK);
+      Bailout = TRUE;
+      goto cleanup;                 
+   }
+
+
+   if ( fOpenLines )
+   {
+
+//* Open all devices
+
+      for (deviceID = 0; deviceID < NumOfDevices; deviceID++ )
+      {
+             lineArray[deviceID] = 0L;
+
+            errcode =  lineOpen(hLineApp, deviceID, &lineArray[deviceID], 
+                           0x00010003,0L,0,LINECALLPRIVILEGE_NONE,0L,NULL);
+
+            if (errcode != 0L)
+            {
+               sprintf( errstr,"lineOpen Failed   device#= 0x%08lx error=0x%lx",deviceID, errcode );
+               MessageBox(GetFocus(), errstr, "Error", MB_OK);
+               Bailout = TRUE;
+            }
+      
+      }
+
+//* Close all open devices
+      for (;deviceID >= 1L;deviceID--)
+      {
+         errcode = lineClose(lineArray[deviceID-1]);
+         if (errcode != 0L)
+         {
+            sprintf( errstr,"lineClose Failed   error=0x%lx",errcode );
+            MessageBox(GetFocus(), errstr, "Error", MB_OK);
+            Bailout = TRUE;
+         }
+      }
+   }
+
+
+//* LineShutdown
+   errcode =  lineShutdown(hLineApp);
+   if (errcode != 0L)
+   {
+      result = errcode;
+
+      sprintf( errstr,"lineShutdown Failed   error=0x%lx",errcode );
+
+      MessageBox(GetFocus(), errstr, "Error", MB_OK);
+
+      Bailout = TRUE;
+
+      goto cleanup;
+   }
+
+cleanup:
+   return(result);   
+
+}
diff --git a/private/tapi/dev/client/unitest/unitest.def b/private/tapi/dev/client/unitest/unitest.def
new file mode 100644
index 000000000..2fda2769d
--- /dev/null
+++ b/private/tapi/dev/client/unitest/unitest.def
@@ -0,0 +1,20 @@
+NAME         unitest
+
+DESCRIPTION  'Microsoft Windows Unicode TAPI tests'
+
+EXETYPE      WINDOWS
+
+STUB         'WINSTUB.EXE'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     4024
+STACKSIZE    12120
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/dev/client/unitest/unitest.h b/private/tapi/dev/client/unitest/unitest.h
new file mode 100644
index 000000000..18acb2cc0
--- /dev/null
+++ b/private/tapi/dev/client/unitest/unitest.h
@@ -0,0 +1,30 @@
+#if !defined(tolltest_h)
+#define tolltest_h
+
+#define IDM_ABOUT     101
+
+#define IDM_TEST1     201
+#define IDM_TEST2     202
+#define IDM_TEST3     203
+#define IDM_TEST4     204
+#define IDM_TEST5     205
+
+#define IDM_TESTA     210
+#define IDM_TESTB     211
+#define IDM_TESTC     212
+#define IDM_TESTD     213
+#define IDM_TESTE     214
+#define IDM_TESTF     215
+
+#define IDM_STOPTEST  230
+
+#define ID_MENUSTR      301
+#define ID_CLASSSTR     302
+#define ID_CAPTIONSTR   303
+#define ID_DLGBOX       304
+#define ID_MSGBOXCAP    305
+#define ID_STATUS1      306
+#define ID_STATUS2      307
+#define ID_STATUS3      308
+
+#endif
diff --git a/private/tapi/dev/client/unitest/unitest.rc b/private/tapi/dev/client/unitest/unitest.rc
new file mode 100644
index 000000000..b25e7305a
--- /dev/null
+++ b/private/tapi/dev/client/unitest/unitest.rc
@@ -0,0 +1,122 @@
+//Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#define APSTUDIO_HIDDEN_SYMBOLS
+#include "windows.h"
+#undef APSTUDIO_HIDDEN_SYMBOLS
+#include "Unitest.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+UniTESTMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "& Uni&open Tests"
+    BEGIN
+        MENUITEM "Test &1 - 32000 Uni/open && close/Shutdown operations", IDM_TEST1
+        MENUITEM "Test &2 - 100 Uni/open && close/Shutdown operations", IDM_TEST2
+        MENUITEM "Test &3 - InfUnie Uni/open && close/Shutdown operations", IDM_TEST5
+        MENUITEM SEPARATOR
+        MENUITEM "About &Sample ...",           IDM_ABOUT
+    END
+    POPUP "& Unicode calls"
+    BEGIN
+        MENUITEM "Test &A - lineTranslateDialogW", IDM_TESTA
+        MENUITEM "Test &B - tapiGetLocationInfoW", IDM_TESTB
+        MENUITEM "Test &C - lineSetTollListW (and lineInitW)", IDM_TESTC
+        MENUITEM "Test &D - WideCharToMultiByte", IDM_TESTD
+        MENUITEM "Test &E - lineGetDevCaps", IDM_TESTE
+    END
+    MENUITEM "&Stop test...",               IDM_STOPTEST
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+ABOUTBOX DIALOG DISCARDABLE  22, 17, 144, 75
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About UniTest"
+BEGIN
+    CTEXT           "Microsoft Windows TAPI UniTest Thingy",-1,0,5,144,8
+    CTEXT           "Version 0.1",-1,0,34,144,8
+    DEFPUSHBUTTON   "OK",IDOK,53,59,32,14,WS_GROUP
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""windows.h""\r\n"
+    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""Unitest.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_MENUSTR              "UniTestMenu"
+    ID_CLASSSTR             "UniTestClass"
+    ID_CAPTIONSTR           "Microsoft Windows Telephony UniList Test thingy"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_DLGBOX               "AboutBox"
+    ID_MSGBOXCAP            "UniList Test"
+    ID_STATUS1              "Entering Test"
+    ID_STATUS2              "Test Failed !"
+    ID_STATUS3              "Test Successful !"
+END
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/private/tapi/dev/cpl.new/debug.c b/private/tapi/dev/cpl.new/debug.c
new file mode 100644
index 000000000..ebac4f75f
--- /dev/null
+++ b/private/tapi/dev/cpl.new/debug.c
@@ -0,0 +1,129 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include  <tapi.h>                  
+#include "debug.h"
+
+
+
+
+DWORD   gdwDebugLevel;
+
+
+static char szNewBuff[256];
+
+
+DWORD TapiCplDebugLevel = 0;
+static fTapiCplDebugLevelValid = FALSE;
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+
+{
+   char    buf[128] = "TAPICPL: ";
+// *** *** ***   static char szFilename[] = filename;
+   if (!fTapiCplDebugLevelValid)
+   {
+
+        {
+            HKEY  hKey;
+
+
+            TapiCplDebugLevel=0;
+
+            if (RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKey
+
+                    ) == ERROR_SUCCESS)
+            {
+                DWORD dwDataSize = sizeof(DWORD), dwDataType;
+
+                RegQueryValueEx(
+                    hKey,
+                    "TelephonDebugLevel",
+                    0,
+                    &dwDataType,
+                    (LPBYTE)&TapiCplDebugLevel,
+                    &dwDataSize
+                    );
+
+                RegCloseKey (hKey);
+            }
+        }
+
+
+      if ( TapiCplDebugLevel > 0 )
+      {
+         wsprintf(
+                   &buf[9],
+                   "TapiCplDebugLevel= %d\n\r",
+                   TapiCplDebugLevel);
+
+         OutputDebugString((LPSTR)buf);
+
+
+      }
+
+      fTapiCplDebugLevelValid = TRUE;
+   }
+
+
+   //
+   // Is the message otherwise "low" enough to display?
+   //
+    if (dwDbgLevel <= TapiCplDebugLevel)
+    {
+        char    buf[128] = "TAPICPL: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[9],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugString(buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+
+
+#endif
diff --git a/private/tapi/dev/cpl.new/debug.h b/private/tapi/dev/cpl.new/debug.h
new file mode 100644
index 000000000..cd9ea2591
--- /dev/null
+++ b/private/tapi/dev/cpl.new/debug.h
@@ -0,0 +1,25 @@
+#if DBG
+
+
+#if !WIN32
+#define IN
+#define PUCHAR char *
+#endif
+
+
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/cpl.new/depend.mk b/private/tapi/dev/cpl.new/depend.mk
new file mode 100644
index 000000000..0b5db6aec
--- /dev/null
+++ b/private/tapi/dev/cpl.new/depend.mk
@@ -0,0 +1,5 @@
+.\telephon.obj: ..\telephon.c ..\resource.h
+
+.\debug.obj: ..\debug.c ..\debug.h
+
+.\telephon.res: ..\telephon.rc ..\resource.h
diff --git a/private/tapi/dev/cpl.new/makefile b/private/tapi/dev/cpl.new/makefile
new file mode 100644
index 000000000..68867704a
--- /dev/null
+++ b/private/tapi/dev/cpl.new/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/cpl.new/makefile.def b/private/tapi/dev/cpl.new/makefile.def
new file mode 100644
index 000000000..f2286b664
--- /dev/null
+++ b/private/tapi/dev/cpl.new/makefile.def
@@ -0,0 +1,67 @@
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+
+WANT_C1032=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+BUILDDLL=1
+DLLENTRY=DllEntryPoint
+
+CLEANLIST=*.cpl
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=telephon.cpl telephon.sym
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+
+L32EXE=telephon.cpl		# Name of exe.
+L32DEF=..\telephon.def              # Our def file.
+L32MAP=telephon.map		# Our map file.
+L32SYM=telephon.sym		# Our sym file.
+L32LIBS=\
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+!IF "$(VERDIR)" == "debug"
+         $(W32LIBID)\advapi32.lib                \
+!endif
+        ..\..\lib\tapi32.lib
+
+#        $(ROOT)\dev\tools\c932\lib\msvcrt.lib   \
+#        $(W32LIBID)\version.lib                 \
+#        $(W32LIBID)\lz32.lib                    \
+#        $(W32LIBID)\comdlg32.lib                \
+#        $(W32LIBID)\comctl32.lib                \
+#        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+
+L32RES=telephon.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = telephon.obj debug.obj
+
+L32FLAGS=$(L32FLAGS) -MAP
+
+
+!include $(ROOT)\dev\master.mk
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Og
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/cpl.new/resource.h b/private/tapi/dev/cpl.new/resource.h
new file mode 100644
index 000000000..e6d33aa56
--- /dev/null
+++ b/private/tapi/dev/cpl.new/resource.h
@@ -0,0 +1,4 @@
+#define IDS_SHORTNAME       0x200
+#define IDS_DESCRIPTION     0x201
+
+#define IDI_TELEPHONICON    0x202
diff --git a/private/tapi/dev/cpl.new/sources b/private/tapi/dev/cpl.new/sources
new file mode 100644
index 000000000..826537c72
--- /dev/null
+++ b/private/tapi/dev/cpl.new/sources
@@ -0,0 +1,65 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=telephon
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=cpl
+
+TARGETLIBS=\
+           $(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+!if 0
+//           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+//           $(BASEDIR)\public\sdk\lib\*\version.lib  \
+//           $(BASEDIR)\public\sdk\lib\*\lz32.lib     \
+//           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+//           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+!endif
+
+DLLBASE=0x60000000
+
+USE_CRTDLL=1
+
+C_DEFINES=-DWINVER=0x400
+
+SOURCES=\
+        telephon.c \
+        debug.c \
+        telephon.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllEntryPoint
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/cpl.new/telephon.c b/private/tapi/dev/cpl.new/telephon.c
new file mode 100644
index 000000000..46efe4479
--- /dev/null
+++ b/private/tapi/dev/cpl.new/telephon.c
@@ -0,0 +1,197 @@
+#include  <windows.h>
+#include  <windowsx.h>
+#include  <tapi.h>
+#include  <cpl.h>
+
+#include  "resource.h"
+#include  "debug.h"
+
+
+
+//***************************************************************************
+HINSTANCE ghInst;
+
+DWORD WINAPI internalConfig(HWND);
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+VOID PASCAL TapiCallbackProc( DWORD hDevice, DWORD dwMsg, DWORD dwCallbackInstance,
+                  DWORD dwParam1, DWORD dwParam2, DWORD dwParam3 )
+{
+   //As if we care...
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+#if WIN32
+ APIENTRY
+#else
+ EXPORT  
+#endif
+CPlApplet(  HWND   hWnd,
+            UINT   uMessage,
+            LPARAM lParam1,
+            LPARAM lParam2 )
+{
+   LPCPLINFO   lpCplInfo;
+   LPNEWCPLINFO   lpNewCplInfo;
+   LONG lResult = 0;
+
+//DBGOUT((0, "Got here, eh?"));
+
+   switch ( uMessage ) 
+   {
+      case CPL_INIT:
+          DBGOUT((10, "CPL_INIT"));
+          lResult = 1;
+          break;
+
+
+      case CPL_GETCOUNT:
+          DBGOUT((10, "CPL_GETCOUNT - returning 1"));
+          // return the number of applets supported
+          lResult = 1;
+          break;
+
+
+      case CPL_INQUIRE:       
+         DBGOUT((10, "CPL_INQUIRE"));
+
+         lpCplInfo  = (LPCPLINFO)lParam2;
+
+         lpCplInfo->idIcon = IDI_TELEPHONICON;
+         lpCplInfo->idName = IDS_SHORTNAME;
+         lpCplInfo->idInfo = IDS_DESCRIPTION;
+         lpCplInfo->lData  = 0;
+        
+         lResult = TRUE;
+
+         break;
+
+
+      case CPL_NEWINQUIRE:
+      {
+         TCHAR buf[64];
+
+         DBGOUT((10, "CPL_NEWINQUIRE"));
+
+         lpNewCplInfo  = (LPNEWCPLINFO)lParam2;
+        
+         lpNewCplInfo->dwSize        = sizeof(NEWCPLINFO);
+         lpNewCplInfo->dwFlags       = 0;
+         lpNewCplInfo->dwHelpContext = 0;
+         lpNewCplInfo->lData         = 0;
+         lpNewCplInfo->hIcon = LoadIcon( ghInst, MAKEINTRESOURCE(IDI_TELEPHONICON) );
+
+//DBGOUT((0, "hIcon = 0x%08lx", (DWORD)lpNewCplInfo->hIcon));
+
+         LoadString( ghInst, IDS_SHORTNAME, buf, sizeof(buf) );
+         lstrcpy( lpNewCplInfo->szName, buf );
+
+         LoadString( ghInst, IDS_DESCRIPTION, buf, sizeof(buf) );
+         lstrcpy( lpNewCplInfo->szInfo, buf );
+
+         lstrcpy (lpNewCplInfo->szHelpFile, "");
+         
+         lResult = TRUE;
+
+         break;
+      }
+     
+
+      case CPL_DBLCLK: 
+          DBGOUT((10, "CPL_DBLCLK"));
+
+                      {
+                      HLINEAPP hLineApp;
+                      DWORD dwNumDevs;
+
+#define TAPI_API_VERSION 0x00020000
+
+                      lineInitialize( &hLineApp,
+                                      ghInst,
+                                      TapiCallbackProc,
+                                      "Telephony Control Panel",
+                                      &dwNumDevs
+                                    );
+
+//                      lineTranslateDialog(hLineApp, 0, TAPI_API_VERSION, hWnd, NULL);
+                      internalConfig(hWnd);
+
+                      lineShutdown( hLineApp );
+                      }
+
+          break;
+
+
+#if DBG
+      case CPL_SELECT: 
+          DBGOUT((10, "CPL_SELECT"));
+          // application selected, who cares...
+          break;
+
+
+      case CPL_STOP: 
+          DBGOUT((10, "CPL_STOP"));
+          // sent once per app before CPL_EXIT
+          break;
+
+
+      case CPL_EXIT: 
+          DBGOUT((10, "CPL_EXIT"));
+          // sent once before FreeLibrary called
+          break;
+#endif
+
+
+      default:
+          break;
+
+   }
+      
+
+   return( lResult );
+}
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+#if WIN32
+BOOL WINAPI DllEntryPoint( HINSTANCE hInstance,
+                             DWORD dwReason,
+                             LPVOID lpReserved )
+{
+   switch (dwReason)
+      {
+      case DLL_PROCESS_ATTACH:
+          ghInst     = hInstance;
+          break;
+
+      case DLL_PROCESS_DETACH:
+         break;
+      }
+
+   return( TRUE );
+}
+
+//***************************************************************************
+#else
+
+int FAR PASCAL LibMain( HINSTANCE   hInstance, 
+                        UINT        uDataSeg, 
+                        UINT        cbHeapSize, 
+                        LPSTR       lpszCmdLine )
+{
+   ghInst     = hInstance;
+
+   return( TRUE );
+}
+
+#endif
diff --git a/private/tapi/dev/cpl.new/telephon.def b/private/tapi/dev/cpl.new/telephon.def
new file mode 100644
index 000000000..b4d936dd0
--- /dev/null
+++ b/private/tapi/dev/cpl.new/telephon.def
@@ -0,0 +1,6 @@
+LIBRARY   TELEPHON
+CODE      PRELOAD MOVEABLE DISCARDABLE
+DATA      PRELOAD MOVEABLE SINGLE
+HEAPSIZE  512
+EXPORTS   
+          CPlApplet        @1
diff --git a/private/tapi/dev/cpl.new/telephon.ico b/private/tapi/dev/cpl.new/telephon.ico
new file mode 100644
index 000000000..003323ef6
--- /dev/null
+++ b/private/tapi/dev/cpl.new/telephon.ico
diff --git a/private/tapi/dev/cpl.new/telephon.rc b/private/tapi/dev/cpl.new/telephon.rc
new file mode 100644
index 000000000..755e00ca6
--- /dev/null
+++ b/private/tapi/dev/cpl.new/telephon.rc
@@ -0,0 +1,33 @@
+#include  <windows.h>
+#include "resource.h"
+
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_SHORTNAME        "Telephony"
+    IDS_DESCRIPTION      "Configure Telephony Drivers and Dialing Properties"
+END
+
+
+#if WINNT
+IDI_TELEPHONICON           ICON    DISCARDABLE     "TELEPHON.ICO"
+#else
+IDI_TELEPHONICON           ICON    DISCARDABLE     "..\\TELEPHON.ICO"
+#endif
+
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony Control Panel"
+#define VER_INTERNALNAME_STR        "telephon.cpl"
+#define VER_ORIGINALFILENAME_STR    "TELEPHON.CPL"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/cpl/copy.c b/private/tapi/dev/cpl/copy.c
new file mode 100644
index 000000000..dcf54471e
--- /dev/null
+++ b/private/tapi/dev/cpl/copy.c
@@ -0,0 +1,1078 @@
+/*
+ *  copy.c - Copy routine for WinDosSetup
+ *  Todd Laney
+ *
+ *  Modification History:
+ *
+ *  6/03/91 Vlads        Change copy process to incorporate new Install API
+ *
+ *  3/24/89  Toddla      Wrote it
+ *
+ *
+ *  notes:
+ *   we now use the LZCopy stuff so COMPRESS is NOT defined
+ *   we now set the crit error handler ourselves so CHECKFLOPPY is
+ *   NOT defined
+ */
+
+#include <windows.h>
+#include <mmsystem.h>
+
+#ifdef NT_INST
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#include <lzexpand.h>
+#include "sulib.h"
+#include "externs.h"
+
+#include "debug.h"
+
+
+typedef struct
+{
+	LPSTR   lpVersionNew;
+	LPSTR   lpVersionOld;
+	char    szFileName[13], szNewFileName[13];
+	char    szPathExisting[128];
+	DWORD   dwErrorFlags;
+} DOUBLE_VERINF, FAR *PDOUBLE_VERINF;
+
+
+#define VIF_SRCSAME             0x00080000L // michaele added (see instfile.c)
+
+#define MAX_COPY_ATTEMPTS  15
+
+#ifndef _WIN32
+#pragma code_seg ( "DRIVERS" )
+#endif
+
+// Local function prototypes.
+
+WORD NEAR PASCAL ConvertFlagToValue(DWORD dwFlags);
+
+#ifdef CHECK_FLOPPY
+BOOL NEAR IsDiskInDrive(int iDisk);
+#endif
+
+extern char FAR szDisks[];          // from drivers.c
+extern char FAR szOemDisks[];
+
+// Global vars in drv.c
+
+
+void FAR PASCAL fartonear(LPSTR dst, LPSTR src)
+{
+   while (*src)
+      *dst++ = *src++;
+
+   *dst = 0;
+}
+
+BOOL FAR PASCAL DefCopyCallback(int msg, int n, LPSTR szFile)
+{
+    return FC_IGNORE;
+}
+
+
+/*
+ *
+ *  This function will copy a group of files to a single destination
+ *
+ *  ENTRY:
+ *
+ *  szSourc      : pointer to a SETUP.INF section
+ *  szDest       : pointer to a string containing the target DIR
+ *  fpfnCopy     : callback function used to notify called of copy status
+ *  fCopy        : flags
+ *
+ *      FC_SECTION            - szSource is a section name
+ *      FC_LIST               - szSource is a pointer to a char **foo;
+ *      FC_LISTTYPE           - szSource is a pointer to a char *foo[];
+ *      FC_FILE               - szSource is a file name.
+ *      FC_QUALIFIED          - szSource is a fully qualified file name.
+ *      FC_DEST_QUALIFIED     - szDir is fully qualified. Don't expand this.
+ *      FC_CALLBACK_WITH_VER  - call back if file exists and report version information.
+ *
+ *  NOTES:
+ *      if szSource points to a string of the form '#name' the section
+ *      named by 'name' will be used as the source files
+ *
+ *      the first field of each line in the secion is used as the name of the
+ *      source file.  A file name has the following form:
+ *
+ *          #:name
+ *
+ *          #       - Disk number containing file 1-9,A-Z
+ *          name    - name of the file, may be a wild card expression
+ *
+ *  Format for copy status function
+ *
+ *  BOOL FAR PASCAL CopyStatus(int msg, int n, LPSTR szFile)
+ *
+ *      msg:
+ *          COPY_ERROR          error occured while copying file(s)
+ *                              n      is the DOS error number
+ *                              szFile is the file that got the error
+ *                              return: TRUE ok, FALSE abort copy
+ *
+ *          COPY_STATUS         Called each time a new file is copied
+ *                              n      is the percent done
+ *                              szFile is the file being copied
+ *                              return: TRUE ok, FALSE abort copy
+ *
+ *          COPY_INSERTDISK     Please tell the user to insert a disk
+ *                              n      is the disk needed ('1' - '9')
+ *                              return: TRUE try again, FALSE abort copy
+ *
+ *          COPY_QUERYCOPY      Should this file be copied?
+ *                              n      line index in SETUP.INF section (0 based)
+ *                              szFile is the line from section
+ *                              return: TRUE copy it, FALSE dont copy
+ *
+ *          COPY_START          Sent before any files are copied
+ *
+ *          COPY_END            Sent after all files have been copied
+ *                              n   is dos error if copy failed
+ *
+ *          COPY_EXISTS         Sent if the FC_CALL_ON_EXIST bit was set
+ *                              and the file exists at the destination
+ *                              given for the filecopy.
+ *
+ *
+ *  EXIT: returns TRUE if successful, FALSE if failure.
+ *
+ */
+
+WORD FAR PASCAL FileCopy(LPSTR szSource, LPSTR szDir, FPFNCOPY fpfnCopy, WORD fCopy)
+{
+   int   err = ERROR_OK;
+   char  szFile[15];
+   char  szPath[MAXPATHLEN+15];
+   char  szLogSrc[MAXPATHLEN];
+//   char  szSrcBase[15];
+   char  szSrc[MAXPATHLEN];
+   char  szErrFile[MAXPATHLEN+15];
+   LPSTR pFile;
+   LPSTR pFileBegin;
+   LPSTR (far * List);
+   LPSTR (far * ListHead) = NULL;
+   BOOL  fDoCopy;
+   BOOL  bRetVal;
+   BOOL  bCallOnExist = FALSE;
+   BOOL  bWindowsDir = FALSE;
+   int   n = 0;
+   int   nDisk;
+   char  cDisk;
+   int   cntFiles = 0, iOffset = 0 ;
+   char  szTempFile[MAX_FILE_SPEC];
+   int    iAttemptCount;
+   UINT   uTmpLen; 
+
+   DOUBLE_VERINF Ver;
+   WORD   wVerFlags;
+   DWORD  dwRetFlags, dwVerLen, dwVerHandle, dwVerHandle1 ;
+   LPSTR  lpVerExisting, lpVerNew = NULL;
+
+   if (fpfnCopy == NULL)
+      fpfnCopy = DefCopyCallback;
+
+   if (!szSource || !*szSource || !szDir || !*szDir)
+      return FALSE;
+
+   /*
+    *  fix up the drive in the destination
+    */
+
+   if (fCopy & FC_DEST_QUALIFIED) {
+      lstrcpy(szPath, szDir);
+      fCopy &= ~FC_DEST_QUALIFIED;
+   } else
+      ExpandFileName(szDir, szPath);
+
+
+   /*
+    *  Handle the "Call back on file existance" flag.
+    */
+
+   if ( fCopy & FC_CALLBACK_WITH_VER )
+      {
+      bCallOnExist = TRUE;
+      fCopy &= ~FC_CALLBACK_WITH_VER;
+      }
+
+   if (szSource[0] == '#' && fCopy == FC_FILE)
+      {
+      fCopy = FC_SECTION;
+      ++szSource;
+      }
+
+   switch (fCopy)
+      {
+    case FC_SECTION:
+       {
+       char buf[40];
+
+       fartonear(buf, szSource);
+       szSource = infFindSection(NULL,buf);
+       if (szSource == NULL)
+          goto exit;
+
+       fCopy = FC_LIST;
+       }
+       // fall through to FC_LIST
+
+    case FC_LIST:
+       pFileBegin = szSource;
+       cntFiles = infLineCount(szSource);
+       break;
+
+    case FC_LISTTYPE:
+       ListHead = List = (LPSTR far *)szSource;
+       pFile = pFileBegin = *ListHead;
+       while ( *List++ )           // Count files to be copied.
+          ++cntFiles;
+       break;
+
+    case FC_FILE:
+    case FC_QUALIFIED:
+    default:
+       pFileBegin = szSource;
+       cntFiles = 1;
+      }
+
+   /*
+    *  walk all files in the list and call DosCopy ....
+    *
+    *  NOTES:
+    *      we must walk file list sorted by disk number.
+    *      we should use the disk that is currently inserted.
+    *      we should do a find first/find next on the files????
+    *      we need to check for errors.
+    *      we need to ask the user to insert disk in drive.
+    *
+    */
+   (*fpfnCopy)(COPY_START,0,NULL);
+
+   // Go through all possible disks: 1 to 9 (9) and A to Z (26)
+   for (nDisk = 1; (cntFiles > 0) && (nDisk <= 35); nDisk++)
+   {
+      cDisk      = CHDISK(nDisk);
+      pFile      = pFileBegin;
+      List       = ListHead;
+      n          = 0;
+
+      while (pFile)
+      {
+    /*
+     *  should we copy this file?
+     *  copy the files in disk order.
+     */
+    fDoCopy = pFile[1] == ':' && UPCASE(cDisk) == UPCASE(pFile[0]&0x7f) ||
+         pFile[1] != ':' && nDisk == 1 && *pFile ||
+         fCopy == FC_QUALIFIED;
+
+    if (fDoCopy)
+       cntFiles--;         // done with a file. decrement count.
+
+    if (fDoCopy)
+       {
+       if (pFile[1] == ':')                    
+         lstrcpy(szDrv, &pFile[2]);
+       else
+         lstrcpy(szDrv, pFile);                
+       switch ((*fpfnCopy)(COPY_QUERYCOPY,n, pFile))
+       {
+          case -1: 
+             goto nextfile;                          
+          case 0: 
+             err = ERROR_50; // File already exists
+             goto exit;
+
+          default:
+             break;
+      
+       }
+       // We have to reset high bit of first byte because it could be set
+       // by translating service in OEM setup to show that file name was mapped
+       *pFile&=0x7f;
+
+
+       // now we convert logical dest into a physical 
+       //   (unless FC_QUALIFIED)
+
+       infParseField(pFile, 1, szLogSrc);  // logical source
+       if ( fCopy != FC_QUALIFIED )
+          ExpandFileName(szLogSrc, szSrc); // full physical source
+       else
+          lstrcpy(szSrc, szLogSrc);
+
+       // Create file name from current string 
+       lstrcpy(szFile, FileName(szSrc));
+       StripPathName(szSrc);
+
+    // Installation operation using Version API.
+    // To avoid infinite looping I now perform installation of each 
+    // file in for loop .
+
+    wVerFlags = 0;
+
+    for(iAttemptCount=0; iAttemptCount<=MAX_COPY_ATTEMPTS;iAttemptCount++)
+      {
+
+    tryagain:
+       // Central operation - attempt to install file szFile in directory
+       // pointed by szPath from directory pointed by szSrc
+       // If operation will fail but with possibility to force install
+       // in last parameter buffer we will have temporary file name ==>
+       // therefore we can avoid excessive copying.
+       // NOTE: now szFile consists of only file name and other buffers
+       // only path names.
+
+       uTmpLen = MAX_FILE_SPEC - 1 ;
+       dwRetFlags = VerInstallFile(wVerFlags,
+                (LPSTR) szFile,(LPSTR) szFile,
+                (LPSTR) szSrc,
+                (LPSTR) szPath,
+                (LPSTR) szPath,
+                (LPSTR) szTempFile, (LPUINT) &uTmpLen);
+
+       // Operation failed if at least one bit of return flags is non-zero
+       // That is unusual but defined so in Version API.
+
+       if ( !dwRetFlags )
+      break;                    // If no errors - goto next file
+
+
+       // If flag MISMATCH is set - install can be forced and we have 
+       // temporary file in destination subdirectory
+
+       if ( dwRetFlags  &  VIF_MISMATCH )
+         {
+          if ( bCallOnExist )
+      {
+
+       // Now we have two files in app directory - old and temporary.
+       // We can fill out double version info structure to pass it
+       // to call back function
+
+       lstrcpy(Ver.szFileName,szFile);
+       lstrcpy(Ver.szPathExisting, szPath);
+       lstrcpy(Ver.szNewFileName, szTempFile);
+       Ver.dwErrorFlags = dwRetFlags;
+
+       lstrcpy(szErrFile, szPath);
+       catpath(szErrFile, szFile);
+
+       lpVerExisting = NULL;
+       dwVerLen = GetFileVersionInfoSize((LPSTR) szErrFile,
+                     (DWORD FAR *) &dwVerHandle);
+       if ( dwVerLen )
+        {
+          lpVerExisting = FALLOC(LOWORD(dwVerLen));
+   
+          if ( GetFileVersionInfo((LPSTR) szErrFile, dwVerHandle,
+                  dwVerLen,
+                  lpVerExisting ) )
+          Ver.lpVersionOld = lpVerExisting;
+        }
+
+
+        Ver.lpVersionNew = NULL;
+
+        if ( dwRetFlags & VIF_TEMPFILE )
+          {
+
+            lstrcpy(szErrFile, szPath);
+            catpath(szErrFile, szTempFile);
+            lpVerNew = NULL;
+
+            dwVerLen = GetFileVersionInfoSize((LPSTR) szErrFile,
+                     (DWORD FAR *) &dwVerHandle1);
+            if ( dwVerLen )
+           {
+             lpVerNew = FALLOC(LOWORD(dwVerLen));
+   
+              if ( GetFileVersionInfo((LPSTR) szErrFile,
+                  dwVerHandle1,
+                  dwVerLen,
+                  lpVerNew ) )
+            Ver.lpVersionNew = lpVerNew;
+            }
+
+
+          }
+
+          bRetVal = (*fpfnCopy)(COPY_EXISTS,wVerFlags, (LPSTR) &Ver);
+         
+          if ( lpVerNew)
+             FFREE(lpVerNew);
+          if ( lpVerExisting )
+             FFREE(lpVerExisting);
+
+          if ( !bRetVal )
+         {
+
+           // If callback returns FALSE - delete temporary file
+           // and not install FORCEINSTALL flag. Break here works to
+           // go out from attempting loop.
+
+//           DosDelete(szErrFile); 
+           DeleteFile(szErrFile); 
+           break;
+         }
+
+      }  /* End of if CallOnExist */
+
+          else if ( dwRetFlags & (VIF_SRCOLD | VIF_SRCSAME) ) {
+
+       // If we need not call back with question - automatically
+       // force install with same parameters.
+       // michaele, *only* if src file is *newer* than dst file
+       lstrcpy(szErrFile, szPath);
+       catpath(szErrFile, szTempFile);
+//       DosDelete(szErrFile); 
+       DeleteFile(szErrFile); 
+       break;
+      }
+
+          // If we need not call back with question - automatically
+          // force install with same parameters.
+
+          wVerFlags |= VIFF_FORCEINSTALL;
+          continue;
+
+         }   /* End if MISMATCH */
+
+
+
+        // If source path or file is nor readable - try to change disk
+
+#ifdef MESGBOX               
+          if (bRetry && (dwRetFlags & VIF_CANNOTREADSRC))
+          {
+       char szOut[70];    
+      
+       bRetry = FALSE;
+       wsprintf(szOut, szFind, (LPSTR)szFile); 
+       MessageBox(hMesgBoxParent, szOut, szFileError, MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);          
+          }
+
+#endif         
+
+          if ( dwRetFlags & VIF_CANNOTREADSRC )
+          {
+        // Now new path in szSrc so I deleted logic for creating it
+
+        if (szLogSrc[1] != ':')
+           // if disk # not provided, default to 1
+           bRetVal = (*fpfnCopy)(COPY_INSERTDISK, '1', szSrc);
+        else
+           bRetVal = (*fpfnCopy)(COPY_INSERTDISK, szLogSrc[0], szSrc);
+
+        switch (bRetVal)
+           {
+           case FC_RETRY:
+              bRetry = TRUE;
+              goto tryagain;         // and try again...
+
+           case FC_ABORT:
+         err = ERROR_NOFILES;
+         goto exit;
+
+           case FC_IGNORE:
+         break;
+           }
+        }
+ 
+          // If real error occured - call back with error file info
+          // In all dialogs we use our error codes - so I will convert
+          // flags returned from Ver API to ours.
+   
+          err = ConvertFlagToValue(dwRetFlags);
+
+          ExpandFileName(szLogSrc, szErrFile);
+
+
+//             lstrcpy(szErrFile,szPath);
+//             catpath(szErrFile, szSrcBase);
+          if (!bWindowsDir  && (err != FC_ERROR_LOADED_DRIVER) 
+             && (err != ERROR_DISKFULL))
+          {
+         GetWindowsDirectory(szPath, sizeof (szPath));
+         bWindowsDir = TRUE;
+         goto tryagain;
+          }
+
+          bRetVal = (*fpfnCopy)(COPY_ERROR, err, szErrFile);
+ 
+          if ( bRetVal == FC_IGNORE)
+        break;
+          else
+       if ( bRetVal == FC_RETRY )
+           goto tryagain;
+          else
+       if ( bRetVal ==  FC_ABORT )
+         {
+           err = ERROR_NOFILES;
+           goto exit;
+         }
+        }  /* End for ATTEMPTS */
+
+
+      if ((*fpfnCopy)(COPY_STATUS,100,pFile) == FC_ABORT)
+      goto exit;
+
+
+     }   /* End if dor if DoCopy */
+    /*
+     * Move on to next file in the list
+     */
+nextfile:         
+    err = ERROR_OK;
+    n++;
+    if ( fCopy == FC_LISTTYPE )
+       pFile = *(++List);
+    else if (fCopy == FC_LIST)
+       pFile = infNextLine(pFile);
+    else
+       pFile = NULL;
+      }
+   }
+
+   err = ERROR_OK;
+exit:
+
+   (*fpfnCopy)(COPY_END,err,NULL);
+
+   return err;
+}
+
+
+LPSTR GetExtension(LPSTR szFile)
+{
+   LPSTR ptr;
+
+   for (ptr = szFile; *ptr && *ptr != '.'; ptr++);
+
+   if (*ptr != '.')
+      return NULL;
+   else
+      return ptr+1;
+
+}
+
+VOID GetCompressedName(LPSTR szComp, LPSTR szSrc)
+{
+   LPSTR ptr;
+
+   lstrcpy(szComp, szSrc);
+   
+   ptr = GetExtension(szComp);
+   if ( ptr )
+      szComp[lstrlen(szComp)-1] = '_';
+   else
+      lstrcat(szComp,"._");
+}
+
+/*  int FAR PASCAL DosCopy(LPSTR szSrc, LPSTR szPath)
+ *
+ *  Copy the file specifed by szSrc to the drive and directory
+ *  specifed by szPath
+ *
+ *  ENTRY:
+ *      szSrc   - File name to copy from
+ *      szPath  - directory to copy to
+ *
+ *  RETURNS:
+ *      0 - no error, else dos error code
+ *
+ */
+int FAR PASCAL DosCopy(LPSTR szSrc, LPSTR szPath)
+{
+#if WIN32
+   WIN32_FIND_DATA FindFileData;
+   HANDLE          FindFileHandle;
+#else
+   FCB         fcb;
+#endif
+   int         fhSrc,fhDst;
+   char        szFile[MAXPATHLEN];
+   char        szComp[MAXPATHLEN];
+   int         f = ERROR_OK;
+   long        l;
+   BOOL        bCompressedName;
+    
+
+#ifdef DEBUG
+
+   if (infGetProfileString(NULL,"setup","copy",szFile) && szFile[0] == 'f')
+      return ERROR_OK;
+
+#endif
+
+
+#ifdef CHECK_FLOPPY
+
+   if (!IsDiskInDrive(szSrc[0]))
+      {
+      f = ERROR_FILENOTFOUND;
+      goto errfree;
+      }
+
+#endif
+
+
+   // allows both compressed and non-compressed filenames on the disks
+
+   GetCompressedName(szComp, szSrc);
+
+#if WIN32
+   if ( FindFileHandle = FindFirstFile(szComp, &FindFileData))
+#else
+   if ( DosFindFirst(&fcb, szComp, ATTR_FILES))
+#endif
+      bCompressedName = TRUE;
+   else
+      {
+      bCompressedName = FALSE;
+#if WIN32
+      if ( INVALID_HANDLE_VALUE == (FindFileHandle = FindFirstFile(szSrc, &FindFileData)))
+#else
+      if (!DosFindFirst(&fcb, szSrc, ATTR_FILES))
+#endif
+    {
+    f = ERROR_FILENOTFOUND;
+    goto errfree;
+    }
+      }
+
+   /*
+    * copy every file that matches the file pattern passed in.
+    */
+   do
+      {
+      /*
+       * create the source file name from the source path and the file
+       * name that DosFindFirst/Next found
+       */
+      lstrcpy(szFile,szSrc);
+      StripPathName(szFile);
+#if WIN32
+      catpath(szFile,FindFileData.cFileName);
+#else
+      catpath(szFile,fcb.szName);
+#endif
+
+      fhSrc = FOPEN(szFile);
+
+      if (fhSrc == -1)
+    {
+    f = FERROR();
+    goto errfree;
+    }
+
+      /*
+       * create the destination file name from the dest path and the file
+       * name that DosFindFirst/Next found
+       */
+      lstrcpy(szFile,szPath);
+
+      // don't support wildcards for compressed files
+
+      if (bCompressedName)
+    catpath(szFile,FileName(szSrc));
+      else
+#if WIN32
+    catpath(szFile,FindFileData.cFileName);   // used name from fcb
+#else
+    catpath(szFile,fcb.szName);   // used name from fcb
+#endif
+
+#if WIN32
+      fhDst = _lopen(szFile,OF_WRITE + OF_SHARE_EXCLUSIVE);
+#else
+      fhDst = fnCarefullyOpenNewFile(szFile,NORMAL_5BH);
+#endif
+
+      if (fhDst < 0)
+    {
+    f = fhDst;
+    goto errclose1;
+    }
+
+
+  {
+#if 1
+    int (FAR WINAPI *lpfnLZCopy)(INT, INT);
+//    FARPROC   lpfnLZCopy;
+    HINSTANCE hInstLZ;
+
+    // use LZ stuff
+
+    hInstLZ = LoadLibrary("LZ32.DLL");
+
+    if ( NULL == hInstLZ )
+    {
+       DBGOUT((0, "LoadLibrary('LZ32.DLL') failed! err=0x%08lx", GetLastError() ));
+       f = ERROR_READ;
+       goto errclose1;
+    }
+
+    lpfnLZCopy = (int (FAR WINAPI *)(INT, INT))GetProcAddress( hInstLZ, "LZCopy" );
+
+
+    // translate LZERROR_ returns (all < 0) to DOS errors
+
+    if ((l = lpfnLZCopy(fhSrc, fhDst)) < 0)
+    {
+
+    // was this a dos error?
+
+    if (FERROR() != 0)
+       f = FERROR();
+    else
+       {
+       // translate LZ error codes to DOS errors
+
+       switch ((int)l)
+          {
+          case LZERROR_BADINHANDLE:
+          case LZERROR_READ:
+        f = ERROR_READ;
+        break;
+
+          case LZERROR_BADOUTHANDLE:
+          case LZERROR_WRITE:
+        f = ERROR_WRITE;
+        break;
+
+          case LZERROR_GLOBALLOC:
+          case LZERROR_GLOBLOCK:
+        f = ERROR_NOMEMORY;
+        break;
+
+          case LZERROR_BADVALUE:
+        f = ERROR_16;
+        break;
+
+          case LZERROR_UNKNOWNALG:
+        f = ERROR_FORMATBAD;
+        break;
+          }
+       }
+    }
+
+#else
+      // our own copy stuff
+
+      while (size = FREAD(fhSrc,lpBuf,nBufSize))
+    {
+    if (FWRITE(fhDst,lpBuf,size) != size)
+       {
+       /* write error? */
+       f = FERROR();
+       if (f == ERROR_OK)
+          f = ERROR_WRITE;
+       goto errclose;
+       }
+    }
+
+      /* Restore date of written file */
+      _dos_setftime(fhDst,date,time);
+
+#endif
+
+      FWRITE(fhDst, szNull, 0);     // Assure file truncated.
+      FCLOSE(fhDst);
+
+      
+      FreeLibrary( hInstLZ );
+
+  }
+
+
+errclose1:
+
+      FCLOSE(fhSrc);
+
+#if WIN32
+      } while (f == ERROR_OK && FindNextFile(FindFileHandle, &FindFileData));
+#else
+      } while (f == ERROR_OK && DosFindNext(&fcb));
+#endif
+
+errfree:
+
+   return f;
+}
+
+
+/*  BOOL GetDiskPath(char cDisk, szPath)
+ *
+ *  This function will retrive the full path name for a logical disk
+ *  the code reads the [disks] section of SETUP.INF and looks for
+ *  n = path where n is the disk char.  NOTE the disk '0' defaults to
+ *  the root windows directory.
+ *
+ *  ENTRY:
+ *
+ *  cDisk        : what disk to find 0-9,A-Z
+ *  szPath       : buffer to hold disk path
+ *
+ */
+BOOL NEAR PASCAL GetDiskPath(char cDisk, LPSTR szPath)
+{
+   char    ach[2];
+   char    szBuf[MAXPATHLEN];
+
+   *szPath = '\0';
+
+   if (cDisk == '0') {
+      // return the windows setup directory
+      lstrcpy(szPath, szSetupPath); // szSetupPath == C:\windows
+      return TRUE;
+   }
+
+   // now look in the [disks] & [oemdisks] section for a full path name
+   ach[0] = cDisk;
+   ach[1] = 0;
+
+   if (!infGetProfileString(NULL, szDisks, ach, szPath))
+      infGetProfileString(NULL, szOemDisks, ach, szPath);
+
+   if (szPath[0]) {
+
+       infParseField(szPath, 1, szPath);
+
+       // is the path relative or default?
+       // if so prepend the szDiskPath (install location)
+       if (szPath[0] == '.' || szPath[0] == 0) {
+     // szDiskPath may be NULL, indicating we haven't installed
+     // anything yet... the below code should leave szPath null
+     // in that case
+     lstrcpy(szBuf, szDiskPath);
+     catpath(szBuf, szPath);
+     lstrcpy(szPath, szBuf);
+       }
+   }
+   return TRUE;
+}
+
+
+/*  BOOL FAR PASCAL ExpandFileName(LPSTR szFile, LPSTR szPath)
+ *
+ *  This function will retrive the full path name for a file
+ *  it will expand, logical disk letters to pyshical ones
+ *  will use current disk and directory if non specifed.
+ *
+ *  if the drive specifed is 0-9, it will expand the drive into a
+ *  full pathname using GetDiskPath()
+ *
+ *  IE  0:system ==>  c:windows\system
+ *      1:foo.txt     a:\foo.txt
+ *
+ *  ENTRY:
+ *
+ *  szFile       : File name to expandwhat disk to find
+ *  szPath       : buffer to hold full file name
+ *
+ */
+BOOL FAR PASCAL ExpandFileName(LPSTR szFile, LPSTR szPath)
+{
+   char    szBuf[MAXPATHLEN*2];
+
+   if (szFile[1] == ':' && GetDiskPath(szFile[0], szBuf)) {
+      lstrcpy(szPath, szBuf);   // szBuf may be NULL
+      if (szBuf[0] && szFile[2])
+    catpath(szPath, szFile + 2);
+   } else
+       lstrcpy(szPath, szFile);
+   return TRUE;
+}
+
+
+#define CBSECTORSIZE   512
+#define INT13_READ   2
+
+/*--------------------------------------------------------------------------
+                
+  IsValidDiskette() -                       
+                
+--------------------------------------------------------------------------*/
+
+BOOL NEAR IsValidDiskette(int iDrive)
+{
+#if WIN32
+    return 1;
+#else
+   char       buf[CBSECTORSIZE];
+
+   iDrive |= 0x0020;   // make lower case
+
+   iDrive -= 'a';   // A = 0, B = 1, etc. for BIOS stuff
+
+   return MyReadWriteSector(buf, INT13_READ, iDrive, 0, 0, 1);
+#endif
+}
+
+
+
+#ifdef CHECK_FLOPPY
+
+/*  BOOL IsDiskInDrive(char cDisk)
+ *
+ *  Is the specifed disk in the drive
+ *
+ *  ENTRY:
+ *
+ *  cDisk        : what disk required to be in the drive (logical)
+ *
+ *  return TRUE if the specifed disk is in the drive
+ *         FALSE if the wrong disk is in the drive or disk error
+ *
+ */
+BOOL NEAR IsDiskInDrive(int iDisk)
+{
+
+   if ((iDisk  >= 'A' && iDisk <= 'Z') || 
+      (iDisk  >= 'a' && iDisk <= 'z'))
+      {
+      if (DosRemoveable(iDisk))
+    {
+    if (!IsValidDiskette(iDisk))
+       return FALSE;
+    }
+      return TRUE;
+      }
+   return TRUE;   // for non drive letters assume a path
+        // and thus always in.
+}
+
+#endif 
+
+// cat sz onto path removing drive letters and ".\" things, making
+// sure path has appropriate slashes
+
+void FAR PASCAL catpath(LPSTR path, LPSTR sz)
+{
+   //
+   // Remove any drive letters from the directory to append
+   //
+   if (sz[1] == ':')
+      sz += 2;
+
+   //
+   // Remove any current directories ".\" from directory to append
+   //
+   while (sz[0] == '.' && SLASH(sz[1]))
+      sz += 2;
+
+   //
+   // Dont append a NULL string or a single "."
+   //
+   if (*sz && ! (sz[0] == '.' && sz[1] == 0))
+   {
+      // Add a slash separator if necessary.
+      if ((! SLASH(path[lstrlen(path) - 1])) &&    // slash at end of path
+     ((path[lstrlen(path) - 1]) != ':') &&    // colon at end of path
+     (! SLASH(sz[0])))                        // slash at beginning of file
+    lstrcat(path, CHSEPSTR);
+
+      lstrcat(path, sz);
+   }
+}
+
+
+LPSTR FAR PASCAL FileName(LPSTR szPath)
+{
+   LPSTR   sz;
+
+   for (sz=szPath; *sz; sz++)
+      ;
+
+   for (; sz>=szPath && !SLASH(*sz) && *sz!=':'; sz--)
+      ;
+   
+   return ++sz;
+}
+
+LPSTR FAR PASCAL StripPathName(LPSTR szPath)
+{
+   LPSTR   sz;
+
+   sz = FileName(szPath);
+
+   if (sz > szPath+1 && SLASH(sz[-1]) && sz[-2] != ':')
+      sz--;
+
+   *sz = 0;
+   return szPath;
+}
+
+
+/***************************************************************************
+
+fnFindFile
+----------
+
+DESCRIPTION:
+
+   Function looks for the given file at the given location. Function
+   returns BOOL value as to existance of the file.
+ 
+   ENTRY: szFilePath - Fully qualified path to file name.
+ 
+   EXIT: True  = old winver present.
+    False = old winver not present.
+ 
+   GLOBALS: Utilizes global buffer szSetupPath, this is where we check for
+       the old winver.
+ 
+
+MODIFICATION HISTORY:
+
+   Modified by:      Date:       Comment:
+
+   Mike Colee                    Created
+   PAK               12/6/90     added FAR PASCAL to concurr with
+             definition in sulib.h
+
+***************************************************************************/
+//BOOL FAR PASCAL fnFindFile(char *szFilePath)
+//{
+//#if WIN32
+//   WIN32_FIND_DATA FileFindData;
+//
+//#else
+//   FCB       MyFCB;            /* Need an FCB for findfirst/findnext */
+//   return (DosFindFirst(&MyFCB,(LPSTR)szFilePath,ATTR_FILES)); // simple as that.
+//#endif
+//}
+
+/**************************************************************************
+*
+* This function converts returned flags from Ver API to the numerical
+* error codes used in SETUP.
+*
+***************************************************************************/
+
+WORD NEAR PASCAL ConvertFlagToValue(DWORD dwFlags)
+{
+  if ( ! dwFlags  )
+     return(ERROR_OK);
+  if ( dwFlags & VIF_CANNOTREADSRC )
+     return(ERROR_FILENOTFOUND);
+  if ( dwFlags & VIF_OUTOFMEMORY )
+     return(ERROR_NOMEMORY);
+  if ( dwFlags & VIF_ACCESSVIOLATION )
+     return(ERROR_ACCESSDENIED);
+  if ( dwFlags & VIF_SHARINGVIOLATION )
+     return(ERROR_SHARE);
+
+  return 0;
+}
+
+
diff --git a/private/tapi/dev/cpl/cpl.c b/private/tapi/dev/cpl/cpl.c
new file mode 100644
index 000000000..fb3e14df4
--- /dev/null
+++ b/private/tapi/dev/cpl/cpl.c
@@ -0,0 +1,537 @@
+/*--------------------------------------------------------------------------*\
+   Module:     cpl.c
+   
+   Purpose: The main entry point for the Control Panel, and the main
+        top level dialog proc(s).
+   
+   History:
+      7/27/93 CBB - Created
+\*--------------------------------------------------------------------------*/
+
+#include  <windows.h>
+#include  <windowsx.h>
+#include  <cpl.h>
+#include  "tapicpl.h"        
+#include  "help.h"
+#include  "init.h"
+
+#include  "drv.h"
+#include  "util.h"
+#include  "resource.h"
+#include  "debug.h"
+#include  <malloc.h>
+#include  <prsht.h>  /* for PropertySheet defs */
+
+//------------------
+// Private Constants
+//------------------
+#ifdef CTL3D
+#define  CTL3D_REGISTER       12       // ordinals for using CTL3D.DLL
+#define  CTL3D_AUTOSUBCLASS   16
+#define  CTL3D_UN_REGISTER    13
+#define  CTL3D_COLOR_CHANGE   6
+#endif /* CTL3D */
+
+//-------------
+// Private Data
+//-------------
+CPL   gCPL;       // app global
+
+#ifndef _WIN32
+#pragma code_seg ( "CPL_MAIN" )
+#endif
+
+// the following are not to be translated, so they can be static
+#ifndef _WIN32  // don't need ctl3d.dll
+#ifdef CTL3D
+static char SEG_CPL gszCtl3DLib[] = "CTL3D.DLL";
+#endif /* CTL3D */
+#endif
+
+//--------------------
+// Function Prototypes
+//--------------------
+UINT PRIVATE   _ErrDoPropertySheet( HWND, WORD, DLGPROC, LPARAM );
+
+
+
+extern UINT WINAPI ErrRefreshProviderList();
+
+
+
+
+#ifdef CTL3D
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+VOID FAR PASCAL CplSysColorChange()
+{
+   FARPROC  lpfnCtl3DColorChange;
+
+   // 3D control stuff
+   //-----------------
+   if ( gCPL.hCtl3DInst != NULL )      // does not happen very often
+   {         
+      lpfnCtl3DColorChange = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_COLOR_CHANGE ));
+      
+      if ( lpfnCtl3DColorChange != NULL )
+     (*lpfnCtl3DColorChange)();     // let him know
+   }  // end if               
+}
+#endif /* CTL3D */
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplInit
+   
+   Purpose:    Initalizes for the init dialog.  We postpone doing some 
+           initalizing until now, so that the control panel won't take
+           years to load...
+   
+\*--------------------------------------------------------------------------*/
+UINT PRIVATE   CplInit( HWND     hWnd,
+            BOOL     fUse3d,
+            LPUINT   lpuUpdated )
+
+{
+   UINT  uResult;
+   UINT  uOldErrMode;
+
+   extern CPL     gCPL;       // app global
+
+   gCPL.uInstances++;            // ONECPL:  CANNOT be used by multiple apps!
+   
+   if ( gCPL.uInstances == 1 )   // ONECPL
+   {
+      gCPL.hWnd = hWnd;          // ONECPL
+
+#ifndef _WIN32
+#ifdef CTL3D
+      if ( fUse3d && (LOBYTE(LOWORD( GetVersion())) < 4))      // only for win3.1 and below
+      {
+
+          // init 3D control stuff
+          //----------------------
+          uOldErrMode = (UINT)SetErrorMode( SEM_NOOPENFILEERRORBOX );  // turn off that it can't find the library!
+     
+          gCPL.hCtl3DInst = LoadLibrary( gszCtl3DLib );
+     
+          SetErrorMode( uOldErrMode );                                 // restore the error mode!
+     
+          if (  gCPL.hCtl3DInst <= HINSTANCE_ERROR )
+          {
+              gCPL.hCtl3DInst = NULL;    // set back to default
+          }
+          else
+          {
+              // get all the procs that we need
+              lpfnCtl3DRegister = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_REGISTER ));
+              lpfnCtl3DAutoSubclass = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_AUTOSUBCLASS ));
+
+              if ((lpfnCtl3DRegister == NULL) || (lpfnCtl3DAutoSubclass == NULL))
+              {
+                  // ah, didn't work, don't worry too much about it
+                  FreeLibrary( gCPL.hCtl3DInst );
+                  gCPL.hCtl3DInst = NULL;
+              }
+              else
+              {      
+                  // ok, looks like everything worked, register the lib
+                  //---------------------------------------------------
+                  (*lpfnCtl3DRegister)( gCPL.hCplInst );
+                  (*lpfnCtl3DAutoSubclass)( gCPL.hCplInst );
+              }
+
+          }
+      }
+#endif /* CTL3D */
+#endif
+   
+      *lpuUpdated = FALSE;       // I don't want to talk about it!
+
+      // Initialize the list of service providers
+      //-----------------------------------------
+      if ( ErrRefreshProviderList() != CPL_SUCCESS )
+      {
+          return CPL_ERR_TAPI_FAILURE;
+      }
+      
+      uResult = CPL_SUCCESS;                         // ONECPL
+   }   
+   else
+   {
+       /* Find the first instance main window, and post a message to it to tell it to activate itself */
+       HWND hTopWindow = GetLastActivePopup( gCPL.hWnd );   // ONECPL
+
+       ShowWindow( hTopWindow, SW_RESTORE );          // ONECPL
+       BringWindowToTop( hTopWindow );                // ONECPL
+
+       uResult = CPL_ERR_ALREADY_INITIALIZED;         // ONECPL
+   }
+
+   return( uResult );
+
+}
+
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplClose
+   
+   Purpose:    The dialog is being closed, write any necessary chagnes out,
+           clean up all left over memmory and all that stuff...
+   
+\*--------------------------------------------------------------------------*/
+UINT PUBLIC CplClose( UINT  uCommand )
+
+   {
+   UINT  uResult;
+   FARPROC  lpfnCtl3DUnregister;
+   extern CPL     gCPL;       // app global
+
+   if (glpProviderList)
+   {
+    GlobalFreePtr(glpProviderList);
+    glpProviderList = NULL;
+   }
+   
+   // write any changes out to the ini file
+   //--------------------------------------                  
+   gCPL.uInstances = (gCPL.uInstances == 0) ? 0 : (gCPL.uInstances - 1);         // can be used by multiple apps!
+   
+   if ( gCPL.uInstances == 0 )
+      {
+      // delete all the left over lists
+      //-------------------------------
+
+#ifdef CTL3D
+      if ( gCPL.hCtl3DInst != NULL )
+     {         
+     // clear 3D control stuff
+     //-----------------------   
+     lpfnCtl3DUnregister = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_UN_REGISTER ));
+     
+     if ( lpfnCtl3DUnregister != NULL )
+        (*lpfnCtl3DUnregister)( gCPL.hCplInst );     // let him know
+        
+     FreeLibrary( gCPL.hCtl3DInst );
+     gCPL.hCtl3DInst = NULL;
+     }  // end if
+#endif /* CTL3D */
+      }  // end if
+      
+   uResult = CPL_SUCCESS;
+   
+#ifndef _WIN32
+      LocalCompact( CPL_HEAP_SIZE );     // shrink the local heap (WIN32 obsolete)
+#endif      
+      return( uResult );
+}  // end function CplClose
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplApplet
+   
+   Purpose: The Control Panel entry point, call back funcition...
+   
+\*--------------------------------------------------------------------------*/
+extern char far gszHelpFile[];                                         
+
+LONG
+#if WIN32
+ APIENTRY
+#else
+ EXPORT  
+#endif
+CPlApplet( HWND   hWndCpl,
+            UINT   uMessage,
+            LPARAM lParam1,
+            LPARAM lParam2 )
+{
+   FUNC_ENTRY( "CPlApplet" )
+    
+   UINT  uResult;
+   UINT  uUpdated;
+   LONG  lResult;
+   LONG  lAppletNum;
+   LPCPLINFO   lpCplInfo;
+   LPNEWCPLINFO   lpNewCplInfo;
+   extern CPL     gCPL;       // app global
+
+   lAppletNum = lParam1;      // start's at zero
+   lResult = 0;               // default return value
+
+   switch ( uMessage ) 
+   {
+      case CPL_INIT:
+
+          DBGOUT((10, "CPL_INIT"));
+
+          // first message, sent once
+          lResult = InitApplets( hWndCpl );
+          break;
+
+
+      case CPL_GETCOUNT:
+          DBGOUT((10, "CPL_GETCOUNT - returning %d", gCPL.uCplApplets));
+
+          // return the number of applets supported
+          lResult = gCPL.uCplApplets;
+          break;
+
+
+      case CPL_INQUIRE:       
+          DBGOUT((10, "CPL_INQUIRE"));
+
+         // get info about each applet -sent once per app
+         //----------------------------------------------
+         if ( lAppletNum < (LONG)gCPL.uCplApplets )
+         {
+             lpCplInfo  = (LPCPLINFO)lParam2;
+
+             lpCplInfo->idIcon = (int)gCPL.taTeleApplet[lAppletNum].uIconResId;
+             lpCplInfo->idName = (int)gCPL.taTeleApplet[lAppletNum].uNameResId;
+             lpCplInfo->idInfo = (int)gCPL.taTeleApplet[lAppletNum].uStatusLineResId;
+             lpCplInfo->lData  = gCPL.taTeleApplet[lAppletNum].lPrivateData;
+        
+             lResult = TRUE;
+         }  // end if
+         break;
+
+
+      case CPL_NEWINQUIRE:
+          DBGOUT((10, "CPL_NEWINQUIRE"));
+
+         // new version of CPL_INQUIRE, return info about each applet
+         //----------------------------------------------------------
+         if ( lAppletNum < (LONG)gCPL.uCplApplets )
+         {
+            lpNewCplInfo  = (LPNEWCPLINFO)lParam2;
+        
+            lpNewCplInfo->dwFlags       = 0;
+            lpNewCplInfo->dwSize        = sizeof(NEWCPLINFO);
+            lpNewCplInfo->lData         = gCPL.taTeleApplet[lAppletNum].lPrivateData;
+// Win95b 12364            lpNewCplInfo->dwHelpContext = gCPL.taTeleApplet[lAppletNum].dwHelpContext;
+            lpNewCplInfo->dwHelpContext = 0;
+           
+         
+            if ( !gCPL.taTeleApplet[lAppletNum].hIcon )         
+               {
+               // load the icon
+               lpNewCplInfo->hIcon = LoadIcon( gCPL.hCplInst, MAKEINTRESOURCE(gCPL.taTeleApplet[lAppletNum].uIconResId));
+           
+               if ( !lpNewCplInfo->hIcon )
+              {
+                 FErrorRpt( hWndCpl, CPL_ERR_MEMORY );
+                 break;      // will return false by default
+              }
+          
+               gCPL.taTeleApplet[lAppletNum].hIcon = lpNewCplInfo->hIcon;     // save it so we can delete it
+               }  // end if
+
+
+            LpszGetStr( lpNewCplInfo->szName, gCPL.taTeleApplet[lAppletNum].uNameResId, CPL_MAX_TITLE );
+            LpszGetStr( lpNewCplInfo->szInfo, gCPL.taTeleApplet[lAppletNum].uStatusLineResId, CPL_MAX_STATUS_LINE );
+            lstrcpy (lpNewCplInfo->szHelpFile, gszHelpFile);
+             
+            lResult = TRUE;
+            }  // end if
+         break;
+     
+
+      case CPL_SELECT: 
+          DBGOUT((10, "CPL_SELECT"));
+
+          // application selected, who cares...
+          break;
+
+
+      case CPL_DBLCLK: 
+          DBGOUT((10, "CPL_DBLCLK"));
+
+          //----------------
+          // show the dialog
+          //----------------
+          if ( lAppletNum < (LONG)gCPL.uCplApplets )
+          {
+              //
+              // Verify single instance, initialize provider list
+              //
+              uResult = CplInit( hWndCpl, TRUE, &uUpdated );
+
+              if ( uResult == CPL_SUCCESS )
+              {
+                  // Get windows directory, set default path for driver additions.
+                  wsInfParseInit();  // initialize Multimedia
+
+                  DEBOUT( "Creating Property Sheet" );
+
+                  uResult = _ErrDoPropertySheet(
+                      (HWND) hWndCpl,
+                      (WORD) gCPL.taTeleApplet[lAppletNum].uDialogResId,
+                      (DLGPROC) gCPL.taTeleApplet[lAppletNum].dlgprcDialog,
+                      (LPARAM) uUpdated
+                      );
+
+                  DEBOUT( "Finished Creating Property Sheet" );
+                    
+                  infClose(NULL);
+
+                  // Free up 3-D lib
+                  if ((uResult = CplClose( uUpdated )) != CPL_SUCCESS )
+                  {
+                      CplClose( IDCANCEL );    // just make sure all the mem is cleaned up!
+                  }
+               
+              } // end if
+                
+              if ( uResult != CPL_SUCCESS )                   // hum, things don't look to good
+              {
+                  FErrorRpt( hWndCpl, uResult );
+                  CplClose( IDCANCEL );    // just make sure all the mem is cleaned up!
+              }
+
+          }
+                   
+          break;
+
+
+      case CPL_STOP: 
+          DBGOUT((10, "CPL_STOP"));
+
+          // sent once per app before CPL_EXIT
+          break;
+
+
+      case CPL_EXIT: 
+          DBGOUT((10, "CPL_EXIT"));
+
+          // sent once before FreeLibrary called
+          InitCleanupApplets();
+          break;
+
+
+      default:
+          break;
+
+      }  // end case
+      
+   return( lResult );
+
+}
+
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+UINT PRIVATE _ErrDoPropertySheet( HWND hwndOwner, WORD idResource, 
+                                             DLGPROC dlgProc, LPARAM lParam )
+{
+    // Property sheet junk
+   HPROPSHEETPAGE rPages[8];
+   PROPSHEETPAGE psp;
+   PROPSHEETHEADER psh;
+   
+    /****************************************************
+
+                            PROPERTY SHEET
+                                    
+    ****************************************************/
+
+    /*
+     * ALERT! ALERT!
+     *
+     * In order for PropertySheets to work correctly, we need
+     * to mark tapi.dll as a Windows 4.0 app. For this we need
+     * to use rc.exe and rcpp.exe from the \chico\dev\sdk\bin
+     * directory (\chico\dev is on \\guilo\slm).
+     * 
+     */
+     
+   psh.dwSize = sizeof(psh);
+   psh.dwFlags = PSH_NOAPPLYNOW | PSH_PROPTITLE;
+   psh.hwndParent = hwndOwner;
+   psh.hInstance = gCPL.hCplInst;
+   psh.pszCaption = MAKEINTRESOURCE(IDS_DIALOG_TITLE);
+   psh.nPages = 0;
+   psh.nStartPage = 0;
+   psh.phpage = rPages;
+
+   /* Define Location page */
+   psp.dwSize = sizeof(psp);
+   psp.dwFlags = PSP_DEFAULT;
+   psp.hInstance = gCPL.hCplInst;
+   psp.pszTemplate = MAKEINTRESOURCE(idResource);
+   psp.pfnDlgProc = dlgProc;
+   psp.lParam = lParam;
+
+//   DBGOUT((1, "Calling CreatePropertySheetPage"));
+
+   psh.phpage[psh.nPages] = CreatePropertySheetPage(&psp);
+
+//   DBGOUT((1, "Done with CreatePropertySheetPage"));
+
+   if (psh.phpage[psh.nPages])
+       psh.nPages++;
+
+//   DBGOUT((1, "Calling PropertySheet"));
+
+   if (PropertySheet(&psh) < 0)
+   {
+//        DBGOUT((1, "... which failed"));
+        return CPL_ERR_DIALOG_BOX;
+   }
+   else
+      return 0;
+}
+
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+#ifdef MSJ_PROP_SHEET
+UINT PRIVATE _ErrDoPropertySheet( HWND hwndOwner, WORD idResource, 
+                                             DLGPROC dlgProc, LPARAM lParam )
+{
+    // Property sheet junk
+   PROPSHEETPAGE   psp[1];
+   PROPSHEETHEADER psh;
+   
+    /****************************************************
+
+                            PROPERTY SHEET
+                                    
+    ****************************************************/
+
+    /*
+     * ALERT! ALERT!
+     *
+     * In order for PropertySheets to work correctly, we need
+     * to mark tapi.dll as a Windows 4.0 app. For this we need
+     * to use rc.exe and rcpp.exe from the \chico\dev\sdk\bin
+     * directory (\chico\dev is on \\guilo\slm).
+     * 
+     */
+     
+    psp[0].dwSize = sizeof(PROPSHEETPAGE);
+    psp[0].dwFlags = PSP_DEFAULT;
+    psp[0].hInstance = gCPL.hCplInst;
+    psp[0].pszTemplate = MAKEINTRESOURCE(idResource);
+    psp[0].pfnDlgProc = dlgProc;
+    psp[0].lParam = lParam;
+
+    psh.dwSize = sizeof(psh);
+    psh.dwFlags = PSH_NOAPPLYNOW;
+    psh.hwndParent = hwndOwner;
+    psh.hInstance = gCPL.hCplInst;
+    psh.pszCaption = MAKEINTRESOURCE(IDS_DIALOG_TITLE);
+    psh.nPages = sizeof(psp)/sizeof(PROPSHEETPAGE);
+    psh.ppsp = (LPCPROPSHEETPAGE)&psp;
+    
+    if (PropertySheet(&psh) < 0)
+        return CPL_ERR_DIALOG_BOX;
+    else
+        return 0;
+}
+#endif /* MSJ_PROP_SHEET */
diff --git a/private/tapi/dev/cpl/debug.c b/private/tapi/dev/cpl/debug.c
new file mode 100644
index 000000000..a9bdbef9d
--- /dev/null
+++ b/private/tapi/dev/cpl/debug.c
@@ -0,0 +1,96 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include  <tapi.h>                  
+#include "debug.h"
+
+
+
+
+DWORD TapiCplDebugLevel = 0;
+static fTapiCplDebugLevelValid = FALSE;
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+
+{
+   char    buf[128] = "TAPICPL: ";
+// *** *** ***   static char szFilename[] = filename;
+   if (!fTapiCplDebugLevelValid)
+   {
+      TapiCplDebugLevel =   GetPrivateProfileInt( "Debug",
+                                             "TelephonDebugLevel",
+                                             0,
+                                             "Telephon.ini" );
+
+      if ( TapiCplDebugLevel > 0 )
+      {
+         wsprintf(
+                   &buf[9],
+                   "TapiCplDebugLevel= %d\n\r",
+                   TapiCplDebugLevel);
+
+         OutputDebugString((LPSTR)buf);
+
+
+      }
+
+      fTapiCplDebugLevelValid = TRUE;
+   }
+
+
+   //
+   // Is the message otherwise "low" enough to display?
+   //
+    if (dwDbgLevel <= TapiCplDebugLevel)
+    {
+        char    buf[128] = "TAPICPL: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        vsprintf (&buf[9],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugString(buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+
+
+#endif
diff --git a/private/tapi/dev/cpl/debug.h b/private/tapi/dev/cpl/debug.h
new file mode 100644
index 000000000..cd9ea2591
--- /dev/null
+++ b/private/tapi/dev/cpl/debug.h
@@ -0,0 +1,25 @@
+#if DBG
+
+
+#if !WIN32
+#define IN
+#define PUCHAR char *
+#endif
+
+
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/cpl/depend.mk b/private/tapi/dev/cpl/depend.mk
new file mode 100644
index 000000000..2070d94d9
--- /dev/null
+++ b/private/tapi/dev/cpl/depend.mk
@@ -0,0 +1,26 @@
+
+.\copy.obj: ..\copy.c ..\externs.h
+
+.\cpl.obj: ..\cpl.c ..\drv.h ..\help.h ..\util.h
+
+.\drv.obj: ..\drv.c ..\drv.h ..\insdisk.h ..\help.h ..\util.h ..\debug.h
+
+.\exe.obj: ..\exe.c ..\drv.h
+
+.\filecopy.obj: ..\filecopy.c ..\drv.h ..\externs.h ..\help.h
+
+.\inf.obj: ..\inf.c
+
+.\init.obj: ..\init.c ..\drv.h ..\help.h ..\util.h
+
+.\insdisk.obj: ..\insdisk.c ..\insdisk.h ..\help.h ..\util.h
+
+.\mmdriver.obj: ..\mmdriver.c ..\drv.h ..\externs.h
+
+.\util.obj: ..\util.c ..\util.h
+
+#.\dos.obj: ..\dos.asm
+
+.\debug.obj: ..\debug.c
+
+.\telephon.res: ..\telephon.rc ..\resource.h
diff --git a/private/tapi/dev/cpl/drv.c b/private/tapi/dev/cpl/drv.c
new file mode 100644
index 000000000..5e8f02b84
--- /dev/null
+++ b/private/tapi/dev/cpl/drv.c
@@ -0,0 +1,1740 @@
+/*--------------------------------------------------------------------------*\
+   Module:     drv.c
+   
+   Purpose:    routiens for dealing with drivers and their configuration
+   
+   History:
+      8/11/93 CBB - Hack-o-rama from NickH's stuff
+\*--------------------------------------------------------------------------*/
+
+#include  <tapi.h>
+#include  <windows.h>                                 
+#include  <windowsx.h>
+#include  <commdlg.h>
+#include  <string.h>       
+#include  <dos.h>
+
+#ifdef NT_INST
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+
+// Get rid of this!
+//#include <mmsystem.h>
+
+
+#include  <malloc.h>
+#include  "tapicpl.h"
+#include  "util.h"
+#include  "resource.h"
+#include  "drv.h"
+#include  "insdisk.h"
+#include  "sulib.h"
+#include  <prsht.h>  /* for PropertySheet defs */
+
+#include "debug.h"
+
+//----------
+// Constants
+//----------
+
+
+//-------
+// DRIVER
+//-------
+typedef struct tagDRIVER
+   {
+   // ini fields
+   DWORD dwProviderID;
+   char  szProviderFileName[CPL_MAX_STRING];
+   }  DRIVER, *PDRIVER, FAR *LPDRIVER;
+
+   
+//------------
+// Public Data
+//------------
+LPLINEPROVIDERLIST glpProviderList;
+
+//-------------
+// Private Data
+//-------------
+
+#ifndef _WIN32
+#pragma code_seg ( "DRIVERS" )
+#endif
+
+// the following are not to be translated, so they can be static
+static char SEG_DRV gszProvidersSec[]  = "Providers";
+static char SEG_DRV gszNumProviders[]  = "NumProviders";   
+static char SEG_DRV gszLastID[]        = "NextProviderID";
+static char SEG_DRV gszProviderX[]     = "Provider";
+static char SEG_DRV gszProviderIdX[]   = "ProviderID";
+static char SEG_DRV gszProviderFileX[] = "ProviderFilename";
+static char SEG_DRV gszDrvNumFormat[]  = "i";
+static char SEG_DRV gszDrvFileFormat[] = "f";
+static char SEG_DRV gszProviderSetup[]   = "TSPI_providerConfig";
+static char SEG_DRV gszProviderRemove[]  = "TSPI_providerRemove";
+static char SEG_DRV gszProviderInstall[] = "TSPI_providerInstall";
+static char SEG_DRV gszVarFileInfo[]    = "\\VarFileInfo\\Translation";
+static char SEG_DRV gszStringFileInfo[] = "\\StringFileInfo\\%04x%04x\\FileDescription";
+//static char SEG_DRV gszStringFileInfo[] = "\\StringFileInfo\\%08lx\\FileDescription";
+static char SEG_DRV gszDriverFiles[] = "\\*.tsp";
+static char SEG_DRV gszInfFiles[] = "\\*.inf";
+static char SEG_DRV gszOpenFileNameFilter[] = "TSPs (*.tsp)\0*.tsp\0INFs (*.inf)\0*.inf\0";
+static char SEG_DRV gszInitialPath[] = "A:\\";
+static char SEG_DRV gszOemInf[] = "oemsetup.inf";
+static char SEG_DRV gszInstallDrvSec[] = "Installable.drivers";
+
+static HLINEAPP _hlineapp;
+static DWORD    _dwNumDevs;
+
+
+extern char far gszHelpFile[];                                         
+
+
+//----------------------------
+// Private Function Prototypes
+//----------------------------
+BOOL  PRIVATE   _FVerifyProcExists( LPSTR lpszFile, LPSTR lpszProcName );
+UINT  PRIVATE   _ErrFillList( HWND hWnd, UINT uControl, LPUINT lpuUpdated );
+UINT  PRIVATE   _ErrSetupDriver( HWND hWnd, UINT uControl );
+UINT  PRIVATE   _ErrRemoveDriver( HWND hWnd, UINT  uControl );
+UINT  PRIVATE   _ErrGetFileDesc( LPSTR lpszFile, LPSTR lpszDesc );
+UINT  PRIVATE   _ErrFillAddList( HWND hWnd, UINT uControl );
+UINT  PRIVATE   _ErrAddProvider( HWND hWnd, UINT uControl, LPSTR lpszDriverFile );
+UINT  PRIVATE   _ErrBrowserAdd( HWND hWnd, UINT  uControl );
+BOOL  PRIVATE   _FAddUnlisted( HWND hWnd );
+BOOL  PRIVATE   _FInstallDrivers(HWND hWnd, LPSTR pstrKey);
+BOOL  PRIVATE   _FInitAvailable( HWND hWnd );
+LPSTR PRIVATE   _LpszProviderIDToFilename( DWORD dwProviderID );
+void  FAR PASCAL EXPORT _LineCallBackProc( DWORD, DWORD, DWORD, DWORD, DWORD,  DWORD );
+
+
+
+UINT WINAPI ErrRefreshProviderList();
+
+
+//============================= BEGIN: Multimedia Paste
+
+BOOL     bRestart = FALSE;
+int      iRestartMessage = 0;
+BOOL     bInstallBootLine = FALSE;
+BOOL     bRelated = FALSE;
+BOOL     bCopyingRelated;
+BOOL     bDescFileValid;
+HWND     hlistbox;    
+UINT     wHelpMessage;
+DWORD    dwContext;
+PINF     pinfOldDefault;
+char     szFile[20]  = {0};  // current filename
+char     szRestartDrv[80];
+char     szAppName[26];
+char     szRemove[12];
+char     szRemoveOrNot[250];
+char     szRemoveOrNotStrict[250];
+char     szStringBuf[128];   
+char     szFullPath[MAXFILESPECLEN];
+// char     aszClose[16];
+char     szSetupInf[] = "setup.inf";
+//char     szDriversHlp[] = "control.hlp";
+//char     szControlIni[] = "control.ini";
+char     szSysIni[] = "system.ini";
+//char     szMIDI[] = "MIDI";
+//char     szWAVE[] = "WAVE";
+//char     szMCI[] = "MCI";
+//char     szDriversDesc[] = "drivers.desc";
+//char     szRelatedDesc[] = "related.desc";
+char     szDrivers[] = "drivers";
+char     szBoot[] = "boot";
+char     szSystem[] = "0:system";
+char     szOemInf[] = "oemsetup.inf";
+char     szMDrivers[] = "Installable.drivers";
+//char     szUserDrivers[] = "Userinstallable.drivers";
+
+HANDLE   hIList;
+//HANDLE   hWndMain;
+char     cSpace              = ' ';
+char     cComma              = ',';
+char     cNull               = '\0';
+
+/*
+ *  global vars used by DosCopy  (taken from COPY.C)
+ */
+BOOL     bRetry = FALSE;
+BOOL     bQueryExist;
+
+// Variable for the error message box, set in drivers
+char szFind[50];
+char szDrv[120];
+char szFileError[50];
+HWND hMesgBoxParent;
+
+char FAR szNull[] = "";
+BOOL bVxd = FALSE;
+
+//  directory where windows will be setup to
+char szSetupPath[MAXPATHLEN];
+
+//  directory where the root of the setup disks are!
+char szDiskPath[MAXPATHLEN];
+char szTapiAppName[] = "telephon.cpl";
+
+//============================= END: Multimedia Paste
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   _FVerifyProcExists
+   
+   Purpose:    Verifies that the specified proceedure exists in the
+               specified service provider
+   
+\*--------------------------------------------------------------------------*/
+BOOL  PRIVATE   _FVerifyProcExists( LPSTR     lpszFile,
+                                     LPSTR     lpszProcName )
+{
+    FUNC_ENTRY( "_FVerifyProcExists" )
+    
+   BOOL        fResult       = TRUE;
+   HINSTANCE   hProviderInst = LoadLibrary( lpszFile );
+   char buffer[256];
+
+#ifdef _WIN32         
+   if (  hProviderInst == NULL )
+#else
+   if (  hProviderInst <= HINSTANCE_ERROR )
+#endif
+      {
+#ifndef _WIN32         
+          DEBOUT2( "LoadLibrary failure %d on file %s", hProviderInst, lpszFile );
+#endif /* _WIN32 */
+         fResult = FALSE;
+         goto  done;
+      }  // end if
+
+   if (GetProcAddress( hProviderInst, lpszProcName ) == NULL)
+   {
+         DEBOUT2( "GetProcAddress for \"%s\" failed on file %s", lpszProcName, lpszFile );
+      fResult = FALSE;
+      goto  done;
+   }   // end if
+
+done:
+
+#ifdef _WIN32
+   if ( hProviderInst != NULL )
+#else
+   if ( hProviderInst > HINSTANCE_ERROR )
+#endif
+      FreeLibrary( hProviderInst );
+
+   return fResult;
+}
+
+                      
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrFillList
+   
+   Purpose:    Use lineGetProviderList to retrieve provider list and 
+               insert into listbox.
+               
+\*--------------------------------------------------------------------------*/
+UINT PRIVATE _ErrFillList( HWND   hWnd, 
+                 UINT   uControl,
+                 LPUINT lpuUpdated )
+{
+   UINT uResult;
+   UINT uIndex;
+   UINT uListIndex;
+   LPLINEPROVIDERENTRY lpProviderEntry;
+   // LPLINEPROVIDERLIST glpProviderList
+
+//   DBGOUT((10, "Entering _ErrFillList"));
+
+   uResult = ErrRefreshProviderList();
+    
+   if (uResult != CPL_SUCCESS)
+   {
+       DBGOUT((1, "Failing _ErrFillList because ErrRefreshProviderList returned 0x%08lx", uResult));
+       return uResult;
+   }
+   
+   DBG_ASSERT( glpProviderList, "Uninitialized Provider List after refresh" );
+
+   SendDlgItemMessage( hWnd, uControl, WM_SETREDRAW, FALSE, 0 );
+   SendDlgItemMessage( hWnd, uControl, LB_RESETCONTENT, 0, 0 );
+
+   // loop through the provider list
+   //-------------------------------   
+
+   lpProviderEntry = (LPLINEPROVIDERENTRY)((char FAR *)(glpProviderList) + 
+                                           glpProviderList->dwProviderListOffset);
+
+   //
+   // Provider list integrity check
+   //
+   DBG_ASSERT( glpProviderList->dwTotalSize >= 
+                   (glpProviderList->dwNumProviders * sizeof( LINEPROVIDERENTRY )),
+                   "TAPI returned lineProviderList structure that is too small for number of providers" );
+                   
+   for ( uIndex = 0; uIndex < glpProviderList->dwNumProviders; uIndex++ )
+   {
+       LPSTR lpszProviderFilename;
+       char  szFriendlyName[CPL_MAX_STRING];
+
+//       DBGOUT((1, "Working on provider # %d", uIndex));
+
+        //
+        // Another provider list integrity check
+        //
+         DBG_ASSERT( lpProviderEntry[uIndex].dwProviderFilenameOffset + 
+                         lpProviderEntry[uIndex].dwProviderFilenameSize <=
+                         glpProviderList->dwTotalSize,
+                         "TAPI LINEPROVIDERLIST too small to hold provider filename" );
+         
+      // Get an entry to put in the list box
+      //------------------------------------
+       lpszProviderFilename = (char FAR *)(glpProviderList) +
+                                     lpProviderEntry[uIndex].dwProviderFilenameOffset;
+
+//       DBGOUT((1, "Provider name: %s", lpszProviderFilename));
+
+      // Determine the user-friendly name
+      //---------------------------------
+      uResult = _ErrGetFileDesc( lpszProviderFilename, (LPSTR)szFriendlyName );
+
+      DBGOUT((1, "Provider friendly name: %s", szFriendlyName));
+
+      if (uResult != CPL_SUCCESS && uResult != CPL_BAD_DRIVER) // just leave bad driver in list
+          goto done;
+          
+      // slam it into the list box
+      //--------------------------
+      uListIndex = (UINT)SendDlgItemMessage( hWnd, uControl, LB_ADDSTRING, 0, 
+                                                          (LPARAM)(LPSTR)(szFriendlyName) );
+      if (uListIndex == CB_ERR)
+      {
+             uResult = CPL_APP_ERROR;
+             goto  done;
+      }  // end if
+
+      DBGOUT((1, "Setting item for index %ld, value=0x%08lx", (DWORD)uListIndex, 
+                                        (DWORD)(lpProviderEntry[uIndex].dwPermanentProviderID) ));
+
+      if (SendDlgItemMessage( hWnd, uControl, LB_SETITEMDATA, uListIndex, 
+                                        (LPARAM)(lpProviderEntry[uIndex].dwPermanentProviderID) ) == CB_ERR)
+      {
+             uResult = CPL_APP_ERROR;
+             goto  done;
+      }
+
+   }
+
+//   DBGOUT((1, "Done providerlist"));
+
+   if (glpProviderList->dwNumProviders == 0)
+   {
+      // no providers, add in default string!
+      //-------------------------------------
+      uListIndex = (UINT)SendDlgItemMessage( hWnd, uControl, LB_ADDSTRING, 0, 
+                                                          (LPARAM)(LPSTR)LpszGetStr( NULL, IDS_DT_DS_NO_DRIVER, 0 ));
+      SendDlgItemMessage( hWnd, uControl, LB_SETITEMDATA, uListIndex, 0 );     // mark!
+   }  // end if
+      
+   uResult = CPL_SUCCESS;
+      
+
+done:
+
+   SendDlgItemMessage( hWnd, uControl, LB_SETCURSEL, 0, 0 );    // set focus to the top guy
+   SendMessage( hWnd, WM_COMMAND, uControl, MAKELONG( GetDlgItem( hWnd, uControl ), LBN_SELCHANGE ));
+     
+   SendDlgItemMessage( hWnd, uControl, WM_SETREDRAW, TRUE, 0 );
+      
+   *lpuUpdated = FALSE;
+      
+//   DBGOUT((11, "Leaving _ErrFillList"));
+
+   return( uResult );
+}
+
+
+   
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrSetupDriver
+   
+   Purpose:    Calls lineConfigProvider
+   
+\*--------------------------------------------------------------------------*/
+UINT  PRIVATE   _ErrSetupDriver( HWND  hWnd, 
+                UINT  uControl )
+                
+{
+   FUNC_ENTRY( "_ErrSetupDriver" )
+   
+   UINT  uResult;
+   LONG  lResult;
+   DWORD dwProviderID;
+   
+   // get the id and tell tapi to configure the provider
+   //---------------------------------------------------
+   uResult      = (UINT)SendDlgItemMessage( hWnd, uControl, LB_GETCURSEL, 0, 0 );
+   dwProviderID = (DWORD)SendDlgItemMessage( hWnd, uControl, LB_GETITEMDATA, (WPARAM)uResult, 0L );
+   
+   if (((LONG)dwProviderID == LB_ERR) || (!dwProviderID))
+   {
+      DEBOUT2( "Warning: strange... dwProviderID= 0x%08lx (uResult=0x%08lx)", (DWORD)dwProviderID, (DWORD)uResult);
+      uResult = CPL_APP_ERROR;
+      goto  done;
+   }  // end if
+
+   lResult = lineConfigProvider( hWnd, dwProviderID );
+   
+   if (lResult)
+   {
+        DEBOUT1( "Warning: lineConfigProvider failure %#08lx", lResult );
+       TapiErrReport( hWnd, lResult );
+       uResult = CPL_ERR_TAPI_FAILURE;
+      goto  done;
+   }
+
+   uResult = CPL_SUCCESS;
+      
+   done:
+      return( uResult );
+}
+
+   
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrRemoveDriver
+   
+   Purpose:    Calls lineRemoveProvider
+   
+\*--------------------------------------------------------------------------*/
+UINT  PRIVATE   _ErrRemoveDriver( HWND  hWnd, 
+                 UINT  uControl )
+                
+{
+    FUNC_ENTRY( "_ErrRemoveDriver" )
+
+   UINT  uResult;
+   LONG  lResult;
+   UINT  uListIndex;
+   DWORD dwProviderID;
+   
+   
+   // find the one we should remove
+   //------------------------------
+   uListIndex   = (UINT)SendDlgItemMessage( hWnd, uControl, LB_GETCURSEL, 0, 0 );
+   dwProviderID = (DWORD)SendDlgItemMessage( hWnd, uControl, LB_GETITEMDATA, uListIndex, 0 );
+   
+      DEBOUT1( "Removing provider ID = %#08lx", dwProviderID );
+      
+   if (((LONG)dwProviderID == LB_ERR) || (!dwProviderID))
+   {
+      uResult = CPL_APP_ERROR;
+      goto  done;
+   }  // end if
+
+   // ask TAPI to remove this provider
+   //---------------------------------
+   lResult = lineRemoveProvider( dwProviderID, hWnd );
+
+   if (lResult)
+   {
+        DEBOUT1( "Warning: lineRemoveProvider failure %#08lx", lResult );
+       TapiErrReport( hWnd, lResult );
+       uResult = CPL_ERR_TAPI_FAILURE;
+      goto  done;
+   }
+
+   // remove him from the list box
+   //-----------------------------
+   lResult = SendDlgItemMessage( hWnd, uControl, LB_DELETESTRING, uListIndex, 0 );
+   
+   if (lResult == LB_ERR )
+   {
+      uResult = CPL_APP_ERROR;
+      goto  done;
+   }  // end if
+  
+   if ( lResult == 0 )
+   {
+      // no providers, add in default string!
+      //-------------------------------------
+      lResult = SendDlgItemMessage( hWnd, uControl, LB_ADDSTRING, 0, 
+                                              (LPARAM)(LPSTR)LpszGetStr( NULL, IDS_DT_DS_NO_DRIVER, 0 ));
+      SendDlgItemMessage( hWnd, uControl, LB_SETITEMDATA, (WPARAM)lResult, 0 );     // mark!
+   }  // end if
+
+   uResult = CPL_SUCCESS;  
+   
+done:
+
+   SendDlgItemMessage( hWnd, uControl, LB_SETCURSEL, 0, 0 );    // set focus to the top guy
+   SendMessage( hWnd, WM_COMMAND, uControl, MAKELONG( GetDlgItem( hWnd, uControl ), LBN_SELCHANGE ));
+     
+   return( uResult );
+}  // end _ErrRemoveDriver
+
+   
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrGetFileDesc
+   
+   Purpose:    Reads the driver description from it's version info stuff
+   
+\*--------------------------------------------------------------------------*/
+UINT  PRIVATE   _ErrGetFileDesc( LPSTR   lpszFile, 
+                LPSTR   lpszDesc )
+                   
+{
+   FUNC_ENTRY( "_ErrGetFileDesc" )
+   
+   UINT  uResult;
+//   DWORD  uVerSize;
+   UINT  uItemSize;
+   DWORD dwSize;
+   DWORD dwVerHandle;
+   LPSTR lpszBuffer;                                           
+   LPBYTE   lpbVerData;
+//   char  szItem[CPL_MAX_STRING];
+   char  szItem[1000];
+      
+   lpbVerData = NULL;   
+   lstrcpy( lpszDesc, lpszFile );   // returns filename as description if we have any errors
+   
+   if ((dwSize = GetFileVersionInfoSize( lpszFile, &dwVerHandle )) == 0)
+      {
+       DEBOUT1( "GetFileVersionInfoSize failure for %s", (LPSTR)lpszFile );
+      uResult = CPL_BAD_DRIVER;
+      goto  done;
+      }  // end if
+
+   lpbVerData = (LPBYTE)GlobalAllocPtr( GPTR, dwSize + 10 );      // this lib sucks, and I don't trust them too much
+   if ( lpbVerData == NULL )
+      {
+      uResult = CPL_ERR_MEMORY;
+      goto  done;
+      }  // end if
+      
+//   DBGOUT((1, "GetFIleVersionInfo"));
+
+   if ( GetFileVersionInfo( lpszFile, dwVerHandle, dwSize, lpbVerData ) == FALSE )
+      {
+       DEBOUT1( "GetFileVersionInfo failure for %s", (LPSTR)lpszFile );
+      uResult = CPL_BAD_DRIVER;
+      goto  done;            
+      }  // end if
+   
+//   DBGOUT((1, "strcpy"));
+
+   lstrcpy( szItem, gszVarFileInfo );     // bug in VerQueryValue, can't handle static CS based str
+
+//   DBGOUT((1, "VerQueryValue"));
+
+   if ((VerQueryValue( lpbVerData, szItem, &lpszBuffer, (LPUINT)&uItemSize ) == FALSE) || (uItemSize == 0))
+      {
+       DEBOUT2( "ERROR:  VerQueryValue failure for %s on file %s", (LPSTR)szItem, (LPSTR)lpszFile );
+      uResult = CPL_SUCCESS;     // does not matter if this did not work!
+      goto  done;
+      }  // end if
+
+//   wsprintf( szItem, gszStringFileInfo, (LPVOID)*(LPWORD)lpszBuffer, (LPVOID)*(((LPWORD)lpszBuffer)+1) );
+   wsprintf( szItem, gszStringFileInfo, (WORD)*(LPWORD)lpszBuffer, (WORD)*(((LPWORD)lpszBuffer)+1) );
+      
+//   DBGOUT((1, "VerQueryValue2"));
+
+   if ((VerQueryValue( lpbVerData, szItem, &lpszBuffer, (LPUINT)&uItemSize ) == FALSE) || (uItemSize == 0))
+      {
+       DEBOUT2( "ERROR:  VerQueryValue failure for %s on file %s", (LPSTR)szItem, (LPSTR)lpszFile );
+      uResult = CPL_SUCCESS;     // does not matter if this did not work!
+      goto  done;
+      }  // end if
+      
+   lstrcpy( lpszDesc, lpszBuffer );
+
+   uResult = CPL_SUCCESS;
+   
+done:      
+
+   if ( lpbVerData )
+      GlobalFreePtr( lpbVerData );
+     
+//   DBGOUT((1, "Leaving _ErrGetFileDesc - uResult= %d", uResult));
+
+   return( uResult );      
+}
+
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrFillAddList
+   
+   Purpose:    
+   
+\*--------------------------------------------------------------------------*/
+UINT  PRIVATE   _ErrFillAddList( HWND  hWnd, 
+                UINT  uControl )
+                
+   {
+   FUNC_ENTRY( "_ErrFillAddList" )
+   
+   UINT  uIndex;
+   UINT  uResult;
+   LPSTR lpszDrvFile;
+#ifdef _WIN32
+   HANDLE hFindFile;
+   WIN32_FIND_DATA ftFileInfo;
+#else
+   struct _find_t ftFileInfo;
+#endif
+   char  szFullPath[CPL_MAX_PATH];
+   char  szDrvDescription[CPL_MAX_STRING];
+   // char gszDriverFiles[]     - global string in code segment
+   extern CPL  gCPL;       // app global
+
+   SendDlgItemMessage( hWnd, uControl, WM_SETREDRAW, FALSE, 0 );
+   SendDlgItemMessage( hWnd, uControl, LB_RESETCONTENT, 0, 0 );
+
+   // get full path to windows/system dir
+   //------------------------------------      
+   if ( GetSystemDirectory( szFullPath, sizeof(szFullPath)) == FALSE )
+      {
+      uResult = CPL_APP_ERROR;      
+      goto  done;
+      }  // end if
+
+//   DBGOUT((1, "Systemdir==%s", szFullPath));
+
+   uIndex = (UINT)lstrlen( szFullPath );      
+
+   if ((uIndex > 0) && (szFullPath[uIndex-1] != '\\'))
+      lstrcat( szFullPath, gszDriverFiles );          // add the '\' 
+   else  
+      lstrcat( szFullPath, gszDriverFiles + 1 );      // ignore the '\' (root dir)
+      
+   // find all the entries in the system dir
+   //---------------------------------------
+
+#ifdef _WIN32
+
+//   DBGOUT((1, "Lookin for: %s", szFullPath));
+
+   hFindFile = FindFirstFile( szFullPath, &ftFileInfo );
+   uResult = 0;
+   if (hFindFile == INVALID_HANDLE_VALUE)
+   {
+      DBGOUT((1, "FindFirstFile failed, 0x%08lx", GetLastError() ));
+      uResult = 1;
+   }
+
+
+#else
+   uResult = (UINT)_dos_findfirst( szFullPath, _A_NORMAL | _A_RDONLY | _A_HIDDEN | _A_SYSTEM, &ftFileInfo );
+#endif
+   
+   while ( uResult == 0 )
+   {
+      // alloc and set the file name to be assocated with each driver
+      //-------------------------------------------------------------
+
+#ifdef _WIN32
+      if ((lpszDrvFile = GlobalAllocPtr( GPTR, lstrlen( ftFileInfo.cFileName ) + 1)) == NULL )
+      {
+          uResult = CPL_ERR_MEMORY;
+          goto  done;
+      }
+
+      lstrcpy( lpszDrvFile, ftFileInfo.cFileName );
+
+#else         
+      if ((lpszDrvFile = GlobalAllocPtr( GPTR, lstrlen( ftFileInfo.name ) + 1)) == NULL )
+      {
+          uResult = CPL_ERR_MEMORY;
+          goto  done;
+      }
+
+      lstrcpy( lpszDrvFile, ftFileInfo.name );
+#endif
+      
+     DEBOUT1( "Examining file %s", (LPSTR)lpszDrvFile );
+     
+// cbb, should we make a full path???      
+      if ((uResult = _ErrGetFileDesc( lpszDrvFile, szDrvDescription )) != CPL_SUCCESS )
+          {
+          DEBOUT1( "No description for %s.  Default to filename.", lpszDrvFile );
+          
+          /* Filename will have to suffice */
+          lstrcpy( (LPSTR)szDrvDescription, lpszDrvFile );
+            }
+
+      // Verify that provider has install routine
+      //-----------------------------------------
+      if (!_FVerifyProcExists( lpszDrvFile, gszProviderInstall ))
+      goto next_driver;
+
+      // slam it into the list box
+      //--------------------------
+      uIndex = (UINT)SendDlgItemMessage( hWnd, uControl, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szDrvDescription );
+      if ( uIndex == CB_ERR )
+         {
+         uResult = CPL_APP_ERROR;
+         goto  done;
+         }  // end if
+
+      if ( SendDlgItemMessage( hWnd, uControl, LB_SETITEMDATA, uIndex, (LPARAM)lpszDrvFile ) == CB_ERR )
+         {
+           uResult = CPL_APP_ERROR;
+          goto  done;
+         }  // end if
+
+next_driver:
+     
+#ifdef _WIN32
+      uResult = 1;
+      if (FindNextFile( hFindFile, &ftFileInfo ))
+         {
+         uResult = 0;
+         } // end if
+#else
+      uResult = (UINT)_dos_findnext( &ftFileInfo );
+#endif
+      }  // end while
+      
+
+
+// We changed the dialog to have a "Have Disk..." button instead of this entry
+// bjm - 3/2/96
+//   // Insert "Unlisted or Updated Driver" entry at the top of the list
+//   //-----------------------------------------------------------------
+//   LoadString( gCPL.hCplInst, IDS_UPDATED, (LPSTR)szDrvDescription, CPL_MAX_STRING );
+//  
+//   uIndex = (UINT)SendMessage( GetDlgItem( hWnd, uControl ), LB_INSERTSTRING, 0, (LPARAM)(LPSTR)szDrvDescription );
+//   if ( uIndex == CB_ERR )
+//      {
+//      uResult = CPL_APP_ERROR;
+//      goto  done;
+//      }  // end if
+//
+//   if ( SendDlgItemMessage( hWnd, uControl, LB_SETITEMDATA, uIndex, (LPARAM)0 ) == CB_ERR )
+//      {
+//      uResult = CPL_APP_ERROR;
+//         goto  done;
+//        }  // end if
+//   
+
+
+   uResult = CPL_SUCCESS;
+      
+   done:
+      SendDlgItemMessage( hWnd, uControl, LB_SETCURSEL, 0, 0 );    // set focus to the top guy
+      SendMessage( hWnd, WM_COMMAND, uControl, MAKELONG( GetDlgItem( hWnd, uControl ), LBN_SELCHANGE ));
+     
+      SendDlgItemMessage( hWnd, uControl, WM_SETREDRAW, TRUE, 0 );
+      
+      return( uResult );
+   }  // end _ErrFillAddList
+
+   
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrAddProvider
+   
+   Purpose:    Call lineAddProvider
+                                           
+\*--------------------------------------------------------------------------*/
+UINT  PRIVATE   _ErrAddProvider( HWND    hWnd, 
+                UINT    uControl,
+                LPSTR   lpszDriverFile )
+{
+    FUNC_ENTRY( "_ErrAddDriver" )
+    
+   UINT  uIndex;
+   UINT  uResult;
+   LONG  lResult;
+   DWORD dwProviderID;
+
+   if ( lpszDriverFile == NULL )
+   {
+       DBG_ASSERT( hWnd, "Simultaneously NULL pointer & hwnd" );
+       
+      // get the stuff from the list box
+      //--------------------------------
+      uIndex = (UINT)SendDlgItemMessage( hWnd, uControl, LB_GETCURSEL, 0, 0 );
+      lpszDriverFile = (LPSTR)SendDlgItemMessage( hWnd, uControl, LB_GETITEMDATA, uIndex, 0 );
+
+      if (lpszDriverFile == NULL)
+       {
+             uResult = CPL_APP_ERROR;
+             goto  done;
+         }  // end if
+   }
+
+   lResult = lineAddProvider( lpszDriverFile, hWnd, &dwProviderID );
+
+   if (lResult)
+   {
+        DEBOUT1( "Error: lineAddProvider failure %#08lx", lResult );
+       TapiErrReport( hWnd, lResult );
+       if ( LINEERR_NOMULTIPLEINSTANCE == lResult )
+          uResult = CPL_ERR_TAPI_NOMULTIPLEINSTANCE;
+       else
+          uResult = CPL_ERR_TAPI_FAILURE;
+       goto done;
+   }
+   
+   uResult = CPL_SUCCESS;
+      
+   done:
+   
+   return( uResult );
+}  // end _ErrAddProvider
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   _ErrBrowserAdd
+   
+   Purpose:    Use the common open dialog to add an new driver...
+   
+\*--------------------------------------------------------------------------*/
+UINT  PRIVATE   _ErrBrowserAdd( HWND    hWnd, 
+                               UINT    uControl )
+   {
+   UINT  uResult;
+   OPENFILENAME ofn;
+   char szFilePath[CPL_MAX_PATH];
+   char szFileName[CPL_MAX_STRING];
+   extern CPL  gCPL;       // app global
+   // char gszOpenFileNameFilter[]   - global string in code segment
+
+   uResult = IDCANCEL;     // don't do all the ok stuff
+   
+   // do the common open dialog to get a file to browse
+   //--------------------------------------------------                       
+   szFilePath[0] = '\0';
+#if WIN32
+   ZeroMemory( &ofn, sizeof( OPENFILENAME ));
+#else
+   _fmemset( &ofn, 0, sizeof( OPENFILENAME ));
+#endif
+         
+   ofn.lStructSize    = sizeof( OPENFILENAME );
+   ofn.hwndOwner      = hWnd;
+   ofn.hInstance      = gCPL.hCplInst;
+   ofn.lpstrFilter    = NULL; //gszOpenFileNameFilter;
+//   ofn.nFilterIndex   = 2;  // *.inf   
+   ofn.lpstrFile      = szFilePath; 
+   ofn.nMaxFile       = sizeof( szFilePath );  
+   ofn.lpstrFileTitle = szFileName;
+   ofn.nMaxFileTitle  = sizeof( szFileName );  
+   ofn.Flags          = OFN_HIDEREADONLY | OFN_SHOWHELP | 
+                        OFN_ENABLETEMPLATE | OFN_NOVALIDATE;
+   ofn.lpTemplateName = MAKEINTRESOURCE( IDD_BROWSE_TEMPLATE );
+   
+   if ( GetOpenFileName( &ofn ) == 0 )
+      goto  done;    // there was a problem or the user hit cancel - either way do nothing...
+
+   // got the file name, now add it...
+   //---------------------------------   
+//   if ((uResult = _ErrAddProvider( hWnd, IDCL_AD_DRIVER_LIST, ofn.lpstrFile )) == CPL_SUCCESS )
+//      *lpuResult = IDOK;     // don't do all the ok stuff
+
+   SetDlgItemText( hWnd, uControl, ofn.lpstrInitialDir );
+   uResult = IDOK;     // don't do all the ok stuff
+   
+   done:
+      return( uResult );
+   }  // end _ErrBrowserAdd
+   
+   
+/*--------------------------------------------------------------------------*\
+
+   Function:   FDlgDriverList
+   
+   Purpose:    
+   
+\*--------------------------------------------------------------------------*/
+BOOL EXPORT FDlgDriverList( HWND  hWnd, 
+                 UINT  wMessage, 
+                 WPARAM  wParam, 
+                 LPARAM  lParam )
+{
+    FUNC_ENTRY( "FDlgDriverList" )
+    
+   UINT  uResult;
+   UINT  uUpdated;
+   LPDRIVER   lpDrv;
+   extern CPL  gCPL;       // app global
+   LPSTR lpszProviderFilename;
+   DWORD dwProviderID;
+   LONG  lResult;
+   FARPROC lpfnLineCallBack;
+   
+// table of controls and context-sensitive help IDs
+
+    static DWORD aIds[] = {
+        IDCL_DS_LIST, IDH_TELCPL_INSTALLED_DRIVERS,
+        IDCB_DS_ADD, IDH_TELCPL_ADD,
+        IDCB_DS_REMOVE, IDH_TELCPL_REMOVE,
+        IDCB_DS_EDIT, IDH_TELCPL_SETUP,
+        IDCB_DS_DIAL_HELPER, IDH_TELCPL_DIALHELPER,
+        IDCB_DS_DIAL_PREF, IDH_TELCPL_DIALHELPER,
+        IDCB_DS_DIAL_PREF_TEXT, IDH_TELCPL_DIALHELPER,
+        0, 0
+    };
+
+    
+//   DBGOUT((1, "Checking a message msg=0x%08lx wparam=0x%08lx",(DWORD)wMessage,(DWORD)wParam));
+
+   switch( wMessage )
+   {
+
+
+    // Process clicks on controls after Context Help mode selected
+    case WM_HELP:
+        WinHelp (((LPHELPINFO) lParam)->hItemHandle, gszHelpFile, HELP_WM_HELP, 
+            (DWORD)(LPSTR) aIds);
+        uResult = FALSE;
+        break;
+
+
+    // Process right-clicks on controls            
+    case WM_CONTEXTMENU:
+        WinHelp ((HWND) wParam, gszHelpFile, HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+        uResult = FALSE;
+        break;
+
+
+   case  WM_INITDIALOG:
+
+//        DBGOUT((1, "Doing WM_INITDIALOG"));
+
+        // initalize all the fields
+        //-------------------------
+        if ((uResult = _ErrFillList( hWnd, IDCL_DS_LIST, &uUpdated )) != CPL_SUCCESS )
+           goto  error;
+
+        if ( uUpdated == TRUE )            
+        {
+           SetWindowLong( hWnd, DWL_USER, TRUE );
+            EnableWindow( GetDlgItem( hWnd, IDOK ), FALSE);
+        }
+        else   
+        {
+           SetWindowLong( hWnd, DWL_USER, FALSE );      // haven't disabled cancel
+        }
+        
+
+        uResult      = (UINT)SendDlgItemMessage( hWnd, IDCL_DS_LIST, LB_GETCURSEL, 0, 0 );
+        dwProviderID = (DWORD)SendDlgItemMessage( hWnd, IDCL_DS_LIST, LB_GETITEMDATA, uResult, 0 );
+        lpszProviderFilename = _LpszProviderIDToFilename( dwProviderID );
+
+        //
+        // enable/disable the remove button
+        //
+        EnableWindow( GetDlgItem( hWnd, IDCB_DS_REMOVE ),
+                                (lpszProviderFilename != NULL) &&
+                                _FVerifyProcExists( lpszProviderFilename,
+                                                     gszProviderRemove ) );
+        //
+        // enable/disable the setup button
+        //
+        EnableWindow( GetDlgItem( hWnd, IDCB_DS_EDIT),
+                                (lpszProviderFilename != NULL) &&
+                                _FVerifyProcExists( lpszProviderFilename,
+                                                     gszProviderSetup ) );
+
+        uResult = TRUE;
+        
+//        DBGOUT((1, "Leaving WM_INITDIALOG"));
+        break;
+
+
+#ifdef CTL3D
+    case  WM_SYSCOLORCHANGE:
+       CplSysColorChange();
+      break;
+#endif /* CTL3D */
+
+
+   case  WM_COMMAND:
+   
+        // do some work with the buttons
+        //------------------------------
+        
+        switch ( GET_WM_COMMAND_ID( wParam, lParam ) )
+        {
+        case  IDCB_DS_ADD:
+     
+//          DBGOUT((1, "Doing IDCL_DS_ADD"));
+
+           // add a new driver
+           //-----------------
+           if ( LDialogBox( IDD_ADD_DRIVER, hWnd, (DLGPROC)FDlgAddDriver, 0 ) == IDOK )
+            {
+                 if ((uResult = _ErrFillList( hWnd, IDCL_DS_LIST, &uUpdated )) != CPL_SUCCESS )   // in with the new
+                   goto  error;
+
+                 if ( SetWindowLong( hWnd, DWL_USER, TRUE ) == FALSE )    // modified
+                     PropSheet_CancelToClose( GetParent( hWnd ) );
+                     
+             }  // end if
+             
+          break;
+
+           
+       case  IDCL_DS_LIST:
+       
+//          DBGOUT((1, "Doing IDCL_DS_LIST"));
+
+          // do the list stuff
+          //------------------
+          uResult      = (UINT)SendDlgItemMessage( hWnd, IDCL_DS_LIST, LB_GETCURSEL, 0, 0 );
+          dwProviderID = (DWORD)SendDlgItemMessage( hWnd, IDCL_DS_LIST, LB_GETITEMDATA, uResult, 0 );
+          lpszProviderFilename = _LpszProviderIDToFilename( dwProviderID );
+
+//          DBGOUT((1, "lpszProviderFilename = %s", lpszProviderFilename));
+
+          if ( GET_WM_COMMAND_CMD( wParam, lParam ) == LBN_SELCHANGE )
+          {
+
+//              DBGOUT((1, "SELCHANGE"));
+
+              if (((lpszProviderFilename == NULL)) && 
+                  (GetFocus() == GetDlgItem( hWnd, IDCB_DS_EDIT )))
+              {
+                 SetFocus( GetDlgItem( hWnd, IDOK ));   // focus problem
+              }
+
+              //
+              // enable/disable the setup button
+              //
+              EnableWindow( GetDlgItem( hWnd, IDCB_DS_EDIT),
+                                       (lpszProviderFilename != NULL) &&
+                                       _FVerifyProcExists( lpszProviderFilename,
+                                                           gszProviderSetup ) );
+
+//            if (((lpszProviderFilename == NULL)) &&
+//                 (GetFocus() == GetDlgItem( hWnd, IDCB_DS_REMOVE )))
+//                SetFocus( GetDlgItem( hWnd, IDOK ));   // focus problem
+                
+
+              //
+              // enable/disable the remove button
+              //
+               EnableWindow( GetDlgItem( hWnd, IDCB_DS_REMOVE ),
+                                       (lpszProviderFilename != NULL) &&
+                                       _FVerifyProcExists( lpszProviderFilename,
+                                                            gszProviderRemove ) );
+               break;
+          }
+          else if ((GET_WM_COMMAND_CMD( wParam, lParam ) != LBN_DBLCLK) || 
+                     (lpszProviderFilename == NULL) ||
+                     !IsWindowEnabled( GetDlgItem( hWnd, IDCB_DS_EDIT ) ))
+          {
+               break;  // done
+          }
+          // fall through, treat the double click like an edit message                  
+           
+
+        case  IDCB_DS_EDIT:
+
+//          DBGOUT((1, "Doing IDCL_DS_EDIT"));
+
+           // do the setup on an existing driver
+           //-----------------------------------
+           uResult = _ErrSetupDriver( hWnd, IDCL_DS_LIST );
+           if ( uResult != CPL_SUCCESS )
+              goto  error;               
+          
+           if ( SetWindowLong( hWnd, DWL_USER, TRUE ) == FALSE )    // modified
+                  PropSheet_CancelToClose( GetParent( hWnd ) );
+           break;
+          
+ 
+        case  IDCB_DS_REMOVE:
+
+//          DBGOUT((1, "Doing IDCL_DS_REMOVE"));
+
+           // remove an old driver
+           //---------------------
+           if ( ErrMsgBox( hWnd, IDS_DRIVER_REMOVE_OR_STUPID, MB_YESNO | MB_DEFBUTTON2 ) == IDYES )
+             {
+             if ( SetWindowLong( hWnd, DWL_USER, TRUE ) == FALSE )    // modified
+                   PropSheet_CancelToClose( GetParent( hWnd ) );
+             
+             uResult = _ErrRemoveDriver( hWnd, IDCL_DS_LIST );
+             if ( uResult != CPL_SUCCESS )
+                goto  error;               
+             }  // end if                     
+           break;
+           
+
+         case IDCB_DS_DIAL_HELPER:
+
+//             DBGOUT((1, "Doing IDCL_DS_DIAL_HELPER"));
+
+             lpfnLineCallBack = MakeProcInstance( (FARPROC)_LineCallBackProc, 
+                                                               gCPL.hCplInst );
+
+             if (!lpfnLineCallBack)
+             {
+                  uResult = CPL_ERR_MEMORY;
+                  goto error;
+             }
+             
+              lResult = lineInitialize( (LPHLINEAPP)&_hlineapp, 
+                                                  gCPL.hCplInst, 
+                                                  (LINECALLBACK)lpfnLineCallBack, 
+                                            (LPCSTR)szTapiAppName, 
+                                            (LPDWORD)&_dwNumDevs );
+            if (lResult)
+            {
+                 DEBOUT1( "Error: lineInitialize failure %#08lx", lResult );
+               TapiErrReport( hWnd, lResult );
+               uResult = CPL_ERR_TAPI_FAILURE;
+                FreeProcInstance( lpfnLineCallBack );
+               goto error;
+            }
+
+            lineTranslateDialog( _hlineapp, 0, 0x00010004, hWnd, NULL );
+            lineShutdown( _hlineapp );
+            FreeProcInstance( lpfnLineCallBack );
+            
+            break;
+
+
+        case  IDCB_DS_HELP:
+           goto DoHelp;
+        }  // end case
+        
+     uResult = TRUE;            
+     break;
+     
+
+      default:
+         // hook for context sensitive help (F1 key)
+         if (wMessage == gCPL.uHelpMsg)
+            {
+DoHelp:
+//            Help( hWnd, CPL_HLP_DRIVER_SETUP );
+           // CPHelp(hDlg);
+            uResult = TRUE;
+            }
+         else
+            uResult = FALSE;
+      }  // end case
+      
+//   DBGOUT((1, "Leaving message handler - uResult=0x%08lx",(DWORD)uResult));
+
+   return( uResult );
+
+
+
+   error:
+
+       DBGOUT((1, "Leaving message handler - ERROR! uResult=0x%08lx",(DWORD)uResult));
+
+      if ( FErrorRpt( hWnd, uResult ))
+          EndDialog( hWnd, IDCANCEL );
+
+      return( TRUE );
+}
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   FDlgAddDriver
+   
+   Purpose:    
+   
+\*--------------------------------------------------------------------------*/
+BOOL EXPORT FDlgAddDriver( HWND  hWnd, 
+                 UINT  wMessage, 
+                 WPARAM  wParam, 
+                 LPARAM  lParam )
+   {
+   UINT  uResult;
+   UINT  uDlgResult;
+   LPDRIVER   lpDrv;
+   extern CPL  gCPL;       // app global
+   
+// table of controls and context-sensitive help IDs
+
+    static DWORD aIds[] = {
+        IDCL_AD_DRIVER_LIST, IDH_TELCPL_ADD_AVAILABLE_DRIVERS,
+        IDCB_AD_ADD, IDH_TELCPL_ADD_ADD,
+        0, 0
+    };
+
+    
+   switch( wMessage )
+      {
+        // Process clicks on controls after Context Help mode selected
+        case WM_HELP:
+            WinHelp (((LPHELPINFO) lParam)->hItemHandle, gszHelpFile, HELP_WM_HELP, 
+                (DWORD)(LPSTR) aIds);
+            uResult = FALSE;
+            break;
+
+        // Process right-clicks on controls            
+        case WM_CONTEXTMENU:
+            WinHelp ((HWND) wParam, gszHelpFile, HELP_CONTEXTMENU, (DWORD)(LPVOID) aIds);
+            uResult = FALSE;
+            break;
+
+      case  WM_INITDIALOG:
+      // initalize all the fields
+      //-------------------------
+      if ((uResult = _ErrFillAddList( hWnd, IDCL_AD_DRIVER_LIST )) != CPL_SUCCESS )
+         goto  error;
+
+      if ( SendDlgItemMessage( hWnd, IDCL_AD_DRIVER_LIST, LB_GETCOUNT, 0, 0 ) <= 0 )
+         EnableWindow( GetDlgItem( hWnd, IDCB_AD_ADD ), FALSE );   // can't add if nothing to add, could bring up the browse dialog?
+        
+      uResult = TRUE;            
+      break;
+                                                   
+      case  WM_COMMAND:
+      // do some work with the buttons
+      //------------------------------
+      switch ( GET_WM_COMMAND_ID(wParam, lParam) )
+         {
+         case  IDCB_HAVE_DISK:
+         {
+               // Add unlisted driver.
+               _FAddUnlisted( hWnd );
+         }
+         break;
+             
+         case  IDCL_AD_DRIVER_LIST:
+
+            // do the list stuff
+            //------------------
+            if ((GET_WM_COMMAND_CMD( wParam, lParam ) != LBN_DBLCLK) || (SendDlgItemMessage( hWnd, IDCL_AD_DRIVER_LIST, LB_GETCOUNT, 0, 0 ) <= 0 ))
+            break;      // done
+            // fall through, threat the double click like an add message                  
+           
+// moved this case up so we can really fall through to add
+//         case  IDCB_HAVE_DISK:
+//         {
+               // Add unlisted driver.
+//               _FAddUnlisted( hWnd );
+//         }
+//         break;
+
+
+         case  IDCB_AD_ADD:
+
+            // add a new driver
+            //-----------------
+         
+
+// This was dropped when we moved this functionality to the "Have Disk..."
+// button - bjm 3/2
+//   
+//            if (SendDlgItemMessage( hWnd, IDCL_AD_DRIVER_LIST, LB_GETCURSEL, 0, 0 ) == 0)
+//               {
+//               // Add unlisted driver.
+//               if (!_FAddUnlisted( hWnd ))
+//                  break;
+//               }
+//            else
+
+
+               if ((uResult = _ErrAddProvider( hWnd, IDCL_AD_DRIVER_LIST, NULL )) != CPL_SUCCESS )
+               goto  error;
+ 
+             // fall through, exit the dialog
+            wParam = IDOK;
+                            
+         case  IDOK:
+         case  IDCANCEL:
+            EndDialog( hWnd, wParam );
+            break;
+           
+         case  IDCH_AD_HELP:
+            goto DoHelp;
+         }  // end case
+        
+         uResult = TRUE;            
+         break;
+
+      default:
+         // hook for context sensitive help (F1 key)
+         if (wMessage == gCPL.uHelpMsg)
+            {
+DoHelp:
+//            Help( hWnd, CPL_HLP_ADD_DRIVER );
+            // CPHelp(hDlg);
+            uResult = TRUE;
+            }
+         else
+            uResult = FALSE;
+      }  // end case
+      
+   return( uResult );
+
+   error:
+      if ( FErrorRpt( hWnd, uResult ))
+      EndDialog( hWnd, IDCANCEL );
+      return( TRUE );
+   }  // end FDlgAddDriver
+   
+  
+/*
+**  DLG: LB_AVAILABLE
+**
+**  InitAvailable()
+**
+**  Add the available drivers from setup.inf to the passed list box.
+**  The format of [Installable.drivers] in setup.inf is:
+**  profile=disk#:driverfile,"type1,type2","Installable driver Description","vxd1.386,vxd2.386","opt1,2,3"
+**
+**  for example:
+**
+**  driver1=6:sndblst.drv,"midi,wave","SoundBlaster MIDI and Waveform drivers","vdmad.386,vadmad.386","3,260"
+*/
+BOOL PRIVATE _FInitAvailable( HWND hWnd )
+{
+    PINF    pinf;
+    BOOL    bInitd=FALSE;
+    PSTR    pstrKey;
+    int     iIndex;
+    char    szDesc[CPL_MAX_INF_LINE_LEN];
+    
+    SendMessage(hWnd, WM_SETREDRAW, FALSE, 0L);
+    // Parse the list of keywords and load their strings
+    //    
+
+    for (pinf = infFindSection(NULL, gszInstallDrvSec); pinf; pinf = infNextLine(pinf))
+    {
+        //
+        // found at least one keyname!
+        //
+        bInitd = TRUE;
+        pstrKey = (PSTR)LocalAlloc(LPTR, CPL_MAX_SYS_INF_LEN);
+        if ( pstrKey )
+                infParseField(pinf, 0, pstrKey);
+        else
+            break;
+        //
+        // add the installable driver's description to listbox, and filename as data
+        //
+
+        infParseField(pinf, 3, szDesc);
+    
+        iIndex = (int)SendMessage(hWnd, LB_ADDSTRING, 0, (LONG)(LPSTR)szDesc);
+        if (iIndex != LB_ERR )
+            SendMessage(hWnd, LB_SETITEMDATA, iIndex, MAKELONG(pstrKey, 0));
+
+    }
+    
+    if (bInitd)
+       SendMessage(hWnd, LB_SETCURSEL, 0, 0L );
+
+    SendMessage(hWnd,WM_SETREDRAW, TRUE, 0L);    
+    return(bInitd);
+}
+
+/*
+**  _FInstallDrivers()
+**
+**  Install a driver and set of driver types.  
+*/
+BOOL PRIVATE _FInstallDrivers(HWND hWnd, LPSTR pstrKey)
+   {
+    PIDRIVER    pIDriver=NULL;
+    int         i, n,iIndex;
+    HWND        hWndI;
+    static IDRIVER  IDTemplate;     // temporary for installing, removing, etc.
+    static char szTemp[MAXSTR];        // this static stuff is fucked
+    static char szTypes[MAX_VDD_LEN],
+                szType[MAX_VDD_LEN];
+
+    szTypes[0] = '\0';
+    
+    hMesgBoxParent = hWnd;            
+
+    // mmAddNewDriver needs a buffer for all types we've actually installed
+    // User critical errors will pop up a task modal
+    IDTemplate.bRelated = FALSE;
+    IDTemplate.szRemove[0] = '\0';
+   
+    if (!mmAddNewDriver(pstrKey, szTypes, &IDTemplate))
+        return FALSE; 
+    
+    szTypes[lstrlen(szTypes)-1] = '\0';
+
+    // At this point we assume the drivers are actually copied.
+    // Now we need to add them to the installed list.
+    // For each driver type we create an IDRIVER and add to the listbox
+     
+    // Install driver in telephon.ini
+    if (_ErrAddProvider( hWnd, 0, IDTemplate.szFile ) != CPL_SUCCESS )
+       return FALSE;
+    
+    if (IDTemplate.bRelated == TRUE)
+    {
+
+      bCopyingRelated = TRUE;
+      for (i = 1; infParseField(IDTemplate.szRelated, i, szTemp);i++)
+          _FInstallDrivers(hWnd, (LPSTR)szTemp);
+    }
+    
+   return TRUE;
+   }
+   
+/* 
+*
+*   The following function processes requests by the user to install unlisted
+*   or updated drivers.
+*
+*/
+
+BOOL EXPORT FDlgAddUnlisted(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
+   {
+   HWND hWndT, hWndLB;            
+   int iIndex, iCount;
+   PSTR pstrKey;
+   BOOL bFoundDrivers, bOneInstalled;
+   extern CPL  gCPL;       // app global
+
+   switch (nMsg)
+      {
+      case WM_INITDIALOG:
+         {
+         wsStartWait();    
+         hWndLB = GetDlgItem(hWnd, LB_UNLISTED);
+
+         /* Search for drivers */
+         bFoundDrivers = _FInitAvailable( hWndLB );
+         if (!bFoundDrivers)
+            EndDialog(hWnd, FALSE);
+         else 
+            {
+            // SendMessage(hWndLB, LB_SETCURSEL, 0, 0L);
+            // select all
+            SendMessage(hWndLB, LB_SETSEL, 1, MAKELONG(-1, 0));
+            }
+
+         wsEndWait();    
+         break;
+         }
+
+      case WM_COMMAND:
+         switch (wParam)
+         {
+         case IDH_DLG_ADD_UNKNOWN:
+            goto DoHelp;
+
+         case LB_UNLISTED:
+            if (HIWORD(lParam) != LBN_DBLCLK)
+               break;
+
+            // else Fall through here 
+         case IDOK:
+
+            bCopyingRelated = FALSE;            
+            bQueryExist = TRUE;
+            bOneInstalled = FALSE;
+    
+            hWndLB = GetDlgItem(hWnd, LB_UNLISTED);
+            iCount = (int)SendMessage(hWndLB, LB_GETCOUNT, 0, 0L);
+
+            wsStartWait();
+
+            for (iIndex = 0; iIndex < iCount; iIndex++)
+               {
+               if (SendMessage(hWndLB, LB_GETSEL, iIndex, 0L) == 0)
+                  continue;
+    
+               pstrKey = (PSTR)SendMessage(hWndLB, LB_GETITEMDATA, iIndex, 0L);
+               if (!pstrKey)
+                  continue;
+    
+               if (_FInstallDrivers(hWnd, pstrKey))
+                  bOneInstalled = TRUE;
+               else
+                  break;
+               }
+            wsEndWait();
+    
+            if (bOneInstalled)
+               {
+//CBB-Mike: Put new driver into "installed drivers" dialog
+//               hWndT = GetDlgItem(hWndMain, LB_INSTALLED);
+//               PostMessage(hWndT, LB_SETCURSEL, 0, 0L);    
+//               PostMessage(hWndMain, WM_COMMAND, LB_INSTALLED, MAKELONG(hWndT, LBN_SELCHANGE));
+
+//CBB-Mike: Restart Dialog?    
+//               if (bRestart)
+//                  {
+//                  iRestartMessage = IDS_RESTART_ADD;                   
+//                  DialogBox(myInstance, MAKEINTRESOURCE(DLG_RESTART), hWnd, FDlgRestart);
+//                  }
+               }
+    
+            bRelated = FALSE;                        
+            bRestart = FALSE;
+            EndDialog(hWnd, FALSE);
+            break;
+
+         case IDCANCEL:
+            EndDialog(hWnd, wParam);
+            break;
+
+         default:
+            return FALSE;
+         }
+      default:
+         if (nMsg == gCPL.uHelpMsg)
+            {
+DoHelp:
+//            Help( hWnd, CPL_HLP_ADD_UNLISTED );
+            break;
+            }
+         else
+            return FALSE;
+      }
+   return TRUE;
+   }
+
+BOOL PRIVATE _FAddUnlisted( HWND hWnd )
+   {
+   OFSTRUCT of;
+   int result;
+   char szPath[CPL_MAX_PATH];
+   char szUnlisted[CPL_MAX_STRING];
+   extern CPL  gCPL;       // app global
+   
+   szPath[0] = 0;
+   
+   while (1)
+      {
+      // ********************* INSERT DISK DIALOG *******************
+      
+      // CBB-MIKE: These strings should probably be placed in gCPL
+      LoadString( gCPL.hCplInst, IDS_UNLISTED, szUnlisted, CPL_MAX_STRING );  
+      result = InsertDisk( hWnd, szUnlisted, gszOemInf, NULL, szDiskPath, NULL, 0);
+      
+      if (result != IDOK)
+         return FALSE;
+      
+      // Concatenate "oemsetup.inf" to path
+      lstrcpy(szPath, szDiskPath);
+      lstrcat(szPath, szOemInf);
+     
+      if (OpenFile(szPath, &of, OF_EXIST) == -1)
+         continue;
+
+      gCPL.pInfOldDefault = infSetDefault(infOpen(of.szPathName));
+
+      LDialogBox( IDD_UPDATE, hWnd, (DLGPROC) FDlgAddUnlisted, (LPARAM)0 );
+      
+      break;
+      } 
+   return TRUE;
+   }
+
+/*
+**
+** Offer user the choice to (not) restart windows.
+*/
+BOOL FAR PASCAL  FDlgRestart(HWND hDlg, UINT uiMessage, WPARAM wParam, LPARAM lParam)
+{
+    extern CPL  gCPL;       // app global
+    switch (uiMessage)
+    {
+        case WM_COMMAND:
+            switch (wParam)
+            {
+               case IDCANCEL:
+                    //
+                    // don't restart windows
+                    //
+                    EndDialog(hDlg, FALSE);
+                    break;
+
+                case IDOK:
+                    //
+                    // do restart windows, *dont* dismiss dialog incase
+            // the user canceled it.
+                    //
+                ExitWindows((LONG)WEC_RESTART, 0);
+            SetActiveWindow(hDlg);
+                    //EndDialog(hDlg, TRUE);
+                    break;
+
+                default:
+                    return FALSE;
+            }
+            return TRUE;
+
+        case WM_INITDIALOG:
+
+          if (iRestartMessage)
+          {
+            char szMesg1[200];
+            char szMesg2[300];
+          
+               LoadString(gCPL.hCplInst, iRestartMessage, szMesg1, sizeof(szMesg1));
+        wsprintf(szMesg2, szMesg1, (LPSTR)szRestartDrv);
+              SetDlgItemText(hDlg, IDS_RESTARTTEXT, (LPSTR)szMesg2);    
+              }
+              return TRUE;
+
+        case WM_KEYUP:
+            if (wParam == VK_F3)
+                //
+                // don't restart windows
+                //
+                EndDialog(hDlg, FALSE);
+            break;
+
+        default:
+            break;
+    }
+    return FALSE;
+}
+
+
+
+//#ifdef USE_INTERNAL_LSTRSTRI  
+// BUGBUG, replace these with strlib functions
+LPSTR FAR PASCAL lstrstri(LPSTR pszStr, LPSTR pszKey)
+{
+     while (*pszStr) {
+        if (!strncmpi(pszStr, pszKey, lstrlen(pszKey)))
+         return pszStr;
+        else
+             pszStr++;
+     }
+     return(NULL);
+}
+//#endif
+
+
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+UINT WINAPI ErrRefreshProviderList()
+{
+   FUNC_ENTRY( "ErrRefreshProviderList" )
+   
+    LONG lResult;
+
+    
+    if (!glpProviderList)
+    {
+        // Initialize data structure
+        
+        glpProviderList = (LPLINEPROVIDERLIST)GlobalAllocPtr(GPTR, INITIAL_PROVIDER_LIST_SIZE);
+    }
+
+    if (!glpProviderList)
+    {
+        DBGOUT((1, " ErrRefreshProviderList - glpProviderList is NULL - returning CPL_ERR_MEMORY"));
+        return CPL_ERR_MEMORY;
+    }
+        
+    glpProviderList->dwTotalSize = INITIAL_PROVIDER_LIST_SIZE;
+        
+    lResult = lineGetProviderList( TAPI_VERSION, glpProviderList );
+
+    if (lResult)
+    {
+        DBGOUT((1, "Error: lineGetProviderList failure %#08lx", lResult ));
+        TapiErrReport( NULL, lResult );
+        return CPL_ERR_TAPI_FAILURE;
+    }
+
+    while (glpProviderList->dwNeededSize > glpProviderList->dwTotalSize)
+    {
+        // Expand data structure as necessary
+        
+         LPLINEPROVIDERLIST lpTemp = 
+            (LPLINEPROVIDERLIST)GlobalReAllocPtr( glpProviderList,
+                                                    (size_t)(glpProviderList->dwNeededSize),
+                                                    GPTR);
+
+         if (!lpTemp)
+           return CPL_ERR_MEMORY;
+
+       glpProviderList = lpTemp;
+       glpProviderList->dwTotalSize = glpProviderList->dwNeededSize;
+       lResult = lineGetProviderList( TAPI_VERSION, glpProviderList );
+        
+        if (lResult)
+        {
+            DEBOUT1( "Error: lineGetProviderList failure %#08lx", lResult );
+            TapiErrReport( NULL, lResult );
+            return CPL_ERR_TAPI_FAILURE;
+        }
+    }
+
+    DEBOUT1( "%d providers", glpProviderList->dwNumProviders );
+    
+    return CPL_SUCCESS;
+}
+
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+/* _  L P S Z  P R O V I D E R  I  D  T O  F I L E N A M E */
+/*-------------------------------------------------------------------------
+    %%Function: _LpszProviderIDToFilename
+
+    
+-------------------------------------------------------------------------*/
+LPSTR PRIVATE _LpszProviderIDToFilename( DWORD dwProviderID )
+{
+    FUNC_ENTRY( "_LpszProviderIDToFilename")
+    
+    UINT uIndex;
+    LPLINEPROVIDERENTRY lpProviderEntry;
+    
+    DBG_ASSERT( glpProviderList, "NULL glpProviderList!" );
+    
+   // loop through the provider list
+   //-------------------------------   
+
+   lpProviderEntry = (LPLINEPROVIDERENTRY)((char FAR *)(glpProviderList) + 
+                                           glpProviderList->dwProviderListOffset);
+                                           
+   for ( uIndex = 0; uIndex < glpProviderList->dwNumProviders; uIndex++ )
+   {
+       if (lpProviderEntry[uIndex].dwPermanentProviderID == dwProviderID)
+       {
+          // Get an entry to put in the list box
+          //------------------------------------
+           return (char FAR *)(glpProviderList) +
+                                     lpProviderEntry[uIndex].dwProviderFilenameOffset;
+        }
+    }
+
+    DEBOUT1( "Provider ID %d not found in list", dwProviderID );
+    return NULL;
+}
+
+
+/*  _ L I N E  C A L L  B A C K  P R O C */
+/*-------------------------------------------------------------------------
+    %%Function: _LineCallBackProc
+
+    
+-------------------------------------------------------------------------*/
+void FAR PASCAL EXPORT _LineCallBackProc(
+           DWORD dwDevice, DWORD dwMessage, DWORD dwInstance, 
+           DWORD dwParam1, DWORD dwParam2,  DWORD dwParam3 )
+{
+}
diff --git a/private/tapi/dev/cpl/drv.h b/private/tapi/dev/cpl/drv.h
new file mode 100644
index 000000000..40200b313
--- /dev/null
+++ b/private/tapi/dev/cpl/drv.h
@@ -0,0 +1,136 @@
+/*--------------------------------------------------------------------------*\
+   Include File:  drv.h
+
+   Public header for dealing with service prodivers, or drivers in english
+      
+\*--------------------------------------------------------------------------*/
+
+#ifndef  PH_DRV
+#define  PH_DRV
+
+#include "tapicpl.h"
+
+#include <tapi.h>
+
+//----------            
+// Constants
+//----------
+#define TAPI_VERSION               0x00010004
+// BUGBUG:  The following is a hack to avoid a TAPI bug:
+#define INITIAL_PROVIDER_LIST_SIZE 1024
+//#define INITIAL_PROVIDER_LIST_SIZE sizeof(LINEPROVIDERLIST)
+
+//------------
+// Public Data
+//------------
+extern LPLINEPROVIDERLIST glpProviderList;
+
+//--------------------
+// Function Prototypes
+//--------------------
+BOOL EXPORT FDlgDriverList( HWND hWnd, UINT wMessage, WPARAM wParam, LPARAM lParam );
+BOOL EXPORT FDlgAddDriver( HWND hWnd, UINT wMessage, WPARAM wParam, LPARAM lParam );
+BOOL EXPORT FDlgAddUnlisted(HWND hDlg, UINT nMsg, WPARAM wParam, LPARAM lParam);
+//UINT WINAPI ErrRefreshProviderList();
+
+// Append Multimedia stuff
+
+/*  DRIVERS.H
+**
+**  Copyright (C) Microsoft, 1990, All Rights Reserved.
+**
+**
+**  Multimedia Control Panel Drivers Applet.
+**
+**  Display a list of all installed drivers, allow user to configure
+**  existing or install new ones.
+**
+*/
+#include <dlgs.h>
+#include <commdlg.h>
+
+#ifdef DEBUG
+#define DOUT(x) (OutputDebugString("DRIVERS.CPL: "), OutputDebugString(x), OutputDebugString("\r\n"))
+#define DOUTX(x) (OutputDebugString(x))
+#else
+#define DOUT(x)     0
+#define DOUTX(x)    0
+#endif
+
+#define MAXTYPES        10  
+#define SECTION         512
+#define MAXPATH         128
+#define DLG_BROWSE      38
+#define MAXSTR          256
+#define UNLIST_LINE     1
+#define NO_UNLIST_LINE  0
+#define WEC_RESTART     0x42
+#define DESC_INF        2
+#define DESC_EXE        1
+#define DESC_NOFILE     0
+
+typedef struct idriver
+{
+    HANDLE  hDriver;
+    char    szSection[MAXSTR];
+    char    szAlias[MAXSTR];
+    char    szFile[MAXPATH];
+    char    szDesc[MAXSTR];
+    struct  idriver *related;
+    BOOL    bRelated;
+    char    szRelated[MAXSTR];
+    char    szRemove[MAXSTR];    
+    int     fQueryable;     // 0 -> can't, 1 -> can, -1 -> need to check
+    BOOL    bInstall;       // 0 -> no,    1 -> yes
+} IDRIVER;
+
+typedef IDRIVER  * PIDRIVER;
+char itoastr[10];
+
+// extern declarations were moved to "externs.h"
+
+// extern void     FAR PASCAL OpenDriverError     (HWND, LPSTR, LPSTR);       
+// extern void     NEAR PASCAL RemoveSpaces        (LPSTR, LPSTR);
+extern BOOL     FAR  PASCAL  FDlgRestart  (HWND, UINT, WPARAM, LPARAM);
+//extern int      FAR  PASCAL  AddDriversDlg (HWND, UINT, WPARAM, LPARAM);
+//extern BOOL     FAR  PASCAL  AddUnlistedDlg (HWND, UINT, WPARAM, LPARAM);
+extern BOOL     FAR PASCAL mmAddNewDriver      (LPSTR, LPSTR, PIDRIVER);
+//extern BOOL     NEAR PASCAL PostRemove          (HWND, PIDRIVER, BOOL, int);
+//extern BOOL     NEAR PASCAL IsOnlyInstance      (HWND, PIDRIVER);
+//extern BOOL     NEAR PASCAL CopyToSysDir        (void);             
+//extern BOOL     NEAR PASCAL InstallDrivers      (HWND, HWND, PSTR);
+//extern void     NEAR PASCAL InitDrvConfigInfo   (LPDRVCONFIGINFO, PIDRIVER);
+//extern int      NEAR PASCAL AddIDriver          (HWND, PIDRIVER);
+//extern BOOL     NEAR PASCAL IsConfigurable      (PIDRIVER, HWND);
+extern BOOL     FAR  PASCAL wsInfParseInit      (void);
+extern void     FAR PASCAL wsStartWait         (void);   
+extern void     FAR PASCAL wsEndWait           (void);                      
+//extern int      NEAR PASCAL LoadDesc            (PIDRIVER, PSTR, PSTR);       
+//extern void     FAR  PASCAL InitFileCopy        (void);               
+//extern void     FAR  PASCAL TermFileCopy        (void);       
+extern WORD     FAR  PASCAL wsCopySingleStatus  (int, int, LPSTR);
+
+
+
+UINT PRIVATE   CplInit( HWND hWnd, BOOL fUse3d, LPUINT lpuUpdated );
+
+
+
+//extern int      FAR  PASCAL strncmpi            (LPSTR, LPSTR, int);
+
+#if WIN32
+#define strncmpi(L1, L2, SZ) _strnicmp(L1, L2, SZ)
+#else
+#define strncmpi(L1, L2, SZ) _fstrnicmp(L1, L2, SZ)
+#endif
+
+extern LPSTR    FAR  PASCAL lstrstri            (LPSTR, LPSTR);
+//#define lstrstri(L1, L2) strstri(L1, L2)
+
+//extern int      FAR  PASCAL atoi(LPSTR sz);
+
+// definition in INSDISK.C
+int WINAPI InsertDisk(HWND hwnd, LPCSTR lpszDiskName,
+    LPCSTR lpszFile, LPCSTR lpszOtherFiles, LPSTR lpszPath, HICON hIcon, UINT wFlags);
+
+#endif   // PH_DRV
diff --git a/private/tapi/dev/cpl/exe.c b/private/tapi/dev/cpl/exe.c
new file mode 100644
index 000000000..67f6e6bcf
--- /dev/null
+++ b/private/tapi/dev/cpl/exe.c
@@ -0,0 +1,209 @@
+/*
+ *  exe.c   Get info from a EXEHDR
+ *
+ *  Modification History:
+ *
+ *  4/03/89  ToddLa Wrote it
+ *
+ */
+
+#include <windows.h>
+#include <dos.h>
+#include <fcntl.h>
+#include <io.h>
+
+
+#include <mmsystem.h>
+
+
+#include "drv.h"
+
+#include "newexe.h"
+#include "sulib.h"
+
+char	szDOSCALLS[] = "DOSCALLS";
+#define lenDOSCALLS 8
+
+
+
+//***************************************************************************
+//***************************************************************************
+#ifdef DONT_REALLY_USE_THIS
+BOOL NEAR PASCAL IsFAPI(int fh, struct new_exe *pne, long off);
+#endif
+//***************************************************************************
+//***************************************************************************
+
+
+/* BOOL FAR PASCAL GetExeInfo(szFile, pBuf, nBuf, fInfo)
+ *
+ *  Function will return a specific piece of information from a new EXEHDR
+ *
+ *      szFile      - Path Name a new exe
+ *      pBuf        - Buffer to place returned info
+ *      nBuf        - Size of buffer
+ *      fInfo       - What info to get?
+ *
+ *          GEI_MODNAME         - Get module name
+ *          GEI_DESCRIPTION     - Get description
+ *          GEI_FLAGS           - Get EXEHDR flags
+ *
+ *  returns:  TRUE if successful, FALSE otherwise.
+ */
+
+BOOL FAR PASCAL GetExeInfo(LPSTR szFile, VOID *pBuf, int nBuf, WORD fInfo)
+{
+    int         fh;
+    DWORD       off;
+    BYTE        len;
+    static struct exe_hdr exehdr;   // make these near
+    static struct new_exe newexe;
+
+    fh = FOPEN(szFile);
+
+    if (fh == -1)
+        return FALSE;
+
+    if (FREAD(fh, (LPSTR)&exehdr, sizeof(struct exe_hdr)) !=
+        sizeof(struct exe_hdr) ||
+        exehdr.e_magic != EMAGIC ||
+        exehdr.e_lfanew == 0L)
+            goto error;        /* Abort("Not an exe",h); */
+
+    FSEEK(fh, exehdr.e_lfanew, SEEK_SET);
+
+    if (FREAD(fh, (LPSTR)&newexe, sizeof(struct new_exe)) !=
+        sizeof(struct new_exe))
+            goto error;      // Read error
+
+    if (newexe.ne_magic != NEMAGIC)
+            goto error;      // Invalid NEWEXE
+
+    switch (fInfo)
+    {
+//***************************************************************************
+//***************************************************************************
+#ifdef DONT_REALLY_USE_THIS
+        case GEI_FAPI:
+            *(BOOL *)pBuf = IsFAPI(fh,&newexe,exehdr.e_lfanew);
+            break;
+
+        case GEI_EXEHDR:
+            *(struct new_exe*)pBuf = newexe;
+            break;
+
+        case GEI_FLAGS:
+            *(WORD *)pBuf = newexe.ne_flags;
+            break;
+
+        /* module name is the first entry in the resident name table */
+        case GEI_MODNAME:
+            off = exehdr.e_lfanew + newexe.ne_restab;
+            goto readstr;
+            break;
+
+#endif
+//***************************************************************************
+//***************************************************************************
+
+        /* module name is the first entry in the non-resident name table */
+        case GEI_DESCRIPTION:
+            off = newexe.ne_nrestab;
+//readstr:
+            FSEEK(fh, off, SEEK_SET);
+            FREAD(fh, &len, sizeof(BYTE));
+
+            nBuf--;         // leave room for a \0
+
+            if (len > (BYTE)nBuf)
+                len = (BYTE)nBuf;
+
+            FREAD(fh, (LPSTR)pBuf, len);
+            ((LPSTR)pBuf)[len] = 0;
+            break;
+
+        default:
+            goto error;
+    }
+
+    FCLOSE(fh);
+    return TRUE;
+
+error:
+    FCLOSE(fh);
+    return FALSE;
+}
+
+#if 0
+static int NEAR PASCAL strncmpi(char *pch1, char *pch2, int n)
+{
+    while (*pch1 && --n > 0 && UPCASE(*pch1) == UPCASE(*pch2))
+	     *pch1++,*pch2++;
+    return UPCASE(*pch1) != UPCASE(*pch2);
+}
+#endif
+
+
+//***************************************************************************
+//***************************************************************************
+#ifdef DONT_REALLY_USE_THIS
+/* BOOL NEAR PASCAL IsFAPI(fh,off)
+ *
+ *  Function will return whether a exe is a FAPI exe
+ *
+ *      fh      - Open file handle to NEW EXE
+ *      off     - Base of module table
+ *
+ *  returns:  TRUE if FAPI, FALSE otherwise.
+ */
+BOOL NEAR PASCAL IsFAPI(int fh, struct new_exe *pne, long off)
+{
+    char    buf[256];
+    LPSTR pch;
+    WORD FAR *pw;
+    int     n;
+    int     i;
+    BOOL    f = FALSE;
+
+    /*
+     *	look through the imported module table for the name "DOSCALLS" if
+     *	found the EXE is a FAPI app.
+     *
+     *  NOTE! assumes module table will fit in a 256 byte buffer
+     */
+
+    // make sure this doesn't point off the end of the buffer we will use
+
+    if (pne->ne_modtab > sizeof(buf))
+	return FALSE;
+
+    FSEEK(fh, off, SEEK_SET);
+    FREAD(fh, buf, sizeof(buf));
+
+    pw = (WORD*)(buf + pne->ne_modtab);
+
+    for (i = 0; i < (int)pne->ne_cmod; i++)
+    {
+        pch = buf + pne->ne_imptab + *pw++;
+
+	if (pch > (buf + sizeof(buf)))	// be sure we don't go off the end
+	    break;
+
+        n = (int)*pch++;
+
+	if (n == 0)
+	    break;
+
+	if (n == lenDOSCALLS && !strncmpi(szDOSCALLS, pch, lenDOSCALLS))
+	{
+	    f = TRUE;
+	    break;
+	}
+    }
+
+    return f;
+}
+#endif
+//***************************************************************************
+//***************************************************************************
+
diff --git a/private/tapi/dev/cpl/externs.h b/private/tapi/dev/cpl/externs.h
new file mode 100644
index 000000000..17d8e743a
--- /dev/null
+++ b/private/tapi/dev/cpl/externs.h
@@ -0,0 +1,61 @@
+//-----------------------------------------------
+//  Externs.h
+//
+//  Created to avoid conflict between externs and
+//  actual variable declarations.
+//-----------------------------------------------
+
+#ifndef PH_EXTERNS
+#define PH_EXTERNS
+
+extern char FAR           szNull[];                              
+extern char FAR           szDrivers[];                                     
+extern char FAR           szBoot[];
+extern char FAR           szDriversHlp[];
+extern char FAR	      szInstallError[];
+extern char FAR	      szNoMemory[];    
+extern char FAR           szAppName[];                           
+extern char FAR           szFullPath[MAXFILESPECLEN];
+extern char FAR           szOemInf[];
+extern char FAR           szUserDrivers[];
+extern char FAR           szSetupInf[];
+extern char FAR           szControlIni[];
+extern char FAR           szDriversDesc[];
+extern char FAR           szSysIni[];
+//extern char FAR           szMCI[];
+//extern char FAR           szWAVE[];
+//extern char FAR           szMIDI[];
+extern char FAR           szRestartDrv[];
+extern char FAR           szRelated[];
+extern char FAR           szMDrivers[];
+extern char FAR           szBackslash[];
+extern char FAR           szKnown[];
+extern char FAR           szRelatedDesc[];
+extern char FAR           szDrv[];
+extern char FAR           szSystem[];
+extern int            iRestartMessage;
+extern WORD           wHelpMessage;
+extern DWORD          dwContext;
+extern BOOL           bCopyVxD;
+extern BOOL           bVxd;
+extern BOOL	      bInstallBootLine;
+extern BOOL           bFindOEM;
+extern BOOL           bRestart;
+extern BOOL           bCopyingRelated;			
+extern BOOL	      bRelated;
+extern HWND	      hlistbox;	
+ 
+// Must declare character arrays as pointers so that the compiler will
+// recognize them and treat them accordingly.
+
+extern char FAR szSetupPath[];    
+extern char FAR szDiskPath[];
+extern char FAR szFind[];
+extern char FAR szDrv[];
+extern char FAR szFileError[];
+
+extern HWND hMesgBoxParent;
+extern BOOL bQueryExist;
+extern BOOL bRetry;
+
+#endif
diff --git a/private/tapi/dev/cpl/filecopy.c b/private/tapi/dev/cpl/filecopy.c
new file mode 100644
index 000000000..bd4185269
--- /dev/null
+++ b/private/tapi/dev/cpl/filecopy.c
@@ -0,0 +1,479 @@
+/*  FILECOPY.C
+**
+**  Copyright (C) Microsoft, 1990, All Rights Reserved.
+**
+**  Control Panel Applet for installing installable driver.
+**
+**  This file contains hooks to SULIB, COMPRESS libraries, and the dialogs
+**  from the display applet to prompt for insert disk, error action...
+**
+**  Note SULIB.LIB, COMPRESS.LIB, SULIB.H come from the display applet
+**  and are updated here if/when updated there.
+**
+**  History:
+**
+**      Sat Oct 27 1990 -by- MichaelE
+**          Munged from display applet's DLG.C.
+**
+*/
+
+#include <windows.h>
+#include <windowsx.h>
+#include <mmsystem.h>
+#include <shellapi.h>
+//#include <commui.h>
+#include "drv.h"
+#include "externs.h"
+#include "sulib.h"
+//#include "cphelp.h"
+#include "tapicpl.h"
+#include "resource.h"
+
+#define FC_ERROR_LOADED_DRIVER  0x80
+#define CURRENT                 -1
+#define NEW                      1
+
+/*
+ *  global vars
+ */
+char     szBlowAway[]    = "blowaway";
+char	 szErrMsg[MAXSTR];
+BOOL     bDriverCopy = NEW;
+
+char FAR szOemDisks[] = "oemdisks";
+char FAR szDisks[] = "disks";
+
+BOOL  FAR  PASCAL wsInfParseInit            (void);
+WORD  NEAR PASCAL wsCopyError               (int, LPSTR);
+
+// BOOL  FAR  PASCAL _loadds wsDiskDlg         (HWND, UINT, WPARAM, LPARAM);
+BOOL  EXPORT wsExistDlg        (HWND, UINT, WPARAM, LPARAM);
+
+
+extern char far gszHelpFile[];                                         
+
+
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+#if 0
+
+/* 
+*  Load the description from the exe header.  Pass NULL for pIDriver
+*  to allocate and return space for Description text for the file
+*  idicated by the global szFile
+*/
+int NEAR PASCAL LoadDesc(PIDRIVER pIDriver, PSTR pstrKey, PSTR pstrDesc)
+{
+    PSTR        pstr;
+    OFSTRUCT    of;
+    PINF        pinf;
+    static char	szProfileString[MAX_INF_LINE_LEN];
+    LPSTR       pstrFile = pIDriver->szFile;
+
+    //
+    //-jyg- Let's look in the setup.inf first!
+    //
+
+    for (pinf = infFindSection(NULL, szMDrivers); pinf; pinf = infNextLine(pinf)) 
+    {
+            infParseField(pinf, 1, szProfileString); // compare filename
+
+            if (lstrcmpi(FileName(pstrFile), FileName(szProfileString)) == 0) 
+            {
+                infParseField(pinf, 3, pstrDesc); // get Description Field
+		if (OpenFile(pstrFile, &of, OF_EXIST) >= 0)	
+			return(DESC_INF);
+		else
+			return(DESC_NOFILE);			
+            }
+    }
+        
+    //
+    // As a last resort, look at the description in the exehdr
+    //
+
+    if (OpenFile(pstrFile, &of, OF_EXIST) == -1)
+    {
+	    return(DESC_NOFILE);
+    }
+    else 
+    {
+        DWORD  dwSize;
+        LPVOID pVerInfo;
+        LPVOID pVerDescription;
+        LANGID lidCurrent;
+        TCHAR  szTemp[256];
+
+//        if (!GetExeInfo(of.szPathName, szProfileString, MAXSTR, GEI_DESCRIPTION))
+
+        GetFileVersionInfoSize( of.szPathName, &dwSize );
+
+        pVerInfo = GlobalAllocPtr( GMEM_FIXED, dwSize );
+
+        GetFileVersionInfo( of.szPathName, 0, dwSize, pVerInfo );
+
+        lidCurrent = GetUserDefaultLangID();
+
+        wsprintf( szTemp,
+                  TEXT("\\StringFileInfo\\%08lx\\FileDescription"),
+                  (DWORD)lidCurrent);
+
+        MessageBox(GetFocus(), szTemp, of.szPathName, MB_OK);
+
+        if (!VerQueryValue(pVerInfo,
+                           szTemp,
+                           &pVerDescription,
+                           &dwSize)
+           )
+
+	     {
+        MessageBox(GetFocus(), "Bad", "Verquery failed", MB_OK);
+            *pstrDesc = '\0';
+        }
+        else    
+        {	
+            //
+            // There is version information.
+            //
+//            pstr = szProfileString;
+//            while (*pstr && *pstr++ != ':'); // skip type information
+//            lstrcpy (pstrDesc, pstr);
+        MessageBox(GetFocus(), "Good", pVerDescription, MB_OK);
+            lstrcpy (pstrDesc, pVerDescription);
+        }
+
+        GlobalFreePtr( pVerInfo );
+        return(DESC_EXE);	
+
+    }
+
+}
+#endif
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+
+
+
+//
+// Initialize the SULIB library stuff which loads the setup.inf file
+// into RAM and parses it all over the place.
+//
+BOOL FAR PASCAL wsInfParseInit(void)
+{
+    OFSTRUCT    os;
+    PINF        pinf, pEnd;
+    HANDLE      hInf;
+    LONG        lSize;
+    char        szNoInf[MAXSTR];
+    // int         iDrive;
+    // static BOOL bChkCDROM = FALSE;
+    extern CPL  gCPL;       // app global
+
+// ************* BEGIN: CBB-Mike temporary hack ***************
+
+    GetWindowsDirectory(szSetupPath, MAXPATHLEN);
+    szDiskPath[0] = 0;	// let InsertDisk() pick our default
+    infSetDefault((PINF)0);
+    
+// ************* END: CBB-Mike temporary hack ***************
+
+    // put up an hour glass here
+/*    wsStartWait();
+
+    if (OpenFile(szSetupInf, &os, OF_EXIST) == -1) {
+
+        wsEndWait();
+	LoadString(gCPL.hCplInst, IDS_NOINF, szNoInf, sizeof(szNoInf));
+        MessageBox(hMesgBoxParent, szNoInf, szDrivers, MB_OK | MB_ICONEXCLAMATION);
+        return FALSE;
+    }
+
+    if (pinf = infOpen(os.szPathName)) {
+
+        // now, lets try to shrink this.
+
+        pEnd = infFindSection(NULL, szBlowAway);
+
+        if (pEnd) {
+
+            *pEnd++ = 0;            // terminate the inf buffer
+            *pEnd++ = 0;
+            *pEnd++ = 26;           // ctrl-z ( EOF )
+
+            lSize = (LONG)(pEnd - pinf);
+
+            hInf = (HANDLE)HIWORD(pinf);
+
+            if (hInf = GlobalReAlloc(hInf, lSize, 0)) {
+
+                // set global default pinf pointer
+
+                infSetDefault((PINF)MAKELONG(0, hInf));
+            }
+        }
+    }
+
+    wsEndWait();
+
+    GetWindowsDirectory(szSetupPath, MAXPATHLEN);
+
+#if 0
+
+    if (bChkCDROM == FALSE)
+	 {
+		 // use the cdrom drive as the default drive (if there is one)
+		 for ( iDrive=0; iDrive<26; iDrive++ )
+			 if ( IsCDROMDrive(iDrive) )
+			 {
+				 wsprintf(szDiskPath, "%c:\\", iDrive + 'A');
+				 break;
+			 }
+		 bChkCDROM = TRUE;
+	 }	
+#endif
+
+    szDiskPath[0] = 0;	// let InsertDisk() pick our default
+
+*/
+    return TRUE;
+}
+
+
+void FAR PASCAL wsStartWait()
+{
+    SetCursor(LoadCursor(NULL,IDC_WAIT));
+}
+
+void FAR PASCAL wsEndWait()
+{
+    SetCursor(LoadCursor(NULL,IDC_ARROW));
+}
+
+
+
+
+/*----------------------------------------------------------------------------*\
+|                                                                              |
+| wsCopyError()                                                                |
+|                                                                              |
+|   Handles errors, as the result of copying files.                            |
+|                                                                              |
+|   this may include net contention errors, in witch case the user must        |
+|   retry the operation.                                                       |
+|                                                                              |
+\*----------------------------------------------------------------------------*/
+WORD NEAR PASCAL wsCopyError(int n, LPSTR sz)
+{
+    PSTR pstrBuf;
+    static char szFile[MAXSTR];
+    char FAR *pstrFileName = sz;
+    int i = 0;
+    extern CPL  gCPL;       // app global
+   
+    // We do not want to report any errors that occur while installing 
+    // related drivers
+		    
+    if (bCopyingRelated)
+	 return(FC_ABORT);	  
+	  
+	    
+    lstrcpy(szFile, sz);          // in case our DS moves in loadstring()
+    while (szFile[i])
+    {
+	if (szFile[i] == ':' || szFile[i] == '\\')
+	   pstrFileName = &szFile[++i];
+        i++;
+    }
+
+    pstrBuf = (PSTR)LocalAlloc(LPTR, MAXSTR);
+
+    // check for out of disk space
+
+    if (n == ERROR_DISKFULL) 
+
+       LoadString(gCPL.hCplInst, IDS_OUTOFDISK, pstrBuf, MAXSTR);
+
+    else
+       if (n == FC_ERROR_LOADED_DRIVER)    // When a copy is done on a file 
+                                           // that is currently loaded by the
+				           // system. n returned by 
+					   // VerInstallFile
+       {
+          int iIndex;
+	  BOOL bFound = FALSE;
+          IDRIVER FAR *pIDriver;
+	  
+          iIndex = (int)SendMessage(hlistbox, LB_GETCOUNT, 0, 0L);
+          while ( iIndex-- > 0  && !bFound)
+          if ( (LONG)(pIDriver = (PIDRIVER)SendMessage(hlistbox, LB_GETITEMDATA, iIndex, 0L)) != LB_ERR)
+	  {
+	     if (!lstrcmpi(pIDriver->szFile, pstrFileName))
+	     {
+		  char sztemp[MAXSTR];
+		  
+		  LoadString(gCPL.hCplInst, IDS_FILEINUSEREM, sztemp, sizeof(sztemp));
+		  wsprintf(pstrBuf, sztemp, (LPSTR)pIDriver->szDesc);
+		  bFound = TRUE;
+             }
+          }
+          if (!bFound)
+	  {
+	      iRestartMessage = IDS_FILEINUSEADD;
+              DialogBox(gCPL.hCplInst, 
+  		      MAKEINTRESOURCE(IDD_RESTART), hMesgBoxParent, FDlgRestart);
+	      LocalFree	((HANDLE)pstrBuf);	      
+              return(FC_ABORT);
+          }
+	      
+       }
+       else
+         LoadString(gCPL.hCplInst, IDS_UNABLE_TOINSTALL, pstrBuf, MAXSTR);
+    DOUTX(pstrBuf); 
+    MessageBox(hMesgBoxParent, pstrBuf, szFileError, MB_OK | MB_ICONEXCLAMATION  | MB_TASKMODAL);
+    LocalFree((HANDLE)pstrBuf);
+    return (FC_ABORT);
+	    
+}
+
+//  now look in the [disks] section for the disk name
+//  the disk name is the second field.
+
+void NEAR PASCAL GetDiskName(int n, LPSTR szDiskName)
+{
+    char szInfLine[MAXSTR];
+    char szDisk[2];
+
+    szDisk[0] = (char)n;
+    szDisk[1] = 0;
+
+    szDiskName[0] = 0;
+
+    infGetProfileString(NULL, szDisks, szDisk, szInfLine);
+    if (!szInfLine[0])	    
+        infGetProfileString(NULL, szOemDisks, szDisk, szInfLine); 
+
+    if (szInfLine[0])
+        infParseField(szInfLine, 2, szDiskName);
+}
+
+
+WORD NEAR PASCAL wsInsertDisk(int n, LPSTR szSrcPath)
+{
+    int temp;
+    char szDiskName[80];
+
+    GetDiskName(n, szDiskName);
+
+    temp = InsertDisk(GetActiveWindow(), szDiskName, szDrv, NULL, szSrcPath, NULL, 0);
+
+    switch (temp) {
+    case IDOK:
+        temp = FC_RETRY;
+	break;
+
+    case IDCANCEL:
+    default:
+        temp = FC_ABORT;
+	break;
+    }
+
+    return temp;
+}
+
+
+/*--------------------------------------------------------------------------
+ *
+ * this call back only copies it's file if it does not exist in the
+ * path.
+ *
+ *--------------------------------------------------------------------------*/
+
+WORD FAR PASCAL wsCopySingleStatus(int msg, int n, LPSTR szFile)
+{
+   OFSTRUCT ofs;
+   char szFullPath[MAXPATH];
+   char szDriverExists[MAXSTR];   
+   LPSTR szInFile;
+   extern CPL  gCPL;       // app global
+		    
+   switch (msg)
+    {
+        case COPY_INSERTDISK:
+            return wsInsertDisk(n, szFile);
+
+        case COPY_ERROR:
+            return wsCopyError(n, szFile);
+
+        case COPY_QUERYCOPY:
+	    GetSystemDirectory(szFullPath, sizeof(szFullPath));
+	    if (szFile[1] == ':')
+	    {
+    		lstrcat(szFullPath, "\\");		    		    
+    		lstrcat(szFullPath, &szFile[2]);
+		szInFile =  &szFile[2];		
+    	    }
+	    else		 
+	    {
+    		lstrcat(szFullPath, "\\");		    
+    		lstrcat(szFullPath, szFile);	
+		szInFile = szFile;				
+            }
+
+	    if (OpenFile(szFullPath, &ofs, OF_EXIST | OF_SHARE_DENY_NONE) >= 0)
+	    {
+		if (bQueryExist && !bVxd)
+		{
+			bQueryExist = FALSE;	
+			LoadString(gCPL.hCplInst, IDS_DRIVER_EXISTS, szDriverExists, sizeof(szDriverExists));
+			wsprintf(szErrMsg, szDriverExists, (LPSTR)szInFile);						
+	                return DialogBox(gCPL.hCplInst, MAKEINTRESOURCE(IDD_EXISTS), hMesgBoxParent, wsExistDlg);
+		}
+	        else
+			return(bDriverCopy);
+            }
+            break;
+                
+        case COPY_STATUS:
+            break;
+    }
+    return FC_IGNORE;
+}
+
+
+BOOL EXPORT  wsExistDlg(HWND hDlg, UINT uiMessage, WPARAM wParam, LPARAM lParam)
+{
+    switch (uiMessage)
+    {
+        case WM_COMMAND:
+            switch ((WORD)wParam)
+            {
+		case ID_CURRENT:             
+		    bDriverCopy	= CURRENT;
+                    EndDialog(hDlg, CURRENT);
+                    break;
+
+                case ID_NEW:
+		    bDriverCopy	= NEW;			
+                    EndDialog(hDlg, NEW);  
+                    break;			
+			
+                case IDCANCEL:			
+                    EndDialog(hDlg, 0);  // Cancel
+                    break;			
+            }
+            return TRUE;
+
+        case WM_INITDIALOG:
+            SetDlgItemText(hDlg, ID_STATUS2, szErrMsg);		
+            return TRUE;
+
+	default:
+	 break;
+    }
+    return FALSE;
+}
+
diff --git a/private/tapi/dev/cpl/help.h b/private/tapi/dev/cpl/help.h
new file mode 100644
index 000000000..d54ad51a7
--- /dev/null
+++ b/private/tapi/dev/cpl/help.h
@@ -0,0 +1,51 @@
+/*--------------------------------------------------------------------------*\
+   Include File:  help.h
+    
+   Defines all the help context id's for the control panel applet
+    
+\*--------------------------------------------------------------------------*/
+
+#ifndef  PH_HELP
+#define  PH_HELP
+
+
+// WIN95b 12364 - //----------
+// WIN95b 12364 - // Constants
+// WIN95b 12364 - //----------
+// WIN95b 12364 - #define  CPL_HLP_FROM_CPANEL           1000
+// WIN95b 12364 - #define  CPL_HLP_TELEPHONY_MAIN        1010
+// WIN95b 12364 - #define  CPL_HLP_LOCATION_LIST         1020
+// WIN95b 12364 - #define  CPL_HLP_DEFINE_LOCATION       1030
+// WIN95b 12364 - #define  CPL_HLP_TOLL_LIST             1040
+// WIN95b 12364 - #define  CPL_HLP_CARD_LIST             1050
+// WIN95b 12364 - #define  CPL_HLP_DEFINE_CARD           1060
+// WIN95b 12364 - #define  CPL_HLP_CARD_DIALING_RULES    1070
+// WIN95b 12364 - #define  CPL_HLP_CARD_COPY_FROM        1080
+// WIN95b 12364 - #define  CPL_HLP_DRIVER_SETUP          1090
+// WIN95b 12364 - #define  CPL_HLP_ADD_DRIVER            1100
+// WIN95b 12364 - #define  CPL_HLP_INSERT_DISK           1110
+// WIN95b 12364 - #define  CPL_HLP_BROWSE                1120
+// WIN95b 12364 - #define  CPL_HLP_ADD_UNLISTED          1130
+
+
+//-----------------------------------------------
+// Constants for context-sensitive help (Chicago)
+//-----------------------------------------------
+
+//#define  IDH_TELCPL_INSTALLED_DRIVERS      2000 These were Win95
+//#define  IDH_TELCPL_ADD                    2001 These were Win95
+//#define  IDH_TELCPL_REMOVE                 2002 These were Win95
+//#define  IDH_TELCPL_SETUP                  2003 These were Win95
+//#define  IDH_TELCPL_DIALHELPER             2004 These were Win95
+//#define  IDH_TELCPL_ADD_AVAILABLE_DRIVERS  2100 These were Win95
+//#define  IDH_TELCPL_ADD_ADD                2101 These were Win95
+
+#define  IDH_TELCPL_INSTALLED_DRIVERS      5122
+#define  IDH_TELCPL_ADD                    5123
+#define  IDH_TELCPL_REMOVE                 5124
+#define  IDH_TELCPL_SETUP                  5125
+#define  IDH_TELCPL_DIALHELPER             5126
+#define  IDH_TELCPL_ADD_AVAILABLE_DRIVERS  5127
+#define  IDH_TELCPL_ADD_ADD                5128
+
+#endif   // PH_HELP
diff --git a/private/tapi/dev/cpl/inf.c b/private/tapi/dev/cpl/inf.c
new file mode 100644
index 000000000..5d8fe5254
--- /dev/null
+++ b/private/tapi/dev/cpl/inf.c
@@ -0,0 +1,828 @@
+/*
+ * Infparse.c - Setup.inf parsing code.
+ * Clark Cyr, Mike Colee, Todd Laney
+ * Copyright (C) Microsoft, 1989
+ * March 15, 1989
+ *
+ *  Modification History:
+ *
+ *  3/15/89  CC  Clark wrote this code for control Panel. This is windows
+ *		 code.
+ *
+ *  3/20/89  MC  Decided this code would work for Dos and windows portion
+ *		 of setup. take out windows specifc stuff like local alloc's
+ *		 and dialog stuff. Replace it with standard C run time calls.
+ *
+ *  3/24/89  Toddla TOTAL rewrite! nothing is the same any more.
+ *
+ *  6/29/89  MC fixed getprofilestring func to not strip quotes if more
+ *              than one field exists.
+ */
+
+#include <windows.h>
+#include <dos.h>
+#include <fcntl.h>
+#include <io.h>
+#include <malloc.h>
+#include <string.h>
+#include <stdlib.h>
+#include "inf.h"
+#include "tapicpl.h"
+
+#ifdef FAR_HEAP
+/*** hack.  to avoid realloc problems we make READ_BUFSIZE
+            as big as the inf file, thus avoiding any reallocs */
+
+#define READ_BUFSIZE	27000	/* size of inf buffer */
+#endif
+#define TMP_BUFSIZE	1024	/* size of temp reads */
+
+#define ISSEP(c)   ((c) == '='  || (c) == ',')
+#define ISWHITE(c) ((c) == ' '  || (c) == '\t' || (c) == '\n' || (c) == '\r')
+#define ISNOISE(c) ((c) == '"')
+#define EOF     26
+
+#define QUOTE   '"'
+#define COMMA   ','
+#define SPACE   ' '
+#define EQUAL   '='
+
+PINF   pinfDefault = NULL;
+
+static PSTR   pBuf;
+static PINF    pInf;
+static WORD    iBuf;
+static WORD    iInf;
+
+/* Globaly used pointers to non-translatable text strings. */
+
+char    pszINFFILE[]    =   "mmsetup.inf";
+//extern char *pszPATH;
+
+/* Local prototypes */
+
+BOOL multifields(PINF);
+
+
+static char GETC(int fh)
+{
+    register WORD n;
+
+    if (!pBuf)
+        return EOF;
+
+    n = iBuf % TMP_BUFSIZE;
+
+    if (n == 0)
+    {
+       FREAD(fh,pBuf,TMP_BUFSIZE);
+    }
+    iBuf++;
+    return pBuf[n];
+}
+
+#ifdef FAR_HEAP
+
+static void PUTC(char c)
+{
+    if (!pInf)
+        return;
+
+#ifdef DOSONLY
+    c = XlateAnsi850(c);
+#endif
+
+    pInf[iInf++] = c;
+}
+
+#else
+
+static void PUTC(char c)
+{
+    register WORD    n;
+    register PINF    pInfT;
+
+    if (!pInf)
+        return;
+
+    n = iInf % READ_BUFSIZE;
+    if (n == 0)
+    {
+        n = (iInf / READ_BUFSIZE) + 1;
+        pInfT = REALLOC(pInf,n * READ_BUFSIZE);
+
+        if (pInfT)
+        {
+            pInf = pInfT;
+        }
+        else
+        {
+            FREE(pInf);
+            pInf = NULL;
+        }
+    }
+    if (pInf)
+        pInf[iInf++] = c;
+}
+#endif
+
+/* int infLoadFile()	  Load a entire INF file into memory
+ *			  comments are removed, each line is terminated
+ *			  by a \0 each section is terminated by a \0\0
+ *			  ONLY spaces inside of " " are preserved
+ *			  the end of file is marked with a ^Z
+ *
+ *   RETURNS:  A pointer to a block of memory containg file, NULL if failure
+ *
+ */
+PINF infLoadFile(int fh)
+{
+    WORD    len;
+    PINF    pInfT;
+    register char    c;
+    register BOOL    fQuote = FALSE;
+
+    if (fh == -1)
+      return NULL;
+
+    len = (WORD)FSEEK(fh,0L,SEEK_END);
+
+    FSEEK(fh,0L,SEEK_SET);
+
+    iBuf = 0;
+    iInf = 0;
+    pBuf = ALLOC(TMP_BUFSIZE);		// temp buffer
+    if (!pBuf)
+        return NULL;
+#ifdef FAR_HEAP
+    pInf = FALLOC(len);			// destination, at least as big as file
+#else
+    pInf = ALLOC(READ_BUFSIZE);
+#endif
+    if (!pInf) {
+        FREE((HANDLE)pBuf);
+        return NULL;
+    }
+
+    while (iBuf < len)
+    {
+	c = GETC(fh);
+loop:
+        if (iBuf >= len)
+            break;
+
+	switch (c)
+	{
+	    case '\r':	    /* ignore '\r' */
+		break;
+
+	    case '\n':
+		for (; ISWHITE(c); c = GETC(fh))
+		    ;
+		if (c != ';')
+		    PUTC(0);	/* all lines end in a \0 */
+
+		if (c == '[')
+		    PUTC(0);	/* all sections end with \0\0 */
+
+		fQuote = FALSE;
+		goto loop;
+		break;
+
+	    case '\t':
+	    case ' ':
+		if (fQuote)
+		    PUTC(c);
+		break;
+
+	    case '"':
+		fQuote = !fQuote;
+		PUTC(c);
+		break;
+
+	    case ';':
+		for (; !ISEOL(c); c = GETC(fh))
+		    ;
+		goto loop;
+		break;
+
+	    default:
+		PUTC(c);
+		break;
+	}
+    }
+
+    PUTC(0);
+    PUTC(0);
+    PUTC(EOF);
+    FREE((HANDLE)pBuf);
+
+    // try to shrink this block
+
+#ifdef FAR_HEAP
+
+    // just leave pInf it's original size.  don't bother shrinking it
+
+#else
+    pInfT = REALLOC(pInf,iInf);
+
+    if (pInfT)		// if REALLOC fails just leave pInf as is
+    	pInf = pInfT;
+#endif
+
+    return pInf;
+}
+
+static int near pascal
+strncmpi(LPSTR pch1, LPSTR pch2, int n)
+{
+    while (*pch1 && --n > 0 && UPCASE(*pch1) == UPCASE(*pch2))
+	     *pch1++,*pch2++;
+    return UPCASE(*pch1) != UPCASE(*pch2);
+}
+
+/* PINF FAR PASCAL infOpen()
+ *                   Takes the string held in szBasePath as the path
+ *                   to find SETUP.INF and attempts to open it. Returns
+ *                   a valid file handle is successful.
+ *   
+ *   RETURNS:  A file pointer if successful, Null pointer in the case of
+ *	       a failure.
+ *
+ *   ENTER:
+ *   EXIT:   To caller
+ */
+PINF FAR PASCAL infOpen(LPSTR szInf)
+{
+    char    szBuf[CPL_MAX_PATH];
+    short   fh;
+    PINF    pinf;
+
+    fh = -1;
+
+    if (szInf == NULL)
+        szInf = pszINFFILE;
+
+    /*
+     * Next try to open passed parameter as is. For Dos half.
+     */
+    if (fh == -1)
+    {
+        fh = FOPEN(szInf);
+    }
+    /*
+     * Next try destination path\system. for win half.
+     */
+//    if (fh == -1) {
+//    	lstrcpy(szBuf, szSetupPath);
+//      catpath(szBuf, "system");
+//      catpath(szBuf, szInf);
+//      fh = FOPEN(szBuf);
+//    }
+    /*
+     * Next try destination path. for initial setup.
+     */
+//    if (fh == -1) {
+//    	lstrcpy(szBuf, szSetupPath);
+//      catpath(szBuf, szInf);
+//      fh = FOPEN(szBuf);
+//    }
+    if (fh != -1)
+    {
+        pinf = infLoadFile(fh);
+        FCLOSE(fh);
+
+        if (pinf && !pinfDefault)
+            pinfDefault = pinf;
+
+        return pinf;
+    }
+    return NULL;
+}
+
+/* void FAR PASCAL infClose(PINF pinf)
+ *
+ *   ENTER:
+ *   EXIT:   To caller
+ */
+void FAR PASCAL infClose(PINF pinf)
+{
+    if (pinf == NULL)
+        pinf = pinfDefault;
+
+    if (pinf != NULL)
+    {
+	FFREE(pinf);
+
+	if (pinf == pinfDefault)
+	    pinfDefault = NULL;
+    }
+}
+
+
+/* FindSection	locates a section in Setup.Inf.  Sections are
+ *               assumed to be delimited by a '[' as the first
+ *               character on a line.
+ *
+ * Arguments:	pInf	 Pointer to SETUP.INF buffer
+ *		pszSect  LPSTR to section name
+ *
+ * Return:	WORD file position of the first line in the section
+ *               0 if section not found
+ */
+
+WORD FindSection(PINF pInf, LPSTR pszSect)
+{
+    BOOL	fFound = FALSE;
+    short	nLen = lstrlen(pszSect);
+    PINF	pch;
+    char        ch;
+
+    if (!pInf)
+        return 0;
+
+    pch = pInf;
+    while (!fFound && *pch != EOF)
+    {
+	if (*pch++ == '[')
+	{
+	    fFound = !strncmpi(pszSect, pch, nLen) && pch[nLen] == ']';
+	}
+
+	/*
+	 * go to the next line, dont forget to skip over \0 and \0\0
+	 */
+	while (*pch != EOF && *pch != '\0')
+	    pch++;
+
+	while (*pch == 0)
+	    pch++;
+    }
+    return((fFound && *pch != '[' && *pch != EOF) ? pch - pInf : 0);
+}
+
+/* char* fnGetDataString(npszData,szDataStr)
+ *
+ * Called by functions that read sections of information from setup.inf
+ * to obtain strings that are set equal to keywords. Example:
+ *
+ * welcome=("Hello There")
+ * 
+ * This function will return a pointer to the null terminated string
+ * "Hello There".
+ *
+ * ENTRY:
+ *
+ * npszData    : pointer to entire section taken from setup.inf
+ * npszDataStr : pointer to key word to look for (welcome in example above.)
+ *
+ * EXIT: retutns pointer to string if successful, NULL if failure.
+ *
+ */
+BOOL fnGetDataString(PINF npszData, LPSTR szDataStr, LPSTR szBuf)
+{
+    int len = lstrlen(szDataStr);
+
+    while (npszData)
+    {
+	    if (!strncmpi(npszData,szDataStr,len))  // looking for correct prof.
+	    {
+	       npszData += len;            // found !, look past prof str.
+	       while (ISWHITE(*npszData))  // suck out the crap.
+		       npszData++;
+          if (*npszData == EQUAL)     // Now we have what were looking for !
+	       {
+		       npszData++;
+		       
+             if (!multifields(npszData) )
+             {
+                while (ISWHITE(*npszData) || ISNOISE(*npszData))
+		             npszData++;
+
+		          while (*npszData)
+		             *szBuf++ = *npszData++;
+
+   		       /*
+	   	        * remove trailing spaces, and those pesky ()'s
+		           */
+
+                while (ISWHITE(szBuf[-1]) || ISNOISE(szBuf[-1]))
+		             szBuf--;
+
+		          *szBuf = 0;
+		          return TRUE;
+             }
+             else
+             {
+                while (*npszData)
+                   *szBuf++ = *npszData++;
+                *szBuf = '\0';
+                return TRUE;
+             }
+	       }
+       }
+       npszData = infNextLine(npszData);
+    }
+    *szBuf = 0;
+    return FALSE;
+}
+
+/*  PINF FAR PASCAL infSetDefault(pinf)
+ *
+ *  Sets the default INF file
+ *
+ * ENTRY:
+ *      pinf            : inf file to be new default
+ *
+ * EXIT: retutns old default
+ *
+ */
+PINF FAR PASCAL infSetDefault(PINF pinf)
+{
+    PINF pinfT;
+
+    pinfT = pinfDefault;
+    pinfDefault = pinf;
+    return pinfT;
+}
+
+/*  PINF FAR PASCAL infFindSection(pinf,szSection)
+ *
+ *  Reads a entire section into memory and returns a pointer to it
+ *
+ * ENTRY:
+ *      pinf            : inf file to search for section
+ *	szSection	: section name to read
+ *
+ * EXIT: retutns pointer to section, NULL if error
+ *
+ */
+PINF FAR PASCAL infFindSection(PINF pinf, LPSTR szSection)
+{
+    WORD   pos;
+
+    if (pinf == NULL)
+        pinf = pinfDefault;
+
+    pos = FindSection(pinf, szSection);
+    return pos ? pinf + pos : NULL;
+}
+
+/*  BOOL FAR PASCAL infGetProfileString(szSection,szItem,szBuf)
+ *
+ *  Reads a single string from a section in SETUP.INF
+ *
+ *  [section]
+ *	item = string
+ *
+ * ENTRY:
+ *	szSection	: pointer to section name to read.
+ *	szItem		: pointer to item name to read
+ *	szBuf		: pointer to a buffer to hold result
+ *
+ * EXIT: retutns TRUE if successful, FALSE if failure.
+ *
+ */
+BOOL FAR PASCAL infGetProfileString(PINF pinf, LPSTR szSection,LPSTR szItem,LPSTR szBuf)
+{
+    PINF    pSection;
+    pSection = infFindSection(pinf,szSection);
+    
+    if ( pSection )
+        return fnGetDataString(pSection,szItem,szBuf);
+    else
+        *szBuf = 0;
+    return FALSE;
+}
+
+/* BOOL FAR PASCAL infParseField(szData,n,szBuf)
+ *
+ * Given a line from SETUP.INF, will extract the nth field from the string
+ * fields are assumed separated by comma's.  Leading and trailing spaces
+ * are removed.
+ *
+ * ENTRY:
+ *
+ * szData    : pointer to line from SETUP.INF
+ * n         : field to extract. ( 1 based )
+ *             0 is field before a '=' sign
+ * szDataStr : pointer to buffer to hold extracted field
+ *
+ * EXIT: retutns TRUE if successful, FALSE if failure.
+ *
+ */
+BOOL FAR PASCAL infParseField(PINF szData, int n, LPSTR szBuf)
+{
+    BOOL    fQuote = FALSE;
+    PINF    pch;
+    LPSTR   ptr;
+
+    if (!szData || !szBuf)
+        return FALSE;
+
+    /*
+     * find the first separator
+     */
+    for (pch=szData; *pch && !ISSEP(*pch); pch++) {
+      if ( *pch == QUOTE )
+         fQuote = !fQuote;
+    }
+
+    if (n == 0 && *pch != '=')
+        return FALSE;
+
+    if (n > 0 && *pch == '=' && !fQuote)
+        szData = ++pch;
+
+    /*
+     *	locate the nth comma, that is not inside of quotes
+     */
+    fQuote = FALSE;
+    while (n > 1)
+    {
+	    while (*szData)
+	    {
+          if (!fQuote && ISSEP(*szData))
+	    	   break;
+
+          if (*szData == QUOTE)
+	    	   fQuote = !fQuote;
+
+	       szData++;
+	    }
+
+	    if (!*szData) {
+	       szBuf[0] = 0;		// make szBuf empty
+	       return FALSE;
+	    }
+
+	    szData++;
+	    n--;
+    }
+    /*
+     * now copy the field to szBuf
+     */
+    while (ISWHITE(*szData))
+	    szData++;
+
+    fQuote = FALSE;
+    ptr = szBuf;		// fill output buffer with this
+    while (*szData)
+    {
+       if (*szData == QUOTE)
+	       fQuote = !fQuote;
+       else if (!fQuote && ISSEP(*szData))
+	       break;
+	    else
+	       *ptr++ = *szData;
+	    szData++;
+    }
+    /*
+     * remove trailing spaces, and those pesky ()'s
+     */
+    while ((ptr > szBuf) && (ISWHITE(ptr[-1]) || ISNOISE(ptr[-1])))
+	    ptr--;
+
+    *ptr = 0;
+    return TRUE;
+}
+
+/* BOOL multifields(LPSTR npszData);
+ *
+ * Given a line line from setup.inf that was phycisacaly after a profile
+ * string this function will determine if that line has more than one
+ * field. ie. Fields are seperated by commas that are NOT contained between
+ * quotes.
+ *
+ * ENYRY:
+ *
+ * npszData : a line from setup.inf Example "xyz adapter",1:foobar.drv
+ *
+ * EXIT: This function will return TRUE if the line containes more than
+ *       one field, ie the function would return TRUE for the example line
+ *       shown above.
+ *
+ */
+BOOL multifields(PINF npszData)
+{
+   BOOL    fQuote = FALSE;
+
+	while (*npszData)
+	{
+      if (!fQuote && ISSEP(*npszData))
+		   return TRUE;
+
+      if (*npszData == QUOTE)
+		   fQuote = !fQuote;
+
+	   npszData++;
+	}
+   return FALSE;
+}
+
+/* LPSTR FAR PASCAL infNextLine(sz)
+ *
+ * Given a line from SETUP.INF, advance to the next line.  will skip past the
+ * ending NULL character checking for end of buffer \0\0
+ *
+ * ENTRY:
+ *
+ * sz	     : pointer to line from a SETUP.INF section
+ *
+ * EXIT: retutns pointer to next line if successful, NULL if failure.
+ *
+ */
+PINF FAR PASCAL infNextLine(PINF pinf)
+{
+    if (!pinf)
+        return NULL;
+
+    while (*pinf != 0 || *(pinf + 1) == ' ')
+        pinf++;
+
+    return *++pinf ? pinf : NULL;
+}
+
+/* int FAR PASCAL infLineCount(pinf)
+ *
+ * Given a section from SETUP.INF, returns the number of lines in the section
+ *
+ * ENTRY:
+ *
+ * pinf	     : pointer to a section from SETUP.INF
+ *
+ * EXIT: retutns line count
+ *
+ */
+int FAR PASCAL infLineCount(PINF pinf)
+{
+    int n = 0;
+
+    for (n=0; pinf; pinf = infNextLine(pinf))
+	n++;
+
+    return n;
+}
+
+/* int FAR PASCAL infLookup(szInf,szBuf)
+ *
+ * lookup a section/key in SETUP.INF
+ *
+ * ENTRY:
+ *
+ * szInf        : pointer to a string of the form section.key
+ * szBuf        : pointer to buffer to recive string
+ *
+ * EXIT: retutns TRUE/FALSE
+ *
+ */
+BOOL FAR PASCAL infLookup(LPSTR szInf, LPSTR szBuf)
+{
+    LPSTR pch;
+    BOOL f;
+
+    /*
+     * find the LAST .
+     */
+    for (pch = szInf; *pch; pch++)
+	;
+
+    for (; pch > szInf && *pch != '.'; pch--)
+	;
+
+    if (*pch == '.')
+    {
+	*pch++ = 0;
+        f = infGetProfileString(NULL,szInf,pch,szBuf);
+        if (szInf != szBuf)
+            *pch = '.';
+        return f;
+    }
+    else
+    {
+        *szBuf = 0;
+        return FALSE;
+    }
+}
+
+#ifdef DOSONLY
+
+unsigned char AnsiToOemTable[] = {
+
+        0x20,     /* non breaking space (NBSP)                 */
+        0xAD,     /* A1h  inverted point                       */
+        0xbd,     /* A2h  cent ---                             */
+        0x9C,     /* A3h  british pound                        */
+        0xcf,     /* A4h  sun ---                              */
+        0xbe,     /* A5h  yen ---                              */
+        0xdd,     /* A6h  vertical bar (cut) ---               */
+        0xf5,     /* A7h  section mark ---                     */
+        0xf9,     /* A8h  umlaut ---                           */
+        0xb8,     /* A9h  copyright sign ---                   */
+        0xa6,     /* AAh  a underlined (superscript) ---       */
+        0xae,     /* ABh  << ---                               */
+        0xAA,     /* ACh  logical NOT                          */
+        0xf0,     /* ADh  syllabic hyphenation (SHY) ---       */
+        0xa9,     /* AEh  registered mark                      */
+        0xee,     /* AFh  top bar ---                          */
+
+        0xF8,     /* B0h  degree                               */
+        0xF1,     /* B1h  + underlined (plus or minus)         */
+        0xFD,     /* B2h  2 (superscript)                      */
+        0xfc,     /* B3h  3 (superscript) ---                  */
+        0xef,     /* B4h  acute ---                            */
+        0xE6,     /* B5h  greek mu                             */
+        0xf4,     /* B6h  paragraph sign ---                   */
+        0xFA,     /* B7h  middle dot                           */
+        0xf7,     /* B8h  cedilla for deadkey ---              */
+        0xfb,     /* B9h  1 (superscript) ---                  */
+        0xa7,     /* BAh  o underlined (superscript) ---       */
+        0xaf,     /* BBh  >> ---                               */
+        0xac,     /* BCh  1/4 ---                              */
+        0xab,     /* BDh  1/2 ---                              */
+        0xf3,     /* BEh  3/4 ---                              */
+        0xA8,     /* BFh  inverted question mark               */
+
+        0xb7,     /* C0h  A grave uppercase --                 */
+        0xb5,     /* C1h  A acute uc --                        */
+        0xb6,     /* C2h  A circumflex uc --                   */
+        0xc7,     /* C3h  A tilde uc ---                       */
+        0x8E,     /* C4h  A umlaut uc                          */
+        0x8F,     /* C5h  A ring uc                            */
+        0x92,     /* C6h  AE uc                                */
+        0x80,     /* C7h  C cedilla uc                         */
+        0xd4,     /* C8h  E grave uc ---                       */
+        0x90,     /* C9h  E acute uc                           */
+        0xd2,     /* CAh  E circumflex uc ---                  */
+        0xd3,     /* CBh  E umlaut uc ---                      */
+        0xde,     /* CCh  I grave uc ---                       */
+        0xd6,     /* CDh  I acute uc ---                       */
+        0xd7,     /* CEh  I circumflex uc ---                  */
+        0xd8,     /* CFh  I umlaut uc ---                      */
+
+        0xd1,     /* D0h  Icelandic eth (D striked) uc ---     */
+        0xA5,     /* D1h  N tilde uc                           */
+        0xe3,     /* D2h  O grave uc ---                       */
+        0xe0,     /* D3h  O acute uc ---                       */
+        0xe2,     /* D4h  O circumflex uc ---                  */
+        0xe5,     /* D5h  O tilde uc ---                       */
+        0x99,     /* D6h  O umlaut uc                          */
+        0x9e,     /* D7h  Multiply sign ---                    */
+        0x9D,     /* D8h  O slashed uc ---                     */
+        0xeb,     /* D9h  U grave uc ---                       */
+        0xe9,     /* DAh  U acute uc ---                       */
+        0xea,     /* DBh  U circumflex uc ---                  */
+        0x9A,     /* DCh  U umlaut uc                          */
+        0xed,     /* DDh  Y acute uc ---                       */
+        0xe8,     /* DEH  Icelandic thorn uc ---               */
+        0xE1,     /* DFh  german sharp S                       */
+
+
+        0x85,     /* E0h  a grave lowercase                    */
+        0xA0,     /* E1h  a acute lc                           */
+        0x83,     /* E2h  a circumflex lc                      */
+        0xc6,     /* E3h  a tilde lc ---                       */
+        0x84,     /* E4h  a umlaut lc                          */
+        0x86,     /* E5h  a ring lc                            */
+        0x91,     /* E6h  ae lc                                */
+        0x87,     /* E7h  c cedilla lc                         */
+        0x8A,     /* E8h  e grave lc                           */
+        0x82,     /* E9h  e acute lc                           */
+        0x88,     /* EAh  e circumflex lc                      */
+        0x89,     /* EBh  e umlaut lc                          */
+        0x8D,     /* ECh  i grave lc                           */
+        0xA1,     /* EDh  i acute lc                           */
+        0x8C,     /* EEh  i circumflex lc                      */
+        0x8B,     /* EFh  i umlaut lc                          */
+
+        0xd0,     /* F0h  Icelandic eth (d striked) lc ---     */
+        0xA4,     /* F1h  n tilde lc                           */
+        0x95,     /* F2h  o grave lc                           */
+        0xA2,     /* F3h  o acute lc                           */
+        0x93,     /* F4h  o circumflex lc                      */
+        0xe4,     /* F5h  o tilde lc ---                       */
+        0x94,     /* F6h  o umlaut lc                          */
+        0xf6,     /* F7h  divide sign ---                      */
+        0x9B,     /* F8h  o slashed lc ---                     */
+        0x97,     /* F9h  u grave lc                           */
+        0xA3,     /* FAh  u acute lc                           */
+        0x96,     /* FBh  u circumflex lc                      */
+        0x81,     /* FCh  u umlaut lc                          */
+        0xec,     /* FDh  y acute lc                           */
+        0xe7,     /* FEH  icelandic thorn lc                   */
+        0x98      /* FFh  y umlaut lc                          */
+             };   /* end of AnsiToOemTable                     */
+
+
+
+unsigned char XlateAnsi850(unsigned char c)
+{
+
+
+    if (c >= 160)
+        c = AnsiToOemTable[c - 160];
+    return c;
+}
+
+
+#endif
diff --git a/private/tapi/dev/cpl/inf.h b/private/tapi/dev/cpl/inf.h
new file mode 100644
index 000000000..210560c90
--- /dev/null
+++ b/private/tapi/dev/cpl/inf.h
@@ -0,0 +1,56 @@
+#ifndef PH_INF
+#define PH_INF
+
+#define FAR_HEAP
+
+#include "sulib.h"
+
+PINF FAR PASCAL infOpen(LPSTR szInf);
+void FAR PASCAL infClose(PINF pinf);
+PINF FAR PASCAL infSetDefault(PINF pinf);
+PINF FAR PASCAL infFindSection(PINF pinf, LPSTR szSection);
+BOOL FAR PASCAL infGetProfileString(PINF pinf, LPSTR szSection,LPSTR szItem,LPSTR szBuf);
+BOOL FAR PASCAL infParseField(PINF szData, int n, LPSTR szBuf);
+PINF FAR PASCAL infNextLine(PINF pinf);
+int  FAR PASCAL infLineCount(PINF pinf);
+BOOL FAR PASCAL infLookup(LPSTR szInf, LPSTR szBuf);
+
+#define FALLOC(n)                (VOID FAR *)GlobalLock(GlobalAlloc(GHND, (DWORD)(n)))
+#define FFREE(n)                 GlobalFree((HANDLE)HIWORD((DWORD)(n)))
+
+#define FOPEN(sz)                _lopen(sz,0 /*READ*/)
+#define FCREATE(sz)              _lcreat(sz,0)
+#define FCLOSE(fh)               _lclose(fh)
+#define FREAD(fh,buf,len)        _lread(fh,buf,len)
+#define FWRITE(fh,buf,len)       _lwrite(fh,buf,len)
+#define FSEEK(fh,off,i)          _llseek(fh,(DWORD)off,i)
+
+#define FERROR()                 0
+
+#define ALLOC(n)                 (VOID NEAR *)LocalAlloc(LPTR,n)
+#define FREE(p)                  LocalFree(p)
+#define SIZE(p)                  LocalSize(p)
+#define REALLOC(p,n)             LocalReAlloc(p,n,LMEM_MOVEABLE)
+
+/* Used in the fnCopyBuf call to specify the copying of the remainder on
+   the from buffer. */
+
+#define CNT_Z        0x1A
+
+#define ISEOF(c)     ((c) == '\0' || (c) == CNT_Z)
+#define ISSEP(c)     ((c) == '='  || (c) == ',')
+#define ISWHITE(c)   ((c) == ' '  || (c) == '\t' || (c) == '\n' || (c) == '\r')
+#define ISFILL(c)    ((c) == ' '  || (c) == '\t')
+#define ISEOL(c)     ((c) == '\n' || (c) == '\r' || (c) == '\0' || (c) == CNT_Z)
+#define ISCRLF(c)    ((c) == '\n' || (c) == '\r')
+#define ISNOISE(c)   ((c) == '"')
+#define ISDIGIT(c)   ((c) >= '0' && (c) <= '9')
+#define ISHEX(c)     (ISDIGIT(c) || ISCHAR(c))
+#define ISCHAR(c)    (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+#define SLASH(c)     ((c) == '/' || (c) == '\\')
+#define DEVICESEP(c) ((c) == '/' || (c) == '\\' || (c) == '=' || (c) == ' ' || (c) == '\t')
+//#define UP_CASE(c)   ((c) | 0x20)  // this is lower case !
+#define UPCASE(c)    (((c) >= 'a' && (c) <= 'z') ? ((c) & 0xdf) : (c))
+#define HEXVAL(c)    (ISDIGIT(c) ? (c) - '0' : UP_CASE(c) - 'a' + 10)
+
+#endif // PH_INF
diff --git a/private/tapi/dev/cpl/init.c b/private/tapi/dev/cpl/init.c
new file mode 100644
index 000000000..4c7720ee0
--- /dev/null
+++ b/private/tapi/dev/cpl/init.c
@@ -0,0 +1,159 @@
+/*--------------------------------------------------------------------------*\
+   Module:     init.c
+   
+   Purpose: All the initalization and external entry points for the 
+            Telephony control panel applet.
+   
+   History:
+      7/7/93 CBB - Created
+\*--------------------------------------------------------------------------*/
+
+#include  <windows.h>
+#include  <cpl.h>
+#include  "tapicpl.h"        
+#include  "help.h"
+#include  "util.h"
+#include  "resource.h"
+#include  "init.h" 
+#include  "drv.h"
+                  
+                  
+//-------------
+// private data
+//-------------
+
+//--------------------
+// Function Prototypes
+//--------------------
+#ifdef _WIN32
+BOOL WINAPI DllEntryPoint( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved );
+#else
+int FAR PASCAL LibMain( HINSTANCE hInstance, UINT uDataSeg, UINT cbHeapSize, LPSTR lpszCmdLine );
+#endif
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   InitApplets
+   
+   Purpose: Initalizes all the applets supported.  Init's there structures
+            and will verify if they should even be there...
+   
+\*--------------------------------------------------------------------------*/
+LONG PUBLIC InitApplets( HWND hWndCpl )
+
+   {                 
+   LONG  lResult;
+   extern CPL   gCPL;       // app global
+   static BOOL    fInit = FALSE;
+                                 
+   if ( fInit == TRUE )    // avoid initalizing more than once                               
+      {
+      lResult = FALSE;
+      goto  done;
+      }  // end if
+      
+   lResult = TRUE;      // default ret value
+               
+   // init the main globals
+   //----------------------
+   gCPL.uCplApplets = 0;
+                       
+   // This message is issued for context sensitive help due to
+   // the user pressing the "F1" key or something.
+   gCPL.uHelpMsg = RegisterWindowMessage("ShellHelp");
+
+   // init the location applet
+   //-------------------------
+   gCPL.taTeleApplet[gCPL.uCplApplets].uIconResId       = IDI_TELEPHONY;
+   gCPL.taTeleApplet[gCPL.uCplApplets].uNameResId       = IDS_TITLE;
+   gCPL.taTeleApplet[gCPL.uCplApplets].uStatusLineResId = IDS_STATUS_LINE;
+
+//   gCPL.taTeleApplet[gCPL.uCplApplets].dwHelpContext    = CPL_HLP_FROM_CPANEL;
+   gCPL.taTeleApplet[gCPL.uCplApplets].dwHelpContext    = 0;
+
+   gCPL.taTeleApplet[gCPL.uCplApplets].lPrivateData     = 0;
+   gCPL.taTeleApplet[gCPL.uCplApplets].uDialogResId     = IDD_DRIVER_SETUP;
+   gCPL.taTeleApplet[gCPL.uCplApplets].dlgprcDialog     = (DLGPROC)FDlgDriverList;
+   gCPL.taTeleApplet[gCPL.uCplApplets].hIcon            = NULL;
+      
+   ++gCPL.uCplApplets;      // valid, so inc it
+
+   done: 
+      return( lResult );
+   }  // end function InitApplets
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   InitCleanupApplets();
+   
+   Purpose: We are out-ta here, clean up any memory or other things
+            that still might be lying around.
+   
+\*--------------------------------------------------------------------------*/
+VOID PUBLIC InitCleanupApplets( VOID )
+
+   {
+   UINT  uCount;
+   extern CPL   gCPL;       // app global
+   
+   for ( uCount = 0; uCount < gCPL.uCplApplets; uCount++ )
+      {
+      if ( gCPL.taTeleApplet[uCount].hIcon )
+         {
+         DestroyIcon( gCPL.taTeleApplet[uCount].hIcon );
+         gCPL.taTeleApplet[uCount].hIcon = NULL;
+         }  // end if 
+      }  // end for
+      
+   gCPL.uCplApplets = 0; // just to be clean
+   }  // end function InitCleanupApplets
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   LibMain
+   
+   Purpose: Entry point for the DLL
+   
+\*--------------------------------------------------------------------------*/
+#ifdef _WIN32
+BOOL WINAPI DllEntryPoint( HINSTANCE hInstance,
+                             DWORD dwReason,
+                             LPVOID lpReserved )
+#else
+int FAR PASCAL LibMain( HINSTANCE   hInstance, 
+                        UINT        uDataSeg, 
+                        UINT        cbHeapSize, 
+                        LPSTR       lpszCmdLine )
+#endif                 
+   {
+   extern CPL   gCPL;       // app global
+
+#ifdef _WIN32
+   switch (dwReason)
+      {
+      case DLL_PROCESS_ATTACH:
+#endif
+   // init global static data    
+   //------------------------
+   gCPL.hCplInst     = hInstance;
+   gCPL.uCplApplets  = 0;
+   gCPL.uInstances   = 0;
+   gCPL.hCtl3DInst   = NULL;
+
+
+#ifdef _WIN32
+         break;
+      case DLL_PROCESS_DETACH:
+
+      // cleanup stuff for win32
+      // Windows 3.1 cleanup goes into WEP
+         break;
+      }
+#endif
+
+   return( TRUE );
+   }  // end function LibMain
+
+
diff --git a/private/tapi/dev/cpl/init.h b/private/tapi/dev/cpl/init.h
new file mode 100644
index 000000000..71495228a
--- /dev/null
+++ b/private/tapi/dev/cpl/init.h
@@ -0,0 +1,21 @@
+/*--------------------------------------------------------------------------*\
+    Include File:   init.h
+    
+    Initalization and DLL entry points for the Telephony Control Panel Applet
+        
+\*--------------------------------------------------------------------------*/
+
+#ifndef  PH_INIT
+#define  PH_INIT
+
+//----------
+// Constants
+//----------
+
+//--------------------
+// Function Prototypes
+//--------------------
+LONG  PUBLIC   InitApplets( HWND    hWndCpl );
+VOID    PUBLIC   InitCleanupApplets( VOID );
+
+#endif   // PH_INIT
diff --git a/private/tapi/dev/cpl/insdisk.c b/private/tapi/dev/cpl/insdisk.c
new file mode 100644
index 000000000..bd04cda14
--- /dev/null
+++ b/private/tapi/dev/cpl/insdisk.c
@@ -0,0 +1,371 @@
+/* BUGBUG define Ansi/Oem ness of the file parameters */
+
+#include  <windows.h>
+#include  <windowsx.h>
+#include  <commdlg.h>
+#include  <dlgs.h>
+#include  "resource.h"
+#include  "tapicpl.h"
+#include  "util.h"
+#include  "string.h"
+#include  "insdisk.h"
+#include  "help.h"
+
+//#include "priv.h"
+
+
+typedef struct {
+    LPCSTR lpszDiskName;
+    LPSTR lpszPath;
+    LPCSTR lpszFile;
+    LPCSTR lpszOtherFiles;
+    HICON hIcon;
+    UINT wFlags;
+} INSERTDISK, FAR *LPINSERTDISK;
+
+UINT wHelpMsg;
+UINT wBrowseDoneMsg;
+char szInstSection[] = "Install Locations";
+char szDriveA[] = "A:\\";
+char szShellHelp[] = "ShellHelp";
+char szFILEOKSTRING[] = FILEOKSTRING;
+
+BOOL NEAR PASCAL DoBrowse(HWND hDlg, LPCSTR lpszFile, LPCSTR lpszOtherFiles);
+BOOL NEAR PASCAL VerifyFileExists(HWND hwnd, LPCSTR lpPath, LPCSTR lpFile);
+BOOL EXPORT  InsertDiskDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+
+
+LPSTR NEAR PASCAL PtrToNullToNull(LPCSTR lpsz)
+{
+    if (lpsz && (*lpsz == 0))
+        return NULL;
+    else
+        return (LPSTR)lpsz;
+}
+
+
+// in:
+//      lpszDiskName
+//          NULL, or the name of the disk being looked for
+//          "Windows Install Disk #3"
+//      lpszFile
+//          NULL, or specific file being looked for or "key file"
+//      lpszPath
+//          if initalized default path to present to the user
+//      hIcon
+//          NULL, or disk type icon to display
+//      wFlags
+//          ID_DISKISTEXT
+//
+// out:
+//      lpszPath
+//          qualified path to location where key file is
+//          found
+//
+// returns:
+//      -1      error, failed to create dialog
+//      IDOK
+//      IDCANCEL
+
+int WINAPI InsertDisk(HWND hwnd, LPCSTR lpszDiskName,
+    LPCSTR lpszFile, LPCSTR lpszOtherFiles, LPSTR lpszPath, HICON hIcon, UINT wFlags)
+{
+    INSERTDISK id;
+    extern CPL  gCPL;       // app global
+
+    id.lpszDiskName = PtrToNullToNull(lpszDiskName);
+    id.lpszFile = PtrToNullToNull(lpszFile);
+    id.lpszPath = lpszPath;
+    id.lpszOtherFiles = lpszOtherFiles;
+    id.hIcon = hIcon;
+    id.wFlags = wFlags;
+
+    return DialogBoxParam(gCPL.hCplInst, MAKEINTRESOURCE(IDD_INSERT_DISK), hwnd, (DLGPROC)InsertDiskDlg, (LONG)(LPINSERTDISK)&id);
+
+}
+
+void NEAR PASCAL SetInsertDiskText(HWND hDlg, LPINSERTDISK lpid)
+{
+    char szBuf[300], szTemp[200];
+    char szTemp2[2];
+    LPCSTR lpszFile;
+    UINT wFlags;
+    extern CPL  gCPL;       // app global
+
+    wFlags = lpid->wFlags;
+    lpszFile = lpid->lpszFile;
+
+    if (lpid->lpszDiskName && lpszFile) {
+        LoadString(gCPL.hCplInst, IDS_DISKFILEMSG, szTemp, sizeof(szTemp));
+
+        //
+        // In case the localizer wants the order of the strings reversed,
+        // we examine this string.  '0' is normal, anything else
+        // will be swapped.
+        //
+
+        LoadString(gCPL.hCplInst, IDS_DISKFILEMSGSWAP, szTemp2, sizeof(szTemp2));
+
+        if ( szTemp2[0] == '0' )
+           wsprintf(szBuf, szTemp, lpid->lpszDiskName, lpszFile);
+        else
+           wsprintf(szBuf, szTemp, lpszFile, lpid->lpszDiskName);
+
+    } else if (lpid->lpszDiskName) {
+        LoadString(gCPL.hCplInst, IDS_DISKMSG, szTemp, sizeof(szTemp));
+        wsprintf(szBuf, szTemp, lpid->lpszDiskName);
+    } else if (lpszFile) {
+        LoadString(gCPL.hCplInst, IDS_FILEMSG, szTemp, sizeof(szTemp));
+        wsprintf(szBuf, szTemp, lpid->lpszFile);
+    }
+
+    SetDlgItemText(hDlg, IDD_TEXT, szBuf);
+
+    // and set the app icon if needed
+    if (lpid->hIcon)
+        SendDlgItemMessage(hDlg, IDD_ICON, STM_SETICON, (WPARAM)lpid->hIcon, 0L);
+}
+
+
+BOOL EXPORT  InsertDiskDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    LPINSERTDISK lpid;
+    HANDLE hMRU;
+    char szTemp[CPL_MAX_PATH];
+    extern CPL  gCPL;       // app global
+
+    lpid = (LPINSERTDISK)GetWindowLong(hDlg, DWL_USER);
+
+    switch (message) {
+    case WM_INITDIALOG:
+        SetWindowLong(hDlg, DWL_USER, lParam);
+        lpid = (LPINSERTDISK)lParam;
+
+        SetInsertDiskText(hDlg, lpid);
+
+        SendDlgItemMessage(hDlg, IDD_PATH, EM_LIMITTEXT, CPL_MAX_PATH - 20, 0L);
+        if (*lpid->lpszPath)
+           lstrcpyn(szTemp, lpid->lpszPath, sizeof(szTemp));
+        else
+           lstrcpy(szTemp, szDriveA);
+
+        LpszPathRemoveBackslash(szTemp);
+        SetDlgItemText(hDlg, IDD_PATH, szTemp);
+
+        SendDlgItemMessage(hDlg, IDD_PATH, EM_SETSEL, 0, 0x7FFF0000);
+
+        wBrowseDoneMsg = RegisterWindowMessage(szFILEOKSTRING);
+
+        return TRUE;
+
+    case WM_COMMAND:
+        switch (wParam) {
+        case IDOK:
+            GetDlgItemText(hDlg, IDD_PATH, szTemp, sizeof(szTemp));
+            PathRemoveBlanks(szTemp);
+            LpszPathAddBackslash(szTemp);
+
+            lstrcpy(lpid->lpszPath, szTemp);
+
+            // we only validate if there didn't specify random other
+            // files (wild cards)
+
+            if (!lpid->lpszOtherFiles) {
+                lstrcat(szTemp, lpid->lpszFile);
+                if (!VerifyFileExists(hDlg, szTemp, lpid->lpszFile))
+                    break;
+            }
+
+            // fall through...
+
+        case IDCANCEL:
+            EndDialog(hDlg, wParam);
+            return(TRUE);
+
+        case IDD_BROWSE:
+            if (DoBrowse(hDlg, lpid->lpszFile, lpid->lpszOtherFiles))
+                SendMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, IDOK), MAKELONG(TRUE, 0));
+            else
+                SendMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, IDD_PATH), MAKELONG(TRUE, 0));
+            break;
+
+        case IDHELP:
+            goto DoHelp;
+        }
+        break;
+
+    default:
+        if (message == gCPL.uHelpMsg) {
+DoHelp:
+//            Help( hDlg, CPL_HLP_INSERT_DISK );
+            // CPHelp(hDlg);
+            return TRUE;
+        } else
+            return FALSE;
+
+    }
+    return (FALSE);                           /* Didn't process a message    */
+}
+
+void NEAR PASCAL CopyWindowText(HWND hwnd, HWND hwnd2)
+{
+    char szBuf[255];
+
+    GetWindowText(hwnd, szBuf, sizeof(szBuf));
+    SetWindowText(hwnd2, szBuf);
+}
+
+
+BOOL NEAR PASCAL VerifyFileExists(HWND hwnd, LPCSTR lpPath, LPCSTR lpFile)
+{
+    int fh;
+    OFSTRUCT of;
+
+    fh = OpenFile(lpPath, &of, OF_EXIST);
+
+    // BUGBUG, we probably need to try again with share modes
+    // use OpenSharedFile() from shell.dll
+
+    if (fh == -1) {
+        IMessageBox(hwnd, IDS_FILENOTINDIR, 0, MB_OK | MB_ICONINFORMATION, (LPSTR)lpFile);
+        return FALSE;   // file does not exists
+    }
+    return TRUE;        // it is there
+}
+
+// Hooks into common dialog to show only directories
+BOOL EXPORT  BrowseHookProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
+{
+    HWND hwndT;
+    extern CPL  gCPL;       // app global
+
+    switch (wMsg) {
+    case WM_INITDIALOG:
+          #define lpOFN ((LPOPENFILENAME)lParam)
+          // CopyWindowText(GetDlgItem(lpOFN->hwndOwner, IDD_TEXT), GetDlgItem(hDlg, ctlLast + 1));
+//          CopyWindowText(lpOFN->hwndOwner, hDlg);
+
+          // hide the file we are looking for in an extra control
+          SetDlgItemText(hDlg, ctlLast + 3, lpOFN->lpstrFile);
+          goto PostMyMessage;
+
+    case WM_COMMAND:
+        switch (wParam) {
+            case lst2:
+            case cmb2:
+            case IDOK:
+PostMyMessage:
+                PostMessage(hDlg, WM_COMMAND, ctlLast+2, 0L);
+                break;
+
+            case pshHelp:
+                goto DoHelp;
+
+            case ctlLast + 2:
+                hwndT = GetDlgItem(hDlg, lst1);
+                if (SendMessage(hwndT, LB_GETCOUNT, 0, 0L)) {
+                    SendMessage(hwndT, LB_SETCURSEL, 0, 0L);
+                    SendMessage(hDlg, WM_COMMAND, lst1, MAKELONG(hwndT, LBN_SELCHANGE));
+                    break;
+                }
+                // poke the file we are looking for back into the edit field
+                // this is needed so that commdlg will send us the
+                // wBrowseDoneMsg
+
+                CopyWindowText(GetDlgItem(hDlg, ctlLast + 3), GetDlgItem(hDlg, edt1));
+
+                break;
+        }
+        break;
+
+    default:
+        if (wMsg == gCPL.uHelpMsg) {
+DoHelp:
+//			Help( hDlg, CPL_HLP_BROWSE );
+            // CPHelp(hDlg);
+            return TRUE;
+        } else if (wMsg == wBrowseDoneMsg) {
+
+            if (!VerifyFileExists(hDlg, lpOFN->lpstrFile, lpOFN->lpstrFile + lpOFN->nFileOffset))
+                return TRUE;
+
+        }
+    }
+
+    return FALSE;  // commdlg, do your thing
+}
+
+
+// hDlg is the prompt dialog
+// lpszFile is the file we are looking for
+
+BOOL NEAR PASCAL DoBrowse(HWND hDlg, LPCSTR lpszFile, LPCSTR lpszOtherFiles)
+{
+    OPENFILENAME ofn;
+    char szPath[CPL_MAX_PATH], szInitDir[CPL_MAX_PATH];
+    char szFilter[30];
+    int temp;
+    LPSTR lpTemp, lpFilters;
+    extern CPL  gCPL;       // app global
+
+    // build a filter that contains wild cards so the
+    // commdlg will fill the file list & edit control for us.
+    // this is based on the file passed in and any other
+    // file specs the caller wants to use.
+
+    szFilter[0] = 'a';      // dummy file type string (user doesn't see this)
+    szFilter[1] = '\0';
+    lpFilters = szFilter + 2;
+
+    lstrcpyn(lpFilters, lpszFile, sizeof(szFilter) - 2);
+    // make sure the extension is ".*"
+    lpTemp = _fstrchr(lpFilters, '.');
+    if (lpTemp) {
+        lstrcpy(lpTemp, ".*");
+    }
+    if (lpszOtherFiles) {
+        lpTemp = lpFilters + lstrlen(lpFilters);
+        *lpTemp++ = ';';
+        lstrcpy(lpTemp, lpszOtherFiles);
+    }
+
+    lstrcpyn(szPath, lpszFile, sizeof(szPath));
+
+    GetDlgItemText(hDlg, IDD_PATH, szInitDir, sizeof(szInitDir));
+    PathRemoveBlanks(szInitDir);
+
+    ofn.lStructSize = sizeof(OPENFILENAME);
+    ofn.hwndOwner = hDlg;
+    ofn.hInstance = gCPL.hCplInst;
+    ofn.lpstrFilter = szFilter;
+    ofn.lpstrCustomFilter = NULL;
+    ofn.nMaxCustFilter = 0;
+    ofn.nFilterIndex = 1;
+    ofn.lpstrFile = szPath;
+    ofn.nMaxFile = sizeof(szPath);
+    ofn.lpstrInitialDir = szInitDir;
+    ofn.lpstrTitle = NULL;
+    ofn.Flags = OFN_HIDEREADONLY | OFN_ENABLEHOOK |
+                OFN_ENABLETEMPLATE |
+                OFN_SHOWHELP | OFN_NOCHANGEDIR;
+    ofn.lCustData = MAKELONG(hDlg, 0);
+    ofn.lpfnHook = BrowseHookProc;
+    ofn.lpTemplateName  = (LPSTR)MAKEINTRESOURCE(IDD_BROWSE);
+    ofn.nFileOffset = 0;
+    ofn.nFileExtension = 0;
+    ofn.lpstrDefExt = NULL;
+    ofn.lpstrFileTitle = NULL;
+
+    temp = GetOpenFileName(&ofn);
+
+    UpdateWindow(hDlg); // force buttons to repaint
+
+    if (temp) {
+        // remove file part, put the result in the path field
+        szPath[ofn.nFileOffset - 1] = '\0';
+        SetDlgItemText(hDlg, IDD_PATH, szPath);
+        return TRUE;
+    }
+    return FALSE;
+}
+
diff --git a/private/tapi/dev/cpl/insdisk.h b/private/tapi/dev/cpl/insdisk.h
new file mode 100644
index 000000000..495250330
--- /dev/null
+++ b/private/tapi/dev/cpl/insdisk.h
@@ -0,0 +1,10 @@
+
+#ifndef PH_INSDISK
+#define PH_INSDISK
+ 
+int WINAPI InsertDisk(HWND hwnd, LPCSTR lpszDiskName,
+    LPCSTR lpszFile, LPCSTR lpszOtherFiles, LPSTR lpszPath, HICON hIcon, UINT wFlags);
+ 
+ 
+#endif // PH_INSDISK
+
diff --git a/private/tapi/dev/cpl/makefile b/private/tapi/dev/cpl/makefile
new file mode 100644
index 000000000..68867704a
--- /dev/null
+++ b/private/tapi/dev/cpl/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/cpl/makefile.16 b/private/tapi/dev/cpl/makefile.16
new file mode 100644
index 000000000..3d1b0766b
--- /dev/null
+++ b/private/tapi/dev/cpl/makefile.16
@@ -0,0 +1,60 @@
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+
+ROOT=..\..\..\..\..
+
+IS_OEM=TRUE
+MASM6=1
+IS_16 = TRUE
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=telephon.cpl
+
+SRCDIR=..
+
+CLEANLIST=*.cpl
+
+L16EXE=telephon.cpl		# Name of exe.
+L16DEF=..\telephon.def              # Our def file.
+L16MAP=telephon.map		# Our map file.
+L16SYM=telephon.sym		# Our sym file.
+L16LIBSNODEP= \
+          libw.lib \
+          ldllcew.lib \
+          ver.lib     \
+          lzexpand.lib     \
+          commctrl.lib     \
+          commdlg.lib
+
+L16LIBS= \
+        ..\..\lib\tapi14\16bit\tapi.lib
+
+L16RES=telephon.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L16OBJS = init.obj util.obj drv.obj cpl.obj \
+       copy.obj filecopy.obj insdisk.obj inf.obj \
+       mmdriver.obj exe.obj debug.obj ..\dos.obj
+
+
+!include $(ROOT)\dev\master.mk
+
+#CFLAGS = $(CFLAGS) /G3 /W3 /Zp1 /ALw /GD /Gf -DDBG=1
+CFLAGS = $(CFLAGS) /G3 /W3 /Zp1 /ALw /GD /Gf
+RCFLAGS = $(RCFLAGS) /DWINBUILD=1
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
+#LFLAGS= /NOD /NOE /ALIGN:8 /NONULLS /PACKD /PACKF @telephon.crf
diff --git a/private/tapi/dev/cpl/makefile.def b/private/tapi/dev/cpl/makefile.def
new file mode 100644
index 000000000..d28602cdf
--- /dev/null
+++ b/private/tapi/dev/cpl/makefile.def
@@ -0,0 +1,65 @@
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+BUILDDLL=1
+DLLENTRY=DllEntryPoint
+
+CLEANLIST=*.cpl
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=telephon.cpl
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+
+L32EXE=telephon.cpl		# Name of exe.
+L32DEF=..\telephon.def              # Our def file.
+L32MAP=telephon.map		# Our map file.
+L32SYM=telephon.sym		# Our sym file.
+L32LIBS=$(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\advapi32.lib                \
+        $(W32LIBID)\version.lib                 \
+        $(W32LIBID)\lz32.lib                    \
+        $(W32LIBID)\comdlg32.lib                \
+        $(W32LIBID)\comctl32.lib                \
+        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib   \
+        ..\..\lib\tapi32.lib
+
+L32RES=telephon.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = init.obj util.obj drv.obj cpl.obj \
+       copy.obj filecopy.obj insdisk.obj inf.obj \
+       mmdriver.obj exe.obj debug.obj
+#       dos.obj
+
+
+
+!include $(ROOT)\dev\master.mk
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/cpl/mmdriver.c b/private/tapi/dev/cpl/mmdriver.c
new file mode 100644
index 000000000..22605cbac
--- /dev/null
+++ b/private/tapi/dev/cpl/mmdriver.c
@@ -0,0 +1,424 @@
+/*----------------------------------------------------------------------------
+
+// BUGBUG - masive abuse of static local variables to get around
+// near pointer usage.  this is increadibly bogus...
+
+ | mmdriver.c - Install Multimedia Drivers
+ |									      
+ | Copyright (C) Microsoft, 1989, 1990.  All Rights Reserved
+ |									      
+ |  History:
+ |	09/11/90    davidle     created
+ |          Install Multimedia Drivers
+ |
+ |      Tue Jan 29 1991 -by- MichaelE
+ |          Redesigned installing installable drivers so additional drivers
+ |        can be installed by adding them to setup.inf's [installable.drivers]
+ |
+ |      Wed Mar 20 1991 -by- MichaelE
+ |          Changed mmAddInstallableDriver to accept multiple VxDs.
+ |          Changed and WriteNextPrivateProfileString to check if the profile
+ |          being concatenated is already there.
+ |
+ |      Sun Apr 14 1991 -by- MichaelE
+ |          WriteNextPrivateProfileString -> Next386EnhDevice.
+ |
+ |      Sun Apr 14 1991 -by- JohnYG
+ |          Taken from setup for drivers applet.
+ |
+ |      Wed Jun 05 1991 -by- MichaelE
+ |          Added FileCopy of associated file list to windows system dir.
+ |
+ *----------------------------------------------------------------------------*/
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <string.h>
+#include "drv.h"
+#include "externs.h"
+#include "sulib.h"
+
+#ifndef PUBLIC
+#define PUBLIC far pascal
+#endif
+#ifndef PRIVATE
+#define PRIVATE near pascal
+#endif
+
+char szComma[]               = ",";
+char szVxDevice[]            = "\r\ndevice=";
+char szBeginSect[]           = "\r\n[";
+char sz386enhSect[]          = "\r\n[386enh]";
+
+BOOL PRIVATE AddInstallableDriver (PINF, LPSTR, LPSTR, LPSTR, PIDRIVER);
+WORD PRIVATE mmFileOffset         (LPSTR, LPSTR);
+PINF PRIVATE Next386EnhDevice     (LPSTR, LPSTR);
+void PRIVATE GetDrivers           (PINF, LPSTR /*!!!*/, LPSTR /*!!!*/);
+
+BOOL FAR PASCAL  mmAddNewDriver       (LPSTR, LPSTR, PIDRIVER);
+
+
+
+
+//**************************************************************************
+//**************************************************************************
+/* mmAddNewDriver() - only exported function in this file.
+
+   This function installs (copies) a driver and all associated VxD's.
+       
+   returns FALSE if no drivers could be installed.
+           TRUE if at least one driver installation was sucessful.
+           All added types in lpszNewTypes buffer.
+*/               
+
+BOOL FAR PASCAL mmAddNewDriver(LPSTR lpstrDriver, LPSTR lpstrNewTypes, PIDRIVER pIDriver)
+{
+    PINF pinf;
+    char sz386enh[256];
+    
+    if ((pinf = infFindSection(NULL, szMDrivers)) == NULL)
+        return FALSE;
+    
+    sz386enh[0] = 0;
+
+    if (AddInstallableDriver(pinf, lpstrDriver, sz386enh, lpstrNewTypes, pIDriver))
+    {
+        Next386EnhDevice(sz386enh, NULL);
+
+        return TRUE;
+    }
+    else 
+       return FALSE;    
+}
+  
+
+
+//**************************************************************************
+//**************************************************************************
+/* AddInstallableDriver() - Do the dirty work looking for VxD's copying them
+    looking for drivers, copying them, and returning the best type names.
+*/
+
+BOOL PRIVATE AddInstallableDriver(PINF pInfIDrivers, LPSTR pstrDriver, LPSTR pstr386enh, LPSTR lpstrNewTypes, PIDRIVER pIDriver)
+{
+    LPSTR /*!!!*/ pstr, pstrSection;
+    PINF pInfSection= pInfIDrivers;
+    int  i;
+    char szTemp[10];
+    static char szBuffer[MAX_INF_LINE_LEN], 
+	        szFilename[MAX_VDD_LEN], 
+                szType[MAX_SECT_NAME_LEN];
+
+    // format of a line in [installable.drivers] of setup.inf:
+    // driver profile = filename, "type(s)", "description", "VxD filename(s)",
+    // "default config params"
+    // find the driver profile line in szMDrivers we are installing
+
+    while (TRUE)
+    {
+        infParseField(pInfIDrivers, 0, szBuffer);
+        if (lstrcmpi(szBuffer, pstrDriver) == 0)
+            break;
+        else if (! (pInfIDrivers = infNextLine(pInfIDrivers)))
+            return FALSE;
+    }
+
+    // copy the driver file and add driver type(s) to the installable 
+    // driver section
+
+    if (!infParseField(pInfIDrivers, 1, szFilename))
+	return FALSE;
+    
+    lstrcpy(szDrv, szFilename);    
+    if (szDrv[1] == ':')
+       lstrcpy(szDrv, &szFilename[2]);	    
+
+    if (FileCopy(szFilename, szSystem, (FPFNCOPY)wsCopySingleStatus, FC_FILE) != ERROR_OK)
+        return FALSE;
+
+    // Add Options
+    
+    if (infParseField (pInfIDrivers, 5, szBuffer+1))
+    {
+       szBuffer[0]=' ';
+       lstrcat(szFilename, szBuffer);       
+    }
+    
+    // copy filename and options
+          
+    lstrcpyn(pIDriver->szFile, FileName(szFilename), sizeof(pIDriver->szFile));
+    // copy description
+            
+    infParseField(pInfIDrivers, 3, pIDriver->szDesc); 
+
+    // determine the section from the description
+            
+//    if (lstrstri(pIDriver->szDesc, szMCI))
+//        pstrSection = szMCI;
+//    else
+        pstrSection = szDrivers;
+        
+    lstrcpyn(pIDriver->szSection, pstrSection, sizeof(pIDriver->szSection));
+        
+    // We return all types in a parseable, contcatentated string
+            
+    for (i = 1, infParseField(pInfIDrivers, 2, szBuffer); infParseField(szBuffer, i, szType); i++)
+    {
+        pstr = &(szType[lstrlen(szType)]);
+        *pstr++ = ',';
+        *pstr = 0;
+        lstrcat(lpstrNewTypes, szType);
+    }
+ 
+    if (!*lpstrNewTypes)
+        // We weren't able to return any types.
+       return FALSE;
+
+    // copy an associated file list (if it exists) to windows system dir 
+    //------------------------------------------------------------------
+    if (FileCopy(pstrDriver, szSystem, (FPFNCOPY)wsCopySingleStatus, FC_SECTION) != ERROR_OK)
+	return(FALSE);
+
+    // if there is a driver VxD copy it and add it to the VxD section
+    
+    bVxd = TRUE;
+    if (infParseField(pInfIDrivers, 4, szBuffer) && szBuffer[0])
+        for (i = 1; infParseField(szBuffer, i, szFilename); i++)
+	{
+  	  if (szFilename[1] == ':')
+     	    lstrcpy(szDrv, &szFilename[2]);
+          else
+	    lstrcpy(szDrv, szFilename);		  
+    
+          if ((FileCopy(szFilename, szSystem, (FPFNCOPY)wsCopySingleStatus, FC_FILE) != ERROR_OK) ||
+                 ! Next386EnhDevice(pstr386enh, FileName(szFilename)))
+	  {
+	    bVxd = FALSE;		  
+            return FALSE;
+          }
+        }
+	
+    bVxd = FALSE;
+    infParseField(pInfIDrivers, 7, szTemp);    
+    if (!lstrcmpi(szTemp, szBoot))
+	bInstallBootLine = TRUE;
+
+    if (bRelated == FALSE)
+    {
+       infParseField(pInfIDrivers, 6, pIDriver->szRelated);
+       if (lstrlen(pIDriver->szRelated))
+       {
+	  GetDrivers(pInfSection, pIDriver->szRelated, pIDriver->szRemove);
+	  pIDriver->bRelated = TRUE;	       
+          bRelated = TRUE;
+       }    
+    }
+    return TRUE;
+}
+
+
+//**************************************************************************
+//**************************************************************************
+/* mmFileOffset() - returns the actual file offset value.
+*/
+
+WORD PRIVATE mmFileOffset(LPSTR lpstrBuf, LPSTR lpstrKey)
+{
+    LPSTR lpstr = lpstrBuf;
+    int   iLen  = lstrlen(lpstrKey);
+
+    while (*lpstr && strncmpi(lpstr, lpstrKey, iLen))
+        lpstr++;
+
+    return lpstr - lpstrBuf;
+}
+
+
+
+//**************************************************************************
+//**************************************************************************
+// Uses the infparse stuff to build a list (pstrDevice) of unique VxDs.
+// If called with pstrValue != NULL, pstrValue is a VxD to add to pstrDevice
+// if it is not already in pstrDevice or the 386enh section.  If called with
+// pstrValue == NULL then it is time to write out all the VxD's in pstrDevice.
+// Since I'm the only guy who is going to be able to write multiple device=
+// lines into [386enh] there is no need to worry about somebody changing
+// this section underneath me.
+
+PINF PRIVATE Next386EnhDevice(LPSTR lpstrDevice, LPSTR lpstrValue)
+{
+    static PINF pinfSysIni = NULL, pinf386enh;
+    static int  i386enhLines;
+
+    OFSTRUCT ofSysIni;
+    PINF     pinf;
+    WORD     wLength;
+    DWORD    dwLength;
+    LPSTR    lpstr, lpstrSysIni, lpstrDev;
+    int      i, j, fh;
+    char     szBuffer[MAX_INF_LINE_LEN];
+
+    if (lpstrValue)
+    {
+        // if first time call, initialize the PINF buffer
+
+	if (pinfSysIni == NULL)
+	    WritePrivateProfileString(NULL, NULL, NULL, szSysIni);
+		    
+        if ((pinfSysIni == NULL)                              &&
+             (OpenFile(szSysIni, &ofSysIni, OF_EXIST) != -1) &&
+             (pinfSysIni = infOpen(ofSysIni.szPathName)))
+        {
+            *lpstrDevice = '\0';
+            pinf386enh = infFindSection(pinfSysIni, SYSTEM_SECT_INI);
+            i386enhLines= infLineCount(pinf386enh);
+        }
+
+        // make sure the VxD isn't already amoung those to add to [386enh]
+
+        for (i = 1; infParseField(lpstrDevice, i, szBuffer); i++)
+            if (! lstrcmpi(szBuffer, lpstrValue))
+                return pinfSysIni;
+
+        // make sure the VxD isn't already in [386enh]
+
+        for (i = i386enhLines, pinf = pinf386enh; i; i--, pinf = infNextLine(pinf))
+            for (j = 1; infParseField(pinf, j, szBuffer); j++)
+                if (! lstrcmpi(szBuffer, lpstrValue))
+                    return pinfSysIni;
+
+        // never seen this VxD before, so throw it in with the rest
+
+        lstrcat(lpstrDevice, lpstrValue);
+        lstrcat(lpstrDevice, szComma);
+
+        return pinfSysIni;
+    }
+    else if (pinfSysIni)
+    {
+        // put the new device things into system.ini
+
+        infClose(pinfSysIni);
+
+        pinfSysIni = NULL;
+
+        // tell kernel to flush any stored ini file.
+
+        WritePrivateProfileString(NULL, NULL, NULL, szSysIni);
+
+        if (*lpstrDevice && (fh = OpenFile(szSysIni, &ofSysIni, OF_READWRITE)) != -1)
+        {
+            // read the system.ini file into a buffer
+
+            dwLength = _llseek(fh, 0L, 2);
+    
+	    //
+	    // if SYSTEM.INI is too big we are hosed.
+	    //
+	    if (dwLength > 64l * 1024 - 2)
+	    {
+		MessageBeep(0);
+		return NULL;  //!!!
+	    }
+		    
+            wLength = (WORD)dwLength;
+	    
+            if (lpstr = lpstrSysIni = GlobalLock(GlobalAlloc(GMEM_MOVEABLE,dwLength + 1)))
+            {
+                _llseek(fh, 0L, 0);
+                if (_lread(fh, lpstr, wLength) == wLength)
+                {
+                    *(lpstr+wLength) = (char)0;       // mark end of buffer
+
+                    // write out the system.ini file up to the last [386enh] line
+
+                    _llseek(fh, 0L, 0);
+                    wLength =  mmFileOffset(lpstr, sz386enhSect) + lstrlen(sz386enhSect);
+                    wLength += mmFileOffset(lpstr+wLength, szBeginSect);
+                    _lwrite(fh, lpstr, wLength);
+                    lpstr += wLength;
+
+                    // write out the new device = guys
+                    lstrcpy(szBuffer, szVxDevice);
+                    lpstrDev = szBuffer + lstrlen(szBuffer);
+                    for (i = 1; infParseField(lpstrDevice, i, lpstrDev) && *lpstrDev; i++)
+                        _lwrite(fh, szBuffer, lstrlen(szBuffer));
+
+                    // write out the rest of the file
+
+                    _lwrite(fh, lpstr, lstrlen(lpstr));
+                }
+                GlobalFree((HANDLE)(HIWORD(lpstrSysIni)));
+            }
+            _lclose(fh);
+        }
+    }
+    return NULL;
+}
+
+
+
+//**************************************************************************
+//**************************************************************************
+#ifdef USE_INTERNAL_STRNCMPI
+/* Yet another copy of strncmpi, probably should be in sulib
+*/
+
+int FAR PASCAL strncmpi(char far *pch1, char far *pch2, int n)
+{
+    while (*pch1 && --n > 0 && UPCASE(*pch1) == UPCASE(*pch2))
+	     *pch1++,*pch2++;
+    return UPCASE(*pch1) != UPCASE(*pch2);
+}
+#endif
+
+
+
+
+//**************************************************************************
+//**************************************************************************
+/* Used to get the list of the related driver filenames
+
+*/
+
+void PRIVATE GetDrivers(PINF pInfIDrivers, LPSTR /*!!!*/ szAliasList, LPSTR /*!!!*/ szDriverList)
+{
+  char szBuffer[50];
+  char szAlias[50];
+  PINF pInfILocal;
+  BOOL bEnd;
+  int i;
+  char szTemp[50];
+  char szFileName[50];
+  
+  for (i = 1; infParseField(szAliasList, i, szAlias); i++)
+  {
+     pInfILocal = pInfIDrivers;	  
+     bEnd = FALSE;     
+     while (!bEnd)
+     {
+        infParseField(pInfILocal, 0, szBuffer);
+        if (lstrcmpi(szBuffer, szAlias) == 0)
+        {
+           if (infParseField(pInfILocal, 1, szFileName))	  
+	   {
+	      if (szFileName[1] == ':')
+	      {
+   	         lstrcpy(szTemp, &szFileName[2]);
+   	         lstrcat(szDriverList, szTemp);
+     	      }
+	      else
+   	         lstrcat(szDriverList, szFileName);
+	 
+	      lstrcat(szDriverList, ",");	    
+           }
+	   break;
+        }
+        else 
+	   if (! (pInfILocal = infNextLine(pInfILocal)))
+	      bEnd = TRUE;
+     }
+  }  
+}
+    
+	
diff --git a/private/tapi/dev/cpl/new/debug.c b/private/tapi/dev/cpl/new/debug.c
new file mode 100644
index 000000000..9d17361c3
--- /dev/null
+++ b/private/tapi/dev/cpl/new/debug.c
@@ -0,0 +1,85 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include  <tapi.h>                  
+#include <stdarg.h>
+
+
+
+
+DWORD   gdwDebugLevel;
+
+
+VOID
+DbgPrt(
+    DWORD  dwDbgLevel,
+    LPSTR lpszFormat,
+    ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    
+    static BOOL fAlreadyGotIt = FALSE;
+    static char    buf[128] = "TAPI CPL: ";
+#define TEXT_START 10
+
+    if (!fAlreadyGotIt)
+    {
+
+        gdwDebugLevel = (DWORD) GetPrivateProfileInt(
+            "Debug",
+            "TapiCPL32DebugLevel",
+            0x0,
+            "Telephon.ini"
+            );
+
+        fAlreadyGotIt = TRUE;
+
+        wsprintf(&buf[TEXT_START], "TAPICPL32DebugLevel=%d \r\n", gdwDebugLevel);
+        OutputDebugString(buf);
+    }
+
+
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        vsprintf (&buf[TEXT_START],
+                  lpszFormat,
+                  ap
+                  );
+
+        strcat (buf, "\n");
+
+        OutputDebugString(buf);
+
+        va_end(ap);
+    }
+}
+
+#endif
diff --git a/private/tapi/dev/cpl/new/debug.h b/private/tapi/dev/cpl/new/debug.h
new file mode 100644
index 000000000..ab27ba4aa
--- /dev/null
+++ b/private/tapi/dev/cpl/new/debug.h
@@ -0,0 +1,17 @@
+#if DBG
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    DWORD  dwDbgLevel,
+    LPSTR DbgMessage,
+    ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/cpl/newexe.h b/private/tapi/dev/cpl/newexe.h
new file mode 100644
index 000000000..d89ae6295
--- /dev/null
+++ b/private/tapi/dev/cpl/newexe.h
@@ -0,0 +1,378 @@
+/*static char *SCCSID = "@(#)newexe.h:2.9";*/
+/*
+ *  Title
+ *
+ *      newexe.h
+ *      Pete Stewart
+ *      (C) Copyright Microsoft Corp 1984
+ *      17 August 1984
+ *
+ *  Description
+ *
+ *      Data structure definitions for the DOS 4.0/Windows 2.0
+ *      executable file format.
+ *
+ *  Modification History
+ *
+ *      84/08/17        Pete Stewart    Initial version
+ *      84/10/17        Pete Stewart    Changed some constants to match OMF
+ *      84/10/23        Pete Stewart    Updates to match .EXE format revision
+ *      84/11/20        Pete Stewart    Substantial .EXE format revision
+ *      85/01/09        Pete Stewart    Added constants ENEWEXE and ENEWHDR
+ *      85/01/10        Steve Wood      Added resource definitions
+ *      85/03/04        Vic Heller      Reconciled Windows and DOS 4.0 versions
+ *      85/03/07        Pete Stewart    Added movable entry count
+ *      85/04/01        Pete Stewart    Segment alignment field, error bit
+ */
+
+#define EMAGIC          0x5A4D          /* Old magic number */
+#define ENEWEXE         sizeof(struct exe_hdr)
+                                        /* Value of E_LFARLC for new .EXEs */
+#define ENEWHDR         0x003C          /* Offset in old hdr. of ptr. to new */
+#define ERESWDS         0x0010          /* No. of reserved words in header */
+#define ECP             0x0004          /* Offset in struct of E_CP */
+#define ECBLP           0x0002          /* Offset in struct of E_CBLP */
+#define EMINALLOC       0x000A          /* Offset in struct of E_MINALLOC */
+
+struct exe_hdr                          /* DOS 1, 2, 3 .EXE header */
+  {
+    unsigned short      e_magic;        /* Magic number */
+    unsigned short      e_cblp;         /* Bytes on last page of file */
+    unsigned short      e_cp;           /* Pages in file */
+    unsigned short      e_crlc;         /* Relocations */
+    unsigned short      e_cparhdr;      /* Size of header in paragraphs */
+    unsigned short      e_minalloc;     /* Minimum extra paragraphs needed */
+    unsigned short      e_maxalloc;     /* Maximum extra paragraphs needed */
+    unsigned short      e_ss;           /* Initial (relative) SS value */
+    unsigned short      e_sp;           /* Initial SP value */
+    unsigned short      e_csum;         /* Checksum */
+    unsigned short      e_ip;           /* Initial IP value */
+    unsigned short      e_cs;           /* Initial (relative) CS value */
+    unsigned short      e_lfarlc;       /* File address of relocation table */
+    unsigned short      e_ovno;         /* Overlay number */
+    unsigned short      e_res[ERESWDS]; /* Reserved words */
+    long                e_lfanew;       /* File address of new exe header */
+  };
+
+#define E_MAGIC(x)      (x).e_magic
+#define E_CBLP(x)       (x).e_cblp
+#define E_CP(x)         (x).e_cp
+#define E_CRLC(x)       (x).e_crlc
+#define E_CPARHDR(x)    (x).e_cparhdr
+#define E_MINALLOC(x)   (x).e_minalloc
+#define E_MAXALLOC(x)   (x).e_maxalloc
+#define E_SS(x)         (x).e_ss
+#define E_SP(x)         (x).e_sp
+#define E_CSUM(x)       (x).e_csum
+#define E_IP(x)         (x).e_ip
+#define E_CS(x)         (x).e_cs
+#define E_LFARLC(x)     (x).e_lfarlc
+#define E_OVNO(x)       (x).e_ovno
+#define E_RES(x)        (x).e_res
+#define E_LFANEW(x)     (x).e_lfanew
+
+#define NEMAGIC         0x454E          /* New magic number */
+#define NERESBYTES      0
+
+struct new_exe                          /* New .EXE header */
+  {
+    unsigned short int  ne_magic;       /* Magic number NE_MAGIC */
+    char                ne_ver;         /* Version number */
+    char                ne_rev;         /* Revision number */
+    unsigned short int  ne_enttab;      /* Offset of Entry Table */
+    unsigned short int  ne_cbenttab;    /* Number of bytes in Entry Table */
+    long                ne_crc;         /* Checksum of whole file */
+    unsigned short int  ne_flags;       /* Flag word */
+    unsigned short int  ne_autodata;    /* Automatic data segment number */
+    unsigned short int  ne_heap;        /* Initial heap allocation */
+    unsigned short int  ne_stack;       /* Initial stack allocation */
+    long                ne_csip;        /* Initial CS:IP setting */
+    long                ne_sssp;        /* Initial SS:SP setting */
+    unsigned short int  ne_cseg;        /* Count of file segments */
+    unsigned short int  ne_cmod;        /* Entries in Module Reference Table */
+    unsigned short int  ne_cbnrestab;   /* Size of non-resident name table */
+    unsigned short int  ne_segtab;      /* Offset of Segment Table */
+    unsigned short int  ne_rsrctab;     /* Offset of Resource Table */
+    unsigned short int  ne_restab;      /* Offset of resident name table */
+    unsigned short int  ne_modtab;      /* Offset of Module Reference Table */
+    unsigned short int  ne_imptab;      /* Offset of Imported Names Table */
+    long                ne_nrestab;     /* Offset of Non-resident Names Table */
+    unsigned short int  ne_cmovent;     /* Count of movable entries */
+    unsigned short int  ne_align;       /* Segment alignment shift count */
+    unsigned short int  ne_cres;        /* Count of resource segments */
+
+#ifdef NEVER
+    unsigned short int  ne_psegcsum;    /* offset to segment chksums */
+#else
+    unsigned char	ne_exetyp;	/* Target Operating system */
+    unsigned char	ne_flagsothers;	/* Other .EXE flags */
+#endif
+    unsigned short int  ne_pretthunks;  /* offset to return thunks */
+    unsigned short int  ne_psegrefbytes;/* offset to segment ref. bytes */
+    unsigned short int  ne_swaparea;    /* Minimum code swap area size */
+    unsigned short int  ne_expver;      /* Expected Windows version number */
+  };
+
+#define NE_MAGIC(x)     (x).ne_magic
+#define NE_VER(x)       (x).ne_ver
+#define NE_REV(x)       (x).ne_rev
+#define NE_ENTTAB(x)    (x).ne_enttab
+#define NE_CBENTTAB(x)  (x).ne_cbenttab
+#define NE_CRC(x)       (x).ne_crc
+#define NE_FLAGS(x)     (x).ne_flags
+#define NE_AUTODATA(x)  (x).ne_autodata
+#define NE_HEAP(x)      (x).ne_heap
+#define NE_STACK(x)     (x).ne_stack
+#define NE_CSIP(x)      (x).ne_csip
+#define NE_SSSP(x)      (x).ne_sssp
+#define NE_CSEG(x)      (x).ne_cseg
+#define NE_CMOD(x)      (x).ne_cmod
+#define NE_CBNRESTAB(x) (x).ne_cbnrestab
+#define NE_SEGTAB(x)    (x).ne_segtab
+#define NE_RSRCTAB(x)   (x).ne_rsrctab
+#define NE_RESTAB(x)    (x).ne_restab
+#define NE_MODTAB(x)    (x).ne_modtab
+#define NE_IMPTAB(x)    (x).ne_imptab
+#define NE_NRESTAB(x)   (x).ne_nrestab
+#define NE_CMOVENT(x)   (x).ne_cmovent
+#define NE_ALIGN(x)     (x).ne_align
+#define NE_RES(x)       (x).ne_res
+#define NE_EXETYPE(x)	(x).ne_exetyp
+
+#define NE_USAGE(x)     (WORD)*((WORD FAR *)(x)+1)
+#define NE_PNEXTEXE(x)  (WORD)(x).ne_cbenttab
+#define NE_PAUTODATA(x) (WORD)(x).ne_crc
+#define NE_PFILEINFO(x) (WORD)((DWORD)(x).ne_crc >> 16)
+
+#ifdef DOS5
+#define NE_MTE(x)   (x).ne_psegcsum /* DOS 5 MTE handle for this module */
+#endif
+
+
+/*
+ *  Format of NE_FLAGS(x):
+ *
+ *  p                                   Not-a-process
+ *   c                                  Non-conforming
+ *    e                                 Errors in image
+ *     xxxxxxxxx                        Unused
+ *              P                       Runs in protected mode
+ *               r                      Runs in real mode
+ *                i                     Instance data
+ *                 s                    Solo data
+ */
+#define NENOTP          0x8000          /* Not a process */
+#define NENONC          0x4000          /* Non-conforming program */
+#define NEIERR          0x2000          /* Errors in image */
+#define NEPROT          0x0008          /* Runs in protected mode */
+#define NEREAL          0x0004          /* Runs in real mode */
+#define NEINST          0x0002          /* Instance data */
+#define NESOLO          0x0001          /* Solo data */
+
+struct new_seg                          /* New .EXE segment table entry */
+  {
+    unsigned short      ns_sector;      /* File sector of start of segment */
+    unsigned short      ns_cbseg;       /* Number of bytes in file */
+    unsigned short      ns_flags;       /* Attribute flags */
+    unsigned short      ns_minalloc;    /* Minimum allocation in bytes */
+  };
+
+struct new_seg1                         /* New .EXE segment table entry */
+  {
+    unsigned short      ns_sector;      /* File sector of start of segment */
+    unsigned short      ns_cbseg;       /* Number of bytes in file */
+    unsigned short      ns_flags;       /* Attribute flags */
+    unsigned short      ns_minalloc;    /* Minimum allocation in bytes */
+    unsigned short      ns_handle;      /* Handle of segment */
+  };
+
+#define NS_SECTOR(x)    (x).ns_sector
+#define NS_CBSEG(x)     (x).ns_cbseg
+#define NS_FLAGS(x)     (x).ns_flags
+#define NS_MINALLOC(x)  (x).ns_minalloc
+
+/*
+ *  Format of NS_FLAGS(x):
+ *
+ *  xxxx                                Unused
+ *      DD                              286 DPL bits
+ *        d                             Segment has debug info
+ *         r                            Segment has relocations
+ *          e                           Execute/read only
+ *           p                          Preload segment
+ *            P                         Pure segment
+ *             m                        Movable segment
+ *              i                       Iterated segment
+ *               ttt                    Segment type
+ */
+#define NSTYPE          0x0007          /* Segment type mask */
+#define NSCODE          0x0000          /* Code segment */
+#define NSDATA          0x0001          /* Data segment */
+#define NSITER          0x0008          /* Iterated segment flag */
+#define NSMOVE          0x0010          /* Movable segment flag */
+#define NSPURE          0x0020          /* Pure segment flag */
+#define NSPRELOAD       0x0040          /* Preload segment flag */
+#define NSEXRD          0x0080          /* Execute-only (code segment), or
+                                        *  read-only (data segment)
+                                        */
+#define NSRELOC         0x0100          /* Segment has relocations */
+#define NSDEBUG         0x0200          /* Segment has debug info */
+#define NSDPL           0x0C00          /* 286 DPL bits */
+#define NSDISCARD       0x1000          /* Discard bit for segment */
+
+#define NSALIGN 9       /* Segment data aligned on 512 byte boundaries */
+
+struct new_segdata                      /* Segment data */
+  {
+    union
+      {
+        struct
+          {
+            unsigned short      ns_niter;       /* number of iterations */
+            unsigned short      ns_nbytes;      /* number of bytes */
+            char                ns_iterdata;    /* iterated data bytes */
+          } ns_iter;
+        struct
+          {
+            char                ns_data;        /* data bytes */
+          } ns_noniter;
+      } ns_union;
+  };
+
+struct new_rlcinfo                      /* Relocation info */
+  {
+    unsigned short      nr_nreloc;      /* number of relocation items that */
+  };                                    /* follow */
+
+struct new_rlc                          /* Relocation item */
+  {
+    char                nr_stype;       /* Source type */
+    char                nr_flags;       /* Flag byte */
+    unsigned short      nr_soff;        /* Source offset */
+    union
+      {
+        struct
+          {
+            char        nr_segno;       /* Target segment number */
+            char        nr_res;         /* Reserved */
+            unsigned short nr_entry;    /* Target Entry Table offset */
+          }             nr_intref;      /* Internal reference */
+        struct
+          {
+            unsigned short nr_mod;      /* Index into Module Reference Table */
+            unsigned short nr_proc;     /* Procedure ordinal or name offset */
+          }             nr_import;      /* Import */
+      }                 nr_union;       /* Union */
+  };
+
+#define NR_STYPE(x)     (x).nr_stype
+#define NR_FLAGS(x)     (x).nr_flags
+#define NR_SOFF(x)      (x).nr_soff
+#define NR_SEGNO(x)     (x).nr_union.nr_intref.nr_segno
+#define NR_RES(x)       (x).nr_union.nr_intref.nr_res
+#define NR_ENTRY(x)     (x).nr_union.nr_intref.nr_entry
+#define NR_MOD(x)       (x).nr_union.nr_import.nr_mod
+#define NR_PROC(x)      (x).nr_union.nr_import.nr_proc
+
+/*
+ *  Format of NR_STYPE(x):
+ *
+ *  xxxxx                               Unused
+ *       sss                            Source type
+ */
+#define NRSTYP          0x07            /* Source type mask */
+#define NRSSEG          0x02            /* 16-bit segment */
+#define NRSPTR          0x03            /* 32-bit pointer */
+#define NRSOFF          0x05            /* 16-bit offset */
+
+/*
+ *  Format of NR_FLAGS(x):
+ *
+ *  xxxxx                               Unused
+ *       a                              Additive fixup
+ *        rr                            Reference type
+ */
+#define NRADD           0x04            /* Additive fixup */
+#define NRRTYP          0x03            /* Reference type mask */
+#define NRRINT          0x00            /* Internal reference */
+#define NRRORD          0x01            /* Import by ordinal */
+#define NRRNAM          0x02            /* Import by name */
+#define OSFIXUP 	0x03		/* Floating point fixup */
+
+
+/* Resource type or name string */
+struct rsrc_string
+    {
+    char rs_len;            /* number of bytes in string */
+    char rs_string[ 1 ];    /* text of string */
+    };
+
+#define RS_LEN( x )    (x).rs_len
+#define RS_STRING( x ) (x).rs_string
+
+/* Resource type information block */
+struct rsrc_typeinfo
+    {
+    unsigned short rt_id;
+    unsigned short rt_nres;
+    long rt_proc;
+    };
+
+#define RT_ID( x )   (x).rt_id
+#define RT_NRES( x ) (x).rt_nres
+#define RT_PROC( x ) (x).rt_proc
+
+/* Resource name information block */
+struct rsrc_nameinfo
+    {
+    /* The following two fields must be shifted left by the value of  */
+    /* the rs_align field to compute their actual value.  This allows */
+    /* resources to be larger than 64k, but they do not need to be    */
+    /* aligned on 512 byte boundaries, the way segments are           */
+    unsigned short rn_offset;   /* file offset to resource data */
+    unsigned short rn_length;   /* length of resource data */
+    unsigned short rn_flags;    /* resource flags */
+    unsigned short rn_id;       /* resource name id */
+    unsigned short rn_handle;   /* If loaded, then global handle */
+    unsigned short rn_usage;    /* Initially zero.  Number of times */
+                                /* the handle for this resource has */
+                                /* been given out */
+    };
+
+#define RN_OFFSET( x ) (x).rn_offset
+#define RN_LENGTH( x ) (x).rn_length
+#define RN_FLAGS( x )  (x).rn_flags
+#define RN_ID( x )     (x).rn_id
+#define RN_HANDLE( x ) (x).rn_handle
+#define RN_USAGE( x )  (x).rn_usage
+
+#define RSORDID     0x8000      /* if high bit of ID set then integer id */
+                                /* otherwise ID is offset of string from
+                                   the beginning of the resource table */
+
+                                /* Ideally these are the same as the */
+                                /* corresponding segment flags */
+#define RNMOVE      0x0010      /* Moveable resource */
+#define RNPURE      0x0020      /* Pure (read-only) resource */
+#define RNPRELOAD   0x0040      /* Preloaded resource */
+#define RNDISCARD   0x1000      /* Discard bit for resource */
+
+#define RNLOADED    0x0004      /* True if handler proc return handle */
+
+/* Resource table */
+struct new_rsrc
+    {
+    unsigned short rs_align;    /* alignment shift count for resources */
+    struct rsrc_typeinfo rs_typeinfo;
+    };
+
+#define RS_ALIGN( x ) (x).rs_align
+
+/* Target operating systems:  Possible values of ne_exetyp field */
+
+#define NE_UNKNOWN	0	/* Unknown (any "new-format" OS) */
+#define NE_OS2		1	/* Microsoft/IBM OS/2 (default)  */
+#define NE_WINDOWS	2	/* Microsoft Windows		 */
+#define NE_DOS4 	3	/* Microsoft MS-DOS 4.x		 */
+#define NE_DEV386	4	/* Microsoft Windows 386	 */
+
diff --git a/private/tapi/dev/cpl/resource.h b/private/tapi/dev/cpl/resource.h
new file mode 100644
index 000000000..ca108e898
--- /dev/null
+++ b/private/tapi/dev/cpl/resource.h
@@ -0,0 +1,120 @@
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by TELEPHON.RC
+//
+#define ID_CURRENT                      4
+#define ID_NEW                          6
+#define IDS_TITLE                       8
+#define IDS_STATUS_LINE                 9
+#define IDHELP                          9
+#define IDS_ERR_TAPI                    15
+#define IDS_ERR_APPLICATION             16
+#define IDS_ERR_MEMORY                  17
+#define IDS_ERR_ALREADY_IN_LIST         18
+#define IDS_WRN_INVAILD_STR             23
+#define IDS_WRN_INVAILD_EX_NUM_STR      24
+#define IDS_WRN_INVAILD_NUM             25
+//#define IDS_ERR_INVALID_TAPIADDR        26
+#define IDS_DT_DS_NO_DRIVER             28
+#define IDS_ERR_NO_DRIVER               29
+#define IDS_ERR_BAD_DRIVER              30
+#define IDS_NONE                        31
+#define IDS_DRIVER_REMOVE_OR_STUPID     36
+#define IDD_BROWSE_TEMPLATE             38
+#define IDS_WRN_INVAILD_NUM_STR         42
+#define IDS_WRN_DRIVER_IN_USE           44
+#define IDS_ERR_DRIVER_FAILED           45
+#define IDS_ERR_MULTIPLE_INST           46
+#define IDS_DIALOG_TITLE                48
+//#define IDD_GENERIC_LIST                102
+#define IDI_TELEPHONY                   108
+#define IDD_ADD_DRIVER                  111
+#define IDD_DRIVER_SETUP                116
+#define IDD_INSTALL_DRIVER              117
+#define IDB_BITMAP1                     120
+#define IDD_DEBUG_OUT                   121
+#define ID_LIST                         303
+#define LB_UNLISTED                     306
+#define IDD_INSERT_DISK                 1000
+#define IDD_BROWSE                      1001
+#define IDD_UPDATE                      1003
+#define IDD_RESTART                     1004
+#define IDD_EXISTS                      1005
+#define IDCB_TM_DRIVER_SETUP            1008
+#define IDCB_TM_HELP                    1009
+#define IDCB_GL_REMOVE                  1011
+#define IDCT_GL_LIST_TEXT               1017
+#define IDCB_AD_ADD                     1032
+#define IDCB_AD_BROWSE                  1033
+#define IDCH_AD_HELP                    1034
+#define psh15                           0x040e
+#define chx1                            0x0410
+#define IDCL_AD_DRIVER_LIST             1042
+#define IDCB_DS_EDIT                    1056
+#define IDCL_DS_LIST                    1057
+#define IDCB_DS_ADD                     1058
+#define IDCB_DS_REMOVE                  1059
+#define IDCB_DS_HELP                    1060
+#define IDCB_INSTALL_BROWSE             1067
+#define IDC_BUTTON2                     1068
+#define IDCB_ID_HELP                    1068
+#define IDC_EDIT1                       1069
+#define IDCE_PATHNAME                   1069
+#define IDT_DEBUG                       1070
+#define IDCB_DS_DIAL_HELPER             1071
+#define IDCB_GL_EDIT                    1083
+
+#define IDCB_DS_DIAL_PREF               1085
+#define IDCB_DS_DIAL_PREF_TEXT          1086
+#define IDCB_HAVE_DISK                  1087
+
+#define stc1                            0x0440
+#define stc2                            0x0441
+#define IDCB_GL_ADD                     1109
+#define IDCB_GL_HELP                    1112
+#define lst1                            0x0460
+#define IDCL_GL_LIST                    1121
+#define lst2                            0x0461
+#define cmb1                            0x0470
+#define cmb2                            0x0471
+#define edt1                            0x0480
+#define ctlLast                         0x04ff
+//#define IDS_NAME                        2001
+//#define IDS_NAME2                       2002
+#define IDS_NOINF                       2003
+//#define IDS_NOINF2                      2004
+#define IDS_OUTOFDISK                   2005
+//#define IDS_NOINF3                      2006
+//#define IDS_NAME3                       2007
+#define IDS_RESTARTTEXT                 2015
+//#define IDS_UPDATED                     2031
+#define IDS_UNLISTED                    2034
+#define IDS_UNABLE_TOINSTALL            2049
+#define IDS_FILEINUSEADD                2053
+#define IDS_FILEINUSEREM                2055
+//#define IDS_FILEINUSEREM2               2056
+#define IDS_DRIVER_EXISTS               2058
+#define ID_STATUS2                      4002
+#define IDS_FILENOTINDIR                0x2001
+#define IDS_DISKMSG                     0x2002
+#define IDS_FILEMSG                     0x2003
+#define IDS_DISKFILEMSG                 0x2004
+#define IDS_DISKFILEMSGSWAP             0x2005
+#define IDS_WRN_NOMULTIPLEINSTANCE      0x2006
+#define IDH_DLG_ADD_UNKNOWN             8803
+#define IDD_PATH                        0x3002
+#define IDD_TEXT                        0x3003
+#define IDD_ICON                        0x3004
+#define IDC_STATIC                      -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        122
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1072
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/cpl/sources b/private/tapi/dev/cpl/sources
new file mode 100644
index 000000000..628f1cef2
--- /dev/null
+++ b/private/tapi/dev/cpl/sources
@@ -0,0 +1,71 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=telephon
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=cpl
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\version.lib  \
+           $(BASEDIR)\public\sdk\lib\*\lz32.lib     \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=..\server;..\inc;.
+
+USE_CRTDLL=1
+
+C_DEFINES=-DWINVER=0x400
+
+SOURCES=copy.c  \
+        cpl.c   \
+        drv.c      \
+        exe.c      \
+        filecopy.c \
+        inf.c      \
+        init.c     \
+        insdisk.c  \
+        mmdriver.c \
+        util.c     \
+        debug.c    \
+        telephon.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllEntryPoint
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/cpl/sulib.h b/private/tapi/dev/cpl/sulib.h
new file mode 100644
index 000000000..84031501a
--- /dev/null
+++ b/private/tapi/dev/cpl/sulib.h
@@ -0,0 +1,454 @@
+/*
+ * SULIB.H - Windows/DOS Setup common code
+ *
+ *  Modification History:
+ *
+ *
+ *  3/23/89  Toddla   combined common.h and prototypes into this file
+ *  1/28/91  MichaelE Added AUDIO_CARDS_SECT for different audio card choices.
+ *  4/17/91  Removed some DOS.ASM routines not used anywhere.
+ *  5/29/91  JKLin added prototype for IsCDROMDrive function
+ *               
+ */
+
+#ifndef PH_SULIB
+#define PH_SULIB
+
+#define FAR_HEAP
+
+/* has windows.h been included */
+#ifndef WM_USER
+#ifdef NULL
+    #undef  NULL
+#endif
+    #define NULL                0
+    #define FALSE               0
+    #define TRUE                1
+
+    #define FAR                 far
+    #define NEAR                near
+    #define PASCAL              pascal
+    #define LONG                long
+    #define VOID                void
+
+    #define MAKELONG(a, b)      ((LONG)(((WORD)(a)) | ((DWORD)((WORD)(b))) << 16))
+    #define LOWORD(l)           ((WORD)(l))
+    #define HIWORD(l)           ((WORD)(((DWORD)(l) >> 16) & 0xFFFF))
+    #define LOBYTE(w)           ((BYTE)(w))
+    #define HIBYTE(w)           (((WORD)(w) >> 8) & 0xFF)
+
+    typedef unsigned char       BYTE;
+    typedef unsigned short      WORD;
+    typedef unsigned long       DWORD;
+    typedef int                 BOOL;
+    typedef char               *PSTR;
+    typedef char NEAR          *NPSTR;
+    typedef char FAR           *LPSTR;
+    typedef int FAR            *LPINT;
+
+    typedef WORD FAR           *LPWORD;
+
+#endif
+
+    #define FALLOC(n)                (VOID FAR *)GlobalLock(GlobalAlloc(GHND, (DWORD)(n)))
+    #define FFREE(n)                 GlobalFree((HANDLE)HIWORD((DWORD)(n)))
+
+    #define FOPEN(sz)                _lopen(sz,0 /*READ*/)
+    #define FCREATE(sz)              _lcreat(sz,0)
+    #define FCLOSE(fh)               _lclose(fh)
+    #define FREAD(fh,buf,len)        _lread(fh,buf,len)
+    #define FWRITE(fh,buf,len)       _lwrite(fh,buf,len)
+    #define FSEEK(fh,off,i)          _llseek(fh,(DWORD)off,i)
+
+    #define FERROR()                 0
+
+    #define ALLOC(n)                 (VOID NEAR *)LocalAlloc(LPTR,n)
+    #define FREE(p)                  LocalFree(p)
+    #define SIZE(p)                  LocalSize(p)
+    #define REALLOC(p,n)             LocalReAlloc(p,n,LMEM_MOVEABLE)
+
+
+/* flags for _lseek */
+#define  SEEK_CUR 1
+#define  SEEK_END 2
+#define  SEEK_SET 0
+
+#define NORMAL_5BH     0x00        // create normal file for int 21h/5bh call.
+#define ACCESS_DENIED  -2
+
+#define MAXPATHLEN           65       /* path length max + Null Byte */
+#define MAXFILESPECLEN       67       /* drive: + path length max + Null Byte */
+#define MAXCMDLINELEN        128      /* Maximum length of DOS command line */
+#define FILEMAX              14       /* 8.3 + NULL byte */
+#define MAX_INF_LINE_LEN     150      /* Maximum length of any .inf line */
+#define MAX_SYS_INF_LEN      16       /* ##: + 8.3 + NULL */
+#define MAX_PROF_LINE_LEN    15       /* Mamimum length of any profile string */
+#define MAX_ASPECT_STR_LEN   11       /* Max length of aspect ratio string */
+#define MAX_VDD_LEN          75       /* multiple vdd names, vdd,vdd,vdd ect. */
+#define MAX_SECT_NAME_LEN    20       /* Max length of a section Name. */
+#define MAX_FILE_SPEC        15       // 8.3 + X: + NULL.
+
+#define WIN386VER              "win386"         
+#define MACHINE_SECT           "machine"
+#define SYSTEM_SECT            "system"
+#define DISPLAY_SECT           "display"
+#define KEYBOARD_DRV_SECT      "keyboard.drivers"
+#define KEYTYPE_SECT           "keyboard.types"
+#define KEYBOARD_TABLES_SECT   "keyboard.tables"
+#define MOUSE_SECT             "pointing.device"
+#define DOS_MOUSE_SECT         "dos.mouse.drivers"
+#define SYSFONT_SECT           "sysfonts"
+#define OEMFONT_SECT           "oemfonts"
+#define FIXEDFON_SECT          "fixedfonts"
+#define DISK_SECT              "disks"
+#define OEMDISK_SECT           "oemdisks"
+#define USER_FONTS_SECT        "fonts"
+#define LANGUAGE_SECT          "language"
+#define NETWORK_SECT           "network"
+#define EXCLUSIONS_SECT        "exclusions"
+#define EBIOS_SECT             "ebios"
+#define AUDIO_CARDS_SECT       "Audio.Hardware"
+#define INTL_SECT              "intl"
+#define S_LANG                 "sLanguage"
+
+#define COMPATIBILITY          "compatibility"
+#define CSCALE                 "continuousscaling"
+
+#define LIM_SECT               "lim"
+#define CACHE_SECT             "diskcache"
+#define VDISK_SECT             "ramdrive"
+
+#define USADLL                 "usadll"       /* dll profile string for usa */
+#define DEFKEYDLL              "defkeydll"    /* data sectio profile string */
+#define CHDISK(n)              (char)((n) < 10 ? '0' + (char)(n) : 'A' + (char)((n) - 10))
+
+#define FILES                  "files"
+#define BUFFERS                "buffers"
+#define NUM_FILES              "= 30"
+#define EMM_SWITCH             " /e"
+#define REM                    "rem  "
+#define HIMEM                  "himem.sys"
+#define SMARTDRV               "smartdrv.sys"
+#define RAMDRIVE               "ramdrive.sys"
+#define MOUSE_SYS              "mouse.sys"
+#define EGASYS                 "ega.sys"
+#define LIMDRIVER              "emm386.sys"
+#define AUTOEXEC_BAT           "autoexec.bat"
+#define AUTOEXEC_BAK           "autoexec.old"
+#define AUTOEXEC_WIN           "autoexec.win"
+#define CONFIG_SYS             "config.sys"  /* Name of config.sys file */
+#define CONFIG_BAK             "config.old"  /* Name of config.bak file */
+#define CONFIG_WIN             "config.win"
+#define OEMINFFILE             "oemsetup.inf"
+#define SETUPEXE               "setup.exe"
+#define SETUPEXE30             "setupexe.30"
+#define SETUPINF               "setup.inf"
+#define SETUPINF30             "setupinf.30"
+#define BOOT_SECT_INI          "boot"
+#define KEYB_SECT_INI          "keyboard"
+#define SYSTEM_SECT_INI        "386enh"
+#define BOOT_DESC_INI          "boot.description"
+#define SYSTEMSRC              "system.src"
+#define PROCESSOR              "data.product"   /* used to retrieve processor =    */
+#define WIN386VER              "win386"         /* means were setting up win386    */
+#define CODEPAGES              "codepages"
+#define RAMDRIVEMIN     128
+#define SMARTDRVMIN     256
+
+/* These are the module names that can be found in the LIBRARY entry of
+   all mouse and display drivrs. */
+
+#define MOUSE_LIB                  "mouse"
+#define DISPLAY_LIB                "display"
+
+ /* These are the possible return values from fnProcessConfig or 
+    fnAutoexecProcess*/
+
+#define CONFIG_ERR             0x8000
+#define OPEN_CONFIG_ERR        (CONFIG_ERR + 2)
+#define OPEN_AUTOEXEC_ERR      (CONFIG_ERR + 3)
+#define RENAME_FAIL            (CONFIG_ERR + 4)
+#define CREATE_FAIL            (CONFIG_ERR + 5)
+#define WRITE_FAIL             (CONFIG_ERR + 6)
+#define WRITE_SUCCESS          0x0001
+#define CHECK_COMPAT_SUCCESS   0x0004
+#define RET_PRAMS_SUCCESS      0x0008
+#define SET_PRAMS_SUCCESS      0x0010
+#define CONFIG_DIRTY           0x0020      // file needs to be writen
+#define AUTOEXEC_DIRTY         0x0040      // file needs to be writen
+
+#define DO_PATH                0x0001      // bit def's to specify work
+#define DO_TEMP                0x0002      // needed to autoexec.bat file.
+#define DO_MOUSE               0x0004      // mouse driver install
+
+#define RETURN_PRAMS           0x0001
+#define SET_PRAMS              0x0002
+#define CHECK_COMPAT           0x0004
+#define WRITE_SYS              0x0008
+#define WRITE_BAK              0x0010   // Option flags for fnProcessFile
+#define WRITE_NONE             0x0020
+#define MUNGE_AUTO             0x0080
+#define ASSURE_OPEN            0x0100
+#define ASSURE_MOUSE_POSITION  0x0200
+#define MUNGE_MDK              0x0400   // option flag for mdk path/env
+
+#define NO_ACTION               -1  // Option flag defines for fnUpdateDevice
+#define REMOVE_DEVICE           -2
+#define RETURN_PRESENCE         -3
+#define REMOUT_DEVICE           -4
+#define ADD_DEVICE              -5
+#define ADD_DEVICE_FIRST   -6
+
+/* These defines are used as arguments to the fnCheckDevice call. */
+
+#define CACHE               0
+#define LIM                 1
+#define VDISK               2
+
+/* These are used as the only argument to the fnCreateFileBuffer function
+   call. They denote which buffer and file is to be created. */
+
+#define CONFIG              0x1
+#define AUTOEXEC            0x2
+
+#define REMOTE              0x3      /* Return value from DosIsRemote */
+
+/* Used in the fnCopyBuf call to specify the copying of the remainder on
+   the from buffer. */
+
+#define CNT_Z        0x1A
+
+/* Used as an argument in function call fnCheckDevice(); */
+
+#define NO_REMOVE        FALSE
+#define YES_REMOVE       TRUE
+
+#define REMAINDER           0xffff  // Used to copy remainder of buffer.
+
+#define ISEOF(c)     ((c) == '\0' || (c) == CNT_Z)
+#define ISSEP(c)     ((c) == '='  || (c) == ',')
+#define ISWHITE(c)   ((c) == ' '  || (c) == '\t' || (c) == '\n' || (c) == '\r')
+#define ISFILL(c)    ((c) == ' '  || (c) == '\t')
+#define ISEOL(c)     ((c) == '\n' || (c) == '\r' || (c) == '\0' || (c) == CNT_Z)
+#define ISCRLF(c)    ((c) == '\n' || (c) == '\r')
+#define ISNOISE(c)   ((c) == '"')
+#define ISDIGIT(c)   ((c) >= '0' && (c) <= '9')
+#define ISHEX(c)     (ISDIGIT(c) || ISCHAR(c))
+#define ISCHAR(c)    (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+#define SLASH(c)     ((c) == '/' || (c) == '\\')
+#define DEVICESEP(c) ((c) == '/' || (c) == '\\' || (c) == '=' || (c) == ' ' || (c) == '\t')
+//#define UP_CASE(c)   ((c) | 0x20)  // this is lower case !
+#define UPCASE(c)    (((c) >= 'a' && (c) <= 'z') ? ((c) & 0xdf) : (c))
+#define HEXVAL(c)    (ISDIGIT(c) ? (c) - '0' : UP_CASE(c) - 'a' + 10)
+
+#define CHSEPSTR                "\\"
+#define EQUAL                   '='
+#define SPACE                   ' '
+#define LF                      0x0A
+#define CR                      0x0D
+
+/*
+ *  directory where MDK Tools executables, Include and Lib files are installed
+ */
+//extern char szMDKPath[MAXPATHLEN];
+//extern char szMDKIncludePath[MAXPATHLEN];
+//extern char szMDKLibPath[MAXPATHLEN];
+
+typedef LPSTR    PINF;
+
+extern PINF FAR PASCAL infOpen(LPSTR szInf);
+extern void FAR PASCAL infClose(PINF pinf);
+extern PINF FAR PASCAL infSetDefault(PINF pinf);
+extern PINF FAR PASCAL infFindSection(PINF pinf, LPSTR szSection);
+extern BOOL FAR PASCAL infGetProfileString(PINF pinf, LPSTR szSection, LPSTR szItem,LPSTR szBuf);
+extern BOOL FAR PASCAL infParseField(PINF szData, int n, LPSTR szBuf);
+extern PINF FAR PASCAL infNextLine(PINF pinf);
+extern int  FAR PASCAL infLineCount(PINF pinf);
+extern BOOL FAR PASCAL infLookup(LPSTR szInf, LPSTR szBuf);
+
+/* TYPEDEFS - copy.c */
+typedef BOOL (FAR PASCAL    *FPFNCOPY) (int,int,LPSTR);
+#define COPY_ERROR          0x0001
+#define COPY_STATUS         0x0002
+#define COPY_INSERTDISK     0x0003
+#define COPY_QUERYCOPY      0x0004
+#define COPY_START          0x0005
+#define COPY_END            0x0006
+#define COPY_EXISTS         0x0007
+
+extern WORD FAR PASCAL FileCopy (LPSTR szSource, LPSTR szDir, FPFNCOPY fpfnCopy, WORD fCopy);
+
+#define FC_FILE              0x0000
+#define FC_LIST              0x0001
+#define FC_SECTION           0x0002
+#define FC_QUALIFIED         0x0008
+#define FC_DEST_QUALIFIED    0x0010
+#define FC_LISTTYPE          0x0020
+#define FC_CALLBACK_WITH_VER 0x0040
+
+#define FC_ABORT    0
+#define FC_IGNORE   1
+#define FC_RETRY    2
+#define FC_ERROR_LOADED_DRIVER  0x80
+/* External functions from copy.c */
+
+extern void FAR PASCAL fartonear(LPSTR dst, LPSTR src);
+extern BOOL FAR PASCAL ExpandFileName(LPSTR szFile, LPSTR szPath);
+extern int  FAR PASCAL DosCopy(LPSTR szFile, LPSTR szPath);
+extern void FAR PASCAL catpath(LPSTR path, LPSTR sz);
+extern BOOL FAR PASCAL fnFindFile(char *);
+extern LPSTR FAR PASCAL FileName(LPSTR szPath);
+extern LPSTR FAR PASCAL StripPathName(LPSTR szPath);
+
+/* TYPEDEFS - dos.asm */
+
+extern int FAR PASCAL fnCarefullyOpenNewFile(LPSTR sz,BYTE Attr);
+
+#define ATTR_READONLY   0x0001
+#define ATTR_HIDDEN     0x0002
+#define ATTR_SYSTEM     0x0004
+#define ATTR_VOLUME     0x0008
+#define ATTR_DIR        0x0010
+#define ATTR_ARCHIVE    0x0020
+#define ATTR_FILES      (ATTR_READONLY+ATTR_SYSTEM)
+#define ATTR_ALL_FILES  (ATTR_READONLY+ATTR_SYSTEM+ATTR_HIDDEN)
+#define ATTR_ALL        (ATTR_READONLY+ATTR_DIR+ATTR_HIDDEN+ATTR_SYSTEM)
+
+typedef struct {
+    char        Reserved[21];
+    BYTE        Attr;
+    WORD        Time;
+    WORD        Date;
+    DWORD       Length;
+    char        szName[13];
+}   FCB;
+
+typedef FCB     * PFCB;
+typedef FCB FAR * LPFCB;
+
+/* functions from dos.asm */
+
+extern BOOL  FAR PASCAL IsCDROMDrive (int iDrive);
+extern int   FAR PASCAL fnCarefullyOpenNewFile(LPSTR sz,BYTE Attr);
+extern int   FAR PASCAL DosFindFirst (LPFCB lpfcb, LPSTR szFileSpec, WORD attr);
+extern int   FAR PASCAL DosFindNext  (LPFCB lpfcb);
+extern int   FAR PASCAL GetCurrentDrive (void);
+extern int   FAR PASCAL SetCurrentDrive (int iDrive);
+extern LONG  FAR PASCAL DosDiskFreeSpace(int iDrive);
+extern int   FAR PASCAL DosCwd   (LPSTR szDir);
+extern int   FAR PASCAL DosChDir (LPSTR szDir);
+extern int   FAR PASCAL DosMkDir (LPSTR szDir);
+extern int   FAR PASCAL DosValidDir (LPSTR szDir);
+extern int   FAR PASCAL GetFixedDisks(int * rgiDrive);
+extern int   FAR PASCAL DosRemoveable(int iDisk);
+extern int   FAR PASCAL DosIsRemote(int);
+extern int   FAR PASCAL MyReadWriteSector(void far *, int, int, int, int, int);
+extern int   FAR PASCAL DosRename(LPSTR, LPSTR);
+extern int   FAR PASCAL DosDelete(LPSTR);
+extern WORD  FAR PASCAL DosVersion(void);
+extern void  FAR PASCAL DosExit(WORD);
+extern LPSTR FAR PASCAL DosGetEnv(void);
+extern DWORD FAR PASCAL XmsVersion(void);
+extern BOOL  FAR PASCAL XmsInstalled(void);
+extern void  FAR PASCAL Reboot(void);
+extern int   FAR PASCAL GetCodePage(void);
+extern WORD  FAR PASCAL get_ext(void);
+extern void  FAR PASCAL fnGetFilePath(char*, char*);
+#if 0
+extern LONG  FAR PASCAL MyGetFileAttributes(LPSTR szBuf);
+#endif
+
+extern unsigned FAR PASCAL fnGetSmartDrvVersion(void);
+extern BOOL     FAR PASCAL fnGetRamDriveVersion(LPSTR szVerString);
+
+/* External functions from exe.c */
+
+extern BOOL FAR PASCAL GetExeInfo(LPSTR szFile, VOID *pBuf, int nBuf, WORD fInfo);
+//#define GEI_MODNAME         0x01
+#define GEI_DESCRIPTION     0x02
+//#define GEI_FLAGS           0x03
+//#define GEI_EXEHDR          0x04
+//#define GEI_FAPI            0x05
+
+#ifdef DOSONLY
+extern int   FAR PASCAL lstrlen(LPSTR lpsz);
+extern LPSTR FAR PASCAL lstrcat(LPSTR lpszFirst, LPSTR lpszSecond);
+extern int   FAR PASCAL lstrcmpi(LPSTR lpStr1, LPSTR lpStr2);
+extern LPSTR FAR PASCAL lstrcpy(LPSTR lpszDest, LPSTR lpszSource);
+extern int   FAR PASCAL lstrcmp(LPSTR lpszFirst, LPSTR lpszSecond);
+#endif
+
+/* DOS ERROR CODES */
+
+#define ERROR_OK            0x00
+#define ERROR_FILENOTFOUND  0x02    /* File not found */
+#define ERROR_PATHNOTFOUND  0x03    /* Path not found */
+#define ERROR_NOFILEHANDLES 0x04    /* Too many open files */
+#define ERROR_ACCESSDENIED  0x05    /* Access denied */
+#define ERROR_INVALIDHANDLE 0x06    /* Handle invalid */
+#define ERROR_FCBNUKED      0x07    /* Memory control blocks destroyed */
+#define ERROR_NOMEMORY      0x08    /* Insufficient memory */
+#define ERROR_FCBINVALID    0x09    /* Memory block address invalid */
+#define ERROR_ENVINVALID    0x0A    /* Environment invalid */
+#define ERROR_FORMATBAD     0x0B    /* Format invalid */
+#define ERROR_ACCESSCODEBAD 0x0C    /* Access code invalid */
+#define ERROR_DATAINVALID   0x0D    /* Data invalid */
+#define ERROR_UNKNOWNUNIT   0x0E    /* Unknown unit */
+#define ERROR_DISKINVALID   0x0F    /* Disk drive invalid */
+#define ERROR_RMCHDIR       0x10    /* Attempted to remove current directory */
+#define ERROR_NOSAMEDEV     0x11    /* Not same device */
+#define ERROR_NOFILES       0x12    /* No more files */
+#define ERROR_13            0x13    /* Write-protected disk */
+#define ERROR_14            0x14    /* Unknown unit */
+#define ERROR_15            0x15    /* Drive not ready */
+#define ERROR_16            0x16    /* Unknown command */
+#define ERROR_17            0x17    /* Data error (CRC) */
+#define ERROR_18            0x18    /* Bad request-structure length */
+#define ERROR_19            0x19    /* Seek error */
+#define ERROR_1A            0x1A    /* Unknown media type */
+#define ERROR_1B            0x1B    /* Sector not found */
+#define ERROR_WRITE         0x1D    /* Write fault */
+#define ERROR_1C            0x1C    /* Printer out of paper */
+#define ERROR_READ          0x1E    /* Read fault */
+#define ERROR_1F            0x1F    /* General failure */
+#define ERROR_SHARE         0x20    /* Sharing violation */
+#define ERROR_21            0x21    /* File-lock violation */
+#define ERROR_22            0x22    /* Disk change invalid */
+#define ERROR_23            0x23    /* FCB unavailable */
+#define ERROR_24            0x24    /* Sharing buffer exceeded */
+#define ERROR_32            0x32    /* Unsupported network request */
+#define ERROR_33            0x33    /* Remote machine not listening */
+#define ERROR_34            0x34    /* Duplicate name on network */
+#define ERROR_35            0x35    /* Network name not found */
+#define ERROR_36            0x36    /* Network busy */
+#define ERROR_37            0x37    /* Device no longer exists on network */
+#define ERROR_38            0x38    /* NetBIOS command limit exceeded */
+#define ERROR_39            0x39    /* Error in network adapter hardware */
+#define ERROR_3A            0x3A    /* Incorrect response from network */
+#define ERROR_3B            0x3B    /* Unexpected network error */
+#define ERROR_3C            0x3C    /* Remote adapter incompatible */
+#define ERROR_3D            0x3D    /* Print queue full */
+#define ERROR_3E            0x3E    /* Not enough room for print file */
+#define ERROR_3F            0x3F    /* Print file was deleted */
+#define ERROR_40            0x40    /* Network name deleted */
+#define ERROR_41            0x41    /* Network access denied */
+#define ERROR_42            0x42    /* Incorrect network device type */
+#define ERROR_43            0x43    /* Network name not found */
+#define ERROR_44            0x44    /* Network name limit exceeded */
+#define ERROR_45            0x45    /* NetBIOS session limit exceeded */
+#define ERROR_46            0x46    /* Temporary pause */
+#define ERROR_47            0x47    /* Network request not accepted */
+#define ERROR_48            0x48    /* Print or disk redirection paused */
+#define ERROR_50            0x50    /* File already exists */
+#define ERROR_51            0x51    /* Reserved */
+#define ERROR_52            0x52    /* Cannot make directory */
+#define ERROR_53            0x53    /* Fail on Int 24H (critical error) */
+#define ERROR_54            0x54    /* Too many redirections */
+#define ERROR_55            0x55    /* Duplicate redirection */
+#define ERROR_56            0x56    /* Invalid password */
+#define ERROR_57            0x57    /* Invalid parameter */
+#define ERROR_58            0x58    /* Net write fault */
+#define ERROR_DISKFULL	    0x100   /* Disk Full */
+
+// External Variables in EXTERNS.H
+#endif // PH_SULIB
diff --git a/private/tapi/dev/cpl/tapicpl.h b/private/tapi/dev/cpl/tapicpl.h
new file mode 100644
index 000000000..62ae48cd6
--- /dev/null
+++ b/private/tapi/dev/cpl/tapicpl.h
@@ -0,0 +1,166 @@
+/*--------------------------------------------------------------------------*\
+   Include File:  cpl.h
+
+   Master include file for the Telephony Control Panel Applet
+      
+\*--------------------------------------------------------------------------*/
+
+#ifndef  PH_CPL
+#define  PH_CPL
+                                                                             
+/* turn off some compiler warnings */
+#pragma warning (disable : 4101 4100 4001)
+
+#include  "help.h"      // implict include, moved to possibly avoid conflicts
+#include  "inf.h"       // definition of PINF
+
+//----------
+// Constants
+//----------
+#define  CPL_NUM_APPLETS            1
+
+#define  CPL_MAX_TITLE              32       // applet name in control panel
+#define  CPL_MAX_STATUS_LINE        64       // control panel status line for applet
+#define  CPL_MAX_HELP_FILE          128      // help file name for cpl
+
+#define  CPL_HELP_CONTEXT           500      // help context location - define!!
+
+#define  CPL_MAX_STRING             132      // biggest allowed string
+#define  CPL_MAX_NUM                32       // max lenght for a number
+#define  CPL_MAX_PATH               256      // biggest allowed string
+#define  CPL_MAX_INI_STR            256      // biggest allowed string
+#define  CPL_MAX_INF_LINE_LEN       150      // max length of any single INF line
+#define  CPL_MAX_SYS_INF_LEN        16       // ##: + 8.3 + NULL
+#define  CPL_MAX_VDD_LEN            75       // Maximum length of VxD line in oemsetup.inf
+#define  CPL_MAX_FILE_SPEC          15       // 8.3 + X: + NULL
+
+#define  CPL_HEAP_SIZE              512      // default local heap size
+
+#define  CPL_LIST_NO_CHANGE         0
+#define  CPL_LIST_MODIFIED          1
+
+#define  CPL_ENTRY_NO_CHANGE        0
+#define  CPL_ENTRY_ADDED            1
+#define  CPL_ENTRY_MODIFIED         2
+#define  CPL_ENTRY_DELETED          3
+
+#define  CPL_SYSTEM_SECT_INI        "386enh"  // System section for VxD's
+//-------
+// Errors
+//-------
+#define  CPL_SUCCESS                 0
+#define  CPL_FAILURE                 2
+#define  CPL_IGNORE                  3        // error that is just ignored
+#define  CPL_APP_ERROR               100
+#define  CPL_ERR_MEMORY              101
+#define  CPL_ERR_DIALOG_BOX          102
+#define  CPL_ERR_LOAD_STRING         103
+#define  CPL_ERR_DLLINIT             104
+#define  CPL_ERR_ALREADY_IN_LIST     105
+#define  CPL_ERR_INVAILD_ARG         106
+#define  CPL_NO_DRIVER               107
+#define  CPL_BAD_DRIVER              108
+#define  CPL_DRIVER_FAILED           109
+#define  CPL_ERR_MULTIPLE_INST       110
+#define  CPL_ERR_ALREADY_INITIALIZED 111      // ONECPL:  Only one instance allowed.
+#define  CPL_ERR_TAPI_FAILURE        112
+#define  CPL_ERR_TAPI_NOMULTIPLEINSTANCE  113
+
+#define  CPL_WRN_INVAILD_STR         201
+#define  CPL_WRN_INVAILD_NUM_STR     202
+#define  CPL_WRN_INVAILD_EX_NUM_STR  203
+#define  CPL_WRN_INVAILD_NUM         204
+#define  CPL_WRN_AREA_CODE_REQUIRED  206
+
+//------
+// Types
+//------
+
+typedef UINT FAR*     LPUINT;
+
+#ifdef _WIN32
+
+#define  PRIVATE
+#define  PUBLIC 
+#define  EXPORT      CALLBACK
+#define  SEG_DRV
+#define  SEG_CRD
+#define  SEG_LOC
+#define  SEG_CPL
+#define  SEG_INI
+#define  SEG_CNTRY
+#define  SEG_UTIL
+#define  SEG_MMD
+
+#else
+
+#define  PRIVATE     NEAR PASCAL          // function type
+#define  PUBLIC      FAR PASCAL           // function type
+#define  EXPORT      FAR PASCAL __export  // function type
+#define  SEG_DRV   __based(__segname("DRIVERS"))      // segment
+#define  SEG_CPL   __based(__segname("CPL_MAIN"))     // segment
+#define  SEG_UTIL  __based(__segname("UTILITY"))      // segment
+#define  SEG_MMD   __based(__segname("MMDRIVER"))     // segment
+
+//-----------------
+// Message Crackers
+//-----------------
+// These message crackers weren't in windowsx.h for win3.1
+//#define  GET_WM_COMMAND_ID(wParam, lParam)  wParam
+//#define  GET_WM_COMMAND_HWND(wParam, lParam)  LOWORD(lParam) 
+//#define  GET_WM_COMMAND_CMD(wParam, lParam)  HIWORD(lParam)
+#endif
+            
+//----------------------------
+// TELEAPP:
+//    info about each applet
+//----------------------------
+typedef struct tagTELEAPP
+   {
+   HICON hIcon;            // kept so it can be deleted at the right time
+   UINT  uIconResId;
+   UINT  uNameResId;       // title, max leng 32
+   UINT  uStatusLineResId; // max leng 64
+   UINT  uHelpFileResId;   // max leng 128
+   DWORD dwHelpContext;    // help context to use
+   LONG  lPrivateData;
+   
+   UINT  uDialogResId;     // dialog box
+   DLGPROC  dlgprcDialog;  // dialog function
+
+   }  TELEAPP, *PTELEAPP,  FAR *LPTELEAPP;
+
+
+//-------------------------------
+// CPL:
+//    global status for the dll
+//-------------------------------
+typedef struct tagCPL
+   {
+   HINSTANCE   hCplInst;      // dll instance handle
+   HWND        hWnd;          // ONECPL:  handle of parent window
+   UINT        uInstances;    // num apps using it
+   HINSTANCE   hCtl3DInst;    // dyno link for 3d effects
+   UINT        uCplApplets;   // num of valid applets
+   TELEAPP     taTeleApplet[CPL_NUM_APPLETS]; // data for each applet
+   PINF        pInfOldDefault;  // Old default inf file
+   UINT        uHelpMsg;      // For "ShellHelp" message from windows
+   }  CPL,   *PCPL, FAR *LPCPL;
+   
+
+//--------------------
+// Function Prototypes
+//--------------------
+LONG EXPORT     CPlApplet( HWND hWndCpl, UINT uMessage, LPARAM lParam1, LPARAM lParam2 );
+UINT EXPORT     CplFixIni( HWND hWnd, UINT uSection, BOOL fShowErrors );
+//extern VOID FAR PASCAL CplSysColorChange();
+UINT PUBLIC     CplClose( UINT uCommand );
+
+//UINT EXPORT  CplEditLocation( HWND hWnd, LPSTR lpszLocation, BOOL fShowErrors );
+//UINT EXPORT  CplEditCard( HWND hWnd, LPSTR lpszCard, BOOL fShowErrors );
+//BOOL EXPORT  CplDlg( HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam );
+
+#define  CplIsDigit( ch )                                            \
+   (((ch) >= '0') && ((ch) <= '9'))                                   
+   
+#endif   // PH_CPL
diff --git a/private/tapi/dev/cpl/telephon.def b/private/tapi/dev/cpl/telephon.def
new file mode 100644
index 000000000..0c8bb8b52
--- /dev/null
+++ b/private/tapi/dev/cpl/telephon.def
@@ -0,0 +1,14 @@
+LIBRARY   TELEPHON
+CODE      PRELOAD MOVEABLE DISCARDABLE
+DATA      PRELOAD MOVEABLE SINGLE
+HEAPSIZE  512
+EXPORTS   
+          CPlApplet        @1
+          
+          FDlgDriverList
+          FDlgAddDriver
+          FDlgAddUnlisted
+          
+          wsExistDlg
+          InsertDiskDlg
+          BrowseHookProc
diff --git a/private/tapi/dev/cpl/telephon.ico b/private/tapi/dev/cpl/telephon.ico
new file mode 100644
index 000000000..003323ef6
--- /dev/null
+++ b/private/tapi/dev/cpl/telephon.ico
diff --git a/private/tapi/dev/cpl/telephon.rc b/private/tapi/dev/cpl/telephon.rc
new file mode 100644
index 000000000..9e5e38bcf
--- /dev/null
+++ b/private/tapi/dev/cpl/telephon.rc
@@ -0,0 +1,275 @@
+//Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include  <windows.h>
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+//IDD_GENERIC_LIST DIALOG DISCARDABLE  20, 15, 222, 109
+//STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+//FONT 8, "MS Shell Dlg"
+//BEGIN
+//    LTEXT           "",IDCT_GL_LIST_TEXT,7,7,140,10
+//    LISTBOX         IDCL_GL_LIST,7,19,150,82,LBS_SORT | WS_VSCROLL | 
+//                    WS_TABSTOP
+//    PUSHBUTTON      "Cancel",IDOK,164,72,50,14
+//    PUSHBUTTON      "&Add...",IDCB_GL_ADD,164,19,50,14
+//    DEFPUSHBUTTON   "&Edit...",IDCB_GL_EDIT,164,55,50,14
+//    PUSHBUTTON      "&Remove",IDCB_GL_REMOVE,164,37,50,14
+//END
+
+IDD_ADD_DRIVER DIALOG DISCARDABLE  20, 15, 222, 105
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU 
+CAPTION "Add Driver"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Telephony drivers:",IDC_STATIC,7,7,144,10
+    LISTBOX         IDCL_AD_DRIVER_LIST,7,18,150,60,LBS_SORT | WS_VSCROLL | 
+                    WS_TABSTOP | LBS_NOTIFY
+    DEFPUSHBUTTON   "Cancel",IDCANCEL,164,36,50,14
+    PUSHBUTTON      "&Add...",IDCB_AD_ADD,164,18,50,14
+
+    PUSHBUTTON      "&Have Disk...",IDCB_HAVE_DISK,107,72,50,14
+END
+
+IDD_DRIVER_SETUP DIALOG DISCARDABLE  20, 15, 257, 188
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Telephony Drivers"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    ICON            IDI_TELEPHONY,IDC_STATIC,7,7,18,20
+    LTEXT           "&The following telephony drivers are installed",
+                    IDC_STATIC,40,7,152,8
+    LTEXT           "on this computer:",IDC_STATIC,40,16,80,8
+    LISTBOX         IDCL_DS_LIST,7,40,203,53,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    WS_VSCROLL | WS_TABSTOP
+    PUSHBUTTON      "&Add...",IDCB_DS_ADD,7,98,65,14
+    PUSHBUTTON      "&Remove",IDCB_DS_REMOVE,76,98,65,14
+    DEFPUSHBUTTON   "&Configure...",IDCB_DS_EDIT,145,98,65,14
+//    PUSHBUTTON      "&Dialing Properties...",IDCB_DS_DIAL_HELPER,111,158,90,
+//                    14
+//    GROUPBOX        "Dialing Preferences",IDCB_DS_DIAL_PREF,7,123,203,58
+//    LTEXT           "Use Dialing Properties to modify how your calls are dialed.",
+//                    IDCB_DS_DIAL_PREF_TEXT,20,138,154,16
+END
+
+IDD_BROWSE DIALOG DISCARDABLE  46, 21, 190, 172
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_CAPTION | WS_SYSMENU
+CAPTION "Browse"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&Directories:",-1,7,37,92,9,NOT WS_GROUP
+    LTEXT           "",stc1,7,48,145,9,NOT WS_GROUP
+    LISTBOX         lst2,7,61,118,72,LBS_SORT | LBS_OWNERDRAWFIXED | 
+                    LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Dri&ves:",-1,7,140,92,9,NOT WS_GROUP
+    COMBOBOX        cmb2,7,150,118,68,CBS_DROPDOWNLIST | CBS_OWNERDRAWFIXED | 
+                    CBS_AUTOHSCROLL | CBS_SORT | CBS_HASSTRINGS | WS_BORDER | 
+                    WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,132,61,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,132,79,50,14,WS_GROUP
+    EDITTEXT        edt1,-100,-100,10,10,ES_LOWERCASE | ES_AUTOHSCROLL | NOT 
+                    WS_TABSTOP
+    LISTBOX         lst1,-100,-100,10,10,LBS_EXTENDEDSEL
+    CONTROL         "",chx1,"Button",BS_AUTOCHECKBOX,-100,-100,10,10
+    LTEXT           "",stc2,-100,-100,10,10,SS_NOPREFIX
+    COMBOBOX        cmb1,-100,-100,10,10,CBS_DROPDOWNLIST | CBS_AUTOHSCROLL | 
+                    WS_BORDER | WS_VSCROLL
+    LTEXT           "Select the drive and directory of the files you are installing, and then press OK",
+                    1280,7,7,173,20,SS_NOPREFIX
+    LTEXT           "",1282,-100,-100,50,12,SS_NOPREFIX
+END
+
+IDD_INSERT_DISK DIALOG DISCARDABLE  54, 36, 250, 98
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Insert Disk"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "",IDD_TEXT,40,7,142,60,SS_NOPREFIX
+    EDITTEXT        IDD_PATH,40,76,142,14,ES_AUTOHSCROLL | ES_OEMCONVERT
+    DEFPUSHBUTTON   "OK",IDOK,192,7,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,192,25,50,14,WS_GROUP
+    PUSHBUTTON      "&Browse...",IDD_BROWSE,192,43,50,14,WS_GROUP
+    ICON            100,IDD_ICON,7,7,18,20
+END
+
+IDD_UPDATE DIALOG DISCARDABLE  54, 36, 222, 93
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Add Unlisted or Updated Driver"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "&List of drivers:",ID_LIST,7,7,124,8
+    LISTBOX         LB_UNLISTED,7,18,150,68,LBS_SORT | LBS_MULTIPLESEL | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,164,18,50,14,WS_GROUP
+    PUSHBUTTON      "Cancel",IDCANCEL,164,35,50,14
+END
+
+IDD_EXISTS DIALOG DISCARDABLE  8, 12, 222, 74
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Driver Exists"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    ICON            32515,-1,7,7,18,20
+    LTEXT           "",ID_STATUS2,40,7,174,35
+    DEFPUSHBUTTON   "&New",ID_NEW,40,53,55,14,WS_GROUP
+    PUSHBUTTON      "Cu&rrent",ID_CURRENT,99,53,55,14
+    PUSHBUTTON      "Cancel",IDCANCEL,159,53,55,14
+END
+
+IDD_RESTART DIALOG DISCARDABLE  10, 10, 220, 68
+STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "System Setting Change"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Your driver settings have changed. Quit and restart Windows so that the new settings can take effect.",
+                    IDS_RESTARTTEXT,40,7,170,30
+    DEFPUSHBUTTON   "&Restart Now",IDOK,129,47,83,14,WS_GROUP
+    PUSHBUTTON      "&Don't Restart Now",IDCANCEL,40,47,83,14
+    ICON            32515,-1,7,7,18,20
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include  <windows.h>\r\n"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include  ""telephon.rcv""\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+#if WINNT
+IDI_TELEPHONY           ICON    DISCARDABLE     "..\\cpl\\TELEPHON.ICO"
+#else
+IDI_TELEPHONY           ICON    DISCARDABLE     "..\\..\\cpl\\TELEPHON.ICO"
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_TITLE               "Telephony"
+    IDS_STATUS_LINE         "Set up Telephony drivers and dialing options"
+    IDS_ERR_TAPI            "The telephony system cannot perform that function at this time.  Please try again later."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_DIALOG_TITLE        "Telephony"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_ERR_APPLICATION     "Internal error.\nQuit and restart the application."
+    IDS_ERR_MEMORY          "There is not enough memory.\nQuit some programs, and then try again."
+    IDS_ERR_ALREADY_IN_LIST "The name you have entered matches another name already in use.\nRe-enter a unique value."
+    IDS_WRN_INVAILD_STR     "No special characters or quotes are allowed for the text input.\nType the text again."
+    IDS_WRN_INVAILD_EX_NUM_STR 
+                            "Invalid character; characters must be 0 thru 9, A thru H, P, T, W, #, *, !, ,, @, $ or the ? symbol.\nType the information again."
+    IDS_WRN_INVAILD_NUM     "Invalid number; numbers must only contain digits from 0 thru 9.\nType the information again."
+//    IDS_ERR_INVALID_TAPIADDR 
+//                            "The file TAPIADDR.DLL is either an incorrect version or corrupt.\nReinstall this file."
+    IDS_DT_DS_NO_DRIVER     "<no service provider is installed>"
+    IDS_ERR_NO_DRIVER       "A required component of the selected driver is missing.\nReinstall the driver using the New Device control panel."
+    IDS_ERR_BAD_DRIVER      "The driver is corrupt or is the incorrect version, and cannot be configured.\nReinstall the driver using the New Device control panel."
+//    IDS_NONE                "<None>"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_DRIVER_REMOVE_OR_STUPID 
+                            "Are you sure you want to remove the selected Telephony Service Provider?"
+    IDS_WRN_INVAILD_NUM_STR "Invalid character. Characters must be 0 thru 9, A thru D, P, T, W, #, *, !, ,, @, $ or the ? symbol.\nType the character again."
+    IDS_WRN_DRIVER_IN_USE   "Removing the service provider without first closing all Windows Telephony applications could cause your computer to become unstable. Do you want to remove it anyway?"
+    IDS_WRN_NOMULTIPLEINSTANCE "This service provider is already installed and cannot be installed again."
+    IDS_ERR_DRIVER_FAILED   "The service provider was unable to perform this operation.\nTry again."
+    IDS_ERR_MULTIPLE_INST   "The Telephony service provider you have selected (or one with the same name) is already installed in the system, and it cannot support multiple instances."
+END
+
+//STRINGTABLE DISCARDABLE 
+//BEGIN
+//    IDS_UPDATED             "Unlisted or Updated Driver"
+//END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_UNLISTED            "the unlisted, updated, or vendor-provided disk"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_FILENOTINDIR        "The file '%s' does not exist in this folder."
+    IDS_DISKMSG             "Insert %s.\r\rIf the files on this disk can be found at a different location, for example, on another drive, type a new path to the file below."
+    IDS_FILEMSG             "Insert the disk with the file %s.\r\rIf this file can be found at a different location, for example, on another drive, type a new path to the file below."
+    IDS_DISKFILEMSG         "Insert %s with the file %s.\r\rIf this file can be found at a different location type a new path to the file below."
+    IDS_DISKFILEMSGSWAP     "0"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_UNABLE_TOINSTALL    "Unable to install the driver file. There may be a problem with your computer.\nQuit and restart Windows, and then try again. If you stil can't install, contact your driver vendor."
+    IDS_FILEINUSEADD        "The old driver is still being used by Windows.\nQuit and restart Windows, and then add the updated driver."
+    IDS_FILEINUSEREM        "You cannot update to a new driver until you remove the old one.\nUse the System control panel to remove the old driver, and then quit and restart Windows. Try again."
+//    IDS_FILEINUSEREM2       "You cannot update to a new driver until you remove the old one.\nUse the System control panel to remove the old driver, and then quit and restart Windows. Try again."
+    IDS_DRIVER_EXISTS       "The required %s driver is already on the system. Do you want to use the current driver or install a new driver?"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+//    IDS_NAME                "D&rivers"
+//    IDS_NAME2               "D&rivers"
+    IDS_NOINF               "Cannot find the SETUP.INF file needed to install drivers. The file may be damaged or may not be in your Windows SYSTEM folder.\nCopy the original file on Windows Disk 1 to your SYSTEM folder."
+//    IDS_NOINF2              "Cannot find the SETUP.INF file needed to install drivers. The file may be damaged or may not be in your Windows SYSTEM folder.\nCopy the original file on Windows Disk 1 to your SYSTEM folder."
+    IDS_OUTOFDISK           "There isn't enough disk space to copy the driver file.\nClose the Drivers dialog box, delete one or more files, and then try again."
+//    IDS_NOINF3              "Cannot find the SETUP.INF file needed to install drivers. The file may be damaged or may not be in your Windows SYSTEM folder.\nCopy the original file on Windows Disk 1 to your SYSTEM folder."
+//    IDS_NAME3               "D&rivers"
+END
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+//#include  "telephon.rcv"
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/private/tapi/dev/cpl/telephon.rcv b/private/tapi/dev/cpl/telephon.rcv
new file mode 100644
index 000000000..0bbf445ce
--- /dev/null
+++ b/private/tapi/dev/cpl/telephon.rcv
@@ -0,0 +1,25 @@
+#include "windows.h"
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
+// Is the following FLAG good to use for this?
+#ifdef NT_INST
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony Control Panel"
+#define VER_INTERNALNAME_STR        "telephon.cpl"
+#define VER_ORIGINALFILENAME_STR    "TELEPHON.CPL"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
diff --git a/private/tapi/dev/cpl/util.c b/private/tapi/dev/cpl/util.c
new file mode 100644
index 000000000..178572be1
--- /dev/null
+++ b/private/tapi/dev/cpl/util.c
@@ -0,0 +1,522 @@
+/*--------------------------------------------------------------------------*\
+   Module:     util.c
+   
+   Purpose: Utility functions, such as loading strings, error reporting
+            and ini file handling...
+   
+   History:
+      7/25/93 CBB - Created
+\*--------------------------------------------------------------------------*/
+
+#include  <windows.h>
+#include  "tapicpl.h"        
+#include  "resource.h"
+#include  "util.h"         
+                  
+#include  <tapi.h>                  
+
+//-------------
+// private data
+//-------------
+
+// the following are not to be translated, so they can be static
+
+#ifndef _WIN32
+#pragma code_seg ( "UTILITY" )
+#endif // _WIN32
+
+//char SEG_UTIL gszHelpFile[] = "telephon.hlp";
+char SEG_UTIL gszHelpFile[] = "Windows.hlp";
+
+//--------------------
+// Function Prototypes
+//--------------------
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   LpszGetString
+   
+   Purpose: Load a resource string
+   
+\*--------------------------------------------------------------------------*/
+LPSTR PUBLIC   LpszGetStr( LPSTR  lpszNewString, // optional
+                           UINT   wStrResId,
+                           UINT   wMaxLeng )     // optional
+               
+   {
+   extern CPL  gCPL;       // app global
+   static char gszUtilString[CPL_MAX_INI_STR];   // function global
+   
+   if ( !LoadString( gCPL.hCplInst, wStrResId, 
+                     lpszNewString ? lpszNewString : gszUtilString,
+                     wMaxLeng ? wMaxLeng : CPL_MAX_INI_STR - 1 ))
+      {
+      // This can cause an infinite loop!
+//      FErrorRpt( NULL, CPL_ERR_LOAD_STRING );
+		DBG_ASSERT( FALSE, "Cannot Load String!" );
+		
+      if ( lpszNewString )
+         lpszNewString[0] = 0;
+      return( NULL );
+      }  // end if                 
+   
+   return( lpszNewString ? lpszNewString : gszUtilString );
+   }  // end LpszGetString
+   
+                  
+/*--------------------------------------------------------------------------*\
+
+   Function:   FErrorRpt
+   
+   Purpose:    Complain about an error found in the app.  Hack return TRUE
+               if it's a bad error and blow out of dlgs, if FALSE can stay
+               in the dialog
+   
+\*--------------------------------------------------------------------------*/
+BOOL PUBLIC FErrorRpt( HWND   hWnd, 
+                          UINT   wErrorId )
+
+   {
+   UINT  wStrID;
+   BOOL  fClose;
+   
+   fClose = FALSE;      // default is to not close calling dialog
+   
+   switch ( wErrorId )
+      {
+      case  CPL_SUCCESS:
+      case  CPL_FAILURE:       
+      case  CPL_APP_ERROR:
+      case  CPL_ERR_DIALOG_BOX:
+      case  CPL_ERR_LOAD_STRING:
+      case  CPL_ERR_DLLINIT:
+      case  CPL_ERR_INVAILD_ARG:
+      default:
+         fClose = TRUE;
+         wStrID = IDS_ERR_APPLICATION;
+         break;
+      case  CPL_ERR_TAPI_FAILURE:
+      	wStrID = IDS_ERR_TAPI;
+      	break;
+      case  CPL_ERR_MULTIPLE_INST:
+         wStrID = IDS_ERR_MULTIPLE_INST;
+			break;
+      case  CPL_NO_DRIVER:
+         wStrID = IDS_ERR_NO_DRIVER;
+         break;
+      case  CPL_BAD_DRIVER:
+         wStrID = IDS_ERR_BAD_DRIVER;
+         break;
+      case  CPL_DRIVER_FAILED:         
+            wStrID = IDS_ERR_DRIVER_FAILED;
+         break;
+      case  CPL_ERR_MEMORY:    
+      case  CPL_ERR_ALREADY_IN_LIST:
+         wStrID = IDS_ERR_ALREADY_IN_LIST;
+         break;
+      case  CPL_IGNORE:         
+      case  CPL_ERR_ALREADY_INITIALIZED:
+         fClose = TRUE;
+         goto  done;         // don't say anything!
+         
+      case  CPL_WRN_INVAILD_STR:
+         fClose = TRUE;
+         wStrID = IDS_WRN_INVAILD_STR;
+         break;
+      case  CPL_WRN_INVAILD_NUM_STR:
+         wStrID = IDS_WRN_INVAILD_NUM_STR;
+         break;
+      case  CPL_WRN_INVAILD_EX_NUM_STR:
+         wStrID = IDS_WRN_INVAILD_EX_NUM_STR;
+         break;
+      case  CPL_WRN_INVAILD_NUM:
+         wStrID = IDS_WRN_INVAILD_NUM;
+         break;
+      case CPL_ERR_TAPI_NOMULTIPLEINSTANCE:
+         wStrID = IDS_WRN_NOMULTIPLEINSTANCE;
+         break;
+
+
+      }  // end case
+
+   ErrMsgBox( hWnd, wStrID, MB_OK );
+
+   done:
+      return( fClose );
+   }  // end FErrorRpt
+
+
+/*  U T I L  T A P I  E R R  R E P O R T */
+/*-------------------------------------------------------------------------
+	%%Function: TapiErrReport
+
+	
+-------------------------------------------------------------------------*/
+void PUBLIC TapiErrReport( HWND   hWnd, 
+		                         LONG   lErr )
+{
+	switch (lErr)
+	{
+	case LINEERR_INIFILECORRUPT:
+	case LINEERR_INVALPARAM:
+	case LINEERR_INVALPOINTER:
+	case LINEERR_NOMEM:
+	case LINEERR_OPERATIONFAILED:
+	default:
+		break;
+	}
+}
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   LDialogBox
+   
+   Purpose:    Generic dialog create, handles all erros here...
+   
+\*--------------------------------------------------------------------------*/
+LONG PUBLIC LDialogBox( UINT     wResourceId,
+                           HWND     hWnd, 
+                           DLGPROC  dlgPrc,
+                           LONG     lDialogParam )
+
+   {
+   LONG  lResult;
+   extern CPL  gCPL;       // app global
+
+   lResult = DialogBoxParam( gCPL.hCplInst, MAKEINTRESOURCE( wResourceId ), hWnd, dlgPrc, lDialogParam );
+                          
+   if ( lResult < 0 )  // could not create the dialog for some reason...
+      FErrorRpt( hWnd, CPL_ERR_DIALOG_BOX );
+
+   return( lResult );
+   }  // end LDialogBox
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   ErrMsgBox
+   
+   Purpose:    Generic private message box routine
+   
+\*--------------------------------------------------------------------------*/
+UINT PUBLIC ErrMsgBox( HWND  hWnd,
+                        UINT  wMsgID, 
+                        UINT  wFlags )
+
+   {
+   UINT  uResult;
+   char  szTitle[CPL_MAX_STRING];
+   extern CPL  gCPL;       // app global
+
+   if ( hWnd == NULL )
+      hWnd = GetActiveWindow();
+      
+   if (!((wFlags & MB_ICONQUESTION) || (wFlags & MB_ICONSTOP) || (wFlags & MB_ICONASTERISK)))
+      wFlags |= MB_ICONEXCLAMATION;
+      
+   MessageBeep( MB_ICONASTERISK );
+   uResult = (UINT)MessageBox( hWnd, LpszGetStr( NULL, wMsgID, 0 ), LpszGetStr( szTitle, IDS_TITLE, sizeof( szTitle )), wFlags );
+   
+   return( uResult  );
+   }  // end ErrMsgBox
+   
+   
+/*--------------------------------------------------------------------------*\
+
+   Function:   Help
+   
+   Purpose:    Brings up the help, handles anything bad and any necessary
+               global data...
+   
+\*--------------------------------------------------------------------------*/
+VOID PUBLIC Help( HWND    hWnd,
+                      DWORD   dwContextId )
+
+   {
+   // char gszHelpFile[];    - global string in code segment
+   // modified by TNIXON 12/6/94 to access HELP FINDER
+
+   WinHelp( hWnd, gszHelpFile, HELP_FINDER, 0 );
+   }  // end Help
+   
+
+   
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+#if 0
+/*--------------------------------------------------------------------------*\
+
+   Function:   LpszGetSelectedStr
+   
+   Purpose:    Returns a valid pointer to a selected string in a list box
+   
+\*--------------------------------------------------------------------------*/
+LPSTR PUBLIC   LpszGetSelectedStr( HWND   hWnd, 
+                                   UINT   uControl,
+                                   BOOL   fListBox )     // optional
+               
+   {
+   UINT  uSize;
+   LONG  lIndex;
+   UINT  uResult;
+   static char gszUtilString[CPL_MAX_STRING];     // fucntion global
+      
+   // find the string
+   //----------------                    
+   lIndex = SendDlgItemMessage( hWnd, uControl, fListBox ? LB_GETCURSEL : CB_GETCURSEL, 0, 0 );
+   if ( lIndex == LB_ERR )
+      {
+      uResult = CPL_APP_ERROR;
+      goto  error;
+      }  // end if
+      
+   // get some memory for this guy
+   //-----------------------------
+   uSize = (UINT)SendDlgItemMessage( hWnd, uControl, fListBox ? LB_GETTEXTLEN : CB_GETLBTEXTLEN, (UINT)lIndex, 0 ) + 1;
+   if ((uSize + 1) >= sizeof(gszUtilString))
+      {
+      uResult = CPL_APP_ERROR;
+      goto  error;
+      }  // end if
+
+   // finally get the string and outa here...                       
+   SendDlgItemMessage( hWnd, uControl, fListBox ? LB_GETTEXT : CB_GETLBTEXT, (UINT)lIndex, (LPARAM)(LPSTR)gszUtilString );
+   
+   return( gszUtilString );
+  
+   error:
+      FErrorRpt( hWnd, uResult );
+      return( NULL );
+   }  // end LpszGetSelectedStr
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   FGetEditStr
+   
+   Purpose:    Get the text from the edit control, and it verifies that it's
+               correct.
+   
+\*--------------------------------------------------------------------------*/
+BOOL PUBLIC   FGetEditStr( HWND  hWnd,
+                              UINT  uControl,
+                              LPSTR lpszStr,
+                              UINT  uSize )
+
+   {
+   UINT  uIndex;
+   BOOL  fResult;
+   
+   GetDlgItemText( hWnd, uControl, lpszStr, uSize );
+   
+   for ( uIndex = 0; lpszStr[uIndex] && UtilValidStr(lpszStr[uIndex]); uIndex++ )
+      ;
+      
+   if ( lpszStr[uIndex] == '\0' )      // valid str
+      fResult = TRUE;           
+   else                                // invalid str
+      {
+      // report an error and set the focus on the offending text
+      FErrorRpt( hWnd, CPL_WRN_INVAILD_STR );
+      
+      SetFocus( GetDlgItem( hWnd, uControl ));
+      SendDlgItemMessage( hWnd, uControl, EM_SETSEL, 0, MAKELPARAM( uIndex, uIndex + 1 ));
+      
+      fResult = FALSE;
+      }  // end if
+      
+   return( fResult );      
+   }  // end FGetEditStr
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   FGetEditNumStr
+   
+   Purpose:    Get the text from the edit control, and it verifies that it's
+               correct.
+   
+\*--------------------------------------------------------------------------*/
+BOOL PUBLIC   FGetEditNumStr( HWND  hWnd,
+                                 UINT  uControl,
+                                 LPSTR lpszNumStr,
+                                 UINT  uSize,
+                                 UINT  wExtendNum )
+
+   {
+   UINT  uIndex;
+   UINT  wWrnId;
+   BOOL  fResult;
+   
+   GetDlgItemText( hWnd, uControl, lpszNumStr, uSize );
+
+   switch ( wExtendNum )
+      {
+      case  UTIL_NUMBER:
+         // 0-9
+         wWrnId = CPL_WRN_INVAILD_NUM;            
+         for ( uIndex = 0; lpszNumStr[uIndex] && CplIsDigit(lpszNumStr[uIndex]); uIndex++ )
+            ;
+         break;
+         
+      case  UTIL_EXTENED:
+         // 0 1 2 3 4 5 6 7 8 9 A a B b C c D d * # , ! W w P p T t @ $ ?
+         wWrnId = CPL_WRN_INVAILD_NUM_STR;            
+         for ( uIndex = 0; lpszNumStr[uIndex] && UtilValidNumStr(lpszNumStr[uIndex]); uIndex++ )
+            ;
+         break;
+         
+      case  UTIL_BIG_EXTENDED:
+      default:
+         // 0 1 2 3 4 5 6 7 8 9 A a B b C c D d E e F f G g H h * # , ! W w P p T t @ $ ?
+         wWrnId = CPL_WRN_INVAILD_EX_NUM_STR;
+         for ( uIndex = 0; lpszNumStr[uIndex] && UtilValidExNumStr(lpszNumStr[uIndex]); uIndex++ )
+            ;
+         break;         
+      }  // end case   
+      
+   if ( lpszNumStr[uIndex] == '\0' )      // valid str
+      fResult = TRUE;           
+   else                                   // invalid str
+      {
+      // report an error and set the focus on the offending text
+      FErrorRpt( hWnd, wWrnId );
+      
+      SetFocus( GetDlgItem( hWnd, uControl ));
+      SendDlgItemMessage( hWnd, uControl, EM_SETSEL, 0, MAKELPARAM( uIndex, uIndex + 1 ));
+      
+      fResult = FALSE;
+      }  // end if
+
+   return( fResult );      
+   }  // end FGetEditNumStr
+
+#endif
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// Strips leading and trailing blanks from a string.
+// Alters the memory where the string sits.
+//
+// in:
+//  lpszString  string to strip
+//
+// out:
+//  lpszString  string sans leading/trailing blanks
+
+void PUBLIC PathRemoveBlanks(LPSTR lpszString)
+{
+    LPSTR lpszPosn;
+
+    /* strip leading blanks */
+    lpszPosn = lpszString;
+    while(*lpszPosn == ' ') {
+        lpszPosn++;
+    }
+    if (lpszPosn != lpszString)
+        lstrcpy(lpszString, lpszPosn);
+
+    /* strip trailing blanks */
+    if ((lpszPosn=lpszString+lstrlen(lpszString)) != lpszString) {
+        lpszPosn = AnsiPrev(lpszString, lpszPosn);
+        while(*lpszPosn == ' ')
+           lpszPosn = AnsiPrev(lpszString, lpszPosn);
+        lpszPosn = AnsiNext(lpszPosn);
+        *lpszPosn = '\0';
+    }
+
+}
+   
+// Removes a trailing backslash from a qualified path
+//
+// in:
+//  lpszPath    (A:\, C:\foo\, etc)
+//
+// out:
+//  lpszPath    (A:\, C:\foo, etc)
+//
+// returns:
+//  ponter to NULL that replaced the backslash
+//  or the pointer to the backslash
+
+LPSTR PUBLIC LpszPathRemoveBackslash(LPSTR lpszPath)
+{
+  int len;
+
+#ifdef  DBCS
+  len = lstrlen(lpszPath) - (IsDBCSLeadByte(*AnsiPrev(lpszPath,lpszPath+lstrlen(lpszPath))) ? 2 : 1);
+#else
+  len = lstrlen(lpszPath) - 1;
+#endif
+  // if this is not a root (A:\) and the last char
+  // is a '\', nuke it
+
+  if ((len > 2) && (lpszPath[len] == '\\'))
+      lpszPath[len] = 0;
+
+  return lpszPath + len;
+}
+     
+// add a backslash to a qualified path
+//
+// in:
+//  lpszPath    path (A:, C:\foo, etc)
+//
+// out:
+//  lpszPath    A:\, C:\foo\  
+//
+// returns:
+//  pointer to the NULL that terminates the path
+
+
+LPSTR PUBLIC LpszPathAddBackslash(LPSTR lpszPath)
+{
+    LPSTR lpszEnd;
+
+    lpszEnd = lpszPath + lstrlen(lpszPath);
+
+    // this is really an error, caller shouldn't pass
+    // an empty string
+    if (!*lpszPath)
+        return lpszEnd;
+
+    /* Get the end of the source directory
+    */
+    switch(*AnsiPrev(lpszPath, lpszEnd)) {
+    case '\\':
+        break;
+
+    default:
+        *lpszEnd++ = '\\';
+        *lpszEnd = '\0';
+    }
+    return lpszEnd;
+}
+
+//int FAR cdecl IMessageBox(HWND hWnd, WORD wText, WORD wCaption, WORD wType, ...)
+int FAR cdecl IMessageBox(HWND hWnd, WORD wText, WORD wCaption, WORD wType, LPSTR lpszString)
+{
+  char szText[256+CPL_MAX_PATH], szCaption[256];
+  extern CPL  gCPL;       // app global
+                 
+  LoadString(gCPL.hCplInst, wText, szCaption, sizeof(szCaption));
+//  wvsprintf(szText, szCaption, (va_list)(&wType+1));
+  wsprintf(szText, szCaption, lpszString);
+
+  if (wCaption)
+      LoadString(gCPL.hCplInst, wCaption, szCaption, sizeof(szCaption));
+  else
+      GetWindowText(hWnd, szCaption, sizeof(szCaption));
+
+  return MessageBox(hWnd, szText, szCaption, wType);
+}
+
+
diff --git a/private/tapi/dev/cpl/util.h b/private/tapi/dev/cpl/util.h
new file mode 100644
index 000000000..3e4703365
--- /dev/null
+++ b/private/tapi/dev/cpl/util.h
@@ -0,0 +1,132 @@
+/*--------------------------------------------------------------------------*\
+   Include File:  util.h
+    
+    Generic utility funcitons for the control panel applet.
+    
+\*--------------------------------------------------------------------------*/
+
+#ifndef  PH_UTIL
+#define  PH_UTIL
+
+
+//----------
+// Constants
+//----------
+#define  UTIL_NUMBER             1           // 0-9
+#define  UTIL_EXTENED            2           // 0 1 2 3 4 5 6 7 8 9 A a B b C c D d * # , ! W w P p T t @ $ ?
+#define  UTIL_BIG_EXTENDED       3           // 0 1 2 3 4 5 6 7 8 9 A a B b C c D d E e F f G g H h * # , ! W w P p T t @ $ ?
+
+
+//--------------------
+// Function Prototypes
+//--------------------
+LPSTR PUBLIC   LpszGetStr( LPSTR pszNewString, UINT wStrResId, UINT wMaxLeng );
+BOOL  PUBLIC   FErrorRpt( HWND hWnd, UINT wErrorId );
+void  PUBLIC   TapiErrReport( HWND hWnd, LONG lErr );
+LONG  PUBLIC   LDialogBox( UINT wResourceId, HWND hWnd, DLGPROC dlgPrc, LONG lDialogParam );
+UINT  PUBLIC   ErrMsgBox( HWND hWnd, UINT wMsgID, UINT wFlags );
+VOID  PUBLIC   Help( HWND hWnd, DWORD dwContextId );
+LPSTR PUBLIC   LpszGetSelectedStr( HWND hWnd, UINT uControl, BOOL fListBox );
+BOOL  PUBLIC   FGetEditStr( HWND hWnd, UINT uControl, LPSTR lpszStr, UINT uSize );
+BOOL  PUBLIC   FGetEditNumStr( HWND hWnd, UINT uControl, LPSTR lpszNumStr, UINT uSize, UINT wExtendNum );
+void  PUBLIC   PathRemoveBlanks(LPSTR lpszString);
+LPSTR PUBLIC   LpszPathRemoveBackslash(LPSTR lpszPath);
+LPSTR PUBLIC   LpszPathAddBackslash(LPSTR lpszPath);
+int  FAR cdecl IMessageBox(HWND hWnd, WORD wText, WORD wCaption, WORD wType, LPSTR);
+
+//-------
+// Macros
+//-------
+#define  UtilValidStr( ch )                     \
+   (((ch) >= ' ') && ((ch) != '\"'))
+
+               
+#define  UtilValidNumStr( ch )                  \
+   ((((ch) >= '0') && ((ch) <= '9')) ||         \
+    (((ch) >= 'a') && ((ch) <= 'd')) ||         \
+    (((ch) >= 'A') && ((ch) <= 'D')) ||         \
+    ((ch) == '#')  ||                           \
+    ((ch) == '*')  ||                           \
+    (((ch) == 't') || ((ch) == 'T')) ||         \
+    (((ch) == 'p') || ((ch) == 'P')) ||         \
+    ((ch) == '!')  ||                           \
+    ((ch) == ',')  ||                           \
+    (((ch) == 'w') || ((ch) == 'W')) ||         \
+    ((ch) == '@')  ||                           \
+    ((ch) == '$')  ||                           \
+    ((ch) <= '?') )
+
+
+#define  UtilValidExNumStr( ch )                \
+   ((((ch) >= '0') && ((ch) <= '9')) ||         \
+    (((ch) >= 'a') && ((ch) <= 'h')) ||         \
+    (((ch) >= 'A') && ((ch) <= 'H')) ||         \
+    ((ch) == '#')  ||                           \
+    ((ch) == '*')  ||                           \
+    (((ch) == 't') || ((ch) == 'T')) ||         \
+    (((ch) == 'p') || ((ch) == 'P')) ||         \
+    ((ch) == '!')  ||                           \
+    ((ch) == ',')  ||                           \
+    (((ch) == 'w') || ((ch) == 'W')) ||         \
+    ((ch) == '@')  ||                           \
+    ((ch) == '$')  ||                           \
+    ((ch) <= '?') )
+
+//-------------
+// Debug Macros
+//-------------
+
+#if DBG
+#define DBG_ASSERT(exp, str) \
+	{ \
+		if (!(exp)) \
+		{ \
+			MessageBox( NULL, (LPCSTR)("ASSERT: " __FILE__ "\n" str), \
+						   (LPCSTR)"Debug Message", MB_OK ); \
+		} \
+	}
+	
+#define FUNC_ENTRY(_s_) char __szFuncName[] = _s_;
+#define DEBUG_WRAP(_s_) ("TAPI CPL: %s: " _s_ "\r\n"), (LPSTR)__szFuncName
+
+#define DEBOUT(str) \
+	{ \
+		char _szBuf[256]; \
+		wsprintf( _szBuf, (LPSTR)DEBUG_WRAP(str) ); \
+		OutputDebugString( _szBuf ); \
+	}
+
+#define DEBOUT1(str, arg) \
+	{ \
+		char _szBuf[256]; \
+		wsprintf( _szBuf, (LPSTR)DEBUG_WRAP(str), arg ); \
+		OutputDebugString( _szBuf ); \
+	}
+
+	
+#define DEBOUT2(str, arg1, arg2) \
+	{ \
+		char _szBuf[256]; \
+		wsprintf( _szBuf, (LPSTR)DEBUG_WRAP(str), arg1, arg2 ); \
+		OutputDebugString( _szBuf ); \
+	}
+
+
+#define DEBOUT3(str, arg1, arg2, arg3) \
+	{ \
+		char _szBuf[256]; \
+		wsprintf( _szBuf, (LPSTR)DEBUG_WRAP(str), arg1, arg2, arg3 ); \
+		OutputDebugString( _szBuf ); \
+	}
+
+	
+#else			
+#define DBG_ASSERT(exp, str)
+#define FUNC_ENTRY(_s_)
+#define DEBOUT(str)
+#define DEBOUT1(str, arg)
+#define DEBOUT2(str, arg1, arg2)
+#define DEBOUT3(str, arg1, arg2, arg3)
+#endif /* _MYDEBUG */
+
+#endif   // PH_UTIL	
diff --git a/private/tapi/dev/dagger.mk b/private/tapi/dev/dagger.mk
new file mode 100644
index 000000000..aa7079c2c
--- /dev/null
+++ b/private/tapi/dev/dagger.mk
@@ -0,0 +1,35 @@
+#############################################################################
+#
+#	Microsoft Confidential
+#	Copyright (C) Microsoft Corporation 1991
+#	All Rights Reserved.
+#                                                                          
+#	WIN project makefile include
+#
+#############################################################################
+
+#	Default to 32bit unless otherwise specified.
+
+#!ifndef IS_16
+IS_32=1
+WIN32=1
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100
+!undef IS_16
+#!endif
+
+INCLUDES=$(INCLUDES);d:\dagger\dev\inc
+INCLUDE=$(INCLUDE);d:\dagger\dev\inc
+
+INCFILE=d:\dagger\dev\inc\inc.mk
+
+MASM6=TRUE
+
+#	Include master makefile
+
+!ifndef PROPROOT
+PROPROOT = $(ROOT)\dev\bin
+!endif
+
+!include $(ROOT)\dev\master.mk 
+#	Add the dos local include/lib directories
+
diff --git a/private/tapi/dev/dirs b/private/tapi/dev/dirs
new file mode 100644
index 000000000..3a435d43e
--- /dev/null
+++ b/private/tapi/dev/dirs
@@ -0,0 +1,32 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+
+DIRS=\
+     client     \
+     explib     \
+     server     \
+     thunk      \
+     sp         \
+     apps       \
+     cpl.new    \
+     perfdll
diff --git a/private/tapi/dev/explib/makefile b/private/tapi/dev/explib/makefile
new file mode 100644
index 000000000..690a91eba
--- /dev/null
+++ b/private/tapi/dev/explib/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tapi32.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/explib/sources b/private/tapi/dev/explib/sources
new file mode 100644
index 000000000..2b98db424
--- /dev/null
+++ b/private/tapi/dev/explib/sources
@@ -0,0 +1,55 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tapi32l
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=LIBRARY
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib   \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib   \
+           $(BASEDIR)\public\sdk\lib\*\version.lib   \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=..\cpl;..\server;$(BASEDIR)\public\sdk\inc
+
+SOURCES=\
+        tapilib.c
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/explib/tapilib.c b/private/tapi/dev/explib/tapilib.c
new file mode 100644
index 000000000..57dcf1f82
--- /dev/null
+++ b/private/tapi/dev/explib/tapilib.c
@@ -0,0 +1,10126 @@
+#if DBG
+#define InternalDebugOut(_x_) DbgPrt _x_
+#else
+#define InternalDebugOut(_x_)
+#endif
+
+#define STRICT
+
+#include <windows.h>
+#include <windowsx.h>
+
+//#include "stdlib.h"
+#include "tapi.h"
+
+HINSTANCE ghTapi32 = NULL;
+DWORD     gdwDebugLevel = 0;
+
+
+
+#undef   lineBlindTransfer
+#undef   lineConfigDialog
+#undef   lineConfigDialogEdit
+#undef   lineDial
+#undef   lineForward
+#undef   lineGatherDigits
+#undef   lineGenerateDigits
+#undef   lineGetAddressCaps
+#undef   lineGetAddressID
+#undef   lineGetAddressStatus
+#undef   lineGetCallInfo
+#undef   lineGetDevCaps
+#undef   lineGetDevConfig
+#undef   lineGetIcon
+#undef   lineGetID
+#undef   lineGetLineDevStatus
+#undef   lineGetRequest
+#undef   lineGetTranslateCaps
+#undef   lineHandoff
+#undef   lineMakeCall
+#undef   lineOpen
+#undef   linePark
+#undef   linePickup
+#undef   linePrepareAddToConference
+#undef   lineRedirect
+#undef   lineSetDevConfig
+#undef   lineSetTollList
+#undef   lineSetupConference
+#undef   lineSetupTransfer
+#undef   lineTranslateAddress
+#undef   lineUnpark
+#undef   phoneConfigDialog
+#undef   phoneGetButtonInfo
+#undef   phoneGetDevCaps
+#undef   phoneGetIcon
+#undef   phoneGetID
+#undef   phoneGetStatus
+#undef   phoneSetButtonInfo
+#undef   tapiGetLocationInfo
+#undef   tapiRequestMakeCall
+#undef   tapiRequestMediaCall
+#undef   lineAddProvider
+#undef   lineGetAppPriority
+#undef   lineGetCountry
+#undef   lineGetProviderList
+#undef   lineSetAppPriority
+#undef   lineTranslateDialog
+
+
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    static BOOLEAN fBeenThereDoneThat = FALSE;
+
+    if ( !fBeenThereDoneThat )
+    {
+            HKEY  hKey;
+
+
+            gdwDebugLevel=0;
+
+            if (RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKey
+
+                    ) == ERROR_SUCCESS)
+            {
+                DWORD dwDataSize = sizeof(DWORD), dwDataType;
+
+                RegQueryValueEx(
+                    hKey,
+                    "Tapi32libDebugLevel",
+                    0,
+                    &dwDataType,
+                    (LPBYTE)&gdwDebugLevel,
+                    &dwDataSize
+                    );
+
+                RegCloseKey (hKey);
+            }
+    }
+
+
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[1280] = "TAPI32.LIB: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[12],
+                   lpszFormat,
+                   ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG PASCAL GetTheFunctionPtr( LPSTR lpszFunction, FARPROC *ppfn )
+{
+   InternalDebugOut((4, "Looking for: [%s]", lpszFunction));
+
+   if ( !ghTapi32 )
+   {
+      ghTapi32 = LoadLibrary("TAPI32.DLL");
+      
+      //
+      // If this failed, we won't try again
+      //
+      if ( 0 == ghTapi32 )
+      {
+         InternalDebugOut((1, "Can't LoadLibrary(""TAPI32.DLL"") !"));
+         ghTapi32 = (HINSTANCE)-1;
+      }
+   }
+
+
+   if ( ghTapi32 != (HINSTANCE)-1 )
+   {
+      *ppfn = GetProcAddress( ghTapi32, lpszFunction );
+   }
+   else
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+
+   if ( NULL == *ppfn )
+   {
+      InternalDebugOut((1, "Can't find function: [%s]", lpszFunction));
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return 0;
+}
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAccept(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAccept", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAddProvider(
+    LPCSTR              lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAddProvider", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszProviderFilename,
+                   hwndOwner,
+                   lpdwPermanentProviderID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAddProviderA(
+    LPCSTR              lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAddProviderA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszProviderFilename,
+                   hwndOwner,
+                   lpdwPermanentProviderID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAddProviderW(
+    LPCWSTR             lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAddProviderW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszProviderFilename,
+                   hwndOwner,
+                   lpdwPermanentProviderID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAddToConference(
+    HCALL               hConfCall,
+    HCALL               hConsultCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAddToConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hConfCall,
+                   hConsultCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAgentSpecific(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentExtensionIDIndex,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAgentSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwAgentExtensionIDIndex,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAnswer(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAnswer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineBlindTransfer(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineBlindTransfer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineBlindTransferA(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineBlindTransferA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineBlindTransferW(
+    HCALL               hCall,
+    LPCWSTR             lpszDestAddressW,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineBlindTransferW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddressW,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineClose(
+    HLINE               hLine
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineClose", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineCompleteCall(
+    HCALL               hCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineCompleteCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpdwCompletionID,
+                   dwCompletionMode,
+                   dwMessageID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineCompleteTransfer(
+    HCALL               hCall,
+    HCALL               hConsultCall,
+    LPHCALL             lphConfCall,
+    DWORD               dwTransferMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineCompleteTransfer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   hConsultCall,
+                   lphConfCall,
+                   dwTransferMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialog", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialogA(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialogA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialogW(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialogW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialogEdit(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialogEdit", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass,
+                   lpDeviceConfigIn,
+                   dwSize,
+                   lpDeviceConfigOut
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialogEditA(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialogEditA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass,
+                   lpDeviceConfigIn,
+                   dwSize,
+                   lpDeviceConfigOut
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialogEditW(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialogEditW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass,
+                   lpDeviceConfigIn,
+                   dwSize,
+                   lpDeviceConfigOut
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigProvider(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigProvider", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hwndOwner,
+                   dwPermanentProviderID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDeallocateCall(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDeallocateCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDevSpecific(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDevSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDevSpecificFeature(
+    HLINE               hLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDevSpecificFeature", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwFeature,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDial(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDial", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDialA(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDialA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDialW(
+    HCALL               hCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDialW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDrop(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDrop", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineForward(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineForward", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   bAllAddresses,
+                   dwAddressID,
+                   lpForwardList,
+                   dwNumRingsNoAnswer,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineForwardA(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineForwardA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   bAllAddresses,
+                   dwAddressID,
+                   lpForwardList,
+                   dwNumRingsNoAnswer,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineForwardW(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineForwardW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   bAllAddresses,
+                   dwAddressID,
+                   lpForwardList,
+                   dwNumRingsNoAnswer,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGatherDigits(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGatherDigits", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitModes,
+                   lpsDigits,
+                   dwNumDigits,
+                   lpszTerminationDigits,
+                   dwFirstDigitTimeout,
+                   dwInterDigitTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGatherDigitsA(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGatherDigitsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitModes,
+                   lpsDigits,
+                   dwNumDigits,
+                   lpszTerminationDigits,
+                   dwFirstDigitTimeout,
+                   dwInterDigitTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGatherDigitsW(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPWSTR              lpsDigits,
+    DWORD               dwNumDigits,
+    LPCWSTR             lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGatherDigitsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitModes,
+                   lpsDigits,
+                   dwNumDigits,
+                   lpszTerminationDigits,
+                   dwFirstDigitTimeout,
+                   dwInterDigitTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGenerateDigits(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGenerateDigits", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitMode,
+                   lpszDigits,
+                   dwDuration
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGenerateDigitsA(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGenerateDigitsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitMode,
+                   lpszDigits,
+                   dwDuration
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGenerateDigitsW(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCWSTR             lpszDigits,
+    DWORD               dwDuration
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGenerateDigitsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitMode,
+                   lpszDigits,
+                   dwDuration
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGenerateTone(
+    HCALL               hCall,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGenerateTone", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwToneMode,
+                   dwDuration,
+                   dwNumTones,
+                   lpTones
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpAddressCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressCapsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpAddressCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressCapsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpAddressCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressID(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressID", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpdwAddressID,
+                   dwAddressMode,
+                   lpsAddress,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressIDA(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressIDA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpdwAddressID,
+                   dwAddressMode,
+                   lpsAddress,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressIDW(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCWSTR             lpsAddress,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressIDW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpdwAddressID,
+                   dwAddressMode,
+                   lpsAddress,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressStatus(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAddressStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressStatusA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressStatusA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAddressStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressStatusW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressStatusW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAddressStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentActivityListA(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentActivityListA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                       hLine,
+                       dwAddressID,
+                       lpAgentActivityList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentActivityListW(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentActivityListW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                       hLine,
+                       dwAddressID,
+                       lpAgentActivityList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentCapsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAppAPIVersion,
+                   lpAgentCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentCapsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAppAPIVersion,
+                   lpAgentCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentGroupListA(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentGroupListA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                       hLine,
+                       dwAddressID,
+                       lpAgentGroupList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentGroupListW(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentGroupListW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                       hLine,
+                       dwAddressID,
+                       lpAgentGroupList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentStatusA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentStatusA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAgentStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentStatusW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentStatusW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAgentStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAppPriority(
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAppPriority", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpExtensionName,
+                   lpdwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAppPriorityA(
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAppPriorityA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpExtensionName,
+                   lpdwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAppPriorityW(
+    LPCWSTR             lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAppPriorityW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpExtensionName,
+                   lpdwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCallInfo(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCallInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCallInfoA(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCallInfoA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCallInfoW(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCallInfoW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCallStatus(
+    HCALL               hCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCallStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetConfRelatedCalls(
+    HCALL               hCall,
+    LPLINECALLLIST      lpCallList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetConfRelatedCalls", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallList
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCountry(
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCountry", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwCountryID,
+                   dwAPIVersion,
+                   lpLineCountryList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCountryA(
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCountryA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwCountryID,
+                   dwAPIVersion,
+                   lpLineCountryList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCountryW(
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCountryW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwCountryID,
+                   dwAPIVersion,
+                   lpLineCountryList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpLineDevCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevCapsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpLineDevCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevCapsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpLineDevCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevConfig", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevConfigA(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevConfigA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevConfigW(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevConfigW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetNewCalls(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwSelect,
+    LPLINECALLLIST      lpCallList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetNewCalls", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwSelect,
+                   lpCallList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetIcon", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetIconA(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetIconA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetIconW(
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetIconW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetID(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetID", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetIDA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetIDA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetIDW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetIDW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetLineDevStatus(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetLineDevStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpLineDevStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetLineDevStatusA(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetLineDevStatusA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpLineDevStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetLineDevStatusW(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetLineDevStatusW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpLineDevStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetMessage(
+    HLINEAPP        hLineApp,
+    LPLINEMESSAGE   lpMessage,
+    DWORD           dwTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetMessage", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   lpMessage,
+                   dwTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetNumRings(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPDWORD             lpdwNumRings
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetNumRings", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpdwNumRings
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetProviderList(
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetProviderList", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwAPIVersion,
+                   lpProviderList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetProviderListA(
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetProviderListA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwAPIVersion,
+                   lpProviderList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetProviderListW(
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetProviderListW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwAPIVersion,
+                   lpProviderList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetRequest(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetRequest", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwRequestMode,
+                   lpRequestBuffer
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetRequestA(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetRequestA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwRequestMode,
+                   lpRequestBuffer
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetRequestW(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetRequestW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwRequestMode,
+                   lpRequestBuffer
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetStatusMessages(
+    HLINE               hLine,
+    LPDWORD             lpdwLineStates,
+    LPDWORD             lpdwAddressStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpdwLineStates,
+                   lpdwAddressStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetTranslateCaps(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetTranslateCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwAPIVersion,
+                   lpTranslateCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetTranslateCapsA(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetTranslateCapsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwAPIVersion,
+                   lpTranslateCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetTranslateCapsW(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetTranslateCapsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwAPIVersion,
+                   lpTranslateCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineHandoff(
+    HCALL               hCall,
+    LPCSTR              lpszFileName,
+    DWORD               dwMediaMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineHandoff", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszFileName,
+                   dwMediaMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineHandoffA(
+    HCALL               hCall,
+    LPCSTR              lpszFileName,
+    DWORD               dwMediaMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineHandoffA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszFileName,
+                   dwMediaMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineHandoffW(
+    HCALL               hCall,
+    LPCWSTR             lpszFileName,
+    DWORD               dwMediaMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineHandoffW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszFileName,
+                   dwMediaMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineHold(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineHold", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineInitialize(
+    LPHLINEAPP          lphLineApp,
+    HINSTANCE           hInstance,
+    LINECALLBACK        lpfnCallback,
+    LPCSTR              lpszAppName,
+    LPDWORD             lpdwNumDevs
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineInitialize", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphLineApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszAppName,
+                   lpdwNumDevs
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineInitializeExA(
+    LPHLINEAPP                  lphLineApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                lpfnCallback,
+    LPCSTR                      lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineInitializeExA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphLineApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszFriendlyAppName,
+                   lpdwNumDevs,
+                   lpdwAPIVersion,
+                   lpLineInitializeExParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineInitializeExW(
+    LPHLINEAPP                  lphLineApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                lpfnCallback,
+    LPCWSTR                     lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineInitializeExW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphLineApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszFriendlyAppName,
+                   lpdwNumDevs,
+                   lpdwAPIVersion,
+                   lpLineInitializeExParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMakeCall(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMakeCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lphCall,
+                   lpszDestAddress,
+                   dwCountryCode,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMakeCallA(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMakeCallA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lphCall,
+                   lpszDestAddress,
+                   dwCountryCode,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMakeCallW(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMakeCallW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lphCall,
+                   lpszDestAddress,
+                   dwCountryCode,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMonitorDigits(
+    HCALL               hCall,
+    DWORD               dwDigitModes
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMonitorDigits", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitModes
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMonitorMedia(
+    HCALL               hCall,
+    DWORD               dwMediaModes
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMonitorMedia", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwMediaModes
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMonitorTones(
+    HCALL               hCall,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMonitorTones", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpToneList,
+                   dwNumEntries
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineNegotiateAPIVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineNegotiateAPIVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPILowVersion,
+                   dwAPIHighVersion,
+                   lpdwAPIVersion,
+                   lpExtensionID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineNegotiateExtVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtLowVersion,
+    DWORD               dwExtHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineNegotiateExtVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtLowVersion,
+                   dwExtHighVersion,
+                   lpdwExtVersion
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineOpen(
+    HLINEAPP            hLineApp, 
+    DWORD               dwDeviceID,
+    LPHLINE             lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineOpen", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp, 
+                   dwDeviceID,
+                   lphLine,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   dwCallbackInstance,
+                   dwPrivileges,
+                   dwMediaModes,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineOpenA(
+    HLINEAPP            hLineApp, 
+    DWORD               dwDeviceID,
+    LPHLINE             lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineOpenA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp, 
+                   dwDeviceID,
+                   lphLine,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   dwCallbackInstance,
+                   dwPrivileges,
+                   dwMediaModes,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineOpenW(
+    HLINEAPP            hLineApp, 
+    DWORD               dwDeviceID,
+    LPHLINE             lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineOpenW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp, 
+                   dwDeviceID,
+                   lphLine,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   dwCallbackInstance,
+                   dwPrivileges,
+                   dwMediaModes,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePark(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePark", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwParkMode,
+                   lpszDirAddress,
+                   lpNonDirAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineParkA(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineParkA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwParkMode,
+                   lpszDirAddress,
+                   lpNonDirAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineParkW(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCWSTR             lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineParkW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwParkMode,
+                   lpszDirAddress,
+                   lpNonDirAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePickup(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePickup", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress,
+                   lpszGroupID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePickupA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePickupA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress,
+                   lpszGroupID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePickupW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszGroupID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePickupW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress,
+                   lpszGroupID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePrepareAddToConference(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePrepareAddToConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hConfCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePrepareAddToConferenceA(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePrepareAddToConferenceA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hConfCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePrepareAddToConferenceW(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePrepareAddToConferenceW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hConfCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineProxyMessage(
+    HLINE               hLine,
+    HCALL               hCall,
+    DWORD               dwMsg,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineProxyMessage", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   hCall,
+                   dwMsg,
+                   dwParam1,
+                   dwParam2,
+                   dwParam3
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineProxyResponse(
+    HLINE               hLine,
+    LPLINEPROXYREQUEST  lpProxyRequest,
+    DWORD               dwResult
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineProxyResponse", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpProxyRequest,
+                   dwResult
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRedirect(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRedirect", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRedirectA(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRedirectA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRedirectW(
+    HCALL               hCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRedirectW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRegisterRequestRecipient(
+    HLINEAPP            hLineApp,
+    DWORD               dwRegistrationInstance,
+    DWORD               dwRequestMode,
+    DWORD               bEnable
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRegisterRequestRecipient", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwRegistrationInstance,
+                   dwRequestMode,
+                   bEnable
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineReleaseUserUserInfo(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineReleaseUserUserInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRemoveFromConference(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRemoveFromConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRemoveProvider(
+    DWORD               dwPermanentProviderID,
+    HWND                hwndOwner
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRemoveProvider", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwPermanentProviderID,
+                   hwndOwner
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSecureCall(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSecureCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSendUserUserInfo(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSendUserUserInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAgentActivity(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwActivityID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAgentActivity", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwActivityID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAgentGroup(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAgentGroup", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAgentGroupList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAgentState(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentState,
+    DWORD               dwNextAgentState
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAgentState", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwAgentState,
+                   dwNextAgentState
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAppPriority(
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCSTR              lpszExtensionName,
+    DWORD               dwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAppPriority", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpszExtensionName,
+                   dwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAppPriorityA(
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCSTR              lpszExtensionName,
+    DWORD               dwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAppPriorityA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpszExtensionName,
+                   dwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAppPriorityW(
+    LPCWSTR             lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCWSTR             lpszExtensionName,
+    DWORD               dwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAppPriorityW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpszExtensionName,
+                   dwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAppSpecific(
+    HCALL               hCall,
+    DWORD               dwAppSpecific
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAppSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwAppSpecific
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallData(
+    HCALL               hCall,
+    LPVOID              lpCallData,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallData", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallData,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallParams(
+    HCALL               hCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallParams", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwBearerMode,
+                   dwMinRate,
+                   dwMaxRate,
+                   lpDialParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallPrivilege(
+    HCALL               hCall,
+    DWORD               dwCallPrivilege
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallPrivilege", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwCallPrivilege
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallQualityOfService(
+    HCALL               hCall,
+    LPVOID              lpSendingFlowspec,
+    DWORD               dwSendingFlowspecSize,
+    LPVOID              lpReceivingFlowspec,
+    DWORD               dwReceivingFlowspecSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallQualityOfService", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpSendingFlowspec,
+                   dwSendingFlowspecSize,
+                   lpReceivingFlowspec,
+                   dwReceivingFlowspecSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallTreatment(
+    HCALL               hCall,
+    DWORD               dwTreatment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallTreatment", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwTreatment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCurrentLocation(
+    HLINEAPP            hLineApp,
+    DWORD               dwLocation
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCurrentLocation", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwLocation
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetDevConfig", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   dwSize,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetDevConfigA(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetDevConfigA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   dwSize,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetDevConfigW(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetDevConfigW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   dwSize,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetLineDevStatus(
+    HLINE               hLine,
+    DWORD               dwStatusToChange,
+    DWORD               fStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetLineDevStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwStatusToChange,
+                   fStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetMediaControl(
+    HLINE                       hLine,
+    DWORD                       dwAddressID,
+    HCALL                       hCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList, 
+    DWORD                       dwCallStateNumEntries
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetMediaControl", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   lpDigitList,
+                   dwDigitNumEntries,
+                   lpMediaList,
+                   dwMediaNumEntries,
+                   lpToneList,
+                   dwToneNumEntries,
+                   lpCallStateList, 
+                   dwCallStateNumEntries
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetMediaMode(
+    HCALL               hCall,
+    DWORD               dwMediaModes
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetMediaMode", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwMediaModes
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetNumRings(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwNumRings
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetNumRings", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwNumRings
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetStatusMessages(
+    HLINE               hLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwLineStates,
+                   dwAddressStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetTerminal(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetTerminal", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   dwTerminalModes,
+                   dwTerminalID,
+                   bEnable
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetTollList(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCSTR              lpszAddressIn,
+    DWORD               dwTollListOption
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetTollList", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   lpszAddressIn,
+                   dwTollListOption
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetTollListA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCSTR              lpszAddressIn,
+    DWORD               dwTollListOption
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetTollListA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   lpszAddressIn,
+                   dwTollListOption
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetTollListW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszAddressInW,
+    DWORD               dwTollListOption
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetTollListW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   lpszAddressInW,
+                   dwTollListOption
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupConference(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   hLine,
+                   lphConfCall,
+                   lphConsultCall,
+                   dwNumParties,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupConferenceA(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupConferenceA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   hLine,
+                   lphConfCall,
+                   lphConsultCall,
+                   dwNumParties,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupConferenceW(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupConferenceW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   hLine,
+                   lphConfCall,
+                   lphConsultCall,
+                   dwNumParties,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupTransfer(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupTransfer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupTransferA(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupTransferA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupTransferW(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupTransferW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineShutdown(
+    HLINEAPP            hLineApp
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineShutdown", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSwapHold(
+    HCALL               hActiveCall,
+    HCALL               hHeldCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSwapHold", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hActiveCall,
+                   hHeldCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateAddress(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateAddress", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   lpszAddressIn,
+                   dwCard,
+                   dwTranslateOptions,
+                   lpTranslateOutput
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateAddressA(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateAddressA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   lpszAddressIn,
+                   dwCard,
+                   dwTranslateOptions,
+                   lpTranslateOutput
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateAddressW(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCWSTR                 lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateAddressW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   lpszAddressIn,
+                   dwCard,
+                   dwTranslateOptions,
+                   lpTranslateOutput
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateDialog(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCSTR              lpszAddressIn
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateDialog", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   hwndOwner,
+                   lpszAddressIn
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateDialogA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCSTR              lpszAddressIn
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateDialogA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   hwndOwner,
+                   lpszAddressIn
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateDialogW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCWSTR             lpszAddressIn
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateDialogW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   hwndOwner,
+                   lpszAddressIn
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUncompleteCall(
+    HLINE               hLine,
+    DWORD               dwCompletionID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUncompleteCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwCompletionID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUnhold(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUnhold", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUnpark(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUnpark", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUnparkA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUnparkA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUnparkW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCWSTR             lpszDestAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUnparkW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneClose(
+    HPHONE              hPhone
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneClose", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneConfigDialog", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneConfigDialogA(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneConfigDialogA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneConfigDialogW(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneConfigDialogW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneDevSpecific(
+    HPHONE              hPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneDevSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetButtonInfo(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetButtonInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetButtonInfoA(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetButtonInfoA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetButtonInfoW(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetButtonInfoW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetData(
+    HPHONE              hPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetData", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwDataID,
+                   lpData,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetDevCaps(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetDevCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpPhoneCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetDevCapsA(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetDevCapsA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpPhoneCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetDevCapsW(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetDevCapsW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpPhoneCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetDisplay(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDisplay
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetDisplay", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpDisplay
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetGain(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetGain", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   lpdwGain
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetHookSwitch(
+    HPHONE              hPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetHookSwitch", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpdwHookSwitchDevs
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetIcon", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetIconA(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetIconA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetIconW(
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetIconW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetID(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetID", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetIDA(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetIDA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetIDW(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetIDW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetLamp(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetLamp", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpdwLampMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetMessage(
+    HPHONEAPP       hPhoneApp,
+    LPPHONEMESSAGE  lpMessage,
+    DWORD           dwTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetMessage", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   lpMessage,
+                   dwTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetRing(
+    HPHONE              hPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetRing", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpdwRingMode,
+                   lpdwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetStatus(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpPhoneStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetStatusA(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetStatusA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpPhoneStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetStatusW(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetStatusW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpPhoneStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetStatusMessages(
+    HPHONE              hPhone,
+    LPDWORD             lpdwPhoneStates,
+    LPDWORD             lpdwButtonModes,
+    LPDWORD             lpdwButtonStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpdwPhoneStates,
+                   lpdwButtonModes,
+                   lpdwButtonStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetVolume(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetVolume", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   lpdwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneInitialize(
+    LPHPHONEAPP         lphPhoneApp,
+    HINSTANCE           hInstance,
+    PHONECALLBACK       lpfnCallback,
+    LPCSTR              lpszAppName,
+    LPDWORD             lpdwNumDevs
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneInitialize", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphPhoneApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszAppName,
+                   lpdwNumDevs
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneInitializeExA(
+    LPHPHONEAPP                 lphPhoneApp,
+    HINSTANCE                   hInstance,
+    PHONECALLBACK               lpfnCallback,
+    LPCSTR                      lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneInitializeExA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphPhoneApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszFriendlyAppName,
+                   lpdwNumDevs,
+                   lpdwAPIVersion,
+                   lpPhoneInitializeExParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneInitializeExW(
+    LPHPHONEAPP                 lphPhoneApp,
+    HINSTANCE                   hInstance,
+    PHONECALLBACK               lpfnCallback,
+    LPCWSTR                     lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneInitializeExW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphPhoneApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszFriendlyAppName,
+                   lpdwNumDevs,
+                   lpdwAPIVersion,
+                   lpPhoneInitializeExParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneNegotiateAPIVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneNegotiateAPIVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPILowVersion,
+                   dwAPIHighVersion,
+                   lpdwAPIVersion,
+                   lpExtensionID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneNegotiateExtVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtLowVersion,
+    DWORD               dwExtHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneNegotiateExtVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtLowVersion,
+                   dwExtHighVersion,
+                   lpdwExtVersion
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneOpen(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    LPHPHONE            lphPhone,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivilege
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneOpen", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   lphPhone,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   dwCallbackInstance,
+                   dwPrivilege
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetButtonInfo(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetButtonInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetButtonInfoA(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetButtonInfoA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetButtonInfoW(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetButtonInfoW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetData(
+    HPHONE              hPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetData", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwDataID,
+                   lpData,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetDisplay(
+    HPHONE              hPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCSTR              lpsDisplay,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetDisplay", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwRow,
+                   dwColumn,
+                   lpsDisplay,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetGain(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetGain", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   dwGain
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetHookSwitch(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetHookSwitch", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDevs,
+                   dwHookSwitchMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetLamp(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetLamp", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   dwLampMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetRing(
+    HPHONE              hPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetRing", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwRingMode,
+                   dwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetStatusMessages(
+    HPHONE              hPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwPhoneStates,
+                   dwButtonModes,
+                   dwButtonStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetVolume(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetVolume", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   dwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneShutdown(
+    HPHONEAPP           hPhoneApp
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneShutdown", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return PHONEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfo(
+    LPSTR               lpszCountryCode,
+    LPSTR               lpszCityCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiGetLocationInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   lpszCountryCode,
+                   lpszCityCode
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfoA(
+    LPSTR               lpszCountryCode,
+    LPSTR               lpszCityCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiGetLocationInfoA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   lpszCountryCode,
+                   lpszCityCode
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfoW(
+    LPWSTR               lpszCountryCodeW,
+    LPWSTR               lpszCityCodeW
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiGetLocationInfoW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   lpszCountryCodeW,
+                   lpszCityCodeW
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestDrop(
+    HWND                hwnd,
+    WPARAM              wRequestID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestDrop", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   hwnd,
+                   wRequestID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMakeCall(
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMakeCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMakeCallA(
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMakeCallA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMakeCallW(
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszAppName,
+    LPCWSTR             lpszCalledParty,
+    LPCWSTR             lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMakeCallW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMediaCall(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCSTR              lpszDeviceClass,
+    LPCSTR              lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMediaCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   hwnd,
+                   wRequestID,
+                   lpszDeviceClass,
+                   lpDeviceID,
+                   dwSize,
+                   dwSecure,
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMediaCallA(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCSTR              lpszDeviceClass,
+    LPCSTR              lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMediaCallA", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   hwnd,
+                   wRequestID,
+                   lpszDeviceClass,
+                   lpDeviceID,
+                   dwSize,
+                   dwSecure,
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMediaCallW(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCWSTR             lpszDeviceClass,
+    LPCWSTR             lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszAppName,
+    LPCWSTR             lpszCalledParty,
+    LPCWSTR             lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMediaCallW", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return TAPIERR_REQUESTFAILED;
+   }
+
+   return (*lpfn)(
+                   hwnd,
+                   wRequestID,
+                   lpszDeviceClass,
+                   lpDeviceID,
+                   dwSize,
+                   dwSecure,
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
diff --git a/private/tapi/dev/inc/inc.mk b/private/tapi/dev/inc/inc.mk
new file mode 100644
index 000000000..e2bebd65b
--- /dev/null
+++ b/private/tapi/dev/inc/inc.mk
@@ -0,0 +1 @@
+INCLUDE=d:\dagger\dev\inc;$(INCLUDE);
diff --git a/private/tapi/dev/inc/tapi.x b/private/tapi/dev/inc/tapi.x
new file mode 100644
index 000000000..35778302f
--- /dev/null
+++ b/private/tapi/dev/inc/tapi.x
@@ -0,0 +1,4728 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+The  Telephony  API  is jointly copyrighted by Intel and Microsoft.  You are
+granted  a royalty free worldwide, unlimited license to make copies, and use
+the   API/SPI  for  making  applications/drivers  that  interface  with  the
+specification provided that this paragraph and the Intel/Microsoft copyright
+statement is maintained as is in the text and source code files.
+
+Copyright 1995-96 Microsoft, all rights reserved.
+Portions copyright 1992, 1993 Intel/Microsoft, all rights reserved.
+
+Module Name:
+
+    tapi.h
+
+Notes:
+
+    Additions to the Telephony Application Programming Interface (TAPI) since
+    version 1.0 are noted by version number (e.g. "TAPI v1.4").
+
+--*/
+
+#ifndef TAPI_H
+#define TAPI_H
+
+
+
+//
+//  -- TAPI VERSION INFO -- TAPI VERSION INFO -- TAPI VERSION INFO --
+//  -- TAPI VERSION INFO -- TAPI VERSION INFO -- TAPI VERSION INFO --
+//  -- TAPI VERSION INFO -- TAPI VERSION INFO -- TAPI VERSION INFO --
+//
+// To build  a TAPI 1.4 application put a define as below in your source
+// file before you include TAPI.H:
+//
+// #define TAPI_CURRENT_VERSION 0x00010004
+//
+//
+#ifndef TAPI_CURRENT_VERSION
+#define TAPI_CURRENT_VERSION 0x00020000
+#endif
+
+#include <windows.h>
+
+#pragma pack(1)
+// Type definitions of the data types used in tapi
+
+#ifdef __cplusplus
+extern "C" {            /* Assume C declarations for C++ */
+#endif  /* __cplusplus */
+
+
+//
+// TAPI type definitions
+//
+
+#define DECLARE_OPAQUE32(name)  struct name##__ { int unused; }; \
+                typedef const struct name##__ FAR* name
+
+DECLARE_OPAQUE32(HCALL);
+typedef HCALL FAR * LPHCALL;
+
+DECLARE_OPAQUE32(HLINE);
+typedef HLINE FAR * LPHLINE;
+
+DECLARE_OPAQUE32(HPHONE);
+typedef HPHONE FAR * LPHPHONE;
+
+DECLARE_OPAQUE32(HLINEAPP);
+typedef HLINEAPP FAR * LPHLINEAPP;
+
+DECLARE_OPAQUE32(HPHONEAPP);
+typedef HPHONEAPP FAR * LPHPHONEAPP;
+
+typedef HICON FAR * LPHICON;
+
+typedef void (CALLBACK * LINECALLBACK)(
+    DWORD               hDevice,
+    DWORD               dwMessage,
+    DWORD               dwInstance,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    );
+
+typedef void (CALLBACK * PHONECALLBACK)(
+    DWORD               hDevice,
+    DWORD               dwMessage,
+    DWORD               dwInstance,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    );
+
+
+// Messages for Phones and Lines
+
+#define LINE_ADDRESSSTATE                       0L
+#define LINE_CALLINFO                           1L
+#define LINE_CALLSTATE                          2L
+#define LINE_CLOSE                              3L
+#define LINE_DEVSPECIFIC                        4L
+#define LINE_DEVSPECIFICFEATURE                 5L
+#define LINE_GATHERDIGITS                       6L
+#define LINE_GENERATE                           7L
+#define LINE_LINEDEVSTATE                       8L
+#define LINE_MONITORDIGITS                      9L
+#define LINE_MONITORMEDIA                       10L
+#define LINE_MONITORTONE                        11L
+#define LINE_REPLY                              12L
+#define LINE_REQUEST                            13L
+#define PHONE_BUTTON                            14L
+#define PHONE_CLOSE                             15L
+#define PHONE_DEVSPECIFIC                       16L
+#define PHONE_REPLY                             17L
+#define PHONE_STATE                             18L
+#define LINE_CREATE                             19L             // TAPI v1.4
+#define PHONE_CREATE                            20L             // TAPI v1.4
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINE_AGENTSPECIFIC                      21L             // TAPI v2.0
+#define LINE_AGENTSTATUS                        22L             // TAPI v2.0
+#define LINE_APPNEWCALL                         23L             // TAPI v2.0
+#define LINE_PROXYREQUEST                       24L             // TAPI v2.0
+#define LINE_REMOVE                             25L             // TAPI v2.0
+#define PHONE_REMOVE                            26L             // TAPI v2.0
+#endif
+
+
+#define INITIALIZE_NEGOTIATION                  0xFFFFFFFFL
+
+#define LINEADDRCAPFLAGS_FWDNUMRINGS            0x00000001
+#define LINEADDRCAPFLAGS_PICKUPGROUPID          0x00000002
+#define LINEADDRCAPFLAGS_SECURE                 0x00000004
+#define LINEADDRCAPFLAGS_BLOCKIDDEFAULT         0x00000008
+#define LINEADDRCAPFLAGS_BLOCKIDOVERRIDE        0x00000010
+#define LINEADDRCAPFLAGS_DIALED                 0x00000020
+#define LINEADDRCAPFLAGS_ORIGOFFHOOK            0x00000040
+#define LINEADDRCAPFLAGS_DESTOFFHOOK            0x00000080
+#define LINEADDRCAPFLAGS_FWDCONSULT             0x00000100
+#define LINEADDRCAPFLAGS_SETUPCONFNULL          0x00000200
+#define LINEADDRCAPFLAGS_AUTORECONNECT          0x00000400
+#define LINEADDRCAPFLAGS_COMPLETIONID           0x00000800
+#define LINEADDRCAPFLAGS_TRANSFERHELD           0x00001000
+#define LINEADDRCAPFLAGS_TRANSFERMAKE           0x00002000
+#define LINEADDRCAPFLAGS_CONFERENCEHELD         0x00004000
+#define LINEADDRCAPFLAGS_CONFERENCEMAKE         0x00008000
+#define LINEADDRCAPFLAGS_PARTIALDIAL            0x00010000
+#define LINEADDRCAPFLAGS_FWDSTATUSVALID         0x00020000
+#define LINEADDRCAPFLAGS_FWDINTEXTADDR          0x00040000
+#define LINEADDRCAPFLAGS_FWDBUSYNAADDR          0x00080000
+#define LINEADDRCAPFLAGS_ACCEPTTOALERT          0x00100000
+#define LINEADDRCAPFLAGS_CONFDROP               0x00200000
+#define LINEADDRCAPFLAGS_PICKUPCALLWAIT         0x00400000
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEADDRCAPFLAGS_PREDICTIVEDIALER       0x00800000      // TAPI v2.0
+#define LINEADDRCAPFLAGS_QUEUE                  0x01000000      // TAPI v2.0
+#define LINEADDRCAPFLAGS_ROUTEPOINT             0x02000000      // TAPI v2.0
+#define LINEADDRCAPFLAGS_HOLDMAKESNEW           0x04000000      // TAPI v2.0
+#define LINEADDRCAPFLAGS_NOINTERNALCALLS        0x08000000      // TAPI v2.0
+#define LINEADDRCAPFLAGS_NOEXTERNALCALLS        0x10000000      // TAPI v2.0
+#define LINEADDRCAPFLAGS_SETCALLINGID           0x20000000      // TAPI v2.0
+#endif
+
+#define LINEADDRESSMODE_ADDRESSID               0x00000001
+#define LINEADDRESSMODE_DIALABLEADDR            0x00000002
+
+#define LINEADDRESSSHARING_PRIVATE              0x00000001
+#define LINEADDRESSSHARING_BRIDGEDEXCL          0x00000002
+#define LINEADDRESSSHARING_BRIDGEDNEW           0x00000004
+#define LINEADDRESSSHARING_BRIDGEDSHARED        0x00000008
+#define LINEADDRESSSHARING_MONITORED            0x00000010
+
+#define LINEADDRESSSTATE_OTHER                  0x00000001
+#define LINEADDRESSSTATE_DEVSPECIFIC            0x00000002
+#define LINEADDRESSSTATE_INUSEZERO              0x00000004
+#define LINEADDRESSSTATE_INUSEONE               0x00000008
+#define LINEADDRESSSTATE_INUSEMANY              0x00000010
+#define LINEADDRESSSTATE_NUMCALLS               0x00000020
+#define LINEADDRESSSTATE_FORWARD                0x00000040
+#define LINEADDRESSSTATE_TERMINALS              0x00000080
+#define LINEADDRESSSTATE_CAPSCHANGE             0x00000100      // TAPI v1.4
+
+#define LINEADDRFEATURE_FORWARD                 0x00000001
+#define LINEADDRFEATURE_MAKECALL                0x00000002
+#define LINEADDRFEATURE_PICKUP                  0x00000004
+#define LINEADDRFEATURE_SETMEDIACONTROL         0x00000008
+#define LINEADDRFEATURE_SETTERMINAL             0x00000010
+#define LINEADDRFEATURE_SETUPCONF               0x00000020
+#define LINEADDRFEATURE_UNCOMPLETECALL          0x00000040
+#define LINEADDRFEATURE_UNPARK                  0x00000080
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEADDRFEATURE_PICKUPHELD              0x00000100      // TAPI v2.0
+#define LINEADDRFEATURE_PICKUPGROUP             0x00000200      // TAPI v2.0
+#define LINEADDRFEATURE_PICKUPDIRECT            0x00000400      // TAPI v2.0
+#define LINEADDRFEATURE_PICKUPWAITING           0x00000800      // TAPI v2.0
+#define LINEADDRFEATURE_FORWARDFWD              0x00001000      // TAPI v2.0
+#define LINEADDRFEATURE_FORWARDDND              0x00002000      // TAPI v2.0
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEAGENTFEATURE_SETAGENTGROUP          0x00000001      // TAPI v2.0
+#define LINEAGENTFEATURE_SETAGENTSTATE          0x00000002      // TAPI v2.0
+#define LINEAGENTFEATURE_SETAGENTACTIVITY       0x00000004      // TAPI v2.0
+#define LINEAGENTFEATURE_AGENTSPECIFIC          0x00000008      // TAPI v2.0
+#define LINEAGENTFEATURE_GETAGENTACTIVITYLIST   0x00000010      // TAPI v2.0
+#define LINEAGENTFEATURE_GETAGENTGROUP          0x00000020      // TAPI v2.0
+
+#define LINEAGENTSTATE_LOGGEDOFF                0x00000001      // TAPI v2.0
+#define LINEAGENTSTATE_NOTREADY                 0x00000002      // TAPI v2.0
+#define LINEAGENTSTATE_READY                    0x00000004      // TAPI v2.0
+#define LINEAGENTSTATE_BUSYACD                  0x00000008      // TAPI v2.0
+#define LINEAGENTSTATE_BUSYINCOMING             0x00000010      // TAPI v2.0
+#define LINEAGENTSTATE_BUSYOUTBOUND             0x00000020      // TAPI v2.0
+#define LINEAGENTSTATE_BUSYOTHER                0x00000040      // TAPI v2.0
+#define LINEAGENTSTATE_WORKINGAFTERCALL         0x00000080      // TAPI v2.0
+#define LINEAGENTSTATE_UNKNOWN                  0x00000100      // TAPI v2.0
+#define LINEAGENTSTATE_UNAVAIL                  0x00000200      // TAPI v2.0
+
+#define LINEAGENTSTATUS_GROUP                   0x00000001      // TAPI v2.0
+#define LINEAGENTSTATUS_STATE                   0x00000002      // TAPI v2.0
+#define LINEAGENTSTATUS_NEXTSTATE               0x00000004      // TAPI v2.0
+#define LINEAGENTSTATUS_ACTIVITY                0x00000008      // TAPI v2.0
+#define LINEAGENTSTATUS_ACTIVITYLIST            0x00000010      // TAPI v2.0
+#define LINEAGENTSTATUS_GROUPLIST               0x00000020      // TAPI v2.0
+#define LINEAGENTSTATUS_CAPSCHANGE              0x00000040      // TAPI v2.0
+#define LINEAGENTSTATUS_VALIDSTATES             0x00000080      // TAPI v2.0
+#define LINEAGENTSTATUS_VALIDNEXTSTATES         0x00000100      // TAPI v2.0
+#endif
+
+
+#define LINEANSWERMODE_NONE                     0x00000001
+#define LINEANSWERMODE_DROP                     0x00000002
+#define LINEANSWERMODE_HOLD                     0x00000004
+
+#define LINEBEARERMODE_VOICE                    0x00000001
+#define LINEBEARERMODE_SPEECH                   0x00000002
+#define LINEBEARERMODE_MULTIUSE                 0x00000004
+#define LINEBEARERMODE_DATA                     0x00000008
+#define LINEBEARERMODE_ALTSPEECHDATA            0x00000010
+#define LINEBEARERMODE_NONCALLSIGNALING         0x00000020
+#define LINEBEARERMODE_PASSTHROUGH              0x00000040      // TAPI v1.4
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEBEARERMODE_RESTRICTEDDATA           0x00000080      // TAPI v2.0
+#endif
+
+#define LINEBUSYMODE_STATION                    0x00000001
+#define LINEBUSYMODE_TRUNK                      0x00000002
+#define LINEBUSYMODE_UNKNOWN                    0x00000004
+#define LINEBUSYMODE_UNAVAIL                    0x00000008
+
+#define LINECALLCOMPLCOND_BUSY                  0x00000001
+#define LINECALLCOMPLCOND_NOANSWER              0x00000002
+
+#define LINECALLCOMPLMODE_CAMPON                0x00000001
+#define LINECALLCOMPLMODE_CALLBACK              0x00000002
+#define LINECALLCOMPLMODE_INTRUDE               0x00000004
+#define LINECALLCOMPLMODE_MESSAGE               0x00000008
+
+#define LINECALLFEATURE_ACCEPT                  0x00000001
+#define LINECALLFEATURE_ADDTOCONF               0x00000002
+#define LINECALLFEATURE_ANSWER                  0x00000004
+#define LINECALLFEATURE_BLINDTRANSFER           0x00000008
+#define LINECALLFEATURE_COMPLETECALL            0x00000010
+#define LINECALLFEATURE_COMPLETETRANSF          0x00000020
+#define LINECALLFEATURE_DIAL                    0x00000040
+#define LINECALLFEATURE_DROP                    0x00000080
+#define LINECALLFEATURE_GATHERDIGITS            0x00000100
+#define LINECALLFEATURE_GENERATEDIGITS          0x00000200
+#define LINECALLFEATURE_GENERATETONE            0x00000400
+#define LINECALLFEATURE_HOLD                    0x00000800
+#define LINECALLFEATURE_MONITORDIGITS           0x00001000
+#define LINECALLFEATURE_MONITORMEDIA            0x00002000
+#define LINECALLFEATURE_MONITORTONES            0x00004000
+#define LINECALLFEATURE_PARK                    0x00008000
+#define LINECALLFEATURE_PREPAREADDCONF          0x00010000
+#define LINECALLFEATURE_REDIRECT                0x00020000
+#define LINECALLFEATURE_REMOVEFROMCONF          0x00040000
+#define LINECALLFEATURE_SECURECALL              0x00080000
+#define LINECALLFEATURE_SENDUSERUSER            0x00100000
+#define LINECALLFEATURE_SETCALLPARAMS           0x00200000
+#define LINECALLFEATURE_SETMEDIACONTROL         0x00400000
+#define LINECALLFEATURE_SETTERMINAL             0x00800000
+#define LINECALLFEATURE_SETUPCONF               0x01000000
+#define LINECALLFEATURE_SETUPTRANSFER           0x02000000
+#define LINECALLFEATURE_SWAPHOLD                0x04000000
+#define LINECALLFEATURE_UNHOLD                  0x08000000
+#define LINECALLFEATURE_RELEASEUSERUSERINFO     0x10000000      // TAPI v1.4
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECALLFEATURE_SETTREATMENT            0x20000000      // TAPI v2.0
+#define LINECALLFEATURE_SETQOS                  0x40000000      // TAPI v2.0
+#define LINECALLFEATURE_SETCALLDATA             0x80000000      // TAPI v2.0
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECALLFEATURE2_NOHOLDCONFERENCE       0x00000001      // TAPI v2.0
+#define LINECALLFEATURE2_ONESTEPTRANSFER        0x00000002      // TAPI v2.0
+#define LINECALLFEATURE2_COMPLCAMPON            0x00000004      // TAPI v2.0
+#define LINECALLFEATURE2_COMPLCALLBACK          0x00000008      // TAPI v2.0
+#define LINECALLFEATURE2_COMPLINTRUDE           0x00000010      // TAPI v2.0
+#define LINECALLFEATURE2_COMPLMESSAGE           0x00000020      // TAPI v2.0
+#define LINECALLFEATURE2_TRANSFERNORM           0x00000040      // TAPI v2.0
+#define LINECALLFEATURE2_TRANSFERCONF           0x00000080      // TAPI v2.0
+#define LINECALLFEATURE2_PARKDIRECT             0x00000100      // TAPI v2.0
+#define LINECALLFEATURE2_PARKNONDIRECT          0x00000200      // TAPI v2.0
+#endif
+
+#define LINECALLINFOSTATE_OTHER                 0x00000001
+#define LINECALLINFOSTATE_DEVSPECIFIC           0x00000002
+#define LINECALLINFOSTATE_BEARERMODE            0x00000004
+#define LINECALLINFOSTATE_RATE                  0x00000008
+#define LINECALLINFOSTATE_MEDIAMODE             0x00000010
+#define LINECALLINFOSTATE_APPSPECIFIC           0x00000020
+#define LINECALLINFOSTATE_CALLID                0x00000040
+#define LINECALLINFOSTATE_RELATEDCALLID         0x00000080
+#define LINECALLINFOSTATE_ORIGIN                0x00000100
+#define LINECALLINFOSTATE_REASON                0x00000200
+#define LINECALLINFOSTATE_COMPLETIONID          0x00000400
+#define LINECALLINFOSTATE_NUMOWNERINCR          0x00000800
+#define LINECALLINFOSTATE_NUMOWNERDECR          0x00001000
+#define LINECALLINFOSTATE_NUMMONITORS           0x00002000
+#define LINECALLINFOSTATE_TRUNK                 0x00004000
+#define LINECALLINFOSTATE_CALLERID              0x00008000
+#define LINECALLINFOSTATE_CALLEDID              0x00010000
+#define LINECALLINFOSTATE_CONNECTEDID           0x00020000
+#define LINECALLINFOSTATE_REDIRECTIONID         0x00040000
+#define LINECALLINFOSTATE_REDIRECTINGID         0x00080000
+#define LINECALLINFOSTATE_DISPLAY               0x00100000
+#define LINECALLINFOSTATE_USERUSERINFO          0x00200000
+#define LINECALLINFOSTATE_HIGHLEVELCOMP         0x00400000
+#define LINECALLINFOSTATE_LOWLEVELCOMP          0x00800000
+#define LINECALLINFOSTATE_CHARGINGINFO          0x01000000
+#define LINECALLINFOSTATE_TERMINAL              0x02000000
+#define LINECALLINFOSTATE_DIALPARAMS            0x04000000
+#define LINECALLINFOSTATE_MONITORMODES          0x08000000
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECALLINFOSTATE_TREATMENT             0x10000000      // TAPI v2.0
+#define LINECALLINFOSTATE_QOS                   0x20000000      // TAPI v2.0
+#define LINECALLINFOSTATE_CALLDATA              0x40000000      // TAPI v2.0
+#endif
+
+#define LINECALLORIGIN_OUTBOUND                 0x00000001
+#define LINECALLORIGIN_INTERNAL                 0x00000002
+#define LINECALLORIGIN_EXTERNAL                 0x00000004
+#define LINECALLORIGIN_UNKNOWN                  0x00000010
+#define LINECALLORIGIN_UNAVAIL                  0x00000020
+#define LINECALLORIGIN_CONFERENCE               0x00000040
+#define LINECALLORIGIN_INBOUND                  0x00000080      // TAPI v1.4
+
+#define LINECALLPARAMFLAGS_SECURE               0x00000001
+#define LINECALLPARAMFLAGS_IDLE                 0x00000002
+#define LINECALLPARAMFLAGS_BLOCKID              0x00000004
+#define LINECALLPARAMFLAGS_ORIGOFFHOOK          0x00000008
+#define LINECALLPARAMFLAGS_DESTOFFHOOK          0x00000010
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECALLPARAMFLAGS_NOHOLDCONFERENCE     0x00000020      // TAPI v2.0
+#define LINECALLPARAMFLAGS_PREDICTIVEDIAL       0x00000040      // TAPI v2.0
+#define LINECALLPARAMFLAGS_ONESTEPTRANSFER      0x00000080      // TAPI v2.0
+#endif
+
+#define LINECALLPARTYID_BLOCKED                 0x00000001
+#define LINECALLPARTYID_OUTOFAREA               0x00000002
+#define LINECALLPARTYID_NAME                    0x00000004
+#define LINECALLPARTYID_ADDRESS                 0x00000008
+#define LINECALLPARTYID_PARTIAL                 0x00000010
+#define LINECALLPARTYID_UNKNOWN                 0x00000020
+#define LINECALLPARTYID_UNAVAIL                 0x00000040
+
+#define LINECALLPRIVILEGE_NONE                  0x00000001
+#define LINECALLPRIVILEGE_MONITOR               0x00000002
+#define LINECALLPRIVILEGE_OWNER                 0x00000004
+
+#define LINECALLREASON_DIRECT                   0x00000001
+#define LINECALLREASON_FWDBUSY                  0x00000002
+#define LINECALLREASON_FWDNOANSWER              0x00000004
+#define LINECALLREASON_FWDUNCOND                0x00000008
+#define LINECALLREASON_PICKUP                   0x00000010
+#define LINECALLREASON_UNPARK                   0x00000020
+#define LINECALLREASON_REDIRECT                 0x00000040
+#define LINECALLREASON_CALLCOMPLETION           0x00000080
+#define LINECALLREASON_TRANSFER                 0x00000100
+#define LINECALLREASON_REMINDER                 0x00000200
+#define LINECALLREASON_UNKNOWN                  0x00000400
+#define LINECALLREASON_UNAVAIL                  0x00000800
+#define LINECALLREASON_INTRUDE                  0x00001000      // TAPI v1.4
+#define LINECALLREASON_PARKED                   0x00002000      // TAPI v1.4
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECALLREASON_CAMPEDON                 0x00004000      // TAPI v2.0
+#define LINECALLREASON_ROUTEREQUEST             0x00008000      // TAPI v2.0
+#endif
+
+#define LINECALLSELECT_LINE                     0x00000001
+#define LINECALLSELECT_ADDRESS                  0x00000002
+#define LINECALLSELECT_CALL                     0x00000004
+
+#define LINECALLSTATE_IDLE                      0x00000001
+#define LINECALLSTATE_OFFERING                  0x00000002
+#define LINECALLSTATE_ACCEPTED                  0x00000004
+#define LINECALLSTATE_DIALTONE                  0x00000008
+#define LINECALLSTATE_DIALING                   0x00000010
+#define LINECALLSTATE_RINGBACK                  0x00000020
+#define LINECALLSTATE_BUSY                      0x00000040
+#define LINECALLSTATE_SPECIALINFO               0x00000080
+#define LINECALLSTATE_CONNECTED                 0x00000100
+#define LINECALLSTATE_PROCEEDING                0x00000200
+#define LINECALLSTATE_ONHOLD                    0x00000400
+#define LINECALLSTATE_CONFERENCED               0x00000800
+#define LINECALLSTATE_ONHOLDPENDCONF            0x00001000
+#define LINECALLSTATE_ONHOLDPENDTRANSFER        0x00002000
+#define LINECALLSTATE_DISCONNECTED              0x00004000
+#define LINECALLSTATE_UNKNOWN                   0x00008000
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECALLTREATMENT_SILENCE               0x00000001      // TAPI v2.0
+#define LINECALLTREATMENT_RINGBACK              0x00000002      // TAPI v2.0
+#define LINECALLTREATMENT_BUSY                  0x00000003      // TAPI v2.0
+#define LINECALLTREATMENT_MUSIC                 0x00000004      // TAPI v2.0
+#endif
+
+#define LINECARDOPTION_PREDEFINED               0x00000001      // TAPI v1.4
+#define LINECARDOPTION_HIDDEN                   0x00000002      // TAPI v1.4
+
+#define LINECONNECTEDMODE_ACTIVE                0x00000001      // TAPI v1.4
+#define LINECONNECTEDMODE_INACTIVE              0x00000002      // TAPI v1.4
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINECONNECTEDMODE_ACTIVEHELD            0x00000004      // TAPI v2.0
+#define LINECONNECTEDMODE_INACTIVEHELD          0x00000008      // TAPI v2.0
+#define LINECONNECTEDMODE_CONFIRMED             0x00000010      // TAPI v2.0
+#endif
+
+#define LINEDEVCAPFLAGS_CROSSADDRCONF           0x00000001
+#define LINEDEVCAPFLAGS_HIGHLEVCOMP             0x00000002
+#define LINEDEVCAPFLAGS_LOWLEVCOMP              0x00000004
+#define LINEDEVCAPFLAGS_MEDIACONTROL            0x00000008
+#define LINEDEVCAPFLAGS_MULTIPLEADDR            0x00000010
+#define LINEDEVCAPFLAGS_CLOSEDROP               0x00000020
+#define LINEDEVCAPFLAGS_DIALBILLING             0x00000040
+#define LINEDEVCAPFLAGS_DIALQUIET               0x00000080
+#define LINEDEVCAPFLAGS_DIALDIALTONE            0x00000100
+
+#define LINEDEVSTATE_OTHER                      0x00000001
+#define LINEDEVSTATE_RINGING                    0x00000002
+#define LINEDEVSTATE_CONNECTED                  0x00000004
+#define LINEDEVSTATE_DISCONNECTED               0x00000008
+#define LINEDEVSTATE_MSGWAITON                  0x00000010
+#define LINEDEVSTATE_MSGWAITOFF                 0x00000020
+#define LINEDEVSTATE_INSERVICE                  0x00000040
+#define LINEDEVSTATE_OUTOFSERVICE               0x00000080
+#define LINEDEVSTATE_MAINTENANCE                0x00000100
+#define LINEDEVSTATE_OPEN                       0x00000200
+#define LINEDEVSTATE_CLOSE                      0x00000400
+#define LINEDEVSTATE_NUMCALLS                   0x00000800
+#define LINEDEVSTATE_NUMCOMPLETIONS             0x00001000
+#define LINEDEVSTATE_TERMINALS                  0x00002000
+#define LINEDEVSTATE_ROAMMODE                   0x00004000
+#define LINEDEVSTATE_BATTERY                    0x00008000
+#define LINEDEVSTATE_SIGNAL                     0x00010000
+#define LINEDEVSTATE_DEVSPECIFIC                0x00020000
+#define LINEDEVSTATE_REINIT                     0x00040000
+#define LINEDEVSTATE_LOCK                       0x00080000
+#define LINEDEVSTATE_CAPSCHANGE                 0x00100000      // TAPI v1.4
+#define LINEDEVSTATE_CONFIGCHANGE               0x00200000      // TAPI v1.4
+#define LINEDEVSTATE_TRANSLATECHANGE            0x00400000      // TAPI v1.4
+#define LINEDEVSTATE_COMPLCANCEL                0x00800000      // TAPI v1.4
+#define LINEDEVSTATE_REMOVED                    0x01000000      // TAPI v1.4
+
+#define LINEDEVSTATUSFLAGS_CONNECTED            0x00000001
+#define LINEDEVSTATUSFLAGS_MSGWAIT              0x00000002
+#define LINEDEVSTATUSFLAGS_INSERVICE            0x00000004
+#define LINEDEVSTATUSFLAGS_LOCKED               0x00000008
+
+#define LINEDIALTONEMODE_NORMAL                 0x00000001
+#define LINEDIALTONEMODE_SPECIAL                0x00000002
+#define LINEDIALTONEMODE_INTERNAL               0x00000004
+#define LINEDIALTONEMODE_EXTERNAL               0x00000008
+#define LINEDIALTONEMODE_UNKNOWN                0x00000010
+#define LINEDIALTONEMODE_UNAVAIL                0x00000020
+    
+#define LINEDIGITMODE_PULSE                     0x00000001
+#define LINEDIGITMODE_DTMF                      0x00000002
+#define LINEDIGITMODE_DTMFEND                   0x00000004
+    
+#define LINEDISCONNECTMODE_NORMAL               0x00000001
+#define LINEDISCONNECTMODE_UNKNOWN              0x00000002
+#define LINEDISCONNECTMODE_REJECT               0x00000004
+#define LINEDISCONNECTMODE_PICKUP               0x00000008
+#define LINEDISCONNECTMODE_FORWARDED            0x00000010
+#define LINEDISCONNECTMODE_BUSY                 0x00000020
+#define LINEDISCONNECTMODE_NOANSWER             0x00000040
+#define LINEDISCONNECTMODE_BADADDRESS           0x00000080
+#define LINEDISCONNECTMODE_UNREACHABLE          0x00000100
+#define LINEDISCONNECTMODE_CONGESTION           0x00000200
+#define LINEDISCONNECTMODE_INCOMPATIBLE         0x00000400
+#define LINEDISCONNECTMODE_UNAVAIL              0x00000800
+#define LINEDISCONNECTMODE_NODIALTONE           0x00001000      // TAPI v1.4
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEDISCONNECTMODE_NUMBERCHANGED        0x00002000      // TAPI v2.0
+#define LINEDISCONNECTMODE_OUTOFORDER           0x00004000      // TAPI v2.0
+#define LINEDISCONNECTMODE_TEMPFAILURE          0x00008000      // TAPI v2.0
+#define LINEDISCONNECTMODE_QOSUNAVAIL           0x00010000      // TAPI v2.0
+#define LINEDISCONNECTMODE_BLOCKED              0x00020000      // TAPI v2.0
+#define LINEDISCONNECTMODE_DONOTDISTURB         0x00040000      // TAPI v2.0
+#define LINEDISCONNECTMODE_CANCELLED            0x00080000      // TAPI v2.0
+#endif
+
+#define LINEERR_ALLOCATED                       0x80000001
+#define LINEERR_BADDEVICEID                     0x80000002
+#define LINEERR_BEARERMODEUNAVAIL               0x80000003
+#define LINEERR_CALLUNAVAIL                     0x80000005
+#define LINEERR_COMPLETIONOVERRUN               0x80000006
+#define LINEERR_CONFERENCEFULL                  0x80000007
+#define LINEERR_DIALBILLING                     0x80000008
+#define LINEERR_DIALDIALTONE                    0x80000009
+#define LINEERR_DIALPROMPT                      0x8000000A
+#define LINEERR_DIALQUIET                       0x8000000B
+#define LINEERR_INCOMPATIBLEAPIVERSION          0x8000000C
+#define LINEERR_INCOMPATIBLEEXTVERSION          0x8000000D
+#define LINEERR_INIFILECORRUPT                  0x8000000E
+#define LINEERR_INUSE                           0x8000000F
+#define LINEERR_INVALADDRESS                    0x80000010
+#define LINEERR_INVALADDRESSID                  0x80000011
+#define LINEERR_INVALADDRESSMODE                0x80000012
+#define LINEERR_INVALADDRESSSTATE               0x80000013
+#define LINEERR_INVALAPPHANDLE                  0x80000014
+#define LINEERR_INVALAPPNAME                    0x80000015
+#define LINEERR_INVALBEARERMODE                 0x80000016
+#define LINEERR_INVALCALLCOMPLMODE              0x80000017
+#define LINEERR_INVALCALLHANDLE                 0x80000018
+#define LINEERR_INVALCALLPARAMS                 0x80000019
+#define LINEERR_INVALCALLPRIVILEGE              0x8000001A
+#define LINEERR_INVALCALLSELECT                 0x8000001B
+#define LINEERR_INVALCALLSTATE                  0x8000001C
+#define LINEERR_INVALCALLSTATELIST              0x8000001D
+#define LINEERR_INVALCARD                       0x8000001E
+#define LINEERR_INVALCOMPLETIONID               0x8000001F
+#define LINEERR_INVALCONFCALLHANDLE             0x80000020
+#define LINEERR_INVALCONSULTCALLHANDLE          0x80000021
+#define LINEERR_INVALCOUNTRYCODE                0x80000022
+#define LINEERR_INVALDEVICECLASS                0x80000023
+#define LINEERR_INVALDEVICEHANDLE               0x80000024
+#define LINEERR_INVALDIALPARAMS                 0x80000025
+#define LINEERR_INVALDIGITLIST                  0x80000026
+#define LINEERR_INVALDIGITMODE                  0x80000027
+#define LINEERR_INVALDIGITS                     0x80000028
+#define LINEERR_INVALEXTVERSION                 0x80000029
+#define LINEERR_INVALGROUPID                    0x8000002A
+#define LINEERR_INVALLINEHANDLE                 0x8000002B
+#define LINEERR_INVALLINESTATE                  0x8000002C
+#define LINEERR_INVALLOCATION                   0x8000002D
+#define LINEERR_INVALMEDIALIST                  0x8000002E
+#define LINEERR_INVALMEDIAMODE                  0x8000002F
+#define LINEERR_INVALMESSAGEID                  0x80000030
+#define LINEERR_INVALPARAM                      0x80000032
+#define LINEERR_INVALPARKID                     0x80000033
+#define LINEERR_INVALPARKMODE                   0x80000034
+#define LINEERR_INVALPOINTER                    0x80000035
+#define LINEERR_INVALPRIVSELECT                 0x80000036
+#define LINEERR_INVALRATE                       0x80000037
+#define LINEERR_INVALREQUESTMODE                0x80000038
+#define LINEERR_INVALTERMINALID                 0x80000039
+#define LINEERR_INVALTERMINALMODE               0x8000003A
+#define LINEERR_INVALTIMEOUT                    0x8000003B
+#define LINEERR_INVALTONE                       0x8000003C
+#define LINEERR_INVALTONELIST                   0x8000003D
+#define LINEERR_INVALTONEMODE                   0x8000003E
+#define LINEERR_INVALTRANSFERMODE               0x8000003F
+#define LINEERR_LINEMAPPERFAILED                0x80000040
+#define LINEERR_NOCONFERENCE                    0x80000041
+#define LINEERR_NODEVICE                        0x80000042
+#define LINEERR_NODRIVER                        0x80000043
+#define LINEERR_NOMEM                           0x80000044
+#define LINEERR_NOREQUEST                       0x80000045
+#define LINEERR_NOTOWNER                        0x80000046
+#define LINEERR_NOTREGISTERED                   0x80000047
+#define LINEERR_OPERATIONFAILED                 0x80000048
+#define LINEERR_OPERATIONUNAVAIL                0x80000049
+#define LINEERR_RATEUNAVAIL                     0x8000004A
+#define LINEERR_RESOURCEUNAVAIL                 0x8000004B
+#define LINEERR_REQUESTOVERRUN                  0x8000004C
+#define LINEERR_STRUCTURETOOSMALL               0x8000004D
+#define LINEERR_TARGETNOTFOUND                  0x8000004E
+#define LINEERR_TARGETSELF                      0x8000004F
+#define LINEERR_UNINITIALIZED                   0x80000050
+#define LINEERR_USERUSERINFOTOOBIG              0x80000051
+#define LINEERR_REINIT                          0x80000052
+#define LINEERR_ADDRESSBLOCKED                  0x80000053
+#define LINEERR_BILLINGREJECTED                 0x80000054
+#define LINEERR_INVALFEATURE                    0x80000055
+#define LINEERR_NOMULTIPLEINSTANCE              0x80000056
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEERR_INVALAGENTID                    0x80000057      // TAPI v2.0
+#define LINEERR_INVALAGENTGROUP                 0x80000058      // TAPI v2.0
+#define LINEERR_INVALPASSWORD                   0x80000059      // TAPI v2.0
+#define LINEERR_INVALAGENTSTATE                 0x8000005A      // TAPI v2.0
+#define LINEERR_INVALAGENTACTIVITY              0x8000005B      // TAPI v2.0
+#define LINEERR_DIALVOICEDETECT                 0x8000005C      // TAPI v2.0
+
+//                                                                        ;internal
+// IMPORTANT!  IMPORTANT!  IMPORTANT!                                     ;internal
+// if adding new LINEERR_ constants, the tapierr.mc file must be updated  ;internal
+// with the new messages!                                                 ;internal
+//                                                                        ;internal
+
+#endif
+
+#define LINEFEATURE_DEVSPECIFIC                 0x00000001
+#define LINEFEATURE_DEVSPECIFICFEAT             0x00000002
+#define LINEFEATURE_FORWARD                     0x00000004
+#define LINEFEATURE_MAKECALL                    0x00000008
+#define LINEFEATURE_SETMEDIACONTROL             0x00000010
+#define LINEFEATURE_SETTERMINAL                 0x00000020
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEFEATURE_SETDEVSTATUS                0x00000040      // TAPI v2.0
+#define LINEFEATURE_FORWARDFWD                  0x00000080      // TAPI v2.0
+#define LINEFEATURE_FORWARDDND                  0x00000100      // TAPI v2.0
+#endif
+
+#define LINEFORWARDMODE_UNCOND                  0x00000001
+#define LINEFORWARDMODE_UNCONDINTERNAL          0x00000002
+#define LINEFORWARDMODE_UNCONDEXTERNAL          0x00000004
+#define LINEFORWARDMODE_UNCONDSPECIFIC          0x00000008
+#define LINEFORWARDMODE_BUSY                    0x00000010
+#define LINEFORWARDMODE_BUSYINTERNAL            0x00000020
+#define LINEFORWARDMODE_BUSYEXTERNAL            0x00000040
+#define LINEFORWARDMODE_BUSYSPECIFIC            0x00000080
+#define LINEFORWARDMODE_NOANSW                  0x00000100
+#define LINEFORWARDMODE_NOANSWINTERNAL          0x00000200
+#define LINEFORWARDMODE_NOANSWEXTERNAL          0x00000400
+#define LINEFORWARDMODE_NOANSWSPECIFIC          0x00000800
+#define LINEFORWARDMODE_BUSYNA                  0x00001000
+#define LINEFORWARDMODE_BUSYNAINTERNAL          0x00002000
+#define LINEFORWARDMODE_BUSYNAEXTERNAL          0x00004000
+#define LINEFORWARDMODE_BUSYNASPECIFIC          0x00008000
+#define LINEFORWARDMODE_UNKNOWN                 0x00010000      // TAPI v1.4
+#define LINEFORWARDMODE_UNAVAIL                 0x00020000      // TAPI v1.4
+
+#define LINEGATHERTERM_BUFFERFULL               0x00000001
+#define LINEGATHERTERM_TERMDIGIT                0x00000002
+#define LINEGATHERTERM_FIRSTTIMEOUT             0x00000004
+#define LINEGATHERTERM_INTERTIMEOUT             0x00000008
+#define LINEGATHERTERM_CANCEL                   0x00000010
+
+#define LINEGENERATETERM_DONE                   0x00000001
+#define LINEGENERATETERM_CANCEL                 0x00000002
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+//
+// These constants are mutually exclusive - there's no way to specify more
+// than one at a time (and it doesn't make sense, either) so they're
+// ordinal rather than bits.
+//
+#define LINEINITIALIZEEXOPTION_USEHIDDENWINDOW      0x00000001  // TAPI v2.0
+#define LINEINITIALIZEEXOPTION_USEEVENT             0x00000002  // TAPI v2.0
+#define LINEINITIALIZEEXOPTION_USECOMPLETIONPORT    0x00000003  // TAPI v2.0
+#endif
+
+#define LINELOCATIONOPTION_PULSEDIAL            0x00000001      // TAPI v1.4
+
+#define LINEMAPPER                              0xFFFFFFFF
+
+#define LINEMEDIACONTROL_NONE                   0x00000001
+#define LINEMEDIACONTROL_START                  0x00000002
+#define LINEMEDIACONTROL_RESET                  0x00000004
+#define LINEMEDIACONTROL_PAUSE                  0x00000008
+#define LINEMEDIACONTROL_RESUME                 0x00000010
+#define LINEMEDIACONTROL_RATEUP                 0x00000020
+#define LINEMEDIACONTROL_RATEDOWN               0x00000040
+#define LINEMEDIACONTROL_RATENORMAL             0x00000080
+#define LINEMEDIACONTROL_VOLUMEUP               0x00000100
+#define LINEMEDIACONTROL_VOLUMEDOWN             0x00000200
+#define LINEMEDIACONTROL_VOLUMENORMAL           0x00000400
+
+#define LINEMEDIAMODE_UNKNOWN                   0x00000002
+#define LINEMEDIAMODE_INTERACTIVEVOICE          0x00000004
+#define LINEMEDIAMODE_AUTOMATEDVOICE            0x00000008
+#define LINEMEDIAMODE_DATAMODEM                 0x00000010
+#define LINEMEDIAMODE_G3FAX                     0x00000020
+#define LINEMEDIAMODE_TDD                       0x00000040
+#define LINEMEDIAMODE_G4FAX                     0x00000080
+#define LINEMEDIAMODE_DIGITALDATA               0x00000100
+#define LINEMEDIAMODE_TELETEX                   0x00000200
+#define LINEMEDIAMODE_VIDEOTEX                  0x00000400
+#define LINEMEDIAMODE_TELEX                     0x00000800
+#define LINEMEDIAMODE_MIXED                     0x00001000
+#define LINEMEDIAMODE_ADSI                      0x00002000
+#define LINEMEDIAMODE_VOICEVIEW                 0x00004000      // TAPI v1.4
+#define LAST_LINEMEDIAMODE                      0x00004000
+
+#define LINEOFFERINGMODE_ACTIVE                 0x00000001      // TAPI v1.4
+#define LINEOFFERINGMODE_INACTIVE               0x00000002      // TAPI v1.4
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEOPENOPTION_SINGLEADDRESS            0x80000000      // TAPI v2.0
+#define LINEOPENOPTION_PROXY                    0x40000000      // TAPI v2.0
+#endif
+
+#define LINEPARKMODE_DIRECTED                   0x00000001
+#define LINEPARKMODE_NONDIRECTED                0x00000002
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINEPROXYREQUEST_SETAGENTGROUP          0x00000001      // TAPI v2.0
+#define LINEPROXYREQUEST_SETAGENTSTATE          0x00000002      // TAPI v2.0
+#define LINEPROXYREQUEST_SETAGENTACTIVITY       0x00000003      // TAPI v2.0
+#define LINEPROXYREQUEST_GETAGENTCAPS           0x00000004      // TAPI v2.0
+#define LINEPROXYREQUEST_GETAGENTSTATUS         0x00000005      // TAPI v2.0
+#define LINEPROXYREQUEST_AGENTSPECIFIC          0x00000006      // TAPI v2.0
+#define LINEPROXYREQUEST_GETAGENTACTIVITYLIST   0x00000007      // TAPI v2.0
+#define LINEPROXYREQUEST_GETAGENTGROUPLIST      0x00000008      // TAPI v2.0
+#endif
+
+#define LINEREMOVEFROMCONF_NONE                 0x00000001
+#define LINEREMOVEFROMCONF_LAST                 0x00000002
+#define LINEREMOVEFROMCONF_ANY                  0x00000003
+
+#define LINEREQUESTMODE_MAKECALL                0x00000001
+#define LINEREQUESTMODE_MEDIACALL               0x00000002
+#define LINEREQUESTMODE_DROP                    0x00000004
+#define LAST_LINEREQUESTMODE                    LINEREQUESTMODE_MEDIACALL
+
+#define LINEROAMMODE_UNKNOWN                    0x00000001
+#define LINEROAMMODE_UNAVAIL                    0x00000002
+#define LINEROAMMODE_HOME                       0x00000004
+#define LINEROAMMODE_ROAMA                      0x00000008
+#define LINEROAMMODE_ROAMB                      0x00000010
+
+#define LINESPECIALINFO_NOCIRCUIT               0x00000001
+#define LINESPECIALINFO_CUSTIRREG               0x00000002
+#define LINESPECIALINFO_REORDER                 0x00000004
+#define LINESPECIALINFO_UNKNOWN                 0x00000008
+#define LINESPECIALINFO_UNAVAIL                 0x00000010
+
+#define LINETERMDEV_PHONE                       0x00000001
+#define LINETERMDEV_HEADSET                     0x00000002
+#define LINETERMDEV_SPEAKER                     0x00000004
+
+#define LINETERMMODE_BUTTONS                    0x00000001
+#define LINETERMMODE_LAMPS                      0x00000002
+#define LINETERMMODE_DISPLAY                    0x00000004
+#define LINETERMMODE_RINGER                     0x00000008
+#define LINETERMMODE_HOOKSWITCH                 0x00000010
+#define LINETERMMODE_MEDIATOLINE                0x00000020
+#define LINETERMMODE_MEDIAFROMLINE              0x00000040
+#define LINETERMMODE_MEDIABIDIRECT              0x00000080
+
+#define LINETERMSHARING_PRIVATE                 0x00000001
+#define LINETERMSHARING_SHAREDEXCL              0x00000002
+#define LINETERMSHARING_SHAREDCONF              0x00000004
+
+#define LINETOLLLISTOPTION_ADD                  0x00000001
+#define LINETOLLLISTOPTION_REMOVE               0x00000002
+
+#define LINETONEMODE_CUSTOM                     0x00000001
+#define LINETONEMODE_RINGBACK                   0x00000002
+#define LINETONEMODE_BUSY                       0x00000004
+#define LINETONEMODE_BEEP                       0x00000008
+#define LINETONEMODE_BILLING                    0x00000010
+
+#define LINETRANSFERMODE_TRANSFER               0x00000001
+#define LINETRANSFERMODE_CONFERENCE             0x00000002
+
+#define LINETRANSLATEOPTION_CARDOVERRIDE        0x00000001
+#define LINETRANSLATEOPTION_CANCELCALLWAITING   0x00000002      // TAPI v1.4
+#define LINETRANSLATEOPTION_FORCELOCAL          0x00000004      // TAPI v1.4
+#define LINETRANSLATEOPTION_FORCELD             0x00000008      // TAPI v1.4
+
+#define LINETRANSLATERESULT_CANONICAL           0x00000001
+#define LINETRANSLATERESULT_INTERNATIONAL       0x00000002
+#define LINETRANSLATERESULT_LONGDISTANCE        0x00000004
+#define LINETRANSLATERESULT_LOCAL               0x00000008
+#define LINETRANSLATERESULT_INTOLLLIST          0x00000010
+#define LINETRANSLATERESULT_NOTINTOLLLIST       0x00000020
+#define LINETRANSLATERESULT_DIALBILLING         0x00000040
+#define LINETRANSLATERESULT_DIALQUIET           0x00000080
+#define LINETRANSLATERESULT_DIALDIALTONE        0x00000100
+#define LINETRANSLATERESULT_DIALPROMPT          0x00000200
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINETRANSLATERESULT_VOICEDETECT         0x00000400      // TAPI v2.0
+#endif
+
+#define PHONEBUTTONFUNCTION_UNKNOWN             0x00000000
+#define PHONEBUTTONFUNCTION_CONFERENCE          0x00000001
+#define PHONEBUTTONFUNCTION_TRANSFER            0x00000002
+#define PHONEBUTTONFUNCTION_DROP                0x00000003
+#define PHONEBUTTONFUNCTION_HOLD                0x00000004
+#define PHONEBUTTONFUNCTION_RECALL              0x00000005
+#define PHONEBUTTONFUNCTION_DISCONNECT          0x00000006
+#define PHONEBUTTONFUNCTION_CONNECT             0x00000007
+#define PHONEBUTTONFUNCTION_MSGWAITON           0x00000008
+#define PHONEBUTTONFUNCTION_MSGWAITOFF          0x00000009
+#define PHONEBUTTONFUNCTION_SELECTRING          0x0000000A
+#define PHONEBUTTONFUNCTION_ABBREVDIAL          0x0000000B
+#define PHONEBUTTONFUNCTION_FORWARD             0x0000000C
+#define PHONEBUTTONFUNCTION_PICKUP              0x0000000D
+#define PHONEBUTTONFUNCTION_RINGAGAIN           0x0000000E
+#define PHONEBUTTONFUNCTION_PARK                0x0000000F
+#define PHONEBUTTONFUNCTION_REJECT              0x00000010
+#define PHONEBUTTONFUNCTION_REDIRECT            0x00000011
+#define PHONEBUTTONFUNCTION_MUTE                0x00000012
+#define PHONEBUTTONFUNCTION_VOLUMEUP            0x00000013
+#define PHONEBUTTONFUNCTION_VOLUMEDOWN          0x00000014
+#define PHONEBUTTONFUNCTION_SPEAKERON           0x00000015
+#define PHONEBUTTONFUNCTION_SPEAKEROFF          0x00000016
+#define PHONEBUTTONFUNCTION_FLASH               0x00000017
+#define PHONEBUTTONFUNCTION_DATAON              0x00000018
+#define PHONEBUTTONFUNCTION_DATAOFF             0x00000019
+#define PHONEBUTTONFUNCTION_DONOTDISTURB        0x0000001A
+#define PHONEBUTTONFUNCTION_INTERCOM            0x0000001B
+#define PHONEBUTTONFUNCTION_BRIDGEDAPP          0x0000001C
+#define PHONEBUTTONFUNCTION_BUSY                0x0000001D
+#define PHONEBUTTONFUNCTION_CALLAPP             0x0000001E
+#define PHONEBUTTONFUNCTION_DATETIME            0x0000001F
+#define PHONEBUTTONFUNCTION_DIRECTORY           0x00000020
+#define PHONEBUTTONFUNCTION_COVER               0x00000021
+#define PHONEBUTTONFUNCTION_CALLID              0x00000022
+#define PHONEBUTTONFUNCTION_LASTNUM             0x00000023
+#define PHONEBUTTONFUNCTION_NIGHTSRV            0x00000024
+#define PHONEBUTTONFUNCTION_SENDCALLS           0x00000025
+#define PHONEBUTTONFUNCTION_MSGINDICATOR        0x00000026
+#define PHONEBUTTONFUNCTION_REPDIAL             0x00000027
+#define PHONEBUTTONFUNCTION_SETREPDIAL          0x00000028
+#define PHONEBUTTONFUNCTION_SYSTEMSPEED         0x00000029
+#define PHONEBUTTONFUNCTION_STATIONSPEED        0x0000002A
+#define PHONEBUTTONFUNCTION_CAMPON              0x0000002B
+#define PHONEBUTTONFUNCTION_SAVEREPEAT          0x0000002C
+#define PHONEBUTTONFUNCTION_QUEUECALL           0x0000002D
+#define PHONEBUTTONFUNCTION_NONE                0x0000002E
+
+#define PHONEBUTTONMODE_DUMMY                   0x00000001
+#define PHONEBUTTONMODE_CALL                    0x00000002
+#define PHONEBUTTONMODE_FEATURE                 0x00000004
+#define PHONEBUTTONMODE_KEYPAD                  0x00000008
+#define PHONEBUTTONMODE_LOCAL                   0x00000010
+#define PHONEBUTTONMODE_DISPLAY                 0x00000020
+
+#define PHONEBUTTONSTATE_UP                     0x00000001
+#define PHONEBUTTONSTATE_DOWN                   0x00000002
+#define PHONEBUTTONSTATE_UNKNOWN                0x00000004      // TAPI v1.4
+#define PHONEBUTTONSTATE_UNAVAIL                0x00000008      // TAPI v1.4
+
+#define PHONEERR_ALLOCATED                      0x90000001
+#define PHONEERR_BADDEVICEID                    0x90000002
+#define PHONEERR_INCOMPATIBLEAPIVERSION         0x90000003
+#define PHONEERR_INCOMPATIBLEEXTVERSION         0x90000004
+#define PHONEERR_INIFILECORRUPT                 0x90000005
+#define PHONEERR_INUSE                          0x90000006
+#define PHONEERR_INVALAPPHANDLE                 0x90000007
+#define PHONEERR_INVALAPPNAME                   0x90000008
+#define PHONEERR_INVALBUTTONLAMPID              0x90000009
+#define PHONEERR_INVALBUTTONMODE                0x9000000A
+#define PHONEERR_INVALBUTTONSTATE               0x9000000B
+#define PHONEERR_INVALDATAID                    0x9000000C
+#define PHONEERR_INVALDEVICECLASS               0x9000000D
+#define PHONEERR_INVALEXTVERSION                0x9000000E
+#define PHONEERR_INVALHOOKSWITCHDEV             0x9000000F
+#define PHONEERR_INVALHOOKSWITCHMODE            0x90000010
+#define PHONEERR_INVALLAMPMODE                  0x90000011
+#define PHONEERR_INVALPARAM                     0x90000012
+#define PHONEERR_INVALPHONEHANDLE               0x90000013
+#define PHONEERR_INVALPHONESTATE                0x90000014
+#define PHONEERR_INVALPOINTER                   0x90000015
+#define PHONEERR_INVALPRIVILEGE                 0x90000016
+#define PHONEERR_INVALRINGMODE                  0x90000017
+#define PHONEERR_NODEVICE                       0x90000018
+#define PHONEERR_NODRIVER                       0x90000019
+#define PHONEERR_NOMEM                          0x9000001A
+#define PHONEERR_NOTOWNER                       0x9000001B
+#define PHONEERR_OPERATIONFAILED                0x9000001C
+#define PHONEERR_OPERATIONUNAVAIL               0x9000001D
+#define PHONEERR_RESOURCEUNAVAIL                0x9000001F
+#define PHONEERR_REQUESTOVERRUN                 0x90000020
+#define PHONEERR_STRUCTURETOOSMALL              0x90000021
+#define PHONEERR_UNINITIALIZED                  0x90000022
+#define PHONEERR_REINIT                         0x90000023
+
+//                                                                        ;internal
+// IMPORTANT!  IMPORTANT!  IMPORTANT!                                     ;internal
+// if adding new PHONEERR_ constants, the tapierr.mc file must be updated ;internal
+// with the new messages!                                                 ;internal
+//                                                                        ;internal
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define PHONEFEATURE_GETBUTTONINFO              0x00000001      // TAPI v2.0
+#define PHONEFEATURE_GETDATA                    0x00000002      // TAPI v2.0
+#define PHONEFEATURE_GETDISPLAY                 0x00000004      // TAPI v2.0
+#define PHONEFEATURE_GETGAINHANDSET             0x00000008      // TAPI v2.0
+#define PHONEFEATURE_GETGAINSPEAKER             0x00000010      // TAPI v2.0
+#define PHONEFEATURE_GETGAINHEADSET             0x00000020      // TAPI v2.0
+#define PHONEFEATURE_GETHOOKSWITCHHANDSET       0x00000040      // TAPI v2.0
+#define PHONEFEATURE_GETHOOKSWITCHSPEAKER       0x00000080      // TAPI v2.0
+#define PHONEFEATURE_GETHOOKSWITCHHEADSET       0x00000100      // TAPI v2.0
+#define PHONEFEATURE_GETLAMP                    0x00000200      // TAPI v2.0
+#define PHONEFEATURE_GETRING                    0x00000400      // TAPI v2.0
+#define PHONEFEATURE_GETVOLUMEHANDSET           0x00000800      // TAPI v2.0
+#define PHONEFEATURE_GETVOLUMESPEAKER           0x00001000      // TAPI v2.0
+#define PHONEFEATURE_GETVOLUMEHEADSET           0x00002000      // TAPI v2.0
+#define PHONEFEATURE_SETBUTTONINFO              0x00004000      // TAPI v2.0
+#define PHONEFEATURE_SETDATA                    0x00008000      // TAPI v2.0
+#define PHONEFEATURE_SETDISPLAY                 0x00010000      // TAPI v2.0
+#define PHONEFEATURE_SETGAINHANDSET             0x00020000      // TAPI v2.0
+#define PHONEFEATURE_SETGAINSPEAKER             0x00040000      // TAPI v2.0
+#define PHONEFEATURE_SETGAINHEADSET             0x00080000      // TAPI v2.0
+#define PHONEFEATURE_SETHOOKSWITCHHANDSET       0x00100000      // TAPI v2.0
+#define PHONEFEATURE_SETHOOKSWITCHSPEAKER       0x00200000      // TAPI v2.0
+#define PHONEFEATURE_SETHOOKSWITCHHEADSET       0x00400000      // TAPI v2.0
+#define PHONEFEATURE_SETLAMP                    0x00800000      // TAPI v2.0
+#define PHONEFEATURE_SETRING                    0x01000000      // TAPI v2.0
+#define PHONEFEATURE_SETVOLUMEHANDSET           0x02000000      // TAPI v2.0
+#define PHONEFEATURE_SETVOLUMESPEAKER           0x04000000      // TAPI v2.0
+#define PHONEFEATURE_SETVOLUMEHEADSET           0x08000000      // TAPI v2.0
+#endif
+
+#define PHONEHOOKSWITCHDEV_HANDSET              0x00000001
+#define PHONEHOOKSWITCHDEV_SPEAKER              0x00000002
+#define PHONEHOOKSWITCHDEV_HEADSET              0x00000004
+
+#define PHONEHOOKSWITCHMODE_ONHOOK              0x00000001
+#define PHONEHOOKSWITCHMODE_MIC                 0x00000002
+#define PHONEHOOKSWITCHMODE_SPEAKER             0x00000004
+#define PHONEHOOKSWITCHMODE_MICSPEAKER          0x00000008
+#define PHONEHOOKSWITCHMODE_UNKNOWN             0x00000010
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW     0x00000001  // TAPI v2.0
+#define PHONEINITIALIZEEXOPTION_USEEVENT            0x00000002  // TAPI v2.0
+#define PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT   0x00000003  // TAPI v2.0
+#endif
+
+#define PHONELAMPMODE_DUMMY                     0x00000001
+#define PHONELAMPMODE_OFF                       0x00000002
+#define PHONELAMPMODE_STEADY                    0x00000004
+#define PHONELAMPMODE_WINK                      0x00000008
+#define PHONELAMPMODE_FLASH                     0x00000010
+#define PHONELAMPMODE_FLUTTER                   0x00000020
+#define PHONELAMPMODE_BROKENFLUTTER             0x00000040
+#define PHONELAMPMODE_UNKNOWN                   0x00000080
+
+#define PHONEPRIVILEGE_MONITOR                  0x00000001
+#define PHONEPRIVILEGE_OWNER                    0x00000002
+
+#define PHONESTATE_OTHER                        0x00000001
+#define PHONESTATE_CONNECTED                    0x00000002
+#define PHONESTATE_DISCONNECTED                 0x00000004
+#define PHONESTATE_OWNER                        0x00000008
+#define PHONESTATE_MONITORS                     0x00000010
+#define PHONESTATE_DISPLAY                      0x00000020
+#define PHONESTATE_LAMP                         0x00000040
+#define PHONESTATE_RINGMODE                     0x00000080
+#define PHONESTATE_RINGVOLUME                   0x00000100
+#define PHONESTATE_HANDSETHOOKSWITCH            0x00000200
+#define PHONESTATE_HANDSETVOLUME                0x00000400
+#define PHONESTATE_HANDSETGAIN                  0x00000800
+#define PHONESTATE_SPEAKERHOOKSWITCH            0x00001000
+#define PHONESTATE_SPEAKERVOLUME                0x00002000
+#define PHONESTATE_SPEAKERGAIN                  0x00004000
+#define PHONESTATE_HEADSETHOOKSWITCH            0x00008000
+#define PHONESTATE_HEADSETVOLUME                0x00010000
+#define PHONESTATE_HEADSETGAIN                  0x00020000
+#define PHONESTATE_SUSPEND                      0x00040000
+#define PHONESTATE_RESUME                       0x00080000
+#define PHONESTATE_DEVSPECIFIC                  0x00100000
+#define PHONESTATE_REINIT                       0x00200000
+#define PHONESTATE_CAPSCHANGE                   0x00400000      // TAPI v1.4
+#define PHONESTATE_REMOVED                      0x00800000      // TAPI v1.4
+
+#define PHONESTATUSFLAGS_CONNECTED              0x00000001
+#define PHONESTATUSFLAGS_SUSPENDED              0x00000002
+
+#define STRINGFORMAT_ASCII                      0x00000001
+#define STRINGFORMAT_DBCS                       0x00000002
+#define STRINGFORMAT_UNICODE                    0x00000003
+#define STRINGFORMAT_BINARY                     0x00000004
+
+#define TAPI_REPLY                              WM_USER + 99
+
+#define TAPIERR_CONNECTED                       0L
+#define TAPIERR_DROPPED                         -1L
+#define TAPIERR_NOREQUESTRECIPIENT              -2L
+#define TAPIERR_REQUESTQUEUEFULL                -3L
+#define TAPIERR_INVALDESTADDRESS                -4L
+#define TAPIERR_INVALWINDOWHANDLE               -5L
+#define TAPIERR_INVALDEVICECLASS                -6L
+#define TAPIERR_INVALDEVICEID                   -7L
+#define TAPIERR_DEVICECLASSUNAVAIL              -8L
+#define TAPIERR_DEVICEIDUNAVAIL                 -9L
+#define TAPIERR_DEVICEINUSE                     -10L
+#define TAPIERR_DESTBUSY                        -11L
+#define TAPIERR_DESTNOANSWER                    -12L
+#define TAPIERR_DESTUNAVAIL                     -13L
+#define TAPIERR_UNKNOWNWINHANDLE                -14L
+#define TAPIERR_UNKNOWNREQUESTID                -15L
+#define TAPIERR_REQUESTFAILED                   -16L
+#define TAPIERR_REQUESTCANCELLED                -17L
+#define TAPIERR_INVALPOINTER                    -18L
+
+//                                                                        ;internal
+// IMPORTANT!  IMPORTANT!  IMPORTANT!                                     ;internal
+// if adding new TAPIERR_ constants, the tapierr.mc file must be updated  ;internal
+// with the new messages!                                                 ;internal
+//                                                                        ;internal
+
+#define TAPIMAXDESTADDRESSSIZE                  80L
+#define TAPIMAXAPPNAMESIZE                      40L
+#define TAPIMAXCALLEDPARTYSIZE                  40L
+#define TAPIMAXCOMMENTSIZE                      80L
+#define TAPIMAXDEVICECLASSSIZE                  40L
+#define TAPIMAXDEVICEIDSIZE                     40L
+
+
+
+typedef struct lineaddresscaps_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwLineDeviceID;
+    DWORD       dwAddressSize;
+    DWORD       dwAddressOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+    DWORD       dwAddressSharing;
+    DWORD       dwAddressStates;
+    DWORD       dwCallInfoStates;
+    DWORD       dwCallerIDFlags;
+    DWORD       dwCalledIDFlags;
+    DWORD       dwConnectedIDFlags;
+    DWORD       dwRedirectionIDFlags;
+    DWORD       dwRedirectingIDFlags;
+    DWORD       dwCallStates;
+    DWORD       dwDialToneModes;
+    DWORD       dwBusyModes;
+    DWORD       dwSpecialInfo;
+    DWORD       dwDisconnectModes;
+    DWORD       dwMaxNumActiveCalls;
+    DWORD       dwMaxNumOnHoldCalls;
+    DWORD       dwMaxNumOnHoldPendingCalls;
+    DWORD       dwMaxNumConference;
+    DWORD       dwMaxNumTransConf;
+    DWORD       dwAddrCapFlags;
+    DWORD       dwCallFeatures;
+    DWORD       dwRemoveFromConfCaps;
+    DWORD       dwRemoveFromConfState;
+    DWORD       dwTransferModes;
+    DWORD       dwParkModes;
+    DWORD       dwForwardModes;
+    DWORD       dwMaxForwardEntries;
+    DWORD       dwMaxSpecificEntries;
+    DWORD       dwMinFwdNumRings;
+    DWORD       dwMaxFwdNumRings;
+    DWORD       dwMaxCallCompletions;
+    DWORD       dwCallCompletionConds;
+    DWORD       dwCallCompletionModes;
+    DWORD       dwNumCompletionMessages;
+    DWORD       dwCompletionMsgTextEntrySize;
+    DWORD       dwCompletionMsgTextSize;
+    DWORD       dwCompletionMsgTextOffset;
+
+    DWORD       dwAddressFeatures;                              // TAPI v1.4
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwPredictiveAutoTransferStates;                 // TAPI v2.0
+    DWORD       dwNumCallTreatments;                            // TAPI v2.0
+    DWORD       dwCallTreatmentListSize;                        // TAPI v2.0
+    DWORD       dwCallTreatmentListOffset;                      // TAPI v2.0
+    DWORD       dwDeviceClassesSize;                            // TAPI v2.0
+    DWORD       dwDeviceClassesOffset;                          // TAPI v2.0
+    DWORD       dwMaxCallDataSize;                              // TAPI v2.0
+    DWORD       dwCallFeatures2;                                // TAPI v2.0
+    DWORD       dwMaxNoAnswerTimeout;                           // TAPI v2.0
+    DWORD       dwConnectedModes;                               // TAPI v2.0
+    DWORD       dwOfferingModes;                                // TAPI v2.0
+    DWORD       dwAvailableMediaModes;                          // TAPI v2.0
+#endif
+
+} LINEADDRESSCAPS, FAR *LPLINEADDRESSCAPS;
+
+typedef struct lineaddressstatus_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwNumInUse;
+    DWORD       dwNumActiveCalls;
+    DWORD       dwNumOnHoldCalls;
+    DWORD       dwNumOnHoldPendCalls;
+    DWORD       dwAddressFeatures;
+    DWORD       dwNumRingsNoAnswer;
+    DWORD       dwForwardNumEntries;
+    DWORD       dwForwardSize;
+    DWORD       dwForwardOffset;
+    DWORD       dwTerminalModesSize;
+    DWORD       dwTerminalModesOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+} LINEADDRESSSTATUS, FAR *LPLINEADDRESSSTATUS;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct lineagentactivityentry_tag
+{
+    DWORD       dwID;                                           // TAPI v2.0
+    DWORD       dwNameSize;                                     // TAPI v2.0
+    DWORD       dwNameOffset;                                   // TAPI v2.0
+
+} LINEAGENTACTIVITYENTRY, *LPLINEAGENTACTIVITYENTRY;
+
+typedef struct lineagentactivitylist_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v2.0
+    DWORD       dwNeededSize;                                   // TAPI v2.0
+    DWORD       dwUsedSize;                                     // TAPI v2.0
+    DWORD       dwNumEntries;                                   // TAPI v2.0
+    DWORD       dwListSize;                                     // TAPI v2.0
+    DWORD       dwListOffset;                                   // TAPI v2.0
+
+} LINEAGENTACTIVITYLIST, *LPLINEAGENTACTIVITYLIST;
+
+typedef struct lineagentcaps_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v2.0
+    DWORD       dwNeededSize;                                   // TAPI v2.0
+    DWORD       dwUsedSize;                                     // TAPI v2.0
+    DWORD       dwAgentHandlerInfoSize;                         // TAPI v2.0
+    DWORD       dwAgentHandlerInfoOffset;                       // TAPI v2.0
+    DWORD       dwCapsVersion;                                  // TAPI v2.0
+    DWORD       dwFeatures;                                     // TAPI v2.0
+    DWORD       dwStates;                                       // TAPI v2.0
+    DWORD       dwNextStates;                                   // TAPI v2.0
+    DWORD       dwMaxNumGroupEntries;                           // TAPI v2.0
+    DWORD       dwAgentStatusMessages;                          // TAPI v2.0
+    DWORD       dwNumAgentExtensionIDs;                         // TAPI v2.0
+    DWORD       dwAgentExtensionIDListSize;                     // TAPI v2.0
+    DWORD       dwAgentExtensionIDListOffset;                   // TAPI v2.0
+
+} LINEAGENTCAPS, *LPLINEAGENTCAPS;
+
+typedef struct lineagentgroupentry_tag
+{
+    struct
+    {
+        DWORD   dwGroupID1;                                     // TAPI v2.0
+        DWORD   dwGroupID2;                                     // TAPI v2.0
+        DWORD   dwGroupID3;                                     // TAPI v2.0
+        DWORD   dwGroupID4;                                     // TAPI v2.0
+
+    } GroupID;
+
+    DWORD       dwNameSize;                                     // TAPI v2.0
+    DWORD       dwNameOffset;                                   // TAPI v2.0
+
+} LINEAGENTGROUPENTRY, *LPLINEAGENTGROUPENTRY;
+
+typedef struct lineagentgrouplist_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v2.0
+    DWORD       dwNeededSize;                                   // TAPI v2.0
+    DWORD       dwUsedSize;                                     // TAPI v2.0
+    DWORD       dwNumEntries;                                   // TAPI v2.0
+    DWORD       dwListSize;                                     // TAPI v2.0
+    DWORD       dwListOffset;                                   // TAPI v2.0
+
+} LINEAGENTGROUPLIST, *LPLINEAGENTGROUPLIST;
+
+typedef struct lineagentstatus_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v2.0
+    DWORD       dwNeededSize;                                   // TAPI v2.0
+    DWORD       dwUsedSize;                                     // TAPI v2.0
+    DWORD       dwNumEntries;                                   // TAPI v2.0
+    DWORD       dwGroupListSize;                                // TAPI v2.0
+    DWORD       dwGroupListOffset;                              // TAPI v2.0
+    DWORD       dwState;                                        // TAPI v2.0
+    DWORD       dwNextState;                                    // TAPI v2.0
+    DWORD       dwActivityID;                                   // TAPI v2.0
+    DWORD       dwActivitySize;                                 // TAPI v2.0
+    DWORD       dwActivityOffset;                               // TAPI v2.0
+    DWORD       dwAgentFeatures;                                // TAPI v2.0
+    DWORD       dwValidStates;                                  // TAPI v2.0
+    DWORD       dwValidNextStates;                              // TAPI v2.0
+
+} LINEAGENTSTATUS, *LPLINEAGENTSTATUS;
+
+typedef struct lineappinfo_tag
+{
+    DWORD       dwMachineNameSize;                              // TAPI v2.0
+    DWORD       dwMachineNameOffset;                            // TAPI v2.0
+    DWORD       dwUserNameSize;                                 // TAPI v2.0
+    DWORD       dwUserNameOffset;                               // TAPI v2.0
+    DWORD       dwModuleFilenameSize;                           // TAPI v2.0
+    DWORD       dwModuleFilenameOffset;                         // TAPI v2.0
+    DWORD       dwFriendlyNameSize;                             // TAPI v2.0
+    DWORD       dwFriendlyNameOffset;                           // TAPI v2.0
+    DWORD       dwMediaModes;                                   // TAPI v2.0
+    DWORD       dwAddressID;                                    // TAPI v2.0
+
+} LINEAPPINFO, *LPLINEAPPINFO;
+#endif
+
+
+typedef struct linedialparams_tag
+{
+    DWORD       dwDialPause;
+    DWORD       dwDialSpeed;
+    DWORD       dwDigitDuration;
+    DWORD       dwWaitForDialtone;
+
+} LINEDIALPARAMS, FAR *LPLINEDIALPARAMS;
+
+typedef struct linecallinfo_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    HLINE       hLine;
+    DWORD       dwLineDeviceID;
+    DWORD       dwAddressID;
+    DWORD       dwBearerMode;
+    DWORD       dwRate;
+    DWORD       dwMediaMode;
+    DWORD       dwAppSpecific;
+    DWORD       dwCallID;
+    DWORD       dwRelatedCallID;
+    DWORD       dwCallParamFlags;
+    DWORD       dwCallStates;
+    DWORD       dwMonitorDigitModes;
+    DWORD       dwMonitorMediaModes;
+    LINEDIALPARAMS  DialParams;
+    DWORD       dwOrigin;
+    DWORD       dwReason;
+    DWORD       dwCompletionID;
+    DWORD       dwNumOwners;
+    DWORD       dwNumMonitors;
+    DWORD       dwCountryCode;
+    DWORD       dwTrunk;
+    DWORD       dwCallerIDFlags;
+    DWORD       dwCallerIDSize;
+    DWORD       dwCallerIDOffset;
+    DWORD       dwCallerIDNameSize;
+    DWORD       dwCallerIDNameOffset;
+    DWORD       dwCalledIDFlags;
+    DWORD       dwCalledIDSize;
+    DWORD       dwCalledIDOffset;
+    DWORD       dwCalledIDNameSize;
+    DWORD       dwCalledIDNameOffset;
+    DWORD       dwConnectedIDFlags;
+    DWORD       dwConnectedIDSize;
+    DWORD       dwConnectedIDOffset;
+    DWORD       dwConnectedIDNameSize;
+    DWORD       dwConnectedIDNameOffset;
+    DWORD       dwRedirectionIDFlags;
+    DWORD       dwRedirectionIDSize;
+    DWORD       dwRedirectionIDOffset;
+    DWORD       dwRedirectionIDNameSize;
+    DWORD       dwRedirectionIDNameOffset;
+    DWORD       dwRedirectingIDFlags;
+    DWORD       dwRedirectingIDSize;
+    DWORD       dwRedirectingIDOffset;
+    DWORD       dwRedirectingIDNameSize;
+    DWORD       dwRedirectingIDNameOffset;
+    DWORD       dwAppNameSize;
+    DWORD       dwAppNameOffset;
+    DWORD       dwDisplayableAddressSize;
+    DWORD       dwDisplayableAddressOffset;
+    DWORD       dwCalledPartySize;
+    DWORD       dwCalledPartyOffset;
+    DWORD       dwCommentSize;
+    DWORD       dwCommentOffset;
+    DWORD       dwDisplaySize;
+    DWORD       dwDisplayOffset;
+    DWORD       dwUserUserInfoSize;
+    DWORD       dwUserUserInfoOffset;
+    DWORD       dwHighLevelCompSize;
+    DWORD       dwHighLevelCompOffset;
+    DWORD       dwLowLevelCompSize;
+    DWORD       dwLowLevelCompOffset;
+    DWORD       dwChargingInfoSize;
+    DWORD       dwChargingInfoOffset;
+    DWORD       dwTerminalModesSize;
+    DWORD       dwTerminalModesOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwCallTreatment;                                // TAPI v2.0
+    DWORD       dwCallDataSize;                                 // TAPI v2.0
+    DWORD       dwCallDataOffset;                               // TAPI v2.0
+    DWORD       dwSendingFlowspecSize;                          // TAPI v2.0
+    DWORD       dwSendingFlowspecOffset;                        // TAPI v2.0
+    DWORD       dwReceivingFlowspecSize;                        // TAPI v2.0
+    DWORD       dwReceivingFlowspecOffset;                      // TAPI v2.0
+#endif
+
+} LINECALLINFO, FAR *LPLINECALLINFO;
+
+typedef struct linecalllist_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwCallsNumEntries;
+    DWORD       dwCallsSize;
+    DWORD       dwCallsOffset;
+
+} LINECALLLIST, FAR *LPLINECALLLIST;
+
+typedef struct linecallparams_tag               // Defaults:
+{
+    DWORD       dwTotalSize;                    // ---------
+    DWORD       dwBearerMode;                   // voice
+    DWORD       dwMinRate;                      // (3.1kHz)
+    DWORD       dwMaxRate;                      // (3.1kHz)
+    DWORD       dwMediaMode;                    // interactiveVoice
+    DWORD       dwCallParamFlags;               // 0
+    DWORD       dwAddressMode;                  // addressID
+    DWORD       dwAddressID;                    // (any available)
+    LINEDIALPARAMS  DialParams;                 // (0, 0, 0, 0)
+    DWORD       dwOrigAddressSize;              // 0
+    DWORD       dwOrigAddressOffset;
+    DWORD       dwDisplayableAddressSize;
+    DWORD       dwDisplayableAddressOffset;
+    DWORD       dwCalledPartySize;              // 0
+    DWORD       dwCalledPartyOffset;
+    DWORD       dwCommentSize;                  // 0
+    DWORD       dwCommentOffset;
+    DWORD       dwUserUserInfoSize;             // 0
+    DWORD       dwUserUserInfoOffset;
+    DWORD       dwHighLevelCompSize;            // 0
+    DWORD       dwHighLevelCompOffset;
+    DWORD       dwLowLevelCompSize;             // 0
+    DWORD       dwLowLevelCompOffset;
+    DWORD       dwDevSpecificSize;              // 0
+    DWORD       dwDevSpecificOffset;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwPredictiveAutoTransferStates;                 // TAPI v2.0
+    DWORD       dwTargetAddressSize;                            // TAPI v2.0
+    DWORD       dwTargetAddressOffset;                          // TAPI v2.0
+    DWORD       dwSendingFlowspecSize;                          // TAPI v2.0
+    DWORD       dwSendingFlowspecOffset;                        // TAPI v2.0
+    DWORD       dwReceivingFlowspecSize;                        // TAPI v2.0
+    DWORD       dwReceivingFlowspecOffset;                      // TAPI v2.0
+    DWORD       dwDeviceClassSize;                              // TAPI v2.0
+    DWORD       dwDeviceClassOffset;                            // TAPI v2.0
+    DWORD       dwDeviceConfigSize;                             // TAPI v2.0
+    DWORD       dwDeviceConfigOffset;                           // TAPI v2.0
+    DWORD       dwCallDataSize;                                 // TAPI v2.0
+    DWORD       dwCallDataOffset;                               // TAPI v2.0
+    DWORD       dwNoAnswerTimeout;                              // TAPI v2.0
+    DWORD       dwCallingPartyIDSize;                           // TAPI v2.0
+    DWORD       dwCallingPartyIDOffset;                         // TAPI v2.0
+#endif
+
+} LINECALLPARAMS, FAR *LPLINECALLPARAMS;
+
+typedef struct linecallstatus_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwCallState;
+    DWORD       dwCallStateMode;
+    DWORD       dwCallPrivilege;
+    DWORD       dwCallFeatures;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwCallFeatures2;                                // TAPI v2.0
+#if WIN32
+    SYSTEMTIME  tStateEntryTime;                                // TAPI v2.0
+#else
+    WORD        tStateEntryTime[8];                             // TAPI v2.0
+#endif
+#endif
+
+} LINECALLSTATUS, FAR *LPLINECALLSTATUS;
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct linecalltreatmententry_tag
+{
+    DWORD       dwCallTreatmentID;                              // TAPI v2.0
+    DWORD       dwCallTreatmentNameSize;                        // TAPI v2.0
+    DWORD       dwCallTreatmentNameOffset;                      // TAPI v2.0
+
+} LINECALLTREATMENTENTRY, FAR *LPLINECALLTREATMENTENTRY;
+#endif
+
+
+typedef struct linecardentry_tag
+{
+    DWORD       dwPermanentCardID;
+    DWORD       dwCardNameSize;
+    DWORD       dwCardNameOffset;
+    DWORD       dwCardNumberDigits;                             // TAPI v1.4
+    DWORD       dwSameAreaRuleSize;                             // TAPI v1.4
+    DWORD       dwSameAreaRuleOffset;                           // TAPI v1.4
+    DWORD       dwLongDistanceRuleSize;                         // TAPI v1.4
+    DWORD       dwLongDistanceRuleOffset;                       // TAPI v1.4
+    DWORD       dwInternationalRuleSize;                        // TAPI v1.4
+    DWORD       dwInternationalRuleOffset;                      // TAPI v1.4
+    DWORD       dwOptions;                                      // TAPI v1.4
+
+} LINECARDENTRY, FAR *LPLINECARDENTRY;
+
+typedef struct linecountryentry_tag
+{
+    DWORD       dwCountryID;                                    // TAPI v1.4
+    DWORD       dwCountryCode;                                  // TAPI v1.4
+    DWORD       dwNextCountryID;                                // TAPI v1.4
+    DWORD       dwCountryNameSize;                              // TAPI v1.4
+    DWORD       dwCountryNameOffset;                            // TAPI v1.4
+    DWORD       dwSameAreaRuleSize;                             // TAPI v1.4
+    DWORD       dwSameAreaRuleOffset;                           // TAPI v1.4
+    DWORD       dwLongDistanceRuleSize;                         // TAPI v1.4
+    DWORD       dwLongDistanceRuleOffset;                       // TAPI v1.4
+    DWORD       dwInternationalRuleSize;                        // TAPI v1.4
+    DWORD       dwInternationalRuleOffset;                      // TAPI v1.4
+
+} LINECOUNTRYENTRY, FAR *LPLINECOUNTRYENTRY;
+
+typedef struct linecountrylist_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v1.4
+    DWORD       dwNeededSize;                                   // TAPI v1.4
+    DWORD       dwUsedSize;                                     // TAPI v1.4
+    DWORD       dwNumCountries;                                 // TAPI v1.4
+    DWORD       dwCountryListSize;                              // TAPI v1.4
+    DWORD       dwCountryListOffset;                            // TAPI v1.4
+
+} LINECOUNTRYLIST, FAR *LPLINECOUNTRYLIST;
+
+typedef struct linedevcaps_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwProviderInfoSize;
+    DWORD       dwProviderInfoOffset;
+    DWORD       dwSwitchInfoSize;
+    DWORD       dwSwitchInfoOffset;
+    DWORD       dwPermanentLineID;
+    DWORD       dwLineNameSize;
+    DWORD       dwLineNameOffset;
+    DWORD       dwStringFormat;
+    DWORD       dwAddressModes;
+    DWORD       dwNumAddresses;
+    DWORD       dwBearerModes;
+    DWORD       dwMaxRate;
+    DWORD       dwMediaModes;
+    DWORD       dwGenerateToneModes;
+    DWORD       dwGenerateToneMaxNumFreq;
+    DWORD       dwGenerateDigitModes;
+    DWORD       dwMonitorToneMaxNumFreq;
+    DWORD       dwMonitorToneMaxNumEntries;
+    DWORD       dwMonitorDigitModes;
+    DWORD       dwGatherDigitsMinTimeout;
+    DWORD       dwGatherDigitsMaxTimeout;
+    DWORD       dwMedCtlDigitMaxListSize;
+    DWORD       dwMedCtlMediaMaxListSize;
+    DWORD       dwMedCtlToneMaxListSize;
+    DWORD       dwMedCtlCallStateMaxListSize;
+    DWORD       dwDevCapFlags;
+    DWORD       dwMaxNumActiveCalls;
+    DWORD       dwAnswerMode;
+    DWORD       dwRingModes;
+    DWORD       dwLineStates;
+    DWORD       dwUUIAcceptSize;
+    DWORD       dwUUIAnswerSize;
+    DWORD       dwUUIMakeCallSize;
+    DWORD       dwUUIDropSize;
+    DWORD       dwUUISendUserUserInfoSize;
+    DWORD       dwUUICallInfoSize;
+    LINEDIALPARAMS  MinDialParams;
+    LINEDIALPARAMS  MaxDialParams;
+    LINEDIALPARAMS  DefaultDialParams;
+    DWORD       dwNumTerminals;
+    DWORD       dwTerminalCapsSize;
+    DWORD       dwTerminalCapsOffset;
+    DWORD       dwTerminalTextEntrySize;
+    DWORD       dwTerminalTextSize;
+    DWORD       dwTerminalTextOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+    DWORD       dwLineFeatures;                                 // TAPI v1.4
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwSettableDevStatus;                            // TAPI v2.0
+    DWORD       dwDeviceClassesSize;                            // TAPI v2.0
+    DWORD       dwDeviceClassesOffset;                          // TAPI v2.0
+#endif
+
+} LINEDEVCAPS, FAR *LPLINEDEVCAPS;
+    
+typedef struct linedevstatus_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwNumOpens;
+    DWORD       dwOpenMediaModes;
+    DWORD       dwNumActiveCalls;
+    DWORD       dwNumOnHoldCalls;
+    DWORD       dwNumOnHoldPendCalls;
+    DWORD       dwLineFeatures;
+    DWORD       dwNumCallCompletions;
+    DWORD       dwRingMode;
+    DWORD       dwSignalLevel;
+    DWORD       dwBatteryLevel;
+    DWORD       dwRoamMode;
+    DWORD       dwDevStatusFlags;
+    DWORD       dwTerminalModesSize;
+    DWORD       dwTerminalModesOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwAvailableMediaModes;                          // TAPI v2.0
+    DWORD       dwAppInfoSize;                                  // TAPI v2.0
+    DWORD       dwAppInfoOffset;                                // TAPI v2.0
+#endif
+
+} LINEDEVSTATUS, FAR *LPLINEDEVSTATUS;
+
+typedef struct lineextensionid_tag
+{
+    DWORD       dwExtensionID0;
+    DWORD       dwExtensionID1;
+    DWORD       dwExtensionID2;
+    DWORD       dwExtensionID3;
+
+} LINEEXTENSIONID, FAR *LPLINEEXTENSIONID;
+
+typedef struct lineforward_tag
+{
+    DWORD       dwForwardMode;
+    DWORD       dwCallerAddressSize;
+    DWORD       dwCallerAddressOffset;
+    DWORD       dwDestCountryCode;
+    DWORD       dwDestAddressSize;
+    DWORD       dwDestAddressOffset;
+
+} LINEFORWARD, FAR *LPLINEFORWARD;
+
+typedef struct lineforwardlist_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNumEntries;
+    LINEFORWARD ForwardList[1];
+
+} LINEFORWARDLIST, FAR *LPLINEFORWARDLIST;
+
+typedef struct linegeneratetone_tag
+{
+    DWORD       dwFrequency;
+    DWORD       dwCadenceOn;
+    DWORD       dwCadenceOff;
+    DWORD       dwVolume;
+
+} LINEGENERATETONE, FAR *LPLINEGENERATETONE;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct lineinitializeexparams_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v2.0
+    DWORD       dwNeededSize;                                   // TAPI v2.0
+    DWORD       dwUsedSize;                                     // TAPI v2.0
+    DWORD       dwOptions;                                      // TAPI v2.0
+
+    union
+    {
+        HANDLE  hEvent;                                         // TAPI v2.0
+        HANDLE  hCompletionPort;                                // TAPI v2.0
+
+    } Handles;
+
+    DWORD       dwCompletionKey;                                // TAPI v2.0
+
+} LINEINITIALIZEEXPARAMS, FAR *LPLINEINITIALIZEEXPARAMS;
+#endif
+
+typedef struct linelocationentry_tag
+{
+    DWORD       dwPermanentLocationID;
+    DWORD       dwLocationNameSize;
+    DWORD       dwLocationNameOffset;
+    DWORD       dwCountryCode;
+    DWORD       dwCityCodeSize;
+    DWORD       dwCityCodeOffset;
+    DWORD       dwPreferredCardID;
+
+    DWORD       dwLocalAccessCodeSize;                          // TAPI v1.4
+    DWORD       dwLocalAccessCodeOffset;                        // TAPI v1.4
+    DWORD       dwLongDistanceAccessCodeSize;                   // TAPI v1.4
+    DWORD       dwLongDistanceAccessCodeOffset;                 // TAPI v1.4
+    DWORD       dwTollPrefixListSize;                           // TAPI v1.4
+    DWORD       dwTollPrefixListOffset;                         // TAPI v1.4
+    DWORD       dwCountryID;                                    // TAPI v1.4
+    DWORD       dwOptions;                                      // TAPI v1.4
+    DWORD       dwCancelCallWaitingSize;                        // TAPI v1.4
+    DWORD       dwCancelCallWaitingOffset;                      // TAPI v1.4
+
+} LINELOCATIONENTRY, FAR *LPLINELOCATIONENTRY;
+
+typedef struct linemediacontrolcallstate_tag
+{
+    DWORD       dwCallStates;
+    DWORD       dwMediaControl;
+
+} LINEMEDIACONTROLCALLSTATE, FAR *LPLINEMEDIACONTROLCALLSTATE;
+
+typedef struct linemediacontroldigit_tag
+{
+    DWORD       dwDigit;
+    DWORD       dwDigitModes;
+    DWORD       dwMediaControl;
+
+} LINEMEDIACONTROLDIGIT, FAR *LPLINEMEDIACONTROLDIGIT;
+
+typedef struct linemediacontrolmedia_tag
+{
+    DWORD       dwMediaModes;
+    DWORD       dwDuration;
+    DWORD       dwMediaControl;
+
+} LINEMEDIACONTROLMEDIA, FAR *LPLINEMEDIACONTROLMEDIA;
+
+typedef struct linemediacontroltone_tag
+{
+    DWORD       dwAppSpecific;
+    DWORD       dwDuration;
+    DWORD       dwFrequency1;
+    DWORD       dwFrequency2;
+    DWORD       dwFrequency3;
+    DWORD       dwMediaControl;
+
+} LINEMEDIACONTROLTONE, FAR *LPLINEMEDIACONTROLTONE;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct linemessage_tag
+{
+    DWORD       hDevice;                                        // TAPI v2.0
+    DWORD       dwMessageID;                                    // TAPI v2.0
+    DWORD       dwCallbackInstance;                             // TAPI v2.0
+    DWORD       dwParam1;                                       // TAPI v2.0
+    DWORD       dwParam2;                                       // TAPI v2.0
+    DWORD       dwParam3;                                       // TAPI v2.0
+
+} LINEMESSAGE, FAR *LPLINEMESSAGE;
+#endif
+
+typedef struct linemonitortone_tag
+{
+    DWORD       dwAppSpecific;
+    DWORD       dwDuration;
+    DWORD       dwFrequency1;
+    DWORD       dwFrequency2;
+    DWORD       dwFrequency3;
+
+} LINEMONITORTONE, FAR *LPLINEMONITORTONE;
+
+typedef struct lineproviderentry_tag
+{
+    DWORD       dwPermanentProviderID;                          // TAPI v1.4
+    DWORD       dwProviderFilenameSize;                         // TAPI v1.4
+    DWORD       dwProviderFilenameOffset;                       // TAPI v1.4
+
+} LINEPROVIDERENTRY, FAR *LPLINEPROVIDERENTRY;
+
+typedef struct lineproviderlist_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v1.4
+    DWORD       dwNeededSize;                                   // TAPI v1.4
+    DWORD       dwUsedSize;                                     // TAPI v1.4
+    DWORD       dwNumProviders;                                 // TAPI v1.4
+    DWORD       dwProviderListSize;                             // TAPI v1.4
+    DWORD       dwProviderListOffset;                           // TAPI v1.4
+
+} LINEPROVIDERLIST, FAR *LPLINEPROVIDERLIST;
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct lineproxyrequest_tag
+{
+    DWORD       dwSize;                                         // TAPI v2.0
+    DWORD       dwClientMachineNameSize;                        // TAPI v2.0
+    DWORD       dwClientMachineNameOffset;                      // TAPI v2.0
+    DWORD       dwClientUserNameSize;                           // TAPI v2.0
+    DWORD       dwClientUserNameOffset;                         // TAPI v2.0
+    DWORD       dwClientAppAPIVersion;                          // TAPI v2.0
+    DWORD       dwRequestType;                                  // TAPI v2.0
+
+    union
+    {
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        LINEAGENTGROUPLIST      GroupList;                      // TAPI v2.0
+
+    } SetAgentGroup;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        DWORD                   dwAgentState;                   // TAPI v2.0
+        DWORD                   dwNextAgentState;               // TAPI v2.0
+
+    } SetAgentState;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        DWORD                   dwActivityID;                   // TAPI v2.0
+
+    } SetAgentActivity;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        LINEAGENTCAPS           AgentCaps;                      // TAPI v2.0
+
+    } GetAgentCaps;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        LINEAGENTSTATUS         AgentStatus;                    // TAPI v2.0
+
+    } GetAgentStatus;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        DWORD                   dwAgentExtensionIDIndex;        // TAPI v2.0
+        DWORD                   dwSize;                         // TAPI v2.0
+        BYTE                    Params[1];                      // TAPI v2.0
+
+    } AgentSpecific;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        LINEAGENTACTIVITYLIST   ActivityList;                   // TAPI v2.0
+
+    } GetAgentActivityList;
+
+    struct
+    {
+        DWORD                   dwAddressID;                    // TAPI v2.0
+        LINEAGENTGROUPLIST      GroupList;                      // TAPI v2.0
+
+    } GetAgentGroupList;
+    }; //ProxyRequestType;
+
+} LINEPROXYREQUEST, *LPLINEPROXYREQUEST;
+#endif
+
+
+typedef struct linereqmakecall_tag
+{
+    char        szDestAddress[TAPIMAXDESTADDRESSSIZE];
+    char        szAppName[TAPIMAXAPPNAMESIZE];
+    char        szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+    char        szComment[TAPIMAXCOMMENTSIZE];
+
+} LINEREQMAKECALL, FAR *LPLINEREQMAKECALL;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct linereqmakecallW_tag
+{
+    WCHAR       szDestAddress[TAPIMAXDESTADDRESSSIZE];
+    WCHAR       szAppName[TAPIMAXAPPNAMESIZE];
+    WCHAR       szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+    WCHAR       szComment[TAPIMAXCOMMENTSIZE];
+
+} LINEREQMAKECALLW, FAR *LPLINEREQMAKECALLW;
+#endif
+
+#ifdef UNICODE
+#define LINEREQMAKECALL LINEREQMAKECALLW
+#endif
+
+typedef struct linereqmediacall_tag
+{
+    HWND        hWnd;
+    WPARAM      wRequestID;
+    char        szDeviceClass[TAPIMAXDEVICECLASSSIZE];
+    unsigned char   ucDeviceID[TAPIMAXDEVICEIDSIZE];
+    DWORD       dwSize;
+    DWORD       dwSecure;
+    char        szDestAddress[TAPIMAXDESTADDRESSSIZE];
+    char        szAppName[TAPIMAXAPPNAMESIZE];
+    char        szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+    char        szComment[TAPIMAXCOMMENTSIZE];
+
+} LINEREQMEDIACALL, FAR *LPLINEREQMEDIACALL;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct linereqmediacallW_tag
+{
+    HWND        hWnd;
+    WPARAM      wRequestID;
+    WCHAR       szDeviceClass[TAPIMAXDEVICECLASSSIZE];
+    unsigned char   ucDeviceID[TAPIMAXDEVICEIDSIZE];
+    DWORD       dwSize;
+    DWORD       dwSecure;
+    WCHAR       szDestAddress[TAPIMAXDESTADDRESSSIZE];
+    WCHAR       szAppName[TAPIMAXAPPNAMESIZE];
+    WCHAR       szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+    WCHAR       szComment[TAPIMAXCOMMENTSIZE];
+
+} LINEREQMEDIACALLW, FAR *LPLINEREQMEDIACALLW;
+#endif
+
+#ifdef UNICODE
+#define LINEREQMEDIACALL LINEREQMEDIACALLW
+#endif
+
+
+typedef struct linetermcaps_tag
+{
+    DWORD       dwTermDev;
+    DWORD       dwTermModes;
+    DWORD       dwTermSharing;
+
+} LINETERMCAPS, FAR *LPLINETERMCAPS;
+
+typedef struct linetranslatecaps_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwNumLocations;
+    DWORD       dwLocationListSize;
+    DWORD       dwLocationListOffset;
+    DWORD       dwCurrentLocationID;
+    DWORD       dwNumCards;
+    DWORD       dwCardListSize;
+    DWORD       dwCardListOffset;
+    DWORD       dwCurrentPreferredCardID;
+
+} LINETRANSLATECAPS, FAR *LPLINETRANSLATECAPS;
+
+typedef struct linetranslateoutput_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwDialableStringSize;
+    DWORD       dwDialableStringOffset;
+    DWORD       dwDisplayableStringSize;
+    DWORD       dwDisplayableStringOffset;
+    DWORD       dwCurrentCountry;
+    DWORD       dwDestCountry;
+    DWORD       dwTranslateResults;
+
+} LINETRANSLATEOUTPUT, FAR *LPLINETRANSLATEOUTPUT;
+
+typedef struct phonebuttoninfo_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwButtonMode;
+    DWORD       dwButtonFunction;
+    DWORD       dwButtonTextSize;
+    DWORD       dwButtonTextOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+    DWORD       dwButtonState;                                  // TAPI v1.4
+
+} PHONEBUTTONINFO, FAR *LPPHONEBUTTONINFO;
+
+typedef struct phonecaps_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwProviderInfoSize;
+    DWORD       dwProviderInfoOffset;
+    DWORD       dwPhoneInfoSize;
+    DWORD       dwPhoneInfoOffset;
+    DWORD       dwPermanentPhoneID;
+    DWORD       dwPhoneNameSize;
+    DWORD       dwPhoneNameOffset;
+    DWORD       dwStringFormat;
+    DWORD       dwPhoneStates;
+    DWORD       dwHookSwitchDevs;
+    DWORD       dwHandsetHookSwitchModes;
+    DWORD       dwSpeakerHookSwitchModes;
+    DWORD       dwHeadsetHookSwitchModes;
+    DWORD       dwVolumeFlags;
+    DWORD       dwGainFlags;
+    DWORD       dwDisplayNumRows;
+    DWORD       dwDisplayNumColumns;
+    DWORD       dwNumRingModes;
+    DWORD       dwNumButtonLamps;
+    DWORD       dwButtonModesSize;
+    DWORD       dwButtonModesOffset;
+    DWORD       dwButtonFunctionsSize;
+    DWORD       dwButtonFunctionsOffset;
+    DWORD       dwLampModesSize;
+    DWORD       dwLampModesOffset;
+    DWORD       dwNumSetData;
+    DWORD       dwSetDataSize;
+    DWORD       dwSetDataOffset;
+    DWORD       dwNumGetData;
+    DWORD       dwGetDataSize;
+    DWORD       dwGetDataOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwDeviceClassesSize;                            // TAPI v2.0
+    DWORD       dwDeviceClassesOffset;                          // TAPI v2.0
+    DWORD       dwPhoneFeatures;                                // TAPI v2.0
+    DWORD       dwSettableHandsetHookSwitchModes;               // TAPI v2.0
+    DWORD       dwSettableSpeakerHookSwitchModes;               // TAPI v2.0
+    DWORD       dwSettableHeadsetHookSwitchModes;               // TAPI v2.0
+    DWORD       dwMonitoredHandsetHookSwitchModes;              // TAPI v2.0
+    DWORD       dwMonitoredSpeakerHookSwitchModes;              // TAPI v2.0
+    DWORD       dwMonitoredHeadsetHookSwitchModes;              // TAPI v2.0
+#endif
+
+} PHONECAPS, FAR *LPPHONECAPS;
+
+typedef struct phoneextensionid_tag
+{
+    DWORD       dwExtensionID0;
+    DWORD       dwExtensionID1;
+    DWORD       dwExtensionID2;
+    DWORD       dwExtensionID3;
+
+} PHONEEXTENSIONID, FAR *LPPHONEEXTENSIONID;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+typedef struct phoneinitializeexparams_tag
+{
+    DWORD       dwTotalSize;                                    // TAPI v2.0
+    DWORD       dwNeededSize;                                   // TAPI v2.0
+    DWORD       dwUsedSize;                                     // TAPI v2.0
+    DWORD       dwOptions;                                      // TAPI v2.0
+
+    union
+    {
+        HANDLE  hEvent;                                         // TAPI v2.0
+        HANDLE  hCompletionPort;                                // TAPI v2.0
+
+    } Handles;
+
+    DWORD       dwCompletionKey;                                // TAPI v2.0
+
+} PHONEINITIALIZEEXPARAMS, FAR *LPPHONEINITIALIZEEXPARAMS;
+
+typedef struct phonemessage_tag
+{
+    DWORD       hDevice;                                        // TAPI v2.0
+    DWORD       dwMessageID;                                    // TAPI v2.0
+    DWORD       dwCallbackInstance;                             // TAPI v2.0
+    DWORD       dwParam1;                                       // TAPI v2.0
+    DWORD       dwParam2;                                       // TAPI v2.0
+    DWORD       dwParam3;                                       // TAPI v2.0
+
+} PHONEMESSAGE, FAR *LPPHONEMESSAGE;
+#endif
+
+typedef struct phonestatus_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwStatusFlags;
+    DWORD       dwNumOwners;
+    DWORD       dwNumMonitors;
+    DWORD       dwRingMode;
+    DWORD       dwRingVolume;
+    DWORD       dwHandsetHookSwitchMode;
+    DWORD       dwHandsetVolume;
+    DWORD       dwHandsetGain;
+    DWORD       dwSpeakerHookSwitchMode;
+    DWORD       dwSpeakerVolume;
+    DWORD       dwSpeakerGain;
+    DWORD       dwHeadsetHookSwitchMode;
+    DWORD       dwHeadsetVolume;
+    DWORD       dwHeadsetGain;
+    DWORD       dwDisplaySize;
+    DWORD       dwDisplayOffset;
+    DWORD       dwLampModesSize;
+    DWORD       dwLampModesOffset;
+    DWORD       dwOwnerNameSize;
+    DWORD       dwOwnerNameOffset;
+    DWORD       dwDevSpecificSize;
+    DWORD       dwDevSpecificOffset;
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    DWORD       dwPhoneFeatures;                                // TAPI v2.0
+#endif
+
+} PHONESTATUS, FAR *LPPHONESTATUS;
+
+typedef struct varstring_tag
+{
+    DWORD       dwTotalSize;
+    DWORD       dwNeededSize;
+    DWORD       dwUsedSize;
+    DWORD       dwStringFormat;
+    DWORD       dwStringSize;
+    DWORD       dwStringOffset;
+
+} VARSTRING, FAR *LPVARSTRING;
+
+
+
+LONG
+WINAPI
+lineAccept(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+lineAddProvider(                                                // TAPI v1.4
+    LPCSTR              lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineAddProviderA(                                               // TAPI v1.4
+    LPCSTR              lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    );
+
+LONG
+WINAPI
+lineAddProviderW(
+    LPCWSTR             lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    );
+
+#ifdef UNICODE
+#define lineAddProvider lineAddProviderW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineAddProvider lineAddProviderA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineAddToConference(
+    HCALL               hConfCall,
+    HCALL               hConsultCall
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineAgentSpecific(                                              // TAPI v2.0
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentExtensionIDIndex,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+#endif
+
+LONG
+WINAPI
+lineAnswer(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+lineBlindTransfer(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineBlindTransferA(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+LONG
+WINAPI
+lineBlindTransferW(
+    HCALL               hCall,
+    LPCWSTR             lpszDestAddressW,
+    DWORD               dwCountryCode
+    );
+
+#ifdef UNICODE
+#define lineBlindTransfer lineBlindTransferW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineBlindTransfer lineBlindTransferA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineClose(
+    HLINE               hLine
+    );
+
+LONG
+WINAPI
+lineCompleteCall(
+    HCALL               hCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    );
+
+LONG
+WINAPI
+lineCompleteTransfer(
+    HCALL               hCall,
+    HCALL               hConsultCall,
+    LPHCALL             lphConfCall,
+    DWORD               dwTransferMode
+    );
+
+LONG
+WINAPI
+lineConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineConfigDialogA(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    );
+
+LONG
+WINAPI
+lineConfigDialogW(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    );
+
+#ifdef UNICODE
+#define lineConfigDialog lineConfigDialogW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineConfigDialog lineConfigDialogA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineConfigDialogEdit(                                           // TAPI v1.4
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineConfigDialogEditA(                                          // TAPI v1.4
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    );
+
+LONG
+WINAPI
+lineConfigDialogEditW(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    );
+
+#ifdef UNICODE
+#define lineConfigDialogEdit lineConfigDialogEditW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineConfigDialogEdit lineConfigDialogEditA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineConfigProvider(                                             // TAPI v1.4
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    );
+
+LONG
+WINAPI
+lineDeallocateCall(
+    HCALL               hCall
+    );
+
+LONG
+WINAPI
+lineDevSpecific(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+lineDevSpecificFeature(
+    HLINE               hLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+lineDial(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineDialA(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+LONG
+WINAPI
+lineDialW(
+    HCALL               hCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+#ifdef UNICODE
+#define lineDial lineDialW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineDial lineDialA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineDrop(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+lineForward(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineForwardA(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+WINAPI
+lineForwardW(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#ifdef UNICODE
+#define lineForward lineForwardW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineForward lineForwardA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGatherDigits(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGatherDigitsA(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    );
+
+LONG
+WINAPI
+lineGatherDigitsW(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPWSTR              lpsDigits,
+    DWORD               dwNumDigits,
+    LPCWSTR             lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    );
+
+#ifdef UNICODE
+#define lineGatherDigits lineGatherDigitsW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGatherDigits lineGatherDigitsA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGenerateDigits(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGenerateDigitsA(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    );
+
+LONG
+WINAPI
+lineGenerateDigitsW(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCWSTR             lpszDigits,
+    DWORD               dwDuration
+    );
+
+#ifdef UNICODE
+#define lineGenerateDigits lineGenerateDigitsW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGenerateDigits lineGenerateDigitsA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGenerateTone(
+    HCALL               hCall,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    );
+
+LONG
+WINAPI
+lineGetAddressCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetAddressCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    );
+
+LONG
+WINAPI
+lineGetAddressCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    );
+
+#ifdef UNICODE
+#define lineGetAddressCaps lineGetAddressCapsW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetAddressCaps lineGetAddressCapsA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetAddressID(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetAddressIDA(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+lineGetAddressIDW(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCWSTR             lpsAddress,
+    DWORD               dwSize
+    );
+
+#ifdef UNICODE
+#define lineGetAddressID lineGetAddressIDW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetAddressID lineGetAddressIDA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetAddressStatus(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetAddressStatusA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    );
+
+LONG
+WINAPI
+lineGetAddressStatusW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    );
+
+#ifdef UNICODE
+#define lineGetAddressStatus lineGetAddressStatusW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetAddressStatus lineGetAddressStatusA
+#endif
+#endif
+
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineGetAgentActivityListA(                                       // TAPI v2.0
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    );
+
+LONG
+WINAPI
+lineGetAgentActivityListW(                                       // TAPI v2.0
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    );
+
+#ifdef UNICODE
+#define lineGetAgentActivityList lineGetAgentActivityListW
+#else
+#define lineGetAgentActivityList lineGetAgentActivityListA
+#endif
+
+
+LONG
+WINAPI
+lineGetAgentCapsA(                                               // TAPI v2.0
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    );
+
+LONG
+WINAPI
+lineGetAgentCapsW(                                               // TAPI v2.0
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    );
+
+#ifdef UNICODE
+#define lineGetAgentCaps lineGetAgentCapsW
+#else
+#define lineGetAgentCaps lineGetAgentCapsA
+#endif
+
+
+LONG
+WINAPI
+lineGetAgentGroupListA(                                          // TAPI v2.0
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    );
+
+LONG
+WINAPI
+lineGetAgentGroupListW(                                          // TAPI v2.0
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    );
+
+#ifdef UNICODE
+#define lineGetAgentGroupList lineGetAgentGroupListW
+#else
+#define lineGetAgentGroupList lineGetAgentGroupListA
+#endif
+
+LONG
+WINAPI
+lineGetAgentStatusA(                                             // TAPI v2.0
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    );
+
+LONG
+WINAPI
+lineGetAgentStatusW(                                             // TAPI v2.0
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    );
+
+#ifdef UNICODE
+#define lineGetAgentStatus lineGetAgentStatusW
+#else
+#define lineGetAgentStatus lineGetAgentStatusA
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetAppPriority(                                             // TAPI v1.4
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetAppPriorityA(                                            // TAPI v1.4
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    );
+
+LONG
+WINAPI
+lineGetAppPriorityW(                                             // TAPI v1.4
+    LPCWSTR             lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    );
+
+#ifdef UNICODE
+#define lineGetAppPriority lineGetAppPriorityW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetAppPriority lineGetAppPriorityA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetCallInfo(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetCallInfoA(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    );
+
+LONG
+WINAPI
+lineGetCallInfoW(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    );
+
+#ifdef UNICODE
+#define lineGetCallInfo lineGetCallInfoW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetCallInfo lineGetCallInfoA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetCallStatus(
+    HCALL               hCall,
+    LPLINECALLSTATUS    lpCallStatus
+    );
+
+LONG
+WINAPI
+lineGetConfRelatedCalls(
+    HCALL               hCall,
+    LPLINECALLLIST      lpCallList
+    );
+    
+LONG
+WINAPI
+lineGetCountry(                                                 // TAPI v1.4
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetCountryA(                                                 // TAPI v1.4
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    );
+
+LONG
+WINAPI
+lineGetCountryW(                                                // TAPI v1.4
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    );
+
+#ifdef UNICODE
+#define lineGetCountry lineGetCountryW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetCountry lineGetCountryA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineGetDevCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetDevCapsA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    );
+
+LONG
+WINAPI
+lineGetDevCapsW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    );
+
+#ifdef UNICODE
+#define lineGetDevCaps lineGetDevCapsW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetDevCaps lineGetDevCapsA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetDevConfigA(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    );
+
+LONG
+WINAPI
+lineGetDevConfigW(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCWSTR             lpszDeviceClass
+    );
+
+#ifdef UNICODE
+#define lineGetDevConfig lineGetDevConfigW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetDevConfig lineGetDevConfigA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetNewCalls(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwSelect,
+    LPLINECALLLIST      lpCallList
+    );
+
+LONG
+WINAPI
+lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetIconA(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+
+LONG
+WINAPI
+lineGetIconW(
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+
+#ifdef UNICODE
+#define lineGetIcon lineGetIconW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetIcon lineGetIconA
+#endif
+#endif
+
+#endif
+    
+LONG
+WINAPI
+lineGetID(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetIDA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    );
+
+LONG
+WINAPI
+lineGetIDW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass
+    );
+
+#ifdef UNICODE
+#define lineGetID lineGetIDW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetID lineGetIDA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetLineDevStatus(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetLineDevStatusA(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    );
+
+LONG
+WINAPI
+lineGetLineDevStatusW(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    );
+
+#ifdef UNICODE
+#define lineGetDevStatus lineGetDevStatusW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetDevStatus lineGetDevStatusA
+#endif
+#endif
+
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineGetMessage(                                                 // TAPI v2.0
+    HLINEAPP        hLineApp,
+    LPLINEMESSAGE   lpMessage,
+    DWORD           dwTimeout
+    );
+#endif
+
+LONG
+WINAPI
+lineGetNumRings(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPDWORD             lpdwNumRings
+    );
+
+LONG
+WINAPI
+lineGetProviderList(                                            // TAPI v1.4
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetProviderListA(
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    );
+
+LONG
+WINAPI
+lineGetProviderListW(
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    );
+
+#ifdef UNICODE
+#define lineGetProviderList lineGetProviderListW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetProviderList lineGetProviderListA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetRequest(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetRequestA(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    );
+
+LONG
+WINAPI
+lineGetRequestW(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    );
+
+#ifdef UNICODE
+#define lineGetRequest lineGetRequestW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetRequest lineGetRequestA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineGetStatusMessages(
+    HLINE               hLine,
+    LPDWORD             lpdwLineStates,
+    LPDWORD             lpdwAddressStates
+    );
+
+LONG
+WINAPI
+lineGetTranslateCaps(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineGetTranslateCapsA(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    );
+
+LONG
+WINAPI
+lineGetTranslateCapsW(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    );
+
+#ifdef UNICODE
+#define lineGetTranslateCaps lineGetTranslateCapsW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineGetTranslateCaps lineGetTranslateCapsA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineHandoff(
+    HCALL               hCall,
+    LPCSTR              lpszFileName,
+    DWORD               dwMediaMode
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineHandoffA(
+    HCALL               hCall,
+    LPCSTR              lpszFileName,
+    DWORD               dwMediaMode
+    );
+
+LONG
+WINAPI
+lineHandoffW(
+    HCALL               hCall,
+    LPCWSTR             lpszFileName,
+    DWORD               dwMediaMode
+    );
+
+#ifdef UNICODE
+#define lineHandoff lineHandoffW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineHandoff lineHandoffA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineHold(
+    HCALL               hCall
+    );
+
+LONG
+WINAPI
+lineInitialize(
+    LPHLINEAPP          lphLineApp,
+    HINSTANCE           hInstance,
+    LINECALLBACK        lpfnCallback,
+    LPCSTR              lpszAppName,
+    LPDWORD             lpdwNumDevs
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineInitializeExA(                                               // TAPI v2.0
+    LPHLINEAPP                  lphLineApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                lpfnCallback,
+    LPCSTR                      lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams
+    );
+
+LONG
+WINAPI
+lineInitializeExW(                                               // TAPI v2.0
+    LPHLINEAPP                  lphLineApp,
+    HINSTANCE                   hInstance,
+    LINECALLBACK                lpfnCallback,
+    LPCWSTR                     lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams
+    );
+
+#ifdef UNICODE
+#define lineInitializeEx lineInitializeExW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineInitializeEx lineInitializeExA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineMakeCall(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineMakeCallA(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+WINAPI
+lineMakeCallW(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#ifdef UNICODE
+#define lineMakeCall lineMakeCallW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineMakeCall lineMakeCallA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineMonitorDigits(
+    HCALL               hCall,
+    DWORD               dwDigitModes
+    );
+
+LONG
+WINAPI
+lineMonitorMedia(
+    HCALL               hCall,
+    DWORD               dwMediaModes
+    );
+
+LONG
+WINAPI
+lineMonitorTones(
+    HCALL               hCall,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    );
+
+LONG
+WINAPI
+lineNegotiateAPIVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    );
+
+LONG
+WINAPI
+lineNegotiateExtVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtLowVersion,
+    DWORD               dwExtHighVersion,
+    LPDWORD             lpdwExtVersion
+    );
+
+LONG
+WINAPI
+lineOpen(
+    HLINEAPP hLineApp, 
+    DWORD dwDeviceID,
+    LPHLINE lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineOpenA(
+    HLINEAPP hLineApp, 
+    DWORD dwDeviceID,
+    LPHLINE lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+WINAPI
+lineOpenW(
+    HLINEAPP hLineApp, 
+    DWORD dwDeviceID,
+    LPHLINE lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#ifdef UNICODE
+#define lineOpen lineOpenW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineOpen lineOpenA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+linePark(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineParkA(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    );
+
+LONG
+WINAPI
+lineParkW(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCWSTR             lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    );
+
+#ifdef UNICODE
+#define linePark lineParkW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define linePark lineParkA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+linePickup(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    );
+
+#if WIN32
+LONG
+WINAPI
+linePickupA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    );
+
+LONG
+WINAPI
+linePickupW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszGroupID
+    );
+
+#ifdef UNICODE
+#define linePickup linePickupW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define linePickup linePickupA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+linePrepareAddToConference(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if WIN32
+LONG
+WINAPI
+linePrepareAddToConferenceA(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+WINAPI
+linePrepareAddToConferenceW(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#ifdef UNICODE
+#define linePrepareAddToConference linePrepareAddToConferenceW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define linePrepareAddToConference linePrepareAddToConferenceA
+#endif
+#endif
+
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineProxyMessage(                                               // TAPI v2.0
+    HLINE               hLine,
+    HCALL               hCall,
+    DWORD               dwMsg,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    );
+
+LONG
+WINAPI
+lineProxyResponse(                                              // TAPI v2.0
+    HLINE               hLine,
+    LPLINEPROXYREQUEST  lpProxyRequest,
+    DWORD               dwResult
+    );
+#endif
+
+LONG
+WINAPI
+lineRedirect(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineRedirectA(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+LONG
+WINAPI
+lineRedirectW(
+    HCALL               hCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+
+#ifdef UNICODE
+#define lineRedirect lineRedirectW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineRedirect lineRedirectA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineRegisterRequestRecipient(
+    HLINEAPP            hLineApp,
+    DWORD               dwRegistrationInstance,
+    DWORD               dwRequestMode,
+    DWORD               bEnable
+    );
+
+LONG
+WINAPI
+lineReleaseUserUserInfo(                                        // TAPI v1.4
+    HCALL               hCall
+    );
+
+LONG
+WINAPI
+lineRemoveFromConference(
+    HCALL               hCall
+    );
+
+LONG
+WINAPI
+lineRemoveProvider(                                             // TAPI v1.4
+    DWORD               dwPermanentProviderID,
+    HWND                hwndOwner
+    );
+
+LONG
+WINAPI
+lineSecureCall(
+    HCALL               hCall
+    );
+
+LONG
+WINAPI
+lineSendUserUserInfo(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineSetAgentActivity(                                           // TAPI v2.0
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwActivityID
+    );
+
+LONG
+WINAPI
+lineSetAgentGroup(                                              // TAPI v2.0
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    );
+
+LONG
+WINAPI
+lineSetAgentState(                                              // TAPI v2.0
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentState,
+    DWORD               dwNextAgentState
+    );
+#endif
+
+LONG
+WINAPI
+lineSetAppPriority(                                             // TAPI v1.4
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCSTR              lpszExtensionName,
+    DWORD               dwPriority
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineSetAppPriorityA(                                             // TAPI v1.4
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCSTR              lpszExtensionName,
+    DWORD               dwPriority
+    );
+
+LONG
+WINAPI
+lineSetAppPriorityW(                                             // TAPI v1.4
+    LPCWSTR             lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCWSTR             lpszExtensionName,
+    DWORD               dwPriority
+    );
+
+#ifdef UNICODE
+#define lineSetAppPriority lineSetAppPriorityW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineSetAppPriority lineSetAppPriorityA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineSetAppSpecific(
+    HCALL               hCall,
+    DWORD               dwAppSpecific
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineSetCallData(                                                // TAPI v2.0
+    HCALL               hCall,
+    LPVOID              lpCallData,
+    DWORD               dwSize
+    );
+#endif
+
+LONG
+WINAPI
+lineSetCallParams(
+    HCALL               hCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    );
+
+LONG
+WINAPI
+lineSetCallPrivilege(
+    HCALL               hCall,
+    DWORD               dwCallPrivilege
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineSetCallQualityOfService(                                    // TAPI v2.0
+    HCALL               hCall,
+    LPVOID              lpSendingFlowspec,
+    DWORD               dwSendingFlowspecSize,
+    LPVOID              lpReceivingFlowspec,
+    DWORD               dwReceivingFlowspecSize
+    );
+
+LONG
+WINAPI
+lineSetCallTreatment(                                           // TAPI v2.0
+    HCALL               hCall,
+    DWORD               dwTreatment
+    );
+#endif
+
+LONG
+WINAPI
+lineSetCurrentLocation(
+    HLINEAPP            hLineApp,
+    DWORD               dwLocation
+    );
+
+LONG
+WINAPI
+lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineSetDevConfigA(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    );
+
+LONG
+WINAPI
+lineSetDevConfigW(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCWSTR             lpszDeviceClass
+    );
+
+#ifdef UNICODE
+#define lineSetDevConfig lineSetDevConfigW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineSetDevConfig lineSetDevConfigA
+#endif
+#endif
+
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+lineSetLineDevStatus(                                           // TAPI v2.0
+    HLINE               hLine,
+    DWORD               dwStatusToChange,
+    DWORD               fStatus
+    );
+#endif
+
+LONG
+WINAPI
+lineSetMediaControl(
+    HLINE                       hLine,
+    DWORD                       dwAddressID,
+    HCALL                       hCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList, 
+    DWORD                       dwCallStateNumEntries
+    );
+
+LONG
+WINAPI
+lineSetMediaMode(
+    HCALL               hCall,
+    DWORD               dwMediaModes
+    );
+
+LONG
+WINAPI
+lineSetNumRings(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwNumRings
+    );
+
+LONG
+WINAPI
+lineSetStatusMessages(
+    HLINE               hLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    );
+
+LONG
+WINAPI
+lineSetTerminal(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    );
+
+LONG
+WINAPI
+lineSetTollList(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCSTR              lpszAddressIn,
+    DWORD               dwTollListOption
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineSetTollListA(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCSTR              lpszAddressIn,
+    DWORD               dwTollListOption
+    );
+
+LONG
+WINAPI
+lineSetTollListW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszAddressInW,
+    DWORD               dwTollListOption
+    );
+
+#ifdef UNICODE
+#define lineSetTollList lineSetTollListW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineSetTollList lineSetTollListA
+#endif
+#endif
+
+#endif
+
+
+LONG
+WINAPI
+lineSetupConference(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineSetupConferenceA(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+WINAPI
+lineSetupConferenceW(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#ifdef UNICODE
+#define lineSetupConference lineSetupConferenceW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineSetupConference lineSetupConferenceA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineSetupTransfer(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineSetupTransferA(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+WINAPI
+lineSetupTransferW(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#ifdef UNICODE
+#define lineSetupTransfer lineSetupTransferW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineSetupTransfer lineSetupTransferA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineShutdown(
+    HLINEAPP            hLineApp
+    );
+
+LONG
+WINAPI
+lineSwapHold(
+    HCALL               hActiveCall,
+    HCALL               hHeldCall
+    );
+
+LONG
+WINAPI
+lineTranslateAddress(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineTranslateAddressA(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    );
+
+LONG
+WINAPI
+lineTranslateAddressW(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCWSTR                 lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    );
+
+#ifdef UNICODE
+#define lineTranslateAddress lineTranslateAddressW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineTranslateAddressA lineTranslateAddressA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineTranslateDialog(                                            // TAPI v1.4
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCSTR              lpszAddressIn
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineTranslateDialogA(                                            // TAPI v1.4
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCSTR              lpszAddressIn
+    );
+
+LONG
+WINAPI
+lineTranslateDialogW(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCWSTR             lpszAddressIn
+    );
+
+#ifdef UNICODE
+#define lineTranslateDialog lineTranslateDialogW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineTranslateDialogA lineTranslateDialogA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+lineUncompleteCall(
+    HLINE               hLine,
+    DWORD               dwCompletionID
+    );
+
+LONG
+WINAPI
+lineUnhold(
+    HCALL               hCall
+    );
+
+LONG
+WINAPI
+lineUnpark(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress
+    );
+
+#if WIN32
+LONG
+WINAPI
+lineUnparkA(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress
+    );
+
+LONG
+WINAPI
+lineUnparkW(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCWSTR             lpszDestAddress
+    );
+
+#ifdef UNICODE
+#define lineUnpark lineUnparkW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define lineUnpark lineUnparkA
+#endif
+#endif
+
+#endif
+
+
+
+LONG
+WINAPI
+phoneClose(
+    HPHONE              hPhone
+    );
+
+LONG
+WINAPI
+phoneConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneConfigDialogA(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    );
+
+LONG
+WINAPI
+phoneConfigDialogW(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    );
+
+#ifdef UNICODE
+#define phoneConfigDialog phoneConfigDialogW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneConfigDialog phoneConfigDialogA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneDevSpecific(
+    HPHONE              hPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+phoneGetButtonInfo(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneGetButtonInfoA(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    );
+
+LONG
+WINAPI
+phoneGetButtonInfoW(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    );
+
+#ifdef UNICODE
+#define phoneGetButtonInfo phoneGetButtonInfoW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneGetButtonInfo phoneGetButtonInfoA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneGetData(
+    HPHONE              hPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+phoneGetDevCaps(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneGetDevCapsA(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    );
+
+LONG
+WINAPI
+phoneGetDevCapsW(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    );
+
+#ifdef UNICODE
+#define phoneGetDevCaps phoneGetDevCapsW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneGetDevCaps phoneGetDevCapsA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneGetDisplay(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDisplay
+    );
+
+LONG
+WINAPI
+phoneGetGain(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    );
+
+LONG
+WINAPI
+phoneGetHookSwitch(
+    HPHONE              hPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    );
+
+LONG
+WINAPI
+phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneGetIconA(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+
+LONG
+WINAPI
+phoneGetIconW(
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+
+#ifdef UNICODE
+#define phoneGetIcon phoneGetIconW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneGetIcon phoneGetIconA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneGetID(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneGetIDA(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    );
+
+LONG
+WINAPI
+phoneGetIDW(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass
+    );
+
+#ifdef UNICODE
+#define phoneGetID phoneGetIDW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneGetID phoneGetIDA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneGetLamp(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+phoneGetMessage(                                                // TAPI v2.0
+    HPHONEAPP       hPhoneApp,
+    LPPHONEMESSAGE  lpMessage,
+    DWORD           dwTimeout
+    );
+#endif
+
+LONG
+WINAPI
+phoneGetRing(
+    HPHONE              hPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    );
+
+LONG
+WINAPI
+phoneGetStatus(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneGetStatusA(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    );
+
+LONG
+WINAPI
+phoneGetStatusW(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    );
+
+
+#ifdef UNICODE
+#define phoneGetStatus phoneGetStatusW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneGetStatus phoneGetStatusA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneGetStatusMessages(
+    HPHONE              hPhone,
+    LPDWORD             lpdwPhoneStates,
+    LPDWORD             lpdwButtonModes,
+    LPDWORD             lpdwButtonStates
+    );
+
+LONG
+WINAPI
+phoneGetVolume(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    );
+
+LONG
+WINAPI
+phoneInitialize(
+    LPHPHONEAPP         lphPhoneApp,
+    HINSTANCE           hInstance,
+    PHONECALLBACK       lpfnCallback,
+    LPCSTR              lpszAppName,
+    LPDWORD             lpdwNumDevs
+    );
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+WINAPI
+phoneInitializeExA(                                              // TAPI v2.0
+    LPHPHONEAPP                 lphPhoneApp,
+    HINSTANCE                   hInstance,
+    PHONECALLBACK               lpfnCallback,
+    LPCSTR                      lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams
+    );
+
+LONG
+WINAPI
+phoneInitializeExW(                                              // TAPI v2.0
+    LPHPHONEAPP                 lphPhoneApp,
+    HINSTANCE                   hInstance,
+    PHONECALLBACK               lpfnCallback,
+    LPCWSTR                     lpszFriendlyAppName,
+    LPDWORD                     lpdwNumDevs,
+    LPDWORD                     lpdwAPIVersion,
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams
+    );
+
+#ifdef UNICODE
+#define phoneInitializeEx phoneInitializeExW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneInitializeEx phoneInitializeExA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneNegotiateAPIVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    );
+
+LONG
+WINAPI
+phoneNegotiateExtVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtLowVersion,
+    DWORD               dwExtHighVersion,
+    LPDWORD             lpdwExtVersion
+    );
+
+LONG
+WINAPI
+phoneOpen(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    LPHPHONE            lphPhone,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivilege
+    );
+
+LONG
+WINAPI
+phoneSetButtonInfo(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    );
+
+#if WIN32
+LONG
+WINAPI
+phoneSetButtonInfoA(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    );
+
+LONG
+WINAPI
+phoneSetButtonInfoW(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    );
+
+#ifdef UNICODE
+#define phoneSetButtonInfo phoneSetButtonInfoW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define phoneSetButtonInfo phoneSetButtonInfoA
+#endif
+#endif
+
+#endif
+
+LONG
+WINAPI
+phoneSetData(
+    HPHONE              hPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+phoneSetDisplay(
+    HPHONE              hPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCSTR              lpsDisplay,
+    DWORD               dwSize
+    );
+
+LONG
+WINAPI
+phoneSetGain(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    );
+
+LONG
+WINAPI
+phoneSetHookSwitch(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    );
+
+LONG
+WINAPI
+phoneSetLamp(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    );
+
+LONG
+WINAPI
+phoneSetRing(
+    HPHONE              hPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    );
+
+LONG
+WINAPI
+phoneSetStatusMessages(
+    HPHONE              hPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    );
+
+LONG
+WINAPI
+phoneSetVolume(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    );
+
+LONG
+WINAPI
+phoneShutdown(
+    HPHONEAPP           hPhoneApp
+    );
+
+
+
+LONG
+WINAPI
+tapiGetLocationInfo(
+    LPSTR               lpszCountryCode,
+    LPSTR               lpszCityCode
+    );
+    
+#if WIN32
+LONG
+WINAPI
+tapiGetLocationInfoA(
+    LPSTR               lpszCountryCode,
+    LPSTR               lpszCityCode
+    );
+    
+LONG
+WINAPI
+tapiGetLocationInfoW(
+    LPWSTR               lpszCountryCodeW,
+    LPWSTR               lpszCityCodeW
+    );
+
+#ifdef UNICODE
+#define tapiGetLocationInfo tapiGetLocationInfoW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define tapiGetLocationInfo tapiGetLocationInfoA
+#endif
+#endif
+
+#endif
+    
+
+LONG
+WINAPI
+tapiRequestDrop(
+    HWND                hwnd,
+    WPARAM              wRequestID
+    );
+
+LONG
+WINAPI
+tapiRequestMakeCall(
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    );
+
+#if WIN32
+LONG
+WINAPI
+tapiRequestMakeCallA(
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    );
+
+LONG
+WINAPI
+tapiRequestMakeCallW(
+    LPCWSTR              lpszDestAddress,
+    LPCWSTR              lpszAppName,
+    LPCWSTR              lpszCalledParty,
+    LPCWSTR              lpszComment
+    );
+
+#ifdef UNICODE
+#define tapiRequestMakeCall tapiRequestMakeCallW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define tapiRequestMakeCall tapiRequestMakeCallA
+#endif
+#endif
+
+#endif
+    
+LONG
+WINAPI
+tapiRequestMediaCall(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCSTR              lpszDeviceClass,
+    LPCSTR              lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    );
+
+#if WIN32
+LONG
+WINAPI
+tapiRequestMediaCallA(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCSTR              lpszDeviceClass,
+    LPCSTR              lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    );
+
+LONG
+WINAPI
+tapiRequestMediaCallW(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCWSTR             lpszDeviceClass,
+    LPCWSTR             lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszAppName,
+    LPCWSTR             lpszCalledParty,
+    LPCWSTR             lpszComment
+    );
+
+#ifdef UNICODE
+#define tapiRequestMediaCall tapiRequestMediaCallW
+#else
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define tapiRequestMediaCall tapiRequestMediaCallA
+#endif
+#endif
+
+#endif
+    
+/*
+
+TAPIERROR_FORMATMESSAGE - macro to convert a TAPI error constant
+    into a constant that FormatMessage will accept
+    
+        TAPIERR : Negative numbers and 0
+            Map to : strip off high WORD
+            Example: 0xFFFFFFFF (-1) becomes 0x0000FFFF
+        LINEERR : Start at 0x80000000
+            Map to : strip off 0x80000000 and add 0xE000
+            Example: 0x80000004 becomes 0x0000E004
+        PHONEERR: Start at 0x90000000
+            Map to : strip off 0x90000000 and add 0xF000
+            Example: 0x9000000A becomes 0x0000F00A
+
+        pseudocode:
+        
+        if (__ErrCode__ is a TAPIERR)
+            strip off high word
+
+            else if (__ErrCode__ is a PHONEERR)
+                strip off 0x90000000
+                add 0xE000
+
+                else
+                    strip off 0x80000000
+                    add 0xF000
+
+*/
+
+#define TAPIERROR_FORMATMESSAGE(__ErrCode__)                                                   \
+                                                                                               \
+                    ( ( (__ErrCode__) > 0xFFFF0000 ) ?                                         \
+                                                                                               \
+                            ( (__ErrCode__) & 0x0000FFFF ) :                                   \
+                                                                                               \
+                            ( ( (__ErrCode__) & 0x10000000 ) ?                                 \
+                                                                                               \
+                              ( (__ErrCode__) - 0x90000000 + 0xF000 ) :                        \
+                                                                                               \
+                              ( (__ErrCode__) - 0x80000000 + 0xE000 ) ) )
+
+
+
+#ifdef __cplusplus
+}                       /* End of extern "C" { */
+#endif  /* __cplusplus */
+
+#pragma pack()
+
+#endif // TAPI_H
diff --git a/private/tapi/dev/inc/tapi10/tapi.h b/private/tapi/dev/inc/tapi10/tapi.h
new file mode 100644
index 000000000..ab02585ab
--- /dev/null
+++ b/private/tapi/dev/inc/tapi10/tapi.h
@@ -0,0 +1,1932 @@
+// The  Telephony  API  is jointly copyrighted by Intel and Microsoft.  You are
+// granted  a royalty free worldwide, unlimited license to make copies, and use
+// the   API/SPI  for  making  applications/drivers  that  interface  with  the
+// specification provided that this paragraph and the Intel/Microsoft copyright
+// statement is maintained as is in the text and source code files.
+//
+// Copyright 1992, 1993 Intel/Microsoft, all rights reserved.
+
+#ifndef TAPI_H
+#define TAPI_H
+
+#include <windows.h>
+
+#pragma pack(1)
+// Type definitions of the data types used in tapi
+
+#ifdef __cplusplus
+extern "C" {            /* Assume C declarations for C++ */
+#endif   /* __cplusplus */
+
+
+#define DECLARE_OPAQUE32(name)  struct name##__ { int unused; }; \
+                                typedef const struct name##__ FAR* name
+
+DECLARE_OPAQUE32(HCALL);
+typedef HCALL FAR * LPHCALL;
+
+DECLARE_OPAQUE32(HLINE);
+typedef HLINE FAR * LPHLINE;
+
+DECLARE_OPAQUE32(HPHONE);
+typedef HPHONE FAR * LPHPHONE;
+
+DECLARE_OPAQUE32(HLINEAPP);
+typedef HLINEAPP FAR * LPHLINEAPP;
+
+DECLARE_OPAQUE32(HPHONEAPP);
+typedef HPHONEAPP FAR * LPHPHONEAPP;
+
+typedef HICON FAR * LPHICON;
+// typedef of the LINE callback procedure
+typedef void (CALLBACK * LINECALLBACK)  (DWORD hDevice,
+                                              DWORD dwMessage,
+                                              DWORD dwInstance,
+                                              DWORD dwParam1,
+                                              DWORD dwParam2,
+                                              DWORD dwParam3);
+
+// typedef of the PHONE callback procedure
+typedef void (CALLBACK * PHONECALLBACK)  (DWORD hDevice,
+                                               DWORD dwMessage,
+                                               DWORD dwInstance,
+                                               DWORD dwParam1,
+                                               DWORD dwParam2,
+                                               DWORD dwParam3);
+
+
+// Messages for Phones and Lines
+
+#define LINE_ADDRESSSTATE        0L
+#define LINE_CALLINFO            1L
+#define LINE_CALLSTATE           2L
+#define LINE_CLOSE               3L
+#define LINE_DEVSPECIFIC         4L
+#define LINE_DEVSPECIFICFEATURE  5L
+#define LINE_GATHERDIGITS        6L
+#define LINE_GENERATE            7L
+#define LINE_LINEDEVSTATE        8L
+#define LINE_MONITORDIGITS       9L
+#define LINE_MONITORMEDIA        10L
+#define LINE_MONITORTONE         11L
+#define LINE_REPLY               12L
+#define LINE_REQUEST             13L
+#define PHONE_BUTTON             14L
+#define PHONE_CLOSE              15L
+#define PHONE_DEVSPECIFIC        16L
+#define PHONE_REPLY              17L
+#define PHONE_STATE              18L
+
+
+// Define Simple Telephony Constants.
+
+#define TAPI_REPLY                    WM_USER + 99
+
+#define TAPIERR_CONNECTED           0L
+#define TAPIERR_DROPPED             -1L
+#define TAPIERR_NOREQUESTRECIPIENT  -2L
+#define TAPIERR_REQUESTQUEUEFULL    -3L
+#define TAPIERR_INVALDESTADDRESS    -4L
+#define TAPIERR_INVALWINDOWHANDLE   -5L
+#define TAPIERR_INVALDEVICECLASS    -6L
+#define TAPIERR_INVALDEVICEID       -7L
+#define TAPIERR_DEVICECLASSUNAVAIL  -8L    
+#define TAPIERR_DEVICEIDUNAVAIL     -9L    
+#define TAPIERR_DEVICEINUSE         -10L    
+#define TAPIERR_DESTBUSY            -11L    
+#define TAPIERR_DESTNOANSWER        -12L    
+#define TAPIERR_DESTUNAVAIL         -13L    
+#define TAPIERR_UNKNOWNWINHANDLE    -14L    
+#define TAPIERR_UNKNOWNREQUESTID    -15L    
+#define TAPIERR_REQUESTFAILED       -16L
+#define TAPIERR_REQUESTCANCELLED    -17L
+#define TAPIERR_INVALPOINTER        -18L
+
+
+#define TAPIMAXDESTADDRESSSIZE    80L 
+#define TAPIMAXAPPNAMESIZE        40L
+#define TAPIMAXCALLEDPARTYSIZE    40L
+#define TAPIMAXCOMMENTSIZE        80L
+#define TAPIMAXDEVICECLASSSIZE    40L
+#define TAPIMAXDEVICEIDSIZE       40L
+
+
+// Data types and values for Phones
+
+
+#define PHONEBUTTONFUNCTION_UNKNOWN          0x00000000
+#define PHONEBUTTONFUNCTION_CONFERENCE       0x00000001
+#define PHONEBUTTONFUNCTION_TRANSFER         0x00000002
+#define PHONEBUTTONFUNCTION_DROP             0x00000003
+#define PHONEBUTTONFUNCTION_HOLD             0x00000004
+#define PHONEBUTTONFUNCTION_RECALL           0x00000005
+#define PHONEBUTTONFUNCTION_DISCONNECT       0x00000006
+#define PHONEBUTTONFUNCTION_CONNECT          0x00000007
+#define PHONEBUTTONFUNCTION_MSGWAITON        0x00000008
+#define PHONEBUTTONFUNCTION_MSGWAITOFF       0x00000009
+#define PHONEBUTTONFUNCTION_SELECTRING       0x0000000A
+#define PHONEBUTTONFUNCTION_ABBREVDIAL       0x0000000B
+#define PHONEBUTTONFUNCTION_FORWARD          0x0000000C
+#define PHONEBUTTONFUNCTION_PICKUP           0x0000000D
+#define PHONEBUTTONFUNCTION_RINGAGAIN        0x0000000E
+#define PHONEBUTTONFUNCTION_PARK             0x0000000F
+#define PHONEBUTTONFUNCTION_REJECT           0x00000010
+#define PHONEBUTTONFUNCTION_REDIRECT         0x00000011
+#define PHONEBUTTONFUNCTION_MUTE             0x00000012
+#define PHONEBUTTONFUNCTION_VOLUMEUP         0x00000013
+#define PHONEBUTTONFUNCTION_VOLUMEDOWN       0x00000014
+#define PHONEBUTTONFUNCTION_SPEAKERON        0x00000015
+#define PHONEBUTTONFUNCTION_SPEAKEROFF       0x00000016
+#define PHONEBUTTONFUNCTION_FLASH            0x00000017
+#define PHONEBUTTONFUNCTION_DATAON           0x00000018
+#define PHONEBUTTONFUNCTION_DATAOFF          0x00000019
+#define PHONEBUTTONFUNCTION_DONOTDISTURB     0x0000001A
+#define PHONEBUTTONFUNCTION_INTERCOM         0x0000001B
+#define PHONEBUTTONFUNCTION_BRIDGEDAPP       0x0000001C
+#define PHONEBUTTONFUNCTION_BUSY             0x0000001D
+#define PHONEBUTTONFUNCTION_CALLAPP          0x0000001E
+#define PHONEBUTTONFUNCTION_DATETIME         0x0000001F
+#define PHONEBUTTONFUNCTION_DIRECTORY        0x00000020
+#define PHONEBUTTONFUNCTION_COVER            0x00000021
+#define PHONEBUTTONFUNCTION_CALLID           0x00000022
+#define PHONEBUTTONFUNCTION_LASTNUM          0x00000023
+#define PHONEBUTTONFUNCTION_NIGHTSRV         0x00000024
+#define PHONEBUTTONFUNCTION_SENDCALLS        0x00000025
+#define PHONEBUTTONFUNCTION_MSGINDICATOR     0x00000026
+#define PHONEBUTTONFUNCTION_REPDIAL          0x00000027
+#define PHONEBUTTONFUNCTION_SETREPDIAL       0x00000028
+#define PHONEBUTTONFUNCTION_SYSTEMSPEED      0x00000029
+#define PHONEBUTTONFUNCTION_STATIONSPEED     0x0000002A
+#define PHONEBUTTONFUNCTION_CAMPON           0x0000002B
+#define PHONEBUTTONFUNCTION_SAVEREPEAT       0x0000002C
+#define PHONEBUTTONFUNCTION_QUEUECALL        0x0000002D
+#define PHONEBUTTONFUNCTION_NONE             0x0000002E
+
+typedef struct phonebuttoninfo_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwButtonMode;
+    DWORD    dwButtonFunction;
+
+    DWORD    dwButtonTextSize;
+    DWORD    dwButtonTextOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} PHONEBUTTONINFO, FAR *LPPHONEBUTTONINFO;
+
+#define PHONEBUTTONMODE_DUMMY        0x00000001
+#define PHONEBUTTONMODE_CALL         0x00000002
+#define PHONEBUTTONMODE_FEATURE      0x00000004
+#define PHONEBUTTONMODE_KEYPAD       0x00000008
+#define PHONEBUTTONMODE_LOCAL        0x00000010
+#define PHONEBUTTONMODE_DISPLAY      0x00000020
+
+#define PHONEBUTTONSTATE_UP          0x00000001
+#define PHONEBUTTONSTATE_DOWN        0x00000002
+
+typedef struct phoneextensionid_tag {
+    DWORD    dwExtensionID0;
+    DWORD    dwExtensionID1;
+    DWORD    dwExtensionID2;
+    DWORD    dwExtensionID3;
+} PHONEEXTENSIONID, FAR *LPPHONEEXTENSIONID;
+
+
+typedef struct phonecaps_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwProviderInfoSize;
+    DWORD    dwProviderInfoOffset;
+
+    DWORD    dwPhoneInfoSize;
+    DWORD    dwPhoneInfoOffset;
+
+    DWORD    dwPermanentPhoneID;
+    DWORD    dwPhoneNameSize;
+    DWORD    dwPhoneNameOffset;
+    DWORD    dwStringFormat;    
+
+    DWORD    dwPhoneStates;
+    DWORD    dwHookSwitchDevs;
+    DWORD    dwHandsetHookSwitchModes;
+    DWORD    dwSpeakerHookSwitchModes;
+    DWORD    dwHeadsetHookSwitchModes;
+
+    DWORD    dwVolumeFlags;
+    DWORD    dwGainFlags;
+    DWORD    dwDisplayNumRows;
+    DWORD    dwDisplayNumColumns;
+    DWORD    dwNumRingModes;
+    DWORD    dwNumButtonLamps;
+
+    DWORD    dwButtonModesSize;
+    DWORD    dwButtonModesOffset;
+
+    DWORD    dwButtonFunctionsSize;
+    DWORD    dwButtonFunctionsOffset;
+
+    DWORD    dwLampModesSize;
+    DWORD    dwLampModesOffset;
+
+    DWORD    dwNumSetData;
+    DWORD    dwSetDataSize;
+    DWORD    dwSetDataOffset;
+
+    DWORD    dwNumGetData;
+    DWORD    dwGetDataSize;
+    DWORD    dwGetDataOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+
+} PHONECAPS, FAR *LPPHONECAPS;
+
+#define PHONEERR_ALLOCATED              0x90000001
+#define PHONEERR_BADDEVICEID            0x90000002
+#define PHONEERR_INCOMPATIBLEAPIVERSION 0x90000003
+#define PHONEERR_INCOMPATIBLEEXTVERSION 0x90000004
+#define PHONEERR_INIFILECORRUPT         0x90000005
+#define PHONEERR_INUSE                  0x90000006
+#define PHONEERR_INVALAPPHANDLE         0x90000007
+#define PHONEERR_INVALAPPNAME           0x90000008
+#define PHONEERR_INVALBUTTONLAMPID      0x90000009
+#define PHONEERR_INVALBUTTONMODE        0x9000000A
+#define PHONEERR_INVALBUTTONSTATE       0x9000000B
+#define PHONEERR_INVALDATAID            0x9000000C
+#define PHONEERR_INVALDEVICECLASS       0x9000000D
+#define PHONEERR_INVALEXTVERSION        0x9000000E
+#define PHONEERR_INVALHOOKSWITCHDEV     0x9000000F
+#define PHONEERR_INVALHOOKSWITCHMODE    0x90000010
+#define PHONEERR_INVALLAMPMODE          0x90000011
+#define PHONEERR_INVALPARAM             0x90000012
+#define PHONEERR_INVALPHONEHANDLE       0x90000013
+#define PHONEERR_INVALPHONESTATE        0x90000014
+#define PHONEERR_INVALPOINTER           0x90000015
+#define PHONEERR_INVALPRIVILEGE         0x90000016
+#define PHONEERR_INVALRINGMODE          0x90000017
+#define PHONEERR_NODEVICE               0x90000018
+#define PHONEERR_NODRIVER               0x90000019
+#define PHONEERR_NOMEM                  0x9000001A
+#define PHONEERR_NOTOWNER               0x9000001B
+#define PHONEERR_OPERATIONFAILED        0x9000001C
+#define PHONEERR_OPERATIONUNAVAIL       0x9000001D
+#define PHONEERR_RESOURCEUNAVAIL        0x9000001F
+#define PHONEERR_REQUESTOVERRUN         0x90000020              
+#define PHONEERR_STRUCTURETOOSMALL      0x90000021
+#define PHONEERR_UNINITIALIZED          0x90000022
+#define PHONEERR_REINIT                 0x90000023
+
+#define PHONEHOOKSWITCHDEV_HANDSET      0x00000001
+#define PHONEHOOKSWITCHDEV_SPEAKER      0x00000002
+#define PHONEHOOKSWITCHDEV_HEADSET      0x00000004
+              
+#define PHONEHOOKSWITCHMODE_ONHOOK      0x00000001
+#define PHONEHOOKSWITCHMODE_MIC         0x00000002
+#define PHONEHOOKSWITCHMODE_SPEAKER     0x00000004
+#define PHONEHOOKSWITCHMODE_MICSPEAKER  0x00000008
+#define PHONEHOOKSWITCHMODE_UNKNOWN     0x00000010              
+
+#define PHONELAMPMODE_DUMMY              0x00000001
+#define PHONELAMPMODE_OFF                0x00000002
+#define PHONELAMPMODE_STEADY             0x00000004
+#define PHONELAMPMODE_WINK               0x00000008
+#define PHONELAMPMODE_FLASH              0x00000010
+#define PHONELAMPMODE_FLUTTER            0x00000020
+#define PHONELAMPMODE_BROKENFLUTTER      0x00000040
+#define PHONELAMPMODE_UNKNOWN            0x00000080
+
+
+#define PHONEPRIVILEGE_MONITOR        0x00000001
+#define PHONEPRIVILEGE_OWNER          0x00000002
+
+#define PHONESTATE_OTHER               0x00000001
+#define PHONESTATE_CONNECTED           0x00000002
+#define PHONESTATE_DISCONNECTED        0x00000004
+#define PHONESTATE_OWNER               0x00000008
+#define PHONESTATE_MONITORS            0x00000010
+#define PHONESTATE_DISPLAY             0x00000020
+#define PHONESTATE_LAMP                0x00000040
+#define PHONESTATE_RINGMODE            0x00000080
+#define PHONESTATE_RINGVOLUME          0x00000100
+#define PHONESTATE_HANDSETHOOKSWITCH   0x00000200
+#define PHONESTATE_HANDSETVOLUME       0x00000400
+#define PHONESTATE_HANDSETGAIN         0x00000800
+#define PHONESTATE_SPEAKERHOOKSWITCH   0x00001000
+#define PHONESTATE_SPEAKERVOLUME       0x00002000
+#define PHONESTATE_SPEAKERGAIN         0x00004000
+#define PHONESTATE_HEADSETHOOKSWITCH   0x00008000
+#define PHONESTATE_HEADSETVOLUME       0x00010000
+#define PHONESTATE_HEADSETGAIN         0x00020000
+#define PHONESTATE_SUSPEND             0x00040000
+#define PHONESTATE_RESUME              0x00080000
+#define PHONESTATE_DEVSPECIFIC         0x00100000
+#define PHONESTATE_REINIT              0x00200000
+
+typedef struct phonestatus_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwStatusFlags; 
+    DWORD    dwNumOwners;
+    DWORD    dwNumMonitors;
+    DWORD    dwRingMode;
+    DWORD    dwRingVolume;
+
+    DWORD    dwHandsetHookSwitchMode;
+    DWORD    dwHandsetVolume;
+    DWORD    dwHandsetGain;
+
+    DWORD    dwSpeakerHookSwitchMode;
+    DWORD    dwSpeakerVolume;
+    DWORD    dwSpeakerGain;
+
+    DWORD    dwHeadsetHookSwitchMode;
+    DWORD    dwHeadsetVolume;
+    DWORD    dwHeadsetGain;
+
+    DWORD    dwDisplaySize;
+    DWORD    dwDisplayOffset;
+
+    DWORD    dwLampModesSize;
+    DWORD    dwLampModesOffset;
+
+    DWORD    dwOwnerNameSize;
+    DWORD    dwOwnerNameOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} PHONESTATUS, FAR *LPPHONESTATUS;
+
+#define PHONESTATUSFLAGS_CONNECTED    0x00000001
+#define PHONESTATUSFLAGS_SUSPENDED    0x00000002
+
+#define STRINGFORMAT_ASCII   0x00000001
+#define STRINGFORMAT_DBCS    0x00000002
+#define STRINGFORMAT_UNICODE 0x00000003
+#define STRINGFORMAT_BINARY  0x00000004
+
+typedef struct varstring_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwStringFormat;
+    DWORD    dwStringSize;
+    DWORD    dwStringOffset;
+} VARSTRING, FAR *LPVARSTRING;
+
+// Data types and values for Lines
+
+
+#define LINEADDRCAPFLAGS_FWDNUMRINGS        0x00000001
+#define LINEADDRCAPFLAGS_PICKUPGROUPID      0x00000002    
+#define LINEADDRCAPFLAGS_SECURE             0x00000004
+#define LINEADDRCAPFLAGS_BLOCKIDDEFAULT     0x00000008
+#define LINEADDRCAPFLAGS_BLOCKIDOVERRIDE    0x00000010
+#define LINEADDRCAPFLAGS_DIALED             0x00000020
+#define LINEADDRCAPFLAGS_ORIGOFFHOOK        0x00000040
+#define LINEADDRCAPFLAGS_DESTOFFHOOK        0x00000080
+#define LINEADDRCAPFLAGS_FWDCONSULT         0x00000100
+#define LINEADDRCAPFLAGS_SETUPCONFNULL      0x00000200
+#define LINEADDRCAPFLAGS_AUTORECONNECT      0x00000400
+#define LINEADDRCAPFLAGS_COMPLETIONID       0x00000800
+#define LINEADDRCAPFLAGS_TRANSFERHELD       0x00001000
+#define LINEADDRCAPFLAGS_TRANSFERMAKE       0x00002000
+#define LINEADDRCAPFLAGS_CONFERENCEHELD     0x00004000
+#define LINEADDRCAPFLAGS_CONFERENCEMAKE     0x00008000
+#define LINEADDRCAPFLAGS_PARTIALDIAL        0x00010000
+#define LINEADDRCAPFLAGS_FWDSTATUSVALID     0x00020000
+#define LINEADDRCAPFLAGS_FWDINTEXTADDR      0x00040000
+#define LINEADDRCAPFLAGS_FWDBUSYNAADDR      0x00080000
+#define LINEADDRCAPFLAGS_ACCEPTTOALERT      0x00100000
+#define LINEADDRCAPFLAGS_CONFDROP           0x00200000
+#define LINEADDRCAPFLAGS_PICKUPCALLWAIT     0x00400000
+
+typedef struct lineaddresscaps_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwLineDeviceID;
+
+    DWORD    dwAddressSize;
+    DWORD    dwAddressOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+
+    DWORD    dwAddressSharing;
+    DWORD    dwAddressStates;
+    DWORD    dwCallInfoStates;
+    DWORD    dwCallerIDFlags;
+    DWORD    dwCalledIDFlags;
+    DWORD    dwConnectedIDFlags;
+    DWORD    dwRedirectionIDFlags;
+    DWORD    dwRedirectingIDFlags;
+    DWORD    dwCallStates;
+    DWORD    dwDialToneModes;
+    DWORD    dwBusyModes;
+    DWORD    dwSpecialInfo;
+    DWORD    dwDisconnectModes;
+
+    DWORD    dwMaxNumActiveCalls;
+    DWORD    dwMaxNumOnHoldCalls;
+    DWORD    dwMaxNumOnHoldPendingCalls;
+    DWORD    dwMaxNumConference;
+    DWORD    dwMaxNumTransConf;
+
+    DWORD    dwAddrCapFlags;
+    DWORD    dwCallFeatures;
+    DWORD    dwRemoveFromConfCaps;
+    DWORD    dwRemoveFromConfState;
+    DWORD    dwTransferModes;
+    DWORD    dwParkModes;
+
+    DWORD    dwForwardModes;
+    DWORD    dwMaxForwardEntries;
+    DWORD    dwMaxSpecificEntries;
+    DWORD    dwMinFwdNumRings;
+    DWORD    dwMaxFwdNumRings;
+
+    DWORD    dwMaxCallCompletions;
+    DWORD    dwCallCompletionConds;
+    DWORD    dwCallCompletionModes;
+    DWORD    dwNumCompletionMessages;
+    DWORD    dwCompletionMsgTextEntrySize;
+    DWORD    dwCompletionMsgTextSize;
+    DWORD    dwCompletionMsgTextOffset;
+} LINEADDRESSCAPS, FAR *LPLINEADDRESSCAPS;
+
+#define LINEADDRESSMODE_ADDRESSID        0x00000001
+#define LINEADDRESSMODE_DIALABLEADDR     0x00000002
+
+
+#define LINEADDRESSSHARING_PRIVATE        0x00000001
+#define LINEADDRESSSHARING_BRIDGEDEXCL    0x00000002
+#define LINEADDRESSSHARING_BRIDGEDNEW     0x00000004
+#define LINEADDRESSSHARING_BRIDGEDSHARED  0x00000008
+#define LINEADDRESSSHARING_MONITORED      0x00000010
+
+#define LINEADDRESSSTATE_OTHER            0x00000001
+#define LINEADDRESSSTATE_DEVSPECIFIC      0x00000002
+#define LINEADDRESSSTATE_INUSEZERO        0x00000004
+#define LINEADDRESSSTATE_INUSEONE         0x00000008
+#define LINEADDRESSSTATE_INUSEMANY        0x00000010
+#define LINEADDRESSSTATE_NUMCALLS         0x00000020
+#define LINEADDRESSSTATE_FORWARD          0x00000040
+#define LINEADDRESSSTATE_TERMINALS        0x00000080
+
+typedef struct lineaddressstatus_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwNumInUse;
+    DWORD    dwNumActiveCalls;
+    DWORD    dwNumOnHoldCalls;
+    DWORD    dwNumOnHoldPendCalls;
+    DWORD    dwAddressFeatures;
+
+    DWORD    dwNumRingsNoAnswer;
+    DWORD    dwForwardNumEntries;
+    DWORD    dwForwardSize;
+    DWORD    dwForwardOffset;
+
+    DWORD    dwTerminalModesSize;
+    DWORD    dwTerminalModesOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} LINEADDRESSSTATUS, FAR *LPLINEADDRESSSTATUS;
+
+#define LINEADDRFEATURE_FORWARD           0x00000001
+#define LINEADDRFEATURE_MAKECALL          0x00000002
+#define LINEADDRFEATURE_PICKUP            0x00000004
+#define LINEADDRFEATURE_SETMEDIACONTROL   0x00000008
+#define LINEADDRFEATURE_SETTERMINAL       0x00000010
+#define LINEADDRFEATURE_SETUPCONF         0x00000020
+#define LINEADDRFEATURE_UNCOMPLETECALL    0x00000040
+#define LINEADDRFEATURE_UNPARK            0x00000080
+
+
+#define LINEANSWERMODE_NONE    0x00000001
+#define LINEANSWERMODE_DROP    0x00000002
+#define LINEANSWERMODE_HOLD    0x00000004
+
+#define LINEBEARERMODE_VOICE            0x00000001
+#define LINEBEARERMODE_SPEECH           0x00000002
+#define LINEBEARERMODE_MULTIUSE         0x00000004
+#define LINEBEARERMODE_DATA             0x00000008
+#define LINEBEARERMODE_ALTSPEECHDATA    0x00000010
+#define LINEBEARERMODE_NONCALLSIGNALING 0x00000020
+
+#define LINEBUSYMODE_STATION    0x00000001
+#define LINEBUSYMODE_TRUNK      0x00000002
+#define LINEBUSYMODE_UNKNOWN    0x00000004
+#define LINEBUSYMODE_UNAVAIL    0x00000008
+
+#define LINECALLCOMPLCOND_BUSY        0x00000001
+#define LINECALLCOMPLCOND_NOANSWER    0x00000002
+
+#define LINECALLCOMPLMODE_CAMPON      0x00000001
+#define LINECALLCOMPLMODE_CALLBACK    0x00000002
+#define LINECALLCOMPLMODE_INTRUDE     0x00000004
+#define LINECALLCOMPLMODE_MESSAGE     0x00000008
+
+#define LINECALLFEATURE_ACCEPT                   0x00000001
+#define LINECALLFEATURE_ADDTOCONF                0x00000002
+#define LINECALLFEATURE_ANSWER                   0x00000004
+#define LINECALLFEATURE_BLINDTRANSFER            0x00000008
+#define LINECALLFEATURE_COMPLETECALL             0x00000010
+#define LINECALLFEATURE_COMPLETETRANSF           0x00000020
+#define LINECALLFEATURE_DIAL                     0x00000040
+#define LINECALLFEATURE_DROP                     0x00000080
+#define LINECALLFEATURE_GATHERDIGITS             0x00000100
+#define LINECALLFEATURE_GENERATEDIGITS           0x00000200
+#define LINECALLFEATURE_GENERATETONE             0x00000400
+#define LINECALLFEATURE_HOLD                     0x00000800
+#define LINECALLFEATURE_MONITORDIGITS            0x00001000
+#define LINECALLFEATURE_MONITORMEDIA             0x00002000
+#define LINECALLFEATURE_MONITORTONES             0x00004000
+#define LINECALLFEATURE_PARK                     0x00008000
+#define LINECALLFEATURE_PREPAREADDCONF           0x00010000
+#define LINECALLFEATURE_REDIRECT                 0x00020000
+#define LINECALLFEATURE_REMOVEFROMCONF           0x00040000
+#define LINECALLFEATURE_SECURECALL               0x00080000
+#define LINECALLFEATURE_SENDUSERUSER             0x00100000
+#define LINECALLFEATURE_SETCALLPARAMS            0x00200000
+#define LINECALLFEATURE_SETMEDIACONTROL          0x00400000
+#define LINECALLFEATURE_SETTERMINAL              0x00800000
+#define LINECALLFEATURE_SETUPCONF                0x01000000
+#define LINECALLFEATURE_SETUPTRANSFER            0x02000000
+#define LINECALLFEATURE_SWAPHOLD                 0x04000000
+#define LINECALLFEATURE_UNHOLD                   0x08000000
+
+typedef struct linedialparams_tag {
+    DWORD    dwDialPause;
+    DWORD    dwDialSpeed;
+    DWORD    dwDigitDuration;
+    DWORD    dwWaitForDialtone;
+} LINEDIALPARAMS, FAR *LPLINEDIALPARAMS;
+
+typedef struct linecallinfo_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    HLINE    hLine;
+    DWORD    dwLineDeviceID;
+    DWORD    dwAddressID;
+
+    DWORD    dwBearerMode;
+    DWORD    dwRate;
+    DWORD    dwMediaMode;
+
+    DWORD    dwAppSpecific;
+    DWORD    dwCallID;
+    DWORD    dwRelatedCallID;
+    DWORD    dwCallParamFlags;
+    DWORD    dwCallStates;
+
+    DWORD    dwMonitorDigitModes;
+    DWORD    dwMonitorMediaModes;
+    LINEDIALPARAMS    DialParams;
+
+    DWORD    dwOrigin;
+    DWORD    dwReason;
+    DWORD    dwCompletionID;
+    DWORD    dwNumOwners;
+    DWORD    dwNumMonitors;
+
+    DWORD    dwCountryCode;
+    DWORD    dwTrunk;
+
+    DWORD    dwCallerIDFlags;
+    DWORD    dwCallerIDSize;
+    DWORD    dwCallerIDOffset;
+    DWORD    dwCallerIDNameSize;
+    DWORD    dwCallerIDNameOffset;
+
+    DWORD    dwCalledIDFlags;
+    DWORD    dwCalledIDSize;
+    DWORD    dwCalledIDOffset;
+    DWORD    dwCalledIDNameSize;
+    DWORD    dwCalledIDNameOffset;
+
+    DWORD    dwConnectedIDFlags;
+    DWORD    dwConnectedIDSize;
+    DWORD    dwConnectedIDOffset;
+    DWORD    dwConnectedIDNameSize;
+    DWORD    dwConnectedIDNameOffset;
+
+    DWORD    dwRedirectionIDFlags;
+    DWORD    dwRedirectionIDSize;
+    DWORD    dwRedirectionIDOffset;
+    DWORD    dwRedirectionIDNameSize;
+    DWORD    dwRedirectionIDNameOffset;
+
+    DWORD    dwRedirectingIDFlags;
+    DWORD    dwRedirectingIDSize;
+    DWORD    dwRedirectingIDOffset;
+    DWORD    dwRedirectingIDNameSize;
+    DWORD    dwRedirectingIDNameOffset;
+
+    DWORD    dwAppNameSize;
+    DWORD    dwAppNameOffset;
+
+    DWORD    dwDisplayableAddressSize;
+    DWORD    dwDisplayableAddressOffset;
+
+    DWORD    dwCalledPartySize;
+    DWORD    dwCalledPartyOffset;
+
+    DWORD    dwCommentSize;
+    DWORD    dwCommentOffset;
+
+    DWORD    dwDisplaySize;
+    DWORD    dwDisplayOffset;
+
+    DWORD    dwUserUserInfoSize;
+    DWORD    dwUserUserInfoOffset;
+
+    DWORD    dwHighLevelCompSize;
+    DWORD    dwHighLevelCompOffset;
+
+    DWORD    dwLowLevelCompSize;
+    DWORD    dwLowLevelCompOffset;
+
+    DWORD    dwChargingInfoSize;
+    DWORD    dwChargingInfoOffset;
+
+    DWORD    dwTerminalModesSize;
+    DWORD    dwTerminalModesOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} LINECALLINFO, FAR *LPLINECALLINFO;
+
+#define LINECALLINFOSTATE_OTHER             0x00000001
+#define LINECALLINFOSTATE_DEVSPECIFIC       0x00000002
+#define LINECALLINFOSTATE_BEARERMODE        0x00000004
+#define LINECALLINFOSTATE_RATE              0x00000008
+#define LINECALLINFOSTATE_MEDIAMODE         0x00000010
+#define LINECALLINFOSTATE_APPSPECIFIC       0x00000020
+#define LINECALLINFOSTATE_CALLID            0x00000040
+#define LINECALLINFOSTATE_RELATEDCALLID     0x00000080
+#define LINECALLINFOSTATE_ORIGIN            0x00000100
+#define LINECALLINFOSTATE_REASON            0x00000200
+#define LINECALLINFOSTATE_COMPLETIONID      0x00000400
+#define LINECALLINFOSTATE_NUMOWNERINCR      0x00000800
+#define LINECALLINFOSTATE_NUMOWNERDECR      0x00001000
+#define LINECALLINFOSTATE_NUMMONITORS       0x00002000
+#define LINECALLINFOSTATE_TRUNK             0x00004000
+#define LINECALLINFOSTATE_CALLERID          0x00008000
+#define LINECALLINFOSTATE_CALLEDID          0x00010000
+#define LINECALLINFOSTATE_CONNECTEDID       0x00020000
+#define LINECALLINFOSTATE_REDIRECTIONID     0x00040000
+#define LINECALLINFOSTATE_REDIRECTINGID     0x00080000
+#define LINECALLINFOSTATE_DISPLAY           0x00100000
+#define LINECALLINFOSTATE_USERUSERINFO      0x00200000
+#define LINECALLINFOSTATE_HIGHLEVELCOMP     0x00400000
+#define LINECALLINFOSTATE_LOWLEVELCOMP      0x00800000
+#define LINECALLINFOSTATE_CHARGINGINFO      0x01000000
+#define LINECALLINFOSTATE_TERMINAL          0x02000000
+#define LINECALLINFOSTATE_DIALPARAMS        0x04000000
+#define LINECALLINFOSTATE_MONITORMODES      0x08000000
+
+typedef struct linecalllist_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+    
+    DWORD    dwCallsNumEntries;
+    DWORD    dwCallsSize;
+    DWORD    dwCallsOffset;
+} LINECALLLIST, FAR *LPLINECALLLIST;
+
+#define LINECALLORIGIN_OUTBOUND    0x00000001
+#define LINECALLORIGIN_INTERNAL    0x00000002
+#define LINECALLORIGIN_EXTERNAL    0x00000004
+#define LINECALLORIGIN_UNKNOWN     0x00000010
+#define LINECALLORIGIN_UNAVAIL     0x00000020
+#define LINECALLORIGIN_CONFERENCE  0x00000040
+
+#define LINECALLPARAMFLAGS_SECURE           0x00000001
+#define LINECALLPARAMFLAGS_IDLE             0x00000002
+#define LINECALLPARAMFLAGS_BLOCKID          0x00000004
+#define LINECALLPARAMFLAGS_ORIGOFFHOOK      0x00000008
+#define LINECALLPARAMFLAGS_DESTOFFHOOK      0x00000010
+
+typedef struct linecallparams_tag {     // Defaults:
+    DWORD    dwTotalSize;               // ---------
+    
+    DWORD    dwBearerMode;              // voice
+    DWORD    dwMinRate;                 // (3.1kHz)
+    DWORD    dwMaxRate;                 // (3.1kHz)
+    DWORD    dwMediaMode;               // interactiveVoice
+
+    DWORD    dwCallParamFlags;          // 0
+    DWORD    dwAddressMode;             // addressID
+    DWORD    dwAddressID;               // (any available)
+
+    LINEDIALPARAMS  DialParams;         // (0, 0, 0, 0)
+    
+    DWORD    dwOrigAddressSize;         // 0
+    DWORD    dwOrigAddressOffset;
+    DWORD    dwDisplayableAddressSize;
+    DWORD    dwDisplayableAddressOffset;
+
+    DWORD    dwCalledPartySize;         // 0
+    DWORD    dwCalledPartyOffset;
+
+    DWORD    dwCommentSize;             // 0
+    DWORD    dwCommentOffset;
+
+    DWORD    dwUserUserInfoSize;        // 0
+    DWORD    dwUserUserInfoOffset;
+
+    DWORD    dwHighLevelCompSize;       // 0
+    DWORD    dwHighLevelCompOffset;
+
+    DWORD    dwLowLevelCompSize;        // 0
+    DWORD    dwLowLevelCompOffset;
+
+    DWORD    dwDevSpecificSize;         // 0
+    DWORD    dwDevSpecificOffset;
+} LINECALLPARAMS, FAR *LPLINECALLPARAMS;
+
+
+#define LINECALLPARTYID_BLOCKED         0x00000001
+#define LINECALLPARTYID_OUTOFAREA       0x00000002
+#define LINECALLPARTYID_NAME            0x00000004
+#define LINECALLPARTYID_ADDRESS         0x00000008
+#define LINECALLPARTYID_PARTIAL         0x00000010
+#define LINECALLPARTYID_UNKNOWN         0x00000020
+#define LINECALLPARTYID_UNAVAIL         0x00000040
+
+#define LINECALLPRIVILEGE_NONE          0x00000001
+#define LINECALLPRIVILEGE_MONITOR       0x00000002
+#define LINECALLPRIVILEGE_OWNER         0x00000004
+
+#define LINECALLREASON_DIRECT           0x00000001
+#define LINECALLREASON_FWDBUSY          0x00000002
+#define LINECALLREASON_FWDNOANSWER      0x00000004
+#define LINECALLREASON_FWDUNCOND        0x00000008
+#define LINECALLREASON_PICKUP           0x00000010
+#define LINECALLREASON_UNPARK           0x00000020
+#define LINECALLREASON_REDIRECT         0x00000040
+#define LINECALLREASON_CALLCOMPLETION   0x00000080
+#define LINECALLREASON_TRANSFER         0x00000100
+#define LINECALLREASON_REMINDER         0x00000200
+#define LINECALLREASON_UNKNOWN          0x00000400
+#define LINECALLREASON_UNAVAIL          0x00000800
+
+#define LINECALLSELECT_LINE     0x00000001
+#define LINECALLSELECT_ADDRESS  0x00000002
+#define LINECALLSELECT_CALL     0x00000004
+
+#define LINECALLSTATE_IDLE                  0x00000001
+#define LINECALLSTATE_OFFERING              0x00000002
+#define LINECALLSTATE_ACCEPTED              0x00000004
+#define LINECALLSTATE_DIALTONE              0x00000008
+#define LINECALLSTATE_DIALING               0x00000010
+#define LINECALLSTATE_RINGBACK              0x00000020
+#define LINECALLSTATE_BUSY                  0x00000040
+#define LINECALLSTATE_SPECIALINFO           0x00000080
+#define LINECALLSTATE_CONNECTED             0x00000100
+#define LINECALLSTATE_PROCEEDING            0x00000200
+#define LINECALLSTATE_ONHOLD                0x00000400
+#define LINECALLSTATE_CONFERENCED           0x00000800
+#define LINECALLSTATE_ONHOLDPENDCONF        0x00001000
+#define LINECALLSTATE_ONHOLDPENDTRANSFER    0x00002000
+#define LINECALLSTATE_DISCONNECTED          0x00004000
+#define LINECALLSTATE_UNKNOWN               0x00008000
+
+typedef struct linecallstatus_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwCallState;
+    DWORD    dwCallStateMode;
+    DWORD    dwCallPrivilege;
+    DWORD    dwCallFeatures;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} LINECALLSTATUS, FAR *LPLINECALLSTATUS;
+
+#define LINEDEVCAPFLAGS_CROSSADDRCONF   0x00000001
+#define LINEDEVCAPFLAGS_HIGHLEVCOMP     0x00000002
+#define LINEDEVCAPFLAGS_LOWLEVCOMP      0x00000004
+#define LINEDEVCAPFLAGS_MEDIACONTROL    0x00000008
+#define LINEDEVCAPFLAGS_MULTIPLEADDR    0x00000010
+#define LINEDEVCAPFLAGS_CLOSEDROP       0x00000020
+#define LINEDEVCAPFLAGS_DIALBILLING     0x00000040
+#define LINEDEVCAPFLAGS_DIALQUIET       0x00000080
+#define LINEDEVCAPFLAGS_DIALDIALTONE    0x00000100
+
+typedef struct lineextensionid_tag {
+    DWORD    dwExtensionID0;
+    DWORD    dwExtensionID1;
+    DWORD    dwExtensionID2;
+    DWORD    dwExtensionID3;
+} LINEEXTENSIONID, FAR *LPLINEEXTENSIONID;
+
+
+typedef struct linedevcaps_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwProviderInfoSize;
+    DWORD    dwProviderInfoOffset;
+
+    DWORD    dwSwitchInfoSize;
+    DWORD    dwSwitchInfoOffset;
+
+    DWORD    dwPermanentLineID;
+    DWORD    dwLineNameSize;
+    DWORD    dwLineNameOffset;
+    DWORD    dwStringFormat;
+    
+    DWORD    dwAddressModes;
+    DWORD    dwNumAddresses;
+    DWORD    dwBearerModes;
+    DWORD    dwMaxRate;
+    DWORD    dwMediaModes;
+
+    DWORD    dwGenerateToneModes;
+    DWORD    dwGenerateToneMaxNumFreq;
+    DWORD    dwGenerateDigitModes;
+    DWORD    dwMonitorToneMaxNumFreq;
+    DWORD    dwMonitorToneMaxNumEntries;
+    DWORD    dwMonitorDigitModes;
+    DWORD    dwGatherDigitsMinTimeout;
+    DWORD    dwGatherDigitsMaxTimeout;
+
+    DWORD    dwMedCtlDigitMaxListSize;
+    DWORD    dwMedCtlMediaMaxListSize;
+    DWORD    dwMedCtlToneMaxListSize;
+    DWORD    dwMedCtlCallStateMaxListSize;
+
+    DWORD    dwDevCapFlags;
+    DWORD    dwMaxNumActiveCalls;
+    DWORD    dwAnswerMode;
+    DWORD    dwRingModes;
+    DWORD    dwLineStates;
+
+    DWORD    dwUUIAcceptSize;
+    DWORD    dwUUIAnswerSize;
+    DWORD    dwUUIMakeCallSize;
+    DWORD    dwUUIDropSize;
+    DWORD    dwUUISendUserUserInfoSize;
+    DWORD    dwUUICallInfoSize;
+    
+    LINEDIALPARAMS    MinDialParams;
+    LINEDIALPARAMS    MaxDialParams;
+    LINEDIALPARAMS    DefaultDialParams;
+
+    DWORD    dwNumTerminals;
+    DWORD    dwTerminalCapsSize;
+    DWORD    dwTerminalCapsOffset;
+    DWORD    dwTerminalTextEntrySize;
+    DWORD    dwTerminalTextSize;
+    DWORD    dwTerminalTextOffset;
+
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} LINEDEVCAPS, FAR *LPLINEDEVCAPS;
+    
+#define LINEDEVSTATE_OTHER              0x00000001
+#define LINEDEVSTATE_RINGING            0x00000002
+#define LINEDEVSTATE_CONNECTED          0x00000004
+#define LINEDEVSTATE_DISCONNECTED       0x00000008
+#define LINEDEVSTATE_MSGWAITON          0x00000010
+#define LINEDEVSTATE_MSGWAITOFF         0x00000020
+#define LINEDEVSTATE_INSERVICE          0x00000040
+#define LINEDEVSTATE_OUTOFSERVICE       0x00000080
+#define LINEDEVSTATE_MAINTENANCE        0x00000100
+#define LINEDEVSTATE_OPEN               0x00000200
+#define LINEDEVSTATE_CLOSE              0x00000400
+#define LINEDEVSTATE_NUMCALLS           0x00000800
+#define LINEDEVSTATE_NUMCOMPLETIONS     0x00001000
+#define LINEDEVSTATE_TERMINALS          0x00002000
+#define LINEDEVSTATE_ROAMMODE           0x00004000
+#define LINEDEVSTATE_BATTERY            0x00008000
+#define LINEDEVSTATE_SIGNAL             0x00010000
+#define LINEDEVSTATE_DEVSPECIFIC        0x00020000
+#define LINEDEVSTATE_REINIT             0x00040000
+#define LINEDEVSTATE_LOCK               0x00080000
+
+typedef struct linedevstatus_tag {
+    DWORD    dwTotalSize;
+    DWORD    dwNeededSize;
+    DWORD    dwUsedSize;
+
+    DWORD    dwNumOpens;
+    DWORD    dwOpenMediaModes;
+    DWORD    dwNumActiveCalls;
+    DWORD    dwNumOnHoldCalls;
+    DWORD    dwNumOnHoldPendCalls;
+    DWORD    dwLineFeatures;
+    DWORD    dwNumCallCompletions;
+    DWORD    dwRingMode;
+    DWORD    dwSignalLevel;
+    DWORD    dwBatteryLevel;
+    DWORD    dwRoamMode;
+    
+    DWORD    dwDevStatusFlags;
+    
+    DWORD    dwTerminalModesSize;
+    DWORD    dwTerminalModesOffset;
+    
+    DWORD    dwDevSpecificSize;
+    DWORD    dwDevSpecificOffset;
+} LINEDEVSTATUS, FAR *LPLINEDEVSTATUS;
+
+#define LINEDEVSTATUSFLAGS_CONNECTED  0x00000001
+#define LINEDEVSTATUSFLAGS_MSGWAIT    0x00000002
+#define LINEDEVSTATUSFLAGS_INSERVICE  0x00000004
+#define LINEDEVSTATUSFLAGS_LOCKED     0x00000008
+
+
+#define LINEDIALTONEMODE_NORMAL    0x00000001
+#define LINEDIALTONEMODE_SPECIAL   0x00000002
+#define LINEDIALTONEMODE_INTERNAL  0x00000004
+#define LINEDIALTONEMODE_EXTERNAL  0x00000008
+#define LINEDIALTONEMODE_UNKNOWN   0x00000010
+#define LINEDIALTONEMODE_UNAVAIL   0x00000020
+    
+#define LINEDIGITMODE_PULSE    0x00000001
+#define LINEDIGITMODE_DTMF     0x00000002
+#define LINEDIGITMODE_DTMFEND  0x00000004
+    
+#define LINEDISCONNECTMODE_NORMAL       0x00000001
+#define LINEDISCONNECTMODE_UNKNOWN      0x00000002
+#define LINEDISCONNECTMODE_REJECT       0x00000004
+#define LINEDISCONNECTMODE_PICKUP       0x00000008
+#define LINEDISCONNECTMODE_FORWARDED    0x00000010
+#define LINEDISCONNECTMODE_BUSY         0x00000020
+#define LINEDISCONNECTMODE_NOANSWER     0x00000040
+#define LINEDISCONNECTMODE_BADADDRESS   0x00000080
+#define LINEDISCONNECTMODE_UNREACHABLE  0x00000100
+#define LINEDISCONNECTMODE_CONGESTION   0x00000200
+#define LINEDISCONNECTMODE_INCOMPATIBLE 0x00000400
+#define LINEDISCONNECTMODE_UNAVAIL      0x00000800
+
+#define LINEERR_ALLOCATED                   0x80000001
+#define LINEERR_BADDEVICEID                 0x80000002
+#define LINEERR_BEARERMODEUNAVAIL           0x80000003
+#define LINEERR_CALLUNAVAIL                 0x80000005
+#define LINEERR_COMPLETIONOVERRUN           0x80000006
+#define LINEERR_CONFERENCEFULL              0x80000007
+#define LINEERR_DIALBILLING                 0x80000008
+#define LINEERR_DIALDIALTONE                0x80000009
+#define LINEERR_DIALPROMPT                  0x8000000A
+#define LINEERR_DIALQUIET                   0x8000000B
+#define LINEERR_INCOMPATIBLEAPIVERSION      0x8000000C
+#define LINEERR_INCOMPATIBLEEXTVERSION      0x8000000D
+#define LINEERR_INIFILECORRUPT              0x8000000E
+#define LINEERR_INUSE                       0x8000000F
+#define LINEERR_INVALADDRESS                0x80000010
+#define LINEERR_INVALADDRESSID              0x80000011
+#define LINEERR_INVALADDRESSMODE            0x80000012
+#define LINEERR_INVALADDRESSSTATE           0x80000013
+#define LINEERR_INVALAPPHANDLE              0x80000014
+#define LINEERR_INVALAPPNAME                0x80000015
+#define LINEERR_INVALBEARERMODE             0x80000016
+#define LINEERR_INVALCALLCOMPLMODE          0x80000017
+#define LINEERR_INVALCALLHANDLE             0x80000018
+#define LINEERR_INVALCALLPARAMS             0x80000019
+#define LINEERR_INVALCALLPRIVILEGE          0x8000001A
+#define LINEERR_INVALCALLSELECT             0x8000001B
+#define LINEERR_INVALCALLSTATE              0x8000001C
+#define LINEERR_INVALCALLSTATELIST          0x8000001D
+#define LINEERR_INVALCARD                   0x8000001E
+#define LINEERR_INVALCOMPLETIONID           0x8000001F
+#define LINEERR_INVALCONFCALLHANDLE         0x80000020
+#define LINEERR_INVALCONSULTCALLHANDLE      0x80000021
+#define LINEERR_INVALCOUNTRYCODE            0x80000022
+#define LINEERR_INVALDEVICECLASS            0x80000023
+#define LINEERR_INVALDEVICEHANDLE           0x80000024
+#define LINEERR_INVALDIALPARAMS             0x80000025
+#define LINEERR_INVALDIGITLIST              0x80000026
+#define LINEERR_INVALDIGITMODE              0x80000027
+#define LINEERR_INVALDIGITS                 0x80000028
+#define LINEERR_INVALEXTVERSION             0x80000029
+#define LINEERR_INVALGROUPID                0x8000002A
+#define LINEERR_INVALLINEHANDLE             0x8000002B
+#define LINEERR_INVALLINESTATE              0x8000002C
+#define LINEERR_INVALLOCATION               0x8000002D
+#define LINEERR_INVALMEDIALIST              0x8000002E
+#define LINEERR_INVALMEDIAMODE              0x8000002F
+#define LINEERR_INVALMESSAGEID              0x80000030
+#define LINEERR_INVALPARAM                  0x80000032
+#define LINEERR_INVALPARKID                 0x80000033
+#define LINEERR_INVALPARKMODE               0x80000034
+#define LINEERR_INVALPOINTER                0x80000035
+#define LINEERR_INVALPRIVSELECT             0x80000036
+#define LINEERR_INVALRATE                   0x80000037
+#define LINEERR_INVALREQUESTMODE            0x80000038
+#define LINEERR_INVALTERMINALID             0x80000039
+#define LINEERR_INVALTERMINALMODE           0x8000003A
+#define LINEERR_INVALTIMEOUT                0x8000003B 
+#define LINEERR_INVALTONE                   0x8000003C
+#define LINEERR_INVALTONELIST               0x8000003D
+#define LINEERR_INVALTONEMODE               0x8000003E
+#define LINEERR_INVALTRANSFERMODE           0x8000003F
+#define LINEERR_LINEMAPPERFAILED            0x80000040
+#define LINEERR_NOCONFERENCE                0x80000041
+#define LINEERR_NODEVICE                    0x80000042
+#define LINEERR_NODRIVER                    0x80000043
+#define LINEERR_NOMEM                       0x80000044
+#define LINEERR_NOREQUEST                   0x80000045
+#define LINEERR_NOTOWNER                    0x80000046
+#define LINEERR_NOTREGISTERED               0x80000047
+#define LINEERR_OPERATIONFAILED             0x80000048
+#define LINEERR_OPERATIONUNAVAIL            0x80000049
+#define LINEERR_RATEUNAVAIL                 0x8000004A
+#define LINEERR_RESOURCEUNAVAIL             0x8000004B
+#define LINEERR_REQUESTOVERRUN              0x8000004C
+#define LINEERR_STRUCTURETOOSMALL           0x8000004D
+#define LINEERR_TARGETNOTFOUND              0x8000004E
+#define LINEERR_TARGETSELF                  0x8000004F
+#define LINEERR_UNINITIALIZED               0x80000050
+#define LINEERR_USERUSERINFOTOOBIG          0x80000051
+#define LINEERR_REINIT                      0x80000052
+#define LINEERR_ADDRESSBLOCKED              0x80000053
+#define LINEERR_BILLINGREJECTED             0x80000054
+#define LINEERR_INVALFEATURE                0x80000055
+#define LINEERR_NOMULTIPLEINSTANCE          0x80000056
+
+
+#define LINEFEATURE_DEVSPECIFIC     0x00000001
+#define LINEFEATURE_DEVSPECIFICFEAT 0x00000002
+#define LINEFEATURE_FORWARD         0x00000004
+#define LINEFEATURE_MAKECALL        0x00000008
+#define LINEFEATURE_SETMEDIACONTROL 0x00000010
+#define LINEFEATURE_SETTERMINAL     0x00000020
+
+typedef struct lineforward_tag {
+    DWORD    dwForwardMode;
+
+    DWORD    dwCallerAddressSize;
+    DWORD    dwCallerAddressOffset;
+    
+    DWORD    dwDestCountryCode;
+    DWORD    dwDestAddressSize;
+    DWORD    dwDestAddressOffset;    
+} LINEFORWARD, FAR *LPLINEFORWARD;
+
+typedef struct lineforwardlist_tag {
+    DWORD    dwTotalSize;
+
+    DWORD    dwNumEntries;
+    LINEFORWARD    ForwardList[1];
+} LINEFORWARDLIST, FAR *LPLINEFORWARDLIST;
+
+#define LINEFORWARDMODE_UNCOND          0x00000001
+#define LINEFORWARDMODE_UNCONDINTERNAL  0x00000002
+#define LINEFORWARDMODE_UNCONDEXTERNAL  0x00000004
+#define LINEFORWARDMODE_UNCONDSPECIFIC  0x00000008
+#define LINEFORWARDMODE_BUSY            0x00000010
+#define LINEFORWARDMODE_BUSYINTERNAL    0x00000020
+#define LINEFORWARDMODE_BUSYEXTERNAL    0x00000040
+#define LINEFORWARDMODE_BUSYSPECIFIC    0x00000080
+#define LINEFORWARDMODE_NOANSW          0x00000100
+#define LINEFORWARDMODE_NOANSWINTERNAL  0x00000200
+#define LINEFORWARDMODE_NOANSWEXTERNAL  0x00000400
+#define LINEFORWARDMODE_NOANSWSPECIFIC  0x00000800
+#define LINEFORWARDMODE_BUSYNA          0x00001000
+#define LINEFORWARDMODE_BUSYNAINTERNAL  0x00002000
+#define LINEFORWARDMODE_BUSYNAEXTERNAL  0x00004000
+#define LINEFORWARDMODE_BUSYNASPECIFIC  0x00008000
+
+#define LINEGATHERTERM_BUFFERFULL    0x00000001
+#define LINEGATHERTERM_TERMDIGIT     0x00000002
+#define LINEGATHERTERM_FIRSTTIMEOUT  0x00000004
+#define LINEGATHERTERM_INTERTIMEOUT  0x00000008
+#define LINEGATHERTERM_CANCEL        0x00000010
+
+#define LINEGENERATETERM_DONE    0x00000001
+#define LINEGENERATETERM_CANCEL  0x00000002
+
+typedef struct linegeneratetone_tag {
+    DWORD    dwFrequency;
+    DWORD    dwCadenceOn;
+    DWORD    dwCadenceOff;
+    DWORD    dwVolume;
+} LINEGENERATETONE, FAR *LPLINEGENERATETONE;
+
+#define LINEMAPPER         0xFFFFFFFF
+typedef struct linemediacontrolcallstate_tag {
+    DWORD    dwCallStates;
+    DWORD    dwMediaControl;
+} LINEMEDIACONTROLCALLSTATE, 
+FAR *LPLINEMEDIACONTROLCALLSTATE;
+
+typedef struct linemediacontroldigit_tag {
+    DWORD            dwDigit;
+    DWORD            dwDigitModes;
+    DWORD            dwMediaControl;
+} LINEMEDIACONTROLDIGIT, FAR *LPLINEMEDIACONTROLDIGIT;
+
+typedef struct linemediacontrolmedia_tag {
+    DWORD            dwMediaModes;
+    DWORD            dwDuration;
+    DWORD            dwMediaControl;
+} LINEMEDIACONTROLMEDIA, FAR *LPLINEMEDIACONTROLMEDIA;
+
+typedef struct linemediacontroltone_tag {
+    DWORD    dwAppSpecific;
+    DWORD    dwDuration;
+    DWORD    dwFrequency1;
+    DWORD    dwFrequency2;
+    DWORD    dwFrequency3;
+    DWORD    dwMediaControl;
+} LINEMEDIACONTROLTONE, FAR *LPLINEMEDIACONTROLTONE;
+
+#define LINEMEDIACONTROL_NONE           0x00000001
+#define LINEMEDIACONTROL_START          0x00000002
+#define LINEMEDIACONTROL_RESET          0x00000004
+#define LINEMEDIACONTROL_PAUSE          0x00000008
+#define LINEMEDIACONTROL_RESUME         0x00000010
+#define LINEMEDIACONTROL_RATEUP         0x00000020
+#define LINEMEDIACONTROL_RATEDOWN       0x00000040
+#define LINEMEDIACONTROL_RATENORMAL     0x00000080
+#define LINEMEDIACONTROL_VOLUMEUP       0x00000100
+#define LINEMEDIACONTROL_VOLUMEDOWN     0x00000200
+#define LINEMEDIACONTROL_VOLUMENORMAL   0x00000400
+
+#define LINEMEDIAMODE_UNKNOWN           0x00000002
+#define LINEMEDIAMODE_INTERACTIVEVOICE  0x00000004
+#define LINEMEDIAMODE_AUTOMATEDVOICE    0x00000008
+#define LINEMEDIAMODE_DATAMODEM         0x00000010
+#define LINEMEDIAMODE_G3FAX             0x00000020
+#define LINEMEDIAMODE_TDD               0x00000040
+#define LINEMEDIAMODE_G4FAX             0x00000080
+#define LINEMEDIAMODE_DIGITALDATA       0x00000100
+#define LINEMEDIAMODE_TELETEX           0x00000200
+#define LINEMEDIAMODE_VIDEOTEX          0x00000400
+#define LINEMEDIAMODE_TELEX             0x00000800
+#define LINEMEDIAMODE_MIXED             0x00001000
+#define LINEMEDIAMODE_ADSI              0x00002000
+
+#define LAST_LINEMEDIAMODE              0x00002000
+
+
+typedef struct linemonitortone_tag {
+    DWORD    dwAppSpecific;
+    DWORD    dwDuration;
+    DWORD    dwFrequency1;
+    DWORD    dwFrequency2;
+    DWORD    dwFrequency3;
+} LINEMONITORTONE, FAR *LPLINEMONITORTONE;
+
+#define LINEPARKMODE_DIRECTED       0x00000001
+#define LINEPARKMODE_NONDIRECTED    0x00000002
+
+#define LINEREMOVEFROMCONF_NONE    0x00000001
+#define LINEREMOVEFROMCONF_LAST    0x00000002
+#define LINEREMOVEFROMCONF_ANY     0x00000003
+
+typedef struct linereqmakecall_tag {
+    char    szDestAddress[TAPIMAXDESTADDRESSSIZE];
+    char    szAppName[TAPIMAXAPPNAMESIZE];
+    char    szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+    char    szComment[TAPIMAXCOMMENTSIZE];
+} LINEREQMAKECALL, FAR *LPLINEREQMAKECALL;
+
+typedef struct linereqmediacall_tag {
+    HWND    hWnd;
+    WPARAM  wRequestID;
+    char    szDeviceClass[TAPIMAXDEVICECLASSSIZE];
+    unsigned char    ucDeviceID[TAPIMAXDEVICEIDSIZE];
+    DWORD    dwSize;
+    DWORD    dwSecure;
+    char    szDestAddress[TAPIMAXDESTADDRESSSIZE];
+    char    szAppName[TAPIMAXAPPNAMESIZE];
+    char    szCalledParty[TAPIMAXCALLEDPARTYSIZE];
+    char    szComment[TAPIMAXCOMMENTSIZE];
+} LINEREQMEDIACALL, FAR *LPLINEREQMEDIACALL;
+
+#define LINEREQUESTMODE_MAKECALL     0x00000001
+#define LINEREQUESTMODE_MEDIACALL    0x00000002
+#define LINEREQUESTMODE_DROP         0x00000004
+
+#define LAST_LINEREQUESTMODE         LINEREQUESTMODE_MEDIACALL
+
+
+#define LINEROAMMODE_UNKNOWN    0x00000001
+#define LINEROAMMODE_UNAVAIL    0x00000002
+#define LINEROAMMODE_HOME       0x00000004
+#define LINEROAMMODE_ROAMA      0x00000008
+#define LINEROAMMODE_ROAMB      0x00000010
+
+#define LINESPECIALINFO_NOCIRCUIT    0x00000001
+#define LINESPECIALINFO_CUSTIRREG    0x00000002
+#define LINESPECIALINFO_REORDER      0x00000004
+#define LINESPECIALINFO_UNKNOWN      0x00000008
+#define LINESPECIALINFO_UNAVAIL      0x00000010
+
+typedef struct linetermcaps_tag {
+    DWORD    dwTermDev;
+    DWORD    dwTermModes;
+    DWORD    dwTermSharing;
+} LINETERMCAPS, FAR *LPLINETERMCAPS;
+
+#define LINETERMDEV_PHONE      0x00000001
+#define LINETERMDEV_HEADSET    0x00000002
+#define LINETERMDEV_SPEAKER    0x00000004
+
+#define LINETERMMODE_BUTTONS       0x00000001
+#define LINETERMMODE_LAMPS         0x00000002
+#define LINETERMMODE_DISPLAY       0x00000004
+#define LINETERMMODE_RINGER        0x00000008
+#define LINETERMMODE_HOOKSWITCH    0x00000010
+#define LINETERMMODE_MEDIATOLINE   0x00000020
+#define LINETERMMODE_MEDIAFROMLINE 0x00000040
+#define LINETERMMODE_MEDIABIDIRECT 0x00000080
+
+#define LINETERMSHARING_PRIVATE       0x00000001
+#define LINETERMSHARING_SHAREDEXCL    0x00000002
+#define LINETERMSHARING_SHAREDCONF    0x00000004
+
+#define LINETONEMODE_CUSTOM    0x00000001
+#define LINETONEMODE_RINGBACK  0x00000002
+#define LINETONEMODE_BUSY      0x00000004
+#define LINETONEMODE_BEEP      0x00000008
+#define LINETONEMODE_BILLING   0x00000010
+
+#define LINETRANSFERMODE_TRANSFER    0x00000001
+#define LINETRANSFERMODE_CONFERENCE  0x00000002
+
+typedef struct linetranslateoutput_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+
+    DWORD dwDialableStringSize;
+    DWORD dwDialableStringOffset;
+    DWORD dwDisplayableStringSize;
+    DWORD dwDisplayableStringOffset;
+
+    DWORD dwCurrentCountry;
+    DWORD dwDestCountry;
+    DWORD dwTranslateResults;
+} LINETRANSLATEOUTPUT, FAR *LPLINETRANSLATEOUTPUT;
+
+typedef struct linetranslatecaps_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+
+    DWORD dwNumLocations;
+    DWORD dwLocationListSize;
+    DWORD dwLocationListOffset;
+    
+    DWORD dwCurrentLocationID;
+    
+    DWORD dwNumCards;
+    DWORD dwCardListSize;
+    DWORD dwCardListOffset;
+
+    DWORD dwCurrentPreferredCardID;
+} LINETRANSLATECAPS, FAR *LPLINETRANSLATECAPS;
+
+typedef struct linelocationentry_tag {
+    DWORD dwPermanentLocationID;
+    DWORD dwLocationNameSize;
+    DWORD dwLocationNameOffset;
+    DWORD dwCountryCode;
+    DWORD dwCityCodeSize;
+    DWORD dwCityCodeOffset;
+    DWORD dwPreferredCardID;
+} LINELOCATIONENTRY, FAR *LPLINELOCATIONENTRY;
+
+typedef struct linecardentry_tag {
+    DWORD dwPermanentCardID;
+    DWORD dwCardNameSize;
+    DWORD dwCardNameOffset;
+} LINECARDENTRY, FAR *LPLINECARDENTRY;
+
+#define LINETOLLLISTOPTION_ADD         0x00000001
+#define LINETOLLLISTOPTION_REMOVE      0x00000002
+
+#define LINETRANSLATEOPTION_CARDOVERRIDE  0x00000001
+
+#define LINETRANSLATERESULT_CANONICAL              0x00000001
+#define LINETRANSLATERESULT_INTERNATIONAL          0x00000002
+#define LINETRANSLATERESULT_LONGDISTANCE           0x00000004
+#define LINETRANSLATERESULT_LOCAL                  0x00000008
+#define LINETRANSLATERESULT_INTOLLLIST             0x00000010
+#define LINETRANSLATERESULT_NOTINTOLLLIST          0x00000020
+#define LINETRANSLATERESULT_DIALBILLING            0x00000040
+#define LINETRANSLATERESULT_DIALQUIET              0x00000080
+#define LINETRANSLATERESULT_DIALDIALTONE           0x00000100
+#define LINETRANSLATERESULT_DIALPROMPT             0x00000200
+
+// Simple Telephony prototypes
+
+LONG WINAPI tapiRequestMakeCall(
+        LPCSTR lpszDestAddress,
+        LPCSTR lpszAppName,
+        LPCSTR lpszCalledParty,
+        LPCSTR lpszComment);
+
+LONG WINAPI tapiRequestMediaCall(
+        HWND hWnd,
+        WPARAM wRequestID,
+        LPCSTR lpszDeviceClass,
+        LPCSTR lpDeviceID,
+        DWORD dwSize,
+        DWORD dwSecure,
+        LPCSTR lpszDestAddress,
+        LPCSTR lpszAppName,
+        LPCSTR lpszCalledParty,
+        LPCSTR lpszComment);
+
+LONG WINAPI tapiRequestDrop(
+        HWND hWnd,
+        WPARAM wRequestID);
+
+LONG WINAPI lineRegisterRequestRecipient(
+        HLINEAPP hLineApp,
+        DWORD dwRegistrationInstance,
+        DWORD dwRequestMode,
+        DWORD bEnable);
+
+LONG WINAPI tapiGetLocationInfo(
+      LPSTR lpszCountryCode,
+      LPSTR lpszCityCode);
+      
+// Tapi Address Translation procedures
+LONG WINAPI lineSetCurrentLocation(
+    HLINEAPP hLineApp,
+    DWORD dwLocation);
+
+LONG WINAPI lineSetTollList(
+    HLINEAPP hLineApp,
+    DWORD dwDeviceID,
+    LPCSTR lpszAddressIn,
+    DWORD dwTollListOption);
+
+LONG WINAPI lineTranslateAddress(
+    HLINEAPP hLineApp,
+    DWORD dwDeviceID,
+    DWORD dwAPIVersion,
+    LPCSTR lpszAddressIn,
+    DWORD dwCard,
+    DWORD dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT lpTranslateOutput);
+
+LONG WINAPI lineGetTranslateCaps(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps);
+
+
+// Tapi function prototypes
+
+LONG WINAPI lineAccept(
+        HCALL hCall, 
+        LPCSTR lpsUserUserInfo,
+        DWORD dwSize);
+
+LONG WINAPI lineAddToConference(
+        HCALL hConfCall, 
+        HCALL hConsultCall);
+
+LONG WINAPI lineAnswer(
+        HCALL hCall,
+        LPCSTR lpsUserUserInfo,
+        DWORD dwSize);
+
+LONG WINAPI lineBlindTransfer(
+        HCALL hCall, 
+        LPCSTR lpszDestAddress,
+        DWORD dwCountryCode);
+
+LONG WINAPI lineClose(
+        HLINE hLine);
+
+LONG WINAPI  lineCompleteCall(
+        HCALL hCall, 
+        LPDWORD lpdwCompletionID, 
+        DWORD dwCompletionMode, 
+        DWORD dwMessageID);
+
+LONG WINAPI lineCompleteTransfer(
+        HCALL hCall, 
+        HCALL hConsultCall,
+        LPHCALL lphConfCall,
+        DWORD dwTransferMode);
+
+LONG WINAPI lineConfigDialog(
+        DWORD dwDeviceID,
+        HWND  hwndOwner,
+        LPCSTR lpszDeviceClass);
+
+LONG WINAPI lineDeallocateCall(
+        HCALL hCall);
+
+LONG WINAPI lineDevSpecific(
+        HLINE hLine, 
+        DWORD dwAddressID,
+        HCALL hCall,
+        LPVOID lpParams, 
+        DWORD dwSize);
+
+LONG WINAPI lineDevSpecificFeature(
+        HLINE hLine, 
+        DWORD dwFeature, 
+        LPVOID lpParams, 
+        DWORD dwSize);
+
+LONG WINAPI lineDial(
+        HCALL hCall, 
+        LPCSTR lpszDestAddress, 
+        DWORD dwCountryCode);
+
+LONG WINAPI lineDrop(
+        HCALL hCall, 
+        LPCSTR lpsUserUserInfo, 
+        DWORD dwSize);
+
+LONG WINAPI lineForward(
+        HLINE hLine, 
+        DWORD bAllAddresses, 
+        DWORD dwAddressID, 
+        LPLINEFORWARDLIST const lpForwardList, 
+        DWORD dwNumRingsNoAnswer,
+        LPHCALL lphConsultCall,
+        LPLINECALLPARAMS const lpCallParams);
+
+LONG WINAPI lineGatherDigits(
+        HCALL hCall, 
+        DWORD dwDigitModes, 
+        LPSTR lpsDigits, 
+        DWORD dwNumDigits, 
+        LPCSTR lpszTerminationDigits, 
+        DWORD dwFirstDigitTimeout, 
+        DWORD dwInterDigitTimeout);
+
+LONG WINAPI lineGenerateDigits(
+        HCALL hCall, 
+        DWORD dwDigitMode, 
+        LPCSTR lpszDigits, 
+        DWORD dwDuration);
+
+LONG WINAPI lineGenerateTone(
+        HCALL hCall, 
+        DWORD dwToneMode,
+        DWORD dwDuration,
+        DWORD dwNumTones,
+        LPLINEGENERATETONE const lpTones);
+
+LONG WINAPI lineGetAddressCaps(
+        HLINEAPP hLineApp, 
+        DWORD dwDeviceID, 
+        DWORD dwAddressID, 
+        DWORD dwAPIVersion,
+        DWORD dwExtVersion, 
+        LPLINEADDRESSCAPS lpAddressCaps);
+
+LONG WINAPI lineGetAddressID(
+        HLINE hLine, 
+        LPDWORD lpdwAddressID, 
+        DWORD dwAddressMode, 
+        LPCSTR lpsAddress, 
+        DWORD dwSize);
+
+LONG WINAPI lineGetAddressStatus(
+        HLINE hLine,
+        DWORD dwAddressID,
+        LPLINEADDRESSSTATUS lpAddressStatus);
+
+LONG WINAPI lineGetCallInfo(
+        HCALL hCall, 
+        LPLINECALLINFO lpCallInfo);
+
+LONG WINAPI lineGetCallStatus(
+        HCALL hCall, 
+        LPLINECALLSTATUS lpCallStatus);
+
+LONG WINAPI lineGetConfRelatedCalls(
+        HCALL hCall,
+        LPLINECALLLIST lpCallList);
+        
+LONG WINAPI lineGetDevCaps(
+        HLINEAPP hLineApp, 
+        DWORD dwDeviceID, 
+        DWORD dwAPIVersion,
+        DWORD dwExtVersion, 
+        LPLINEDEVCAPS lpLineDevCaps);
+
+LONG WINAPI lineGetDevConfig(
+        DWORD dwDeviceID,
+        LPVARSTRING lpDeviceConfig,
+        LPCSTR lpszDeviceClass);
+
+LONG WINAPI lineGetNewCalls(
+        HLINE hLine,
+        DWORD dwAddressID,
+        DWORD dwSelect,
+        LPLINECALLLIST lpCallList);
+
+LONG WINAPI lineGetIcon(
+        DWORD dwDeviceID,
+        LPCSTR lpszDeviceClass,
+        LPHICON lphIcon);
+        
+LONG WINAPI lineGetID(
+        HLINE hLine,
+        DWORD dwAddressID, 
+        HCALL hCall,
+        DWORD dwSelect,        
+        LPVARSTRING lpDeviceID, 
+        LPCSTR lpszDeviceClass);
+
+LONG WINAPI lineGetLineDevStatus(
+        HLINE hLine, 
+        LPLINEDEVSTATUS lpLineDevStatus);
+
+LONG WINAPI lineGetNumRings(
+        HLINE hLine, 
+        DWORD dwAddressID, 
+        LPDWORD lpdwNumRings);
+
+LONG WINAPI lineGetRequest(
+        HLINEAPP hLineApp,
+        DWORD dwRequestMode,
+        LPVOID lpRequestBuffer);
+
+LONG WINAPI lineGetStatusMessages(
+        HLINE hLine, 
+        LPDWORD lpdwLineStates, 
+        LPDWORD lpdwAddressStates);
+
+LONG WINAPI lineHandoff(
+        HCALL hCall, 
+        LPCSTR lpszFileName,
+        DWORD dwMediaMode);
+
+LONG WINAPI lineHold(
+        HCALL hCall);
+
+LONG WINAPI lineInitialize(
+        LPHLINEAPP lphLineApp,
+        HINSTANCE hInstance,
+        LINECALLBACK lpfnCallback,
+        LPCSTR lpszAppName,
+        LPDWORD lpdwNumDevs);
+
+LONG WINAPI lineMakeCall(
+        HLINE hLine, 
+        LPHCALL lphCall, 
+        LPCSTR lpszDestAddress, 
+        DWORD dwCountryCode, 
+        LPLINECALLPARAMS const lpCallParams);
+
+LONG WINAPI lineMonitorDigits(
+        HCALL hCall, 
+        DWORD dwDigitModes);
+
+LONG WINAPI lineMonitorMedia(
+        HCALL hCall, 
+        DWORD dwMediaModes);
+
+LONG WINAPI lineMonitorTones(
+        HCALL hCall, 
+        LPLINEMONITORTONE const lpToneList, 
+        DWORD dwNumEntries);
+
+LONG WINAPI lineNegotiateAPIVersion(
+        HLINEAPP hLineApp,
+        DWORD dwDeviceID,
+        DWORD dwAPILowVersion,
+        DWORD dwAPIHighVersion,
+        LPDWORD lpdwAPIVersion,
+        LPLINEEXTENSIONID lpExtensionID);
+
+LONG WINAPI lineNegotiateExtVersion(
+        HLINEAPP hLineApp,
+        DWORD dwDeviceID,
+        DWORD dwAPIVersion,
+        DWORD dwExtLowVersion,
+        DWORD dwExtHighVersion,
+        LPDWORD lpdwExtVersion);
+
+LONG WINAPI lineOpen(
+        HLINEAPP hLineApp, 
+        DWORD dwDeviceID,
+        LPHLINE lphLine,
+        DWORD dwAPIVersion,
+        DWORD dwExtVersion,
+        DWORD dwCallbackInstance,
+        DWORD dwPrivileges,
+        DWORD dwMediaModes,
+        LPLINECALLPARAMS const lpCallParams);
+
+LONG WINAPI linePark(
+        HCALL hCall, 
+        DWORD dwParkMode, 
+        LPCSTR lpszDirAddress,
+        LPVARSTRING lpNonDirAddress);
+
+LONG WINAPI linePickup(
+        HLINE hLine,
+        DWORD dwAddressID,
+        LPHCALL lphCall, 
+        LPCSTR lpszDestAddress, 
+        LPCSTR lpszGroupID);
+
+LONG WINAPI linePrepareAddToConference(
+        HCALL            hConfCall,
+        LPHCALL          lphConsultCall,
+        LPLINECALLPARAMS const lpCallParams);
+        
+LONG WINAPI lineRedirect(
+        HCALL hCall, 
+        LPCSTR lpszDestAddress, 
+        DWORD dwCountryCode);
+
+LONG WINAPI lineRemoveFromConference(
+        HCALL hCall);
+
+LONG WINAPI lineSecureCall(
+        HCALL hCall);
+
+LONG WINAPI lineSendUserUserInfo(
+        HCALL hCall, 
+        LPCSTR lpsUserUserInfo, 
+        DWORD dwSize);
+
+LONG WINAPI lineSetAppSpecific(
+        HCALL hCall, 
+        DWORD dwAppSpecific);
+
+LONG WINAPI lineSetCallParams(
+        HCALL hCall, 
+        DWORD dwBearerMode,
+        DWORD dwMinRate,
+        DWORD dwMaxRate,
+        LPLINEDIALPARAMS const lpDialParams);
+
+LONG WINAPI lineSetCallPrivilege(
+        HCALL hCall,
+        DWORD dwCallPrivilege);
+
+LONG WINAPI lineSetDevConfig(
+        DWORD dwDeviceID,
+        LPVOID const lpDeviceConfig,
+        DWORD dwSize,
+        LPCSTR lpszDeviceClass);
+
+LONG WINAPI lineSetMediaControl(
+        HLINE hLine,
+        DWORD dwAddressID,
+        HCALL hCall, 
+        DWORD dwSelect,
+        LPLINEMEDIACONTROLDIGIT const lpDigitList, 
+        DWORD dwDigitNumEntries, 
+        LPLINEMEDIACONTROLMEDIA const lpMediaList, 
+        DWORD dwMediaNumEntries, 
+        LPLINEMEDIACONTROLTONE const lpToneList, 
+        DWORD dwToneNumEntries, 
+        LPLINEMEDIACONTROLCALLSTATE const lpCallStateList, 
+        DWORD dwCallStateNumEntries);
+
+LONG WINAPI lineSetMediaMode(
+        HCALL hCall,
+        DWORD dwMediaModes);
+
+LONG WINAPI lineSetNumRings(
+        HLINE hLine, 
+        DWORD dwAddressID, 
+        DWORD dwNumRings);
+
+LONG WINAPI lineSetStatusMessages(
+        HLINE hLine, 
+        DWORD dwLineStates, 
+        DWORD dwAddressStates);
+
+LONG WINAPI lineSetTerminal(
+        HLINE hLine, 
+        DWORD dwAddressID,
+        HCALL hCall,
+        DWORD dwSelect,
+        DWORD dwTerminalModes, 
+        DWORD dwTerminalID, 
+        DWORD  bEnable);
+
+LONG WINAPI lineSetupConference(
+        HCALL hCall,
+        HLINE hLine,
+        LPHCALL lphConfCall, 
+        LPHCALL lphConsultCall, 
+        DWORD dwNumParties,
+        LPLINECALLPARAMS const lpCallParams);
+
+LONG WINAPI lineSetupTransfer(
+        HCALL hCall, 
+        LPHCALL lphConsultCall,
+        LPLINECALLPARAMS const lpCallParams);
+
+LONG WINAPI lineShutdown(
+        HLINEAPP hLineApp);
+
+LONG WINAPI lineSwapHold(
+        HCALL hActiveCall, 
+        HCALL hHeldCall);
+
+LONG WINAPI lineUncompleteCall(
+        HLINE hLine, 
+        DWORD dwCompletionID);
+
+LONG WINAPI lineUnhold(
+        HCALL hCall);
+
+LONG WINAPI lineUnpark(
+        HLINE hLine,
+        DWORD dwAddressID,
+        LPHCALL lphCall, 
+        LPCSTR lpszDestAddress);
+
+LONG WINAPI phoneClose(
+        HPHONE hPhone);
+
+LONG WINAPI phoneConfigDialog(
+        DWORD dwDeviceID,
+        HWND  hwndOwner,
+        LPCSTR lpszDeviceClass);
+
+
+LONG WINAPI phoneDevSpecific(
+        HPHONE hPhone, 
+        LPVOID lpParams, 
+        DWORD dwSize);
+
+LONG WINAPI phoneGetButtonInfo(
+        HPHONE hPhone, 
+        DWORD dwButtonLampID, 
+        LPPHONEBUTTONINFO lpButtonInfo);
+
+LONG WINAPI phoneGetData(
+        HPHONE hPhone, 
+        DWORD dwDataID, 
+        LPVOID lpData, 
+        DWORD dwSize);
+
+LONG WINAPI phoneGetDevCaps(
+        HPHONEAPP hPhoneApp, 
+        DWORD dwDeviceID,
+        DWORD dwAPIVersion, 
+        DWORD dwExtVersion, 
+        LPPHONECAPS lpPhoneCaps);
+
+LONG WINAPI phoneGetDisplay(
+        HPHONE hPhone, 
+        LPVARSTRING lpDisplay);
+
+LONG WINAPI phoneGetGain(
+        HPHONE hPhone, 
+        DWORD dwHookSwitchDev, 
+        LPDWORD lpdwGain);
+
+LONG WINAPI phoneGetHookSwitch(
+        HPHONE hPhone, 
+        LPDWORD lpdwHookSwitchDevs);
+
+LONG WINAPI phoneGetIcon(
+        DWORD dwDeviceID,
+        LPCSTR lpszDeviceClass,
+        LPHICON lphIcon);
+
+LONG WINAPI phoneGetID(
+        HPHONE hPhone, 
+        LPVARSTRING lpDeviceID, 
+        LPCSTR lpszDeviceClass);
+
+LONG WINAPI phoneGetLamp(
+        HPHONE hPhone, 
+        DWORD dwButtonLampID, 
+        LPDWORD lpdwLampMode);
+
+LONG WINAPI phoneGetRing(
+        HPHONE hPhone, 
+        LPDWORD lpdwRingMode, 
+        LPDWORD lpdwVolume);
+
+LONG WINAPI phoneGetStatus(
+        HPHONE hPhone, 
+        LPPHONESTATUS lpPhoneStatus);
+
+LONG WINAPI phoneGetStatusMessages(
+        HPHONE hPhone, 
+        LPDWORD lpdwPhoneStates,
+        LPDWORD lpdwButtonModes,
+        LPDWORD lpdwButtonStates);
+
+LONG WINAPI phoneGetVolume(
+        HPHONE hPhone, 
+        DWORD dwHookSwitchDev, 
+        LPDWORD lpdwVolume);
+
+LONG WINAPI phoneInitialize(
+        LPHPHONEAPP   lphPhoneApp,
+        HINSTANCE     hInstance,
+        PHONECALLBACK lpfnCallback,
+        LPCSTR lpszAppName,
+        LPDWORD       lpdwNumDevs);
+
+LONG WINAPI phoneNegotiateAPIVersion(
+        HPHONEAPP hPhoneApp,
+        DWORD dwDeviceID,
+        DWORD dwAPILowVersion,
+        DWORD dwAPIHighVersion,
+        LPDWORD lpdwAPIVersion,
+        LPPHONEEXTENSIONID lpExtensionID);
+
+LONG WINAPI phoneNegotiateExtVersion(
+        HPHONEAPP hPhoneApp,
+        DWORD dwDeviceID,
+        DWORD dwAPIVersion,
+        DWORD dwExtLowVersion,
+        DWORD dwExtHighVersion,
+        LPDWORD lpdwExtVersion);
+
+LONG WINAPI phoneOpen(
+        HPHONEAPP hPhoneApp, 
+        DWORD dwDeviceID,
+        LPHPHONE lphPhone,
+        DWORD dwAPIVersion,
+        DWORD dwExtVersion,
+        DWORD dwCallbackInstance,
+        DWORD dwPrivilege);
+
+LONG WINAPI phoneSetButtonInfo(
+        HPHONE hPhone, 
+        DWORD dwButtonLampID, 
+        LPPHONEBUTTONINFO const lpButtonInfo);
+
+LONG WINAPI phoneSetData(
+        HPHONE hPhone, 
+        DWORD dwDataID, 
+        LPVOID const lpData, 
+        DWORD dwSize);
+
+LONG WINAPI phoneSetDisplay(
+        HPHONE hPhone, 
+        DWORD dwRow, 
+        DWORD dwColumn, 
+        LPCSTR lpsDisplay,
+        DWORD dwSize);
+
+LONG WINAPI phoneSetGain(
+        HPHONE hPhone, 
+        DWORD  dwHookSwitchDev, 
+        DWORD  dwGain);
+
+LONG WINAPI phoneSetHookSwitch(
+        HPHONE hPhone, 
+        DWORD  dwHookSwitchDevs, 
+        DWORD  dwHookSwitchMode);
+
+LONG WINAPI phoneSetLamp(
+        HPHONE hPhone, 
+        DWORD  dwButtonLampID, 
+        DWORD  dwLampMode);
+
+LONG WINAPI phoneSetRing(
+        HPHONE hPhone, 
+        DWORD  dwRingMode, 
+        DWORD  dwVolume);
+
+LONG WINAPI phoneSetStatusMessages(
+        HPHONE hPhone, 
+        DWORD  dwPhoneStates,
+        DWORD  dwButtonModes,
+        DWORD  dwButtonStates);
+
+LONG WINAPI phoneSetVolume(
+        HPHONE hPhone, 
+        DWORD  dwHookSwitchDev, 
+        DWORD  dwVolume);
+
+LONG WINAPI phoneShutdown(
+        HPHONEAPP hPhoneApp);
+#ifdef __cplusplus
+}                       /* End of extern "C" { */
+#endif   /* __cplusplus */
+
+#pragma pack()
+
+#endif // TAPI_H
diff --git a/private/tapi/dev/inc/tapi10/tspi.h b/private/tapi/dev/inc/tapi10/tspi.h
new file mode 100644
index 000000000..838c5d69a
--- /dev/null
+++ b/private/tapi/dev/inc/tapi10/tspi.h
@@ -0,0 +1,763 @@
+// The  Telephony  API  is jointly copyrighted by Intel and Microsoft.  You are
+// granted  a royalty free worldwide, unlimited license to make copies, and use
+// the   API/SPI  for  making  applications/drivers  that  interface  with  the
+// specification provided that this paragraph and the Intel/Microsoft copyright
+// statement is maintained as is in the text and source code files.
+//
+// Copyright 1992, 1993 Intel/Microsoft, all rights reserved.
+
+#ifndef TSPI_H
+#define TSPI_H
+
+
+#include <windows.h>
+
+#include "tapi.h"
+
+// tspi.h  is  only  of  use  in  conjunction  with tapi.h.  Very few types are
+// defined  in  tspi.h.   Most  types of procedure formal parameters are simply
+// passed through from corresponding procedures in tapi.h.  A working knowledge
+// of the TAPI interface is required for an understanding of this interface.
+
+#ifdef __cplusplus
+extern "C" {            /* Assume C declarations for C++ */
+#endif  /* __cplusplus */
+
+#ifndef DECLARE_OPAQUE32
+#define DECLARE_OPAQUE32(name)  struct name##__ { int unused; }; \
+                                typedef const struct name##__ FAR* name
+#endif  // DECLARE_OPAQUE32
+
+#ifndef TSPIAPI
+#define TSPIAPI __export __far __pascal
+#endif
+
+DECLARE_OPAQUE32(HDRVCALL);
+DECLARE_OPAQUE32(HDRVLINE);
+DECLARE_OPAQUE32(HDRVPHONE);
+
+typedef HDRVCALL FAR * LPHDRVCALL;
+typedef HDRVLINE FAR * LPHDRVLINE;
+typedef HDRVPHONE FAR * LPHDRVPHONE;
+
+DECLARE_OPAQUE32(HTAPICALL);
+DECLARE_OPAQUE32(HTAPILINE);
+DECLARE_OPAQUE32(HTAPIPHONE);
+
+typedef HTAPICALL FAR * LPHTAPICALL;
+typedef HTAPILINE FAR * LPHTAPILINE;
+typedef HTAPIPHONE FAR * LPHTAPIPHONE;
+
+
+
+typedef void (CALLBACK * LINEEVENT) (
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3);
+
+typedef void (CALLBACK * PHONEEVENT) (
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3);
+
+
+#define TSPI_MESSAGE_BASE 500
+    // The lowest-numbered TSPI-specific message ID number
+
+#define LINE_NEWCALL                ((long) TSPI_MESSAGE_BASE + 0)
+#define LINE_CALLDEVSPECIFIC        ((long) TSPI_MESSAGE_BASE + 1)
+#define LINE_CALLDEVSPECIFICFEATURE ((long) TSPI_MESSAGE_BASE + 2)
+
+#define INITIALIZE_NEGOTIATION 0xFFFFFFFFL
+
+
+typedef DWORD DRV_REQUESTID;
+
+typedef void (CALLBACK * ASYNC_COMPLETION) (
+    DRV_REQUESTID  dwRequestID,
+    LONG           lResult);
+
+
+
+// TSPIAPI TSPI_line functions
+// ----------------------------------------------------------------------------
+    
+LONG TSPIAPI TSPI_lineAccept(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpsUserUserInfo,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineAddToConference(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdConfCall,
+    HDRVCALL       hdConsultCall);
+
+LONG TSPIAPI TSPI_lineAnswer(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpsUserUserInfo,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineBlindTransfer(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpszDestAddress,
+    DWORD          dwCountryCode);
+
+LONG TSPIAPI TSPI_lineClose(
+    HDRVLINE  hdLine);
+
+LONG TSPIAPI TSPI_lineCloseCall(
+    HDRVCALL  hdCall);
+
+LONG TSPIAPI TSPI_lineCompleteCall(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPDWORD        lpdwCompletionID,
+    DWORD          dwCompletionMode,
+    DWORD          dwMessageID);
+
+LONG TSPIAPI TSPI_lineCompleteTransfer(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    HDRVCALL       hdConsultCall,
+    HTAPICALL      htConfCall,
+    LPHDRVCALL     lphdConfCall,
+    DWORD          dwTransferMode);
+
+LONG TSPIAPI TSPI_lineConditionalMediaDetection(
+    HDRVLINE          hdLine,
+    DWORD             dwMediaModes,
+    LPLINECALLPARAMS  const lpCallParams);
+
+LONG TSPIAPI TSPI_lineConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass);
+
+LONG TSPIAPI TSPI_lineDevSpecific(
+    DRV_REQUESTID  dwRequestID,
+    HDRVLINE       hdLine,
+    DWORD          dwAddressID,
+    HDRVCALL       hdCall,
+    LPVOID         lpParams,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID  dwRequestID,
+    HDRVLINE       hdLine,
+    DWORD          dwFeature,
+    LPVOID         lpParams,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineDial(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpszDestAddress,
+    DWORD          dwCountryCode);
+
+LONG TSPIAPI TSPI_lineDrop(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpsUserUserInfo,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineForward(
+    DRV_REQUESTID     dwRequestID,
+    HDRVLINE          hdLine,
+    DWORD             bAllAddresses,
+    DWORD             dwAddressID,
+    LPLINEFORWARDLIST const lpForwardList,
+    DWORD             dwNumRingsNoAnswer,
+    HTAPICALL         htConsultCall,
+    LPHDRVCALL        lphdConsultCall,
+    LPLINECALLPARAMS  const lpCallParams);
+
+LONG TSPIAPI TSPI_lineGatherDigits(
+    HDRVCALL       hdCall,
+    DWORD          dwEndToEndID,
+    DWORD          dwDigitModes,
+    LPSTR          lpsDigits,
+    DWORD          dwNumDigits,
+    LPCSTR         lpszTerminationDigits,
+    DWORD          dwFirstDigitTimeout,
+    DWORD          dwInterDigitTimeout);
+
+LONG TSPIAPI TSPI_lineGenerateDigits(
+    HDRVCALL       hdCall,
+    DWORD          dwEndToEndID,
+    DWORD          dwDigitMode,
+    LPCSTR         lpszDigits,
+    DWORD          dwDuration);
+
+LONG TSPIAPI TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones);
+
+LONG TSPIAPI TSPI_lineGetAddressCaps(
+    DWORD              dwDeviceID,
+    DWORD              dwAddressID,
+    DWORD              dwTSPIVersion,
+    DWORD              dwExtVersion,
+    LPLINEADDRESSCAPS  lpAddressCaps);
+
+LONG TSPIAPI TSPI_lineGetAddressID(
+    HDRVLINE       hdLine,
+    LPDWORD        lpdwAddressID,
+    DWORD          dwAddressMode,
+    LPCSTR         lpsAddress,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineGetAddressStatus(
+    HDRVLINE             hdLine,
+    DWORD                dwAddressID,
+    LPLINEADDRESSSTATUS  lpAddressStatus);
+
+LONG TSPIAPI TSPI_lineGetCallAddressID(
+    HDRVCALL  hdCall,
+    LPDWORD   lpdwAddressID);
+
+LONG TSPIAPI TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpCallInfo);
+
+LONG TSPIAPI TSPI_lineGetCallStatus(
+    HDRVCALL          hdCall,
+    LPLINECALLSTATUS  lpCallStatus);
+
+LONG TSPIAPI TSPI_lineGetDevCaps(
+    DWORD          dwDeviceID,
+    DWORD          dwTSPIVersion,
+    DWORD          dwExtVersion,
+    LPLINEDEVCAPS  lpLineDevCaps);
+
+LONG TSPIAPI TSPI_lineGetDevConfig(
+        DWORD dwDeviceID,
+        LPVARSTRING lpDeviceConfig,
+        LPCSTR lpszDeviceClass);
+
+LONG TSPIAPI TSPI_lineGetExtensionID(
+    DWORD              dwDeviceID,
+    DWORD              dwTSPIVersion,
+    LPLINEEXTENSIONID  lpExtensionID);
+
+LONG TSPIAPI TSPI_lineGetIcon(
+    DWORD    dwDeviceID,
+    LPCSTR   lpszDeviceClass,
+    LPHICON  lphIcon);
+
+LONG TSPIAPI TSPI_lineGetID(
+    HDRVLINE       hdLine,
+    DWORD          dwAddressID,
+    HDRVCALL       hdCall,
+    DWORD          dwSelect,
+    LPVARSTRING    lpDeviceID,
+    LPCSTR         lpszDeviceClass);
+
+LONG TSPIAPI TSPI_lineGetLineDevStatus(
+    HDRVLINE         hdLine,
+    LPLINEDEVSTATUS  lpLineDevStatus);
+
+LONG TSPIAPI TSPI_lineGetNumAddressIDs(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwNumAddressIDs);
+
+LONG TSPIAPI TSPI_lineHold(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall);
+
+LONG TSPIAPI TSPI_lineMakeCall(
+    DRV_REQUESTID     dwRequestID,
+    HDRVLINE          hdLine,
+    HTAPICALL         htCall,
+    LPHDRVCALL        lphdCall,
+    LPCSTR            lpszDestAddress,
+    DWORD             dwCountryCode,
+    LPLINECALLPARAMS  const lpCallParams);
+
+LONG TSPIAPI TSPI_lineMonitorDigits(
+    HDRVCALL       hdCall,
+    DWORD          dwDigitModes);
+
+LONG TSPIAPI TSPI_lineMonitorMedia(
+    HDRVCALL       hdCall,
+    DWORD          dwMediaModes);
+
+LONG TSPIAPI TSPI_lineMonitorTones(
+    HDRVCALL           hdCall,
+    DWORD              dwToneListID,
+    LPLINEMONITORTONE  const lpToneList,
+    DWORD              dwNumEntries);
+
+LONG TSPIAPI TSPI_lineNegotiateExtVersion(
+    DWORD    dwDeviceID,
+    DWORD    dwTSPIVersion,
+    DWORD    dwLowVersion,
+    DWORD    dwHighVersion,
+    LPDWORD  lpdwExtVersion);
+
+LONG TSPIAPI TSPI_lineNegotiateTSPIVersion(
+    DWORD    dwDeviceID,
+    DWORD    dwLowVersion,
+    DWORD    dwHighVersion,
+    LPDWORD  lpdwTSPIVersion);
+
+LONG TSPIAPI TSPI_lineOpen(
+    DWORD       dwDeviceID,
+    HTAPILINE   htLine,
+    LPHDRVLINE  lphdLine,
+    DWORD       dwTSPIVersion,
+    LINEEVENT   lpfnEventProc);
+
+LONG TSPIAPI TSPI_linePark(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    DWORD          dwParkMode,
+    LPCSTR         lpszDirAddress,
+    LPVARSTRING    lpNonDirAddress);
+
+LONG TSPIAPI TSPI_linePickup(
+    DRV_REQUESTID  dwRequestID,
+    HDRVLINE       hdLine,
+    DWORD          dwAddressID,
+    HTAPICALL      htCall,
+    LPHDRVCALL     lphdCall,
+    LPCSTR         lpszDestAddress,
+    LPCSTR         lpszGroupID);
+
+LONG TSPIAPI TSPI_linePrepareAddToConference(
+    DRV_REQUESTID     dwRequestID,
+    HDRVCALL          hdConfCall,
+    HTAPICALL         htConsultCall,
+    LPHDRVCALL        lphdConsultCall,
+    LPLINECALLPARAMS  const lpCallParams);
+
+LONG TSPIAPI TSPI_lineRedirect(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpszDestAddress,
+    DWORD          dwCountryCode);
+
+LONG TSPIAPI TSPI_lineRemoveFromConference(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall);
+
+LONG TSPIAPI TSPI_lineSecureCall(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall);
+
+LONG TSPIAPI TSPI_lineSelectExtVersion(
+    HDRVLINE  hdLine,
+    DWORD     dwExtVersion);
+
+LONG TSPIAPI TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall,
+    LPCSTR         lpsUserUserInfo,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_lineSetAppSpecific(
+    HDRVCALL       hdCall,
+    DWORD          dwAppSpecific);
+
+LONG TSPIAPI TSPI_lineSetCallParams(
+    DRV_REQUESTID     dwRequestID,
+    HDRVCALL          hdCall,
+    DWORD             dwBearerMode,
+    DWORD             dwMinRate,
+    DWORD             dwMaxRate,
+    LPLINEDIALPARAMS  const lpDialParams);
+
+LONG TSPIAPI TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE       hdLine,
+    DWORD          dwMediaModes);
+
+LONG TSPIAPI TSPI_lineSetDevConfig(
+    DWORD         dwDeviceID,
+    LPVOID        const lpDeviceConfig,
+    DWORD         dwSize,
+    LPCSTR        lpszDeviceClass);
+
+LONG TSPIAPI TSPI_lineSetMediaControl(
+    HDRVLINE                     hdLine,
+    DWORD                        dwAddressID,
+    HDRVCALL                     hdCall,
+    DWORD                        dwSelect,
+    LPLINEMEDIACONTROLDIGIT      const lpDigitList,
+    DWORD                        dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA      const lpMediaList,
+    DWORD                        dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE       const lpToneList,
+    DWORD                        dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE  const lpCallStateList,
+    DWORD                        dwCallStateNumEntries);
+
+LONG TSPIAPI TSPI_lineSetMediaMode(
+    HDRVCALL       hdCall,
+    DWORD          dwMediaMode);
+
+LONG TSPIAPI TSPI_lineSetStatusMessages(
+    HDRVLINE       hdLine,
+    DWORD          dwLineStates,
+    DWORD          dwAddressStates);
+
+LONG TSPIAPI TSPI_lineSetTerminal(
+    DRV_REQUESTID  dwRequestID,
+    HDRVLINE       hdLine,
+    DWORD          dwAddressID,
+    HDRVCALL       hdCall,
+    DWORD          dwSelect,
+    DWORD          dwTerminalModes,
+    DWORD          dwTerminalID,
+    DWORD           bEnable);
+
+LONG TSPIAPI TSPI_lineSetupConference(
+    DRV_REQUESTID     dwRequestID,
+    HDRVCALL          hdCall,
+    HDRVLINE          hdLine,
+    HTAPICALL         htConfCall,
+    LPHDRVCALL        lphdConfCall,
+    HTAPICALL         htConsultCall,
+    LPHDRVCALL        lphdConsultCall,
+    DWORD             dwNumParties,
+    LPLINECALLPARAMS  const lpCallParams);
+
+LONG TSPIAPI TSPI_lineSetupTransfer(
+    DRV_REQUESTID     dwRequestID,
+    HDRVCALL          hdCall,
+    HTAPICALL         htConsultCall,
+    LPHDRVCALL        lphdConsultCall,
+    LPLINECALLPARAMS  const lpCallParams);
+
+LONG TSPIAPI TSPI_lineSwapHold(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdActiveCall,
+    HDRVCALL       hdHeldCall);
+
+LONG TSPIAPI TSPI_lineUncompleteCall(
+    DRV_REQUESTID  dwRequestID,
+    HDRVLINE       hdLine,
+    DWORD          dwCompletionID);
+
+LONG TSPIAPI TSPI_lineUnhold(
+    DRV_REQUESTID  dwRequestID,
+    HDRVCALL       hdCall);
+
+LONG TSPIAPI TSPI_lineUnpark(
+    DRV_REQUESTID  dwRequestID,
+    HDRVLINE       hdLine,
+    DWORD          dwAddressID,
+    HTAPICALL      htCall,
+    LPHDRVCALL     lphdCall,
+    LPCSTR         lpszDestAddress);
+
+
+
+// TSPIAPI TSPI_phone functions
+// ----------------------------------------------------------------------------
+
+LONG TSPIAPI TSPI_phoneClose(
+    HDRVPHONE  hdPhone);
+
+LONG TSPIAPI TSPI_phoneConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass);
+
+LONG TSPIAPI TSPI_phoneDevSpecific(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    LPVOID         lpParams,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_phoneGetButtonInfo(
+    HDRVPHONE          hdPhone,
+    DWORD              dwButtonLampID,
+    LPPHONEBUTTONINFO  lpButtonInfo);
+
+LONG TSPIAPI TSPI_phoneGetData(
+    HDRVPHONE      hdPhone,
+    DWORD          dwDataID,
+    LPVOID         lpData,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_phoneGetDevCaps(
+    DWORD          dwDeviceID,
+    DWORD          dwTSPIVersion,
+    DWORD          dwExtVersion,
+    LPPHONECAPS    lpPhoneCaps);
+
+LONG TSPIAPI TSPI_phoneGetDisplay(
+    HDRVPHONE      hdPhone,
+    LPVARSTRING    lpDisplay);
+
+LONG TSPIAPI TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID);
+
+LONG TSPIAPI TSPI_phoneGetGain(
+    HDRVPHONE      hdPhone,
+    DWORD          dwHookSwitchDev,
+    LPDWORD        lpdwGain);
+
+LONG TSPIAPI TSPI_phoneGetHookSwitch(
+    HDRVPHONE      hdPhone,
+    LPDWORD        lpdwHookSwitchDevs);
+
+LONG TSPIAPI TSPI_phoneGetIcon(
+    DWORD    dwDeviceID,
+    LPCSTR   lpszDeviceClass,
+    LPHICON  lphIcon);
+
+LONG TSPIAPI TSPI_phoneGetID(
+    HDRVPHONE      hdPhone,
+    LPVARSTRING    lpDeviceID,
+    LPCSTR         lpszDeviceClass);
+
+LONG TSPIAPI TSPI_phoneGetLamp(
+    HDRVPHONE      hdPhone,
+    DWORD          dwButtonLampID,
+    LPDWORD        lpdwLampMode);
+
+LONG TSPIAPI TSPI_phoneGetRing(
+    HDRVPHONE      hdPhone,
+    LPDWORD        lpdwRingMode,
+    LPDWORD        lpdwVolume);
+
+LONG TSPIAPI TSPI_phoneGetStatus(
+    HDRVPHONE      hdPhone,
+    LPPHONESTATUS  lpPhoneStatus);
+
+LONG TSPIAPI TSPI_phoneGetVolume(
+    HDRVPHONE      hdPhone,
+    DWORD          dwHookSwitchDev,
+    LPDWORD        lpdwVolume);
+
+LONG TSPIAPI TSPI_phoneNegotiateExtVersion(
+    DWORD    dwDeviceID,
+    DWORD    dwTSPIVersion,
+    DWORD    dwLowVersion,
+    DWORD    dwHighVersion,
+    LPDWORD  lpdwExtVersion);
+
+LONG TSPIAPI TSPI_phoneNegotiateTSPIVersion(
+    DWORD    dwDeviceID,
+    DWORD    dwLowVersion,
+    DWORD    dwHighVersion,
+    LPDWORD  lpdwTSPIVersion);
+
+LONG TSPIAPI TSPI_phoneOpen(
+    DWORD        dwDeviceID,
+    HTAPIPHONE   htPhone,
+    LPHDRVPHONE  lphdPhone,
+    DWORD        dwTSPIVersion,
+    PHONEEVENT   lpfnEventProc);
+
+LONG TSPIAPI TSPI_phoneSelectExtVersion(
+    HDRVPHONE  hdPhone,
+    DWORD      dwExtVersion);
+
+LONG TSPIAPI TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID            dwRequestID,
+    HDRVPHONE                hdPhone,
+    DWORD                    dwButtonLampID,
+    LPPHONEBUTTONINFO  const lpButtonInfo);
+
+LONG TSPIAPI TSPI_phoneSetData(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwDataID,
+    LPVOID         const lpData,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_phoneSetDisplay(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwRow,
+    DWORD          dwColumn,
+    LPCSTR         lpsDisplay,
+    DWORD          dwSize);
+
+LONG TSPIAPI TSPI_phoneSetGain(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwHookSwitchDev,
+    DWORD          dwGain);
+
+LONG TSPIAPI TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwHookSwitchDevs,
+    DWORD          dwHookSwitchMode);
+
+LONG TSPIAPI TSPI_phoneSetLamp(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwButtonLampID,
+    DWORD          dwLampMode);
+
+LONG TSPIAPI TSPI_phoneSetRing(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwRingMode,
+    DWORD          dwVolume);
+
+LONG TSPIAPI TSPI_phoneSetStatusMessages(
+    HDRVPHONE      hdPhone,
+    DWORD          dwPhoneStates,
+    DWORD          dwButtonModes,
+    DWORD          dwButtonStates);
+
+LONG TSPIAPI TSPI_phoneSetVolume(
+    DRV_REQUESTID  dwRequestID,
+    HDRVPHONE      hdPhone,
+    DWORD          dwHookSwitchDev,
+    DWORD          dwVolume);
+
+
+
+// TSPIAPI TSPI_provider functions
+// ----------------------------------------------------------------------------
+
+LONG TSPIAPI TSPI_providerConfig(
+    HWND   hwndOwner,
+    DWORD  dwPermanentProviderID);
+
+LONG TSPIAPI TSPI_providerInit(
+    DWORD             dwTSPIVersion,
+    DWORD             dwPermanentProviderID,
+    DWORD             dwLineDeviceIDBase,
+    DWORD             dwPhoneDeviceIDBase,
+    DWORD             dwNumLines,
+    DWORD             dwNumPhones,
+    ASYNC_COMPLETION  lpfnCompletionProc);
+
+LONG TSPIAPI TSPI_providerInstall(
+    HWND   hwndOwner,
+    DWORD  dwPermanentProviderID);
+
+LONG TSPIAPI TSPI_providerRemove(
+    HWND   hwndOwner,
+    DWORD  dwPermanentProviderID);
+
+LONG TSPIAPI TSPI_providerShutdown(
+    DWORD    dwTSPIVersion);
+
+
+// The following macros are the ordinal numbers of the exported tspi functions
+
+#define TSPI_PROC_BASE            500
+
+#define TSPI_LINEACCEPT                    (TSPI_PROC_BASE + 0)
+#define TSPI_LINEADDTOCONFERENCE           (TSPI_PROC_BASE + 1)
+#define TSPI_LINEANSWER                    (TSPI_PROC_BASE + 2)
+#define TSPI_LINEBLINDTRANSFER             (TSPI_PROC_BASE + 3)
+#define TSPI_LINECLOSE                     (TSPI_PROC_BASE + 4)
+#define TSPI_LINECLOSECALL                 (TSPI_PROC_BASE + 5)
+#define TSPI_LINECOMPLETECALL              (TSPI_PROC_BASE + 6)
+#define TSPI_LINECOMPLETETRANSFER          (TSPI_PROC_BASE + 7)
+#define TSPI_LINECONDITIONALMEDIADETECTION (TSPI_PROC_BASE + 8)
+#define TSPI_LINECONFIGDIALOG              (TSPI_PROC_BASE + 9)
+#define TSPI_LINEDEVSPECIFIC               (TSPI_PROC_BASE + 10)
+#define TSPI_LINEDEVSPECIFICFEATURE        (TSPI_PROC_BASE + 11)
+#define TSPI_LINEDIAL                      (TSPI_PROC_BASE + 12)
+#define TSPI_LINEDROP                      (TSPI_PROC_BASE + 13)
+#define TSPI_LINEFORWARD                   (TSPI_PROC_BASE + 14)
+#define TSPI_LINEGATHERDIGITS              (TSPI_PROC_BASE + 15)
+#define TSPI_LINEGENERATEDIGITS            (TSPI_PROC_BASE + 16)
+#define TSPI_LINEGENERATETONE              (TSPI_PROC_BASE + 17)
+#define TSPI_LINEGETADDRESSCAPS            (TSPI_PROC_BASE + 18)
+#define TSPI_LINEGETADDRESSID              (TSPI_PROC_BASE + 19)
+#define TSPI_LINEGETADDRESSSTATUS          (TSPI_PROC_BASE + 20)
+#define TSPI_LINEGETCALLADDRESSID          (TSPI_PROC_BASE + 21)
+#define TSPI_LINEGETCALLINFO               (TSPI_PROC_BASE + 22)
+#define TSPI_LINEGETCALLSTATUS             (TSPI_PROC_BASE + 23)
+#define TSPI_LINEGETDEVCAPS                (TSPI_PROC_BASE + 24)
+#define TSPI_LINEGETDEVCONFIG              (TSPI_PROC_BASE + 25)
+#define TSPI_LINEGETEXTENSIONID            (TSPI_PROC_BASE + 26)
+#define TSPI_LINEGETICON                   (TSPI_PROC_BASE + 27)
+#define TSPI_LINEGETID                     (TSPI_PROC_BASE + 28)
+#define TSPI_LINEGETLINEDEVSTATUS          (TSPI_PROC_BASE + 29)
+#define TSPI_LINEGETNUMADDRESSIDS          (TSPI_PROC_BASE + 30)
+#define TSPI_LINEHOLD                      (TSPI_PROC_BASE + 31)
+#define TSPI_LINEMAKECALL                  (TSPI_PROC_BASE + 32)
+#define TSPI_LINEMONITORDIGITS             (TSPI_PROC_BASE + 33)
+#define TSPI_LINEMONITORMEDIA              (TSPI_PROC_BASE + 34)
+#define TSPI_LINEMONITORTONES              (TSPI_PROC_BASE + 35)
+#define TSPI_LINENEGOTIATEEXTVERSION       (TSPI_PROC_BASE + 36)
+#define TSPI_LINENEGOTIATETSPIVERSION      (TSPI_PROC_BASE + 37)
+#define TSPI_LINEOPEN                      (TSPI_PROC_BASE + 38)
+#define TSPI_LINEPARK                      (TSPI_PROC_BASE + 39)
+#define TSPI_LINEPICKUP                    (TSPI_PROC_BASE + 40)
+#define TSPI_LINEPREPAREADDTOCONFERENCE    (TSPI_PROC_BASE + 41)
+#define TSPI_LINEREDIRECT                  (TSPI_PROC_BASE + 42)
+#define TSPI_LINEREMOVEFROMCONFERENCE      (TSPI_PROC_BASE + 43)
+#define TSPI_LINESECURECALL                (TSPI_PROC_BASE + 44)
+#define TSPI_LINESELECTEXTVERSION          (TSPI_PROC_BASE + 45)
+#define TSPI_LINESENDUSERUSERINFO          (TSPI_PROC_BASE + 46)
+#define TSPI_LINESETAPPSPECIFIC            (TSPI_PROC_BASE + 47)
+#define TSPI_LINESETCALLPARAMS             (TSPI_PROC_BASE + 48)
+#define TSPI_LINESETDEFAULTMEDIADETECTION  (TSPI_PROC_BASE + 49)
+#define TSPI_LINESETDEVCONFIG              (TSPI_PROC_BASE + 50)
+#define TSPI_LINESETMEDIACONTROL           (TSPI_PROC_BASE + 51)
+#define TSPI_LINESETMEDIAMODE              (TSPI_PROC_BASE + 52)
+#define TSPI_LINESETSTATUSMESSAGES         (TSPI_PROC_BASE + 53)
+#define TSPI_LINESETTERMINAL               (TSPI_PROC_BASE + 54)
+#define TSPI_LINESETUPCONFERENCE           (TSPI_PROC_BASE + 55)
+#define TSPI_LINESETUPTRANSFER             (TSPI_PROC_BASE + 56)
+#define TSPI_LINESWAPHOLD                  (TSPI_PROC_BASE + 57)
+#define TSPI_LINEUNCOMPLETECALL            (TSPI_PROC_BASE + 58)
+#define TSPI_LINEUNHOLD                    (TSPI_PROC_BASE + 59)
+#define TSPI_LINEUNPARK                    (TSPI_PROC_BASE + 60)
+#define TSPI_PHONECLOSE                    (TSPI_PROC_BASE + 61)
+#define TSPI_PHONECONFIGDIALOG             (TSPI_PROC_BASE + 62)
+#define TSPI_PHONEDEVSPECIFIC              (TSPI_PROC_BASE + 63)
+#define TSPI_PHONEGETBUTTONINFO            (TSPI_PROC_BASE + 64)
+#define TSPI_PHONEGETDATA                  (TSPI_PROC_BASE + 65)
+#define TSPI_PHONEGETDEVCAPS               (TSPI_PROC_BASE + 66)
+#define TSPI_PHONEGETDISPLAY               (TSPI_PROC_BASE + 67)
+#define TSPI_PHONEGETEXTENSIONID           (TSPI_PROC_BASE + 68)
+#define TSPI_PHONEGETGAIN                  (TSPI_PROC_BASE + 69)
+#define TSPI_PHONEGETHOOKSWITCH            (TSPI_PROC_BASE + 70)
+#define TSPI_PHONEGETICON                  (TSPI_PROC_BASE + 71)
+#define TSPI_PHONEGETID                    (TSPI_PROC_BASE + 72)
+#define TSPI_PHONEGETLAMP                  (TSPI_PROC_BASE + 73)
+#define TSPI_PHONEGETRING                  (TSPI_PROC_BASE + 74)
+#define TSPI_PHONEGETSTATUS                (TSPI_PROC_BASE + 75)
+#define TSPI_PHONEGETVOLUME                (TSPI_PROC_BASE + 76)
+#define TSPI_PHONENEGOTIATEEXTVERSION      (TSPI_PROC_BASE + 77)
+#define TSPI_PHONENEGOTIATETSPIVERSION     (TSPI_PROC_BASE + 78)
+#define TSPI_PHONEOPEN                     (TSPI_PROC_BASE + 79)
+#define TSPI_PHONESELECTEXTVERSION         (TSPI_PROC_BASE + 80)
+#define TSPI_PHONESETBUTTONINFO            (TSPI_PROC_BASE + 81)
+#define TSPI_PHONESETDATA                  (TSPI_PROC_BASE + 82)
+#define TSPI_PHONESETDISPLAY               (TSPI_PROC_BASE + 83)
+#define TSPI_PHONESETGAIN                  (TSPI_PROC_BASE + 84)
+#define TSPI_PHONESETHOOKSWITCH            (TSPI_PROC_BASE + 85)
+#define TSPI_PHONESETLAMP                  (TSPI_PROC_BASE + 86)
+#define TSPI_PHONESETRING                  (TSPI_PROC_BASE + 87)
+#define TSPI_PHONESETSTATUSMESSAGES        (TSPI_PROC_BASE + 88)
+#define TSPI_PHONESETVOLUME                (TSPI_PROC_BASE + 89)
+#define TSPI_PROVIDERCONFIG                (TSPI_PROC_BASE + 90)
+#define TSPI_PROVIDERINIT                  (TSPI_PROC_BASE + 91)
+#define TSPI_PROVIDERINSTALL               (TSPI_PROC_BASE + 92)
+#define TSPI_PROVIDERREMOVE                (TSPI_PROC_BASE + 93)
+#define TSPI_PROVIDERSHUTDOWN              (TSPI_PROC_BASE + 94)
+
+
+#ifdef __cplusplus
+}                       /* End of extern "C" { */
+#endif  /* __cplusplus */
+
+#endif  // TSPI_H
diff --git a/private/tapi/dev/inc/tapiver.h b/private/tapi/dev/inc/tapiver.h
new file mode 100644
index 000000000..3883fdf31
--- /dev/null
+++ b/private/tapi/dev/inc/tapiver.h
@@ -0,0 +1,9 @@
+// version numbers for tapi release
+
+#define rmj         4
+#define rmm         0
+#define rup	      509
+
+#define VERSION                     "4.0"
+#define VER_PRODUCTVERSION_STR	"4.00.0509"
+#define VER_PRODUCTVERSION          rmj,rmm,0,rup
diff --git a/private/tapi/dev/inc/tspi.x b/private/tapi/dev/inc/tspi.x
new file mode 100644
index 000000000..3dde79791
--- /dev/null
+++ b/private/tapi/dev/inc/tspi.x
@@ -0,0 +1,1554 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+The  Telephony  API  is jointly copyrighted by Intel and Microsoft.  You are
+granted  a royalty free worldwide, unlimited license to make copies, and use
+the   API/SPI  for  making  applications/drivers  that  interface  with  the
+specification provided that this paragraph and the Intel/Microsoft copyright
+statement is maintained as is in the text and source code files.
+
+Copyright (c) 1992-1996  Microsoft Corporation
+Portions copyright 1992, 1993 Intel/Microsoft, all rights reserved.
+
+Module Name:
+
+    tspi.h
+
+Notes:
+
+    Additions to the Telephony Service Provider Interface (TSPI) since
+    version 1.0 are noted by version number (i.e. "TSPI v1.4").
+
+--*/
+
+#ifndef TSPI_H
+#define TSPI_H
+
+
+#include <windows.h>
+
+#include "tapi.h"
+
+
+#if WIN32
+#if TAPI_CURRENT_VERSION < 0x00020000
+#error Building a 32bit 1.3 or 1.4 service provider is not supported.
+#endif
+#endif
+
+
+// tspi.h  is  only  of  use  in  conjunction  with tapi.h.  Very few types are
+// defined  in  tspi.h.   Most  types of procedure formal parameters are simply
+// passed through from corresponding procedures in tapi.h.  A working knowledge
+// of the TAPI interface is required for an understanding of this interface.
+
+#ifdef __cplusplus
+extern "C" {            /* Assume C declarations for C++ */
+#endif  /* __cplusplus */
+
+#ifndef DECLARE_OPAQUE32
+#define DECLARE_OPAQUE32(name)  struct name##__ { int unused; }; \
+                typedef const struct name##__ FAR* name
+#endif  // DECLARE_OPAQUE32
+
+#ifndef TSPIAPI
+
+#define TSPIAPI PASCAL
+
+#endif
+
+DECLARE_OPAQUE32(HDRVCALL);
+DECLARE_OPAQUE32(HDRVLINE);
+DECLARE_OPAQUE32(HDRVPHONE);
+DECLARE_OPAQUE32(HDRVDIALOGINSTANCE);
+
+typedef HDRVCALL FAR * LPHDRVCALL;
+typedef HDRVLINE FAR * LPHDRVLINE;
+typedef HDRVPHONE FAR * LPHDRVPHONE;
+typedef HDRVDIALOGINSTANCE FAR * LPHDRVDIALOGINSTANCE;
+
+DECLARE_OPAQUE32(HTAPICALL);
+DECLARE_OPAQUE32(HTAPILINE);
+DECLARE_OPAQUE32(HTAPIPHONE);
+DECLARE_OPAQUE32(HTAPIDIALOGINSTANCE);
+
+typedef HTAPICALL FAR * LPHTAPICALL;
+typedef HTAPILINE FAR * LPHTAPILINE;
+typedef HTAPIPHONE FAR * LPHTAPIPHONE;
+typedef HTAPIDIALOGINSTANCE FAR * LPHTAPIDIALOGINSTANCE;
+
+
+DECLARE_OPAQUE32(HPROVIDER);
+typedef HPROVIDER FAR * LPHPROVIDER;
+
+typedef DWORD DRV_REQUESTID;
+
+typedef void (CALLBACK * ASYNC_COMPLETION)(
+    DRV_REQUESTID       dwRequestID,
+    LONG                lResult
+    );
+
+typedef void (CALLBACK * LINEEVENT)(
+    HTAPILINE           htLine,
+    HTAPICALL           htCall,
+    DWORD               dwMsg,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    );
+
+typedef void (CALLBACK * PHONEEVENT)(
+    HTAPIPHONE          htPhone,
+    DWORD               dwMsg,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    );
+
+typedef LONG (CALLBACK * TUISPIDLLCALLBACK)(
+    DWORD               dwObjectID,
+    DWORD               dwObjectType,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+#if TAPI_CURRENT_VERSION >= 0x00020000
+typedef struct tuispicreatedialoginstanceparams_tag
+{
+    DRV_REQUESTID           dwRequestID;
+
+    HDRVDIALOGINSTANCE      hdDlgInst;
+
+    HTAPIDIALOGINSTANCE     htDlgInst;
+
+    LPCWSTR                 lpszUIDLLName;
+
+    LPVOID                  lpParams;
+
+    DWORD                   dwSize;
+
+} TUISPICREATEDIALOGINSTANCEPARAMS, *LPTUISPICREATEDIALOGINSTANCEPARAMS;
+#endif
+
+
+#define TSPI_MESSAGE_BASE 500
+    // The lowest-numbered TSPI-specific message ID number
+
+#define LINE_NEWCALL                            ((long) TSPI_MESSAGE_BASE + 0)
+#define LINE_CALLDEVSPECIFIC                    ((long) TSPI_MESSAGE_BASE + 1)
+#define LINE_CALLDEVSPECIFICFEATURE             ((long) TSPI_MESSAGE_BASE + 2)
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINE_CREATEDIALOGINSTANCE               ((long) TSPI_MESSAGE_BASE + 3)
+                                                                // TSPI v2.0
+#define LINE_SENDDIALOGINSTANCEDATA             ((long) TSPI_MESSAGE_BASE + 4)
+                                                                // TSPI v2.0
+#endif
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define LINETSPIOPTION_NONREENTRANT             0x00000001      // TSPI v2.0
+#endif
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+#define TUISPIDLL_OBJECT_LINEID                 1L              // TSPI v2.0
+#define TUISPIDLL_OBJECT_PHONEID                2L              // TSPI v2.0
+#define TUISPIDLL_OBJECT_PROVIDERID             3L              // TSPI v2.0
+#define TUISPIDLL_OBJECT_DIALOGINSTANCE         4L              // TSPI v2.0
+#endif
+
+
+//
+// The following function prototypes pertain
+// to a service provider's core module
+//
+
+
+#ifndef DONT_DECLARE_TSPI_FUNCTIONS   // ;internal
+
+LONG
+TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HDRVCALL            hdConsultCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode);
+#else
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode);
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE            hdLine
+    );
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL            hdCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    );
+
+LONG
+TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVCALL            hdConsultCall,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    DWORD               dwTransferMode
+    );
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TSPI_lineDropOnClose(                                           // TSPI v1.4
+    HDRVCALL            hdCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineDropNoOwner(                                           // TSPI v1.4
+    HDRVCALL            hdCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitModes,
+    LPWSTR              lpsDigits,
+    DWORD               dwNumDigits,
+    LPCWSTR             lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    );
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitMode,
+    LPCWSTR             lpszDigits,
+    DWORD               dwDuration
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    );
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCWSTR             lpsAddress,
+    DWORD               dwSize
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    );
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwAddressID
+    );
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL            hdCall,
+    LPLINECALLINFO      lpCallInfo
+    );
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    );
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCWSTR             lpszDeviceClass
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    HANDLE              hTargetProcess                          // TSPI v2.0
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    );
+#endif
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE            hdLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    );
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwNumAddressIDs
+    );
+
+LONG
+TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwDigitModes
+    );
+
+LONG
+TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaModes
+    );
+
+LONG
+TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    );
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    );
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    );
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD               dwDeviceID,
+    HTAPILINE           htLine,
+    LPHDRVLINE          lphdLine,
+    DWORD               dwTSPIVersion,
+    LINEEVENT           lpfnEventProc
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwParkMode,
+    LPCWSTR             lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    );
+#else
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    );
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszGroupID
+    );
+#else
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineReleaseUserUserInfo(                                   // TSPI v1.4
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE            hdLine,
+    DWORD               dwExtVersion
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL            hdCall,
+    DWORD               dwAppSpecific
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineSetCallData(                                           // TSPI v2.0
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPVOID              lpCallData,
+    DWORD               dwSize
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineSetCallQualityOfService(                               // TSPI v2.0
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPVOID              lpSendingFlowspec,
+    DWORD               dwSendingFlowspecSize,
+    LPVOID              lpReceivingFlowspec,
+    DWORD               dwReceivingFlowspecSize
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetCallTreatment(                                      // TSPI v2.0
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwTreatment
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineSetCurrentLocation(                                    // TSPI v1.4
+    DWORD               dwLocation
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCWSTR             lpszDeviceClass
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    );
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineSetLineDevStatus(                                      // TSPI v2.0
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwStatusToChange,
+    DWORD               fStatus
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaMode
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE            hdLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdActiveCall,
+    HDRVCALL            hdHeldCall
+    );
+
+LONG
+TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwCompletionID
+    );
+
+LONG
+TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress
+    );
+#else
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress
+    );
+#endif
+
+
+
+LONG
+TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE           hdPhone
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDisplay
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+#else
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    );
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass,
+    HANDLE              hTargetProcess                          // TSPI v2.0
+    );
+#else
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE           hdPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneOpen(
+    DWORD               dwDeviceID,
+    HTAPIPHONE          htPhone,
+    LPHDRVPHONE         lphdPhone,
+    DWORD               dwTSPIVersion,
+    PHONEEVENT          lpfnEventProc
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE           hdPhone,
+    DWORD               dwExtVersion
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCWSTR             lpsDisplay,
+    DWORD               dwSize
+    );
+#else
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCSTR              lpsDisplay,
+    DWORD               dwSize
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE           hdPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    );
+
+LONG
+TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    );
+
+
+
+LONG
+TSPIAPI
+TSPI_providerCreateLineDevice(                                  // TSPI v1.4
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    );
+
+LONG
+TSPIAPI
+TSPI_providerCreatePhoneDevice(                                 // TSPI v1.4
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    );
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(                                       // TSPI v1.4
+    DWORD               dwPermanentProviderID,
+    LPDWORD             lpdwNumLines,
+    LPDWORD             lpdwNumPhones,
+    HPROVIDER           hProvider,
+    LINEEVENT           lpfnLineCreateProc,
+    PHONEEVENT          lpfnPhoneCreateProc
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_providerFreeDialogInstance(                                // TSPI v2.0
+    HDRVDIALOGINSTANCE  hdDlgInst
+    );
+
+LONG
+TSPIAPI
+TSPI_providerGenericDialogData(                                 // TSPI v2.0
+    DWORD               dwObjectID,
+    DWORD               dwObjectType,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+#endif
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    ,
+    LPDWORD             lpdwTSPIOptions                         // TSPI v2.0
+#endif
+    );
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    );
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    );
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD               dwTSPIVersion
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    ,
+    DWORD               dwPermanentProviderID                   // TSPI v2.0
+#endif
+    );
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+LONG
+TSPIAPI
+TSPI_providerUIIdentify(                                        // TSPI v2.0
+    LPWSTR              lpszUIDLLName
+    );
+#endif
+
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+//
+// The following function prototypes pertain
+// to a service provider's UI module
+//
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialog(                                        // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    );
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialogEdit(                                    // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    );
+
+LONG
+TSPIAPI
+TUISPI_phoneConfigDialog(                                       // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    );
+
+LONG
+TSPIAPI
+TUISPI_providerConfig(                                          // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    );
+
+LONG
+TSPIAPI
+TUISPI_providerGenericDialog(                                   // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HTAPIDIALOGINSTANCE htDlgInst,
+    LPVOID              lpParams,
+    DWORD               dwSize,
+    HANDLE              hEvent
+    );
+
+LONG
+TSPIAPI
+TUISPI_providerGenericDialogData(                               // TSPI v2.0
+    HTAPIDIALOGINSTANCE htDlgInst,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    );
+
+LONG
+TSPIAPI
+TUISPI_providerInstall(                                         // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    );
+
+LONG
+TSPIAPI
+TUISPI_providerRemove(                                          // TSPI v2.0
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    );
+
+#else
+
+//
+// The following were obsoleted by the above (but are needed to build 1.4 SPs)
+//
+LONG TSPIAPI TSPI_lineConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass);
+
+LONG TSPIAPI TSPI_lineConfigDialogEdit(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass,
+    LPVOID  const lpDeviceConfigIn,
+    DWORD   dwSize,
+    LPVARSTRING lpDeviceConfigOut);
+
+LONG TSPIAPI TSPI_phoneConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass);
+
+LONG TSPIAPI TSPI_providerConfig(
+    HWND   hwndOwner,
+    DWORD  dwPermanentProviderID);
+
+
+#endif
+
+
+#endif     // ;internal
+
+
+#if (TAPI_CURRENT_VERSION < 0x00020000)
+
+//
+// The following macros are the ordinal numbers of the exported tspi functions
+//
+
+#define TSPI_PROC_BASE                      500
+
+#define TSPI_LINEACCEPT                     (TSPI_PROC_BASE + 0)
+#define TSPI_LINEADDTOCONFERENCE            (TSPI_PROC_BASE + 1)
+#define TSPI_LINEANSWER                     (TSPI_PROC_BASE + 2)
+#define TSPI_LINEBLINDTRANSFER              (TSPI_PROC_BASE + 3)
+#define TSPI_LINECLOSE                      (TSPI_PROC_BASE + 4)
+#define TSPI_LINECLOSECALL                  (TSPI_PROC_BASE + 5)
+#define TSPI_LINECOMPLETECALL               (TSPI_PROC_BASE + 6)
+#define TSPI_LINECOMPLETETRANSFER           (TSPI_PROC_BASE + 7)
+#define TSPI_LINECONDITIONALMEDIADETECTION  (TSPI_PROC_BASE + 8)
+#define TSPI_LINECONFIGDIALOG               (TSPI_PROC_BASE + 9)
+#define TSPI_LINEDEVSPECIFIC                (TSPI_PROC_BASE + 10)
+#define TSPI_LINEDEVSPECIFICFEATURE         (TSPI_PROC_BASE + 11)
+#define TSPI_LINEDIAL                       (TSPI_PROC_BASE + 12)
+#define TSPI_LINEDROP                       (TSPI_PROC_BASE + 13)
+#define TSPI_LINEFORWARD                    (TSPI_PROC_BASE + 14)
+#define TSPI_LINEGATHERDIGITS               (TSPI_PROC_BASE + 15)
+#define TSPI_LINEGENERATEDIGITS             (TSPI_PROC_BASE + 16)
+#define TSPI_LINEGENERATETONE               (TSPI_PROC_BASE + 17)
+#define TSPI_LINEGETADDRESSCAPS             (TSPI_PROC_BASE + 18)
+#define TSPI_LINEGETADDRESSID               (TSPI_PROC_BASE + 19)
+#define TSPI_LINEGETADDRESSSTATUS           (TSPI_PROC_BASE + 20)
+#define TSPI_LINEGETCALLADDRESSID           (TSPI_PROC_BASE + 21)
+#define TSPI_LINEGETCALLINFO                (TSPI_PROC_BASE + 22)
+#define TSPI_LINEGETCALLSTATUS              (TSPI_PROC_BASE + 23)
+#define TSPI_LINEGETDEVCAPS                 (TSPI_PROC_BASE + 24)
+#define TSPI_LINEGETDEVCONFIG               (TSPI_PROC_BASE + 25)
+#define TSPI_LINEGETEXTENSIONID             (TSPI_PROC_BASE + 26)
+#define TSPI_LINEGETICON                    (TSPI_PROC_BASE + 27)
+#define TSPI_LINEGETID                      (TSPI_PROC_BASE + 28)
+#define TSPI_LINEGETLINEDEVSTATUS           (TSPI_PROC_BASE + 29)
+#define TSPI_LINEGETNUMADDRESSIDS           (TSPI_PROC_BASE + 30)
+#define TSPI_LINEHOLD                       (TSPI_PROC_BASE + 31)
+#define TSPI_LINEMAKECALL                   (TSPI_PROC_BASE + 32)
+#define TSPI_LINEMONITORDIGITS              (TSPI_PROC_BASE + 33)
+#define TSPI_LINEMONITORMEDIA               (TSPI_PROC_BASE + 34)
+#define TSPI_LINEMONITORTONES               (TSPI_PROC_BASE + 35)
+#define TSPI_LINENEGOTIATEEXTVERSION        (TSPI_PROC_BASE + 36)
+#define TSPI_LINENEGOTIATETSPIVERSION       (TSPI_PROC_BASE + 37)
+#define TSPI_LINEOPEN                       (TSPI_PROC_BASE + 38)
+#define TSPI_LINEPARK                       (TSPI_PROC_BASE + 39)
+#define TSPI_LINEPICKUP                     (TSPI_PROC_BASE + 40)
+#define TSPI_LINEPREPAREADDTOCONFERENCE     (TSPI_PROC_BASE + 41)
+#define TSPI_LINEREDIRECT                   (TSPI_PROC_BASE + 42)
+#define TSPI_LINEREMOVEFROMCONFERENCE       (TSPI_PROC_BASE + 43)
+#define TSPI_LINESECURECALL                 (TSPI_PROC_BASE + 44)
+#define TSPI_LINESELECTEXTVERSION           (TSPI_PROC_BASE + 45)
+#define TSPI_LINESENDUSERUSERINFO           (TSPI_PROC_BASE + 46)
+#define TSPI_LINESETAPPSPECIFIC             (TSPI_PROC_BASE + 47)
+#define TSPI_LINESETCALLPARAMS              (TSPI_PROC_BASE + 48)
+#define TSPI_LINESETDEFAULTMEDIADETECTION   (TSPI_PROC_BASE + 49)
+#define TSPI_LINESETDEVCONFIG               (TSPI_PROC_BASE + 50)
+#define TSPI_LINESETMEDIACONTROL            (TSPI_PROC_BASE + 51)
+#define TSPI_LINESETMEDIAMODE               (TSPI_PROC_BASE + 52)
+#define TSPI_LINESETSTATUSMESSAGES          (TSPI_PROC_BASE + 53)
+#define TSPI_LINESETTERMINAL                (TSPI_PROC_BASE + 54)
+#define TSPI_LINESETUPCONFERENCE            (TSPI_PROC_BASE + 55)
+#define TSPI_LINESETUPTRANSFER              (TSPI_PROC_BASE + 56)
+#define TSPI_LINESWAPHOLD                   (TSPI_PROC_BASE + 57)
+#define TSPI_LINEUNCOMPLETECALL             (TSPI_PROC_BASE + 58)
+#define TSPI_LINEUNHOLD                     (TSPI_PROC_BASE + 59)
+#define TSPI_LINEUNPARK                     (TSPI_PROC_BASE + 60)
+#define TSPI_PHONECLOSE                     (TSPI_PROC_BASE + 61)
+#define TSPI_PHONECONFIGDIALOG              (TSPI_PROC_BASE + 62)
+#define TSPI_PHONEDEVSPECIFIC               (TSPI_PROC_BASE + 63)
+#define TSPI_PHONEGETBUTTONINFO             (TSPI_PROC_BASE + 64)
+#define TSPI_PHONEGETDATA                   (TSPI_PROC_BASE + 65)
+#define TSPI_PHONEGETDEVCAPS                (TSPI_PROC_BASE + 66)
+#define TSPI_PHONEGETDISPLAY                (TSPI_PROC_BASE + 67)
+#define TSPI_PHONEGETEXTENSIONID            (TSPI_PROC_BASE + 68)
+#define TSPI_PHONEGETGAIN                   (TSPI_PROC_BASE + 69)
+#define TSPI_PHONEGETHOOKSWITCH             (TSPI_PROC_BASE + 70)
+#define TSPI_PHONEGETICON                   (TSPI_PROC_BASE + 71)
+#define TSPI_PHONEGETID                     (TSPI_PROC_BASE + 72)
+#define TSPI_PHONEGETLAMP                   (TSPI_PROC_BASE + 73)
+#define TSPI_PHONEGETRING                   (TSPI_PROC_BASE + 74)
+#define TSPI_PHONEGETSTATUS                 (TSPI_PROC_BASE + 75)
+#define TSPI_PHONEGETVOLUME                 (TSPI_PROC_BASE + 76)
+#define TSPI_PHONENEGOTIATEEXTVERSION       (TSPI_PROC_BASE + 77)
+#define TSPI_PHONENEGOTIATETSPIVERSION      (TSPI_PROC_BASE + 78)
+#define TSPI_PHONEOPEN                      (TSPI_PROC_BASE + 79)
+#define TSPI_PHONESELECTEXTVERSION          (TSPI_PROC_BASE + 80)
+#define TSPI_PHONESETBUTTONINFO             (TSPI_PROC_BASE + 81)
+#define TSPI_PHONESETDATA                   (TSPI_PROC_BASE + 82)
+#define TSPI_PHONESETDISPLAY                (TSPI_PROC_BASE + 83)
+#define TSPI_PHONESETGAIN                   (TSPI_PROC_BASE + 84)
+#define TSPI_PHONESETHOOKSWITCH             (TSPI_PROC_BASE + 85)
+#define TSPI_PHONESETLAMP                   (TSPI_PROC_BASE + 86)
+#define TSPI_PHONESETRING                   (TSPI_PROC_BASE + 87)
+#define TSPI_PHONESETSTATUSMESSAGES         (TSPI_PROC_BASE + 88)
+#define TSPI_PHONESETVOLUME                 (TSPI_PROC_BASE + 89)
+#define TSPI_PROVIDERCONFIG                 (TSPI_PROC_BASE + 90)
+#define TSPI_PROVIDERINIT                   (TSPI_PROC_BASE + 91)
+#define TSPI_PROVIDERINSTALL                (TSPI_PROC_BASE + 92)
+#define TSPI_PROVIDERREMOVE                 (TSPI_PROC_BASE + 93)
+#define TSPI_PROVIDERSHUTDOWN               (TSPI_PROC_BASE + 94)
+
+#define TSPI_PROVIDERENUMDEVICES            (TSPI_PROC_BASE + 95)  // TSPI v1.4
+#define TSPI_LINEDROPONCLOSE                (TSPI_PROC_BASE + 96)  // TSPI v1.4
+#define TSPI_LINEDROPNOOWNER                (TSPI_PROC_BASE + 97)  // TSPI v1.4
+#define TSPI_PROVIDERCREATELINEDEVICE       (TSPI_PROC_BASE + 98)  // TSPI v1.4
+#define TSPI_PROVIDERCREATEPHONEDEVICE      (TSPI_PROC_BASE + 99)  // TSPI v1.4
+#define TSPI_LINESETCURRENTLOCATION         (TSPI_PROC_BASE + 100) // TSPI v1.4
+#define TSPI_LINECONFIGDIALOGEDIT           (TSPI_PROC_BASE + 101) // TSPI v1.4
+#define TSPI_LINERELEASEUSERUSERINFO        (TSPI_PROC_BASE + 102) // TSPI v1.4
+
+#endif
+
+
+#ifdef __cplusplus
+}                       /* End of extern "C" { */
+#endif  /* __cplusplus */
+
+#endif  // TSPI_H
diff --git a/private/tapi/dev/instsrv/instsrv.c b/private/tapi/dev/instsrv/instsrv.c
new file mode 100644
index 000000000..5cc67c6f3
--- /dev/null
+++ b/private/tapi/dev/instsrv/instsrv.c
@@ -0,0 +1,101 @@
+
+/******************************************************************************\
+*       This is a part of the Microsoft Source Code Samples. 
+*       Copyright (C) 1993 Microsoft Corporation.
+*       All rights reserved. 
+*       This source code is only intended as a supplement to 
+*       Microsoft Development Tools and/or WinHelp documentation.
+*       See these sources for detailed information regarding the 
+*       Microsoft samples programs.
+\******************************************************************************/
+
+///////////////////////////////////////////////////////
+//
+//  InstSrv.c --
+//
+//      This program demonstrates the use of the OpenSCManager and
+//      CreateService APIs to install the Simple service sample.
+//
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+SC_HANDLE   schService;
+SC_HANDLE   schSCManager;
+
+VOID
+InstallService(LPCTSTR serviceName, LPCTSTR serviceExe)
+{
+    LPCTSTR lpszBinaryPathName = serviceExe;
+
+    schService = CreateService(
+        schSCManager,               // SCManager database
+        serviceName,                // name of service
+        serviceName,                // name to display (new parameter after october beta)
+        SERVICE_ALL_ACCESS,         // desired access
+        SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
+                                    // service type
+        SERVICE_DEMAND_START,       // start type
+        SERVICE_ERROR_NORMAL,       // error control type
+        lpszBinaryPathName,         // service's binary
+        NULL,                       // no load ordering group
+        NULL,                       // no tag identifier
+        NULL,                       // no dependencies
+        NULL,                       // LocalSystem account
+        NULL);                      // no password
+
+    if (schService == NULL) {
+        printf("failure: CreateService (0x%02x)\n", GetLastError());
+        return;
+    } else
+        printf("CreateService SUCCESS\n");
+
+    CloseServiceHandle(schService);
+}
+
+VOID
+RemoveService(LPCTSTR serviceName)
+{
+    BOOL    ret;
+
+    schService = OpenService(schSCManager, serviceName, SERVICE_ALL_ACCESS);
+
+    if (schService == NULL) {
+        printf("failure: OpenService (0x%02x)\n", GetLastError());
+        return;
+    }
+
+    ret = DeleteService(schService);
+
+    if (ret)
+        printf("DeleteService SUCCESS\n");
+    else
+        printf("failure: DeleteService (0x%02x)\n", GetLastError());
+}
+
+VOID
+__cdecl
+main(int argc, char *argv[])
+{
+    if (argc != 3) {
+        printf("usage: instsrv <service name> <exe location>\n");
+        printf("           to install a service, or:\n");
+        printf("       instsrv <service name> remove\n");
+        printf("           to remove a service\n");
+        exit(1);
+    }
+
+    schSCManager = OpenSCManager(
+                        NULL,                   // machine (NULL == local)
+                        NULL,                   // database (NULL == default)
+                        SC_MANAGER_ALL_ACCESS   // access required
+                        );
+
+    if (!stricmp(argv[2], "remove"))
+        RemoveService(argv[1]);
+    else
+        InstallService(argv[1], argv[2]);
+
+    CloseServiceHandle(schSCManager);
+}
diff --git a/private/tapi/dev/instsrv/makefile b/private/tapi/dev/instsrv/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/dev/instsrv/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/instsrv/sources b/private/tapi/dev/instsrv/sources
new file mode 100644
index 000000000..3b07b04db
--- /dev/null
+++ b/private/tapi/dev/instsrv/sources
@@ -0,0 +1,46 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=instsrv
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib
+
+
+INCLUDES=
+
+USE_CRTDLL=1
+
+SOURCES=instsrv.c
+
+UMTYPE=console
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/makefil0 b/private/tapi/dev/makefil0
new file mode 100644
index 000000000..9e155390c
--- /dev/null
+++ b/private/tapi/dev/makefil0
@@ -0,0 +1,116 @@
+#
+# this is the midl compile phase of the build process.
+#
+# The following is where you put the name of your .idl file without
+# the .idl extension:
+#
+
+
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.plt
+
+SDKINC = $(BASEDIR)\public\sdk\inc
+SDKCRTINC = $(BASEDIR)\public\sdk\inc\crt
+INCS  = -I$(SDKINC)  -I$(SDKCRTINC) -I..\..\inc
+
+CPP = -cpp_cmd "$(MIDL_CPP)" $(MIDL_FLAGS) $(C_DEFINES) $(NET_C_DEFINES)
+
+HEADER_TARGETS =   $(SDKINC)\tapi.h \
+                   $(SDKINC)\tspi.h
+
+!else
+
+FLAGS = -D_X86_ -Di386 -D_WCHAR_T_DEFINED
+CPP = -cpp_cmd "cl" -cpp_opt "-E $(FLAGS) $(INCS) $(C_DEFINES)"
+
+HEADER_TARGETS =
+
+!endif
+
+
+
+IDL_NAME  = tapsrv
+
+CLIENT_TARGETS =   client\$(IDL_NAME)_c.c  \
+
+SERVER_TARGETS =   server\$(IDL_NAME)_s.c
+
+EXTRN_DEPENDS =
+
+IDL_NAME2  = rmotsp
+
+CLIENT_TARGETS2 =   server\$(IDL_NAME2)_c.c
+
+SERVER_TARGETS2 =   sp\remotesp\$(IDL_NAME2)_s.c
+
+EXTRN_DEPENDS2 =
+
+#
+# Define Products and Dependencies
+#
+
+all:    $(CLIENT_TARGETS) $(SERVER_TARGETS) $(CLIENT_TARGETS2) $(SERVER_TARGETS2) $(HEADER_TARGETS) $(EXTRN_DEPENDS)
+!IF "$(BUILDMSG)" != ""
+    @ech ; $(BUILDMSG) ;
+!ENDIF
+
+clean: delete_source all
+
+delete_source:
+    -erase $(CLIENT_TARGETS) $(SERVER_TARGETS) $(HEADER_TARGETS)
+
+#
+# MIDL COMPILE
+#
+
+$(SDKINC)\tapi.h: inc\tapi.x
+!if "$(OS)" == "Windows_NT"
+    hsplit -s -o $(SDKINC)\tapi.h nul: inc\tapi.x
+!else
+#    copy inc\tapi.x $(SDKINC)\tapi.h
+!endif
+
+
+$(SDKINC)\tspi.h: inc\tspi.x
+!if "$(OS)" == "Windows_NT"
+    hsplit -s -o $(SDKINC)\tspi.h nul: inc\tspi.x
+!else
+#    copy inc\tspi.x $(SDKINC)\tspi.h
+!endif
+
+
+$(CLIENT_TARGETS) : $(IDL_NAME).idl $(EXTRN_DEPENDS)
+    midl -Oi -server none -oldnames -error allocation -error ref -ms_ext -c_ext $(CPP) $(IDL_NAME).idl $(INCS)
+    IF EXIST $(IDL_NAME)_c.c copy $(IDL_NAME)_c.c .\client
+    IF EXIST $(IDL_NAME)_c.c copy $(IDL_NAME)_c.c .\sp\remotesp
+    IF EXIST $(IDL_NAME)_c.c del  $(IDL_NAME)_c.c
+
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h .\client
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h .\sp\remotesp
+
+
+$(SERVER_TARGETS) : $(IDL_NAME).idl $(EXTRN_DEPENDS)
+    midl -client none -oldnames -error stub_data -error allocation -error ref -ms_ext -c_ext $(CPP) $(IDL_NAME).idl $(INCS)
+    IF EXIST $(IDL_NAME)_s.c copy $(IDL_NAME)_s.c .\server
+    IF EXIST $(IDL_NAME)_s.c del  $(IDL_NAME)_s.c
+
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h .\server
+    IF EXIST $(IDL_NAME).h del  $(IDL_NAME).h
+
+
+$(CLIENT_TARGETS2) : $(IDL_NAME2).idl $(EXTRN_DEPENDS2)
+    midl -Oi -server none -oldnames -error allocation -error ref -ms_ext -c_ext $(CPP) $(IDL_NAME2).idl $(INCS)
+    IF EXIST $(IDL_NAME2)_c.c copy $(IDL_NAME2)_c.c .\server
+    IF EXIST $(IDL_NAME2)_c.c del  $(IDL_NAME2)_c.c
+
+    IF EXIST $(IDL_NAME2).h copy $(IDL_NAME2).h .\server
+
+
+$(SERVER_TARGETS2) : $(IDL_NAME2).idl $(EXTRN_DEPENDS2)
+    midl -client none -oldnames -error stub_data -error allocation -error ref -ms_ext -c_ext $(CPP) $(IDL_NAME2).idl $(INCS)
+    IF EXIST $(IDL_NAME2)_s.c copy $(IDL_NAME2)_s.c .\sp\remotesp
+    IF EXIST $(IDL_NAME2)_s.c del  $(IDL_NAME2)_s.c
+
+    IF EXIST $(IDL_NAME2).h copy $(IDL_NAME2).h .\sp\remotesp
+    IF EXIST $(IDL_NAME2).h del  $(IDL_NAME2).h
diff --git a/private/tapi/dev/midlstuf/makefile b/private/tapi/dev/midlstuf/makefile
new file mode 100644
index 000000000..7169737fe
--- /dev/null
+++ b/private/tapi/dev/midlstuf/makefile
@@ -0,0 +1,114 @@
+#
+# this is the midl compile phase of the build process.
+#
+
+
+ROOT=..\..\..\..
+NEWROOT=..\..\..\..
+
+SDKINC=$(ROOT)\dev\sdk\inc
+SDKINC16=$(ROOT)\dev\sdk\inc16
+
+MIDL=$(NEWROOT)\dev\tools\binw\x86\midl.exe
+
+
+WIN32=TRUE
+IS_32=TRUE
+WANT_C932=TRUE
+
+IDL_NAME=tapsrv
+
+CLIENT_TARGETS =   ..\client\$(IDL_NAME)_c.c
+
+SERVER_TARGETS =   ..\server\$(IDL_NAME)_s.c
+
+HEADER_TARGETS =   $(SDKINC)\tapi.h   $(SDKINC)\tspi.h
+
+IDL_NAME2  = rmotsp
+
+CLIENT_TARGETS2 =   ..\server\$(IDL_NAME2)_c.c
+
+SERVER_TARGETS2 =   ..\sp\remotesp\$(IDL_NAME2)_s.c
+
+EXTRN_DEPENDS2 =
+
+
+TARGETS=$(CLIENT_TARGETS) $(SERVER_TARGETS) $(CLIENT_TARGETS2) $(SERVER_TARGETS2) $(HEADER_TARGETS) $(EXTRN_DEPENDS)
+
+!include $(ROOT)\root.mk
+
+
+#all:    $(CLIENT_TARGETS) $(SERVER_TARGETS)
+#!IF "$(BUILDMSG)" != ""
+#    @echo ; $(BUILDMSG) ;
+#!ENDIF
+
+
+
+$(SDKINC)\tapi.h: ..\inc\tapi.x
+    mkpublic ..\inc\tapi.x $(SDKINC)\tapi.h
+    copy ..\inc\tapi.x ..\inc\tapi.h
+
+$(SDKINC)\tspi.h: ..\inc\tspi.x
+    mkpublic ..\inc\tspi.x $(SDKINC)\tspi.h
+    copy ..\inc\tspi.x ..\inc\tspi.h
+
+
+
+$(CLIENT_TARGETS) : ..\$(IDL_NAME).idl $(EXTRN_DEPENDS)
+    copy ..\tapsrv.acf
+    copy ..\tapsrv.idl
+    $(MIDL) -Oi -server none -oldnames -error allocation -error ref -ms_ext -c_ext $(IDL_NAME).idl $(INCS)
+    IF EXIST $(IDL_NAME)_c.c copy $(IDL_NAME)_c.c ..\client
+    IF EXIST $(IDL_NAME)_c.c copy $(IDL_NAME)_c.c ..\sp\remotesp
+    IF EXIST $(IDL_NAME)_c.c del  $(IDL_NAME)_c.c
+
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h ..\client
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h ..\sp\remotesp
+
+
+$(SERVER_TARGETS) : ..\$(IDL_NAME).idl $(EXTRN_DEPENDS)
+    copy ..\tapsrv.acf
+    copy ..\tapsrv.idl
+    $(MIDL) -client none -oldnames -error stub_data -error allocation -error ref -ms_ext -c_ext $(IDL_NAME).idl $(INCS)
+    IF EXIST $(IDL_NAME)_s.c copy $(IDL_NAME)_s.c ..\server
+    IF EXIST $(IDL_NAME)_s.c del  $(IDL_NAME)_s.c
+
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h ..\server
+    IF EXIST $(IDL_NAME).h del  $(IDL_NAME).h
+
+
+$(CLIENT_TARGETS2) : ..\$(IDL_NAME2).idl $(EXTRN_DEPENDS2)
+    copy ..\rmotsp.acf
+    copy ..\rmotsp.idl
+    $(MIDL) -Oi -server none -oldnames -error allocation -error ref -ms_ext  $(IDL_NAME2).idl $(INCS)
+    IF EXIST $(IDL_NAME2)_c.c copy $(IDL_NAME2)_c.c ..\server
+    IF EXIST $(IDL_NAME2)_c.c del  $(IDL_NAME2)_c.c
+
+    IF EXIST $(IDL_NAME2).h copy $(IDL_NAME2).h ..\server
+
+
+$(SERVER_TARGETS2) : ..\$(IDL_NAME2).idl $(EXTRN_DEPENDS2)
+    copy ..\rmotsp.acf
+    copy ..\rmotsp.idl
+    $(MIDL) -client none -oldnames -error stub_data -error allocation -error ref -ms_ext  $(IDL_NAME2).idl $(INCS)
+    IF EXIST $(IDL_NAME2)_s.c copy $(IDL_NAME2)_s.c ..\sp\remotesp
+    IF EXIST $(IDL_NAME2)_s.c del  $(IDL_NAME2)_s.c
+
+    IF EXIST $(IDL_NAME2).h copy $(IDL_NAME2).h ..\sp\remotesp
+    IF EXIST $(IDL_NAME2).h del  $(IDL_NAME2).h
+
+
+#
+# Define Products and Dependencies
+#
+
+clean: delete_source all
+
+delete_source:
+    erase $(CLIENT_TARGETS)
+    erase $(SERVER_TARGETS)
+    erase $(CLIENT_TARGETS2)
+    erase $(SERVER_TARGETS2)
+    erase $(SDKINC)\tapi.h
+    erase $(SDKINC)\tspi.h
diff --git a/private/tapi/dev/perfdll/makefile b/private/tapi/dev/perfdll/makefile
new file mode 100644
index 000000000..68867704a
--- /dev/null
+++ b/private/tapi/dev/perfdll/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/perfdll/perfctr.h b/private/tapi/dev/perfdll/perfctr.h
new file mode 100644
index 000000000..e29caf35c
--- /dev/null
+++ b/private/tapi/dev/perfdll/perfctr.h
@@ -0,0 +1,28 @@
+//
+//  Offset definition file for extensible counter objects and counters
+//
+//  These "relative" offsets must start at 0 and be multiples of 2 (i.e.
+//  even numbers). In the Open Procedure, they will be added to the 
+//  "First Counter" and "First Help" values for the device they belong to, 
+//  in order to determine the absolute location of the counter and 
+//  object names and corresponding Explain text in the registry.
+//
+//  This file is used by the extensible counter DLL code as well as the 
+//  counter name and Explain text definition file (.INI) file that is used
+//  by LODCTR to load the names into the registry.
+//
+#define TAPIOBJ                 0
+#define LINES                   2
+#define PHONES                  4
+#define LINESINUSE              6
+#define PHONESINUSE             8
+#define TOTALOUTGOINGCALLS      10
+#define TOTALINCOMINGCALLS      12
+#define CLIENTAPPS              14
+#define ACTIVEOUTGOINGCALLS     16
+#define ACTIVEINCOMINGCALLS     18
+
+
+
+  
+  
diff --git a/private/tapi/dev/perfdll/sources b/private/tapi/dev/perfdll/sources
new file mode 100644
index 000000000..2aa59352b
--- /dev/null
+++ b/private/tapi/dev/perfdll/sources
@@ -0,0 +1,56 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tapiperf
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=dll
+
+TARGETLIBS=\
+           $(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+DLLBASE=0x60000000
+
+USE_CRTDLL=1
+
+C_DEFINES=-DWINVER=0x400
+
+SOURCES=\
+        tapiperf.c \
+        tapiperf.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllEntryPoint
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
+
diff --git a/private/tapi/dev/perfdll/tapiperf.c b/private/tapi/dev/perfdll/tapiperf.c
new file mode 100644
index 000000000..8cfcb708f
--- /dev/null
+++ b/private/tapi/dev/perfdll/tapiperf.c
@@ -0,0 +1,940 @@
+/*++ BUILD Version: 0001    // Increment this if a change has global effects
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    perfTAPI.c
+
+Abstract:
+
+    This file implements the Extensible Objects for the TAPI object type
+
+Revision History
+
+
+--*/
+
+//
+//  Include Files
+//
+
+#include <windows.h>
+#include <string.h>
+#include <wcstr.h>
+#include <tapi.h>
+#include <tspi.h>
+#include "..\client\client.h"
+#include "..\client\private.h"
+#include "..\client\tapsrv.h"
+#include <ntprfctr.h>
+#include "perfctr.h"
+#include "tapiperf.h"
+
+//
+//  References to constants which initialize the Object type definitions
+//
+
+
+HINSTANCE                   ghInst;
+HINSTANCE                   ghTapiInst;
+extern TAPI_DATA_DEFINITION TapiDataDefinition;
+DWORD                       dwOpenCount = 0;        // count of "Open" threads
+BOOL                        bInitOK = FALSE;        // true = DLL initialized OK
+HLINEAPP                    hLineApp;
+HPHONEAPP                   hPhoneApp;
+BOOL                        bTapiSrvRunning = FALSE;
+DWORD                       gdwLineDevs, gdwPhoneDevs;
+
+void CheckForTapiSrv();
+LONG WINAPI Tapi32Performance(PPERFBLOCK);
+//
+// Tapi data structures
+//
+
+HANDLE hTapiSharedMemory;		 // Handle of Tapi Shared Memory
+PPERF_COUNTER_BLOCK pCounterBlock;
+
+typedef  LONG (* PERFPROC)(PERFBLOCK *);
+
+#define SZINTERNALPERF          TEXT("internalPerformance")
+#define SZTAPI32                TEXT("tapi32.dll")
+#define SZTAPISRVKEY            TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Telephony")
+
+PERFPROC    glpfnInternalPerformance;
+
+//
+//  Function Prototypes
+//
+//      these are used to insure that the data collection functions
+//      accessed by Perflib will have the correct calling format.
+//
+
+PM_OPEN_PROC        OpenTapiPerformanceData;
+PM_COLLECT_PROC     CollectTapiPerformanceData;
+PM_CLOSE_PROC       CloseTapiPerformanceData;
+
+
+//
+//  Constant structure initializations 
+//      defined in datatapi.h
+//
+
+TAPI_DATA_DEFINITION TapiDataDefinition = 
+{
+        {
+                sizeof(TAPI_DATA_DEFINITION) + SIZE_OF_TAPI_PERFORMANCE_DATA,
+                sizeof(TAPI_DATA_DEFINITION),
+                sizeof(PERF_OBJECT_TYPE),
+                TAPIOBJ,
+                0,
+                TAPIOBJ,
+                0,
+                PERF_DETAIL_NOVICE,
+                (sizeof(TAPI_DATA_DEFINITION)-sizeof(PERF_OBJECT_TYPE))/
+                        sizeof(PERF_COUNTER_DEFINITION),
+                0,
+                0,
+                0
+        },
+
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                LINES,
+                0,
+                LINES,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                LINES_OFFSET
+        },
+
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                PHONES,
+                0,
+                PHONES,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                PHONES_OFFSET
+        },
+
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                LINESINUSE,
+                0,
+                LINESINUSE,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                LINESINUSE_OFFSET
+        },
+        
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                PHONESINUSE,
+                0,
+                PHONESINUSE,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                PHONESINUSE_OFFSET
+        },
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                TOTALOUTGOINGCALLS,
+                0,
+                TOTALOUTGOINGCALLS,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_COUNTER,
+                sizeof(DWORD),
+                TOTALOUTGOINGCALLS_OFFSET
+        },
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                TOTALINCOMINGCALLS,
+                0,
+                TOTALINCOMINGCALLS,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_COUNTER,
+                sizeof(DWORD),
+                TOTALINCOMINGCALLS_OFFSET
+        },
+
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                CLIENTAPPS,
+                0,
+                CLIENTAPPS,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                CLIENTAPPS_OFFSET
+        }
+ ,
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                ACTIVEOUTGOINGCALLS,
+                0,
+                ACTIVEOUTGOINGCALLS,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                ACTIVEOUTGOINGCALLS_OFFSET
+        },
+        {   
+                sizeof(PERF_COUNTER_DEFINITION),
+                ACTIVEINCOMINGCALLS,
+                0,
+                ACTIVEINCOMINGCALLS,
+                0,
+                0,
+                PERF_DETAIL_NOVICE,
+                PERF_COUNTER_RAWCOUNT,
+                sizeof(DWORD),
+                ACTIVEINCOMINGCALLS_OFFSET
+        }
+
+
+};
+
+
+DWORD APIENTRY
+OpenTapiPerformanceData(
+    LPWSTR lpDeviceNames
+    )
+
+/*++
+
+Routine Description:
+
+    This routine will open and map the memory used by the TAPI driver to
+    pass performance data in. This routine also initializes the data
+    structures used to pass data back to the registry
+
+Arguments:
+
+    Pointer to object ID of each device to be opened (TAPI)
+
+
+Return Value:
+
+    None.
+
+--*/
+
+{
+    LONG status;
+    TCHAR szMappedObject[] = TEXT("TAPI_COUNTER_BLOCK");
+    HKEY hKeyDriverPerf;
+    DWORD size;
+    DWORD type;
+    DWORD dwFirstCounter;
+    DWORD dwFirstHelp;
+    HKEY  hTapiKey;
+    DWORD   dwType;
+    DWORD   dwSize;
+
+    //
+    //  Since SCREG is multi-threaded and will call this routine in
+    //  order to service remote performance queries, this library
+    //  must keep track of how many times it has been opened (i.e.
+    //  how many threads have accessed it). the registry routines will
+    //  limit access to the initialization routine to only one thread 
+    //  at a time so synchronization (i.e. reentrancy) should not be 
+    //  a problem
+    //
+    
+    if (!dwOpenCount)
+    {
+
+        // get counter and help index base values
+        //      update static data structures by adding base to 
+        //          offset value in structure.
+
+        // these values are from <ntprfctr.h>
+        dwFirstCounter  = TAPI_FIRST_COUNTER_INDEX;
+        dwFirstHelp     = TAPI_FIRST_HELP_INDEX;
+        
+        TapiDataDefinition.TapiObjectType.ObjectNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.TapiObjectType.ObjectHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.Lines.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.Lines.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.Phones.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.Phones.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.LinesInUse.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.LinesInUse.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.PhonesInUse.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.PhonesInUse.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.TotalOutgoingCalls.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.TotalOutgoingCalls.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.TotalIncomingCalls.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.TotalIncomingCalls.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.ClientApps.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.ClientApps.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.CurrentOutgoingCalls.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.CurrentOutgoingCalls.CounterHelpTitleIndex += dwFirstHelp;
+
+        TapiDataDefinition.CurrentIncomingCalls.CounterNameTitleIndex += dwFirstCounter;
+        TapiDataDefinition.CurrentIncomingCalls.CounterHelpTitleIndex += dwFirstHelp;
+        
+        bInitOK = TRUE; // ok to use this function
+    }
+
+    dwOpenCount++;  // increment OPEN counter
+
+    // get number of devices from tapi
+
+
+    RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+                 SZTAPISRVKEY,
+                 0,
+                 KEY_READ,
+                 &hTapiKey);
+
+    dwSize = sizeof(DWORD);
+    
+    if (ERROR_SUCCESS != RegQueryValueEx(hTapiKey,
+                                         TEXT("Perf1"),
+                                         NULL,
+                                         &dwType,
+                                         (LPBYTE)&gdwLineDevs,
+                                         &dwSize))
+    {
+        gdwLineDevs = 0;
+    }
+    else
+    {
+        gdwLineDevs -= 'PERF';
+    }
+
+    dwSize = sizeof(DWORD);
+    
+    if (ERROR_SUCCESS != RegQueryValueEx(hTapiKey,
+                                         TEXT("Perf2"),
+                                         NULL,
+                                         &dwType,
+                                         (LPBYTE)&gdwPhoneDevs,
+                                         &dwSize))
+    {
+        gdwPhoneDevs = 0;
+    }
+    else
+    {
+        gdwPhoneDevs -= 'PERF';
+    }
+
+    RegCloseKey(hTapiKey);
+                    
+    status = ERROR_SUCCESS; // for successful exit
+
+OpenExitPoint:
+
+    return status;
+
+}
+
+DWORD APIENTRY
+CollectTapiPerformanceData(
+    IN      LPWSTR  lpValueName,
+    IN OUT  LPVOID  *lppData,
+    IN OUT  LPDWORD lpcbTotalBytes,
+    IN OUT  LPDWORD lpNumObjectTypes
+)
+/*++
+
+Routine Description:
+
+    This routine will return the data for the TAPI counters.
+
+Arguments:
+
+   IN       LPWSTR   lpValueName
+         pointer to a wide character string passed by registry.
+
+   IN OUT   LPVOID   *lppData
+         IN: pointer to the address of the buffer to receive the completed 
+            PerfDataBlock and subordinate structures. This routine will
+            append its data to the buffer starting at the point referenced
+            by *lppData.
+         OUT: points to the first byte after the data structure added by this
+            routine. This routine updated the value at lppdata after appending
+            its data.
+
+   IN OUT   LPDWORD  lpcbTotalBytes
+         IN: the address of the DWORD that tells the size in bytes of the 
+            buffer referenced by the lppData argument
+         OUT: the number of bytes added by this routine is written to the 
+            DWORD pointed to by this argument
+
+   IN OUT   LPDWORD  NumObjectTypes
+         IN: the address of the DWORD to receive the number of objects added 
+            by this routine 
+         OUT: the number of objects added by this routine is written to the 
+            DWORD pointed to by this argument
+
+Return Value:
+
+      ERROR_MORE_DATA if buffer passed is too small to hold data
+         any error conditions encountered are reported to the event log if
+         event logging is enabled.
+
+      ERROR_SUCCESS  if success or any other error. Errors, however are
+         also reported to the event log.
+
+--*/
+{
+    //  Variables for reformatting the data
+
+    ULONG SpaceNeeded;
+    PDWORD pdwCounter;
+    PERF_COUNTER_BLOCK *pPerfCounterBlock;
+    TAPI_DATA_DEFINITION *pTapiDataDefinition;
+
+    //	Variables for collecting data about TAPI Resouces
+
+    LPWSTR                              lpFromString;
+    LPWSTR                              lpToString;
+    INT                                 iStringLength;
+
+    // variables used for error logging
+
+    DWORD                               dwDataReturn[2];
+    DWORD                               dwQueryType;
+
+    PPERFBLOCK                          pPerfBlock;
+    static BOOL                         bFirst = TRUE;
+
+    //
+    // before doing anything else, see if Open went OK
+    //
+
+    if (!bInitOK)
+    {
+        // unable to continue because open failed.
+        *lpcbTotalBytes = (DWORD) 0;
+        *lpNumObjectTypes = (DWORD) 0;
+        return ERROR_SUCCESS; // yes, this is a successful exit
+    }
+    
+    // see if this is a foreign (i.e. non-NT) computer data request 
+    //
+    dwQueryType = GetQueryType (lpValueName);
+    
+    if (dwQueryType == QUERY_FOREIGN)
+    {
+        // this routine does not service requests for data from
+        // Non-NT computers
+        *lpcbTotalBytes = (DWORD) 0;
+        *lpNumObjectTypes = (DWORD) 0;
+        
+        return ERROR_SUCCESS;
+    }
+
+    if (dwQueryType == QUERY_ITEMS)
+    {
+	if ( !(IsNumberInUnicodeList (TapiDataDefinition.TapiObjectType.ObjectNameTitleIndex, lpValueName)))
+        {
+             
+            // request received for data object not provided by this routine
+            *lpcbTotalBytes = (DWORD) 0;
+    	    *lpNumObjectTypes = (DWORD) 0;
+            return ERROR_SUCCESS;
+        }
+    }
+
+    pTapiDataDefinition = (TAPI_DATA_DEFINITION *) *lppData;
+
+    SpaceNeeded = sizeof(TAPI_DATA_DEFINITION) +
+		  SIZE_OF_TAPI_PERFORMANCE_DATA;
+
+    if ( *lpcbTotalBytes < SpaceNeeded )
+    {
+        *lpcbTotalBytes = (DWORD) 0;
+        *lpNumObjectTypes = (DWORD) 0;
+        
+        return ERROR_MORE_DATA;
+    }
+
+    //
+    // Copy the (constant, initialized) Object Type and counter definitions
+    //  to the caller's data buffer
+    //
+
+    if (!bTapiSrvRunning)
+    {
+        CheckForTapiSrv();
+    }
+    
+    pPerfBlock = (PPERFBLOCK)GlobalAlloc(GPTR, sizeof(PERFBLOCK));
+
+    if (!bTapiSrvRunning)
+    {
+        // don't do anything, but succeed
+        
+        FillMemory(pPerfBlock,
+                   sizeof(PERFBLOCK),
+                   0);
+
+        pPerfBlock->dwLines = gdwLineDevs;
+        pPerfBlock->dwPhones = gdwPhoneDevs;
+    }
+    else
+    {
+        pPerfBlock->dwSize = sizeof(PERFBLOCK);
+        glpfnInternalPerformance(pPerfBlock);
+
+        // don't count me as a client app!
+        if (0 != pPerfBlock->dwClientApps)
+        {
+            pPerfBlock->dwClientApps--;
+        }
+    }
+
+    memmove(pTapiDataDefinition,
+            &TapiDataDefinition,
+            sizeof(TAPI_DATA_DEFINITION));
+
+    //
+    //	Format and collect TAPI data from shared memory 
+    //
+
+    pPerfCounterBlock = (PERF_COUNTER_BLOCK *) &pTapiDataDefinition[1];
+
+    pPerfCounterBlock->ByteLength = SIZE_OF_TAPI_PERFORMANCE_DATA;
+
+    pdwCounter = (PDWORD) (&pPerfCounterBlock[1]);
+
+    // make sure we don't have funky values
+    if (((LONG)pPerfBlock->dwTotalOutgoingCalls) < 0)
+    {
+        pPerfBlock->dwTotalOutgoingCalls = 0;
+    }
+
+    if (((LONG)pPerfBlock->dwTotalIncomingCalls) < 0)
+    {
+        pPerfBlock->dwTotalIncomingCalls = 0;
+    }
+
+    if (((LONG)pPerfBlock->dwCurrentOutgoingCalls) < 0)
+    {
+        pPerfBlock->dwCurrentOutgoingCalls = 0;
+    }
+
+    if (((LONG)pPerfBlock->dwCurrentIncomingCalls) < 0)
+    {
+        pPerfBlock->dwCurrentIncomingCalls = 0;
+    }
+    
+    *pdwCounter =   pPerfBlock->dwLines;
+    *++pdwCounter = pPerfBlock->dwPhones;
+    *++pdwCounter = pPerfBlock->dwLinesInUse;
+    *++pdwCounter = pPerfBlock->dwPhonesInUse;
+    *++pdwCounter = pPerfBlock->dwTotalOutgoingCalls;
+    *++pdwCounter = pPerfBlock->dwTotalIncomingCalls;
+    *++pdwCounter = pPerfBlock->dwClientApps;
+    *++pdwCounter = pPerfBlock->dwCurrentOutgoingCalls;
+    *++pdwCounter = pPerfBlock->dwCurrentIncomingCalls;
+
+    *lppData = (PVOID) ++pdwCounter;
+
+    // update arguments for return
+    
+    *lpNumObjectTypes = 1;
+
+    *lpcbTotalBytes = (PBYTE) pdwCounter - (PBYTE) pTapiDataDefinition;
+
+    GlobalFree(pPerfBlock);
+
+    bFirst = FALSE;
+
+    return ERROR_SUCCESS;
+}
+
+
+DWORD APIENTRY
+CloseTapiPerformanceData(
+)
+
+/*++
+
+Routine Description:
+
+    This routine closes the open handles to TAPI device performance counters
+
+Arguments:
+
+    None.
+
+
+Return Value:
+
+    ERROR_SUCCESS
+
+--*/
+
+{
+
+    return ERROR_SUCCESS;
+
+}
+
+void CALLBACK LineCallbackFunc(DWORD dw1,
+                               DWORD dw2,
+                               DWORD dw3,
+                               DWORD dw4,
+                               DWORD dw5,
+                               DWORD dw6)
+{
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+//
+// PERF UTILITY STUFF BELOW!
+//
+//////////////////////////////////////////////////////////////////////
+#define INITIAL_SIZE     1024L
+#define EXTEND_SIZE      1024L
+
+//
+// Global data definitions.
+//
+
+ULONG                   ulInfoBufferSize = 0;
+
+  
+                              // initialized in Open... routines
+  
+  
+DWORD  dwLogUsers = 0;        // count of functions using event log
+
+WCHAR GLOBAL_STRING[] = L"Global";
+WCHAR FOREIGN_STRING[] = L"Foreign";
+WCHAR COSTLY_STRING[] = L"Costly";
+
+WCHAR NULL_STRING[] = L"\0";    // pointer to null string 
+
+// test for delimiter, end of line and non-digit characters
+// used by IsNumberInUnicodeList routine
+//
+#define DIGIT       1
+#define DELIMITER   2
+#define INVALID     3
+
+#define EvalThisChar(c,d) ( \
+     (c == d) ? DELIMITER : \
+     (c == 0) ? DELIMITER : \
+     (c < (WCHAR)'0') ? INVALID : \
+     (c > (WCHAR)'9') ? INVALID : \
+     DIGIT)
+
+
+DWORD
+GetQueryType (
+    IN LPWSTR lpValue
+)
+/*++
+
+GetQueryType
+
+    returns the type of query described in the lpValue string so that
+    the appropriate processing method may be used
+
+Arguments
+
+    IN lpValue
+        string passed to PerfRegQuery Value for processing
+
+Return Value
+
+    QUERY_GLOBAL
+        if lpValue == 0 (null pointer)
+           lpValue == pointer to Null string
+           lpValue == pointer to "Global" string
+
+    QUERY_FOREIGN
+        if lpValue == pointer to "Foreign" string
+
+    QUERY_COSTLY
+        if lpValue == pointer to "Costly" string
+
+    otherwise:
+
+    QUERY_ITEMS
+
+--*/
+{
+    WCHAR   *pwcArgChar, *pwcTypeChar;
+    BOOL    bFound;
+
+    if (lpValue == 0) {
+        return QUERY_GLOBAL;
+    } else if (*lpValue == 0) {
+        return QUERY_GLOBAL;
+    }
+
+    // check for "Global" request
+
+    pwcArgChar = lpValue;
+    pwcTypeChar = GLOBAL_STRING;
+    bFound = TRUE;  // assume found until contradicted
+
+    // check to the length of the shortest string
+    
+    while ((*pwcArgChar != 0) && (*pwcTypeChar != 0)) {
+        if (*pwcArgChar++ != *pwcTypeChar++) {
+            bFound = FALSE; // no match
+            break;          // bail out now
+        }
+    }
+
+    if (bFound) return QUERY_GLOBAL;
+
+    // check for "Foreign" request
+    
+    pwcArgChar = lpValue;
+    pwcTypeChar = FOREIGN_STRING;
+    bFound = TRUE;  // assume found until contradicted
+
+    // check to the length of the shortest string
+    
+    while ((*pwcArgChar != 0) && (*pwcTypeChar != 0)) {
+        if (*pwcArgChar++ != *pwcTypeChar++) {
+            bFound = FALSE; // no match
+            break;          // bail out now
+        }
+    }
+
+    if (bFound) return QUERY_FOREIGN;
+
+    // check for "Costly" request
+    
+    pwcArgChar = lpValue;
+    pwcTypeChar = COSTLY_STRING;
+    bFound = TRUE;  // assume found until contradicted
+
+    // check to the length of the shortest string
+    
+    while ((*pwcArgChar != 0) && (*pwcTypeChar != 0)) {
+        if (*pwcArgChar++ != *pwcTypeChar++) {
+            bFound = FALSE; // no match
+            break;          // bail out now
+        }
+    }
+
+    if (bFound) return QUERY_COSTLY;
+
+    // if not Global and not Foreign and not Costly, 
+    // then it must be an item list
+    
+    return QUERY_ITEMS;
+
+}
+
+BOOL
+IsNumberInUnicodeList (
+    IN DWORD   dwNumber,
+    IN LPWSTR  lpwszUnicodeList
+)
+/*++
+
+IsNumberInUnicodeList
+
+Arguments:
+        
+    IN dwNumber
+        DWORD number to find in list
+
+    IN lpwszUnicodeList
+        Null terminated, Space delimited list of decimal numbers
+
+Return Value:
+
+    TRUE:
+            dwNumber was found in the list of unicode number strings
+
+    FALSE:
+            dwNumber was not found in the list.
+
+--*/
+{
+    DWORD   dwThisNumber;
+    WCHAR   *pwcThisChar;
+    BOOL    bValidNumber;
+    BOOL    bNewItem;
+    BOOL    bReturnValue;
+    WCHAR   wcDelimiter;    // could be an argument to be more flexible
+
+    if (lpwszUnicodeList == 0) return FALSE;    // null pointer, # not found
+
+    pwcThisChar = lpwszUnicodeList;
+    dwThisNumber = 0;
+    wcDelimiter = (WCHAR)' ';
+    bValidNumber = FALSE;
+    bNewItem = TRUE;
+    
+    while (TRUE) {
+        switch (EvalThisChar (*pwcThisChar, wcDelimiter)) {
+            case DIGIT:
+                // if this is the first digit after a delimiter, then 
+                // set flags to start computing the new number
+                if (bNewItem) {
+                    bNewItem = FALSE;
+                    bValidNumber = TRUE;
+                }
+                if (bValidNumber) {
+                    dwThisNumber *= 10;
+                    dwThisNumber += (*pwcThisChar - (WCHAR)'0');
+                }
+                break;
+            
+            case DELIMITER:
+                // a delimiter is either the delimiter character or the 
+                // end of the string ('\0') if when the delimiter has been
+                // reached a valid number was found, then compare it to the
+                // number from the argument list. if this is the end of the
+                // string and no match was found, then return.
+                //
+                if (bValidNumber) {
+                    if (dwThisNumber == dwNumber) return TRUE;
+                    bValidNumber = FALSE;
+                }
+                if (*pwcThisChar == 0) {
+                    return FALSE;
+                } else {
+                    bNewItem = TRUE;
+                    dwThisNumber = 0;
+                }
+                break;
+
+            case INVALID:
+                // if an invalid character was encountered, ignore all
+                // characters up to the next delimiter and then start fresh.
+                // the invalid number is not compared.
+                bValidNumber = FALSE;
+                break;
+
+            default:
+                break;
+
+        }
+        pwcThisChar++;
+    }
+
+}   // IsNumberInUnicodeList
+
+BOOL
+WINAPI
+DllEntryPoint(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+        {
+            ghInst = hDLL;
+
+            break;
+        }
+        case DLL_PROCESS_DETACH:
+        {
+            break;
+        }
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+        {
+            break;
+        }
+
+    } // switch
+
+    return TRUE;
+}
+
+void CheckForTapiSrv()
+{
+    SC_HANDLE               sc, scTapiSrv;
+    SERVICE_STATUS          ServStat;
+
+    sc = OpenSCManager(NULL,
+                       NULL,
+                       GENERIC_READ);
+
+    if (NULL == sc)
+    {
+        return;
+    }
+
+    bTapiSrvRunning = FALSE;
+
+    scTapiSrv = OpenService(sc,
+                            "TAPISRV",
+                            SERVICE_QUERY_STATUS);
+
+
+    if (!QueryServiceStatus(scTapiSrv,
+                            &ServStat))
+    {
+    }
+
+    if (ServStat.dwCurrentState != SERVICE_RUNNING)
+    {
+    }
+    else
+    {
+        bTapiSrvRunning = TRUE;
+    }
+    
+    if (bTapiSrvRunning)
+    {
+        ghTapiInst = LoadLibrary(SZTAPI32);
+
+        if (!ghTapiInst)
+        {
+        }
+        
+        glpfnInternalPerformance = (PERFPROC)GetProcAddress(ghTapiInst,
+                                                            SZINTERNALPERF);
+
+        if (!glpfnInternalPerformance)
+        {
+        }
+            
+    }
+
+    CloseServiceHandle(sc);
+
+}
diff --git a/private/tapi/dev/perfdll/tapiperf.def b/private/tapi/dev/perfdll/tapiperf.def
new file mode 100644
index 000000000..412ff08a0
--- /dev/null
+++ b/private/tapi/dev/perfdll/tapiperf.def
@@ -0,0 +1,10 @@
+LIBRARY   TAPIPERF
+
+DATA      READ WRITE
+
+EXPORTS
+
+    OpenTapiPerformanceData
+    CollectTapiPerformanceData
+    CloseTapiPerformanceData
+
diff --git a/private/tapi/dev/perfdll/tapiperf.h b/private/tapi/dev/perfdll/tapiperf.h
new file mode 100644
index 000000000..17459e958
--- /dev/null
+++ b/private/tapi/dev/perfdll/tapiperf.h
@@ -0,0 +1,193 @@
+/*++ BUILD Version: 0001    // Increment this if a change has global effects
+  
+  
+
+Copyright (c) 1992 Microsoft Corporation
+
+Module Name:
+
+      datatapi.h
+
+Abstract:
+
+    Header file for the TAPI Extensible Object data definitions
+
+    This file contains definitions to construct the dynamic data
+    which is returned by the Configuration Registry.  Data from
+    various driver API calls is placed into the structures shown
+    here.
+
+--*/
+
+#ifndef _TAPIPERF_H_
+#define _TAPIPERF_H_
+
+#include <winperf.h>
+//
+//  The routines that load these structures assume that all fields
+//  are packed and aligned on DWORD boundaries. Alpha support may 
+//  change this assumption so the pack pragma is used here to insure
+//  the DWORD packing assumption remains valid.
+//
+#pragma pack (4)
+
+//
+//  Extensible Object definitions
+//
+
+//  Update the following sort of define when adding an object type.
+
+#define TAPI_NUM_PERF_OBJECT_TYPES 1
+
+
+//
+//  TAPI Resource object type counter definitions.
+//
+//  These are used in the counter definitions to describe the relative
+//  position of each counter in the returned data.
+  
+
+#define LINES_OFFSET                                                 sizeof(DWORD)
+#define PHONES_OFFSET                   LINES_OFFSET               + sizeof(DWORD)
+#define LINESINUSE_OFFSET               PHONES_OFFSET              + sizeof(DWORD)
+#define PHONESINUSE_OFFSET              LINESINUSE_OFFSET          + sizeof(DWORD)
+#define TOTALOUTGOINGCALLS_OFFSET       PHONESINUSE_OFFSET         + sizeof(DWORD)
+#define TOTALINCOMINGCALLS_OFFSET       TOTALOUTGOINGCALLS_OFFSET  + sizeof(DWORD)
+#define CLIENTAPPS_OFFSET               TOTALINCOMINGCALLS_OFFSET  + sizeof(DWORD)
+#define ACTIVEOUTGOINGCALLS_OFFSET      CLIENTAPPS_OFFSET          + sizeof(DWORD)
+#define ACTIVEINCOMINGCALLS_OFFSET      ACTIVEOUTGOINGCALLS_OFFSET + sizeof(DWORD)
+//#define SIZE_OF_TAPI_PERFORMANCE_DATA   32
+#define SIZE_OF_TAPI_PERFORMANCE_DATA   40
+
+
+//
+//  This is the counter structure presently returned by TAPI.
+//
+
+typedef struct _TAPI_DATA_DEFINITION 
+{
+    PERF_OBJECT_TYPE            TapiObjectType;
+    PERF_COUNTER_DEFINITION     Lines;
+    PERF_COUNTER_DEFINITION     Phones;
+    PERF_COUNTER_DEFINITION     LinesInUse;
+    PERF_COUNTER_DEFINITION     PhonesInUse;
+    PERF_COUNTER_DEFINITION     TotalOutgoingCalls;
+    PERF_COUNTER_DEFINITION     TotalIncomingCalls;
+    PERF_COUNTER_DEFINITION     ClientApps;
+    PERF_COUNTER_DEFINITION     CurrentOutgoingCalls;
+    PERF_COUNTER_DEFINITION     CurrentIncomingCalls;
+} TAPI_DATA_DEFINITION;
+
+typedef struct tagPERFBLOCK
+{
+    DWORD           dwSize;
+    DWORD           dwLines;
+    DWORD           dwPhones;
+    DWORD           dwLinesInUse;
+    DWORD           dwPhonesInUse;
+    DWORD           dwTotalOutgoingCalls;
+    DWORD           dwTotalIncomingCalls;
+    DWORD           dwClientApps;
+    DWORD           dwCurrentOutgoingCalls;
+    DWORD           dwCurrentIncomingCalls;
+} PERFBLOCK, *PPERFBLOCK;
+
+#pragma pack ()
+
+    
+
+/////////////////////////////////////////////////////////////////
+// PERFUTIL header stuff below
+
+// enable this define to log process heap data to the event log
+#ifdef PROBE_HEAP_USAGE
+#undef PROBE_HEAP_USAGE
+#endif
+//
+  
+  
+//  Utility macro.  This is used to reserve a DWORD multiple of bytes for Unicode strings 
+//  embedded in the definitional data, viz., object instance names.
+  
+  
+//
+  
+  
+#define DWORD_MULTIPLE(x) (((x+sizeof(DWORD)-1)/sizeof(DWORD))*sizeof(DWORD))
+  
+  
+
+//    (assumes dword is 4 bytes long and pointer is a dword in size)
+  
+  
+#define ALIGN_ON_DWORD(x) ((VOID *)( ((DWORD) x & 0x00000003) ? ( ((DWORD) x & 0xFFFFFFFC) + 4 ) : ( (DWORD) x ) ))
+  
+  
+
+extern WCHAR  GLOBAL_STRING[];      // Global command (get all local ctrs)
+extern WCHAR  FOREIGN_STRING[];           // get data from foreign computers
+extern WCHAR  COSTLY_STRING[];      
+  
+  
+extern WCHAR  NULL_STRING[];
+  
+  
+
+#define QUERY_GLOBAL    1
+#define QUERY_ITEMS     2
+#define QUERY_FOREIGN   3
+#define QUERY_COSTLY    4
+
+//
+  
+  
+// The definition of the only routine of perfutil.c, It builds part of a performance data 
+// instance (PERF_INSTANCE_DEFINITION) as described in winperf.h
+  
+  
+//
+
+HANDLE MonOpenEventLog ();
+VOID MonCloseEventLog ();
+DWORD GetQueryType (IN LPWSTR);
+BOOL IsNumberInUnicodeList (DWORD, LPWSTR);
+
+typedef struct _LOCAL_HEAP_INFO_BLOCK {
+    DWORD   AllocatedEntries;
+    DWORD   AllocatedBytes;
+    DWORD   FreeEntries;
+    DWORD   FreeBytes;
+} LOCAL_HEAP_INFO, *PLOCAL_HEAP_INFO;
+
+
+//
+//  Memory Probe macro
+//
+#ifdef PROBE_HEAP_USAGE
+
+#define HEAP_PROBE()    { \
+    DWORD   dwHeapStatus[5]; \
+    NTSTATUS CallStatus; \
+    dwHeapStatus[4] = __LINE__; }
+//    if (!(CallStatus = memprobe (dwHeapStatus, 16L, NULL))) { \
+//        REPORT_INFORMATION_DATA (TAPI_HEAP_STATUS, LOG_DEBUG,    \
+//            &dwHeapStatus, sizeof(dwHeapStatus));  \
+//    } else {  \
+//        REPORT_ERROR_DATA (TAPI_HEAP_STATUS_ERROR, LOG_DEBUG, \
+//            &CallStatus, sizeof (DWORD)); \
+//    } \
+//}
+
+#else
+
+#define HEAP_PROBE()    ;
+  
+  
+
+  
+  
+#endif
+
+
+#endif //_DATATAPI_H_
+
diff --git a/private/tapi/dev/perfdll/tapiperf.ini b/private/tapi/dev/perfdll/tapiperf.ini
new file mode 100644
index 000000000..8964d8985
--- /dev/null
+++ b/private/tapi/dev/perfdll/tapiperf.ini
@@ -0,0 +1,38 @@
+[info]
+
+drivername=TAPISRV
+symbolfile=perfctr.h
+
+[languages]
+009=English
+
+[text]
+TAPIOBJ_009_NAME=Telephony
+TAPIOBJ_009_HELP=The Telphony System
+
+LINES_009_NAME=Number of Lines
+LINES_009_HELP=The number of telephone lines serviced by this computer.
+
+PHONES_009_NAME=Number of Telephone devices
+PHONES_009_HELP=The number of telephone devices serviced by this computer.
+
+LINESINUSE_009_NAME=Number of Active Lines
+LINESINUSE_009_HELP=the number of telephone lines serviced by this computer that are currently active.
+
+PHONESINUSE_009_NAME=Number of Active Telephones
+PHONESINUSE_009_HELP=The number of telephone devices that are currently being monitored.
+
+TOTALOUTGOINGCALLS_009_NAME=Outgoing calls/sec
+TOTALOUTGOINGCALLS_009_HELP=The rate of outgoing calls made by this computer.
+
+TOTALINCOMINGCALLS_009_NAME=Incoming calls/sec
+TOTALINCOMINGCALLS_009_HELP=The rate of incoming calls answered by this computer.
+
+CLIENTAPPS_009_NAME=Number of Client Apps
+CLIENTAPPS_009_HELP=The number of applications that are currently using telephony services.
+
+ACTIVEOUTGOINGCALLS_009_NAME=Current Outgoing Calls 
+ACTIVEOUTGOINGCALLS_009_HELP=Current outgoing calls being serviced by this computer.
+
+ACTIVEINCOMINGCALLS_009_NAME=Current Incoming Calls
+ACTIVEINCOMINGCALLS_009_HELP=Current incoming calls being serviced by this computer.
diff --git a/private/tapi/dev/perfdll/tapiperf.rc b/private/tapi/dev/perfdll/tapiperf.rc
new file mode 100644
index 000000000..17d2a4092
--- /dev/null
+++ b/private/tapi/dev/perfdll/tapiperf.rc
@@ -0,0 +1,18 @@
+#include "windows.h"
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+#include <ntverp.h>
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony Performance Monitor"
+#define VER_INTERNALNAME_STR        "Telephony Performance"
+#define VER_ORIGINALFILENAME_STR    "TAPIPERF.DLL"
+//#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+#define VER_LEGALCOPYRIGHT_YEARS      "1996"
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
diff --git a/private/tapi/dev/post14/cpl/cpl.c b/private/tapi/dev/post14/cpl/cpl.c
new file mode 100644
index 000000000..87bc08251
--- /dev/null
+++ b/private/tapi/dev/post14/cpl/cpl.c
@@ -0,0 +1,507 @@
+/*--------------------------------------------------------------------------*\
+   Module:     cpl.c
+   
+   Purpose: The main entry point for the Control Panel, and the main
+            top level dialog proc(s).
+   
+   History:
+      7/27/93 CBB - Created
+\*--------------------------------------------------------------------------*/
+
+#include  <windows.h>
+#include  <windowsx.h>
+#include  <cpl.h>    /* Windows, not ours, sorry a little confusing */
+#include  "cpl.h"        
+#include  "help.h"
+#include  "init.h"
+#include  "drv.h"
+#include  "util.h"
+#include  "resource.h"
+#include  <malloc.h>
+#include  <prsht.h>  /* for PropertySheet defs */
+
+//------------------
+// Private Constants
+//------------------
+#ifdef CTL3D
+#define  CTL3D_REGISTER       12       // ordinals for using CTL3D.DLL
+#define  CTL3D_AUTOSUBCLASS   16
+#define  CTL3D_UN_REGISTER    13
+#define  CTL3D_COLOR_CHANGE   6
+#endif /* CTL3D */
+
+//-------------
+// Private Data
+//-------------
+CPL   gCPL;       // app global
+
+#ifndef _WIN32
+#pragma code_seg ( "CPL_MAIN" )
+#endif
+
+// the following are not to be translated, so they can be static
+#ifndef _WIN32  // don't need ctl3d.dll
+#ifdef CTL3D
+static char SEG_CPL gszCtl3DLib[] = "CTL3D.DLL";
+#endif /* CTL3D */
+#endif
+
+//--------------------
+// Function Prototypes
+//--------------------
+UINT PRIVATE   CplInit( HWND hWnd, BOOL fUse3d, LPUINT lpuUpdated );
+UINT PRIVATE   _ErrDoPropertySheet( HWND, WORD, DLGPROC, LPARAM );
+
+
+#ifdef CTL3D
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplSysColorChange
+   
+   Purpose:    Handles WM_SYSCOLORCHANGE for driver dialog.
+   
+\*--------------------------------------------------------------------------*/
+VOID FAR PASCAL CplSysColorChange()
+{
+   FARPROC  lpfnCtl3DColorChange;
+
+   // 3D control stuff
+   //-----------------
+   if ( gCPL.hCtl3DInst != NULL )      // does not happen very often
+   {         
+      lpfnCtl3DColorChange = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_COLOR_CHANGE ));
+      
+      if ( lpfnCtl3DColorChange != NULL )
+         (*lpfnCtl3DColorChange)();     // let him know
+   }  // end if               
+}
+#endif /* CTL3D */
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplInit
+   
+   Purpose:    Initalizes for the init dialog.  We pospone doing some 
+               initalizing until now, so that the control panel won't take
+               years to load...
+   
+\*--------------------------------------------------------------------------*/
+UINT PRIVATE   CplInit( HWND     hWnd,
+                        BOOL     fUse3d,
+                        LPUINT   lpuUpdated )
+
+   {
+   UINT  uResult;
+   UINT  uOldErrMode;
+#ifdef CTL3D
+   FARPROC  lpfnCtl3DRegister;
+   FARPROC  lpfnCtl3DAutoSubclass;
+#endif /* CTL3D */
+   extern CPL     gCPL;       // app global
+   // char gszCtl3DLib[]   - global string in code segment
+
+   gCPL.wInstances++;            // ONECPL:  CANNOT be used by multiple apps!
+   
+   if ( gCPL.wInstances == 1 )   // ONECPL
+      {
+      gCPL.hWnd = hWnd;          // ONECPL
+
+#ifndef _WIN32
+#ifdef CTL3D
+      if ( fUse3d && (LOBYTE(LOWORD( GetVersion())) < 4))      // only for win3.1 and below
+         {
+
+         // init 3D control stuff
+         //----------------------
+         uOldErrMode = (UINT)SetErrorMode( SEM_NOOPENFILEERRORBOX );  // turn off that it can't find the library!
+         
+         gCPL.hCtl3DInst = LoadLibrary( gszCtl3DLib );
+         
+         SetErrorMode( uOldErrMode );                                 // restore the error mode!
+         
+         if (  gCPL.hCtl3DInst <= HINSTANCE_ERROR )
+            {
+            gCPL.hCtl3DInst = NULL;    // set back to default
+            }
+         else
+            {
+            // get all the procs that we need
+            lpfnCtl3DRegister = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_REGISTER ));
+            lpfnCtl3DAutoSubclass = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_AUTOSUBCLASS ));
+
+            if ((lpfnCtl3DRegister == NULL) || (lpfnCtl3DAutoSubclass == NULL))
+               {
+               // ah, didn't work, don't worry too much about it
+               FreeLibrary( gCPL.hCtl3DInst );
+               gCPL.hCtl3DInst = NULL;
+               }
+            else
+               {      
+               // ok, looks like everything worked, register the lib
+               //---------------------------------------------------
+               (*lpfnCtl3DRegister)( gCPL.hCplInst );
+               (*lpfnCtl3DAutoSubclass)( gCPL.hCplInst );
+               }  // end if
+            }  // end if
+         }  // end if
+#endif /* CTL3D */
+#endif
+   
+      *lpuUpdated = FALSE;       // I don't want to talk about it!
+
+      // Initialize the list of service providers
+      //-----------------------------------------
+      if ( ErrRefreshProviderList() != CPL_SUCCESS )
+      {
+      	uResult = CPL_ERR_TAPI_FAILURE;
+         goto  done;
+      }
+      
+      uResult = CPL_SUCCESS;                         // ONECPL
+      }   
+   else
+      {
+      /* Find the first instance main window, and post a message to it to tell it to activate itself */
+      HWND hTopWindow = GetLastActivePopup( gCPL.hWnd );   // ONECPL
+
+      ShowWindow( hTopWindow, SW_RESTORE );          // ONECPL
+      BringWindowToTop( hTopWindow );                // ONECPL
+
+      uResult = CPL_ERR_ALREADY_INITIALIZED;         // ONECPL
+      }  // end if
+
+   done:
+      return( uResult );
+   }  // end function CplInit
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplClose
+   
+   Purpose:    The dialog is being closed, write any necessary chagnes out,
+               clean up all left over memmory and all that stuff...
+   
+\*--------------------------------------------------------------------------*/
+UINT PUBLIC CplClose( UINT  uCommand )
+
+   {
+   UINT  uResult;
+   FARPROC  lpfnCtl3DUnregister;
+   extern CPL     gCPL;       // app global
+
+   if (glpProviderList)
+   {
+   	_ffree(glpProviderList);
+   	glpProviderList = NULL;
+   }
+   
+   // write any changes out to the ini file
+   //--------------------------------------                  
+   gCPL.wInstances = (gCPL.wInstances == 0) ? 0 : (gCPL.wInstances - 1);         // can be used by multiple apps!
+   
+   if ( gCPL.wInstances == 0 )
+      {
+      // delete all the left over lists
+      //-------------------------------
+
+#ifdef CTL3D
+      if ( gCPL.hCtl3DInst != NULL )
+         {         
+         // clear 3D control stuff
+         //-----------------------   
+         lpfnCtl3DUnregister = GetProcAddress( gCPL.hCtl3DInst, MAKEINTRESOURCE( CTL3D_UN_REGISTER ));
+         
+         if ( lpfnCtl3DUnregister != NULL )
+            (*lpfnCtl3DUnregister)( gCPL.hCplInst );     // let him know
+            
+         FreeLibrary( gCPL.hCtl3DInst );
+         gCPL.hCtl3DInst = NULL;
+         }  // end if
+#endif /* CTL3D */
+      }  // end if
+      
+   uResult = CPL_SUCCESS;
+   
+#ifndef _WIN32
+      LocalCompact( CPL_HEAP_SIZE );     // shrink the local heap (WIN32 obsolete)
+#endif      
+      return( uResult );
+}  // end function CplClose
+
+
+/*--------------------------------------------------------------------------*\
+
+   Function:   CplApplet
+   
+   Purpose: The Control Panel entry point, call back funcition...
+   
+\*--------------------------------------------------------------------------*/
+extern char far gszHelpFile[];                                         
+
+
+LONG EXPORT  CPlApplet( HWND   hWndCpl,
+                        UINT   uMessage,
+                        LPARAM lParam1,
+                        LPARAM lParam2 )
+{
+	FUNC_ENTRY( "CPlApplet" )
+	
+   UINT  uResult;
+   UINT  uUpdated;
+   LONG  lResult;
+   LONG  lAppletNum;
+   LPCPLINFO   lpCplInfo;
+   LPNEWCPLINFO   lpNewCplInfo;
+   extern CPL     gCPL;       // app global
+
+  
+   lAppletNum = lParam1;      // start's at zero
+   lResult = 0;               // default return value
+
+   switch ( uMessage ) 
+      {
+      case CPL_INIT:
+         // first message, sent once
+         lResult = InitApplets( hWndCpl );
+         break;
+
+      case CPL_GETCOUNT:
+         // return the number of applets supported
+         lResult = gCPL.wCplApplets;
+         break;
+
+      case CPL_INQUIRE:       
+         // get info about each applet -sent once per app
+         //----------------------------------------------
+         if ( lAppletNum < (LONG)gCPL.wCplApplets )
+            {
+            lpCplInfo  = (LPCPLINFO)lParam2;
+
+            lpCplInfo->idIcon = (int)gCPL.taTeleApplet[lAppletNum].wIconResId;
+            lpCplInfo->idName = (int)gCPL.taTeleApplet[lAppletNum].wNameResId;
+            lpCplInfo->idInfo = (int)gCPL.taTeleApplet[lAppletNum].wStatusLineResId;
+            lpCplInfo->lData  = gCPL.taTeleApplet[lAppletNum].lPrivateData;
+            
+            lResult = TRUE;
+            }  // end if
+         break;
+
+//
+// There was a bug with Nashville in that NEWINQUIRE got sent twice.  We did not set the
+// hIcon field on the second call (see code below).  The value that just happened to be
+// there was our CS.  Later, CP calls DestroyIcon() on that value, and
+// DestroyIcon() calls FreeSelector().  Later when CP goes to call us for
+// CPL_STOP, it GP faults because the CS is invalid.  Cool, huh?
+//
+//
+// FrancisH, on 5/1/96, said:
+//
+//the two CPL_NEWINQUIREs are the shell trying to probe whether you are an ANSI or UNICODE
+//applet (the dwSize that comes through is different each time).  this code was added when
+//we merged with the NT4 shell.  I've already contacted the NT shell team about doing this
+//another way (without sending two NEWINQUIREs), but please check your fix in regardless of
+//what we do and assign the bug to me once the telephon.cpl code has been updated.  I'll
+//take care of getting ANSI/UNICODE CPL detection straight with the NT team and a fix checked
+//into the Nashville tree.
+//
+//ps: the ideal fix in your applet is to remove support for the CPL_NEWINQUIRE message and just
+//answer the CPL_INQUIRE message instead.  CPL_INQUIRE is much faster than CPL_NEWINQUIRE as
+//the shell can cache the ids you return and avoid repeatedly loading your DLL.  if you do
+//require CPL_NEWINQUIRE (for example if you are dynamically updating your applet's icon
+//based on the state of some device) then please load/create a new icon every time you
+//see the message...
+//
+//      case CPL_NEWINQUIRE:
+//         // new version of CPL_INQUIRE, return info about each applet
+//         //----------------------------------------------------------
+//         if ( lAppletNum < (LONG)gCPL.wCplApplets )
+//            {
+//            lpNewCplInfo  = (LPNEWCPLINFO)lParam2;
+//            
+//            lpNewCplInfo->dwFlags       = 0;
+//            lpNewCplInfo->dwSize        = sizeof(NEWCPLINFO);
+//            lpNewCplInfo->lData         = gCPL.taTeleApplet[lAppletNum].lPrivateData;
+//// Win95b 12364            lpNewCplInfo->dwHelpContext = gCPL.taTeleApplet[lAppletNum].dwHelpContext;
+//            lpNewCplInfo->dwHelpContext = 0;
+//             
+//            if ( !gCPL.taTeleApplet[lAppletNum].hIcon )         
+//               {
+//               // load the icon
+//               lpNewCplInfo->hIcon = LoadIcon( gCPL.hCplInst, MAKEINTRESOURCE(gCPL.taTeleApplet[lAppletNum].wIconResId));
+//               
+//               if ( !lpNewCplInfo->hIcon )
+//                  {
+//                  FErrorRpt( hWndCpl, CPL_ERR_MEMORY );
+//                  break;      // will return false by default
+//                  }  // end if
+//                  
+//               gCPL.taTeleApplet[lAppletNum].hIcon = lpNewCplInfo->hIcon;     // save it so we can delete it
+//               }  // end if
+//               
+//            lpNewCplInfo->hIcon = gCPL.taTeleApplet[lAppletNum].hIcon;
+//               
+//            LpszGetStr( lpNewCplInfo->szName, gCPL.taTeleApplet[lAppletNum].wNameResId, CPL_MAX_TITLE );
+//            LpszGetStr( lpNewCplInfo->szInfo, gCPL.taTeleApplet[lAppletNum].wStatusLineResId, CPL_MAX_STATUS_LINE );
+//            lstrcpy (lpNewCplInfo->szHelpFile, gszHelpFile);
+//                     
+//            lResult = TRUE;
+//            }  // end if
+//         break;
+         
+      case CPL_SELECT: 
+         // application selected, who cares...
+         break;
+
+      case CPL_DBLCLK: 
+         //----------------
+         // show the dialog
+         //----------------
+         if ( lAppletNum < (LONG)gCPL.wCplApplets )
+            {
+            // Initialize 3-D lib, verify single instance, initialize provider list
+            uResult = CplInit( hWndCpl, TRUE, &uUpdated );
+            if ( uResult == CPL_SUCCESS )
+            {
+               // Get windows directory, set default path for driver additions.
+               wsInfParseInit();  // initialize Multimedia
+
+					DEBOUT( "Creating Property Sheet" );
+
+					uResult = _ErrDoPropertySheet( hWndCpl,
+															 gCPL.taTeleApplet[lAppletNum].wDialogResId,
+															 gCPL.taTeleApplet[lAppletNum].dlgprcDialog,
+															 uUpdated );
+
+					DEBOUT( "Finished Creating Property Sheet" );
+					
+	            infClose(NULL);    // free up Multimedia
+
+	            // Free up 3-D lib
+	            if ((uResult = CplClose( uUpdated )) != CPL_SUCCESS )
+	               CplClose( IDCANCEL );    // just make sure all the mem is cleaned up!
+	               
+				} // end if
+				
+            if ( uResult != CPL_SUCCESS )                   // hum, things don't look to good
+               {
+               FErrorRpt( hWndCpl, uResult );
+               CplClose( IDCANCEL );    // just make sure all the mem is cleaned up!
+               }  // end if
+            }  // end if
+                                   
+         break;
+
+      case CPL_STOP: 
+         // sent once per app before CPL_EXIT
+         break;
+
+      case CPL_EXIT: 
+         // sent once before FreeLibrary called
+         InitCleanupApplets();
+         break;
+
+      default:
+         break;
+      }  // end case
+      
+   return( lResult );
+}  // end function CplApplet                    
+
+
+UINT PRIVATE _ErrDoPropertySheet( HWND hwndOwner, WORD idResource, 
+											 DLGPROC dlgProc, LPARAM lParam )
+{
+	// Property sheet junk
+   HPROPSHEETPAGE rPages[8];
+   PROPSHEETPAGE psp;
+   PROPSHEETHEADER psh;
+   
+	/****************************************************
+
+							PROPERTY SHEET
+									
+	****************************************************/
+
+    /*
+     * ALERT! ALERT!
+     *
+     * In order for PropertySheets to work correctly, we need
+     * to mark tapi.dll as a Windows 4.0 app. For this we need
+     * to use rc.exe and rcpp.exe from the \chico\dev\sdk\bin
+     * directory (\chico\dev is on \\guilo\slm).
+     * 
+     */
+     
+   psh.dwSize = sizeof(psh);
+   psh.dwFlags = PSH_NOAPPLYNOW | PSH_PROPTITLE;
+   psh.hwndParent = hwndOwner;
+   psh.hInstance = gCPL.hCplInst;
+   psh.pszCaption = MAKEINTRESOURCE(IDS_DIALOG_TITLE);
+   psh.nPages = 0;
+   psh.nStartPage = 0;
+   psh.phpage = rPages;
+
+   /* Define Location page */
+   psp.dwSize = sizeof(psp);
+   psp.dwFlags = PSP_DEFAULT;
+   psp.hInstance = gCPL.hCplInst;
+   psp.pszTemplate = MAKEINTRESOURCE(idResource);
+   psp.pfnDlgProc = dlgProc;
+   psp.lParam = lParam;
+
+   psh.phpage[psh.nPages] = CreatePropertySheetPage(&psp);
+   if (psh.phpage[psh.nPages])
+       psh.nPages++;
+
+   if (PropertySheet(&psh) < 0)
+		return CPL_ERR_DIALOG_BOX;
+   else
+      return 0;
+}
+
+#ifdef MSJ_PROP_SHEET
+UINT PRIVATE _ErrDoPropertySheet( HWND hwndOwner, WORD idResource, 
+											 DLGPROC dlgProc, LPARAM lParam )
+{
+	// Property sheet junk
+   PROPSHEETPAGE   psp[1];
+   PROPSHEETHEADER psh;
+   
+	/****************************************************
+
+							PROPERTY SHEET
+									
+	****************************************************/
+
+    /*
+     * ALERT! ALERT!
+     *
+     * In order for PropertySheets to work correctly, we need
+     * to mark tapi.dll as a Windows 4.0 app. For this we need
+     * to use rc.exe and rcpp.exe from the \chico\dev\sdk\bin
+     * directory (\chico\dev is on \\guilo\slm).
+     * 
+     */
+     
+	psp[0].dwSize = sizeof(PROPSHEETPAGE);
+	psp[0].dwFlags = PSP_DEFAULT;
+	psp[0].hInstance = gCPL.hCplInst;
+	psp[0].pszTemplate = MAKEINTRESOURCE(idResource);
+	psp[0].pfnDlgProc = dlgProc;
+	psp[0].lParam = lParam;
+
+	psh.dwSize = sizeof(psh);
+	psh.dwFlags = PSH_NOAPPLYNOW;
+	psh.hwndParent = hwndOwner;
+	psh.hInstance = gCPL.hCplInst;
+	psh.pszCaption = MAKEINTRESOURCE(IDS_DIALOG_TITLE);
+	psh.nPages = sizeof(psp)/sizeof(PROPSHEETPAGE);
+	psh.ppsp = (LPCPROPSHEETPAGE)&psp;
+	
+	if (PropertySheet(&psh) < 0)
+		return CPL_ERR_DIALOG_BOX;
+	else
+		return 0;
+}
+#endif /* MSJ_PROP_SHEET */
diff --git a/private/tapi/dev/post14/explib.14/depend.mk b/private/tapi/dev/post14/explib.14/depend.mk
new file mode 100644
index 000000000..e3f39ea35
--- /dev/null
+++ b/private/tapi/dev/post14/explib.14/depend.mk
@@ -0,0 +1,3 @@
+.\tapilib.obj: ..\tapilib.c
+
+
diff --git a/private/tapi/dev/post14/explib.14/explib.txt b/private/tapi/dev/post14/explib.14/explib.txt
new file mode 100644
index 000000000..c5b05baf6
--- /dev/null
+++ b/private/tapi/dev/post14/explib.14/explib.txt
@@ -0,0 +1,8 @@
+TAPI32.LIB
+
+This library can be copied over the TAPI32.LIB from the Win32 SDK.  Using this library will allow your application to load and run on versions Windows NT that do not have TAPI.  Using the TAPI32.LIB from the Win32 SDK to build an application will cause application problems when attempting to run that application on Windows NT; ie: the user will get an "Unable to Locate DLL - The dynamic link library TAPI32.DLL could not be found in the specified path..." messagebox.
+
+With this new library, however, the application will successfully run.  When lineInitialize (or any TAPI function) is called on a system without TAPI, the function will simply fail with a LINEERR_OPERATIONUNAVAIL error.  If this error is returned from lineInitialize, it's a good bet TAPI is not installed on that system (ie: the user is running on Windows NT prior to the "Shell Update Release", or has intentionally or accidentally deleted necessary  system files).
+
+Note: this library will only work with 32bit apps and only supports the TAPI 1.4 function set.  When TAPI 2.0 is available, the TAPI32.LIB supplied at that time will provide this same functionality for TAPI 2.0 (which, of course, includes TAPI 1.4...).
+
diff --git a/private/tapi/dev/post14/explib.14/makefile b/private/tapi/dev/post14/explib.14/makefile
new file mode 100644
index 000000000..80d57b7c6
--- /dev/null
+++ b/private/tapi/dev/post14/explib.14/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tapi32.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/post14/explib.14/makefile.def b/private/tapi/dev/post14/explib.14/makefile.def
new file mode 100644
index 000000000..5270add76
--- /dev/null
+++ b/private/tapi/dev/post14/explib.14/makefile.def
@@ -0,0 +1,67 @@
+##############################################################################
+#
+#   tapi32.LIB (explicit lib) Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+WANT_C932=1
+#WANT_C1032=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+DEPENDNAME=..\depend.mk
+
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+
+#LIBNAME=$(SDKLIB)\tapi32l.lib
+LIBNAME=tapi32l.lib		# Name of target
+TARGETS=tapi32l.lib
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+LIBOBJS = tapilib.obj
+
+
+
+# These rules had to be include here because the LIBNAME rules are bogus
+# with C832 and C932's LIB.EXE.
+
+!IFNDEF LB
+LB      = lib
+!ENDIF
+LBFLAGS = $(LBFLAGS) $(NOLOGO:-=/)
+
+$(LIBNAME): $(LIBOBJS)
+        if exist $(LIBNAME) del $(LIBNAME)
+        $(LB) $(LBFLAGS) @<<$(@B).lnk
+/OUT:$(LIBNAME)
+$(LIBOBJS)
+<<$(KEEPFLAG)
+
+
+
+!include $(ROOT)\dev\master.mk
+
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc -GD
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Ox
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
+
+#$(SDKLIB)\tapi32l.lib: tapi32l.lib
+#   copy tapi32l.lib $(SDKLIB)\tapi32l.lib
+
diff --git a/private/tapi/dev/post14/explib.14/sources b/private/tapi/dev/post14/explib.14/sources
new file mode 100644
index 000000000..2b98db424
--- /dev/null
+++ b/private/tapi/dev/post14/explib.14/sources
@@ -0,0 +1,55 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tapi32l
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=LIBRARY
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib   \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib   \
+           $(BASEDIR)\public\sdk\lib\*\version.lib   \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=..\cpl;..\server;$(BASEDIR)\public\sdk\inc
+
+SOURCES=\
+        tapilib.c
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/post14/explib.14/tapilib.c b/private/tapi/dev/post14/explib.14/tapilib.c
new file mode 100644
index 000000000..d12908335
--- /dev/null
+++ b/private/tapi/dev/post14/explib.14/tapilib.c
@@ -0,0 +1,5633 @@
+#if DBG
+#define InternalDebugOut(_x_) DbgPrt _x_
+#else
+#define InternalDebugOut(_x_)
+#endif
+
+#define STRICT
+
+#include <windows.h>
+#include <windowsx.h>
+
+//#include "stdlib.h"
+#include "tapi.h"
+
+HINSTANCE ghTapi32 = NULL;
+DWORD     gdwDebugLevel = 0;
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    static BOOLEAN fBeenThereDoneThat = FALSE;
+
+    if ( !fBeenThereDoneThat )
+    {
+            HKEY  hKey;
+
+
+            gdwDebugLevel=0;
+
+            if (RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKey
+
+                    ) == ERROR_SUCCESS)
+            {
+                DWORD dwDataSize = sizeof(DWORD), dwDataType;
+
+                RegQueryValueEx(
+                    hKey,
+                    "Tapi32libDebugLevel",
+                    0,
+                    &dwDataType,
+                    (LPBYTE)&gdwDebugLevel,
+                    &dwDataSize
+                    );
+
+                RegCloseKey (hKey);
+            }
+    }
+
+
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[1280] = "TAPI32.LIB: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[12],
+                   lpszFormat,
+                   ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG PASCAL GetTheFunctionPtr( LPSTR lpszFunction, FARPROC *ppfn )
+{
+   InternalDebugOut((4, "Looking for: [%s]", lpszFunction));
+
+   if ( !ghTapi32 )
+   {
+      ghTapi32 = LoadLibrary("TAPI32.DLL");
+      
+      //
+      // If this failed, we won't try again
+      //
+      if ( 0 == ghTapi32 )
+      {
+         InternalDebugOut((1, "Can't LoadLibrary(""TAPI32.DLL"") !"));
+         ghTapi32 = (HINSTANCE)-1;
+      }
+   }
+
+
+   if ( ghTapi32 != (HINSTANCE)-1 )
+   {
+      *ppfn = GetProcAddress( ghTapi32, lpszFunction );
+   }
+   else
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+
+   if ( NULL == *ppfn )
+   {
+      InternalDebugOut((1, "Can't find function: [%s]", lpszFunction));
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return 0;
+}
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAccept(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAccept", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAddProvider(
+    LPCSTR              lpszProviderFilename,
+    HWND                hwndOwner,
+    LPDWORD             lpdwPermanentProviderID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAddProvider", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszProviderFilename,
+                   hwndOwner,
+                   lpdwPermanentProviderID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAddToConference(
+    HCALL               hConfCall,
+    HCALL               hConsultCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAddToConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hConfCall,
+                   hConsultCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAgentSpecific(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentExtensionIDIndex,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAgentSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwAgentExtensionIDIndex,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineAnswer(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineAnswer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineBlindTransfer(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineBlindTransfer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineClose(
+    HLINE               hLine
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineClose", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineCompleteCall(
+    HCALL               hCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineCompleteCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpdwCompletionID,
+                   dwCompletionMode,
+                   dwMessageID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineCompleteTransfer(
+    HCALL               hCall,
+    HCALL               hConsultCall,
+    LPHCALL             lphConfCall,
+    DWORD               dwTransferMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineCompleteTransfer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   hConsultCall,
+                   lphConfCall,
+                   dwTransferMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "//*************************************************************************", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigDialogEdit(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigDialogEdit", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass,
+                   lpDeviceConfigIn,
+                   dwSize,
+                   lpDeviceConfigOut
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineConfigProvider(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineConfigProvider", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hwndOwner,
+                   dwPermanentProviderID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDeallocateCall(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDeallocateCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDevSpecific(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDevSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDevSpecificFeature(
+    HLINE               hLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDevSpecificFeature", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwFeature,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDial(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDial", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineDrop(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineDrop", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineForward(
+    HLINE               hLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineForward", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   bAllAddresses,
+                   dwAddressID,
+                   lpForwardList,
+                   dwNumRingsNoAnswer,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGatherDigits(
+    HCALL               hCall,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGatherDigits", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitModes,
+                   lpsDigits,
+                   dwNumDigits,
+                   lpszTerminationDigits,
+                   dwFirstDigitTimeout,
+                   dwInterDigitTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGenerateDigits(
+    HCALL               hCall,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGenerateDigits", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitMode,
+                   lpszDigits,
+                   dwDuration
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGenerateTone(
+    HCALL               hCall,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGenerateTone", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwToneMode,
+                   dwDuration,
+                   dwNumTones,
+                   lpTones
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpAddressCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressID(
+    HLINE               hLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressID", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpdwAddressID,
+                   dwAddressMode,
+                   lpsAddress,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAddressStatus(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAddressStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAddressStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentActivityList(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTACTIVITYLIST lpAgentActivityList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentActivityList", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                       hLine,
+                       dwAddressID,
+                       lpAgentActivityList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwAppAPIVersion,
+    LPLINEAGENTCAPS     lpAgentCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAddressID,
+                   dwAppAPIVersion,
+                   lpAgentCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentGroupList(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentGroupList", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                       hLine,
+                       dwAddressID,
+                       lpAgentGroupList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAgentStatus(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPLINEAGENTSTATUS   lpAgentStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAgentStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAgentStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetAppPriority(
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPVARSTRING         lpExtensionName,
+    LPDWORD             lpdwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetAppPriority", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpExtensionName,
+                   lpdwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCallInfo(
+    HCALL               hCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCallInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCallStatus(
+    HCALL               hCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCallStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetConfRelatedCalls(
+    HCALL               hCall,
+    LPLINECALLLIST      lpCallList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetConfRelatedCalls", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallList
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetCountry(
+    DWORD               dwCountryID,
+    DWORD               dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetCountry", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwCountryID,
+                   dwAPIVersion,
+                   lpLineCountryList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpLineDevCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetDevConfig", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetNewCalls(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwSelect,
+    LPLINECALLLIST      lpCallList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetNewCalls", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwSelect,
+                   lpCallList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetIcon", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetID(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetID", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetLineDevStatus(
+    HLINE               hLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetLineDevStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpLineDevStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetMessage(
+    HLINEAPP        hLineApp,
+    LPLINEMESSAGE   lpMessage,
+    DWORD           dwTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetMessage", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   lpMessage,
+                   dwTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetNumRings(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPDWORD             lpdwNumRings
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetNumRings", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpdwNumRings
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetProviderList(
+    DWORD               dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetProviderList", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwAPIVersion,
+                   lpProviderList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetRequest(
+    HLINEAPP            hLineApp,
+    DWORD               dwRequestMode,
+    LPVOID              lpRequestBuffer
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetRequest", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwRequestMode,
+                   lpRequestBuffer
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetStatusMessages(
+    HLINE               hLine,
+    LPDWORD             lpdwLineStates,
+    LPDWORD             lpdwAddressStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpdwLineStates,
+                   lpdwAddressStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineGetTranslateCaps(
+    HLINEAPP hLineApp,
+    DWORD dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineGetTranslateCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwAPIVersion,
+                   lpTranslateCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineHandoff(
+    HCALL               hCall,
+    LPCSTR              lpszFileName,
+    DWORD               dwMediaMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineHandoff", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszFileName,
+                   dwMediaMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineHold(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineHold", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineInitialize(
+    LPHLINEAPP          lphLineApp,
+    HINSTANCE           hInstance,
+    LINECALLBACK        lpfnCallback,
+    LPCSTR              lpszAppName,
+    LPDWORD             lpdwNumDevs
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineInitialize", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphLineApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszAppName,
+                   lpdwNumDevs
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMakeCall(
+    HLINE               hLine,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMakeCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lphCall,
+                   lpszDestAddress,
+                   dwCountryCode,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMonitorDigits(
+    HCALL               hCall,
+    DWORD               dwDigitModes
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMonitorDigits", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwDigitModes
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMonitorMedia(
+    HCALL               hCall,
+    DWORD               dwMediaModes
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMonitorMedia", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwMediaModes
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineMonitorTones(
+    HCALL               hCall,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineMonitorTones", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpToneList,
+                   dwNumEntries
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineNegotiateAPIVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineNegotiateAPIVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPILowVersion,
+                   dwAPIHighVersion,
+                   lpdwAPIVersion,
+                   lpExtensionID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineNegotiateExtVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtLowVersion,
+    DWORD               dwExtHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineNegotiateExtVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtLowVersion,
+                   dwExtHighVersion,
+                   lpdwExtVersion
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineOpen(
+    HLINEAPP            hLineApp, 
+    DWORD               dwDeviceID,
+    LPHLINE             lphLine,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivileges,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineOpen", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp, 
+                   dwDeviceID,
+                   lphLine,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   dwCallbackInstance,
+                   dwPrivileges,
+                   dwMediaModes,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePark(
+    HCALL               hCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePark", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwParkMode,
+                   lpszDirAddress,
+                   lpNonDirAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePickup(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePickup", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress,
+                   lpszGroupID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+linePrepareAddToConference(
+    HCALL               hConfCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "linePrepareAddToConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hConfCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineProxyMessage(
+    HLINE               hLine,
+    HCALL               hCall,
+    DWORD               dwMsg,
+    DWORD               dwParam1,
+    DWORD               dwParam2,
+    DWORD               dwParam3
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineProxyMessage", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   hCall,
+                   dwMsg,
+                   dwParam1,
+                   dwParam2,
+                   dwParam3
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineProxyResponse(
+    HLINE               hLine,
+    LPLINEPROXYREQUEST  lpProxyRequest,
+    DWORD               dwResult
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineProxyResponse", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   lpProxyRequest,
+                   dwResult
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRedirect(
+    HCALL               hCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRedirect", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpszDestAddress,
+                   dwCountryCode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRegisterRequestRecipient(
+    HLINEAPP            hLineApp,
+    DWORD               dwRegistrationInstance,
+    DWORD               dwRequestMode,
+    DWORD               bEnable
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRegisterRequestRecipient", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwRegistrationInstance,
+                   dwRequestMode,
+                   bEnable
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineReleaseUserUserInfo(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineReleaseUserUserInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRemoveFromConference(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRemoveFromConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineRemoveProvider(
+    DWORD               dwPermanentProviderID,
+    HWND                hwndOwner
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineRemoveProvider", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwPermanentProviderID,
+                   hwndOwner
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSecureCall(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSecureCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSendUserUserInfo(
+    HCALL               hCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSendUserUserInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpsUserUserInfo,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAgentActivity(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwActivityID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAgentActivity", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwActivityID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAgentGroup(
+    HLINE                   hLine,
+    DWORD                   dwAddressID,
+    LPLINEAGENTGROUPLIST    lpAgentGroupList
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAgentGroup", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lpAgentGroupList
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAgentState(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwAgentState,
+    DWORD               dwNextAgentState
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAgentState", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwAgentState,
+                   dwNextAgentState
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAppPriority(
+    LPCSTR              lpszAppFilename,
+    DWORD               dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD               dwRequestMode,
+    LPCSTR              lpszExtensionName,
+    DWORD               dwPriority
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAppPriority", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszAppFilename,
+                   dwMediaMode,
+                   lpExtensionID,
+                   dwRequestMode,
+                   lpszExtensionName,
+                   dwPriority
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetAppSpecific(
+    HCALL               hCall,
+    DWORD               dwAppSpecific
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetAppSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwAppSpecific
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallData(
+    HCALL               hCall,
+    LPVOID              lpCallData,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallData", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpCallData,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallParams(
+    HCALL               hCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallParams", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwBearerMode,
+                   dwMinRate,
+                   dwMaxRate,
+                   lpDialParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallPrivilege(
+    HCALL               hCall,
+    DWORD               dwCallPrivilege
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallPrivilege", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwCallPrivilege
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallQualityOfService(
+    HCALL               hCall,
+    LPVOID              lpSendingFlowspec,
+    DWORD               dwSendingFlowspecSize,
+    LPVOID              lpReceivingFlowspec,
+    DWORD               dwReceivingFlowspecSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallQualityOfService", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lpSendingFlowspec,
+                   dwSendingFlowspecSize,
+                   lpReceivingFlowspec,
+                   dwReceivingFlowspecSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCallTreatment(
+    HCALL               hCall,
+    DWORD               dwTreatment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCallTreatment", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwTreatment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetCurrentLocation(
+    HLINEAPP            hLineApp,
+    DWORD               dwLocation
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetCurrentLocation", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwLocation
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetDevConfig", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpDeviceConfig,
+                   dwSize,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetLineDevStatus(
+    HLINE               hLine,
+    DWORD               dwStatusToChange,
+    DWORD               fStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetLineDevStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwStatusToChange,
+                   fStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetMediaControl(
+    HLINE                       hLine,
+    DWORD                       dwAddressID,
+    HCALL                       hCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList, 
+    DWORD                       dwCallStateNumEntries
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetMediaControl", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   lpDigitList,
+                   dwDigitNumEntries,
+                   lpMediaList,
+                   dwMediaNumEntries,
+                   lpToneList,
+                   dwToneNumEntries,
+                   lpCallStateList, 
+                   dwCallStateNumEntries
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetMediaMode(
+    HCALL               hCall,
+    DWORD               dwMediaModes
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetMediaMode", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   dwMediaModes
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetNumRings(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    DWORD               dwNumRings
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetNumRings", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   dwNumRings
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetStatusMessages(
+    HLINE               hLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwLineStates,
+                   dwAddressStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetTerminal(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    HCALL               hCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetTerminal", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   hCall,
+                   dwSelect,
+                   dwTerminalModes,
+                   dwTerminalID,
+                   bEnable
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetTollList(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    LPCSTR              lpszAddressIn,
+    DWORD               dwTollListOption
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetTollList", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   lpszAddressIn,
+                   dwTollListOption
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupConference(
+    HCALL               hCall,
+    HLINE               hLine,
+    LPHCALL             lphConfCall,
+    LPHCALL             lphConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupConference", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   hLine,
+                   lphConfCall,
+                   lphConsultCall,
+                   dwNumParties,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSetupTransfer(
+    HCALL               hCall,
+    LPHCALL             lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSetupTransfer", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall,
+                   lphConsultCall,
+                   lpCallParams
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineShutdown(
+    HLINEAPP            hLineApp
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineShutdown", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineSwapHold(
+    HCALL               hActiveCall,
+    HCALL               hHeldCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineSwapHold", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hActiveCall,
+                   hHeldCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateAddress(
+    HLINEAPP                hLineApp,
+    DWORD                   dwDeviceID,
+    DWORD                   dwAPIVersion,
+    LPCSTR                  lpszAddressIn,
+    DWORD                   dwCard,
+    DWORD                   dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateAddress", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   lpszAddressIn,
+                   dwCard,
+                   dwTranslateOptions,
+                   lpTranslateOutput
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineTranslateDialog(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    HWND                hwndOwner,
+    LPCSTR              lpszAddressIn
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineTranslateDialog", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLineApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   hwndOwner,
+                   lpszAddressIn
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUncompleteCall(
+    HLINE               hLine,
+    DWORD               dwCompletionID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUncompleteCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwCompletionID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUnhold(
+    HCALL               hCall
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUnhold", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hCall
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+lineUnpark(
+    HLINE               hLine,
+    DWORD               dwAddressID,
+    LPHCALL             lphCall,
+    LPCSTR              lpszDestAddress
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "lineUnpark", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hLine,
+                   dwAddressID,
+                   lphCall,
+                   lpszDestAddress
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneClose(
+    HPHONE              hPhone
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneClose", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneConfigDialog", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   hwndOwner,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneDevSpecific(
+    HPHONE              hPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneDevSpecific", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpParams,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetButtonInfo(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetButtonInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetData(
+    HPHONE              hPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetData", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwDataID,
+                   lpData,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetDevCaps(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetDevCaps", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   lpPhoneCaps
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetDisplay(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDisplay
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetDisplay", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpDisplay
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetGain(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetGain", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   lpdwGain
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetHookSwitch(
+    HPHONE              hPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetHookSwitch", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpdwHookSwitchDevs
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetIcon", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   dwDeviceID,
+                   lpszDeviceClass,
+                   lphIcon
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetID(
+    HPHONE              hPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetID", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpDeviceID,
+                   lpszDeviceClass
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetLamp(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetLamp", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpdwLampMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetMessage(
+    HPHONEAPP       hPhoneApp,
+    LPPHONEMESSAGE  lpMessage,
+    DWORD           dwTimeout
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetMessage", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   lpMessage,
+                   dwTimeout
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetRing(
+    HPHONE              hPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetRing", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpdwRingMode,
+                   lpdwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetStatus(
+    HPHONE              hPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetStatus", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpPhoneStatus
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetStatusMessages(
+    HPHONE              hPhone,
+    LPDWORD             lpdwPhoneStates,
+    LPDWORD             lpdwButtonModes,
+    LPDWORD             lpdwButtonStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   lpdwPhoneStates,
+                   lpdwButtonModes,
+                   lpdwButtonStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneGetVolume(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneGetVolume", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   lpdwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneInitialize(
+    LPHPHONEAPP         lphPhoneApp,
+    HINSTANCE           hInstance,
+    PHONECALLBACK       lpfnCallback,
+    LPCSTR              lpszAppName,
+    LPDWORD             lpdwNumDevs
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneInitialize", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lphPhoneApp,
+                   hInstance,
+                   lpfnCallback,
+                   lpszAppName,
+                   lpdwNumDevs
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneNegotiateAPIVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneNegotiateAPIVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPILowVersion,
+                   dwAPIHighVersion,
+                   lpdwAPIVersion,
+                   lpExtensionID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneNegotiateExtVersion(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtLowVersion,
+    DWORD               dwExtHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneNegotiateExtVersion", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   dwAPIVersion,
+                   dwExtLowVersion,
+                   dwExtHighVersion,
+                   lpdwExtVersion
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneOpen(
+    HPHONEAPP           hPhoneApp,
+    DWORD               dwDeviceID,
+    LPHPHONE            lphPhone,
+    DWORD               dwAPIVersion,
+    DWORD               dwExtVersion,
+    DWORD               dwCallbackInstance,
+    DWORD               dwPrivilege
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneOpen", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp,
+                   dwDeviceID,
+                   lphPhone,
+                   dwAPIVersion,
+                   dwExtVersion,
+                   dwCallbackInstance,
+                   dwPrivilege
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetButtonInfo(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetButtonInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   lpButtonInfo
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetData(
+    HPHONE              hPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetData", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwDataID,
+                   lpData,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetDisplay(
+    HPHONE              hPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCSTR              lpsDisplay,
+    DWORD               dwSize
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetDisplay", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwRow,
+                   dwColumn,
+                   lpsDisplay,
+                   dwSize
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetGain(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetGain", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   dwGain
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetHookSwitch(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetHookSwitch", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDevs,
+                   dwHookSwitchMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetLamp(
+    HPHONE              hPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetLamp", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwButtonLampID,
+                   dwLampMode
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetRing(
+    HPHONE              hPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetRing", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwRingMode,
+                   dwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetStatusMessages(
+    HPHONE              hPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetStatusMessages", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwPhoneStates,
+                   dwButtonModes,
+                   dwButtonStates
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneSetVolume(
+    HPHONE              hPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneSetVolume", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhone,
+                   dwHookSwitchDev,
+                   dwVolume
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+phoneShutdown(
+    HPHONEAPP           hPhoneApp
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "phoneShutdown", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hPhoneApp
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiGetLocationInfo(
+    LPSTR               lpszCountryCode,
+    LPSTR               lpszCityCode
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiGetLocationInfo", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszCountryCode,
+                   lpszCityCode
+                 );
+}
+    
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestDrop(
+    HWND                hwnd,
+    WPARAM              wRequestID
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestDrop", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hwnd,
+                   wRequestID
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMakeCall(
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMakeCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+LONG
+WINAPI
+tapiRequestMediaCall(
+    HWND                hwnd,
+    WPARAM              wRequestID,
+    LPCSTR              lpszDeviceClass,
+    LPCSTR              lpDeviceID,
+    DWORD               dwSize,
+    DWORD               dwSecure,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszAppName,
+    LPCSTR              lpszCalledParty,
+    LPCSTR              lpszComment
+    )
+{
+   static FARPROC lpfn = NULL;
+   LONG lResult;
+
+   if ( lpfn == NULL )
+   {
+      //
+      // Did we have a problem?
+      //
+      if ( 0 != (lResult = GetTheFunctionPtr( "tapiRequestMediaCall", &lpfn )) )
+      {
+         lpfn = (FARPROC)-1;
+         return lResult;
+      }
+   }
+
+   //
+   // Have we determined that this is a lost cause?
+   //
+   if ( (FARPROC)-1 == lpfn )
+   {
+      return LINEERR_OPERATIONUNAVAIL;
+   }
+
+   return (*lpfn)(
+                   hwnd,
+                   wRequestID,
+                   lpszDeviceClass,
+                   lpDeviceID,
+                   dwSize,
+                   dwSecure,
+                   lpszDestAddress,
+                   lpszAppName,
+                   lpszCalledParty,
+                   lpszComment
+                 );
+}
+
+//**************************************************************************
+//**************************************************************************
+//**************************************************************************
+
diff --git a/private/tapi/dev/post14/override/override.inf b/private/tapi/dev/post14/override/override.inf
new file mode 100644
index 000000000..8aec9b4ef
--- /dev/null
+++ b/private/tapi/dev/post14/override/override.inf
@@ -0,0 +1,144 @@
+; Override Inf File
+
+[version]
+signature="$CHICAGO$"
+SetupClass=Base
+LayoutFile=layout.inf
+
+[BaseWinOptions]
+Register_Override
+
+[Register_Override]
+CopyFiles  = Override.Copyfiles
+UpdateInis = CountryOverrides
+
+[DestinationDirs]
+Override.Copyfiles=17         ; goes to LDID_INF
+
+[Override.Copyfiles]
+override.inf
+
+;[DefaultInstall]
+;UpdateInis  = CountryOverrides
+
+;[TapiCountriesInstall]
+;UpdateInis  = CountryOverrides
+
+[CountryOverrides]
+telephon.ini,CountryOverrides,,"Country101=1,102,""%Anguilla%"",""G"","" 1FG"",""011EFG"""
+telephon.ini,CountryOverrides,,"Country103=1,104,""%Bahamas%"",""G"","" 1FG"",""011EFG"""
+telephon.ini,CountryOverrides,,"Country112=1,113,""%Jamaica%"",""G"","" 1FG"",""011EFG"""
+telephon.ini,CountryOverrides,,"Country213=213,216,""%Algeria%"",""G"",""0FG"",""00,EFG"""
+telephon.ini,CountryOverrides,,"Country231=231,232,""%Liberia%"",""G"","""",""0EFG"""
+telephon.ini,CountryOverrides,,"Country244=244,245,""%Angola%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country251=251,252,""%Ethiopia%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country252=252,253,""%Somalia%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country254=254,255,""%Kenya%"",""G"",""0FG"",""000EFG"""
+telephon.ini,CountryOverrides,,"Country256=256,257,""%Uganda%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country260=260,261,""%Zambia%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country34=34,350,""%Spain%"",""G"",""9FG"",""07,EFG"""
+telephon.ini,CountryOverrides,,"Country358=358,359,""%Finland%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country36=36,370,""%Hungary%"",""G"","" 06,FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country370=370,371,""%Lithuania%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country372=372,373,""%Estonia%"",""G"","" 8,2FG"",""8,00EFG"""
+telephon.ini,CountryOverrides,,"Country373=373,374,""%Moldova%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country375=375,376,""%Belarus%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country380=380,381,""%Ukraine%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country47=47,48,""%Norway%"",""G"","""",""00EFG"""
+telephon.ini,CountryOverrides,,"Country508=508,509,""%St_Pierre_and_Miquelon%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country509=509,51,""%Haiti%"",""G"","""",""00EFG"""
+telephon.ini,CountryOverrides,,"Country53=53,5399,""%Cuba%"",""G"",""0FG"",""119EFG"""
+telephon.ini,CountryOverrides,,"Country57=57,58,""%Colombia%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country590=590,5901,""%Guadeloupe%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country5901=590,591,""%French_Antilles%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country592=592,593,""%Guyana%"",""G"",""0FG"",""001EFG"""
+telephon.ini,CountryOverrides,,"Country594=594,595,""%French_Guiana%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country596=596,597,""%Martinique%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country65=65,66,""%Singapore%"",""G"","""",""001EFG"""
+telephon.ini,CountryOverrides,,"Country681=681,682,""%Wallis_and_Futuna_Islands%"",""G"","""",""19,EFG"""
+telephon.ini,CountryOverrides,,"Country686=686,687,""%Kiribati_Republic%"",""G"","""",""00EFG"""
+telephon.ini,CountryOverrides,,"Country691=691,692,""%Micronesia_Federated_States_of%"",""G"","""",""011EFG"""
+telephon.ini,CountryOverrides,,"Country7=7,705,""%Russia%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country705=7,706,""%Kazakhstan%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country706=7,708,""%Kyrgyz_Republic%"",""G"","" 8WFG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country708=7,709,""%Tajikistan%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country709=7,711,""%Turkmenistan%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country711=7,800,""%Uzbekistan%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country800=800,81,""%International_Freephone_Service%"","""","""","""""
+telephon.ini,CountryOverrides,,"Country82=82,84,""%Korea_Republic_of%"",""G"",""0FG"",""001EFG"""
+telephon.ini,CountryOverrides,,"Country853=853,855,""%Macau%"",""G"","""",""00EFG"""
+telephon.ini,CountryOverrides,,"Country86=86,870,""%China%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country870=870,871,""%INMARSAT%"",""00EFG#"",""00EFG#"",""00EFG#"""
+telephon.ini,CountryOverrides,,"Country871=871,872,""%INMARSAT_Atlantic_East%"",""00EFG#"",""00EFG#"",""00EFG#"""
+telephon.ini,CountryOverrides,,"Country872=872,873,""%INMARSAT_Pacific%"", ""00EFG#"",""00EFG#"",""00EFG#"""
+telephon.ini,CountryOverrides,,"Country873=873,874,""%INMARSAT_Indian%"", ""00EFG#"",""00EFG#"",""00EFG#"""
+telephon.ini,CountryOverrides,,"Country874=874,880,""%INMARSAT_Atlantic_West%"",""00EFG#"",""00EFG#"",""00EFG#"""
+telephon.ini,CountryOverrides,,"Country961=961,962,""%Lebanon%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country963=963,964,""%Syria%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country967=967,968,""%Yemen%"",""G"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country994=994,995,""%Azerbaijan%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country995=995,0,""%Georgia%"",""G"","" 8WFG"",""8W10EFG"""
+telephon.ini,CountryOverrides,,"Country33=33,34,""%France%"",""0FG"",""0FG"",""00EFG"""
+telephon.ini,CountryOverrides,,"Country376=376,377,""Andorra"",""G"","""",""00EFG"""
+telephon.ini,CountryOverrides,,"Country377=377,378,""%Monaco%"",""G"","""",""00EFG"""
+
+
+[Strings]
+Anguilla="Anguilla"
+Bahamas="Bahamas"
+Jamaica="Jamaica"
+Algeria="Algeria"
+Liberia="Liberia"
+Angola="Angola"
+Ethiopia="Ethiopia"
+Somalia="Somalia"
+Kenya="Kenya"
+Uganda="Uganda"
+Zambia="Zambia"
+France="France"
+Monaco="Monaco"
+Spain="Spain"
+Hungary="Hungary"
+Estonia="Estonia"
+Norway="Norway"
+St_Pierre_and_Miquelon="St. Pierre and Miquelon"
+Haiti="Haiti"
+Cuba="Cuba"
+Guadeloupe="Guadeloupe"
+French_Antilles="French Antilles"
+Guyana="Guyana"
+French_Guiana="French Guiana"
+Martinique="Martinique"
+Singapore="Singapore"
+Wallis_and_Futuna_Islands="Wallis and Futuna Islands"
+Kiribati_Republic="Kiribati Republic"
+Micronesia_Federated_States_of="Micronesia, Federated States of"
+International_Freephone_Service="International Freephone Service"
+Korea_Republic_of="Korea (Republic of)"
+Macau="Macau"
+China="China"
+INMARSAT="INMARSAT"
+INMARSAT_Atlantic_East="INMARSAT (Atlantic-East)"
+INMARSAT_Pacific="INMARSAT (Pacific)"
+INMARSAT_Indian="INMARSAT (Indian)"
+INMARSAT_Atlantic_West="INMARSAT (Atlantic-West)"
+Lebanon="Lebanon"
+Syria="Syria"
+Yemen="Yemen"
+Lithuania="Lithuania"
+Moldova="Moldova"
+Belarus="Belarus"
+Ukraine="Ukraine"
+Russia="Russia"
+Kyrgyz_Republic="Kyrgyz Republic"
+Kazakhstan="Kazakhstan"
+Kyrgyzstan="Kyrgyzstan"
+Tajikistan="Tajikistan"
+Turkmenistan="Turkmenistan"
+Uzbekistan="Uzbekistan"
+Azerbaijan="Azerbaijan"
+Georgia="Georgia"
+Colombia="Colombia"
+Finland="Finland"
+Andorra="Andorra"
+
diff --git a/private/tapi/dev/rmotsp.acf b/private/tapi/dev/rmotsp.acf
new file mode 100644
index 000000000..f945cdef3
--- /dev/null
+++ b/private/tapi/dev/rmotsp.acf
@@ -0,0 +1,5 @@
+[implicit_handle(handle_t hRemoteSP)]
+interface remotesp
+{
+
+}
diff --git a/private/tapi/dev/rmotsp.idl b/private/tapi/dev/rmotsp.idl
new file mode 100644
index 000000000..40b8a4099
--- /dev/null
+++ b/private/tapi/dev/rmotsp.idl
@@ -0,0 +1,31 @@
+[ uuid(2F5F6521-CA47-1068-B319-00DD010662DB),
+  version(1.0),
+#ifdef __midl
+        ms_union,
+#endif // __midl
+  pointer_default(unique)
+]
+
+interface remotesp
+
+{
+
+typedef [context_handle] void * PCONTEXT_HANDLE_TYPE2;
+
+long
+RemoteSPAttach(
+    [out]   PCONTEXT_HANDLE_TYPE2 *pphContext
+    );
+
+void
+RemoteSPEventProc(
+    [in] PCONTEXT_HANDLE_TYPE2 phContext,
+    [in, length_is(lSize), size_is(lSize)] char pBuffer[],
+    [in]        long    lSize
+    );
+
+void
+RemoteSPDetach(
+    [in, out]   PCONTEXT_HANDLE_TYPE2 *pphContext
+    );
+}
diff --git a/private/tapi/dev/server/country.rc b/private/tapi/dev/server/country.rc
new file mode 100644
index 000000000..c023a1087
--- /dev/null
+++ b/private/tapi/dev/server/country.rc
@@ -0,0 +1,252 @@
+//
+// (c) 1995 Microsoft Corporation.  Portions Copyright Intel/Microsoft 1992-93.  All Rights Reserved."
+//
+
+STRINGTABLE DISCARDABLE
+BEGIN
+
+RC_COUNTRY_ID_BASE + 1  "1,101,""United States of America"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 101 "1,102,""Anguilla"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 102 "1,103,""Antigua"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 103 "1,104,""Bahamas"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 104 "1,105,""Barbados"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 105 "1,106,""Bermuda"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 106 "1,107,""British Virgin Islands"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 107 "1,108,""Canada"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 108 "1,109,""Cayman Islands"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 109 "1,110,""Dominica"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 110 "1,111,""Dominican Republic"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 111 "1,112,""Grenada"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 112 "1,113,""Jamaica"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 113 "1,114,""Montserrat"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 114 "1,115,""Nevis"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 115 "1,116,""St. Kitts"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 116 "1,117,""St. Vincent and the Grenadines"",""G"","" 1FG"",""0EFG"""
+RC_COUNTRY_ID_BASE + 117 "1,118,""Trinidad and Tobago"",""G"","" 1FG"",""01EFG"""
+RC_COUNTRY_ID_BASE + 118 "1,120,""Turks and Caicos Islands"",""G"","" 1FG"",""0EFG"""
+RC_COUNTRY_ID_BASE + 120 "1,121,""Barbuda"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 121 "1,122,""Puerto Rico"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 122 "1,123,""Saint Lucia"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 123 "1,20,""United States Virgin Islands"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE +  20 "20,212,""Egypt"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 212 "212,213,""Morocco"",""G"",""0IG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 213 "213,216,""Algeria"",""G"",""0FG"",""00,EFG"""
+RC_COUNTRY_ID_BASE + 216 "216,218,""Tunisia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 218 "218,220,""Libya"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 220 "220,221,""Gambia"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 221 "221,222,""Senegal Republic"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 222 "222,223,""Mauritania"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 223 "223,224,""Mali"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 224 "224,225,""Guinea"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 225 "225,226,""Ivory Coast"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 226 "226,227,""Burkina Faso"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 227 "227,228,""Niger"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 228 "228,229,""Togo"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 229 "229,230,""Benin"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 230 "230,231,""Mauritius"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 231 "231,232,""Liberia"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 232 "232,233,""Sierra Leone"",""G"",""IG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 233 "233,234,""Ghana"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 234 "234,235,""Nigeria"",""G"","""",""009EFG"""
+RC_COUNTRY_ID_BASE + 235 "235,236,""Chad"",""G"","""",""15EFG"""
+RC_COUNTRY_ID_BASE + 236 "236,237,""Central African Republic"",""G"","""",""19EFG"""
+RC_COUNTRY_ID_BASE + 237 "237,238,""Cameroon"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 238 "238,239,""Cape Verde Islands"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 239 "239,240,""Sao Tome and Principe"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 240 "240,241,""Equatorial Guinea"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 241 "241,242,""Gabon"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 242 "242,243,""Congo"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 243 "243,244,""Zaire"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 244 "244,245,""Angola"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 245 "245,246,""Guinea-Bissau"",""G"","""",""099EFG"""
+RC_COUNTRY_ID_BASE + 246 "246,247,""Diego Garcia"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 247 "247,248,""Ascension Island"",""G"","""",""01EFG"""
+RC_COUNTRY_ID_BASE + 248 "248,249,""Seychelle Islands"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 249 "249,250,""Sudan"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 250 "250,251,""Rwanda"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 251 "251,252,""Ethiopia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 252 "252,253,""Somalia"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 253 "253,254,""Djibouti"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 254 "254,255,""Kenya"",""G"",""0FG"",""000EFG"""
+RC_COUNTRY_ID_BASE + 255 "255,256,""Tanzania"",""G"","""",""0900EFG"""
+RC_COUNTRY_ID_BASE + 256 "256,257,""Uganda"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 257 "257,258,""Burundi"",""G"","""",""90EFG"""
+RC_COUNTRY_ID_BASE + 258 "258,260,""Mozambique"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 260 "260,261,""Zambia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 261 "261,262,""Madagascar"",""G"","""",""16EFG"""
+RC_COUNTRY_ID_BASE + 262 "262,263,""Reunion Island"",""G"","""",""19EFG"""
+RC_COUNTRY_ID_BASE + 263 "263,264,""Zimbabwe"",""G"",""1FG"",""110EFG"""
+RC_COUNTRY_ID_BASE + 264 "264,265,""Namibia"",""G"",""0FG"",""09EFG"""
+RC_COUNTRY_ID_BASE + 265 "265,266,""Malawi"",""G"","""",""101EFG"""
+RC_COUNTRY_ID_BASE + 266 "266,267,""Lesotho"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 267 "267,268,""Botswana"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 268 "268,269,""Swaziland"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 269 "269,2691,""Mayotte Island"",""G"","""",""10EFG"""
+RC_COUNTRY_ID_BASE + 2691 "269,27,""Comoros"",""G"","""",""10EFG"""
+RC_COUNTRY_ID_BASE + 27 "27,290,""South Africa"",""G"",""0FG"",""09EFG"""
+RC_COUNTRY_ID_BASE + 290 "290,291,""St. Helena"",""G"","""",""01EFG"""
+RC_COUNTRY_ID_BASE + 291 "291,297,""Eritrea"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 297 "297,298,""Aruba"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 298 "298,299,""Faeroe Islands"",""G"","""",""009EFG"""
+RC_COUNTRY_ID_BASE + 299 "299,30,""Greenland"",""G"","""",""009EFG"""
+RC_COUNTRY_ID_BASE + 30 "30,31,""Greece"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 31 "31,32,""Netherlands"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 32 "32,33,""Belgium"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 33 "33,34,""France"",""0FG"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 34 "34,350,""Spain"",""G"",""9FG"",""07,EFG"""
+RC_COUNTRY_ID_BASE + 350 "350,351,""Gibraltar"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 351 "351,352,""Portugal"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 352 "352,353,""Luxembourg"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 353 "353,354,""Ireland"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 354 "354,355,""Iceland"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 355 "355,356,""Albania"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 356 "356,357,""Malta"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 357 "357,358,""Cyprus"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 358 "358,359,""Finland"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 359 "359,36,""Bulgaria"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 36 "36,370,""Hungary"",""G"","" 06,FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 370 "370,371,""Lithuania"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 371 "371,372,""Latvia"",""G"","" 8,IG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 372 "372,373,""Estonia"",""G"","" 8,2FG"",""8,00EFG"""
+RC_COUNTRY_ID_BASE + 373 "373,374,""Moldova"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 374 "374,375,""Armenia"",""G"","" 8,FG"",""8,10EFG"""
+RC_COUNTRY_ID_BASE + 375 "375,376,""Belarus"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 376 "376,377,""Andorra"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 377 "377,378,""Monaco"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 378 "378,379,""San Marino"",""G"",""0IG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 379 "39,380,""Vatican City"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 380 "380,381,""Ukraine"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 381 "381,385,""Yugoslavia"",""G"",""0FG"",""99EFG"""
+RC_COUNTRY_ID_BASE + 385 "385,386,""Croatia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 386 "386,387,""Slovenia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 387 "387,389,""Bosnia and Herzegovina"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 389 "389,39,""F.Y.R.O.M. (Former Yugoslav Republic of Macedonia)"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 39 "39,40,""Italy"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 40 "40,41,""Romania"",""G"","" 0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 41 "41,4101,""Switzerland"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 4101 "41,42,""Liechtenstein"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 42 "42,4201,""Czech Republic"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 4201 "42,43,""Slovak Republic"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 43 "43,44,""Austria"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 44 "44,45,""United Kingdom"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 45 "45,46,""Denmark"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 46 "46,47,""Sweden"",""G"",""0FG"",""009EFG"""
+RC_COUNTRY_ID_BASE + 47 "47,48,""Norway"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 48 "48,49,""Poland"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 49 "49,500,""Germany"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 500 "500,501,""Falkland Islands"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 501 "501,502,""Belize"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 502 "502,503,""Guatemala"",""G"",""0IG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 503 "503,504,""El Salvador"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 504 "504,505,""Honduras"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 505 "505,506,""Nicaragua"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 506 "506,507,""Costa Rica"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 507 "507,508,""Panama"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 508 "508,509,""St. Pierre and Miquelon"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 509 "509,51,""Haiti"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 51 "51,52,""Peru"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 52 "52,53,""Mexico"",""G"","" 91FG"",""98EFG"""
+RC_COUNTRY_ID_BASE + 53 "53,5399,""Cuba"",""G"",""0FG"",""119EFG"""
+RC_COUNTRY_ID_BASE + 5399 "53,54,""Guantanamo Bay"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 54 "54,55,""Argentina"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 55 "55,56,""Brazil"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 56 "56,57,""Chile"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 57 "57,58,""Colombia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 58 "58,590,""Venezuela"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 590 "590,5901,""Guadeloupe"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 5901 "590,591,""French Antilles"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 591 "591,592,""Bolivia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 592 "592,593,""Guyana"",""G"",""0FG"",""001EFG"""
+RC_COUNTRY_ID_BASE + 593 "593,594,""Ecuador"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 594 "594,595,""French Guiana"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 595 "595,596,""Paraguay"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 596 "596,597,""Martinique"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 597 "597,598,""Suriname"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 598 "598,599,""Uruguay"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 599 "599,60,""Netherlands Antilles"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 60 "60,61,""Malaysia"",""G"",""0FG"",""007EFG"""
+RC_COUNTRY_ID_BASE + 61 "61,6101,""Australia"",""G"","" 0FG"",""0011EFG"""
+RC_COUNTRY_ID_BASE + 6101 "61,62,""Cocos-Keeling Islands"",""G"","" 0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 62 "62,63,""Indonesia"",""G"",""0FG"",""001EFG"""
+RC_COUNTRY_ID_BASE + 63 "63,64,""Philippines"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 64 "64,65,""New Zealand"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 65 "65,66,""Singapore"",""G"","""",""001EFG"""
+RC_COUNTRY_ID_BASE + 66 "66,670,""Thailand"",""G"",""0FG"",""001EFG"""
+RC_COUNTRY_ID_BASE + 670 "670,6701,""Saipan Island"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 6701 "670,6702,""Rota Island"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 6702 "670,671,""Tinian Island"",""G"","" 1FG"",""011EFG"""
+RC_COUNTRY_ID_BASE + 671 "671,672,""Guam"",""G"","""",""011EFG"""
+RC_COUNTRY_ID_BASE + 672 "672,6721,""Christmas Island"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 6721 "672,6722,""Australian Antarctic Territory"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 6722 "672,673,""Norfolk Island"",""G"","""",""0101EFG"""
+RC_COUNTRY_ID_BASE + 673 "673,674,""Brunei"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 674 "674,675,""Nauru"",""G"","""",""115EFG"""
+RC_COUNTRY_ID_BASE + 675 "675,676,""Papua New Guinea"",""G"","""",""05EFG"""
+RC_COUNTRY_ID_BASE + 676 "676,677,""Tonga"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 677 "677,678,""Solomon Islands"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 678 "678,679,""Vanuatu"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 679 "679,680,""Fiji Islands"",""G"","""",""05EFG"""
+RC_COUNTRY_ID_BASE + 680 "680,681,""Palau"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 681 "681,682,""Wallis and Futuna Islands"",""G"","""",""19,EFG"""
+RC_COUNTRY_ID_BASE + 682 "682,683,""Cook Islands"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 683 "683,684,""Niue"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 684 "684,685,""American Samoa"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 685 "685,686,""Western Samoa"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 686 "686,687,""Kiribati Republic"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 687 "687,688,""New Caledonia"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 688 "688,689,""Tuvalu"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 689 "689,690,""French Polynesia"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 690 "690,691,""Tokelau"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 691 "691,692,""Micronesia, Federated States of"",""G"","""",""011EFG"""
+RC_COUNTRY_ID_BASE + 692 "692,7,""Marshall Islands"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 7 "7,705,""Russia"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 705 "7,706,""Kazakhstan"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 706 "7,708,""Kyrgyz Republic"",""G"","" 8WFG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 708 "7,709,""Tajikistan"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 709 "7,711,""Turkmenistan"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 711 "7,800,""Uzbekistan"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 800 "800,81,""International Freephone Service"","""","""","""""
+RC_COUNTRY_ID_BASE + 81 "81,82,""Japan"",""G"",""0FG"",""001EFG"""
+RC_COUNTRY_ID_BASE + 82 "82,84,""Korea (Republic of)"",""G"",""0FG"",""001EFG"""
+RC_COUNTRY_ID_BASE + 84 "84,850,""Vietnam"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 850 "850,852,""Korea (North)"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 852 "852,853,""Hong Kong"",""G"","""",""001EFG"""
+RC_COUNTRY_ID_BASE + 853 "853,855,""Macau"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 855 "855,856,""Cambodia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 856 "856,86,""Laos"",""G"","""",""14EFG"""
+RC_COUNTRY_ID_BASE + 86 "86,870,""China"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 870 "870,871,""INMARSAT"",""00EFG#"",""00EFG#"",""00EFG#"""
+RC_COUNTRY_ID_BASE + 871 "871,872,""INMARSAT (Atlantic-East)"",""00EFG#"",""00EFG#"",""00EFG#"""
+RC_COUNTRY_ID_BASE + 872 "872,873,""INMARSAT (Pacific)"",""00EFG#"",""00EFG#"",""00EFG#"""
+RC_COUNTRY_ID_BASE + 873 "873,874,""INMARSAT (Indian)"",""00EFG#"",""00EFG#"",""00EFG#"""
+RC_COUNTRY_ID_BASE + 874 "874,880,""INMARSAT (Atlantic-West)"",""00EFG#"",""00EFG#"",""00EFG#"""
+RC_COUNTRY_ID_BASE + 880 "880,886,""Bangladesh"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 886 "886,90,""Taiwan, Republic of China"",""G"",""0FG"",""002EFG"""
+RC_COUNTRY_ID_BASE + 90 "90,91,""Turkey"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 91 "91,92,""India"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 92 "92,93,""Pakistan"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 93 "93,94,""Afghanistan"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 94 "94,95,""Sri Lanka"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 95 "95,960,""Myanmar"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 960 "960,961,""Maldives"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 961 "961,962,""Lebanon"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 962 "962,963,""Jordan"",""G"",""FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 963 "963,964,""Syria"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 964 "964,965,""Iraq"",""G"",""FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 965 "965,966,""Kuwait"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 966 "966,967,""Saudi Arabia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 967 "967,968,""Yemen"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 968 "968,971,""Oman"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 971 "971,972,""United Arab Emirates"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 972 "972,973,""Israel"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 973 "973,974,""Bahrain"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 974 "974,975,""Qatar"",""G"","""",""0EFG"""
+RC_COUNTRY_ID_BASE + 975 "975,976,""Bhutan"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE + 976 "976,977,""Mongolia"",""G"",""0FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 977 "977,98,""Nepal"",""G"","""",""00EFG"""
+RC_COUNTRY_ID_BASE +  98 "98,994,""Iran"",""G"",""FG"",""00EFG"""
+RC_COUNTRY_ID_BASE + 994 "994,995,""Azerbaijan"",""G"","" 8WFG"",""8W10EFG"""
+RC_COUNTRY_ID_BASE + 995 "995,0,""Georgia"",""G"","" 8WFG"",""8W10EFG"""
+
+END
+
diff --git a/private/tapi/dev/server/depend.mk b/private/tapi/dev/server/depend.mk
new file mode 100644
index 000000000..5809d7308
--- /dev/null
+++ b/private/tapi/dev/server/depend.mk
@@ -0,0 +1,19 @@
+
+.\server.obj: ..\server.c ..\server.h
+
+.\line.obj: ..\line.c ..\line.h
+
+.\phone.obj: ..\phone.c ..\phone.h
+
+.\dial.obj: ..\dial.c ..\line.h ..\..\client\client.h
+
+.\provider.obj: ..\provider.c
+
+.\tapsrv_s.obj: ..\tapsrv_s.c
+
+.\tapi.obj: ..\tapi.c
+
+.\server.res: ..\server.rc ..\dial.rc ..\country.rc
+
+.\rmotsp_c.obj: ..\rmotsp_c.c ..\rmotsp.h
+
diff --git a/private/tapi/dev/server/dial.c b/private/tapi/dev/server/dial.c
new file mode 100644
index 000000000..2ef07d025
--- /dev/null
+++ b/private/tapi/dev/server/dial.c
@@ -0,0 +1,60 @@
+#include "windows.h"
+#include "prsht.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "resource.h"
+#include "..\client\client.h"
+#include "server.h"
+#include "line.h"
+
+
+
+// This code is in TAPI32.DLL
+//
+// //***************************************************************************
+// //***************************************************************************
+// void
+// WINAPI
+// LTranslateDialog(
+//     PLINETRANSLATEDIALOG_PARAMS pParams,
+//     LPBYTE                      pDataBuf,
+//     LPDWORD                     pdwNumBytesReturned
+//     )
+// {
+// }
+// 
+// 
+// This code is in TAPI32.DLL
+//
+// //***************************************************************************
+// //***************************************************************************
+// void
+// WINAPI
+// LGetTranslateCaps(
+//     PLINEGETTRANSLATECAPS_PARAMS    pParams,
+//     LPBYTE                          pDataBuf,
+//     LPDWORD                         pdwNumBytesReturned
+// 
+//     )
+// {
+// }
+// 
+// 
+// 
+// This code is in TAPI32.DLL
+//
+// //***************************************************************************
+// //***************************************************************************
+// //Get the current location
+// //xlate the number based on that
+// 
+// void
+// WINAPI
+// LTranslateAddress(
+//     PLINETRANSLATEADDRESS_PARAMS    pParams,
+//     LPBYTE                          pDataBuf,
+//     LPDWORD                         pdwNumBytesReturned
+//     )
+// {
+// }
diff --git a/private/tapi/dev/server/dial.rc b/private/tapi/dev/server/dial.rc
new file mode 100644
index 000000000..c914ed63d
--- /dev/null
+++ b/private/tapi/dev/server/dial.rc
@@ -0,0 +1,69 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_DIAL_ASST                   "Dialing Properties"
+END
+
+//
+// The following three messages are likely to be seen by developers only.
+// They occur at TAPI.DLL load time.
+//
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_PROVIDERERROR_NOT_AN_SP     "A module was found claiming to be a Telephony service provider that is not. It will not be used."
+    IDS_PROVIDERERROR_TOO_OLD       "An old Telephony service provider was detected. It will not be used."
+    IDS_PROVIDERERROR_FAILED_INIT   "A Telephony service provider was unable to start. It will not be used."
+END
+ 
+//
+// These strings are unlikely to be used in normal operation.
+//
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_ERR_APPLICATION             "Internal error.\nQuit and restart the program."
+    IDS_ERR_MEMORY                  "There is not enough memory to complete the operation.\nQuit some programs, and then try again."
+    IDS_ERR_READ_PRIV_INI           "Could not read the Telephony parameter file TELEPHON.INI.\nPlease check to make sure you have full access to this file."
+    IDS_ERR_WRITE_INI               "Cannot write to the Telephony parameter file TELEPHON.INI, so changes you have made will not be saved.\nPlease check to make sure you have full access to this file."
+    IDS_ERR_INVALID_INI             "The Telephony parameter file TELEPHON.INI is corrupt or missing.\nWould you like to reset to the default values?"
+    IDS_ERR_WRITE_WIN_INI           "Cannot write to the WIN.INI file, so changes you have made will not be saved.\nPlease check to make sure you have full access to the WIN.INI file."
+    IDS_ERR_INVALID_INI_LOCATIONS   "The stored location information may be corrupt.\nWould you like to reset to the default values?"
+    IDS_ERR_INVALID_INI_CARDS       "The stored calling card information may be corrupt.\nWould you like to reset to the default values?"
+    IDS_WRN_INVALID_LOCATION_CARD   "An inconsistency in the stored location information was found and has been fixed."
+    IDS_ERR_INVALID_TAPIADDR        "The file TAPIADDR.DLL is either an incorrect version or corrupt.\nPlease reinstall this file."
+    IDS_WRN_LOCATION_NAME_REQUIRED 
+			    	    "A valid location name is required for the current location."
+    IDS_WRN_CARD_NAME_REQUIRED 
+			    	    "A valid card name is required for the current card."
+    IDS_WRN_QUITING_WIZ            "If you do not enter proper values, your applications will not be able to dial calls properly. Are you sure you want to cancel?"
+
+    IDS_MSG_SIMPLEMSG_MDMINSTALLED  "Your modem has been installed.  Please enter the following so that your calls can be dialed correctly."
+END
+
+// 
+// These strings are likely to be used in normal operation.
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_ERR_ALREADY_IN_LIST         "The name you have entered matches another name already in use.\nPlease enter a unique name."
+    IDS_CARD_REMOVE_OR_STUPID       "Are you sure you want to remove the selected calling card?"
+    IDS_LOCATION_REMOVE_OR_STUPID   "Are you sure you want to remove the selected location?"
+    IDS_WRN_REMOVE_CARD             "A location uses this calling card; are you sure you want to remove it?"
+    IDS_WRN_AREA_CODE_REQUIRED      "Locations in the selected country must specify an area (city) code. Please enter one."
+    IDS_WRN_CARD_NUMBER_REQUIRED    "The calling card you have selected requires a card number to be entered."
+    IDS_WRN_INVALID_STR             "No special characters or quotes are allowed in the name.\nPlease enter a proper name."
+    IDS_WRN_INVALID_EX_NUM_STR      "Only the characters 0 thru 9, A thru H, P, T, W, #, *, !, ,, @, $ and ? are allowed.\nPlease enter a proper dialing rule."
+    IDS_WRN_INVALID_NUM             "Numbers must contain only digits from 0 through 9.\nPlease enter a proper number."
+    IDS_WRN_INVALID_NUM_STR         "Only the characters 0 thru 9, A thru D, P, T, W, #, *, !, ,, @, $ and ? are allowed.\nPlease enter a proper value."
+    IDS_WRN_TITLE_WARNING           "Warning"
+    IDS_WRN_TITLE_NAMEINUSE         "Name in Use"
+    IDS_WRN_TITLE_INVALCHAR         "Improper Character Entered"
+    IDS_WRN_TITLE_SURE              "Are You Sure?"
+    IDS_WRN_TITLE_REQUIRED          "Required Entry Not Made"
+
+    IDS_WRN_CANT_REMOVE_LAST_CARD   "The last calling card may not be removed."
+END
diff --git a/private/tapi/dev/server/line.c b/private/tapi/dev/server/line.c
new file mode 100644
index 000000000..8b6e76080
--- /dev/null
+++ b/private/tapi/dev/server/line.c
@@ -0,0 +1,21292 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    line.c
+
+Abstract:
+
+    Src module for tapi server line funcs
+
+Author:
+
+    Dan Knudson (DanKn)    01-Apr-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "assert.h"
+#include "prsht.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "..\client\client.h"
+#include "..\client\loc_comn.h"
+#include "server.h"
+#include "line.h"
+#include "resource.h"
+
+// PERF
+#include "..\perfdll\tapiperf.h"
+
+// PERF
+extern PERFBLOCK           PerfBlock;
+
+
+LPLINECOUNTRYLIST   gpCountryList = NULL;
+DWORD   gdwCallInstance = 1;
+
+extern TAPIGLOBALS TapiGlobals;
+extern CRITICAL_SECTION gSafeMutexCritSec,
+                        gRequestIDCritSec,
+                        gPriorityListCritSec;
+
+extern char gszProviders[];
+extern WCHAR gszProviderIDW[];
+//extern char gszTelephonIni[];
+extern char gszNumProviders[];
+extern char gszNextProviderID[];
+extern char gszProviderFilenameW[];
+extern char gszRegKeyTelephony[];
+
+const WCHAR gszLocationW[] = L"Location";
+const WCHAR gszLocationsW[] = L"Locations";
+
+extern char gszRegKeyProviders[];
+
+extern PTPROVIDER pRemoteSP;
+
+WCHAR gszNameW[]               = L"Name";
+WCHAR gszIDW[]                 = L"ID";
+WCHAR gszAreaCodeW[]           = L"AreaCode";
+WCHAR gszCountryW[]            = L"Country";
+WCHAR gszOutsideAccessW[]      = L"OutsideAccess";
+WCHAR gszLongDistanceAccessW[] = L"LongDistanceAccess";
+WCHAR gszFlagsW[]              = L"Flags";
+WCHAR gszCallingCardW[]        = L"CallingCard";
+WCHAR gszDisableCallWaitingW[] = L"DisableCallWaiting";
+WCHAR gszTollListW[]           = L"TollList";
+
+WCHAR gszNumEntriesW[]         = L"NumEntries";
+WCHAR gszCurrentIDW[]          = L"CurrentID";
+WCHAR gszNextIDW[]             = L"NextID";
+
+
+#if DBG
+extern DWORD   gdwDebugLevel;
+
+char *
+PASCAL
+MapResultCodeToText(
+    LONG    lResult,
+    char   *pszResult
+    );
+#endif
+
+void
+PASCAL
+DestroytCall(
+    PTCALL  ptCall
+    );
+
+void
+PASCAL
+DestroytCallClient(
+    PTCALLCLIENT    ptCallClient
+    );
+
+void
+PASCAL
+DestroytLineClient(
+    PTLINECLIENT    ptLineClient
+    );
+
+void
+LDevSpecific_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    );
+
+void
+LMakeCall_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    );
+
+void
+WINAPI
+FreeDialogInstance(
+    PFREEDIALOGINSTANCE_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    );
+
+void
+CALLBACK
+CompletionProcSP(
+    DWORD   dwRequestID,
+    LONG    lResult
+    );
+
+LONG
+PASCAL
+GetPhoneAppListFromClient(
+    PTCLIENT        ptClient,
+    PTPOINTERLIST  *ppList
+    );
+
+
+BOOL
+IsAPIVersionInRange(
+    DWORD   dwAPIVersion,
+    DWORD   dwSPIVersion
+    )
+{
+    if (dwAPIVersion <= dwSPIVersion)
+    {
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+        case TAPI_VERSION_CURRENT:
+
+            return TRUE;
+
+        default:
+
+            break;
+        }
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+InitTapiStruct(
+    LPVOID  pTapiStruct,
+    DWORD   dwTotalSize,
+    DWORD   dwFixedSize,
+    BOOL    bZeroInit
+    )
+{
+    //
+    // Verify there's space enough for fixed data
+    //
+
+    if (dwTotalSize < dwFixedSize)
+    {
+        return FALSE;
+    }
+
+
+    //
+    // Init the dwTotalSize as specified, then init the dwUsedSize and
+    // dwNeededSize fields as the fixed size of the structure (saves the
+    // SP some work if it's not planning on adding any of it's own
+    // varible-length data to the structure)
+    //
+
+    *((LPDWORD) pTapiStruct)       = dwTotalSize;
+
+    *(((LPDWORD) pTapiStruct) + 1) =
+    *(((LPDWORD) pTapiStruct) + 2) = dwFixedSize;
+
+
+    //
+    // Now zero out the rest of the buffer if the caller wants us to
+    //
+
+    if (bZeroInit)
+    {
+        ZeroMemory(
+            ((LPDWORD) pTapiStruct) + 3,
+            dwTotalSize - 3 * sizeof (DWORD)
+            );
+    }
+
+    return TRUE;
+}
+
+
+#if DBG
+BOOL
+IsBadSizeOffset(
+    DWORD dwTotalSize,
+    DWORD dwFixedSize,
+    DWORD dwXxxSize,
+    DWORD dwXxxOffset,
+    char *pszCallingFunc,
+    char *pszFieldName
+    )
+
+#else
+BOOL
+IsBadSizeOffset(
+    DWORD dwTotalSize,
+    DWORD dwFixedSize,
+    DWORD dwXxxSize,
+    DWORD dwXxxOffset
+    )
+
+#endif
+{
+    if (dwXxxSize != 0)
+    {
+        DWORD   dwSum = dwXxxSize + dwXxxOffset;
+
+
+        if (dwXxxOffset < dwFixedSize)
+        {
+            DBGOUT((
+                2,
+                "%s: dw%sOffset (=x%x) points at fixed portion (=x%x)" \
+                    " of structure",
+                pszCallingFunc,
+                pszFieldName,
+                dwXxxSize,
+                dwFixedSize
+                ));
+
+            return TRUE;
+        }
+        else if ((dwSum > dwTotalSize) || (dwSum < dwXxxSize))
+        {
+            DBGOUT((
+                2,
+                "%s: sum of dw%sSize/Offset (=x%x/x%x) > dwTotalSize (=x%x)",
+                pszCallingFunc,
+                pszFieldName,
+                dwXxxSize,
+                dwXxxOffset,
+                dwFixedSize,
+                dwTotalSize
+                ));
+
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+
+LONG
+PASCAL
+ValidateCallParams(
+    LPLINECALLPARAMS    pCallParamsApp,
+    LPLINECALLPARAMS   *ppCallParamsSP,
+    DWORD               dwAPIVersion,
+    DWORD               dwSPIVersion,
+    DWORD               dwAsciiCallParamsCodePage
+    )
+{
+    //
+    // This routine checks the fields in a LINECALLPARAMS struct,
+    // looking for invalid bit flags and making sure that the
+    // various size/offset pairs only reference data within the
+    // variable-data portion of the structure. Also, if the
+    // specified SPI version is greater than the API version and
+    // the fixed structure size differs between the two versions,
+    // a larger buffer is allocated, the var data is relocated,
+    // and the sizeof/offset pairs are patched.
+    //
+
+#if DBG
+    char    szFunc[] = "ValidateCallParams";
+#endif
+    DWORD   dwTotalSize = pCallParamsApp->dwTotalSize, dwFixedSizeApp,
+            dwFixedSizeSP, dwAllBearerModes, dwAllMediaModes;
+
+
+    switch (dwAPIVersion)
+    {
+    case TAPI_VERSION1_0:
+
+        dwFixedSizeApp   = 108; // 24 * sizeof (DWORD) + sizeof(LINEDIALPARAMS)
+        dwAllMediaModes  = AllMediaModes1_0;
+        dwAllBearerModes = AllBearerModes1_0;
+        break;
+
+    case TAPI_VERSION1_4:
+
+        dwFixedSizeApp   = 108; // 24 * sizeof (DWORD) + sizeof(LINEDIALPARAMS)
+        dwAllMediaModes  = AllMediaModes1_4;
+        dwAllBearerModes = AllBearerModes1_4;
+        break;
+
+    case TAPI_VERSION_CURRENT:
+
+        dwFixedSizeApp   = sizeof (LINECALLPARAMS);
+        dwAllMediaModes  = AllMediaModes1_4;
+        dwAllBearerModes = AllBearerModes2_0;
+        break;
+
+    default:
+
+        return LINEERR_OPERATIONFAILED;
+    }
+
+
+    switch (dwSPIVersion)
+    {
+    case TAPI_VERSION1_0:
+    case TAPI_VERSION1_4:
+
+        dwFixedSizeSP = 108;    // 24 * sizeof (DWORD) + sizeof(LINEDIALPARAMS)
+        break;
+
+    case TAPI_VERSION_CURRENT:
+
+        dwFixedSizeSP = sizeof (LINECALLPARAMS);
+        break;
+
+    default:
+
+        return LINEERR_OPERATIONFAILED;
+    }
+
+
+    if (dwTotalSize < dwFixedSizeApp)
+    {
+        DBGOUT((
+            3,
+            "%sbad dwTotalSize, x%x (minimum valid size=x%x)",
+            szFunc,
+            dwTotalSize,
+            dwFixedSizeApp
+            ));
+
+        return LINEERR_STRUCTURETOOSMALL;
+    }
+
+    if (
+        (pCallParamsApp->dwBearerMode) &&
+        (!IsOnlyOneBitSetInDWORD (pCallParamsApp->dwBearerMode) ||
+        (pCallParamsApp->dwBearerMode & ~dwAllBearerModes)))
+    {
+        //
+        // For clarity's sake reset 0 bearer mode to VOICE
+        //
+
+        if (pCallParamsApp->dwBearerMode == 0)
+        {
+            pCallParamsApp->dwBearerMode = LINEBEARERMODE_VOICE;
+        }
+        else
+        {
+            DBGOUT((
+                3,
+                "%sbad dwBearerMode, x%x",
+                szFunc,
+                pCallParamsApp->dwBearerMode
+                ));
+
+            return LINEERR_INVALBEARERMODE;
+        }
+    }
+
+    {
+        DWORD dwMediaModeApp = pCallParamsApp->dwMediaMode;
+
+
+        if ((dwMediaModeApp & (0x00ffffff ^ dwAllMediaModes)) ||
+
+            (!IsOnlyOneBitSetInDWORD (dwMediaModeApp) &&
+                !(dwMediaModeApp & LINEMEDIAMODE_UNKNOWN)))
+        {
+            //
+            // For clarity's sake reset 0 media mode to INTERACTIVEVOICE
+            //
+
+            if (dwMediaModeApp == 0)
+            {
+                pCallParamsApp->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+            }
+            else
+            {
+                DBGOUT((3, "%sbad dwMediaMode, x%x", szFunc, dwMediaModeApp));
+
+                return LINEERR_INVALMEDIAMODE;
+            }
+        }
+    }
+
+    if (pCallParamsApp->dwCallParamFlags & ~AllCallParamFlags)
+    {
+        DBGOUT((
+            3,
+            "%sbad dwCallParamFlags, x%x",
+            szFunc,
+            pCallParamsApp->dwCallParamFlags
+            ));
+
+        return LINEERR_INVALCALLPARAMS;
+    }
+
+    //
+    // Note: an address mode of 0 means "default to any address,
+    //       don't select a specific address" (says TNixon)
+    //
+
+    if (pCallParamsApp->dwAddressMode == LINEADDRESSMODE_ADDRESSID ||
+        pCallParamsApp->dwAddressMode == LINEADDRESSMODE_DIALABLEADDR)
+    {
+        // do nothing (it's a valid addr mode)
+    }
+    else if (pCallParamsApp->dwAddressMode == 0)
+    {
+        //
+        // For clarity's sake reset 0 addr mode to ADDRESSID
+        //
+
+        pCallParamsApp->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+    }
+    else
+    {
+        DBGOUT((
+            3,
+            "%sbad dwAddressMode, x%x",
+            szFunc,
+            pCallParamsApp->dwAddressMode
+            ));
+
+        return LINEERR_INVALADDRESSMODE;
+    }
+
+    if (ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwOrigAddressSize,
+            pCallParamsApp->dwOrigAddressOffset,
+            szFunc,
+            "OrigAddress"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwUserUserInfoSize,
+            pCallParamsApp->dwUserUserInfoOffset,
+            szFunc,
+            "UserUserInfo"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwHighLevelCompSize,
+            pCallParamsApp->dwHighLevelCompOffset,
+            szFunc,
+            "HighLevelComp"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwLowLevelCompSize,
+            pCallParamsApp->dwLowLevelCompOffset,
+            szFunc,
+            "LowLevelComp"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwDevSpecificSize,
+            pCallParamsApp->dwDevSpecificOffset,
+            szFunc,
+            "DevSpecificSize"
+            ))
+    {
+        return LINEERR_INVALCALLPARAMS;
+    }
+
+
+    //
+    // The following is an attempt to compensate for 1.x tapi apps
+    // that borrowed dialer.exe's source code and package their
+    // call params incorrectly.  The fix is to zero the offending
+    // dwXxxSize/Offset pair of the various information-only fields,
+    // so at worst some logging info will be lost, but the app will
+    // still be able to make calls.  (Failure to correctly package
+    // any of the above var-length fields is considered "fatal" in
+    // any case.)
+    //
+
+    if (ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwDisplayableAddressSize,
+            pCallParamsApp->dwDisplayableAddressOffset,
+            szFunc,
+            "DisplayableAddress"
+            ))
+    {
+        if (dwAPIVersion < TAPI_VERSION2_0)
+        {
+            pCallParamsApp->dwDisplayableAddressSize   =
+            pCallParamsApp->dwDisplayableAddressOffset = 0;
+        }
+        else
+        {
+            return LINEERR_INVALCALLPARAMS;
+        }
+    }
+
+    if (ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwCalledPartySize,
+            pCallParamsApp->dwCalledPartyOffset,
+            szFunc,
+            "CalledParty"
+            ))
+    {
+        if (dwAPIVersion < TAPI_VERSION2_0)
+        {
+            pCallParamsApp->dwCalledPartySize   =
+            pCallParamsApp->dwCalledPartyOffset = 0;
+        }
+        else
+        {
+            return LINEERR_INVALCALLPARAMS;
+        }
+    }
+
+    if (ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwCommentSize,
+            pCallParamsApp->dwCommentOffset,
+            szFunc,
+            "Comment"
+            ))
+    {
+        if (dwAPIVersion < TAPI_VERSION2_0)
+        {
+            pCallParamsApp->dwCommentSize   =
+            pCallParamsApp->dwCommentOffset = 0;
+        }
+        else
+        {
+            return LINEERR_INVALCALLPARAMS;
+        }
+    }
+
+
+    if (dwAPIVersion <= TAPI_VERSION1_4)
+    {
+        goto ValidateCallParams_checkFixedSizes;
+    }
+
+    #define AllCallStates                     \
+        (LINECALLSTATE_IDLE                 | \
+        LINECALLSTATE_OFFERING              | \
+        LINECALLSTATE_ACCEPTED              | \
+        LINECALLSTATE_DIALTONE              | \
+        LINECALLSTATE_DIALING               | \
+        LINECALLSTATE_RINGBACK              | \
+        LINECALLSTATE_BUSY                  | \
+        LINECALLSTATE_SPECIALINFO           | \
+        LINECALLSTATE_CONNECTED             | \
+        LINECALLSTATE_PROCEEDING            | \
+        LINECALLSTATE_ONHOLD                | \
+        LINECALLSTATE_CONFERENCED           | \
+        LINECALLSTATE_ONHOLDPENDCONF        | \
+        LINECALLSTATE_ONHOLDPENDTRANSFER    | \
+        LINECALLSTATE_DISCONNECTED          | \
+        LINECALLSTATE_UNKNOWN)
+
+    if (pCallParamsApp->dwPredictiveAutoTransferStates & ~AllCallStates)
+    {
+        DBGOUT((
+            3,
+            "%sbad dwPredictiveAutoTransferStates, x%x",
+            szFunc,
+            pCallParamsApp->dwPredictiveAutoTransferStates
+            ));
+
+        return LINEERR_INVALCALLPARAMS;
+    }
+
+    if (ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwTargetAddressSize,
+            pCallParamsApp->dwTargetAddressOffset,
+            szFunc,
+            "TargetAddress"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwSendingFlowspecSize,
+            pCallParamsApp->dwSendingFlowspecOffset,
+            szFunc,
+            "SendingFlowspec"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwReceivingFlowspecSize,
+            pCallParamsApp->dwReceivingFlowspecOffset,
+            szFunc,
+            "ReceivingFlowspec"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwDeviceClassSize,
+            pCallParamsApp->dwDeviceClassOffset,
+            szFunc,
+            "DeviceClass"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwDeviceConfigSize,
+            pCallParamsApp->dwDeviceConfigOffset,
+            szFunc,
+            "DeviceConfig"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwCallDataSize,
+            pCallParamsApp->dwCallDataOffset,
+            szFunc,
+            "CallData"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pCallParamsApp->dwCallingPartyIDSize,
+            pCallParamsApp->dwCallingPartyIDOffset,
+            szFunc,
+            "CallingPartyID"
+            ))
+    {
+        return LINEERR_INVALCALLPARAMS;
+    }
+
+ValidateCallParams_checkFixedSizes:
+
+    if (dwAsciiCallParamsCodePage == 0xffffffff)
+    {
+        //
+        // If here we're getting unicode call params from the app
+        //
+        // Check to see if the fixed size of the app's call params
+        // are smaller than the fixed size of the call params
+        // required by the service provider (due to it's negotiated
+        // SPI version), and if so alloc a larger buffer to account
+        // for this different fixed size & set it up correctly
+        //
+
+        if (dwFixedSizeApp < dwFixedSizeSP)
+        {
+            DWORD               dwFixedSizeDiff =
+                                    dwFixedSizeSP - dwFixedSizeApp;
+            LPLINECALLPARAMS    pCallParamsSP;
+
+
+            if (!(pCallParamsSP = ServerAlloc (dwTotalSize + dwFixedSizeDiff)))
+            {
+                return LINEERR_NOMEM;
+            }
+
+            CopyMemory (pCallParamsSP, pCallParamsApp, dwFixedSizeApp);
+
+            pCallParamsSP->dwTotalSize = dwTotalSize + dwFixedSizeDiff;
+
+            CopyMemory(
+                ((LPBYTE) pCallParamsSP) + dwFixedSizeSP,
+                ((LPBYTE) pCallParamsApp) + dwFixedSizeApp,
+                dwTotalSize - dwFixedSizeApp
+                );
+
+            pCallParamsSP->dwOrigAddressOffset        += dwFixedSizeDiff;
+            pCallParamsSP->dwDisplayableAddressOffset += dwFixedSizeDiff;
+            pCallParamsSP->dwCalledPartyOffset        += dwFixedSizeDiff;
+            pCallParamsSP->dwCommentOffset            += dwFixedSizeDiff;
+            pCallParamsSP->dwUserUserInfoOffset       += dwFixedSizeDiff;
+            pCallParamsSP->dwHighLevelCompOffset      += dwFixedSizeDiff;
+            pCallParamsSP->dwLowLevelCompOffset       += dwFixedSizeDiff;
+            pCallParamsSP->dwDevSpecificOffset        += dwFixedSizeDiff;
+
+            *ppCallParamsSP = pCallParamsSP;
+        }
+        else
+        {
+            *ppCallParamsSP = pCallParamsApp;
+        }
+    }
+    else // see if there's ascii var data fields to translate
+    {
+        //
+        // If here we're getting ascii call params form the app
+        //
+        // We may need to due ascii -> unicode conversions on some
+        // of the var fields, as well as account for differences
+        // in the fixed sizes of the call params structs as described
+        // above
+        //
+
+        DWORD   dwAsciiVarDataSize,
+                dwFixedSizeDiff = dwFixedSizeSP - dwFixedSizeApp;
+
+
+        dwAsciiVarDataSize =
+            pCallParamsApp->dwOrigAddressSize +
+            pCallParamsApp->dwDisplayableAddressSize +
+            pCallParamsApp->dwCalledPartySize +
+            pCallParamsApp->dwCommentSize;
+
+        if (dwAPIVersion > TAPI_VERSION1_4)
+        {
+            dwAsciiVarDataSize +=
+                pCallParamsApp->dwTargetAddressSize +
+                pCallParamsApp->dwDeviceClassSize +
+                pCallParamsApp->dwCallingPartyIDSize;
+        }
+
+        if (dwFixedSizeDiff != 0  ||  dwAsciiVarDataSize != 0)
+        {
+            LPLINECALLPARAMS    pCallParamsSP;
+
+
+            // alloc 3 extra for alignment
+            if (!(pCallParamsSP = ServerAlloc(
+                    dwTotalSize + dwFixedSizeDiff + 2 * dwAsciiVarDataSize + 3
+                    )))
+            {
+                return LINEERR_NOMEM;
+            }
+
+            if (dwFixedSizeDiff)
+            {
+                CopyMemory (pCallParamsSP, pCallParamsApp, dwFixedSizeApp);
+
+                CopyMemory(
+                    ((LPBYTE) pCallParamsSP) + dwFixedSizeSP,
+                    ((LPBYTE) pCallParamsApp) + dwFixedSizeApp,
+                    dwTotalSize - dwFixedSizeApp
+                    );
+
+                pCallParamsSP->dwUserUserInfoOffset  += dwFixedSizeDiff;
+                pCallParamsSP->dwHighLevelCompOffset += dwFixedSizeDiff;
+                pCallParamsSP->dwLowLevelCompOffset  += dwFixedSizeDiff;
+                pCallParamsSP->dwDevSpecificOffset   += dwFixedSizeDiff;
+            }
+            else
+            {
+                CopyMemory (pCallParamsSP, pCallParamsApp, dwTotalSize);
+            }
+
+            pCallParamsSP->dwTotalSize = dwTotalSize + dwFixedSizeDiff +
+                2*dwAsciiVarDataSize;
+
+            if (dwAsciiVarDataSize)
+            {
+                LPDWORD alpdwXxxSize[] =
+                {
+                    &pCallParamsSP->dwOrigAddressSize,
+                    &pCallParamsSP->dwDisplayableAddressSize,
+                    &pCallParamsSP->dwCalledPartySize,
+                    &pCallParamsSP->dwCommentSize,
+                    (dwAPIVersion > TAPI_VERSION1_4 ?
+                        &pCallParamsSP->dwTargetAddressSize : NULL),
+                    (dwAPIVersion > TAPI_VERSION1_4 ?
+                        &pCallParamsSP->dwDeviceClassSize : NULL),
+                    (dwAPIVersion > TAPI_VERSION1_4 ?
+                        &pCallParamsSP->dwCallingPartyIDSize : NULL),
+                    NULL
+                };
+
+                // align dwXxxOffset
+                DWORD   i, dwXxxOffset = (dwTotalSize + dwFixedSizeDiff + 3) &
+                                         0xFFFFFFFC;
+
+
+                for (i = 0; alpdwXxxSize[i]; i++)
+                {
+                    if (*alpdwXxxSize[i] != 0)
+                    {
+                        MultiByteToWideChar(
+                            (UINT) dwAsciiCallParamsCodePage,
+                            MB_PRECOMPOSED,
+                            (LPCSTR) (((LPBYTE) pCallParamsApp) +
+                                *(alpdwXxxSize[i] + 1)), // dwXxxOffset
+                            *alpdwXxxSize[i],
+                            (LPWSTR) (((LPBYTE) pCallParamsSP) + dwXxxOffset),
+                            *alpdwXxxSize[i] * 2
+                            );
+
+                        *(alpdwXxxSize[i] + 1) = dwXxxOffset;
+                        *alpdwXxxSize[i] *= 2;
+                        dwXxxOffset += *alpdwXxxSize[i];
+                    }
+                }
+            }
+
+            *ppCallParamsSP = pCallParamsSP;
+        }
+        else
+        {
+            *ppCallParamsSP = pCallParamsApp;
+        }
+    }
+
+    return 0; // success
+}
+
+
+void
+PASCAL
+InsertVarData(
+    LPVOID      lpXxx,
+    LPDWORD     pdwXxxSize,
+    LPVOID     *pData,
+    DWORD       dwDataSize
+    )
+{
+    DWORD       dwAlignedSize, dwUsedSize;
+    LPVARSTRING lpVarString = (LPVARSTRING) lpXxx;
+
+
+    if (dwDataSize != 0)
+    {
+        //
+        // Align var data on 64-bit boundaries
+        //
+
+        if ((dwAlignedSize = dwDataSize) & 7)
+        {
+            dwAlignedSize += 8;
+            dwAlignedSize &= 0xfffffff8;
+
+        }
+
+
+        //
+        // The following if statement should only be TRUE the first time
+        // we're inserting data into a given structure that does not have
+        // an even number of DWORD fields
+        //
+
+        if ((dwUsedSize = lpVarString->dwUsedSize) & 7)
+        {
+            dwUsedSize += 8;
+            dwUsedSize &= 0xfffffff8;
+
+            lpVarString->dwNeededSize += dwUsedSize - lpVarString->dwUsedSize;
+        }
+
+        lpVarString->dwNeededSize += dwAlignedSize;
+
+        if ((dwUsedSize + dwAlignedSize) <= lpVarString->dwTotalSize)
+        {
+            CopyMemory(
+                ((LPBYTE) lpVarString) + dwUsedSize,
+                pData,
+                dwDataSize
+                );
+
+            *pdwXxxSize = dwDataSize;
+            pdwXxxSize++;             // pdwXxxSize = pdwXxxOffset
+            *pdwXxxSize = dwUsedSize;
+
+            lpVarString->dwUsedSize = dwUsedSize + dwAlignedSize;
+        }
+
+    }
+}
+
+
+PTLINELOOKUPENTRY
+GetLineLookupEntry(
+    DWORD   dwDeviceID
+    )
+{
+    DWORD               dwDeviceIDBase = 0;
+    PTLINELOOKUPTABLE   pLookupTable = TapiGlobals.pLineLookup;
+
+
+    if (dwDeviceID >= TapiGlobals.dwNumLines)
+    {
+        return ((PTLINELOOKUPENTRY) NULL);
+    }
+
+    while (pLookupTable)
+    {
+        if (dwDeviceID < pLookupTable->dwNumTotalEntries)
+        {
+            return (pLookupTable->aEntries + dwDeviceID);
+        }
+
+        dwDeviceID -= pLookupTable->dwNumTotalEntries;
+
+        pLookupTable = pLookupTable->pNext;
+    }
+
+    return ((PTLINELOOKUPENTRY) NULL);
+}
+
+
+BOOL
+PASCAL
+IsValidLineExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwExtVersion
+    )
+{
+    BOOL                bResult;
+    PTLINE              ptLine;
+    PTPROVIDER          ptProvider;
+    PTLINELOOKUPENTRY   pLookupEntry;
+
+
+    if (dwExtVersion == 0)
+    {
+        return TRUE;
+    }
+
+    if (!(pLookupEntry = GetLineLookupEntry (dwDeviceID)))
+    {
+        return FALSE;
+    }
+
+    ptLine = pLookupEntry->ptLine;
+
+    if (ptLine)
+    {
+        try
+        {
+            if (ptLine->dwExtVersionCount)
+            {
+                bResult = (dwExtVersion == ptLine->dwExtVersion ?
+                    TRUE : FALSE);
+
+                if (ptLine->dwKey == TLINE_KEY)
+                {
+                    goto IsValidLineExtVersion_return;
+                }
+            }
+        }
+        myexcept
+        {
+            //
+            // if here the line was closed, just drop thru to the code below
+            //
+        }
+    }
+
+    ptProvider = pLookupEntry->ptProvider;
+
+    if (ptProvider->apfn[SP_LINENEGOTIATEEXTVERSION])
+    {
+        LONG    lResult;
+        DWORD   dwNegotiatedExtVersion;
+
+
+        lResult = CallSP5(
+            ptProvider->apfn[SP_LINENEGOTIATEEXTVERSION],
+            "lineNegotiateExtVersion",
+            SP_FUNC_SYNC,
+            (DWORD) dwDeviceID,
+            (DWORD) pLookupEntry->dwSPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) &dwNegotiatedExtVersion
+            );
+
+        bResult = ((lResult || !dwNegotiatedExtVersion) ? FALSE : TRUE);
+    }
+    else
+    {
+        bResult = FALSE;
+    }
+
+IsValidLineExtVersion_return:
+
+    return bResult;
+}
+
+
+PTCALL
+PASCAL
+IsValidtCall(
+    HTAPICALL   htCall
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (htCall, TCALL_KEY))
+        {
+            htCall = (HTAPICALL) 0;
+        }
+    }
+    myexcept
+    {
+        htCall = (HTAPICALL) 0;
+    }
+
+    return ((PTCALL) htCall);
+}
+
+
+PTCALLCLIENT
+PASCAL
+IsValidCall(
+    HCALL       hCall,
+    PTCLIENT    ptClient
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (hCall, TCALLCLIENT_KEY) ||
+            (*(((LPDWORD) hCall) + 1) != (DWORD) ptClient))
+        {
+            hCall = (HCALL) 0;
+        }
+    }
+    myexcept
+    {
+        hCall = (HCALL) 0;
+    }
+
+    return ((PTCALLCLIENT) hCall);
+}
+
+
+PTLINECLIENT
+PASCAL
+IsValidLine(
+    HLINE       hLine,
+    PTCLIENT    ptClient
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (hLine, TLINECLIENT_KEY) ||
+            (*(((LPDWORD) hLine) + 1) != (DWORD) ptClient))
+        {
+            hLine = (HLINE) 0;
+        }
+    }
+    myexcept
+    {
+        hLine = (HLINE) 0;
+    }
+
+    return ((PTLINECLIENT) hLine);
+}
+
+
+PTLINEAPP
+PASCAL
+IsValidLineApp(
+    HLINEAPP    hLineApp,
+    PTCLIENT    ptClient
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (hLineApp, TLINEAPP_KEY) ||
+            (*( ((LPDWORD) hLineApp) + 1) != (DWORD) ptClient))
+        {
+            hLineApp = (HLINEAPP) 0;
+        }
+    }
+    myexcept
+    {
+        hLineApp = (HLINEAPP) 0;
+    }
+
+    return ((PTLINEAPP) hLineApp);
+}
+
+
+PTCALL
+PASCAL
+WaitForExclusivetCallAccess(
+    HTAPICALL   htCall,
+    DWORD       dwKey,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    )
+{
+    try
+    {
+        if (!IsBadPtrKey (htCall, dwKey) &&
+
+            WaitForMutex(
+                ((PTCALL) htCall)->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) htCall,
+                dwKey,
+                dwTimeout
+                ))
+        {
+            if (((PTCALL) htCall)->dwKey == dwKey)
+            {
+                return ((PTCALL) htCall);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+PTLINE
+PASCAL
+WaitForExclusivetLineAccess(
+    HTAPILINE   htLine,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    )
+{
+    try
+    {
+        if (!IsBadPtrKey (htLine, TLINE_KEY) &&
+
+            WaitForMutex(
+                ((PTLINE) htLine)->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) htLine,
+                TLINE_KEY,
+                dwTimeout
+                ))
+        {
+            if (((PTLINE) htLine)->dwKey == TLINE_KEY)
+            {
+                return ((PTLINE) htLine);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+PTLINECLIENT
+PASCAL
+WaitForExclusiveLineClientAccess(
+    HLINE   hLine,
+    HANDLE *phMutex,
+    BOOL   *pbDupedMutex,
+    DWORD  dwTimeout
+    )
+{
+    try
+    {
+        if (WaitForMutex(
+                ((PTLINECLIENT) hLine)->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) hLine,
+                TLINECLIENT_KEY,
+                dwTimeout
+                ))
+        {
+            if (((PTLINECLIENT) hLine)->dwKey == TLINECLIENT_KEY)
+            {
+                return ((PTLINECLIENT) hLine);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+PTLINEAPP
+PASCAL
+WaitForExclusiveLineAppAccess(
+    HLINEAPP    hLineApp,
+    PTCLIENT    ptClient,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (hLineApp, TLINEAPP_KEY))
+        {
+            return NULL;
+        }
+
+        if (WaitForMutex(
+                ((PTLINEAPP) hLineApp)->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) hLineApp,
+                TLINEAPP_KEY,
+                dwTimeout
+                ))
+        {
+            if (((PTLINEAPP) hLineApp)->dwKey == TLINEAPP_KEY  &&
+                ((PTLINEAPP) hLineApp)->ptClient == ptClient)
+            {
+                return ((PTLINEAPP) hLineApp);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+PTCLIENT
+PASCAL
+WaitForExclusiveClientAccess(
+    PTCLIENT    ptClient,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    )
+{
+    try
+    {
+        if (WaitForMutex(
+                ptClient->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) ptClient,
+                TCLIENT_KEY,
+                dwTimeout
+                ))
+        {
+            if (ptClient->dwKey == TCLIENT_KEY)
+            {
+                return (ptClient);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+LONG
+PASCAL
+CreateProxyRequest(
+    PTLINECLIENT            pProxy,
+    DWORD                   dwRequestType,
+    DWORD                   dwExtraBytes,
+    PASYNCREQUESTINFO       pAsyncReqInfo,
+    PPROXYREQUESTWRAPPER   *ppWrapper
+    )
+{
+    DWORD                   dwSize, dwComputerNameSize, dwUserNameSize;
+    PTCLIENT                ptClient = pAsyncReqInfo->ptClient;
+    PPROXYREQUESTWRAPPER    pWrapper;
+
+
+    dwComputerNameSize = ptClient->dwComputerNameSize;
+    dwUserNameSize     = ptClient->dwUserNameSize;
+
+
+    //
+    // Calculate, alloc, & initalize a PROXYREQUESTWRAPPER struct.  At the
+    // head of this struct is the msg info for the LINE_PROXYREQUEST,
+    // followed by the actual request data.
+    //
+
+    dwSize =
+        (sizeof (ASYNCEVENTMSG) +   // LINE_PROXYREQUEST msg info
+        7 * sizeof (DWORD) +        // Non-union fields in LINEPROXYREQUEST
+        dwExtraBytes +              // Request-specific size
+        dwUserNameSize +            // User name size
+        dwComputerNameSize +        // Computer name size
+        3) & 0xfffffffc;            // make sure size is a DWORD multiple
+                                    //   so our lstrcpyW's below don't fault
+                                    //   and so that when this msg eventually
+                                    //   gets copied to some client's async
+                                    //   event buf we don't start running into
+                                    //   alignment problems (the msgs's
+                                    //   dwTotalSize field must be DWORD-
+                                    //   aligned)
+
+    if (!(pWrapper = ServerAlloc (dwSize)))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    pWrapper->AsyncEventMsg.dwTotalSize        = dwSize;
+    pWrapper->AsyncEventMsg.pInitData          = (DWORD)
+        ((PTLINEAPP) pProxy->ptLineApp)->lpfnCallback;
+    //pWrapper->AsyncEventMsg.pfnPostProcessProc =
+    pWrapper->AsyncEventMsg.hDevice            = (DWORD) pProxy;
+    pWrapper->AsyncEventMsg.dwMsg              = LINE_PROXYREQUEST;
+    pWrapper->AsyncEventMsg.dwCallbackInst     = pProxy->dwCallbackInstance;
+    pWrapper->AsyncEventMsg.dwParam1           = (DWORD) pAsyncReqInfo;
+    //pWrapper->AsyncEventMsg.dwParam2           =
+    //pWrapper->AsyncEventMsg.dwParam3           =
+    //pWrapper->AsyncEventMsg.dwParam4           =
+
+    dwSize -= sizeof (ASYNCEVENTMSG);
+
+    pWrapper->ProxyRequest.dwSize = dwSize;
+
+    pWrapper->ProxyRequest.dwClientMachineNameSize   = dwComputerNameSize;
+    pWrapper->ProxyRequest.dwClientMachineNameOffset =
+        dwSize - dwComputerNameSize;
+
+    lstrcpyW(
+        (PWSTR)((LPBYTE) &pWrapper->ProxyRequest +
+            pWrapper->ProxyRequest.dwClientMachineNameOffset),
+        ptClient->pszComputerName
+        );
+
+    pWrapper->ProxyRequest.dwClientUserNameSize   = dwUserNameSize;
+    pWrapper->ProxyRequest.dwClientUserNameOffset =
+        (dwSize - dwComputerNameSize) - dwUserNameSize;
+
+    lstrcpyW(
+        (PWSTR)((LPBYTE) &pWrapper->ProxyRequest +
+            pWrapper->ProxyRequest.dwClientUserNameOffset),
+        ptClient->pszUserName
+        );
+
+    pWrapper->ProxyRequest.dwClientAppAPIVersion = 0; // BUGBUG
+    pWrapper->ProxyRequest.dwRequestType = dwRequestType;
+
+    *ppWrapper = pWrapper;
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+SendProxyRequest(
+    PTLINECLIENT            pProxy,
+    PPROXYREQUESTWRAPPER    pWrapper,
+    PASYNCREQUESTINFO       pAsyncRequestInfo
+    )
+{
+    LONG    lResult;
+
+
+    //
+    // Add the request to the proxy's list, then send it the request.
+    // Since the proxy (tLineClient) could get closed at any time we
+    // wrap the following in a try/except.
+    //
+    // Note: the AsyncReqInfo.dwParam4 & dwParam5 fields are used as
+    // the prev & next pointers for maintaining the list of proxy
+    // requests pending on tLineClient.
+    //
+
+    try
+    {
+        BOOL    bDupedMutex;
+        HANDLE  hMutex;
+
+
+        if (WaitForMutex(
+                pProxy->hMutex,
+                &hMutex,
+                &bDupedMutex,
+                pProxy,
+                TLINECLIENT_KEY,
+                INFINITE
+                ))
+        {
+            if ((pAsyncRequestInfo->dwParam5 = (DWORD)
+                    pProxy->pPendingProxyRequests))
+            {
+                ((PASYNCREQUESTINFO) pAsyncRequestInfo->dwParam5)->dwParam4 =
+                    (DWORD) pAsyncRequestInfo;
+            }
+
+            pProxy->pPendingProxyRequests = pAsyncRequestInfo;
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+            WriteEventBuffer (pProxy->ptClient, (PASYNCEVENTMSG) pWrapper);
+
+            lResult = 0;
+        }
+        else
+        {
+            lResult = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+    myexcept
+    {
+        lResult = LINEERR_OPERATIONUNAVAIL;
+    }
+
+    ServerFree (pWrapper);
+
+    return lResult;
+}
+
+
+BOOL
+PASCAL
+NotifyHighestPriorityRequestRecipient(
+    void
+    )
+{
+    //
+    // Send a LINE_REQUEST msg to the highest priority request recipient
+    // to inform it that there are requests available for processing
+    //
+
+    PTLINEAPP       ptLineApp;
+    ASYNCEVENTMSG   msg;
+
+
+// BUGBUG NotifyHighestPriorityRequestRecipient: mutex or try/xcpt
+
+    ptLineApp = TapiGlobals.pHighestPriorityRequestRecipient->ptLineApp;
+
+    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+    msg.pInitData          = (DWORD) ptLineApp->lpfnCallback;
+    msg.pfnPostProcessProc =
+    msg.hDevice            = 0;
+    msg.dwMsg              = LINE_REQUEST;
+    msg.dwCallbackInst     = 0;
+    msg.dwParam1           = LINEREQUESTMODE_MAKECALL;
+    msg.dwParam2           =
+    msg.dwParam3           = 0;
+
+    WriteEventBuffer (ptLineApp->ptClient, &msg);
+
+    return TRUE;
+}
+
+void
+SetDrvCallFlags(
+    PTCALL  ptCall,
+    DWORD   dwDrvCallFlags
+    )
+{
+    //
+    // This func is called on return from TSPI_lineMakeCall (and other
+    // TSPI_lineXxx funcs where calls are created) and sets the
+    // dwDrvCallFlags field in the tCall as specified.  This keeps
+    // another thread which is currently doing a DestroytCall on this
+    // call from passing an invalid hdCall to the provider when
+    // doing a TSPI_lineCloseCall.
+    //
+    //
+
+    try
+    {
+        BOOL    bCloseMutex;
+        HANDLE  hMutex = ptCall->hMutex;
+
+
+        if ((ptCall->dwKey == TINCOMPLETECALL_KEY) ||
+            (ptCall->dwKey == TCALL_KEY) ||
+            (ptCall->dwKey == TZOMBIECALL_KEY))
+        {
+            if (WaitForMutex(
+                    hMutex,
+                    &hMutex,
+                    &bCloseMutex,
+                    NULL,
+                    0,
+                    INFINITE
+                    ))
+            {
+                if ((ptCall->dwKey == TINCOMPLETECALL_KEY) ||
+                    (ptCall->dwKey == TCALL_KEY) ||
+                    (ptCall->dwKey == TZOMBIECALL_KEY))
+                {
+                    // only set the loword
+                    ptCall->dwDrvCallFlags = MAKELONG(LOWORD(dwDrvCallFlags),
+                                                      HIWORD(ptCall->dwDrvCallFlags));
+                }
+
+                MyReleaseMutex (hMutex, bCloseMutex);
+            }
+        }
+    }
+    myexcept
+    {
+        // do nothing
+    }
+}
+
+
+LONG
+PASCAL
+SetCallConfList(
+    PTCALL              ptCall,
+    PTCONFERENCELIST    pConfList,
+    BOOL                bAddToConfPostProcess
+    )
+{
+    LONG    lResult;
+    BOOL    bDupedMutex, bAddToConfList = FALSE;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusivetCallAccess(
+            (HTAPICALL) ptCall,
+            TCALL_KEY,
+            &hMutex,
+            &bDupedMutex,
+// BUGBUG SetCallConfList: use timeout here?
+            INFINITE
+            ))
+    {
+        if (pConfList)
+        {
+            if (ptCall->pConfList && !bAddToConfPostProcess)
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+            }
+            else
+            {
+                ptCall->pConfList = pConfList;
+                lResult = 0;
+                bAddToConfList = TRUE;
+            }
+        }
+        else
+        {
+            if (ptCall->pConfList)
+            {
+                pConfList = ptCall->pConfList;
+                ptCall->pConfList = NULL;
+                lResult = 0;
+            }
+            else
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+            }
+        }
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+    }
+    else
+    {
+        lResult = LINEERR_INVALCALLHANDLE;
+    }
+
+// BUGBUG SetCallConfList: verify the conf list, and wrap in mutex
+
+    if (pConfList &&
+        (pConfList != (PTCONFERENCELIST) 0xffffffff) &&
+        (lResult == 0))
+    {
+        if (bAddToConfList)
+        {
+             while (pConfList->dwNumUsedEntries >=
+                     pConfList->dwNumTotalEntries)
+             {
+                 if (pConfList->pNext)
+                 {
+                     pConfList = pConfList->pNext;
+                 }
+                 else
+                 {
+                    DWORD               dwSize;
+                    PTCONFERENCELIST    pNewConfList;
+
+
+                    dwSize = sizeof (TCONFERENCELIST) +  sizeof (PTCALL) *
+                         (2 * pConfList->dwNumTotalEntries - 1);
+
+                    if (!(pNewConfList = ServerAlloc (dwSize)))
+                    {
+                         ptCall->pConfList = NULL;
+                         return LINEERR_NOMEM;
+                    }
+
+                    pNewConfList->dwNumTotalEntries =
+                        2 * pConfList->dwNumTotalEntries;
+
+                    pConfList->pNext = pNewConfList;
+
+                    pConfList = pNewConfList;
+                }
+            }
+
+            pConfList->aptCalls[pConfList->dwNumUsedEntries++] = ptCall;
+        }
+        else
+        {
+            while (pConfList)
+            {
+                DWORD   i, dwNumUsedEntries = pConfList->dwNumUsedEntries;
+                PTCALL *pptCall = pConfList->aptCalls;
+
+
+                for (i = 0; i < dwNumUsedEntries; i++)
+                {
+                    if (pConfList->aptCalls[i] == ptCall)
+                    {
+                        //
+                        // Found the call in the list, shuffle all the
+                        // following calls in list down by 1 to maintain
+                        // continuity
+                        //
+
+                        for (; i < (dwNumUsedEntries - 1); i++)
+                        {
+                            pConfList->aptCalls[i] = pConfList->aptCalls[i+1];
+                        }
+
+                        pConfList->dwNumUsedEntries--;
+
+                        pConfList = NULL;
+
+                        break;
+                    }
+
+                    pptCall++;
+                }
+
+                if (pConfList)
+                {
+                    pConfList = pConfList->pNext;
+                }
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+RemoveCallFromLineList(
+    PTCALL  ptCall
+    )
+{
+    PTLINE ptLine = (PTLINE) ptCall->ptLine;
+
+
+    WaitForSingleObject (ptLine->hMutex, INFINITE);
+
+    if (ptCall->pNext)
+    {
+        ptCall->pNext->pPrev = ptCall->pPrev;
+    }
+
+    if (ptCall->pPrev)
+    {
+        ptCall->pPrev->pNext = ptCall->pNext;
+    }
+    else
+    {
+        ptLine->ptCalls = ptCall->pNext;
+    }
+
+    ReleaseMutex (ptLine->hMutex);
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+RemoveCallClientFromLineClientList(
+    PTCALLCLIENT    ptCallClient
+    )
+{
+    PTLINECLIENT    ptLineClient = (PTLINECLIENT) ptCallClient->ptLineClient;
+
+
+    WaitForSingleObject (ptLineClient->hMutex, INFINITE);
+
+    if (ptCallClient->pNextSametLineClient)
+    {
+        ptCallClient->pNextSametLineClient->pPrevSametLineClient =
+            ptCallClient->pPrevSametLineClient;
+    }
+
+    if (ptCallClient->pPrevSametLineClient)
+    {
+        ptCallClient->pPrevSametLineClient->pNextSametLineClient =
+            ptCallClient->pNextSametLineClient;
+    }
+    else
+    {
+        ptLineClient->ptCallClients = ptCallClient->pNextSametLineClient;
+    }
+
+    ReleaseMutex (ptLineClient->hMutex);
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetConfCallListFromConf(
+    PTCONFERENCELIST    pConfList,
+    PTPOINTERLIST      *ppList
+    )
+{
+// BUGBUG GetConfCallListFromConf: needs a mutex
+
+    DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                    dwNumUsedEntries = 0, i;
+    PTPOINTERLIST   pList = *ppList;
+
+
+    while (pConfList)
+    {
+        if ((dwNumUsedEntries + pConfList->dwNumUsedEntries) >
+                dwNumTotalEntries)
+        {
+            //
+            // We need a larger list, so alloc a new one, copy the
+            // contents of the current one, and the free the current
+            // one iff we previously alloc'd it
+            //
+
+            PTPOINTERLIST   pNewList;
+
+
+            do
+            {
+                dwNumTotalEntries <<= 1;
+
+            } while ((dwNumUsedEntries + pConfList->dwNumUsedEntries) >
+                        dwNumTotalEntries);
+
+            if (!(pNewList = ServerAlloc(
+                    sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                        (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                    )))
+            {
+                return LINEERR_NOMEM;
+            }
+
+            CopyMemory(
+                pNewList->aEntries,
+                pList->aEntries,
+                dwNumUsedEntries * sizeof (LPVOID)
+                );
+
+            if (pList != *ppList)
+            {
+                ServerFree (pList);
+            }
+
+            pList = pNewList;
+        }
+
+        for (i = 0; i < pConfList->dwNumUsedEntries; i++)
+        {
+            pList->aEntries[dwNumUsedEntries++] = pConfList->aptCalls[i];
+        }
+
+        pConfList = pConfList->pNext;
+    }
+
+    pList->dwNumUsedEntries = dwNumUsedEntries;
+
+    *ppList = pList;
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetCallClientListFromCall(
+    PTCALL          ptCall,
+    PTPOINTERLIST  *ppList
+    )
+{
+    BOOL    bDupedMutex;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusivetCallAccess(
+            (HTAPICALL) ptCall,
+            TCALL_KEY,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                        dwNumUsedEntries = 0;
+        PTPOINTERLIST   pList = *ppList;
+        PTCALLCLIENT    ptCallClient = ptCall->ptCallClients;
+
+
+        while (ptCallClient)
+        {
+            if (dwNumUsedEntries == dwNumTotalEntries)
+            {
+                //
+                // We need a larger list, so alloc a new one, copy the
+                // contents of the current one, and the free the current
+                // one iff we previously alloc'd it
+                //
+
+                PTPOINTERLIST   pNewList;
+
+
+                dwNumTotalEntries <<= 1;
+
+                if (!(pNewList = ServerAlloc(
+                        sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                            (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                        )))
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+                    return LINEERR_NOMEM;
+                }
+
+                CopyMemory(
+                    pNewList->aEntries,
+                    pList->aEntries,
+                    dwNumUsedEntries * sizeof (LPVOID)
+                    );
+
+                if (pList != *ppList)
+                {
+                    ServerFree (pList);
+                }
+
+                pList = pNewList;
+            }
+
+            pList->aEntries[dwNumUsedEntries++] = ptCallClient;
+
+            ptCallClient = ptCallClient->pNextSametCall;
+        }
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+
+        pList->dwNumUsedEntries = dwNumUsedEntries;
+
+        *ppList = pList;
+    }
+    else
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetCallListFromLine(
+    PTLINE          ptLine,
+    PTPOINTERLIST  *ppList
+    )
+{
+    BOOL    bDupedMutex;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusivetLineAccess(
+            (HTAPILINE) ptLine,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                        dwNumUsedEntries = 0;
+        PTCALL          ptCall = ptLine->ptCalls;
+        PTPOINTERLIST   pList = *ppList;
+
+
+        while (ptCall)
+        {
+            if (dwNumUsedEntries == dwNumTotalEntries)
+            {
+                //
+                // We need a larger list, so alloc a new one, copy the
+                // contents of the current one, and the free the current
+                // one iff we previously alloc'd it
+                //
+
+                PTPOINTERLIST   pNewList;
+
+
+                dwNumTotalEntries <<= 1;
+
+                if (!(pNewList = ServerAlloc(
+                        sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                            (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                        )))
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+                    return LINEERR_NOMEM;
+                }
+
+                CopyMemory(
+                    pNewList->aEntries,
+                    pList->aEntries,
+                    dwNumUsedEntries * sizeof (LPVOID)
+                    );
+
+                if (pList != *ppList)
+                {
+                    ServerFree (pList);
+                }
+
+                pList = pNewList;
+            }
+
+            pList->aEntries[dwNumUsedEntries++] = ptCall;
+
+            ptCall = ptCall->pNext;
+        }
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+
+        pList->dwNumUsedEntries = dwNumUsedEntries;
+
+        *ppList = pList;
+    }
+    else
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetLineClientListFromLine(
+    PTLINE          ptLine,
+    PTPOINTERLIST  *ppList
+    )
+{
+    BOOL    bDupedMutex;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusivetLineAccess(
+            (HTAPILINE) ptLine,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                        dwNumUsedEntries = 0;
+        PTPOINTERLIST   pList = *ppList;
+        PTLINECLIENT    ptLineClient = ptLine->ptLineClients;
+
+
+        while (ptLineClient)
+        {
+            if (dwNumUsedEntries == dwNumTotalEntries)
+            {
+                //
+                // We need a larger list, so alloc a new one, copy the
+                // contents of the current one, and the free the current
+                // one iff we previously alloc'd it
+                //
+
+                PTPOINTERLIST   pNewList;
+
+
+                dwNumTotalEntries <<= 1;
+
+                if (!(pNewList = ServerAlloc(
+                        sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                            (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                        )))
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+                    return LINEERR_NOMEM;
+                }
+
+                CopyMemory(
+                    pNewList->aEntries,
+                    pList->aEntries,
+                    dwNumUsedEntries * sizeof (LPVOID)
+                    );
+
+                if (pList != *ppList)
+                {
+                    ServerFree (pList);
+                }
+
+                pList = pNewList;
+            }
+
+            pList->aEntries[dwNumUsedEntries++] = ptLineClient;
+
+            ptLineClient = ptLineClient->pNextSametLine;
+        }
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+
+        pList->dwNumUsedEntries = dwNumUsedEntries;
+
+        *ppList = pList;
+    }
+    else
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetLineAppListFromClient(
+    PTCLIENT        ptClient,
+    PTPOINTERLIST  *ppList
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusiveClientAccess(
+            ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                        dwNumUsedEntries = 0;
+        PTLINEAPP       ptLineApp = ptClient->ptLineApps;
+        PTPOINTERLIST   pList = *ppList;
+
+
+        while (ptLineApp)
+        {
+            if (dwNumUsedEntries == dwNumTotalEntries)
+            {
+                //
+                // We need a larger list, so alloc a new one, copy the
+                // contents of the current one, and the free the current
+                // one iff we previously alloc'd it
+                //
+
+                PTPOINTERLIST   pNewList;
+
+
+                dwNumTotalEntries <<= 1;
+
+                if (!(pNewList = ServerAlloc(
+                        sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                            (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                        )))
+                {
+                    MyReleaseMutex (hMutex, bCloseMutex);
+                    return LINEERR_NOMEM;
+                }
+
+                CopyMemory(
+                    pNewList->aEntries,
+                    pList->aEntries,
+                    dwNumUsedEntries * sizeof (LPVOID)
+                    );
+
+                if (pList != *ppList)
+                {
+                    ServerFree (pList);
+                }
+
+                pList = pNewList;
+            }
+
+            pList->aEntries[dwNumUsedEntries++] = ptLineApp;
+
+            ptLineApp = ptLineApp->pNext;
+        }
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+
+        pList->dwNumUsedEntries = dwNumUsedEntries;
+
+        *ppList = pList;
+    }
+    else
+    {
+        return LINEERR_OPERATIONFAILED;
+    }
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetClientList(
+    PTPOINTERLIST  *ppList
+    )
+{
+    DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                    dwNumUsedEntries = 0;
+    PTPOINTERLIST   pList = *ppList;
+    PTCLIENT        ptClient;
+
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    ptClient = TapiGlobals.ptClients;
+
+    while (ptClient)
+    {
+        if (dwNumUsedEntries == dwNumTotalEntries)
+        {
+            //
+            // We need a larger list, so alloc a new one, copy the
+            // contents of the current one, and the free the current
+            // one iff we previously alloc'd it
+            //
+
+            PTPOINTERLIST   pNewList;
+
+
+            dwNumTotalEntries <<= 1;
+
+            if (!(pNewList = ServerAlloc(
+                    sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                        (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                    )))
+            {
+                ReleaseMutex (TapiGlobals.hMutex);
+                return LINEERR_NOMEM;
+            }
+
+            CopyMemory(
+                pNewList->aEntries,
+                pList->aEntries,
+                dwNumUsedEntries * sizeof (LPVOID)
+                );
+
+            if (pList != *ppList)
+            {
+                ServerFree (pList);
+            }
+
+            pList = pNewList;
+        }
+
+        pList->aEntries[dwNumUsedEntries++] = ptClient;
+
+        ptClient = ptClient->pNext;
+    }
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+    pList->dwNumUsedEntries = dwNumUsedEntries;
+
+    *ppList = pList;
+
+    ReleaseMutex (TapiGlobals.hMutex);
+}
+
+
+void
+PASCAL
+SendMsgToCallClients(
+    PTCALL          ptCall,
+    PTCALLCLIENT    ptCallClientToExclude,
+    DWORD           dwMsg,
+    DWORD           dwParam1,
+    DWORD           dwParam2,
+    DWORD           dwParam3
+    )
+{
+    DWORD           i;
+    TPOINTERLIST    clientList, *pClientList = &clientList;
+    ASYNCEVENTMSG   msg;
+
+
+    if (GetCallClientListFromCall (ptCall, &pClientList) != 0)
+    {
+        return;
+    }
+
+    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+    msg.pfnPostProcessProc = 0;
+    msg.dwMsg              = dwMsg;
+    msg.dwParam1           = dwParam1;
+    msg.dwParam2           = dwParam2;
+    msg.dwParam3           = dwParam3;
+
+    for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+    {
+        try
+        {
+            PTCLIENT        ptClient;
+            PTCALLCLIENT    ptCallClient = pClientList->aEntries[i];
+            PTLINECLIENT    ptLineClient = ptCallClient->ptLineClient;
+
+
+            if (ptCallClient == ptCallClientToExclude)
+            {
+                continue;
+            }
+
+            if (dwMsg == LINE_MONITORDIGITS)
+            {
+                if ((ptCallClient->dwMonitorDigitModes & dwParam2) == 0)
+                {
+                    continue;
+                }
+            }
+            else if (dwMsg == LINE_MONITORMEDIA)
+            {
+                DWORD   dwMediaModes = dwParam1;
+
+
+                //
+                // Munge the media modes so we don't pass unexpected flags
+                // to old apps
+                //
+
+                if (ptLineClient->dwAPIVersion == TAPI_VERSION1_0)
+                {
+                    if ((dwMediaModes & ~AllMediaModes1_0))
+                    {
+                        dwMediaModes = (dwMediaModes & AllMediaModes1_0) |
+                            LINEMEDIAMODE_UNKNOWN;
+                    }
+                }
+
+                if (ptCallClient->dwMonitorMediaModes & dwMediaModes)
+                {
+                    msg.dwParam1 = dwMediaModes;
+                }
+                else
+                {
+                    continue;
+                }
+            }
+
+            msg.pInitData      = (DWORD)
+                ((PTLINEAPP) ptLineClient->ptLineApp)->lpfnCallback;
+            msg.hDevice        = (DWORD) ptCallClient;
+            msg.dwCallbackInst = ptLineClient->dwCallbackInstance;
+
+            //
+            // Indicate the hRemoteLine in p4 to make life easier for remotesp
+            //
+
+            msg.dwParam4 = ptLineClient->hRemoteLine;
+
+            ptClient = ptLineClient->ptClient;
+
+            if (ptCallClient->dwKey == TCALLCLIENT_KEY)
+            {
+                WriteEventBuffer (ptClient, &msg);
+            }
+        }
+        myexcept
+        {
+            // just continue
+        }
+    }
+
+    if (pClientList != &clientList)
+    {
+        ServerFree (pClientList);
+    }
+}
+
+
+void
+PASCAL
+SendAMsgToAllLineApps(
+    DWORD dwWantVersion,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+    DWORD           i, j;
+    TPOINTERLIST    clientList, *pClientList = &clientList;
+    ASYNCEVENTMSG   lineMsg;
+
+
+    if (GetClientList (&pClientList) != 0)
+    {
+        return;
+    }
+
+    ZeroMemory (&lineMsg, sizeof (ASYNCEVENTMSG));
+
+    lineMsg.dwTotalSize = sizeof (ASYNCEVENTMSG);
+    lineMsg.dwMsg    = dwMsg;
+    lineMsg.dwParam1 = dwParam1;
+    lineMsg.dwParam2 = dwParam2;
+    lineMsg.dwParam3 = dwParam3;
+
+
+    for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+    {
+        PTCLIENT        ptClient = (PTCLIENT) pClientList->aEntries[i];
+        TPOINTERLIST    xxxAppList, *pXxxAppList = &xxxAppList;
+
+
+        if (GetLineAppListFromClient (ptClient, &pXxxAppList) == 0)
+        {
+            for (j = 0; j < pXxxAppList->dwNumUsedEntries; j++)
+            {
+                PTLINEAPP ptLineApp = (PTLINEAPP) pXxxAppList->aEntries[j];
+
+                try
+                {
+                    lineMsg.pInitData = (DWORD) ptLineApp->lpfnCallback;
+
+                    if (
+                          (ptLineApp->dwKey == TLINEAPP_KEY)
+                        &&
+                          (
+                             (dwWantVersion == 0)
+                           ||
+                             (ptLineApp->dwAPIVersion == dwWantVersion)
+                           ||
+                             (
+                                (dwWantVersion & 0x80000000)
+                              &&
+                                (ptLineApp->dwAPIVersion >
+                                        (dwWantVersion & 0x7fffffff)
+                                )
+                             )
+                          )
+                       )
+                    {
+                        WriteEventBuffer (ptClient, &lineMsg);
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+
+            if (pXxxAppList != &xxxAppList)
+            {
+                ServerFree (pXxxAppList);
+            }
+        }
+
+    }
+
+
+    if (pClientList != &clientList)
+    {
+        ServerFree (pClientList);
+    }
+}
+
+
+
+void
+PASCAL
+SendAMsgToAllPhoneApps(
+    DWORD dwWantVersion,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+    DWORD           i, j;
+    TPOINTERLIST    clientList, *pClientList = &clientList;
+    ASYNCEVENTMSG   phoneMsg;
+
+
+    if (GetClientList (&pClientList) != 0)
+    {
+        return;
+    }
+
+    ZeroMemory (&phoneMsg, sizeof (ASYNCEVENTMSG));
+
+    phoneMsg.dwTotalSize = sizeof (ASYNCEVENTMSG);
+    phoneMsg.dwMsg    = dwMsg;
+    phoneMsg.dwParam1 = dwParam1;
+    phoneMsg.dwParam2 = dwParam2;
+    phoneMsg.dwParam3 = dwParam3;
+
+    for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+    {
+        PTCLIENT        ptClient = (PTCLIENT) pClientList->aEntries[i];
+        TPOINTERLIST    xxxAppList, *pXxxAppList = &xxxAppList;
+
+
+        if (GetPhoneAppListFromClient (ptClient, &pXxxAppList) == 0)
+        {
+            for (j = 0; j < pXxxAppList->dwNumUsedEntries; j++)
+            {
+                PTPHONEAPP  ptPhoneApp = (PTPHONEAPP) pXxxAppList->aEntries[j];
+
+                try
+                {
+                    phoneMsg.pInitData = (DWORD) ptPhoneApp->lpfnCallback;
+
+                    if (
+                          (ptPhoneApp->dwKey == TPHONEAPP_KEY)
+                        &&
+                          (
+                             (dwWantVersion == 0)
+                           ||
+                             (ptPhoneApp->dwAPIVersion == dwWantVersion)
+                           ||
+                             (
+                                (dwWantVersion & 0x80000000)
+                              &&
+                                (ptPhoneApp->dwAPIVersion >
+                                        (dwWantVersion & 0x7fffffff)
+                                )
+                             )
+                          )
+                       )
+                    {
+                        WriteEventBuffer (ptClient, &phoneMsg);
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+
+            if (pXxxAppList != &xxxAppList)
+            {
+                ServerFree (pXxxAppList);
+            }
+        }
+    }
+
+
+    if (pClientList != &clientList)
+    {
+        ServerFree (pClientList);
+    }
+}
+
+
+
+void
+PASCAL
+SendReinitMsgToAllXxxApps(
+    void
+    )
+{
+    TapiGlobals.bReinit = TRUE;
+
+    SendAMsgToAllLineApps(  0,
+                            LINE_LINEDEVSTATE,
+                            LINEDEVSTATE_REINIT,
+                            0,
+                            0
+                            );
+
+    SendAMsgToAllPhoneApps(  0,
+                             PHONE_STATE,
+                             PHONESTATE_REINIT,
+                             0,
+                             0
+                             );
+}
+
+
+void
+PASCAL
+SendMsgToLineClients(
+    PTLINE          ptLine,
+    PTLINECLIENT    ptLineClientToExclude,
+    DWORD           dwMsg,
+    DWORD           dwParam1,
+    DWORD           dwParam2,
+    DWORD           dwParam3
+    )
+{
+    DWORD           i;
+    TPOINTERLIST    clientList, *pClientList = &clientList;
+    ASYNCEVENTMSG   msg;
+
+
+    if (dwMsg == LINE_LINEDEVSTATE  &&  dwParam1 & LINEDEVSTATE_REINIT)
+    {
+        SendReinitMsgToAllXxxApps();
+
+        if (dwParam1 == LINEDEVSTATE_REINIT)
+        {
+            return;
+        }
+        else
+        {
+            dwParam1 &= ~LINEDEVSTATE_REINIT;
+        }
+    }
+
+
+    if (GetLineClientListFromLine (ptLine, &pClientList) != 0)
+    {
+        return;
+    }
+
+    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+    msg.pfnPostProcessProc = 0;
+    msg.dwMsg              = dwMsg;
+    msg.dwParam1           = dwParam1;
+    msg.dwParam2           = dwParam2;
+    msg.dwParam3           = dwParam3;
+    msg.dwParam4           = 0; // remotesp chks this on LINE_DEVSPEC(FEATURE)
+
+    for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+    {
+        try
+        {
+            PTCLIENT     ptClient;
+            PTLINECLIENT ptLineClient = pClientList->aEntries[i];
+
+
+            if (ptLineClient == ptLineClientToExclude)
+            {
+                continue;
+            }
+
+            if (dwMsg == LINE_ADDRESSSTATE)
+            {
+                DWORD   dwAddressStates = dwParam2;
+
+
+                //
+                // Munge the state flags so we don't pass
+                // unexpected flags to old apps
+                //
+
+                switch (ptLineClient->dwAPIVersion)
+                {
+                case TAPI_VERSION1_0:
+
+                    dwAddressStates &= AllAddressStates1_0;
+                    break;
+
+                case TAPI_VERSION1_4:
+
+                    dwAddressStates &= AllAddressStates1_4;
+                    break;
+
+                case TAPI_VERSION_CURRENT:
+
+                    dwAddressStates &= AllAddressStates1_4;
+//                    dwAddressStates &= AllAddressStates2_0;
+                    break;
+
+                }
+
+                if ((dwAddressStates &= ptLineClient->dwAddressStates))
+                {
+                    msg.dwParam2 = dwAddressStates;
+                }
+                else
+                {
+                    continue;
+                }
+
+                if ((dwParam2 & LINEADDRESSSTATE_CAPSCHANGE))
+                {
+// BUGBUG LINE_ADDRSTATE: send REINIT msg to 1_0 apps (dwParam3 = dwParam1?)
+                }
+            }
+            else if (dwMsg == LINE_LINEDEVSTATE)
+            {
+                DWORD           dwLineStates = dwParam1;
+
+
+                //
+                // Munge the state flags so we don't pass unexpected flags
+                // to old apps
+                //
+
+                switch (ptLineClient->dwAPIVersion)
+                {
+                case TAPI_VERSION1_0:
+
+                    dwLineStates &= AllLineStates1_0;
+                    break;
+
+                default:    // case TAPI_VERSION1_4:
+                            // case TAPI_VERSION_CURRENT:
+
+                    dwLineStates &= AllLineStates1_4;
+                    break;
+                }
+
+                if ((dwLineStates &= ptLineClient->dwLineStates))
+                {
+                    msg.dwParam1 = dwLineStates;
+                }
+                else
+                {
+                    continue;
+                }
+
+                if ((dwParam1 & (LINEDEVSTATE_CAPSCHANGE |
+                        LINEDEVSTATE_TRANSLATECHANGE)))
+                {
+// BUGBUG LINE_LINEDEVSTATE: send REINIT to 1_0 apps (dwParam3 = dwParam1)
+                }
+
+            }
+
+            msg.pInitData         = (DWORD)
+                           ((PTLINEAPP) ptLineClient->ptLineApp)->lpfnCallback;
+            msg.hDevice           = (DWORD) ptLineClient->hRemoteLine;
+            msg.dwCallbackInst    = ptLineClient->dwCallbackInstance;
+
+            ptClient = ptLineClient->ptClient;
+
+            if (ptLineClient->dwKey == TLINECLIENT_KEY)
+            {
+                WriteEventBuffer (ptClient, &msg);
+            }
+        }
+        myexcept
+        {
+            // just continue
+        }
+    }
+
+    if (pClientList != &clientList)
+    {
+        ServerFree (pClientList);
+    }
+}
+
+
+LONG
+PASCAL
+CreatetCall(
+    PTLINE              ptLine,
+    BOOL                bValidate,
+    PTCALL             *pptCall,
+    LPLINECALLPARAMS    pCallParams,
+    LPDWORD             pdwCallInstance
+    )
+{
+    BOOL    bDupedMutex;
+    DWORD   dwExtraBytes;
+    HANDLE  hMutex;
+    PTCALL  ptCall;
+
+
+//    DBGOUT((3, "CreatetCall: enter, ptLine=x%x", ptLine));
+
+
+    //
+    // If there's call params specified check to see if we need to alloc
+    // any extra space for the CalledParty, DisplayableAddr, or Comment
+    // fields.  Also, if any of these fields are non-NULL make sure to
+    // get extra space to keep these fields 64-bit aligned.
+    //
+
+    dwExtraBytes = (pCallParams == NULL ? 0 : pCallParams->dwCalledPartySize +
+        pCallParams->dwDisplayableAddressSize + pCallParams->dwCommentSize);
+
+    if (dwExtraBytes != 0)
+    {
+        dwExtraBytes += (sizeof (TCALL) & 4) + 16;
+    }
+
+
+    //
+    // Alloc necessary resources
+    //
+
+    if (!(ptCall = ServerAlloc (sizeof (TCALL) + dwExtraBytes)) ||
+        !(ptCall->hMutex = MyCreateMutex()))
+    {
+        if (ptCall)
+        {
+            ServerFree (ptCall);
+        }
+
+        return LINEERR_NOMEM;
+    }
+
+
+    //
+    // Init tCall & add to tLine's tCall list
+    //
+
+    if (bValidate)
+    {
+        ptCall->dwKey = TCALL_KEY;
+        ptCall->dwDrvCallFlags = DCF_SPIRETURNED | DCF_DRVCALLVALID;
+    }
+    else
+    {
+        EnterCriticalSection (&gRequestIDCritSec);
+
+        *pdwCallInstance = ptCall->dwCallInstance = gdwCallInstance;
+        gdwCallInstance++;
+
+        LeaveCriticalSection (&gRequestIDCritSec);
+
+        ptCall->dwKey = TINCOMPLETECALL_KEY;
+    }
+
+    if (pCallParams)
+    {
+        DWORD dwOffset = sizeof (TCALL) + (sizeof (TCALL) & 4);
+
+
+        if (pCallParams->dwDisplayableAddressSize != 0)
+        {
+            CopyMemory(
+                (ptCall->pszDisplayableAddress = (WCHAR *)
+                    (((LPBYTE) ptCall) + dwOffset)),
+                ((LPBYTE) pCallParams) +
+                    pCallParams->dwDisplayableAddressOffset,
+                (ptCall->dwDisplayableAddressSize =
+                    pCallParams->dwDisplayableAddressSize)
+                );
+
+            dwOffset += ((ptCall->dwDisplayableAddressSize + 8) & 0xfffffff8);
+        }
+
+        if (pCallParams->dwCalledPartySize)
+        {
+            CopyMemory(
+                (ptCall->pszCalledParty = (WCHAR *)
+                    (((LPBYTE)ptCall) + dwOffset)),
+                ((LPBYTE) pCallParams) + pCallParams->dwCalledPartyOffset,
+                (ptCall->dwCalledPartySize = pCallParams->dwCalledPartySize)
+                );
+
+            dwOffset += ((ptCall->dwCalledPartySize + 8) & 0xfffffff8);
+        }
+
+        if (pCallParams->dwCommentSize)
+        {
+            CopyMemory(
+                (ptCall->pszComment = (WCHAR *)
+                    (((LPBYTE) ptCall) + dwOffset)),
+                ((LPBYTE) pCallParams) + pCallParams->dwCommentOffset,
+                (ptCall->dwCommentSize = pCallParams->dwCommentSize)
+                );
+        }
+    }
+
+    if (WaitForExclusivetLineAccess(
+            (HTAPILINE) ptLine,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        ptCall->ptLine     = ptLine;
+        ptCall->ptProvider = ptLine->ptProvider;
+
+        if ((ptCall->pNext = ptLine->ptCalls))
+        {
+           ptCall->pNext->pPrev = ptCall;
+        }
+
+        ptLine->ptCalls = ptCall;
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+    }
+    else
+    {
+        //
+        // tLine was destroyed, so clean up. Note that we return
+        // a generic OPFAILED error, since some calling routines
+        // might no be spec'd to return INVALLINEHANDLE, etc.
+        //
+
+        CloseHandle (ptCall->hMutex);
+        ServerFree (ptCall);
+        return LINEERR_OPERATIONFAILED;
+    }
+
+
+    //
+    // Fill in caller's pointer & return success
+    //
+
+    *pptCall = ptCall;
+
+    PerfBlock.dwTotalOutgoingCalls++;
+    PerfBlock.dwCurrentOutgoingCalls++;
+    
+//    DBGOUT((3, "CreatetCall: exit, new ptCall=x%x", *pptCall));
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+CreatetCallClient(
+    PTCALL          ptCall,
+    PTLINECLIENT    ptLineClient,
+    DWORD           dwPrivilege,
+    BOOL            bValidate,
+    BOOL            bSendCallInfoMsg,
+    PTCALLCLIENT   *pptCallClient,
+    BOOL            bIndicatePrivilege
+    )
+{
+    BOOL            bDupedMutex;
+    HANDLE          hMutex;
+    PTCALLCLIENT    ptCallClient;
+
+
+//    DBGOUT((3, "CreatetCallClient: enter, ptCall=x%lx", ptCall));
+
+    if (!(ptCallClient = ServerAlloc (sizeof(TCALLCLIENT))))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    ptCallClient->dwKey = (bValidate ? TCALLCLIENT_KEY :
+        TINCOMPLETECALLCLIENT_KEY);
+
+    try
+    {
+        ptCallClient->ptClient = ptLineClient->ptClient;
+    }
+    myexcept
+    {
+        ServerFree (ptCallClient);
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    ptCallClient->ptLineClient = ptLineClient;
+    ptCallClient->ptCall       = ptCall;
+    ptCallClient->dwPrivilege  = dwPrivilege;
+    ptCallClient->bIndicatePrivilege = bIndicatePrivilege;
+
+
+    //
+    // Send a call info msg to existing call clients if appropriate.
+    // Note that if the following attempt to add the new call client
+    // to the line client's list fails we will have sent an "invalid"
+    // msg.
+    //
+
+    if (bSendCallInfoMsg)
+    {
+        SendMsgToCallClients(
+            ptCall,
+            NULL,
+            LINE_CALLINFO,
+            (dwPrivilege == LINECALLPRIVILEGE_OWNER ?
+                LINECALLINFOSTATE_NUMOWNERINCR :
+                LINECALLINFOSTATE_NUMMONITORS),
+            0,
+            0
+            );
+    }
+
+
+    //
+    // Safely increment tCall's dwNumOwners or dwNumMonitors field,
+    // and add new call client to list of call clients
+    //
+
+    if (WaitForExclusivetCallAccess(
+            (HTAPICALL) ptCall,
+            (bValidate ? TCALL_KEY : TINCOMPLETECALL_KEY),
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        if (dwPrivilege == LINECALLPRIVILEGE_OWNER)
+        {
+            ptCall->dwNumOwners++;
+        }
+        else
+        {
+            ptCall->dwNumMonitors++;
+        }
+
+        if ((ptCallClient->pNextSametCall = ptCall->ptCallClients))
+        {
+            ptCallClient->pNextSametCall->pPrevSametCall =
+                ptCallClient;
+        }
+
+        ptCall->ptCallClients = ptCallClient;
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+    }
+    else
+    {
+        //
+        // tCall was destroyed, so clean up. Note that we return
+        // a generic OPFAILED error, since some calling routines
+        // might no be spec'd to return INVALCALLHANDLE, etc.
+        //
+
+        ServerFree (ptCallClient);
+        return LINEERR_OPERATIONFAILED;
+    }
+
+
+    //
+    // Add to tLineClient's tCallClient list
+    //
+
+    if (WaitForExclusiveLineClientAccess(
+            (HLINE) ptLineClient,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        if ((ptCallClient->pNextSametLineClient = ptLineClient->ptCallClients))
+        {
+            ptCallClient->pNextSametLineClient->pPrevSametLineClient =
+                ptCallClient;
+        }
+
+        ptLineClient->ptCallClients = ptCallClient;
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+    }
+    else
+    {
+        //
+        // Couldn't add tCallClient to tLineClient's list, so safely
+        // remove it from tCall's list, dec the owner or monitor count,
+        // free the tCallClient, and return an appropriate error
+        //
+
+        if (WaitForExclusivetCallAccess(
+                (HTAPICALL) ptCall,
+                (bValidate ? TCALL_KEY : TINCOMPLETECALL_KEY),
+                &hMutex,
+                &bDupedMutex,
+                INFINITE
+                ))
+        {
+            if (ptCallClient->dwKey ==
+                    (bValidate ? TCALLCLIENT_KEY : TINCOMPLETECALLCLIENT_KEY))
+            {
+                if (dwPrivilege == LINECALLPRIVILEGE_OWNER)
+                {
+                    ptCall->dwNumOwners--;
+                }
+                else
+                {
+                    ptCall->dwNumMonitors--;
+                }
+
+                if (ptCallClient->pNextSametCall)
+                {
+                    ptCallClient->pNextSametCall->pPrevSametCall =
+                        ptCallClient->pPrevSametCall;
+                }
+
+                if (ptCallClient->pPrevSametCall)
+                {
+                    ptCallClient->pPrevSametCall->pNextSametCall =
+                        ptCallClient->pNextSametCall;
+                }
+                else
+                {
+                    ptCall->ptCallClients = ptCallClient->pNextSametCall;
+                }
+
+                ServerFree (ptCallClient);
+            }
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+        }
+
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+
+    //
+    // Fill in caller's pointer & return success
+    //
+
+    *pptCallClient = ptCallClient;
+
+//    DBGOUT((
+//        3,
+//        "CreatetCallClient: exit, new ptCallClient=x%lx",
+//        *pptCallClient
+//        ));
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+CreatetCallAndClient(
+    PTLINECLIENT        ptLineClient,
+    PTCALL             *pptCall,
+    PTCALLCLIENT       *pptCallClient,
+    LPLINECALLPARAMS    pCallParams,
+    LPDWORD             pdwCallInstance
+    )
+{
+    LONG    lResult;
+    PTCALL  ptCall = NULL;
+
+
+    if ((lResult = CreatetCall(
+            ptLineClient->ptLine,
+            FALSE,
+            &ptCall,
+            pCallParams,
+            pdwCallInstance
+
+            )) != 0 ||
+
+        (lResult = CreatetCallClient(
+            ptCall,
+            ptLineClient,
+            LINECALLPRIVILEGE_OWNER,
+            FALSE,
+            FALSE,
+            pptCallClient,
+            FALSE
+
+            )) != 0)
+    {
+        if (ptCall)
+        {
+// BUGBUG CreatetCallAndClient: cleanup
+
+            *pptCall = (PTCALL) NULL;
+        }
+
+        return lResult;
+    }
+
+
+    try
+    {
+        WCHAR  *pszXxx;
+        DWORD   dwXxxSize = ((PTLINEAPP)
+                    ptLineClient->ptLineApp)->dwFriendlyNameSize;
+
+
+        if ((pszXxx = ServerAlloc (dwXxxSize)))
+        {
+            CopyMemory(
+                pszXxx,
+                ((PTLINEAPP) ptLineClient->ptLineApp)->pszFriendlyName,
+                dwXxxSize
+                );
+
+            ptCall->dwAppNameSize = dwXxxSize;
+            ptCall->pszAppName    = pszXxx;
+        }
+
+        // don't worry about the error case for now (will just show up in
+        // lineCallInfo as NULL app name)
+    }
+    myexcept
+    {
+        lResult = LINEERR_OPERATIONFAILED;
+// CreatetCallAndClient: cleanup
+    }
+
+    *pptCall = ptCall;
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+CreateCallMonitors(
+    PTCALL  ptCall
+    )
+{
+    //
+    // This func is called by post processing routines when
+    // a call was successfully created, or on receiving the
+    // first call state message for an incoming call, at
+    // which times we want to create call handles for any
+    // monitoring apps.
+    //
+    // Assumes tCall only has has either no clients at all
+    // or a single (owner) client
+    //
+    // Returns the # of monitor call clients created (>=0) or
+    // and error value (<0)
+    //
+
+    LONG            lResult;
+    DWORD           i;
+    TPOINTERLIST    lineClients, *pLineClients = &lineClients;
+    PTLINE          ptLine;
+    PTLINECLIENT    ptLineClientOwner;
+
+
+    //
+    // Get a list of line clients
+    //
+
+    try
+    {
+        ptLine = (PTLINE) ptCall->ptLine;
+
+        ptLineClientOwner = (PTLINECLIENT) (ptCall->ptCallClients ?
+            ((PTCALLCLIENT) ptCall->ptCallClients)->ptLineClient : NULL);
+    }
+    myexcept
+    {
+        return LINEERR_OPERATIONFAILED;
+    }
+
+    if ((lResult = GetLineClientListFromLine (ptLine, &pLineClients)))
+    {
+        return lResult;
+    }
+
+
+    //
+    // Look at each line client in the list, and if it has
+    // monitor privileges and is not the one associated with
+    // the existing owner call client then create a monitor
+    // call client
+    //
+    //
+
+    for (i = 0; i < pLineClients->dwNumUsedEntries; i++)
+    {
+        PTCALLCLIENT    ptCallClientMonitor;
+        PTLINECLIENT    ptLineClient = pLineClients->aEntries[i];
+
+
+        try
+        {
+            if (!(ptLineClient->dwPrivileges & LINECALLPRIVILEGE_MONITOR) ||
+                (ptLineClient == ptLineClientOwner))
+            {
+                continue;
+            }
+        }
+        myexcept
+        {
+            //
+            // If here the tLineClient or tCallClient was destroyed,
+            // just continue
+            //
+
+            continue;
+        }
+
+        if (CreatetCallClient(
+                ptCall,
+                ptLineClient,
+                LINECALLPRIVILEGE_MONITOR,
+                TRUE,
+                FALSE,
+                &ptCallClientMonitor,
+                TRUE
+
+                ) == 0)
+        {
+            lResult++;
+        }
+    }
+
+    if (pLineClients != &lineClients)
+    {
+        ServerFree (pLineClients);
+    }
+
+
+    //
+    // Now safely set the flag that says it's ok for other routines like
+    // lineGetNewCalls to create new call handles for apps for this call
+    //
+
+    {
+        BOOL    bCloseMutex;
+        HANDLE  hMutex;
+
+
+        if ((ptCall = WaitForExclusivetCallAccess(
+                (HTAPICALL) ptCall,
+                TCALL_KEY,
+                &hMutex,
+                &bCloseMutex,
+                0xffffffff
+                )))
+        {
+            ptCall->bCreatedInitialMonitors = TRUE;
+            MyReleaseMutex (hMutex, bCloseMutex);
+        }
+        else
+        {
+            lResult = LINEERR_OPERATIONFAILED;
+        }
+    }
+
+    return lResult;
+}
+
+
+PTREQUESTRECIPIENT
+PASCAL
+GetHighestPriorityRequestRecipient(
+    void
+    )
+{
+    BOOL               bFoundRecipientInPriorityList = FALSE;
+    WCHAR             *pszAppInPriorityList,
+                      *pszAppInPriorityListPrev = (WCHAR *) 0xffffffff;
+    PTREQUESTRECIPIENT pRequestRecipient,
+                       pHighestPriorityRequestRecipient = NULL;
+
+
+    EnterCriticalSection (&gPriorityListCritSec);
+
+    pRequestRecipient = TapiGlobals.pRequestRecipients;
+
+    while (pRequestRecipient)
+    {
+        if (TapiGlobals.pszReqMakeCallPriList &&
+
+            (pszAppInPriorityList = wcsstr(
+                TapiGlobals.pszReqMakeCallPriList,
+                pRequestRecipient->ptLineApp->pszModuleName
+                )))
+        {
+            if (pszAppInPriorityList <= pszAppInPriorityListPrev)
+            {
+                pHighestPriorityRequestRecipient = pRequestRecipient;
+                pszAppInPriorityListPrev = pszAppInPriorityList;
+
+                bFoundRecipientInPriorityList = TRUE;
+            }
+        }
+        else if (!bFoundRecipientInPriorityList)
+        {
+            pHighestPriorityRequestRecipient = pRequestRecipient;
+        }
+
+        pRequestRecipient = pRequestRecipient->pNext;
+    }
+
+    LeaveCriticalSection (&gPriorityListCritSec);
+
+    return pHighestPriorityRequestRecipient;
+}
+
+
+void
+PASCAL
+FreetCall(
+    PTCALL  ptCall
+    )
+{
+    if (ptCall->pszAppName)
+    {
+        ServerFree (ptCall->pszAppName);
+    }
+
+    if (ptCall->dwDrvCallFlags & DCF_INCOMINGCALL)
+    {
+        PerfBlock.dwCurrentIncomingCalls--;
+    }
+    else
+    {
+        PerfBlock.dwCurrentOutgoingCalls--;
+    }
+
+    ServerFree (ptCall);
+}
+
+
+void
+PASCAL
+DestroytCall(
+    PTCALL  ptCall
+    )
+{
+    BOOL    bDupedMutex;
+    DWORD   dwKey;
+    HANDLE  hMutex;
+
+
+//    DBGOUT((3, "DestroytCall: enter, ptCall=x%x", ptCall));
+
+
+    //
+    // Safely get the call's hMutex & current key, then grab the call's
+    // mutex. The two waits allow us to deal with the case where the
+    // tCall's key is either TINCOMPLETECALL_KEY or TCALL_KEY, or changing
+    // from the former to the latter (the completion proc was called)
+    //
+
+    try
+    {
+        hMutex = ptCall->hMutex;
+        dwKey = (ptCall->dwKey == TCALL_KEY ? TCALL_KEY : TINCOMPLETECALL_KEY);
+    }
+    myexcept
+    {
+        return;
+    }
+
+    if (WaitForMutex(
+            hMutex,
+            &hMutex,
+            &bDupedMutex,
+            ptCall,
+            dwKey,
+            INFINITE
+            ) ||
+
+        WaitForMutex(
+            hMutex,
+            &hMutex,
+            &bDupedMutex,
+            ptCall,
+            TCALL_KEY,
+            INFINITE
+            ))
+    {
+        if (ptCall->dwKey == TCALL_KEY ||
+            ptCall->dwKey == TINCOMPLETECALL_KEY)
+        {
+            //
+            // Invalidate the tCall
+            //
+
+            ptCall->dwKey = TZOMBIECALL_KEY;
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+
+            //
+            // If the provider has not returned from it's call-creation
+            // routine yet (i.e. TSPI_lineMakeCall) wait for it to do so
+            //
+
+            while (!(ptCall->dwDrvCallFlags & DCF_SPIRETURNED))
+            {
+                Sleep (0);
+            }
+
+
+            //
+            // Destroy all the tCallClient's
+            //
+
+            if (ptCall->ptCallClients)
+            {
+                while (ptCall->ptCallClients)
+                {
+                    DestroytCallClient (ptCall->ptCallClients);
+                }
+            }
+
+
+            //
+            // Tell the provider to close the call, but only if the hdCall
+            // is valid (we might be destroying a call that
+            // LMakeCall_PostProcess would normally destroy in the event
+            // of a failed make-call request, and we wouldn't want to pass
+            //an invalid hdCall to the driver)
+            //
+
+            if (ptCall->dwDrvCallFlags & DCF_DRVCALLVALID)
+            {
+                PTPROVIDER  ptProvider = ptCall->ptProvider;
+
+
+                if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+                {
+                    WaitForSingleObject (ptProvider->hMutex, INFINITE);
+                }
+
+                CallSP1(
+                    ptProvider->apfn[SP_LINECLOSECALL],
+                    "lineCloseCall",
+                    SP_FUNC_SYNC,
+                    (DWORD) ptCall->hdCall
+                    );
+
+                if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+                {
+                    ReleaseMutex (ptProvider->hMutex);
+                }
+            }
+
+
+            //
+            // Remove tCall from the tLine's tCall list
+            //
+
+            RemoveCallFromLineList (ptCall);
+
+
+            //
+            // If we have a dup'd mutex handle (bCloseMutex == TRUE)
+            // then we can safely go ahead and close the ptCall->hMutex
+            // since no other thread will be waiting on it (thanks to
+            // the first WaitForSingleObject in WaitForMutex).  Also
+            // release & close the dup'd handle.
+            //
+            // Otherwise, we have the actual ptCall->hMutex, and we
+            // wrap the release & close in a critical section to
+            // prevent another thread "T2" from grabbing ptCall->hMutex
+            // right after we release but right before we close.  This
+            // could result in deadlock at some point when "T2" goes to
+            // release the mutex, only to find that it's handle is bad,
+            // and thread "T3", which is waiting on the mutex (or a dup'd
+            // handle) waits forever.  (See corresponding critical
+            // section in WaitForMutex.)
+            //
+
+            WaitForMutex(
+                ptCall->hMutex,
+                &hMutex,
+                &bDupedMutex,
+                NULL,
+                0,
+                INFINITE
+                );
+
+            if (bDupedMutex)
+            {
+                CloseHandle (ptCall->hMutex);
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+            }
+            else
+            {
+                EnterCriticalSection (&gSafeMutexCritSec);
+
+                ReleaseMutex (hMutex);
+                CloseHandle (hMutex);
+
+                LeaveCriticalSection (&gSafeMutexCritSec);
+            }
+
+
+            //
+            // Free the resources
+            //
+
+            {
+                PTCONFERENCELIST    pConfList;
+
+
+// BUGBUG DestroytCall: confList stuff needs a mutex, do this up above?
+
+                if ((pConfList = ptCall->pConfList) &&
+                    (pConfList != (PTCONFERENCELIST) 0xffffffff))
+                {
+                    DWORD   i;
+
+
+                    if (pConfList->aptCalls[0] == ptCall)
+                    {
+                        //
+                        // We're destroying a conf parent so we want to zero
+                        // out the pConfList field of all the conf children,
+                        // essentially removing them from the conference.
+                        //
+
+                        TPOINTERLIST    confCallList,
+                                        *pConfCallList = &confCallList;
+
+
+                        if (GetConfCallListFromConf(
+                                pConfList,
+                                &pConfCallList
+
+                                ) == 0)
+                        {
+                            for(
+                                i = 1;
+                                i < pConfCallList->dwNumUsedEntries;
+                                i++
+                                )
+                            {
+                                SetCallConfList(
+                                    pConfCallList->aEntries[i],
+                                    NULL,
+                                    FALSE
+                                    );
+                            }
+
+                            if (pConfCallList != &confCallList)
+                            {
+                                ServerFree (pConfCallList);
+                            }
+                        }
+
+                        while (pConfList)
+                        {
+                            PTCONFERENCELIST    pNextConfList =
+                                                    pConfList->pNext;
+
+
+                            ServerFree (pConfList);
+                            pConfList = pNextConfList;
+                        }
+                    }
+                    else
+                    {
+                        //
+                        // We're destroying a conf child so we want to
+                        // remove it from the conference list
+                        //
+
+                        SetCallConfList(
+                            ptCall,
+                            (PTCONFERENCELIST) NULL,
+                            FALSE
+                            );
+                    }
+                }
+            }
+
+            FreetCall (ptCall);
+        }
+        else
+        {
+            MyReleaseMutex (hMutex, bDupedMutex);
+        }
+    }
+}
+
+
+void
+PASCAL
+DestroytCallClient(
+    PTCALLCLIENT    ptCallClient
+    )
+{
+    BOOL    bDupedMutex;
+    HANDLE  hMutex;
+    PTCALL  ptCall;
+
+
+//    DBGOUT((3, "DestroytCallClient: enter, ptCallCli=x%x", ptCallClient));
+
+    try
+    {
+        if (ptCallClient->dwKey != TINCOMPLETECALLCLIENT_KEY &&
+            ptCallClient->dwKey != TCALLCLIENT_KEY)
+        {
+            return;
+        }
+
+        ptCall = ptCallClient->ptCall;
+
+        hMutex = ptCall->hMutex;
+    }
+    myexcept
+    {
+        return;
+    }
+
+    if (WaitForMutex (hMutex, &hMutex, &bDupedMutex, NULL, 0, INFINITE))
+    {
+        if (ptCallClient->dwKey == TINCOMPLETECALLCLIENT_KEY ||
+            ptCallClient->dwKey == TCALLCLIENT_KEY)
+        {
+            BOOL        bDestroytCall = FALSE,
+                        bSendCallInfoMsgs =
+                            (ptCall->dwKey == TCALL_KEY ? TRUE : FALSE);
+
+
+            //
+            // Mark tCallClient as bad
+            //
+
+            ptCallClient->dwKey = INVAL_KEY;
+
+
+            //
+            // Munge tCall's num owners/monitors fields
+            //
+
+            if (ptCallClient->dwPrivilege == LINECALLPRIVILEGE_OWNER)
+            {
+                ptCall->dwNumOwners--;
+
+/* NOTE: per bug #20545 we're no longer auto-dropping non-IDLE calls; figured
+         this would be the wrong thing to do in a distributed system
+         dankn 02/15/96
+
+                if (ptCall->dwNumOwners == 0 &&
+                    ptCall->dwCallState != LINECALLSTATE_IDLE)
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+
+// BUG//BUG DestroytCallClient: grab provider's mutex if approp
+
+                    if (ptCall->ptProvider->apfn[SP_LINEDROPONCLOSE])
+                    {
+                        CallSP1(
+                            ptCall->ptProvider->apfn[SP_LINEDROPONCLOSE],
+                            "lineDropOnClose",
+                            SP_FUNC_SYNC,
+                            (DWORD) ptCall->hdCall
+                            );
+                    }
+                    else
+                    {
+                        CallSP4(
+                            ptCall->ptProvider->apfn[SP_LINEDROP],
+                            "lineDrop",
+                            SP_FUNC_ASYNC,
+                            (DWORD) BOGUS_REQUEST_ID,
+                            (DWORD) ptCall->hdCall,
+                            (DWORD) NULL,
+                            (DWORD) 0
+                            );
+                    }
+
+                    WaitForMutex(
+                        ptCall->hMutex,
+                        &hMutex,
+                        &bDupedMutex,
+                        NULL,
+                        0,
+                        INFINITE
+                        );
+                }
+*/
+            }
+            else
+            {
+                ptCall->dwNumMonitors--;
+
+/* NOTE: per bug #20545 we're no longer auto-dropping non-IDLE calls; figured
+         this would be the wrong thing to do in a distributed system
+         dankn 02/15/96
+
+                if (ptCall->dwNumMonitors == 0 &&
+                    ptCall->dwNumOwners == 0 &&
+                    ptCall->dwCallState != LINECALLSTATE_IDLE)
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+
+// BUGBUG DestroytCallClient: grab provider's mutex if approp
+
+                    CallSP4(
+                        ptCall->ptProvider->apfn[SP_LINEDROP],
+                        "lineDrop",
+                        SP_FUNC_ASYNC,
+                        (DWORD) BOGUS_REQUEST_ID,
+                        (DWORD) ptCall->hdCall,
+                        (DWORD) NULL,
+                        (DWORD) 0
+                        );
+
+                    WaitForMutex(
+                        ptCall->hMutex,
+                        &hMutex,
+                        &bDupedMutex,
+                        NULL,
+                        0,
+                        INFINITE
+                        );
+                }
+*/
+            }
+
+
+            //
+            // Remove it from the tCall's tCallClient list
+            //
+
+            if (ptCallClient->pNextSametCall)
+            {
+                ptCallClient->pNextSametCall->pPrevSametCall =
+                    ptCallClient->pPrevSametCall;
+            }
+
+            if (ptCallClient->pPrevSametCall)
+            {
+                ptCallClient->pPrevSametCall->pNextSametCall =
+                    ptCallClient->pNextSametCall;
+            }
+            else if (ptCallClient->pNextSametCall)
+            {
+                ptCall->ptCallClients = ptCallClient->pNextSametCall;
+            }
+            else // last call client so destroy the tCall too
+            {
+                ptCall->ptCallClients = NULL;
+                bDestroytCall = TRUE;
+            }
+
+
+            //
+            // Release the mutex, destroy the call if appropriate,
+            //  & send call info msgs
+            //
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+            if (bDestroytCall)
+            {
+                DestroytCall (ptCall);
+                bSendCallInfoMsgs = FALSE;
+            }
+
+            if (bSendCallInfoMsgs)
+            {
+                SendMsgToCallClients(
+                    ptCall,
+                    NULL,
+                    LINE_CALLINFO,
+                    (ptCallClient->dwPrivilege ==
+                        LINECALLPRIVILEGE_OWNER ?
+                        LINECALLINFOSTATE_NUMOWNERDECR :
+                        LINECALLINFOSTATE_NUMMONITORS),
+                    0,
+                    0
+                    );
+            }
+
+
+            //
+            // Remove tCallClient from the tLineClient's tCallClient list
+            //
+
+            RemoveCallClientFromLineClientList (ptCallClient);
+
+
+            //
+            // Free the tCallClient
+            //
+
+            ServerFree (ptCallClient);
+        }
+        else
+        {
+            MyReleaseMutex (hMutex, bDupedMutex);
+        }
+    }
+}
+
+
+void
+PASCAL
+DestroytLine(
+    PTLINE  ptLine,
+    BOOL    bUnconditional
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    DBGOUT((
+        3,
+        "DestroytLine: enter, ptLine=x%x, bUnconditional=%d",
+        ptLine,
+        bUnconditional
+        ));
+
+    if (WaitForExclusivetLineAccess(
+            (HTAPILINE) ptLine,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        //
+        // If the key is bad another thread is in the process of
+        // destroying this widget, so just release the mutex &
+        // return. Otherwise, if this is a conditional destroy
+        // & there are existing clients (which can happen when
+        // one app is closing the last client just as another app
+        // is creating one) just release the mutex & return.
+        // Otherwise, mark the widget as bad and proceed with
+        // the destroy; also, send CLOSE msgs to all the clients.
+        //
+
+        {
+            BOOL bExit;
+
+
+            if (ptLine->dwKey == TLINE_KEY &&
+                (bUnconditional == TRUE  ||  ptLine->ptLineClients == NULL))
+            {
+                SendMsgToLineClients (ptLine, NULL, LINE_CLOSE, 0, 0, 0);
+                ptLine->dwKey = INVAL_KEY;
+                bExit = FALSE;
+            }
+            else
+            {
+                bExit = TRUE;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+
+            if (bExit)
+            {
+                DBGOUT((
+                    3,
+                    "DestroytLine: exit, didn't destroy tLine=x%x",
+                    ptLine
+                    ));
+
+                return;
+            }
+        }
+
+
+        //
+        // Destroy all the widget's clients.  Note that we want to
+        // grab the mutex (and we don't have to dup it, since this
+        // thread will be the one to close it) each time we reference
+        // the list of clients, since another thread might be
+        // destroying a client too.
+        //
+
+        {
+            PTLINECLIENT ptLineClient;
+
+
+            hMutex = ptLine->hMutex;
+
+destroy_tLineClients:
+
+            WaitForSingleObject (hMutex, INFINITE);
+
+            ptLineClient = ptLine->ptLineClients;
+
+            ReleaseMutex (hMutex);
+
+            if (ptLineClient)
+            {
+                DestroytLineClient (ptLineClient);
+                goto destroy_tLineClients;
+            }
+        }
+
+
+        //
+        // There may yet be some tCall's hanging around, i.e. incoming
+        // calls that we have not processed the 1st call state msg for
+        // and hence have no associated owner/monitor that would have
+        // been destroyed in the loop above, so destroy any of these
+        // before proceeding
+        //
+        //
+
+        {
+            PTCALL  ptCall;
+
+
+destroy_UnownedtCalls:
+
+            WaitForSingleObject (hMutex, INFINITE);
+
+            ptCall = ptLine->ptCalls;
+
+            ReleaseMutex (hMutex);
+
+            if (ptCall)
+            {
+                DestroytCall (ptCall);
+                goto destroy_UnownedtCalls;
+            }
+        }
+
+
+        //
+        // Tell the provider to close the widget
+        //
+
+        {
+            PTPROVIDER  ptProvider = ptLine->ptProvider;
+
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                WaitForSingleObject (ptProvider->hMutex, INFINITE);
+            }
+
+            CallSP1(
+                ptProvider->apfn[SP_LINECLOSE],
+                "lineClose",
+                SP_FUNC_SYNC,
+                (DWORD) ptLine->hdLine
+                );
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                ReleaseMutex (ptProvider->hMutex);
+            }
+        }
+
+
+        //
+        // NULLify the ptLine field in the lookup entry, so LOpen will
+        // know it has to open the SP's line on the next open request
+        //
+
+        {
+            PTLINELOOKUPENTRY   pEntry;
+
+
+            pEntry = GetLineLookupEntry (ptLine->dwDeviceID);
+            pEntry->ptLine = NULL;
+        }
+
+        ServerFree (ptLine);
+    }
+
+    // PERF
+
+    if (PerfBlock.dwLinesInUse)
+    {
+        PerfBlock.dwLinesInUse--;
+    }
+    else
+    {
+        DBGOUT((10, "PERF: dwNumLinesInUse below 0"));
+    }
+
+    DBGOUT((3, "DestroytLine: exit, destroyed line=x%x", ptLine));
+}
+
+
+
+void
+PASCAL
+DestroytLineClient(
+    PTLINECLIENT    ptLineClient
+    )
+{
+    BOOL    bDupedMutex;
+    HANDLE  hMutex;
+
+
+    DBGOUT((3, "DestroytLineClient: enter, ptLineClient=x%x", ptLineClient));
+
+    if (WaitForMutex(
+            ptLineClient->hMutex,
+            &hMutex,
+            &bDupedMutex,
+            ptLineClient,
+            TLINECLIENT_KEY,
+            INFINITE
+            ))
+    {
+        PTLINE  ptLine;
+
+
+        //
+        // If the key is bad another thread is in the process of
+        // destroying this tLineClient, so just release the mutex &
+        // return. Otherwise, mark the tLineClient as bad, release
+        // the mutex, and continue on.
+        //
+
+        {
+            BOOL    bExit;
+
+
+            if (ptLineClient->dwKey == TLINECLIENT_KEY)
+            {
+                ptLineClient->dwKey = INVAL_KEY;
+
+                bExit = FALSE;
+            }
+            else
+            {
+                bExit = TRUE;
+            }
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+            if (bExit)
+            {
+                DBGOUT((3, "DestroytLineClient: bExit"));
+                return;
+            }
+        }
+
+
+        //
+        // Destroy all the tCallClients.  Note that we want to grab the
+        // mutex (and we don't have to dup it, since this thread will be
+        // the one to close it) each time we reference the list of
+        // tCallClient's, since another thread might be destroying a
+        // tCallClient too.
+        //
+
+        while (ptLineClient->ptCallClients)
+        {
+            DestroytCallClient (ptLineClient->ptCallClients);
+        }
+
+
+        //
+        // Remove tLineClient from tLineApp's list.  Note that we don't
+        // have to worry about dup-ing the mutex here because we know
+        // it's valid & won't get closed before we release it.
+        //
+
+        {
+            PTLINEAPP   ptLineApp = (PTLINEAPP) ptLineClient->ptLineApp;
+
+
+            WaitForSingleObject (ptLineApp->hMutex, INFINITE);
+
+            if (ptLineClient->pNextSametLineApp)
+            {
+                ptLineClient->pNextSametLineApp->pPrevSametLineApp =
+                    ptLineClient->pPrevSametLineApp;
+            }
+
+            if (ptLineClient->pPrevSametLineApp)
+            {
+                ptLineClient->pPrevSametLineApp->pNextSametLineApp =
+                    ptLineClient->pNextSametLineApp;
+            }
+            else
+            {
+                ptLineApp->ptLineClients = ptLineClient->pNextSametLineApp;
+            }
+
+            ReleaseMutex (ptLineApp->hMutex);
+        }
+
+
+        //
+        // Grab the tLine's mutex & start munging.  Note that we don't
+        // have to worry about dup-ing the mutex here because we know
+        // it's valid & won't get closed before we release it.
+        //
+
+        ptLine = ptLineClient->ptLine;
+        hMutex = ptLine->hMutex;
+        WaitForSingleObject (hMutex, INFINITE);
+
+
+        //
+        // If client registered as a proxy then unregister it
+        //
+
+        if (ptLineClient->dwPrivileges & LINEOPENOPTION_PROXY)
+        {
+            DWORD i;
+
+
+// BUGBUG DestroytLineClient- restore lower pri proxies
+
+            for(
+                i = LINEPROXYREQUEST_SETAGENTGROUP;
+                i <= LINEPROXYREQUEST_GETAGENTGROUPLIST;
+                i++
+                )
+            {
+                if (ptLine->apProxys[i] == ptLineClient)
+                {
+                    ptLine->apProxys[i] = NULL;
+                }
+            }
+        }
+
+
+        //
+        //
+        //
+
+        if (ptLineClient->dwExtVersion)
+        {
+            if ((--ptLine->dwExtVersionCount) == 0)
+            {
+                CallSP2(
+                    ptLine->ptProvider->apfn[SP_LINESELECTEXTVERSION],
+                    "lineSelectExtVersion",
+                    SP_FUNC_SYNC,
+                    (DWORD) ptLine->hdLine,
+                    (DWORD) 0
+                    );
+
+                ptLine->dwExtVersion = 0;
+            }
+        }
+
+
+        //
+        // Remove the tLineClient from the tLine's list & decrement
+        // the number of opens
+        //
+
+        if (ptLineClient->pNextSametLine)
+        {
+            ptLineClient->pNextSametLine->pPrevSametLine =
+                ptLineClient->pPrevSametLine;
+        }
+
+        if (ptLineClient->pPrevSametLine)
+        {
+            ptLineClient->pPrevSametLine->pNextSametLine =
+                ptLineClient->pNextSametLine;
+        }
+        else
+        {
+            ptLine->ptLineClients = ptLineClient->pNextSametLine;
+        }
+
+        ptLine->dwNumOpens--;
+
+
+        //
+        // See if we need to reset the monitored media modes or close
+        // the tLine (still hanging on the the mutex)
+        //
+
+        if (ptLine->dwKey == TLINE_KEY)
+        {
+            DBGOUT((4, "It's a line_key"));
+            if (ptLine->ptLineClients)
+            {
+                DBGOUT((4, "...and there are still clients"));
+                if (ptLine->dwOpenMediaModes && ptLineClient->dwMediaModes)
+                {
+                    DWORD           dwUnionMediaModes = 0;
+                    PTLINECLIENT    ptLineClientTmp =
+                                        ptLine->ptLineClients;
+
+
+                    while (ptLineClientTmp)
+                    {
+                        if (ptLineClientTmp->dwPrivileges &
+                                LINECALLPRIVILEGE_OWNER)
+                        {
+                            dwUnionMediaModes |=
+                                ptLineClientTmp->dwMediaModes;
+                        }
+
+                        ptLineClientTmp = ptLineClientTmp->pNextSametLine;
+                    }
+
+                    if (dwUnionMediaModes != ptLine->dwOpenMediaModes)
+                    {
+                        LONG        lResult;
+                        PTPROVIDER  ptProvider = ptLine->ptProvider;
+
+
+                        if (ptProvider->dwTSPIOptions &
+                                LINETSPIOPTION_NONREENTRANT)
+                        {
+                            WaitForSingleObject (ptProvider->hMutex, INFINITE);
+                        }
+
+                        lResult = CallSP2(
+                            ptLine->ptProvider->apfn
+                                [SP_LINESETDEFAULTMEDIADETECTION],
+                            "lineSetDefaultMediaDetection",
+                            SP_FUNC_SYNC,
+                            (DWORD) ptLine->hdLine,
+                            dwUnionMediaModes
+                            );
+
+                        if (ptProvider->dwTSPIOptions &
+                                LINETSPIOPTION_NONREENTRANT)
+                        {
+                            ReleaseMutex (ptProvider->hMutex);
+                        }
+
+                        ptLine->dwOpenMediaModes = dwUnionMediaModes;
+                    }
+                }
+
+                SendMsgToLineClients(
+                    ptLine,
+                    NULL,
+                    LINE_LINEDEVSTATE,
+                    LINEDEVSTATE_CLOSE,
+                    0,
+                    0
+                    );
+            }
+            else
+            {
+                //
+                // This was the last client so destroy the tLine too
+                //
+
+                DBGOUT((4, "...and it's the last one out"));
+
+                ReleaseMutex (hMutex);
+                hMutex = NULL;
+                DestroytLine (ptLine, FALSE); // conditional destroy
+            }
+        }
+
+        if (hMutex)
+        {
+            ReleaseMutex (hMutex);
+        }
+
+
+        //
+        // Complete any remaining
+        // proxy requests
+        //
+
+        if (ptLineClient->dwPrivileges & LINEOPENOPTION_PROXY)
+        {
+            PASYNCREQUESTINFO   pAsyncRequestInfo =
+                                    ptLineClient->pPendingProxyRequests,
+                                pNextAsyncRequestInfo;
+
+
+            while (pAsyncRequestInfo)
+            {
+                pNextAsyncRequestInfo = (PASYNCREQUESTINFO)
+                    pAsyncRequestInfo->dwParam5;
+
+                pAsyncRequestInfo->dwKey = TASYNC_KEY;
+
+                CompletionProc (pAsyncRequestInfo, LINEERR_OPERATIONUNAVAIL);
+
+                pAsyncRequestInfo = pNextAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // Now clean up the tLineClient.  Before we close ptLineClient->hMutex
+        // we want to make sure no one else is waiting on it.
+        //
+
+        WaitForMutex(
+            ptLineClient->hMutex,
+            &hMutex,
+            &bDupedMutex,
+            NULL,
+            0,
+            INFINITE
+            );
+
+        if (bDupedMutex)
+        {
+            CloseHandle (ptLineClient->hMutex);
+            ReleaseMutex (hMutex);
+            CloseHandle (hMutex);
+        }
+        else
+        {
+            EnterCriticalSection (&gSafeMutexCritSec);
+
+            ReleaseMutex (hMutex);
+            CloseHandle (hMutex);
+
+            LeaveCriticalSection (&gSafeMutexCritSec);
+        }
+
+        if (ptLineClient->aNumRings)
+        {
+            ServerFree (ptLineClient->aNumRings);
+        }
+
+        ServerFree (ptLineClient);
+    }
+#if DBG
+    else
+    {
+        DBGOUT((1, "DestroytLineClient: mutex failed!"));
+    }
+#endif
+
+
+}
+
+
+void
+PASCAL
+DestroytLineApp(
+    PTLINEAPP   ptLineApp
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    DBGOUT((3, "DestroytLineApp: enter, ptLineApp=x%x", ptLineApp));
+
+
+    if (WaitForMutex(
+            ptLineApp->hMutex,
+            &hMutex,
+            &bCloseMutex,
+            ptLineApp,
+            TLINEAPP_KEY,
+            INFINITE
+            ))
+    {
+        PTCLIENT    ptClient = (PTCLIENT) ptLineApp->ptClient;
+
+
+        //
+        // If the key is bad another thread is in the process of
+        // destroying this tLineApp, so just release the mutex &
+        // return. Otherwise, mark the tLineApp as bad, release
+        // the mutex, and continue on.
+        //
+
+        {
+            BOOL    bExit;
+
+
+            if (ptLineApp->dwKey == TLINEAPP_KEY)
+            {
+                ptLineApp->dwKey = INVAL_KEY;
+
+                bExit = FALSE;
+            }
+            else
+            {
+                bExit = TRUE;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+
+            if (bExit)
+            {
+                DBGOUT((3, "DestroytLineApp: bExit"));
+                return;
+            }
+        }
+
+
+        //
+        // Destroy all the tLineClients.  Note that we want to grab the
+        // mutex (and we don't have to dup it, since this thread will be
+        // the one to close it) each time we reference the list of
+        // tLineClient's, since another thread might be destroying a
+        // tLineClient too.
+        //
+
+        {
+            PTLINECLIENT ptLineClient;
+
+
+            hMutex = ptLineApp->hMutex;
+
+destroy_tLineClients:
+
+            WaitForSingleObject (hMutex, INFINITE);
+
+            ptLineClient = ptLineApp->ptLineClients;
+
+            ReleaseMutex (hMutex);
+
+            if (ptLineClient)
+            {
+                DestroytLineClient (ptLineClient);
+                goto destroy_tLineClients;
+            }
+        }
+
+
+        //
+        // Remove tLineApp from tClient's list. Note that we don't
+        // have to worry about dup-ing the mutex here because we know
+        // it's valid & won't get closed before we release it.
+        //
+
+        WaitForSingleObject (ptClient->hMutex, INFINITE);
+
+        if (ptLineApp->pNext)
+        {
+            ptLineApp->pNext->pPrev = ptLineApp->pPrev;
+        }
+
+        if (ptLineApp->pPrev)
+        {
+            ptLineApp->pPrev->pNext = ptLineApp->pNext;
+        }
+        else
+        {
+            ptClient->ptLineApps = ptLineApp->pNext;
+        }
+
+
+        //
+        // Clean up any existing generic dialog instances if this is the
+        // last tLineApp on this tClient
+        //
+
+        if (ptClient->pGenericDlgInsts && ptClient->ptLineApps == NULL)
+        {
+            PTAPIDIALOGINSTANCE         pGenericDlgInst =
+                                            ptClient->pGenericDlgInsts,
+                                        pNextGenericDlgInst;
+            FREEDIALOGINSTANCE_PARAMS   params =
+            {
+                0,
+                ptClient,
+                (HTAPIDIALOGINSTANCE) pGenericDlgInst,
+                LINEERR_OPERATIONFAILED
+            };
+
+
+            while (pGenericDlgInst)
+            {
+                pNextGenericDlgInst = pGenericDlgInst->pNext;
+
+                FreeDialogInstance (&params, NULL, NULL);
+
+                pGenericDlgInst = pNextGenericDlgInst;
+            }
+        }
+
+        ReleaseMutex (ptClient->hMutex);
+
+
+        //
+        // Decrement total num inits & see if we need to go thru shutdown
+        //
+
+        WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+        //assert(TapiGlobals.dwNumLineInits != 0);
+
+        TapiGlobals.dwNumLineInits--;
+
+
+        if ((TapiGlobals.dwNumLineInits == 0) &&
+            (TapiGlobals.dwNumPhoneInits == 0))
+        {
+            ServerShutdown();
+        }
+
+        ReleaseMutex (TapiGlobals.hMutex);
+
+
+        //
+        // Check to see if this tLineApp is a registered request
+        // recipient, and if so do the appropriate munging
+        //
+
+        {
+            BOOL               bResetHighestPriorityRequestRecipient;
+            PTREQUESTRECIPIENT pRequestRecipient;
+
+
+            if ((pRequestRecipient = ptLineApp->pRequestRecipient))
+            {
+                EnterCriticalSection (&gPriorityListCritSec);
+
+                bResetHighestPriorityRequestRecipient =
+                    (TapiGlobals.pHighestPriorityRequestRecipient ==
+                        pRequestRecipient ? TRUE : FALSE);
+
+                if (pRequestRecipient->pNext)
+                {
+                    pRequestRecipient->pNext->pPrev = pRequestRecipient->pPrev;
+                }
+
+                if (pRequestRecipient->pPrev)
+                {
+                    pRequestRecipient->pPrev->pNext = pRequestRecipient->pNext;
+                }
+                else
+                {
+                    TapiGlobals.pRequestRecipients = pRequestRecipient->pNext;
+                }
+
+                if (bResetHighestPriorityRequestRecipient)
+                {
+                    TapiGlobals.pHighestPriorityRequestRecipient =
+                        GetHighestPriorityRequestRecipient();
+
+                    if (TapiGlobals.pRequestMakeCallList)
+                    {
+                        if (TapiGlobals.pHighestPriorityRequestRecipient)
+                        {
+                            NotifyHighestPriorityRequestRecipient();
+                        }
+
+// BUGBUG DestroytLineApp: else if (!StartRequestRecipient())
+                        else
+                        {
+                            //
+                            // We couldn't start a request recipient so
+                            // nuke all pending request make calls
+                            //
+
+                            PTREQUESTMAKECALL   pRequestMakeCall,
+                                                pNextRequestMakeCall;
+
+
+                            pRequestMakeCall =
+                                TapiGlobals.pRequestMakeCallList;
+
+                            TapiGlobals.pRequestMakeCallList    =
+                            TapiGlobals.pRequestMakeCallListEnd = NULL;
+
+                            while (pRequestMakeCall)
+                            {
+                                pNextRequestMakeCall =
+                                    pRequestMakeCall->pNext;
+                                ServerFree (pRequestMakeCall);
+                                pRequestMakeCall =  pNextRequestMakeCall;
+                            }
+
+                            DBGOUT((
+                                2,
+                                "DestroytLineApp: deleting pending " \
+                                    "MakeCall requests"
+                                ));
+                        }
+                    }
+                }
+
+                LeaveCriticalSection (&gPriorityListCritSec);
+            }
+        }
+
+
+        //
+        // Free the resources
+        //
+
+        CloseHandle (ptLineApp->hMutex);
+
+        ServerFree (ptLineApp);
+    }
+}
+
+
+DWORD MyWToL(PWSTR lpszBuf)
+{
+    DWORD   dwReturn = 0;
+
+    while ( (*lpszBuf >= '0') && (*lpszBuf <= '9') )
+    {
+        dwReturn = dwReturn*10 + (*lpszBuf - '0');
+        lpszBuf++;
+    }
+
+    return dwReturn;
+}
+
+
+
+
+BOOL FillupACountryEntry( HKEY hKey,
+                          PBYTE  pcl,
+                          LPLINECOUNTRYENTRY pce,
+                          PBYTE *ppVarOffset
+                        )
+{
+    PBYTE  pVarOffset = *ppVarOffset;
+    DWORD  dwSize;
+    DWORD  dwType;
+
+
+    dwSize = sizeof(pce->dwCountryCode);
+    RegQueryValueExW(
+                      hKey,
+                      L"CountryCode",
+                      NULL,
+                      &dwType,
+                      (LPBYTE)&(pce->dwCountryCode),
+                      &dwSize
+                    );
+
+
+    dwSize = MAXLEN_NAME * sizeof(WCHAR);
+    RegQueryValueExW(
+                      hKey,
+                      L"Name",
+                      NULL,
+                      &dwType,
+                      pVarOffset,
+                      &dwSize
+                    );
+
+    pce->dwCountryNameOffset = pVarOffset - pcl;
+    pce->dwCountryNameSize = dwSize;
+
+    pVarOffset += dwSize;
+
+
+    dwSize = MAXLEN_RULE * sizeof(WCHAR);
+    RegQueryValueExW(
+                      hKey,
+                      L"SameAreaRule",
+                      NULL,
+                      &dwType,
+                      pVarOffset,
+                      &dwSize
+                    );
+
+    pce->dwSameAreaRuleOffset = pVarOffset - pcl;
+    pce->dwSameAreaRuleSize = dwSize;
+
+    pVarOffset += dwSize;
+
+
+    dwSize = MAXLEN_RULE * sizeof(WCHAR);
+    RegQueryValueExW(
+                      hKey,
+                      L"LongDistanceRule",
+                      NULL,
+                      &dwType,
+                      pVarOffset,
+                      &dwSize
+                    );
+
+    pce->dwLongDistanceRuleOffset = pVarOffset - pcl;
+    pce->dwLongDistanceRuleSize = dwSize;
+
+    pVarOffset += dwSize;
+
+
+    dwSize = MAXLEN_RULE * sizeof(WCHAR);
+    RegQueryValueExW(
+                      hKey,
+                      L"InternationalRule",
+                      NULL,
+                      &dwType,
+                      pVarOffset,
+                      &dwSize
+                    );
+
+    pce->dwInternationalRuleOffset =  pVarOffset - pcl;
+    pce->dwInternationalRuleSize = dwSize;
+
+    pVarOffset += dwSize;
+
+
+    *ppVarOffset = pVarOffset;
+
+    return TRUE;
+}
+
+
+
+BOOL BuildCountryRegistryListFromRC( void )
+{
+    HKEY  hKey;
+    HKEY  hKey2;
+    DWORD dwDisposition;
+    WCHAR sz[512];
+    UINT  uNumEntries;
+    DWORD dwNextCountryID;
+    HINSTANCE hInst;
+    DWORD dw;
+
+
+    hInst = GetModuleHandle (NULL);
+
+    RegOpenKeyEx(
+                  HKEY_LOCAL_MACHINE,
+                  gszRegKeyTelephony,
+                  0,
+                  KEY_READ,
+                  &hKey2
+                );
+
+    RegCreateKeyEx(
+                    hKey2,
+                    "Country List",
+                    0,
+                    NULL,
+                    REG_OPTION_NON_VOLATILE,
+                    KEY_ALL_ACCESS,
+                    NULL,
+                    &hKey,
+                    &dwDisposition
+                  );
+
+
+    RegCloseKey( hKey2 );
+
+
+    dwNextCountryID = 1;
+
+    while( dwNextCountryID )
+    {
+        if ( LoadStringW(
+                         hInst,
+                         RC_COUNTRY_ID_BASE + dwNextCountryID,
+                         sz,
+                         sizeof(sz) / sizeof(WCHAR)
+                        )  > 0
+           )
+        {
+            CHAR  szCountryKey[20];
+            PWSTR p;
+            PWSTR p2;
+
+            wsprintf( szCountryKey, "%ld", dwNextCountryID );
+
+            RegCreateKeyEx(
+                            hKey,
+                            szCountryKey,
+                            0,
+                            NULL,
+                            REG_OPTION_NON_VOLATILE,
+                            KEY_ALL_ACCESS,
+                            NULL,
+                            &hKey2,
+                            &dwDisposition
+                          );
+
+//RC_COUNTRY_ID_BASE + 1 "1,101,""United States of America"",""G"","" 1FG"",""011EFG"""
+
+
+            p = sz;
+
+
+            //
+            // Get the countryID
+            //
+            dw = MyWToL( p );
+
+            RegSetValueEx( hKey2,
+                           "CountryCode",
+                           0,
+                           REG_DWORD,
+                           (LPBYTE)&dw,
+                           sizeof(DWORD)
+                         );
+
+
+            p = wcschr( p, L',' ) + 1;
+            dwNextCountryID = MyWToL( p );
+
+
+            p = wcschr( p, L'"' ) + 1;
+            p2 = wcschr( p, L'"' );
+            *p2 = L'\0';
+
+            RegSetValueExW( hKey2,
+                            L"Name",
+                            0,
+                            REG_SZ,
+                            (LPBYTE)p,
+                            (PBYTE)p2 - (PBYTE)p + sizeof(WCHAR)
+                          );
+
+
+            p  = wcschr( p2 + 1, L'"' ) + 1;  // Point to start of rule
+            p2 = wcschr( p, L'"' );           // Point to end of rule
+            *p2 = L'\0';
+
+            RegSetValueExW( hKey2,
+                            L"SameAreaRule",
+                            0,
+                            REG_SZ,
+                            (LPBYTE)p,
+                            (PBYTE)p2 - (PBYTE)p + sizeof(WCHAR)
+                          );
+
+
+            p  = wcschr( p2 + 1, L'"' ) + 1;  // Point to start of rule
+            p2 = wcschr( p, L'"' );           // Point to end of rule
+            *p2 = L'\0';
+
+            RegSetValueExW( hKey2,
+                            L"LongDistanceRule",
+                            0,
+                            REG_SZ,
+                            (LPBYTE)p,
+                            (PBYTE)p2 - (PBYTE)p + sizeof(WCHAR)
+                          );
+
+
+            p  = wcschr( p2 + 1, L'"' ) + 1;  // Point to start of rule
+            p2 = wcschr( p, L'"' );           // Point to end of rule
+            *p2 = L'\0';
+
+            RegSetValueExW( hKey2,
+                            L"InternationalRule",
+                            0,
+                            REG_SZ,
+                            (LPBYTE)p,
+                            (PBYTE)p2 - (PBYTE)p + sizeof(WCHAR)
+                          );
+
+
+            RegCloseKey( hKey2 );
+        }
+        else
+        {
+            //
+            // BUGBUG?
+            // There should be something else we could do here, but what?
+            //
+            dwNextCountryID = 0;
+        }
+
+    }
+
+
+/*
+    LoadStringW( ExceptionsBase )
+
+    uNumEntries = MyWToL( sz );
+
+    for ( i = 0;  i < uNumCountries;  i++ )
+    {
+        if ( LoadStringW( ExceptionsBase + i )  >  0 )
+        {
+            parse and write to registry
+        }
+    }
+*/
+
+//    dwNextCountryID = 0;
+//
+//    while ( LoadStringW(
+//                     hInst,
+//                     RC_COUNTRY_EXCEPTIONS_BASE + dwNextCountryID,
+//                     sz,
+//                     sizeof(sz) / sizeof(WCHAR)
+//                    )  > 0
+//          )
+//    {
+//        PWSTR pstrRuleName;
+//        PWSTR pstrRule;
+//
+////RC_COUNTRY_EXCEPTIONS_BASE + 1 "1\\Exceptions\\95,InternationalRule,011EFG"
+//
+//        //
+//        // The stuff following the first comma is the RuleName
+//        //
+//        pstrRuleName = wcschr( sz, L',' ) + 1;
+//        
+//        //
+//        // Give the key name a terminating NULL
+//        //
+//        *(pstrRuleName - 1) = L'\0';
+//        
+//        //
+//        // The stuff following the first comma is the rule itself
+//        //
+//        pstrRule = wcschr( pstrRuleName, L',') + 1;
+//
+//        //
+//        // Give the rule name a terminating NULL
+//        //
+//        *(pstrRule - 1) = L'\0';
+//        
+//
+//        RegCreateKeyExW(
+//                        hKey,
+//                        sz,
+//                        0,
+//                        NULL,
+//                        REG_OPTION_NON_VOLATILE,
+//                        KEY_ALL_ACCESS,
+//                        NULL,
+//                        &hKey2,
+//                        &dwDisposition
+//                      );
+//
+//        RegSetValueExW( hKey2,
+//                        pstrRuleName,
+//                        0,
+//                        REG_SZ,
+//                        (LPBYTE)pstrRule,
+//                        ( lstrlenW( pstrRule ) + 1 ) * sizeof(WCHAR)
+//                      );
+//
+//
+//        RegCloseKey( hKey2 );
+//        
+//        dwNextCountryID++;
+//    }
+//
+//    RegCloseKey( hKey );
+
+    return TRUE;
+}
+
+
+
+BOOL
+BuildCountryList(
+    void
+    )
+{
+    //
+    // The following is our "last resort" country list, i.e. the one we
+    // use of we get errors trying to build the country list below
+    //
+
+    static LINECOUNTRYLIST defCountryList =
+    {
+        sizeof(LINECOUNTRYLIST),    // dwTotalSize
+        sizeof(LINECOUNTRYLIST),    // dwNeededSize
+        sizeof(LINECOUNTRYLIST),    // dwUsedSize
+        0,                          // dwNumCountries
+        0,                          // dwCountryListSize
+        0                           // dwCountryListOffset
+    };
+    BOOL bResult = TRUE;
+    UINT i;
+
+
+//    static BOOL fAintNeverDoneThat = TRUE;
+//    static HANDLE hRegistryEvent = NULL;
+//
+//
+//    if ( fAintNeverDoneThat )
+//    {
+//       hRegistryEvent = CreateEvent(
+//                    NULL,
+//                    TRUE,
+//                    FALSE,
+//                    NULL
+//                  );
+//
+//       //BUGBUG Need to kill the event when TAPISRV exits.
+//
+//
+//       RegNotifyChangeKeyValue(
+//                                hKey,
+//                                TRUE,
+//                                REG_NOTIFY_CHANGE_LAST_SET |
+//                                    REG_NOTIFY_CHANGE_NAME,
+//                                hRegistryEvent,
+//                                TRUE
+//                              );
+//    }
+
+
+    if (!gpCountryList)
+    {
+        WCHAR sz[256];
+        DWORD dwSize;
+        DWORD dwType;
+        DWORD dwListSize;
+        DWORD dwCountryId;
+        PBYTE pTempCountryList;
+        LPLINECOUNTRYENTRY pce;
+        LPLINECOUNTRYENTRY pcePrev = NULL;
+        HKEY hKey;
+        HKEY hKeyTemp;
+        UINT uNumCountries;
+        PBYTE pVarOffset;
+
+
+        #define INITIAL_COUNTRY_COUNT 256
+
+
+
+        dwListSize = sizeof(LINECOUNTRYLIST) +
+               INITIAL_COUNTRY_COUNT * (sizeof(LINECOUNTRYENTRY) + 64);
+
+        if ( NULL == (pTempCountryList = ServerAlloc(dwListSize)) )
+        {
+            bResult = FALSE;
+            DBGOUT((1, "Mem alloc failed for country list!1 (0x%lx", dwListSize));
+            goto BuildCountryList_return;
+        }
+
+
+        //
+        // Make sure the list is more-or-less there first
+        //
+        RegOpenKeyEx(
+                      HKEY_LOCAL_MACHINE,
+                      gszRegKeyTelephony,
+                      0,
+                      KEY_READ,
+                      &hKey
+                    );
+
+        //
+        // If a read on the key for country code 1 (these united states)
+        // fails, we'll assume the country list in the registry is toasted
+        //
+        if ( RegOpenKeyEx(
+                      hKey,
+                      "Country List\\1",
+                      0,
+                      KEY_READ,
+                      &hKeyTemp
+                    )
+           )
+        {
+            //
+            // (re)create it
+            //
+            BuildCountryRegistryListFromRC();
+        }
+        else
+        {
+            RegCloseKey( hKeyTemp );
+        }
+
+        RegCloseKey( hKey );
+
+        //
+        // In any case, the list is now good
+        //
+
+
+        RegOpenKeyEx(
+                      HKEY_LOCAL_MACHINE,
+                      gszRegKeyTelephony,
+                      0,
+                      KEY_READ,
+                      &hKeyTemp
+                    );
+
+        RegOpenKeyEx(
+                      hKeyTemp,
+                      "Country List",
+                      0,
+                      KEY_READ,
+                      &hKey
+                    );
+
+        RegCloseKey( hKeyTemp );
+
+
+        //
+        // Enum through the country keys and make sure there's enough room
+        // for all of the LINECOUNTRYENTRYs
+        //
+
+        pce = (LPLINECOUNTRYENTRY)(pTempCountryList +
+                                     sizeof(LINECOUNTRYLIST));
+
+        //
+        // Make pretend we already have a previous linecountryentry so we
+        // don't have to do an 'if' in the loop every time just for the
+        // special case of the first time.  (The correct number gets put
+        // into the field the second time through the loop.)
+        //
+        pcePrev = pce;
+
+        dwSize = sizeof(sz) / sizeof(WCHAR);
+
+        uNumCountries = 0;
+
+        while (
+                0 == RegEnumKeyExW(
+                                   hKey,
+                                   uNumCountries,
+                                   sz,
+                                   &dwSize,
+                                   NULL,
+                                   NULL,
+                                   NULL,
+                                   NULL
+                                  )
+              )
+        {
+
+           if (
+                 (  sizeof(LINECOUNTRYLIST) +
+                   (sizeof(LINECOUNTRYENTRY) * uNumCountries) )
+                >
+                 ( dwListSize )
+              )
+           {
+               PBYTE p;
+               UINT uOldSize;
+
+
+               uOldSize = dwListSize;
+
+               //
+               // alloc a new space
+               //
+
+               dwListSize = sizeof(LINECOUNTRYLIST) +
+                                (
+                                   (sizeof(LINECOUNTRYENTRY) + 64) 
+                                     * (uNumCountries + 25)
+                                );
+              
+               p = ServerAlloc( dwListSize );
+
+               if ( NULL == p )
+               {
+                   bResult = FALSE;
+                   DBGOUT((1, "Mem alloc failed for country list!2 (0x%lx", dwListSize));
+                   ServerFree( pTempCountryList );
+                   goto BuildCountryList_return;
+               }
+
+               CopyMemory(
+                           p,
+                           pTempCountryList,
+                           (LPBYTE)pce - pTempCountryList
+                         );
+
+               ServerFree( pTempCountryList );
+
+               pTempCountryList = p;
+
+               pce = (LPLINECOUNTRYENTRY)((LPBYTE)p + uOldSize);
+           }
+
+
+           dwCountryId = MyWToL( sz );
+
+           pce->dwCountryID = dwCountryId;
+
+           pcePrev->dwNextCountryID = dwCountryId;
+
+
+           // Prepare for next trip through the loop
+
+           pcePrev = pce;
+
+           pce++;
+
+           uNumCountries++;
+
+           dwSize = sizeof(sz) / sizeof(WCHAR);  // need to set every time :-(
+        }
+
+
+        pcePrev->dwNextCountryID = 0;
+
+
+        //
+        // Now go through and get all of the associated strings
+        //
+
+        pce = (LPLINECOUNTRYENTRY)
+                (pTempCountryList + sizeof(LINECOUNTRYLIST));
+
+        pVarOffset = pTempCountryList +
+                                 sizeof(LINECOUNTRYLIST) +
+                                 (sizeof(LINECOUNTRYENTRY) * uNumCountries);
+
+        i = 0;
+
+        while ( i < uNumCountries )
+        {
+            HKEY hKey2;
+
+
+//-->      if it can't fix MAX_SPACE, realloc it
+            if ( ((DWORD)(pVarOffset - pTempCountryList) +
+                         ((MAXLEN_NAME +
+                         MAXLEN_RULE +
+                         MAXLEN_RULE +
+                         MAXLEN_RULE +
+                         100) * sizeof(WCHAR)))    // mmmm... fudge...
+                    > dwListSize )
+            {
+               PBYTE p;
+
+               //
+               // alloc a new space
+               //
+
+               dwListSize += 1024;
+              
+               p = ServerAlloc( dwListSize );
+
+               if ( NULL == p )
+               {
+                   bResult = FALSE;
+                   DBGOUT((1, "Mem alloc failed for country list!3 (0x%lx", dwListSize));
+                   ServerFree( pTempCountryList );
+                   goto BuildCountryList_return;
+               }
+
+               CopyMemory(
+                           p,
+                           pTempCountryList,
+                           (LPBYTE)pce - pTempCountryList
+                         );
+
+               pVarOffset = (LPVOID)(p +
+                               (UINT)(pTempCountryList - pVarOffset));
+
+               ServerFree( pTempCountryList );
+
+               pTempCountryList = p;
+
+               pce = (LPLINECOUNTRYENTRY)
+                     (pTempCountryList + sizeof(LINECOUNTRYLIST) +
+                                 ( sizeof(LINECOUNTRYENTRY) * i ));
+            }
+
+
+
+            wsprintfW( sz, L"%ld", pce->dwCountryID);
+
+            RegOpenKeyExW(
+                           hKey,
+                           sz,
+                           0,
+                           KEY_READ,
+                           &hKey2
+                         );
+
+
+            FillupACountryEntry( hKey2, pTempCountryList, pce, &pVarOffset );
+
+            RegCloseKey( hKey2 );
+
+            pce++;
+            i++;
+        }
+
+
+        RegCloseKey( hKey );
+
+
+        ((LPLINECOUNTRYLIST)pTempCountryList)->dwTotalSize =
+                      (DWORD)(pVarOffset - pTempCountryList);
+
+        ((LPLINECOUNTRYLIST)pTempCountryList)->dwNeededSize = 
+                      (DWORD)(pVarOffset - pTempCountryList);
+
+        ((LPLINECOUNTRYLIST)pTempCountryList)->dwUsedSize =
+                      (DWORD)(pVarOffset - pTempCountryList);
+
+        ((LPLINECOUNTRYLIST)pTempCountryList)->dwNumCountries = uNumCountries;
+
+        ((LPLINECOUNTRYLIST)pTempCountryList)->dwCountryListSize =
+                                 uNumCountries * sizeof(LINECOUNTRYENTRY);
+
+        ((LPLINECOUNTRYLIST)pTempCountryList)->dwCountryListOffset =
+                                          sizeof(LINECOUNTRYLIST);
+
+
+        gpCountryList = (LPLINECOUNTRYLIST)pTempCountryList;
+    }
+
+/*
+        //
+        // Build the country list
+        //
+
+        DWORD               dwNextCountryID = 1,
+                            dwNumCountries = 0,
+                            dwCountryListSize = 4096,
+                            dwVarDataSize = 4096,
+                            dwFixedSize,
+                            dwVarDataOffset = 0,
+                            i;
+
+        HINSTANCE           hInst = (HINSTANCE) GetModuleHandle (NULL);
+        LPLINECOUNTRYENTRY  pCountryEntry;
+        LPLINECOUNTRYLIST   pCountryList = ServerAlloc (dwCountryListSize);
+        LPBYTE              pVarData = ServerAlloc (dwVarDataSize);
+
+
+        if (!pCountryList || !pVarData)
+        {
+            bResult = FALSE;
+            goto BuildCountryList_return;
+        }
+
+        pCountryEntry = (LPLINECOUNTRYENTRY)
+            (((LPBYTE) pCountryList) + sizeof(LINECOUNTRYLIST));
+
+        while (dwNextCountryID != 0)
+        {
+            WCHAR   szCountryInfo[256],
+                   *p = szCountryInfo;
+            LPDWORD pdwXxxSize;
+
+
+            //
+            // Get next country info string
+            //
+
+            if (LoadStringW(
+                    hInst,
+                    RC_COUNTRY_ID_BASE + dwNextCountryID,
+                    szCountryInfo,
+                    256
+                    ) == 0)
+            {
+                DBGOUT((
+                    3,
+                    "BuildCountryList: LoadString failed, err=%ld",
+                    GetLastError()
+                    ));
+
+                ServerFree (pCountryList);
+                ServerFree (pVarData);
+                bResult = FALSE;
+                goto BuildCountryList_return;
+            }
+
+            //
+            // Increment the number of countries & make sure our buffer is
+            // large enough
+            //
+
+            dwNumCountries++;
+
+            if ((dwNumCountries * sizeof(LINECOUNTRYENTRY) +
+                    sizeof(LINECOUNTRYLIST)) > dwCountryListSize)
+            {
+                LPLINECOUNTRYLIST   pTmpCountryList;
+
+
+                if (!(pTmpCountryList = ServerAlloc (dwCountryListSize * 2)))
+                {
+                    ServerFree (pCountryList);
+                    ServerFree (pVarData);
+                    bResult = FALSE;
+                    goto BuildCountryList_return;
+                }
+
+                CopyMemory (pTmpCountryList, pCountryList, dwCountryListSize);
+
+                ServerFree (pCountryList);
+
+                pCountryList = pTmpCountryList;
+
+                dwCountryListSize *= 2;
+
+                pCountryEntry = (LPLINECOUNTRYENTRY)
+                    (((LPBYTE) pCountryList) + sizeof(LINECOUNTRYLIST) +
+                        (dwNumCountries - 1) * sizeof(LINECOUNTRYENTRY));
+            }
+
+
+            //
+            // Initialize all the country entry DWORD fields
+            //
+
+            pCountryEntry->dwCountryID = dwNextCountryID;
+
+            pCountryEntry->dwCountryCode = (DWORD) _wtoi (p);
+            p = wcschr(p, ',');
+            p++;
+
+            dwNextCountryID =
+            pCountryEntry->dwNextCountryID = (DWORD) _wtoi (p);
+            p = wcschr(p, '\"');
+            p++;
+
+
+            //
+            // Initialize all the country entry string fields
+            //
+
+            pdwXxxSize = &pCountryEntry->dwCountryNameSize;
+
+            for (i = 0; i < 4; i++)
+            {
+                WCHAR *p2 = wcschr (p, '\"');
+
+
+                *p2 = 0;
+                *pdwXxxSize       = (wcslen (p) + 1) * sizeof(WCHAR);
+                *(pdwXxxSize + 1) = dwVarDataOffset;
+
+                if ((dwVarDataOffset + *pdwXxxSize) > dwVarDataSize)
+                {
+                    LPBYTE   pTmpVarData;
+
+
+                    if (!(pTmpVarData = ServerAlloc (dwVarDataSize * 2)))
+                    {
+                        ServerFree (pCountryList);
+                        ServerFree (pVarData);
+                        bResult = FALSE;
+                        goto BuildCountryList_return;
+                    }
+
+                    CopyMemory (pTmpVarData, pVarData, dwVarDataSize);
+
+                    ServerFree (pVarData);
+
+                    pVarData = pTmpVarData;
+
+                    dwVarDataSize *= 2;
+                }
+
+                wcscpy ((PWSTR)(pVarData + dwVarDataOffset), p);
+
+                dwVarDataOffset += *pdwXxxSize;
+
+                p = p2 + 3; // ","
+
+                pdwXxxSize++;
+                pdwXxxSize++;
+            }
+
+            pCountryEntry++;
+        }
+
+
+        //
+        // Alloc a global buffer, initialize it, and copy the fixed
+        // & var data into it
+        //
+
+        dwFixedSize = sizeof(LINECOUNTRYLIST) +
+            dwNumCountries * sizeof(LINECOUNTRYENTRY);
+
+        if (!(gpCountryList = ServerAlloc (dwFixedSize + dwVarDataOffset)))
+        {
+            ServerFree (pCountryList);
+            ServerFree (pVarData);
+            bResult = FALSE;
+            goto BuildCountryList_return;
+        }
+
+        CopyMemory(
+            (LPBYTE) gpCountryList,
+            (LPBYTE) pCountryList,
+            dwFixedSize
+            );
+
+        CopyMemory(
+            ((LPBYTE) gpCountryList) + dwFixedSize,
+            (LPBYTE) pVarData,
+            dwVarDataOffset
+            );
+
+        gpCountryList->dwTotalSize  =
+        gpCountryList->dwNeededSize =
+        gpCountryList->dwUsedSize   = dwFixedSize + dwVarDataOffset;
+
+        gpCountryList->dwNumCountries      = dwNumCountries;
+        gpCountryList->dwCountryListSize   =
+            dwNumCountries * sizeof(LINECOUNTRYENTRY);
+        gpCountryList->dwCountryListOffset = sizeof(LINECOUNTRYLIST);
+
+        ServerFree (pCountryList);
+        ServerFree (pVarData);
+
+
+        //
+        // Add the fixed size offset to the dwXxxOffset fields of all
+        // the country entries
+        //
+
+        pCountryEntry = (LPLINECOUNTRYENTRY)
+            (((LPBYTE) gpCountryList) + gpCountryList->dwCountryListOffset);
+
+        for (i = 0; i < dwNumCountries; i++)
+        {
+            pCountryEntry->dwCountryNameOffset       += dwFixedSize;
+            pCountryEntry->dwSameAreaRuleOffset      += dwFixedSize;
+            pCountryEntry->dwLongDistanceRuleOffset  += dwFixedSize;
+            pCountryEntry->dwInternationalRuleOffset += dwFixedSize;
+
+            pCountryEntry++;
+        }
+    }
+*/
+
+
+
+BuildCountryList_return:
+
+    if (bResult == FALSE)
+    {
+        gpCountryList = &defCountryList;
+    }
+
+    return bResult;
+}
+
+
+PTLINECLIENT
+PASCAL
+GetHighestPriorityLineClient(
+    PTLINE  ptLine,
+    DWORD   dwMediaModes,
+    DWORD   dwAddressID
+    )
+{
+    WCHAR          *pszPriorityList,
+                   *pszAppInPriorityList,
+                   *pszAppInPriorityListPrev = (WCHAR *) 0xffffffff;
+    BOOL            bFoundOwnerInPriorityList = FALSE;
+    DWORD           dwMaskBit, dwPriorityListIndex, i;
+    TPOINTERLIST    lineClientList, *pLineClientList = &lineClientList;
+    PTLINECLIENT    ptHiPriLineClient = (PTLINECLIENT) NULL;
+
+
+    if (GetLineClientListFromLine(
+            ptLine,
+            &pLineClientList
+
+            ) != 0)
+    {
+        return NULL;
+    }
+
+    for(
+        dwMaskBit = LINEMEDIAMODE_UNKNOWN, dwPriorityListIndex = 1;
+        dwMediaModes;
+        dwMaskBit <<= 1, dwPriorityListIndex++
+        )
+    {
+        if (dwMaskBit & dwMediaModes)
+        {
+            //
+            // See if there's a non-empty priority list for this media
+            // mode, and if so safely make a local copy of it
+            //
+
+            EnterCriticalSection (&gPriorityListCritSec);
+
+            {
+                WCHAR *pszGlobalPriList;
+
+
+                if ((pszGlobalPriList =
+                        TapiGlobals.apszPriorityList[dwPriorityListIndex]))
+                {
+                    if (!(pszPriorityList = ServerAlloc( sizeof(WCHAR) * 
+                            (1 + lstrlenW(pszGlobalPriList))
+                            )))
+                    {
+                    }
+
+                    lstrcpyW(pszPriorityList, pszGlobalPriList);
+                }
+                else
+                {
+                    pszPriorityList = NULL;
+                }
+            }
+
+            LeaveCriticalSection (&gPriorityListCritSec);
+
+
+            //
+            // Step thru the list of line clients (youngest client at head
+            // of list, oldest at tail) and look for the oldest & highest
+            // priority owner.  Position in pri list takes precedence
+            // over "age" of line client.
+            //
+            // To be considered for ownership a line client must have owner
+            // privileges and be registered for (one of) the call's media
+            // mode(s).  In addition, if the line client was opened with
+            // the SINGLEADDRESS option and the calling function specified
+            // a valid address ID (not 0xffffffff), the line client's single
+            // address ID must match that which was passed in.
+            //
+
+            for (i = 0; i < pLineClientList->dwNumUsedEntries; i++)
+            {
+                PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                    pLineClientList->aEntries[i];
+
+                try
+                {
+                    if ((ptLineClient->dwPrivileges &
+                            LINECALLPRIVILEGE_OWNER)  &&
+
+                        (ptLineClient->dwMediaModes & dwMaskBit) &&
+
+
+                        // most common case, line opened for all addrs
+
+                        ((ptLineClient->dwAddressID == 0xffffffff) ||
+
+
+                        // line opened for single addr, check if match
+
+                        (ptLineClient->dwAddressID == dwAddressID) ||
+
+
+                        // called from lineHandoff, addr ID irrelevent
+
+                        (dwAddressID == 0xffffffff)))
+                    {
+                        if (pszPriorityList &&
+
+                            (pszAppInPriorityList = wcsstr(
+                                pszPriorityList,
+                                ((PTLINEAPP) ptLineClient->ptLineApp)
+                                    ->pszModuleName
+                                )))
+                        {
+                            //
+                            // See if this app has higher pri
+                            // than the previous app we found,
+                            // and if so save the info
+                            //
+
+                            if (pszAppInPriorityList <=
+                                    pszAppInPriorityListPrev)
+                            {
+                                ptHiPriLineClient = ptLineClient;
+
+                                pszAppInPriorityListPrev  =
+                                    pszAppInPriorityList;
+                                bFoundOwnerInPriorityList = TRUE;
+                            }
+                        }
+                        else if (!bFoundOwnerInPriorityList)
+                        {
+                            ptHiPriLineClient = ptLineClient;
+                        }
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+
+
+            //
+            // If we alloc'd a local pri list above then free it
+            //
+
+            if (pszPriorityList)
+            {
+                ServerFree (pszPriorityList);
+            }
+        }
+
+        if (ptHiPriLineClient != NULL)
+        {
+            break;
+        }
+
+        dwMediaModes &= ~dwMaskBit;
+    }
+
+    if (pLineClientList != &lineClientList)
+    {
+        ServerFree (pLineClientList);
+    }
+
+    return ptHiPriLineClient;
+}
+
+
+LONG
+PASCAL
+LineProlog(
+    PTCLIENT    ptClient,
+    DWORD       dwArgType,
+    DWORD       dwArg,
+    LPVOID      phdXxx,
+    DWORD       dwPrivilege,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTSPIFuncIndex,
+    FARPROC    *ppfnTSPI_lineXxx,
+    PASYNCREQUESTINFO  *ppAsyncRequestInfo,
+    DWORD       dwRemoteRequestID
+#if DBG
+    ,char      *pszFuncName
+#endif
+    )
+{
+    LONG        lResult = 0;
+    PTPROVIDER  ptProvider;
+
+
+    DBGOUT((3, "LineProlog: (line%s) enter", pszFuncName));
+
+    *phMutex = NULL;
+    *pbDupedMutex = FALSE;
+
+    if (ppAsyncRequestInfo)
+    {
+        *ppAsyncRequestInfo = (PASYNCREQUESTINFO) NULL;
+    }
+
+    if (TapiGlobals.dwNumLineInits == 0)
+    {
+        lResult = LINEERR_UNINITIALIZED;
+        goto LineProlog_exit;
+    }
+
+    switch (dwArgType)
+    {
+    case ANY_RT_HCALL:
+    {
+        try
+        {
+            PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) dwArg;
+
+
+            if (IsBadPtrKey (ptCallClient, TCALLCLIENT_KEY) ||
+                (ptCallClient->ptClient != ptClient))
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+                goto LineProlog_exit;
+            }
+
+            ptProvider = ptCallClient->ptCall->ptProvider;
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                if (!WaitForMutex(
+                        ptProvider->hMutex,
+                        phMutex,
+                        pbDupedMutex,
+                        ptProvider,
+                        TPROVIDER_KEY,
+                        INFINITE
+                        ))
+                {
+                    lResult = LINEERR_OPERATIONFAILED;
+                    goto LineProlog_exit;
+                }
+            }
+
+            *((HDRVCALL *) phdXxx) = ptCallClient->ptCall->hdCall;
+
+            if (ptCallClient->dwPrivilege < dwPrivilege)
+            {
+                lResult = LINEERR_NOTOWNER;
+                goto LineProlog_exit;
+            }
+
+            if (ptCallClient->dwKey != TCALLCLIENT_KEY)
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+                goto LineProlog_exit;
+            }
+        }
+        myexcept
+        {
+            lResult = LINEERR_INVALCALLHANDLE;
+            goto LineProlog_exit;
+        }
+
+
+        break;
+    }
+    case ANY_RT_HLINE:
+    {
+        try
+        {
+            PTLINECLIENT    ptLineClient = (PTLINECLIENT) dwArg;
+
+
+            if (IsBadPtrKey (ptLineClient, TLINECLIENT_KEY) ||
+                (ptLineClient->ptClient != ptClient))
+            {
+                lResult = LINEERR_INVALLINEHANDLE;
+                goto LineProlog_exit;
+            }
+
+            ptProvider = ptLineClient->ptLine->ptProvider;
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                if (!WaitForMutex(
+                        ptProvider->hMutex,
+                        phMutex,
+                        pbDupedMutex,
+                        ptProvider,
+                        TPROVIDER_KEY,
+                        INFINITE
+                        ))
+                {
+                    lResult = LINEERR_OPERATIONFAILED;
+                    goto LineProlog_exit;
+                }
+            }
+
+            *((HDRVLINE *) phdXxx) = ptLineClient->ptLine->hdLine;
+
+            if ((ptLineClient->dwKey != TLINECLIENT_KEY) ||
+                (ptLineClient->ptClient != ptClient))
+            {
+                lResult = LINEERR_INVALLINEHANDLE;
+                goto LineProlog_exit;
+            }
+        }
+        myexcept
+        {
+            lResult = LINEERR_INVALLINEHANDLE;
+            goto LineProlog_exit;
+        }
+
+        break;
+    }
+    case DEVICE_ID:
+    {
+        PTLINELOOKUPENTRY   pLineLookupEntry;
+
+
+        if (dwArg && !IsValidLineApp ((HLINEAPP) dwArg, ptClient))
+        {
+            lResult = LINEERR_INVALAPPHANDLE;
+            goto LineProlog_exit;
+        }
+
+        if (!(pLineLookupEntry = GetLineLookupEntry (dwPrivilege)))
+        {
+            lResult = LINEERR_BADDEVICEID;
+            goto LineProlog_exit;
+        }
+
+        if (pLineLookupEntry->bRemoved)
+        {
+            lResult = LINEERR_NODEVICE;
+            goto LineProlog_exit;
+        }
+
+        if (!(ptProvider = pLineLookupEntry->ptProvider))
+        {
+            lResult = LINEERR_NODRIVER;
+            goto LineProlog_exit;
+        }
+
+// BUGBUG LineProlog: wrap tProvider access in try/except
+
+        if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+        {
+            if (!WaitForMutex(
+                    ptProvider->hMutex,
+                    phMutex,
+                    pbDupedMutex,
+                    ptProvider,
+                    TPROVIDER_KEY,
+                    INFINITE
+                    ))
+            {
+                lResult = LINEERR_OPERATIONFAILED;
+                goto LineProlog_exit;
+            }
+        }
+
+        break;
+    }
+    } // switch
+
+
+    //
+    // Make sure that if caller wants a pointer to a TSPI proc that the
+    // func is exported by the provider
+    //
+
+    if (ppfnTSPI_lineXxx &&
+        !(*ppfnTSPI_lineXxx = ptProvider->apfn[dwTSPIFuncIndex]))
+    {
+        lResult = LINEERR_OPERATIONUNAVAIL;
+        goto LineProlog_exit;
+    }
+
+
+    //
+    // See if we need to alloc & init an ASYNCREQUESTINFO struct
+    //
+
+    if (ppAsyncRequestInfo)
+    {
+        PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+        if (!(pAsyncRequestInfo = ServerAlloc (sizeof(ASYNCREQUESTINFO))))
+        {
+            lResult = LINEERR_NOMEM;
+            goto LineProlog_exit;
+        }
+
+        pAsyncRequestInfo->dwKey    = TASYNC_KEY;
+        pAsyncRequestInfo->ptClient = ptClient;
+
+
+        if (dwArgType == ANY_RT_HCALL)
+        {
+            PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                ((PTCALLCLIENT) dwArg)->ptLineClient;
+
+
+            pAsyncRequestInfo->pInitData      = (DWORD)
+                ((PTLINEAPP) ptLineClient->ptLineApp)->lpfnCallback;
+            pAsyncRequestInfo->dwCallbackInst =
+                ptLineClient->dwCallbackInstance;
+        }
+        else if (dwArgType == ANY_RT_HLINE)
+        {
+            pAsyncRequestInfo->pInitData      = (DWORD)
+                ((PTLINEAPP) ((PTLINECLIENT) dwArg)->ptLineApp)->lpfnCallback;
+            pAsyncRequestInfo->dwCallbackInst =
+                ((PTLINECLIENT) dwArg)->dwCallbackInstance;
+        }
+        else
+        {
+            pAsyncRequestInfo->pInitData = (DWORD)
+                ((PTLINEAPP) dwArg)->lpfnCallback;
+            pAsyncRequestInfo->dwCallbackInst = 0;
+        }
+
+        pAsyncRequestInfo->bLineFunc = TRUE;
+
+        if (dwRemoteRequestID)
+        {
+            lResult = pAsyncRequestInfo->dwRequestID = dwRemoteRequestID;
+        }
+        else
+        {
+            EnterCriticalSection (&gRequestIDCritSec);
+
+            lResult =
+            pAsyncRequestInfo->dwRequestID = TapiGlobals.dwAsyncRequestID;
+
+            if (++TapiGlobals.dwAsyncRequestID & 0x80000000)
+            {
+                TapiGlobals.dwAsyncRequestID = 1;
+            }
+
+            LeaveCriticalSection (&gRequestIDCritSec);
+        }
+
+        *ppAsyncRequestInfo = pAsyncRequestInfo;
+    }
+
+LineProlog_exit:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "LineProlog: (line%s) exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (lResult, szResult)
+            ));
+    }
+#endif
+
+    return lResult;
+}
+
+
+void
+PASCAL
+LineEpilogSync(
+    LONG   *plResult,
+    HANDLE  hMutex,
+    BOOL    bCloseMutex
+#if DBG
+    ,char *pszFuncName
+#endif
+    )
+{
+    MyReleaseMutex (hMutex, bCloseMutex);
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "LineEpilogSync: (line%s) exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (*plResult, szResult)
+            ));
+    }
+#endif
+}
+
+
+void
+PASCAL
+LineEpilogAsync(
+    LONG   *plResult,
+    LONG    lRequestID,
+    HANDLE  hMutex,
+    BOOL    bCloseMutex,
+    PASYNCREQUESTINFO pAsyncRequestInfo
+#if DBG
+    ,char *pszFuncName
+#endif
+    )
+{
+    MyReleaseMutex (hMutex, bCloseMutex);
+
+
+    if (lRequestID > 0)
+    {
+        if (*plResult != (LONG) pAsyncRequestInfo)
+        {
+            //
+            // If here the service provider returned an error (or 0,
+            // which it never should for async requests), so call
+            // CompletionProcSP like the service provider normally
+            // would, & the worker thread will take care of sending
+            // the client a REPLY msg with the request result (we'll
+            // return an async request id)
+            //
+
+            CompletionProcSP ((DWORD) pAsyncRequestInfo, *plResult);
+        }
+    }
+    else if (pAsyncRequestInfo != NULL)
+    {
+        //
+        // If here an error occured before we even called the service
+        // provider, so just free the async request (the error will
+        // be returned to the client synchronously)
+        //
+
+        ServerFree (pAsyncRequestInfo);
+    }
+
+    *plResult = lRequestID;
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "LineEpilogAsync: (line%s) exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (lRequestID, szResult)
+            ));
+    }
+#endif
+}
+
+
+void
+PASCAL
+LineEventProc(
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    switch (dwMsg)
+    {
+    case LINE_ADDRESSSTATE:
+    case LINE_LINEDEVSTATE:
+    case LINE_DEVSPECIFIC:
+    case LINE_DEVSPECIFICFEATURE:
+
+// BUGBUG: if LINE_LINEDEVSTATE\CAPSCHG get num addr id's again
+
+        SendMsgToLineClients(
+            (PTLINE) htLine,
+            NULL,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        break;
+
+    case LINE_CLOSE:
+
+        DestroytLine ((PTLINE) htLine, TRUE); // unconditional destroy
+        break;
+
+    case LINE_CALLDEVSPECIFIC:
+    case LINE_CALLDEVSPECIFICFEATURE:
+    case LINE_CALLINFO:
+
+        switch (dwMsg)
+        {
+        case LINE_CALLDEVSPECIFIC:
+
+            dwMsg = LINE_DEVSPECIFIC;
+            break;
+
+        case LINE_CALLDEVSPECIFICFEATURE:
+
+            dwMsg = LINE_DEVSPECIFICFEATURE;
+            break;
+
+        case LINE_CALLINFO:
+
+            dwParam2 =
+            dwParam3 = 0;
+            break;
+        }
+
+        SendMsgToCallClients(
+            (PTCALL) htCall,
+            NULL,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        break;
+
+    case LINE_MONITORDIGITS:
+    case LINE_MONITORMEDIA:
+
+// BUGBUG LINE_MONITORDIGITS\MEDIA: only send these msgs to callCli's that
+//                                  have the corresponding bits enabled
+
+        SendMsgToCallClients(
+            (PTCALL) htCall,
+            NULL,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            (dwParam3 ? dwParam3 : (DWORD) GetTickCount())
+            );
+
+        break;
+
+    case LINE_CALLSTATE:
+    {
+        BOOL    bDupedMutex;
+        HANDLE  hMutex;
+        PTCALL  ptCall = (PTCALL) htCall;
+
+
+        if ((ptCall = WaitForExclusivetCallAccess(
+                htCall,
+                TCALL_KEY,
+                &hMutex,
+                &bDupedMutex,
+                INFINITE
+                )))
+        {
+            PTCALLCLIENT    ptCallClient = (PTCALLCLIENT)ptCall->ptCallClients;
+            ASYNCEVENTMSG   msg;
+
+            if (dwParam1 == LINECALLSTATE_OFFERING)
+            {
+                ptCall->dwDrvCallFlags |= DCF_INCOMINGCALL;
+                PerfBlock.dwCurrentIncomingCalls++;
+                PerfBlock.dwTotalIncomingCalls++;
+                PerfBlock.dwCurrentOutgoingCalls--;
+                PerfBlock.dwTotalOutgoingCalls--;
+            }
+
+            if (ptCall->bAlertApps)
+            {
+                //
+                // This is the first state msg we've received for an incoming
+                // call.  We need to determine who owns & who monitors it,
+                // and create the appropriate tCallClients
+                //
+
+                DWORD           dwMediaModes = dwParam3;
+                PTLINECLIENT    ptLineClientOwner;
+
+
+                ptCall->bAlertApps = FALSE;
+
+
+                //
+                // Find out which address the call is on
+                //
+
+                // BUGBUG mutex if req'b by SP
+
+                CallSP2(
+                    ptCall->ptProvider->apfn[SP_LINEGETCALLADDRESSID],
+                    "lineGetCallAddressID",
+                    SP_FUNC_SYNC,
+                    (DWORD) ptCall->hdCall,
+                    (DWORD) (&ptCall->dwAddressID)
+                    );
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+
+                //
+                // Add the UNKNOWN bit if >1 bit set
+                //
+
+                if (!IsOnlyOneBitSetInDWORD (dwMediaModes) ||
+                    dwMediaModes == 0)
+                {
+                    dwMediaModes |= LINEMEDIAMODE_UNKNOWN;
+                }
+
+
+                //
+                // Try to find an owner.  If no owner found then destroy
+                // the tCall.
+                //
+
+LINE_CALLSTATE_findOwner:
+
+                if ((ptLineClientOwner = GetHighestPriorityLineClient(
+                        (PTLINE) htLine,
+                        dwMediaModes,
+                        ptCall->dwAddressID
+                        )))
+                {
+                    LONG         lResult;
+                    PTCALLCLIENT ptCallClientOwner;
+
+
+                    if ((lResult = CreatetCallClient(
+                            ptCall,
+                            ptLineClientOwner,
+                            LINECALLPRIVILEGE_OWNER,
+                            TRUE,
+                            FALSE,
+                            &ptCallClientOwner,
+                            TRUE
+
+                            )) != 0)
+                    {
+                        if (lResult == LINEERR_INVALLINEHANDLE)
+                        {
+                            //
+                            // The tLineClient was just closed, so jump
+                            // up top & try to find another owner
+                            //
+
+                            goto LINE_CALLSTATE_findOwner;
+                        }
+                        else
+                        {
+                            //
+                            // No mem, line closed, etc
+                            //
+
+                            DestroytCall (ptCall);
+
+                            return;
+                        }
+                    }
+                }
+
+                if (CreateCallMonitors (ptCall) <= 0 && !ptLineClientOwner)
+                {
+                    DestroytCall (ptCall);
+
+                    return;
+                }
+
+                if (!WaitForExclusivetCallAccess(
+                        htCall,
+                        TCALL_KEY,
+                        &hMutex,
+                        &bDupedMutex,
+                        INFINITE
+                        ))
+                {
+                    return;
+                }
+            }
+
+
+/* NOTE: per bug #20545 we're no longer auto-dropping non-IDLE calls; figured
+         this would be the wrong thing to do in a distributed system
+         dankn 02/15/96
+
+            //
+            // If there isn't an owner for this call & the state is something
+            // other than IDLE or OFFERING then drop the call (otherwise no
+            // app has "responsibility" for it)
+            //
+
+            if (ptCall->dwNumOwners == 0 &&
+                !(dwParam1 & (LINECALLSTATE_IDLE | LINECALLSTATE_OFFERING)))
+            {
+
+// BUG//BUG LINE_CALLSTATE: grab provider mutex if needed
+
+                if (ptCall->ptProvider->apfn[SP_LINEDROPNOOWNER])
+                {
+                    CallSP1(
+                        ptCall->ptProvider->apfn[SP_LINEDROPNOOWNER],
+                        "lineDropNoOwner",
+                        SP_FUNC_SYNC,
+                        (DWORD) ptCall->hdCall
+                        );
+                }
+                else
+                {
+                    CallSP4(
+                        ptCall->ptProvider->apfn[SP_LINEDROP],
+                        "lineDrop",
+                        SP_FUNC_ASYNC,
+                        (DWORD) BOGUS_REQUEST_ID,
+                        (DWORD) ptCall->hdCall,
+                        (DWORD) NULL,
+                        (DWORD) 0
+                        );
+                }
+                MyReleaseMutex (hMutex, bDupedMutex);
+                return;
+            }
+*/
+
+            //
+            // SP-initiated conference
+            //
+
+            if (dwParam1 == LINECALLSTATE_CONFERENCED)
+            {
+                if (!ptCall->pConfList)
+                {
+                    PTCALL              ptConfCall = (PTCALL) dwParam2;
+                    PTCONFERENCELIST    pConfList;
+
+
+                    ptCall->pConfList = (LPVOID) 0xffffffff;
+
+                    MyReleaseMutex (hMutex, bDupedMutex);
+
+                    if (WaitForExclusivetCallAccess(
+                            (HTAPICALL) dwParam2,
+                            TCALL_KEY,
+                            &hMutex,
+                            &bDupedMutex,
+                            INFINITE
+                            ))
+                    {
+                        ptConfCall = (PTCALL) dwParam2;
+
+                        if (!ptConfCall->pConfList)
+                        {
+                            if ((pConfList = ServerAlloc(
+                                    sizeof (TCONFERENCELIST) + sizeof(PTCALL) *
+                                        (DEF_NUM_CONF_LIST_ENTRIES - 1)
+                                    )))
+                            {
+                                pConfList->dwKey = TCONFLIST_KEY;
+                                pConfList->dwNumTotalEntries =
+                                    DEF_NUM_CONF_LIST_ENTRIES;
+                                pConfList->dwNumUsedEntries  = 1;
+
+                                pConfList->aptCalls[0] = ptConfCall;
+
+                                ptConfCall->pConfList = pConfList;
+                            }
+                        }
+
+                        pConfList = ptConfCall->pConfList;
+
+                        MyReleaseMutex (hMutex, bDupedMutex);
+                    }
+                    else
+                    {
+                        pConfList = NULL;
+                    }
+
+                    SetCallConfList (ptCall, pConfList, TRUE);
+
+                    if (!WaitForExclusivetCallAccess(
+                            htCall,
+                            TCALL_KEY,
+                            &hMutex,
+                            &bDupedMutex,
+                            INFINITE
+                            ))
+                    {
+                        return;
+                    }
+                }
+            }
+
+
+            //
+            // If call is a conference child and the call state has
+            // changed then remove it from the conference
+            //
+
+// BUGBUG LINE_CALLSTATE: conf list race conditions
+
+            else if (ptCall->pConfList  &&
+                     ptCall->pConfList != (PTCONFERENCELIST) 0xffffffff)
+            {
+                try
+                {
+                    if (((PTCONFERENCELIST) ptCall->pConfList)->aptCalls[0]
+                            != ptCall)
+                    {
+                        SetCallConfList (ptCall, NULL, FALSE);
+                    }
+                }
+                myexcept
+                {
+                }
+            }
+
+
+            //
+            //
+            //
+
+            ptCall->dwCallState     = dwParam1;
+            ptCall->dwCallStateMode = dwParam2;
+
+
+            //
+            // Send the CALLSTATE msg to all the clients
+            //
+
+            msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+            msg.pfnPostProcessProc = 0;
+            msg.dwMsg              = dwMsg;
+            msg.dwParam1           = dwParam1;
+            msg.dwParam2           = dwParam2;
+
+            ptCallClient = ptCall->ptCallClients;
+
+            while (ptCallClient)
+            {
+                PTLINECLIENT    ptLineClient;
+                PTLINEAPP       ptLineApp;
+
+
+                ptLineClient = (PTLINECLIENT) ptCallClient->ptLineClient;
+                ptLineApp    = (PTLINEAPP) ptLineClient->ptLineApp;
+
+                msg.pInitData      = (DWORD) ptLineApp->lpfnCallback;
+                msg.hDevice        = (DWORD) ptCallClient;
+                msg.dwCallbackInst = ptLineClient->dwCallbackInstance;
+
+                //
+                // REMOTESP HACK: indicate the hRemoteLine in p4
+                //
+
+                msg.dwParam4 = ptLineClient->hRemoteLine;
+
+                if (ptCallClient->bIndicatePrivilege)
+                {
+                    //
+                    // We're presenting the app with a new call handle; for
+                    // 2.0 & newer apps we indicate this with an APPNEWCALL
+                    // msg, while older apps just get the privilege field
+                    // set in the call state msg.
+                    //
+
+                    if (ptLineApp->dwAPIVersion >= TAPI_VERSION2_0)
+                    {
+                        ASYNCEVENTMSG  newCallMsg;
+
+
+                        newCallMsg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+                        newCallMsg.pInitData          = (DWORD) msg.pInitData;
+                        newCallMsg.hDevice            = (DWORD)
+                            ptLineClient->hRemoteLine;
+                        newCallMsg.dwCallbackInst     = msg.dwCallbackInst;
+                        newCallMsg.pfnPostProcessProc = 0;
+                        newCallMsg.dwMsg              = LINE_APPNEWCALL;
+                        newCallMsg.dwParam1           = ptCall->dwAddressID;
+                        newCallMsg.dwParam2           = (DWORD) ptCallClient;
+                        newCallMsg.dwParam3           =
+                            ptCallClient->dwPrivilege;
+
+                        WriteEventBuffer (ptCallClient->ptClient, &newCallMsg);
+
+                        msg.dwParam3 = 0;
+                    }
+                    else
+                    {
+                        msg.dwParam3 = ptCallClient->dwPrivilege;
+                    }
+
+                    ptCallClient->bIndicatePrivilege = FALSE;
+                }
+                else
+                {
+                    msg.dwParam3 = 0;
+                }
+
+
+                //
+                // REMOTESP HACK: If the client is remote(sp), then pass
+                //                on the media mode the SP passed us in p3
+                //
+
+                if (((PTCLIENT) ptLineApp->ptClient)->hProcess ==
+                        (HANDLE) 0xffffffff)
+                {
+                    msg.dwParam3 = dwParam3;
+                }
+
+                WriteEventBuffer (ptCallClient->ptClient, &msg);
+
+                ptCallClient = ptCallClient->pNextSametCall;
+            }
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+        } // if ((ptCall = WaitForExclusivetCallAccess(
+
+        break;
+    }
+    case LINE_GATHERDIGITS:
+    {
+        PASYNCREQUESTINFO pAsyncRequestInfo;
+
+
+        if (!(pAsyncRequestInfo = (PASYNCREQUESTINFO) dwParam2))
+        {
+            //
+            // The SP is notifying us of the completion of a cancel
+            // request (not a _canceled_ request), so we can just blow
+            // this off and not bother passing it on to the client
+            //
+
+            break;
+        }
+
+        if (!IsBadReadPtr (pAsyncRequestInfo, sizeof (ASYNCREQUESTINFO)) &&
+            !IsBadPtrKey (pAsyncRequestInfo, TASYNC_KEY))
+        {
+            LPWSTR            lpsDigitsSrv = (LPWSTR)
+                                  (((LPBYTE) pAsyncRequestInfo) +
+                                      pAsyncRequestInfo->dwParam1),
+                              lpsDigitsCli =
+                                  (LPWSTR) pAsyncRequestInfo->dwParam2;
+            DWORD             dwNumDigits = pAsyncRequestInfo->dwParam3,
+                              dwNumDigitsTmp;
+            HCALL             hCall = (HCALL) pAsyncRequestInfo->dwParam4;
+            ASYNCEVENTMSG     *pMsg;
+
+
+// BUGBUG LINE_GATHERDIGITS: need to pass pLine->hRemoteLine for remotesp
+
+            if (!(pMsg = ServerAlloc(
+                    sizeof (ASYNCEVENTMSG) + dwNumDigits * sizeof (WCHAR) + 3
+                    )))
+            {
+                break;
+            }
+
+
+            //
+            // Note: We either have < dwNumDigits digits in the buffer,
+            //       and they are null-terminated, or we have dwNumDigits
+            //       digits in the buffer and they are NOT null-terminated
+            //       (such is the implementation given the spec)
+            //
+
+            lstrcpynW ((WCHAR *) (pMsg + 1), lpsDigitsSrv, dwNumDigits + 1);
+
+            if ((dwNumDigitsTmp = lstrlenW ((WCHAR *) (pMsg + 1)))
+                    < dwNumDigits)
+            {
+                dwNumDigits = dwNumDigitsTmp + 1;
+            }
+
+
+            //
+            // Make sure total size is DWORD-aligned so client side doesn't
+            // incur an alignment fault
+            //
+
+            pMsg->dwTotalSize        = (sizeof (ASYNCEVENTMSG) +
+                dwNumDigits * sizeof (WCHAR) + 3) & 0xfffffffc;
+            pMsg->pInitData          = pAsyncRequestInfo->pInitData;
+            pMsg->pfnPostProcessProc =
+                pAsyncRequestInfo->pfnClientPostProcessProc;
+            pMsg->hDevice            = (DWORD) hCall;
+            pMsg->dwMsg              = LINE_GATHERDIGITS;
+            pMsg->dwCallbackInst     = pAsyncRequestInfo->dwCallbackInst;
+            pMsg->dwParam1           = dwParam1;
+            pMsg->dwParam2           = (DWORD) lpsDigitsCli;
+            pMsg->dwParam4           = dwNumDigits;
+
+            if (pMsg->dwParam3 == 0)
+            {
+                pMsg->dwParam3 = GetTickCount();
+            }
+
+            WriteEventBuffer (pAsyncRequestInfo->ptClient, pMsg);
+
+            ServerFree (pMsg);
+            ServerFree (pAsyncRequestInfo);
+        }
+        else
+        {
+// BUGBUG assert (sp error)
+        }
+
+        break;
+    }
+    case LINE_GENERATE:
+    case LINE_MONITORTONE:
+    {
+        //
+        // Note: dwParam2 id really a pointer to instance data containing
+        //       ([0]) the hCall & ([1]) the dwEndToEndID or dwToneListID,
+        //       the latter of which is only useful to remotesp
+        //
+
+        try
+        {
+            LPDWORD         pInstData = (LPDWORD) dwParam2;
+            ASYNCEVENTMSG   msg;
+            PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) pInstData[0];
+            PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                ptCallClient->ptLineClient;
+
+
+            msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+            msg.pInitData          = (DWORD)
+                ((PTLINEAPP) ptLineClient->ptLineApp)->lpfnCallback;
+            msg.pfnPostProcessProc = 0;
+            msg.hDevice            = (DWORD) ptCallClient;
+            msg.dwMsg              = dwMsg;
+            msg.dwCallbackInst     = ptLineClient->dwCallbackInstance;
+            msg.dwParam1           = dwParam1;
+
+
+            //
+            // Indicate the endToEndID/toneListID for remotesp, and the
+            // hRemoteLine in p4 to make life easier for remotesp
+            //
+
+            msg.dwParam2 = pInstData[1];
+
+            if (msg.dwParam3 == 0)
+            {
+                msg.dwParam3 = GetTickCount();
+            }
+
+            msg.dwParam4 = ptLineClient->hRemoteLine;
+
+
+            //
+            // Now a final check to make sure all the
+            // params are valid before sending the msg
+            //
+
+            {
+                PTCLIENT    ptClient = ptCallClient->ptClient;
+
+
+                if (ptCallClient->dwKey == TCALLCLIENT_KEY)
+                {
+                    WriteEventBuffer (ptClient, &msg);
+                }
+            }
+
+            ServerFree (pInstData);
+        }
+        myexcept
+        {
+            // do nothing
+        }
+
+        break;
+    }
+    case LINE_NEWCALL:
+    {
+        BOOL    bCloseMutex;
+        HANDLE  hMutex;
+        PTLINE  ptLine;
+
+
+        if ((ptLine = WaitForExclusivetLineAccess(
+                htLine,
+                &hMutex,
+                &bCloseMutex,
+                INFINITE
+                )))
+        {
+            //
+            // Create a tCall & set the bAlertApps field so we create the
+            // appropriate tCallClients on the first call state msg
+            //
+
+            PTCALL  ptCall;
+
+
+            if (CreatetCall ((PTLINE) htLine, TRUE, &ptCall, NULL, NULL) == 0)
+            {
+                ptCall->hdCall      = (HDRVCALL) dwParam1;
+                ptCall->bAlertApps  = TRUE;
+                ptCall->dwCallState = LINECALLSTATE_UNKNOWN;
+            }
+            else
+            {
+                //
+                // Failed to create the tCall, so make sure we set
+                // *lphtCall to NULL below to indicate this failure
+                // to the provider
+                //
+
+                ptCall = (PTCALL) NULL;
+            }
+
+
+            //
+            // Fill in the provider's lphtCall
+            //
+
+            *((LPHTAPICALL) dwParam2) = (HTAPICALL) ptCall;
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+        }
+
+        break;
+    }
+    case LINE_CREATE:
+    {
+        LONG                lResult;
+        DWORD               dwDeviceID;
+        TSPIPROC            pfnTSPI_providerCreateLineDevice;
+        PTPROVIDER          ptProvider = (PTPROVIDER) dwParam1;
+        PTLINELOOKUPTABLE   pTable, pPrevTable;
+        PTLINELOOKUPENTRY   pEntry;
+
+
+        pfnTSPI_providerCreateLineDevice =
+            ptProvider->apfn[SP_PROVIDERCREATELINEDEVICE];
+
+        assert (pfnTSPI_providerCreateLineDevice != NULL);
+
+
+        //
+        // Search for a table entry (create a new table if we can't find
+        // a free entry in an existing table)
+        //
+
+        WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+        pTable = TapiGlobals.pLineLookup;
+
+        while (pTable &&
+               !(pTable->dwNumUsedEntries < pTable->dwNumTotalEntries))
+        {
+            pPrevTable = pTable;
+
+            pTable = pTable->pNext;
+        }
+
+        if (!pTable)
+        {
+            if (!(pTable = ServerAlloc(
+                    sizeof (TLINELOOKUPTABLE) +
+                        (2 * pPrevTable->dwNumTotalEntries - 1) *
+                        sizeof (TLINELOOKUPENTRY)
+                    )))
+            {
+                ReleaseMutex (TapiGlobals.hMutex);
+                break;
+            }
+
+            pPrevTable->pNext = pTable;
+
+            pTable->dwNumTotalEntries = 2 * pPrevTable->dwNumTotalEntries;
+        }
+
+
+        //
+        // Initialize the table entry
+        //
+
+        pEntry = pTable->aEntries + pTable->dwNumUsedEntries;
+
+        dwDeviceID = TapiGlobals.dwNumLines;
+
+        if ((pEntry->hMutex = MyCreateMutex()))
+        {
+            pEntry->ptProvider = (PTPROVIDER) dwParam1;
+
+
+            //
+            // Now call the creation & negotiation entrypoints, and if all
+            // goes well increment the counts & send msgs to the clients
+            //
+
+            if ((lResult = CallSP2(
+                    pfnTSPI_providerCreateLineDevice,
+                    "providerCreateLineDevice",
+                    SP_FUNC_SYNC,
+                    dwParam2,
+                    dwDeviceID
+
+                    )) == 0)
+            {
+                TSPIPROC    pfnTSPI_lineNegotiateTSPIVersion =
+                                ptProvider->apfn[SP_LINENEGOTIATETSPIVERSION];
+
+
+                if ((lResult = CallSP4(
+                        pfnTSPI_lineNegotiateTSPIVersion,
+                        "",
+                        SP_FUNC_SYNC,
+                        dwDeviceID,
+                        TAPI_VERSION1_0,
+                        TAPI_VERSION_CURRENT,
+                        (DWORD) &pEntry->dwSPIVersion
+
+                        )) == 0)
+                {
+                    PTCLIENT        ptClient = TapiGlobals.ptClients;
+                    ASYNCEVENTMSG   msg;
+
+                    pTable->dwNumUsedEntries++;
+
+                    TapiGlobals.dwNumLines++;
+
+                    // PERF ** Number of lines
+                    PerfBlock.dwLines = TapiGlobals.dwNumLines;
+
+                    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+                    msg.pfnPostProcessProc =
+                    msg.hDevice            =
+                    msg.dwCallbackInst     =
+                    msg.dwParam2           =
+                    msg.dwParam3           = 0;
+
+                    while (ptClient)
+                    {
+// BUGBUG LINE_CREATE: WaitForSingleObject (ptClient->hMutex,
+
+                        PTLINEAPP   ptLineApp = ptClient->ptLineApps;
+
+
+                        while (ptLineApp)
+                        {
+                            if (ptLineApp->dwAPIVersion == TAPI_VERSION1_0)
+                            {
+                                msg.dwMsg    = LINE_LINEDEVSTATE;
+                                msg.dwParam1 = LINEDEVSTATE_REINIT;
+                            }
+                            else
+                            {
+                                msg.dwMsg    = LINE_CREATE;
+                                msg.dwParam1 = dwDeviceID;
+                            }
+
+                            msg.pInitData = (DWORD) ptLineApp->lpfnCallback;
+
+                            WriteEventBuffer (ptClient, &msg);
+
+                            ptLineApp = ptLineApp->pNext;
+                        }
+
+                        ptClient = ptClient->pNext;
+                    }
+
+//                    break;
+                }
+#if DBG
+                else
+                {
+                    DBGOUT((1, "SP failed TSPI_lineNegotiateTSPIVersion"));
+                }
+#endif      
+          
+            }
+            
+#if DBG
+            else
+            {
+                DBGOUT((1, "SP failed providerCreateLineDevice"));
+            }
+#endif  
+
+
+            if (lResult)
+            {
+                CloseHandle (pEntry->hMutex);
+            }
+        }
+
+        ReleaseMutex (TapiGlobals.hMutex);
+        break;
+    }
+    case LINE_CREATEDIALOGINSTANCE:
+    {
+        DWORD                               dwDataSize, dwAlignedDataSize,
+                                            dwAlignedUIDllNameSize,
+                                            dwTotalSize;
+        PTCLIENT                            ptClient;
+        PASYNCEVENTMSG                      pMsg;
+        PASYNCREQUESTINFO                   pAsyncReqInfo;
+        PTAPIDIALOGINSTANCE                 ptDlgInst;
+        LPTUISPICREATEDIALOGINSTANCEPARAMS  pParams;
+
+
+        pParams = (LPTUISPICREATEDIALOGINSTANCEPARAMS) dwParam1;
+
+
+        //
+        // Verify the async request info struct
+        //
+
+        pAsyncReqInfo = (PASYNCREQUESTINFO) pParams->dwRequestID;
+
+        try
+        {
+            ptClient = pAsyncReqInfo->ptClient;
+
+            if (IsBadPtrKey (pAsyncReqInfo, TASYNC_KEY))
+            {
+                pParams->htDlgInst = NULL;
+                return;
+            }
+        }
+        myexcept
+        {
+            pParams->htDlgInst = NULL;
+            return;
+        }
+
+
+        //
+        // Alloc bufs for the msg & dlg instance, careful to keep offsets
+        // & total msg size on 64-bit boundaries
+        //
+
+        dwDataSize             = pParams->dwSize;
+        dwAlignedDataSize      = (dwDataSize + 8) & 0xfffffff7;
+        dwAlignedUIDllNameSize = 0xfffffff7 & (8 +
+            ((lstrlenW ((PWSTR) pParams->lpszUIDLLName) + 1)*sizeof (WCHAR)));
+
+        dwTotalSize = sizeof (ASYNCEVENTMSG) + dwAlignedDataSize +
+            dwAlignedUIDllNameSize;
+
+        if (!(pMsg = ServerAlloc (dwTotalSize)))
+        {
+            pParams->htDlgInst = NULL;
+            return;
+        }
+
+        if (!(ptDlgInst = ServerAlloc (sizeof (TAPIDIALOGINSTANCE))))
+        {
+            ServerFree (pMsg);
+            pParams->htDlgInst = NULL;
+            return;
+        }
+
+
+        //
+        // Add the dlg inst to the tClient's list
+        //
+
+// BUGBUG mutex
+
+        if ((ptDlgInst->pNext = ptClient->pGenericDlgInsts))
+        {
+            ptDlgInst->pNext->pPrev = ptDlgInst;
+        }
+
+        ptClient->pGenericDlgInsts = ptDlgInst;
+
+
+        //
+        // Init dlg inst struct & send msg to client
+        //
+
+        ptDlgInst->dwKey      = TDLGINST_KEY;
+        ptDlgInst->hdDlgInst  = pParams->hdDlgInst;
+        ptDlgInst->ptClient   = ptClient;
+        ptDlgInst->ptProvider = (PTPROVIDER) htLine;
+
+        pMsg->dwTotalSize = dwTotalSize;
+        pMsg->hDevice     = (DWORD) ptDlgInst;
+        pMsg->dwMsg       = LINE_CREATEDIALOGINSTANCE;
+        pMsg->dwParam1    = sizeof (ASYNCEVENTMSG);          // data offset
+        pMsg->dwParam2    = dwDataSize;                      // data size
+        pMsg->dwParam3    = sizeof (ASYNCEVENTMSG) + dwAlignedDataSize;
+                                                             // name offset
+
+        CopyMemory ((LPBYTE)(pMsg + 1), pParams->lpParams, dwDataSize);
+
+        lstrcpyW(
+            (PWSTR) ((LPBYTE)(pMsg + 1) + dwAlignedDataSize),
+            (PWSTR) pParams->lpszUIDLLName
+            );
+
+        pParams->htDlgInst = (HTAPIDIALOGINSTANCE) ptDlgInst;
+
+        WriteEventBuffer (ptClient, pMsg);
+
+        ServerFree (pMsg);
+
+        break;
+    }
+    case LINE_SENDDIALOGINSTANCEDATA:
+    {
+        DWORD               dwDataSize, dwAlignedDataSize, dwTotalSize;
+        PTCLIENT            ptClient;
+        PASYNCEVENTMSG      pMsg;
+        PTAPIDIALOGINSTANCE ptDlgInst = (PTAPIDIALOGINSTANCE) htLine;
+
+
+        //
+        // Verify the dlg inst
+        //
+
+        try
+        {
+            ptClient = ptDlgInst->ptClient;
+
+            if (IsBadPtrKey (ptDlgInst, TDLGINST_KEY))
+            {
+                return;
+            }
+        }
+        myexcept
+        {
+            return;
+        }
+
+
+        //
+        // Careful to keep offsets & total msg size on 64-bit boundaries
+        //
+
+        dwDataSize        = dwParam2;
+        dwAlignedDataSize = (dwDataSize + 8) & 0xfffffff7;
+        dwTotalSize       = sizeof (ASYNCEVENTMSG) + dwAlignedDataSize;
+
+        if (!(pMsg = ServerAlloc (dwTotalSize)))
+        {
+            return;
+        }
+
+
+        //
+        // Send the msg to the client
+        //
+
+        pMsg->dwTotalSize = dwTotalSize;
+        pMsg->hDevice     = (DWORD) ptDlgInst;
+        pMsg->dwMsg       = LINE_SENDDIALOGINSTANCEDATA;
+        pMsg->dwParam1    = sizeof (ASYNCEVENTMSG); // data offset
+        pMsg->dwParam2    = dwDataSize;             // data size
+
+        CopyMemory ((LPBYTE)(pMsg + 1), (LPBYTE) dwParam1, dwDataSize);
+
+        WriteEventBuffer (ptClient, pMsg);
+
+        ServerFree (pMsg);
+
+        break;
+    }
+    case LINE_REMOVE:
+    {
+        PTLINELOOKUPENTRY pLookupEntry;
+
+
+        if (!(pLookupEntry = GetLineLookupEntry (dwParam1)))
+        {
+            return;
+        }
+
+
+        //
+        // Mark the lookup table entry as removed
+        //
+
+        pLookupEntry->bRemoved = 1;
+
+        DestroytLine (pLookupEntry->ptLine, TRUE); // unconditional destroy
+
+        SendAMsgToAllLineApps (TAPI_VERSION2_0, LINE_REMOVE, dwParam1, 0, 0);
+
+        break;
+    }
+    default:
+
+        // if DBG assert (unrecognized dwMsg)
+
+        break;
+    }
+}
+
+
+void
+CALLBACK
+LineEventProcSP(
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    PSPEVENT    pSPEvent;
+
+
+#if DBG
+    if (gdwDebugLevel >= 3)
+    {
+        char           *pszMsg;
+        static char     szInvalMsgVal[] = "<inval msg value>";
+        static char    *aszMsgs[] =
+        {
+            "LINE_ADDRESSSTATE",
+            "LINE_CALLINFO",
+            "LINE_CALLSTATE",
+            "LINE_CLOSE",
+            "LINE_DEVSPECIFIC",
+            "LINE_DEVSPECIFICFEATURE",
+            "LINE_GATHERDIGITS",
+            "LINE_GENERATE",
+            "LINE_LINEDEVSTATE",
+            "LINE_MONITORDIGITS",
+            "LINE_MONITORMEDIA",
+            "LINE_MONITORTONE",
+            szInvalMsgVal,              // LINE_REPLY
+            szInvalMsgVal,              // LINE_REQUEST
+            szInvalMsgVal,              // PHONE_BUTTON
+            szInvalMsgVal,              // PHONE_CLOSE
+            szInvalMsgVal,              // PHONE_DEVSPECIFIC
+            szInvalMsgVal,              // PHONE_REPLY
+            szInvalMsgVal,              // PHONE_STATE
+            "LINE_CREATE",
+            szInvalMsgVal,              // PHONE_CREATE
+            "LINE_AGENTSPECIFIC",
+            "LINE_AGENTSTATUS",
+            szInvalMsgVal,              // LINE_APPNEWCALL
+            "LINE_PROXYREQUEST",
+            "LINE_REMOVE",
+            szInvalMsgVal,              // PHONE_REMOVE
+
+            "LINE_NEWCALL",
+            "LINE_CALLDEVSPECIFIC",
+            "LINE_CALLDEVSPECIFICFEATURE",
+            "LINE_CREATEDIALOGINSTANCE",
+            "LINE_SENDDIALOGINSTANCEDATA"
+        };
+
+
+        if (dwMsg <= PHONE_REMOVE)
+        {
+            pszMsg = aszMsgs[dwMsg];
+        }
+        else if (dwMsg >= LINE_NEWCALL && dwMsg <= LINE_SENDDIALOGINSTANCEDATA)
+        {
+            pszMsg = aszMsgs[27 + dwMsg - TSPI_MESSAGE_BASE];
+        }
+        else
+        {
+            pszMsg = szInvalMsgVal;
+        }
+
+        DBGOUT((
+            3,
+            "LineEventProc: enter\n" \
+                "\t   Msg=%s (x%x), htLine=x%x, htCall=x%x",
+            pszMsg,
+            dwMsg,
+            htLine,
+            htCall
+            ));
+
+        if (dwMsg == LINE_CALLSTATE)
+        {
+            char           *pszCallState;
+            static char     szInvalCallStateVal[] = "<inval callstate value>";
+            static char    *aszCallStates[] =
+            {
+                "IDLE",
+                "OFFERING",
+                "ACCEPTED",
+                "DIALTONE",
+                "DIALING",
+                "RINGBACK",
+                "BUSY",
+                "SPECIALINFO",
+                "CONNECTED",
+                "PROCEEDING",
+                "ONHOLD",
+                "CONFERENCED",
+                "ONHOLDPENDCONF",
+                "ONHOLDPENDTRANSFER",
+                "DISCONNECTED",
+                "UNKNOWN"
+            };
+
+
+            if (!IsOnlyOneBitSetInDWORD(dwParam1) ||
+                dwParam1 > LINECALLSTATE_UNKNOWN)
+            {
+                pszCallState = szInvalCallStateVal;
+            }
+            else
+            {
+                DWORD   i, dwBitMask;
+
+                for(
+                    i = 0, dwBitMask = 1;
+                    dwParam1 != dwBitMask;
+                    i++, dwBitMask <<= 1
+                    );
+
+
+                pszCallState = aszCallStates[i];
+            }
+
+            DBGOUT((
+                3,
+                "  P1=%s (x%x), P2=x%x, P3=x%x",
+                pszCallState,
+                dwParam1,
+                dwParam2,
+                dwParam3
+                ));
+        }
+        else
+        {
+            DBGOUT((
+                3,
+                "  P1=x%x, P2=x%x, P3=x%x",
+                dwParam1,
+                dwParam2,
+                dwParam3
+                ));
+        }
+    }
+#endif
+
+
+    switch (dwMsg)
+    {
+    case LINE_NEWCALL:
+    case LINE_CREATEDIALOGINSTANCE:
+    case LINE_SENDDIALOGINSTANCEDATA:
+
+        //
+        // These msgs need immediate attention, since they contain
+        // pointers that we need to play with which may not be
+        // available during async processing later
+        //
+
+        LineEventProc (htLine, htCall, dwMsg, dwParam1, dwParam2, dwParam3);
+        break;
+
+    default:
+
+        if ((pSPEvent = (PSPEVENT) ServerAlloc (sizeof (SPEVENT))))
+        {
+            pSPEvent->dwType   = SP_LINE_EVENT;
+            pSPEvent->htLine   = htLine;
+            pSPEvent->htCall   = htCall;
+            pSPEvent->dwMsg    = dwMsg;
+            pSPEvent->dwParam1 = dwParam1;
+            pSPEvent->dwParam2 = dwParam2;
+            pSPEvent->dwParam3 = dwParam3;
+
+            QueueSPEvent (pSPEvent);
+        }
+        else
+        {
+            //
+            // Alloc failed, so call the event proc within the SP's context
+            //
+
+            LineEventProc (htLine, htCall, dwMsg, dwParam1, dwParam2, dwParam3);
+        }
+
+        break;
+    }
+
+}
+
+
+void
+WINAPI
+LAccept(
+    PLINEACCEPT_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineAccept;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEACCEPT,              // provider func index
+            &pfnTSPI_lineAccept,        // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Accept"                    // func name
+
+            )) > 0)
+    {
+        //
+        // Safely check to see if the app name associated with this call is
+        // NULL (meaning this is the first client to accept/answer the call),
+        // and if so save the app name
+        //
+
+        try
+        {
+            PTCALL  ptCall = (PTCALL) ((PTCALLCLIENT) pParams->hCall)->ptCall;
+
+
+            if (ptCall->pszAppName == NULL)
+            {
+                DWORD       dwAppNameSize;
+                PTLINEAPP   ptLineApp;
+
+
+                ptLineApp = (PTLINEAPP) ((PTLINECLIENT)
+                    ((PTCALLCLIENT) pParams->hCall)->ptLineClient)->ptLineApp;
+
+                dwAppNameSize = ptLineApp->dwFriendlyNameSize;
+
+                if ((ptCall->pszAppName = ServerAlloc (dwAppNameSize)))
+                {
+                    CopyMemory(
+                        ptCall->pszAppName,
+                        ptLineApp->pszFriendlyName,
+                        dwAppNameSize
+                        );
+
+                    ptCall->dwAppNameSize = dwAppNameSize;
+                }
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LAccept_epilog;
+        }
+
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineAccept,
+            "lineAccept",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwUserUserInfoOffset),
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? 0 :
+                pParams->dwSize)
+            );
+    }
+
+LAccept_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Accept"
+        );
+}
+
+
+void
+LAddToConference_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    PTCALL  ptConsultCall = (PTCALL) pAsyncRequestInfo->dwParam1;
+
+
+    if (pAsyncEventMsg->dwParam2 == 0)
+    {
+        PTCONFERENCELIST    pConfList = (PTCONFERENCELIST)
+                                pAsyncRequestInfo->dwParam2;
+
+
+        SetCallConfList (ptConsultCall, pConfList, TRUE);
+    }
+    else
+    {
+        SetCallConfList (ptConsultCall, NULL, TRUE);
+    }
+}
+
+
+void
+WINAPI
+LAddToConference(
+    PLINEADDTOCONFERENCE_PARAMS pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdConfCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineAddToConference;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hConfCall, // client widget handle
+            (LPVOID) &hdConfCall,       // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEADDTOCONFERENCE,     // provider func index
+            &pfnTSPI_lineAddToConference,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "AddToConference"           // func name
+
+            )) > 0)
+    {
+        PTCALL              ptConfCall, ptConsultCall;
+        HDRVCALL            hdConsultCall;
+        PTCALLCLIENT        ptConsultCallClient,
+                            ptConfCallClient = (PTCALLCLIENT)
+                                pParams->hConfCall;
+        PTCONFERENCELIST    pConfList;
+
+
+        //
+        // Safely make sure that the conf call is really a conf parent
+        //
+
+        try
+        {
+            ptConfCall = ((PTCALLCLIENT) pParams->hConfCall)->ptCall;
+
+            if (!(pConfList = ptConfCall->pConfList) ||
+                (pConfList->aptCalls[0] != ptConfCall))
+            {
+                lRequestID = LINEERR_INVALCONFCALLHANDLE;
+                goto LAddToConference_return;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALCONFCALLHANDLE;
+            goto LAddToConference_return;
+        }
+
+
+        //
+        // Verify hConsultCall
+        //
+
+        if (!(ptConsultCallClient = IsValidCall(
+                pParams->hConsultCall,
+                pParams->ptClient
+                )))
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LAddToConference_return;
+        }
+
+
+        //
+        // Safely make sure calls are on same tLineClient, that client has
+        // owner privilege for consult call, and that the consult call
+        // is neither a conf parent or child (call SetCallConfList
+        // with an inval list to temporarily mark the call as conf'd)
+        //
+
+        try
+        {
+            ptConsultCall = ptConsultCallClient->ptCall;
+
+            if (ptConsultCallClient->ptLineClient !=
+                    ptConfCallClient->ptLineClient)
+            {
+                lRequestID = LINEERR_INVALCALLHANDLE;
+                goto LAddToConference_return;
+            }
+
+            if (!(ptConsultCallClient->dwPrivilege & LINECALLPRIVILEGE_OWNER))
+            {
+                lRequestID = LINEERR_NOTOWNER;
+                goto LAddToConference_return;
+            }
+
+            if (SetCallConfList(
+                    ptConsultCall,
+                    (PTCONFERENCELIST) 0xffffffff,
+                    FALSE
+                    ))
+            {
+                lRequestID = (pConfList->aptCalls[0] == ptConsultCall ?
+                     LINEERR_INVALCALLHANDLE : LINEERR_INVALCALLSTATE);
+
+                goto LAddToConference_return;
+            }
+
+            hdConsultCall = ptConsultCall->hdCall;
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LAddToConference_return;
+        }
+
+
+        //
+        // Set up the async request struct & call the SP
+        //
+
+        pAsyncRequestInfo->pfnPostProcess = LAddToConference_PostProcess;
+        pAsyncRequestInfo->dwParam1       = (DWORD) ptConsultCall;
+        pAsyncRequestInfo->dwParam2       = (DWORD) pConfList;
+
+        pParams->lResult = CallSP3(
+            pfnTSPI_lineAddToConference,
+            "lineAddToConference",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdConfCall,
+            (DWORD) hdConsultCall
+            );
+    }
+
+LAddToConference_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "AddToConference"
+        );
+}
+
+
+void
+WINAPI
+LAgentSpecific(
+    PLINEAGENTSPECIFIC_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "AgentSpecific"             // func name
+
+            )) > 0)
+    {
+        DWORD           dwParamsSize = pParams->dwParamsSize;
+        PTLINE          ptLine;
+        PTLINECLIENT    pProxy;
+
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+            pProxy = ptLine->apProxys[LINEPROXYREQUEST_AGENTSPECIFIC];
+
+            if (pParams->dwAddressID >= ptLine->dwNumAddresses)
+            {
+                lRequestID = LINEERR_INVALADDRESSID;
+                goto LAgentSpecific_epilog;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+            goto LAgentSpecific_epilog;
+        }
+
+
+        //
+        // Save the client's buf ptr & post processing proc ptr
+        //
+
+        pAsyncRequestInfo->dwParam1 = pParams->lpParams;
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+
+        //
+        // First check to see if there's a (local) proxy registered
+        // for this type of request on this line.  If so, build a
+        // request & send it to the proxy.
+        //
+
+        if (pProxy)
+        {
+            LONG                    lResult;
+            PPROXYREQUESTWRAPPER    pProxyRequestWrapper;
+
+
+            if ((lResult = CreateProxyRequest(
+                    pProxy,
+                    LINEPROXYREQUEST_AGENTSPECIFIC,
+                    3 * sizeof (DWORD) + dwParamsSize,
+                    pAsyncRequestInfo,
+                    &pProxyRequestWrapper
+                    )))
+            {
+                lRequestID = lResult;
+                goto LAgentSpecific_epilog;
+            }
+
+            pProxyRequestWrapper->ProxyRequest.AgentSpecific.dwAddressID  =
+                pParams->dwAddressID;
+            pProxyRequestWrapper->ProxyRequest.AgentSpecific.
+                dwAgentExtensionIDIndex  = pParams->dwAgentExtensionIDIndex;
+            pProxyRequestWrapper->ProxyRequest.AgentSpecific.dwSize  =
+                dwParamsSize;
+
+            CopyMemory(
+                pProxyRequestWrapper->ProxyRequest.AgentSpecific.Params,
+                pDataBuf + pParams->dwParamsOffset,
+                dwParamsSize
+                );
+
+
+            //
+            // Change the async request info key so we can verify stuff
+            // when lineProxyRequest is called
+            //
+
+            pAsyncRequestInfo->dwKey = (DWORD) pProxy;
+
+            if ((lResult = SendProxyRequest(
+                    pProxy,
+                    pProxyRequestWrapper,
+                    pAsyncRequestInfo
+                    )))
+            {
+                lRequestID = lResult;
+                goto LAgentSpecific_epilog;
+            }
+            else // success
+            {
+                pParams->lResult = (LONG) pAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // There's no proxy, so check to see if line is remote and
+        // call remotesp if so
+        //
+
+        else if ((GetLineLookupEntry (ptLine->dwDeviceID))->bRemote)
+        {
+            LPBYTE  pBuf;
+
+
+            //
+            // Alloc a shadow buf that the SP can use until it completes this
+            // request.  Make sure there's enough extra space in the buf for
+            // an ASYNCEVENTMSG header so we don't have to alloc yet another
+            // buf in the post processing proc when preparing the completion
+            // msg to send to the client, and that the msg is 64-bit aligned.
+            //
+
+            if (!(pBuf = ServerAlloc(
+                    sizeof (ASYNCEVENTMSG) + ((dwParamsSize + 7) & 0xfffffff8)
+                    )))
+            {
+                lRequestID = LINEERR_NOMEM;
+                goto LAgentSpecific_epilog;
+            }
+
+            pAsyncRequestInfo->pfnPostProcess = LDevSpecific_PostProcess;
+
+            pAsyncRequestInfo->dwParam2 = dwParamsSize;
+            pAsyncRequestInfo->dwParam3 = (DWORD) pBuf;
+
+            CopyMemory(
+                pBuf + sizeof (ASYNCEVENTMSG),
+                pDataBuf + pParams->dwParamsOffset,
+                dwParamsSize
+                );
+
+            pParams->lResult = CallSP6(
+                pRemoteSP->apfn[SP_LINEAGENTSPECIFIC],
+                "lineAgentSpecific",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdLine,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) pParams->dwAgentExtensionIDIndex,
+                (DWORD) pBuf + sizeof (ASYNCEVENTMSG),
+                (DWORD) dwParamsSize
+                );
+        }
+
+
+        //
+        // There's no registered proxy & line is not remote, so fail
+        //
+
+        else
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+
+LAgentSpecific_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "AgentSpecific"
+        );
+}
+
+
+void
+WINAPI
+LAnswer(
+    PLINEANSWER_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineAnswer;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEANSWER,              // provider func index
+            &pfnTSPI_lineAnswer,        // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Answer"                    // func name
+
+            )) > 0)
+    {
+        //
+        // Safely check to see if the app name associated with this call is
+        // NULL (meaning this is the first client to accept/answer the call),
+        // and if so save the app name
+        //
+
+        try
+        {
+            PTCALL  ptCall = (PTCALL) ((PTCALLCLIENT) pParams->hCall)->ptCall;
+
+
+            if (ptCall->pszAppName == NULL)
+            {
+                DWORD       dwAppNameSize;
+                PTLINEAPP   ptLineApp;
+
+
+                ptLineApp = (PTLINEAPP) ((PTLINECLIENT)
+                    ((PTCALLCLIENT) pParams->hCall)->ptLineClient)->ptLineApp;
+
+                dwAppNameSize = ptLineApp->dwFriendlyNameSize;
+
+                if ((ptCall->pszAppName = ServerAlloc (dwAppNameSize)))
+                {
+                    CopyMemory(
+                        ptCall->pszAppName,
+                        ptLineApp->pszFriendlyName,
+                        dwAppNameSize
+                        );
+
+                    ptCall->dwAppNameSize = dwAppNameSize;
+                }
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LAnswer_epilog;
+        }
+
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineAnswer,
+            "lineAnswer",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwUserUserInfoOffset),
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? 0 :
+                pParams->dwSize)
+            );
+
+        
+    }
+
+LAnswer_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Answer"
+        );
+}
+
+
+void
+WINAPI
+LBlindTransfer(
+    PLINEBLINDTRANSFER_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineBlindTransfer;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEBLINDTRANSFER,       // provider func index
+            &pfnTSPI_lineBlindTransfer, // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "BlindTransfer"             // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineBlindTransfer,
+            "lineBlindTransfer",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) pDataBuf + pParams->dwDestAddressOffset,
+            pParams->dwCountryCode
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "BlindTransfer"
+        );
+}
+
+
+void
+WINAPI
+LClose(
+    PLINECLOSE_PARAMS   pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+
+    DBGOUT((4, "Entering lineClose"));
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "Close"                     // func name
+
+            )) == 0)
+    {
+        DestroytLineClient ((PTLINECLIENT) pParams->hLine);
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "Close"
+        );
+
+    DBGOUT((4, "Leaving lineClose"));
+}
+
+
+void
+LCompleteCall_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    pAsyncEventMsg->dwParam3 = pAsyncRequestInfo->dwParam1;
+    pAsyncEventMsg->dwParam4 = pAsyncRequestInfo->dwParam2;
+}
+
+
+void
+WINAPI
+LCompleteCall(
+    PLINECOMPLETECALL_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineCompleteCall;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINECOMPLETECALL,        // provider func index
+            &pfnTSPI_lineCompleteCall,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "CompleteCall"              // func name
+
+            )) > 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwCompletionMode) ||
+            (pParams->dwCompletionMode & ~AllCallComplModes)
+            )
+        {
+            lRequestID = LINEERR_INVALCALLCOMPLMODE;
+            goto LCompleteCall_epilog;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LCompleteCall_PostProcess;
+        pAsyncRequestInfo->dwParam2       = pParams->lpdwCompletionID;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP5(
+            pfnTSPI_lineCompleteCall,
+            "lineCompleteCall",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) &pAsyncRequestInfo->dwParam1,
+            (DWORD) pParams->dwCompletionMode,
+            (DWORD) pParams->dwMessageID
+            );
+    }
+
+LCompleteCall_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "CompleteCall"
+        );
+}
+
+
+void
+LCompleteTransfer_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    BOOL            bDupedMutex;
+    HANDLE          hMutex;
+    PTCALL          ptConfCall = (PTCALL) pAsyncRequestInfo->dwParam1;
+    LPHCALL         lphConfCall = (LPHCALL) pAsyncRequestInfo->dwParam2;
+    PTCALLCLIENT    ptConfCallClient;
+
+
+    if (WaitForExclusivetCallAccess(
+            (HTAPICALL) ptConfCall,
+            TINCOMPLETECALL_KEY,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwCallInstance = pAsyncRequestInfo->dwParam5;
+        PTCALL          ptCall = (PTCALL) pAsyncRequestInfo->dwParam3,
+                        ptConsultCall = (PTCALL) pAsyncRequestInfo->dwParam4;
+        LPHCALL         lphCall = (LPHCALL) pAsyncRequestInfo->dwParam2;
+
+
+        //
+        // Check to make sure this is the call we think it is (that the
+        // pointer wasn't freed by a previous call to lineClose/Shutdown
+        // and realloc'd for use as a ptCall again)
+        //
+
+        if (ptConfCall->dwCallInstance != dwCallInstance)
+        {
+            MyReleaseMutex (hMutex, bDupedMutex);
+            goto LCompleteTransfer_PostProcess_bad_ptConfCall;
+        }
+
+        ptConfCallClient = (PTCALLCLIENT) ptConfCall->ptCallClients;
+
+        if (pAsyncEventMsg->dwParam2 == 0)  // success
+        {
+            //
+            // Check to see if the app closed the line & left us with
+            // 0 call clients (in which case it'll also be taking care of
+            // cleaning up this tCall too)
+            //
+
+            if (ptConfCall->ptCallClients == NULL)
+            {
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+                ptConfCallClient = (PTCALLCLIENT) NULL;
+
+                if (pAsyncEventMsg->dwParam2 == 0)
+                {
+                    pAsyncEventMsg->dwParam2 = LINEERR_INVALLINEHANDLE;
+                }
+
+                goto LCompleteTransfer_PostProcess_initMsgParams;
+            }
+
+
+            //
+            // Find out which address the call is on
+            //
+
+            CallSP2(
+                ptCall->ptProvider->apfn[SP_LINEGETCALLADDRESSID],
+                "lineGetCallAddressID",
+                SP_FUNC_SYNC,
+                (DWORD) ptCall->hdCall,
+                (DWORD) (&ptCall->dwAddressID)
+                );
+
+
+            //
+            // Mark the calls & conf list as valid, the release the mutex.
+            //
+
+            ptConfCall->dwKey       = TCALL_KEY;
+            ptConfCallClient->dwKey = TCALLCLIENT_KEY;
+
+            ((PTCONFERENCELIST) ptConfCall->pConfList)->dwKey = TCONFLIST_KEY;
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+
+            //
+            // Create monitor tCallClients
+            //
+
+            CreateCallMonitors (ptConfCall);
+        }
+        else    // error
+        {
+            RemoveCallFromLineList (ptConfCall);
+            ptConfCall->dwKey =
+            ((PTCONFERENCELIST) ptConfCall->pConfList)->dwKey = INVAL_KEY;
+
+
+            //
+            // Check to see if another thread already destroyed the
+            // tCallClient (due to a lineClose/Shutdown) before trying
+            // to reference a freed object
+            //
+
+            if (ptConfCall->ptCallClients)
+            {
+                RemoveCallClientFromLineClientList (ptConfCallClient);
+                ptConfCallClient->dwKey = INVAL_KEY;
+                ServerFree  (ptConfCallClient);
+            }
+
+
+            //
+            // If we have a duped mutex handle (bDupedMutex == TRUE)
+            // then we can safely go ahead and close the ptCall->hMutex
+            // since no other thread will be waiting on it (thanks to
+            // the first WaitForSingleObject in WaitForMutex).  Also
+            // release & close the duped handle.
+            //
+            // Otherwise, we have the actual ptCall->hMutex, and we
+            // wrap the release & close in a critical section to
+            // prevent another thread "T2" from grabbing ptCall->hMutex
+            // right after we release but right before we close.  This
+            // could result in deadlock at some point when "T2" goes to
+            // release the mutex, only to find that it's handle is bad,
+            // and thread "T3", which is waiting on the mutex (or a dup'd
+            // handle) waits forever.  (See corresponding critical
+            // section in WaitForMutex.)
+            //
+
+            if (bDupedMutex)
+            {
+                CloseHandle (ptConfCall->hMutex);
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+            }
+            else
+            {
+                EnterCriticalSection (&gSafeMutexCritSec);
+
+                ReleaseMutex (hMutex);
+                CloseHandle (hMutex);
+
+                LeaveCriticalSection (&gSafeMutexCritSec);
+            }
+
+            SetCallConfList (ptCall, NULL, FALSE);
+            SetCallConfList (ptConsultCall, NULL, FALSE);
+
+            ServerFree  (ptConfCall->pConfList);
+            FreetCall  (ptConfCall);
+        }
+    }
+    else
+    {
+        //
+        // If here we can assume that the call was already destroyed
+        // and just fail the request
+        //
+
+LCompleteTransfer_PostProcess_bad_ptConfCall:
+
+        ptConfCallClient = (PTCALLCLIENT) NULL;
+
+        if (pAsyncEventMsg->dwParam2 == 0)
+        {
+            pAsyncEventMsg->dwParam2 = LINEERR_OPERATIONFAILED;
+        }
+    }
+
+
+    //
+    // Fill in the params to pass to client (important to remotesp in both
+    // the success & fail cases so it can either init or clean up drvCall)
+    //
+
+LCompleteTransfer_PostProcess_initMsgParams:
+
+    pAsyncEventMsg->dwParam3 = (DWORD) ptConfCallClient;
+    pAsyncEventMsg->dwParam4 = (DWORD) lphConfCall;
+}
+
+
+void
+WINAPI
+LCompleteTransfer(
+    PLINECOMPLETETRANSFER_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineCompleteTransfer;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINECOMPLETETRANSFER,    // provider func index
+            &pfnTSPI_lineCompleteTransfer,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "CompleteTransfer"          // func name
+
+            )) > 0)
+    {
+        PTCALL          ptConfCall = (PTCALL) NULL, ptCall, ptConsultCall;
+        PTCALLCLIENT    ptConfCallClient,
+                        ptCallClient = (PTCALLCLIENT) pParams->hCall,
+                        ptConsultCallClient;
+
+
+        //
+        // Validate the hConsultCall
+        //
+
+        if (!(ptConsultCallClient = IsValidCall(
+                pParams->hConsultCall,
+                pParams->ptClient
+                )))
+        {
+            lRequestID = LINEERR_INVALCONSULTCALLHANDLE;
+            goto LCompleteTransfer_return;
+        }
+
+
+        //
+        // Verify that app has owner privilege for hConsultCall
+        //
+
+        if (ptConsultCallClient->dwPrivilege != LINECALLPRIVILEGE_OWNER)
+        {
+            lRequestID = LINEERR_NOTOWNER;
+            goto LCompleteTransfer_return;
+        }
+
+
+        //
+        // Safely verify hCall & hConsultCall are not the same call,
+        // and that they are on the same tLine
+        //
+
+        try
+        {
+            ptCall        = ptCallClient->ptCall;
+            ptConsultCall = ptConsultCallClient->ptCall;
+
+            if ((ptCall == ptConsultCall) ||
+
+                (((PTLINECLIENT) ptCallClient->ptLineClient)->ptLine !=
+                    ((PTLINECLIENT)ptConsultCallClient->ptLineClient)->ptLine))
+            {
+                lRequestID = LINEERR_INVALCALLHANDLE;
+                goto LCompleteTransfer_return;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LCompleteTransfer_return;
+        }
+
+
+        if (pParams->dwTransferMode == LINETRANSFERMODE_CONFERENCE)
+        {
+            LONG                lResult;
+            PTCONFERENCELIST    pConfList;
+
+
+            //
+            // Create & init a conf list
+            //
+
+            if (!(pConfList = ServerAlloc(
+                    sizeof (TCONFERENCELIST) + DEF_NUM_CONF_LIST_ENTRIES *
+                        sizeof (PTCALL)
+                    )))
+            {
+                lRequestID = LINEERR_NOMEM;
+                goto LCompleteTransfer_return;
+            }
+
+            pConfList->dwNumTotalEntries = DEF_NUM_CONF_LIST_ENTRIES + 1;
+            pConfList->dwNumUsedEntries = 1;
+
+
+            //
+            // Set the tCall & tConsultCall conf list, then create
+            // the tConfCall & tConfCallClient
+            //
+
+            if ((lResult = SetCallConfList (ptCall, pConfList, FALSE)) == 0)
+            {
+                if ((lResult = SetCallConfList(
+                        ptConsultCall,
+                        pConfList,
+                        FALSE
+
+                        )) == 0)
+                {
+                    if ((lResult = CreatetCallAndClient(
+                            ptCallClient->ptLineClient,
+                            &ptConfCall,
+                            &ptConfCallClient,
+                            NULL,
+                            &pAsyncRequestInfo->dwParam5
+
+                            )) == 0)
+                    {
+                        ptConfCall->pConfList = pConfList;
+
+                        pConfList->aptCalls[0] = ptConfCall;
+
+                        pAsyncRequestInfo->dwParam1 = (DWORD) ptConfCall;
+                        pAsyncRequestInfo->dwParam2 = (DWORD)
+                            pParams->lphConfCall;
+                        pAsyncRequestInfo->dwParam3 = (DWORD) ptCall;
+                        pAsyncRequestInfo->dwParam4 = (DWORD) ptConsultCall;
+
+                        pAsyncRequestInfo->pfnPostProcess =
+                            LCompleteTransfer_PostProcess;
+
+                        goto LCompleteTransfer_callSP;
+                    }
+
+                    SetCallConfList (ptConsultCall, NULL, FALSE);
+                }
+
+                SetCallConfList (ptCall, NULL, FALSE);
+            }
+
+
+            //
+            // If here an error occured
+            //
+
+            ServerFree (pConfList);
+            lRequestID = lResult;
+            goto LCompleteTransfer_return;
+        }
+        else if (pParams->dwTransferMode != LINETRANSFERMODE_TRANSFER)
+        {
+            lRequestID = LINEERR_INVALTRANSFERMODE;
+            goto LCompleteTransfer_return;
+        }
+
+LCompleteTransfer_callSP:
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP6(
+            pfnTSPI_lineCompleteTransfer,
+            "lineCompleteTransfer",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) ptConsultCallClient->ptCall->hdCall,
+            (DWORD) ptConfCall,
+            (DWORD) (ptConfCall ? (DWORD) &ptConfCall->hdCall : 0),
+            (DWORD) pParams->dwTransferMode
+            );
+
+        if (ptConfCall)
+        {
+            SetDrvCallFlags(
+                ptConfCall,
+                DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+                );
+        }
+    }
+
+LCompleteTransfer_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "CompleteTransfer"
+        );
+}
+
+
+void
+WINAPI
+LDeallocateCall(
+    PLINEDEALLOCATECALL_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                           // client async request ID
+            "DeallocateCall"            // func name
+
+            )) == 0)
+    {
+        //
+        // Per nt bug #20546 we're now allowing the last owner to dealloc
+        // a non-IDLE call.  Decided to do this based on distributed call
+        // ownership issues.  dankn 02/13/96
+        //
+
+        DestroytCallClient ((PTCALLCLIENT) pParams->hCall);
+
+/*        try
+        {
+            PTCALL          ptCall;
+            PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) pParams->hCall;
+
+
+// BUG//BUG LDeallocateCall: race condition, may want to move this to DestroytCC
+
+            ptCall = ptCallClient->ptCall;
+
+            if (ptCall->dwNumOwners == 1 &&
+                ptCallClient->dwPrivilege == LINECALLPRIVILEGE_OWNER &&
+                ptCall->dwCallState != LINECALLSTATE_IDLE)
+            {
+                pParams->lResult = LINEERR_INVALCALLSTATE;
+            }
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        if (pParams->lResult == 0)
+        {
+            DestroytCallClient ((PTCALLCLIENT) pParams->hCall);
+        }
+*/
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "DeallocateCall"
+        );
+}
+
+
+void
+LDevSpecific_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    PASYNCEVENTMSG  pNewAsyncEventMsg = (PASYNCEVENTMSG)
+                        pAsyncRequestInfo->dwParam3;
+
+
+    CopyMemory (pNewAsyncEventMsg, pAsyncEventMsg, sizeof (ASYNCEVENTMSG));
+
+    *ppBuf = pNewAsyncEventMsg;
+
+    if (pAsyncEventMsg->dwParam2 == 0)  // success
+    {
+        //
+        // Make sure to keep the total size 64-bit aligned
+        //
+
+        pNewAsyncEventMsg->dwTotalSize +=
+            (pAsyncRequestInfo->dwParam2 + 7) & 0xfffffff8;
+
+        pNewAsyncEventMsg->dwParam3 = pAsyncRequestInfo->dwParam1; // lpParams
+        pNewAsyncEventMsg->dwParam4 = pAsyncRequestInfo->dwParam2; // dwSize
+    }
+}
+
+
+void
+WINAPI
+LDevSpecific(
+    PLINEDEVSPECIFIC_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    DWORD               dwWidgetType, hWidget;
+    HANDLE              hMutex;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineDevSpecific;
+
+
+    if (pParams->hCall)
+    {
+        dwWidgetType = ANY_RT_HCALL;
+        hWidget = (DWORD) pParams->hCall;
+    }
+    else
+    {
+        dwWidgetType = ANY_RT_HLINE;
+        hWidget = (DWORD) pParams->hLine;
+    }
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            dwWidgetType,               // widget type
+            hWidget,                    // client widget handle
+            (LPVOID) &hWidget,          // provider widget handle
+            (pParams->hCall ? LINECALLPRIVILEGE_MONITOR : 0),
+                                        // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEDEVSPECIFIC,         // provider func index
+            &pfnTSPI_lineDevSpecific,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "DevSpecific"               // func name
+
+            )) > 0)
+    {
+        DWORD   hdLine, hdCall;
+        LPBYTE  pBuf;
+
+
+        //
+        // If an hCall was specified verify the hLine &
+        // make sure the call is on the specified hLine
+        //
+
+        if (dwWidgetType == ANY_RT_HCALL)
+        {
+            LONG lResult;
+
+
+            try
+            {
+                PTLINECLIENT    ptLineClient;
+
+
+                ptLineClient = (PTLINECLIENT) pParams->hLine;
+
+                lResult = LINEERR_INVALLINEHANDLE;
+
+                if (IsBadPtrKey (ptLineClient, TLINECLIENT_KEY) ||
+                    (ptLineClient->ptClient != pParams->ptClient))
+                {
+                    lRequestID = LINEERR_INVALLINEHANDLE;
+                    goto LDevSpecific_epilog;
+                }
+
+                hdLine = (DWORD) ptLineClient->ptLine;
+
+                lResult = LINEERR_INVALCALLHANDLE;
+
+                if (ptLineClient != (PTLINECLIENT)
+                        ((PTCALLCLIENT) pParams->hCall)->ptLineClient)
+                {
+                    DBGOUT((
+                        1,
+                        "LDevSpecific: error, hCall=x%x not related " \
+                            "to hLine=x%x",
+                        pParams->hCall,
+                        ptLineClient
+                        ));
+
+                    lRequestID = LINEERR_INVALCALLHANDLE;
+                    goto LDevSpecific_epilog;
+                }
+            }
+            myexcept
+            {
+                lRequestID = lResult;
+                goto LDevSpecific_epilog;
+            }
+
+            hdCall = hWidget;
+        }
+        else
+        {
+            hdLine = hWidget;
+            hdCall = 0;
+        }
+
+
+        //
+        // Alloc a shadow buf that the SP can use until it completes this
+        // request.  Make sure there's enough extra space in the buf for
+        // an ASYNCEVENTMSG header so we don't have to alloc yet another
+        // buf in the post processing proc when preparing the completion
+        // msg to send to the client, and that the msg is 64-bit aligned.
+        //
+
+        if (!(pBuf = ServerAlloc(
+                ((pParams->dwParamsSize + 7) & 0xfffffff8) +
+                    sizeof (ASYNCEVENTMSG)
+                )))
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LDevSpecific_epilog;
+        }
+
+        CopyMemory(
+            pBuf + sizeof (ASYNCEVENTMSG),
+            pDataBuf + pParams->dwParamsOffset,
+            pParams->dwParamsSize
+            );
+
+        pAsyncRequestInfo->pfnPostProcess = LDevSpecific_PostProcess;
+        pAsyncRequestInfo->dwParam1       = (DWORD) pParams->lpParams;
+        pAsyncRequestInfo->dwParam2       = pParams->dwParamsSize;
+        pAsyncRequestInfo->dwParam3       = (DWORD) pBuf;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP6(
+            pfnTSPI_lineDevSpecific,
+            "lineDevSpecific",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            (DWORD) pParams->dwAddressID,
+            (DWORD) hdCall,
+            (DWORD) (pParams->dwParamsSize ?
+                pBuf + sizeof (ASYNCEVENTMSG) : NULL),
+            (DWORD) pParams->dwParamsSize
+            );
+    }
+
+LDevSpecific_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "DevSpecific"
+        );
+}
+
+
+void
+WINAPI
+LDevSpecificFeature(
+    PLINEDEVSPECIFICFEATURE_PARAMS  pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineDevSpecificFeature;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEDEVSPECIFICFEATURE,  // provider func index
+            &pfnTSPI_lineDevSpecificFeature,// provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "DevSpecificFeature"        // func name
+
+            )) > 0)
+    {
+        LPBYTE pBuf;
+
+
+        if (pParams->dwFeature > PHONEBUTTONFUNCTION_NONE  &&
+            (pParams->dwFeature & 0x80000000) == 0)
+        {
+            lRequestID = LINEERR_INVALFEATURE;
+            goto LDevSpecificFeature_epilog;
+        }
+
+
+        //
+        // Alloc a shadow buf that the SP can use until it completes this
+        // request.  Make sure there's enough extra space in the buf for
+        // an ASYNCEVENTMSG header so we don't have to alloc yet another
+        // buf in the post processing proc when preparing the completion
+        // msg to send to the client, and that the msg is 64-bit aligned.
+        //
+
+        if (!(pBuf = ServerAlloc(
+                ((pParams->dwParamsSize + 7) & 0xfffffff8) +
+                    sizeof (ASYNCEVENTMSG)
+                )))
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LDevSpecificFeature_epilog;
+        }
+
+        CopyMemory(
+            pBuf + sizeof (ASYNCEVENTMSG),
+            pDataBuf + pParams->dwParamsOffset,
+            pParams->dwParamsSize
+            );
+
+        pAsyncRequestInfo->pfnPostProcess = LDevSpecific_PostProcess;
+        pAsyncRequestInfo->dwParam1       = (DWORD) pParams->lpParams;
+        pAsyncRequestInfo->dwParam2       = pParams->dwParamsSize;
+        pAsyncRequestInfo->dwParam3       = (DWORD) pBuf;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP5(
+            pfnTSPI_lineDevSpecificFeature,
+            "lineDevSpecificFeature",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            (DWORD) pParams->dwFeature,
+            (DWORD) (pParams->dwParamsSize ?
+                pBuf + sizeof (ASYNCEVENTMSG) : NULL),
+            (DWORD) pParams->dwParamsSize
+            );
+    }
+
+LDevSpecificFeature_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "DevSpecificFeature"
+        );
+}
+
+
+void
+WINAPI
+LDial(
+    PLINEDIAL_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineDial;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEDIAL,                // provider func index
+            &pfnTSPI_lineDial,          // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Dial"                      // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineDial,
+            "lineDial",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) pDataBuf + pParams->dwDestAddressOffset,
+            pParams->dwCountryCode
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Dial"
+        );
+}
+
+
+void
+WINAPI
+LDrop(
+    PLINEDROP_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineDrop;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEDROP,                // provider func index
+            &pfnTSPI_lineDrop,          // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Drop"                      // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineDrop,
+            "lineDrop",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwUserUserInfoOffset),
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? 0 :
+                pParams->dwSize)
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Drop"
+        );
+}
+
+
+void
+WINAPI
+LForward(
+    PLINEFORWARD_PARAMS pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineForward;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEFORWARD,             // provider func index
+            &pfnTSPI_lineForward,       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Forward"                   // func name
+
+            )) > 0)
+    {
+        LONG                lResult;
+        DWORD               dwAPIVersion, dwSPIVersion;
+        PTCALL              ptConsultCall;
+        PTCALLCLIENT        ptConsultCallClient;
+        LPLINECALLPARAMS    pCallParamsApp, pCallParamsSP;
+        LPLINEFORWARDLIST   pFwdList = (LPLINEFORWARDLIST)
+                                (pParams->dwForwardListOffset == TAPI_NO_DATA ?
+                                NULL :pDataBuf + pParams->dwForwardListOffset),
+                            pTmpFwdList = NULL;
+
+
+        //
+        // Validate the params
+        //
+
+        try
+        {
+            dwAPIVersion = ((PTLINECLIENT) pParams->hLine)->dwAPIVersion;
+            dwSPIVersion =
+                ((PTLINECLIENT) pParams->hLine)->ptLine->dwSPIVersion;
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALLINEHANDLE;
+            goto LForward_epilog;
+        }
+
+        if (pFwdList)
+        {
+            DWORD           dwTotalSize  = pFwdList->dwTotalSize, dwFixedSize,
+                            dwNumEntries, i, dwInvalidForwardModes;
+            LPLINEFORWARD   pFwdEntry = pFwdList->ForwardList;
+
+
+            if (dwTotalSize < sizeof (LINEFORWARDLIST))
+            {
+                lRequestID = LINEERR_STRUCTURETOOSMALL;
+                goto LForward_epilog;
+            }
+
+
+            //
+            // Note: dwNumEntries == 0 is the same as pFwdList == NULL
+            //
+
+            dwNumEntries = pFwdList->dwNumEntries;
+
+            if (dwNumEntries & 0xffff0000)
+            {
+                lRequestID = LINEERR_INVALPARAM;
+                goto LForward_epilog;
+            }
+
+            dwFixedSize = sizeof (LINEFORWARDLIST) + sizeof (LINEFORWARD) *
+                (dwNumEntries == 0 ? 0 : dwNumEntries - 1);
+
+            if (dwFixedSize > dwTotalSize)
+            {
+                lRequestID = LINEERR_INVALPARAM;
+                goto LForward_epilog;
+            }
+
+            dwInvalidForwardModes = (dwAPIVersion < TAPI_VERSION1_4 ?
+                ~AllForwardModes1_0 : ~AllForwardModes1_4);
+
+            for (i = 0; i < dwNumEntries; i++, pFwdEntry++)
+            {
+                if (!IsOnlyOneBitSetInDWORD (pFwdEntry->dwForwardMode) ||
+                    pFwdEntry->dwForwardMode & dwInvalidForwardModes)
+                {
+                    DBGOUT((
+                        3,
+                        "LFoward: bad dwForwardMode, x%x",
+                        pFwdEntry->dwForwardMode
+                        ));
+
+                    lRequestID = LINEERR_INVALPARAM;
+                    goto LForward_epilog;
+                }
+
+                if (ISBADSIZEOFFSET(
+                        dwTotalSize,
+                        dwFixedSize,
+                        pFwdEntry->dwCallerAddressSize,
+                        pFwdEntry->dwCallerAddressOffset,
+                        "LFoward",
+                        "CallerAddress"
+                        ) ||
+
+                    ISBADSIZEOFFSET(
+                        dwTotalSize,
+                        dwFixedSize,
+                        pFwdEntry->dwDestAddressSize,
+                        pFwdEntry->dwDestAddressOffset,
+                        "LFoward",
+                        "CallerAddress"
+                        ))
+                {
+                    lRequestID = LINEERR_INVALPARAM;
+                    goto LForward_epilog;
+                }
+
+                // don't bother validating country code right now
+            }
+
+
+            //
+            // See if we need to convert an ascii fwd list to unicode
+            //
+
+            if (pParams->dwAsciiCallParamsCodePage != 0xffffffff  &&
+                dwNumEntries != 0)
+            {
+                DWORD dwXxxOffset;
+
+
+                //
+                // Alloc a temporary buffer for storing the converted
+                // data (sizeof(WCHAR) * dwTotalSize to insure buffer
+                // is large enough for all ascii->unicode conversions)
+                //
+
+                if (!(pTmpFwdList = ServerAlloc (sizeof(WCHAR) * dwTotalSize)))
+                {
+                    lRequestID = LINEERR_NOMEM;
+                    goto LForward_epilog;
+                }
+
+                dwXxxOffset = sizeof (LINEFORWARDLIST) +
+                    (dwNumEntries - 1) * sizeof (LINEFORWARD);
+
+                pFwdEntry = pTmpFwdList->ForwardList;
+
+                CopyMemory (pTmpFwdList, pFwdList, dwXxxOffset);
+
+                pTmpFwdList->dwTotalSize *= sizeof (WCHAR);
+
+                for (i = 0; i < dwNumEntries; i++, pFwdEntry++)
+                {
+                    if (pFwdEntry->dwCallerAddressSize)
+                    {
+                        MultiByteToWideChar(
+                            pParams->dwAsciiCallParamsCodePage,
+                            MB_PRECOMPOSED,
+                            (LPCSTR) (((LPBYTE) pFwdList) +
+                                pFwdEntry->dwCallerAddressOffset),
+                            pFwdEntry->dwCallerAddressSize,
+                            (LPWSTR) (((LPBYTE) pTmpFwdList) + dwXxxOffset),
+                            pFwdEntry->dwCallerAddressSize * sizeof (WCHAR)
+                            );
+
+                        pFwdEntry->dwCallerAddressOffset = dwXxxOffset;
+                        dwXxxOffset += (pFwdEntry->dwCallerAddressSize *=
+                            sizeof (WCHAR));
+                    }
+
+                    if (pFwdEntry->dwDestAddressSize)
+                    {
+                        MultiByteToWideChar(
+                            pParams->dwAsciiCallParamsCodePage,
+                            MB_PRECOMPOSED,
+                            (LPCSTR) (((LPBYTE) pFwdList) +
+                                pFwdEntry->dwDestAddressOffset),
+                            pFwdEntry->dwDestAddressSize,
+                            (LPWSTR) (((LPBYTE) pTmpFwdList) + dwXxxOffset),
+                            pFwdEntry->dwDestAddressSize * sizeof (WCHAR)
+                            );
+
+                        pFwdEntry->dwDestAddressOffset = dwXxxOffset;
+                        dwXxxOffset += (pFwdEntry->dwDestAddressSize *=
+                            sizeof (WCHAR));
+                    }
+                }
+
+                pFwdList = pTmpFwdList;
+            }
+        }
+
+        pCallParamsApp = (LPLINECALLPARAMS)
+            (pParams->dwCallParamsOffset == TAPI_NO_DATA ? NULL :
+            pDataBuf + pParams->dwCallParamsOffset);
+
+        if (pCallParamsApp)
+        {
+            if ((lResult = ValidateCallParams(
+                    pCallParamsApp,
+                    &pCallParamsSP,
+                    dwAPIVersion,
+                    dwSPIVersion,
+                    pParams->dwAsciiCallParamsCodePage
+
+                    )) != 0)
+            {
+                lRequestID = lResult;
+                goto LForward_freeFwdList;
+            }
+        }
+        else
+        {
+            pCallParamsSP = (LPLINECALLPARAMS) NULL;
+        }
+
+        if (CreatetCallAndClient(
+                (PTLINECLIENT) pParams->hLine,
+                &ptConsultCall,
+                &ptConsultCallClient,
+                pCallParamsSP,
+                &pAsyncRequestInfo->dwParam5
+
+                ) != 0)
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LForward_freeCallParams;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LMakeCall_PostProcess;
+        pAsyncRequestInfo->dwParam1 = (DWORD) ptConsultCall;
+        pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphConsultCall;
+        pAsyncRequestInfo->dwParam3 = 1; // special case for post-process proc
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP9(
+            pfnTSPI_lineForward,
+            "lineForward",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            (DWORD) pParams->bAllAddresses,
+            (DWORD) pParams->dwAddressID,
+            (DWORD) pFwdList,
+            (DWORD) pParams->dwNumRingsNoAnswer,
+            (DWORD) ptConsultCall,
+            (DWORD) &ptConsultCall->hdCall,
+            (DWORD) pCallParamsSP
+            );
+
+        SetDrvCallFlags(
+            ptConsultCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+
+LForward_freeCallParams:
+
+        if (pCallParamsSP != pCallParamsApp)
+        {
+            ServerFree (pCallParamsSP);
+        }
+
+LForward_freeFwdList:
+
+        if (pTmpFwdList)
+        {
+            ServerFree (pTmpFwdList);
+        }
+    }
+
+LForward_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Forward"
+        );
+}
+
+
+void
+WINAPI
+LGatherDigits(
+    PLINEGATHERDIGITS_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineGatherDigits;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGATHERDIGITS,        // provider func index
+            &pfnTSPI_lineGatherDigits,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GatherDigits"              // func name
+
+            )) == 0)
+    {
+        DWORD               dwDigitModes = pParams->dwDigitModes;
+        LPWSTR              lpsDigits;
+        PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+        #define AllGatherDigitsModes (LINEDIGITMODE_PULSE | LINEDIGITMODE_DTMF)
+
+        if (!(dwDigitModes & AllGatherDigitsModes) ||
+            (dwDigitModes & ~AllGatherDigitsModes))
+        {
+            pParams->lResult = LINEERR_INVALDIGITMODE;
+            goto LGatherDigits_epilog;
+        }
+
+        if (pParams->lpsDigits)
+        {
+            //
+            // The client passed us a non-null digits buffer so we'll
+            // alloc an async request info buf with extra space at the
+            // end for the temporary digits buf for use by the sp
+            // (faster than two two allocs & two frees for separate
+            // async request & digits bufs).  Use the pointer as the
+            // dwEndToEndID we pass to the sp.
+            //
+
+            PTLINECLIENT    ptLineClient;
+
+
+            if (pParams->dwNumDigits == 0)
+            {
+                pParams->lResult = LINEERR_INVALPARAM;
+                goto LGatherDigits_epilog;
+            }
+
+            if (!(pAsyncRequestInfo = ServerAlloc(
+                    sizeof (ASYNCREQUESTINFO) +
+                        (pParams->dwNumDigits * sizeof (WCHAR))
+                    )))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGatherDigits_epilog;
+            }
+
+            lpsDigits = (LPWSTR) (pAsyncRequestInfo + 1);
+
+            ptLineClient = (PTLINECLIENT)
+                ((PTCALLCLIENT) pParams->hCall)->ptLineClient;
+
+            pAsyncRequestInfo->dwKey          = TASYNC_KEY;
+            pAsyncRequestInfo->ptClient       = pParams->ptClient;
+            pAsyncRequestInfo->pInitData      =
+                (DWORD) ((PTLINEAPP) ptLineClient->ptLineApp)->lpfnCallback;
+            pAsyncRequestInfo->dwCallbackInst =
+                ptLineClient->dwCallbackInstance;
+
+            pAsyncRequestInfo->dwParam1 = sizeof (ASYNCREQUESTINFO);
+            pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lpsDigits;
+            pAsyncRequestInfo->dwParam3 = (DWORD) pParams->dwNumDigits;
+            pAsyncRequestInfo->dwParam4 = (DWORD) pParams->hCall;
+
+            pAsyncRequestInfo->pfnClientPostProcessProc =
+                pParams->pfnPostProcessProc;
+        }
+        else
+        {
+            //
+            // Client wants to cancel gathering, so just set these two to null
+            //
+
+            lpsDigits = NULL;
+            pAsyncRequestInfo = NULL;
+        }
+
+        if ((pParams->lResult = CallSP8(
+                pfnTSPI_lineGatherDigits,
+                "lineGatherDigits",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) dwDigitModes,
+                (DWORD) lpsDigits,
+                (DWORD) pParams->dwNumDigits,
+                (pParams->dwTerminationDigitsOffset == TAPI_NO_DATA ? 0 :
+                    (DWORD) (pDataBuf + pParams->dwTerminationDigitsOffset)),
+                (DWORD) pParams->dwFirstDigitTimeout,
+                (DWORD) pParams->dwInterDigitTimeout
+
+                )) != 0)
+        {
+            if (pAsyncRequestInfo)
+            {
+                ServerFree (pAsyncRequestInfo);
+            }
+        }
+    }
+
+LGatherDigits_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GatherDigits"
+        );
+}
+
+
+void
+WINAPI
+LGenerateDigits(
+    PLINEGENERATEDIGITS_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    TSPIPROC            pfnTSPI_lineGenerateDigits;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGENERATEDIGITS,      // provider func index
+            &pfnTSPI_lineGenerateDigits,// provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GenerateDigits"            // func name
+
+            )) == 0)
+    {
+        DWORD   dwDigitMode = pParams->dwDigitMode, *pInstData;
+
+
+        if (dwDigitMode != LINEDIGITMODE_PULSE  &&
+            dwDigitMode != LINEDIGITMODE_DTMF)
+        {
+            pParams->lResult = LINEERR_INVALDIGITMODE;
+            goto LGenerateDigits_epilog;
+        }
+
+        if (pParams->dwDigitsOffset != TAPI_NO_DATA)
+        {
+            if (!(pInstData = ServerAlloc (2 * sizeof (DWORD))))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGenerateDigits_epilog;
+            }
+
+            pInstData[0] = (DWORD) pParams->hCall;
+            pInstData[1] = pParams->dwEndToEndID;
+        }
+        else
+        {
+            pInstData = NULL;
+        }
+
+        pParams->lResult = CallSP5(
+            pfnTSPI_lineGenerateDigits,
+            "lineGenerateDigits",
+            SP_FUNC_SYNC,
+            (DWORD) hdCall,
+            (DWORD) pInstData,  // used as dwEndToEndID
+            (DWORD) dwDigitMode,
+            (DWORD) (pParams->dwDigitsOffset == TAPI_NO_DATA ?
+                NULL : pDataBuf + pParams->dwDigitsOffset),
+            (DWORD) pParams->dwDuration
+            );
+
+        if (pParams->lResult != 0  &&  pInstData != NULL)
+        {
+            ServerFree (pInstData);
+        }
+    }
+
+LGenerateDigits_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GenerateDigits"
+        );
+}
+
+
+void
+WINAPI
+LGenerateTone(
+    PLINEGENERATETONE_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    TSPIPROC            pfnTSPI_lineGenerateTone;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGENERATETONE,        // provider func index
+            &pfnTSPI_lineGenerateTone,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GenerateTone"              // func name
+
+            )) == 0)
+    {
+        DWORD   dwToneMode = pParams->dwToneMode, *pInstData;
+
+
+        if (dwToneMode != 0)
+        {
+            if (!(dwToneMode & AllToneModes) ||
+                !IsOnlyOneBitSetInDWORD (dwToneMode))
+            {
+                pParams->lResult = LINEERR_INVALTONEMODE;
+                goto LGenerateTone_epilog;
+            }
+            else if (!(pInstData = ServerAlloc (2 * sizeof (DWORD))))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGenerateTone_epilog;
+            }
+
+            pInstData[0] = (DWORD) pParams->hCall;
+            pInstData[1] = pParams->dwEndToEndID;
+        }
+        else
+        {
+            pInstData = NULL;
+        }
+
+        pParams->lResult = CallSP6(
+            pfnTSPI_lineGenerateTone,
+            "lineGenerateTone",
+            SP_FUNC_SYNC,
+            (DWORD) hdCall,
+            (DWORD) pInstData,              // used as dwEndToEndID
+            (DWORD) pParams->dwToneMode,
+            (DWORD) pParams->dwDuration,
+            (DWORD) pParams->dwNumTones,
+            (DWORD) pDataBuf + pParams->dwTonesOffset
+            );
+
+        if (pParams->lResult != 0  &&  pInstData)
+        {
+            ServerFree (pInstData);
+        }
+    }
+
+LGenerateTone_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GenerateTone"
+        );
+}
+
+
+void
+WINAPI
+LGetAddressCaps(
+    PLINEGETADDRESSCAPS_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwDeviceID = pParams->dwDeviceID;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineGetAddressCaps;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hLineApp,  // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETADDRESSCAPS,      // provider func index
+            &pfnTSPI_lineGetAddressCaps,// provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetAddressCaps"            // func name
+
+            )) == 0)
+    {
+        DWORD               dwAPIVersion, dwSPIVersion, dwTotalSize,
+                            dwFixedSizeClient, dwFixedSizeSP;
+        LPLINEADDRESSCAPS   pAddrCaps = (LPLINEADDRESSCAPS) pDataBuf,
+                            pAddrCaps2 = (LPLINEADDRESSCAPS) NULL;
+
+
+        //
+        // Verify API & SPI version compatibility
+        //
+
+        dwAPIVersion = pParams->dwAPIVersion;
+
+        dwSPIVersion = (GetLineLookupEntry (dwDeviceID))->dwSPIVersion;
+
+        if (!IsAPIVersionInRange (dwAPIVersion, dwSPIVersion))
+        {
+            pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+            goto LGetAddressCaps_epilog;
+        }
+
+
+        //
+        // Verify Ext version compatibility
+        //
+
+        if (!IsValidLineExtVersion (dwDeviceID, pParams->dwExtVersion))
+        {
+            pParams->lResult = LINEERR_INCOMPATIBLEEXTVERSION;
+            goto LGetAddressCaps_epilog;
+        }
+
+
+        //
+        // Determine the fixed siize of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwTotalSize = pParams->u.dwAddressCapsTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwFixedSizeClient = 176;    // 44 * sizeof (DWORD);
+            break;
+
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 180;    // 45 * sizeof (DWORD);
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (LINEADDRESSCAPS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetAddressCaps_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwFixedSizeSP = 176;        // 44 * sizeof (DWORD);
+            break;
+
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 180;        // 45 * sizeof (DWORD);
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (LINEADDRESSCAPS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pAddrCaps2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGetAddressCaps_epilog;
+            }
+
+            pAddrCaps   = pAddrCaps2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pAddrCaps,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pAddrCaps2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP5(
+                pfnTSPI_lineGetAddressCaps,
+                "lineGetAddressCaps",
+                SP_FUNC_SYNC,
+                (DWORD) dwDeviceID,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) dwSPIVersion,
+                (DWORD) pParams->dwExtVersion,
+                (DWORD) pAddrCaps
+
+                )) == 0)
+        {
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+
+            //
+            // Add the fields we're responsible for
+            //
+
+            pAddrCaps->dwCallInfoStates |= LINECALLINFOSTATE_NUMOWNERINCR |
+                                           LINECALLINFOSTATE_NUMOWNERDECR |
+                                           LINECALLINFOSTATE_NUMMONITORS;
+
+            pAddrCaps->dwCallStates |= LINECALLSTATE_UNKNOWN;
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+            if ((dwAPIVersion == TAPI_VERSION1_0) &&
+                (pAddrCaps->dwForwardModes &
+                    (LINEFORWARDMODE_UNKNOWN | LINEFORWARDMODE_UNAVAIL)))
+            {
+// BUGBUG?? LGetAddrssCaps: compare w/ orig src
+
+                pAddrCaps->dwForwardModes &=
+                            ~(LINEFORWARDMODE_UNKNOWN |
+                            LINEFORWARDMODE_UNAVAIL);
+
+                pAddrCaps->dwForwardModes |= LINEFORWARDMODE_UNCOND;
+            }
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pAddrCaps == pAddrCaps2)
+            {
+                pAddrCaps = (LPLINEADDRESSCAPS) pDataBuf;
+
+                CopyMemory (pAddrCaps, pAddrCaps2, dwFixedSizeClient);
+
+                ServerFree (pAddrCaps2);
+
+                pAddrCaps->dwTotalSize = pParams->u.dwAddressCapsTotalSize;
+                pAddrCaps->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwAddressCapsOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pAddrCaps->dwUsedSize;
+         }
+    }
+
+LGetAddressCaps_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetAddressCaps"
+        );
+}
+
+
+void
+WINAPI
+LGetAddressID(
+    PLINEGETADDRESSID_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineGetAddressID;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETADDRESSID,        // provider func index
+            &pfnTSPI_lineGetAddressID,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetAddressID"              // func name
+
+            )) == 0)
+    {
+        if (pParams->dwAddressMode == LINEADDRESSMODE_DIALABLEADDR)
+        {
+            pParams->lResult = CallSP5(
+                pfnTSPI_lineGetAddressID,
+                "lineGetAddressID",
+                SP_FUNC_SYNC,
+                (DWORD) hdLine,
+                (DWORD) &pParams->dwAddressID,
+                (DWORD) pParams->dwAddressMode,
+                (DWORD) pDataBuf + pParams->dwAddressOffset,
+                (DWORD) pParams->dwSize
+                );
+
+            *pdwNumBytesReturned = sizeof (LINEGETADDRESSID_PARAMS);
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALADDRESSMODE;
+        }
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetAddressID"
+        );
+}
+
+
+void
+WINAPI
+LGetAddressStatus(
+    PLINEGETADDRESSSTATUS_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineGetAddressStatus;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETADDRESSSTATUS,    // provider func index
+            &pfnTSPI_lineGetAddressStatus,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetAddressStatus"          // func name
+
+            )) == 0)
+    {
+        DWORD               dwAPIVersion, dwSPIVersion, dwTotalSize,
+                            dwFixedSizeClient, dwFixedSizeSP;
+        PTLINECLIENT        ptLineClient = (PTLINECLIENT) pParams->hLine;
+        LPLINEADDRESSSTATUS pAddrStatus = (LPLINEADDRESSSTATUS) pDataBuf,
+                            pAddrStatus2 = (LPLINEADDRESSSTATUS) NULL;
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwAPIVersion = ptLineClient->dwAPIVersion;
+
+        dwTotalSize = pParams->u.dwAddressStatusTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 64;     // 16 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (LINEADDRESSSTATUS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetAddressStatus_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        dwSPIVersion = ptLineClient->ptLine->dwSPIVersion;
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 64;         // 16 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (LINEADDRESSSTATUS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pAddrStatus2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGetAddressStatus_epilog;
+            }
+
+            pAddrStatus = pAddrStatus2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pAddrStatus,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pAddrStatus2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_lineGetAddressStatus,
+                "lineGetAddressStatus",
+                SP_FUNC_SYNC,
+                (DWORD) hdLine,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) pAddrStatus
+
+                )) == 0)
+        {
+            DWORD   dwForwardNumEntries;
+
+
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+
+            //
+            // Add the fields we're responsible for
+            //
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+            if ((dwAPIVersion == TAPI_VERSION1_0) &&
+                (dwForwardNumEntries = pAddrStatus->dwForwardNumEntries))
+            {
+                DWORD           i;
+                LPLINEFORWARD   pLineForward;
+
+
+                pLineForward = (LPLINEFORWARD) (((LPBYTE) pAddrStatus) +
+                    pAddrStatus->dwForwardOffset);
+
+                for (i = 0; i < dwForwardNumEntries; i++, pLineForward++)
+                {
+                    if (pLineForward->dwForwardMode &
+                        (LINEFORWARDMODE_UNKNOWN | LINEFORWARDMODE_UNAVAIL))
+                    {
+                        pLineForward->dwForwardMode &=
+                            ~(LINEFORWARDMODE_UNKNOWN |
+                            LINEFORWARDMODE_UNAVAIL);
+
+                        pLineForward->dwForwardMode |= LINEFORWARDMODE_UNCOND;
+                    }
+                }
+            }
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pAddrStatus == pAddrStatus2)
+            {
+                pAddrStatus = (LPLINEADDRESSSTATUS) pDataBuf;
+
+                CopyMemory (pAddrStatus, pAddrStatus2, dwFixedSizeClient);
+
+                ServerFree (pAddrStatus2);
+
+                pAddrStatus->dwTotalSize =
+                    pParams->u.dwAddressStatusTotalSize;
+                pAddrStatus->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwAddressStatusOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pAddrStatus->dwUsedSize;
+        }
+    }
+
+LGetAddressStatus_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetAddressStatus"
+        );
+}
+
+
+void
+LGetAgentXxx_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    PASYNCEVENTMSG          pNewAsyncEventMsg = (PASYNCEVENTMSG)
+                                pAsyncRequestInfo->dwParam3;
+
+
+    CopyMemory (pNewAsyncEventMsg, pAsyncEventMsg, sizeof (ASYNCEVENTMSG));
+
+    *ppBuf = pNewAsyncEventMsg;
+
+    if (pAsyncEventMsg->dwParam2 == 0)  // success
+    {
+        LPLINEAGENTACTIVITYLIST pActivityList = (LPLINEAGENTACTIVITYLIST)
+                                    pNewAsyncEventMsg + 1;
+
+
+        pNewAsyncEventMsg->dwTotalSize += pActivityList->dwUsedSize;
+
+        pNewAsyncEventMsg->dwParam3 = pAsyncRequestInfo->dwParam1;
+    }
+}
+
+
+#if DBG
+void
+PASCAL
+LGetAgentXxx(
+    PLINEGETAGENTACTIVITYLIST_PARAMS    pParams,
+    DWORD                               dwRequestType,
+    DWORD                               dwSPIOrdinal,
+    DWORD                               dwFixedStructSize,
+    char                               *pszFuncName
+    )
+#else
+void
+PASCAL
+LGetAgentXxx(
+    PLINEGETAGENTACTIVITYLIST_PARAMS    pParams,
+    DWORD                               dwRequestType,
+    DWORD                               dwSPIOrdinal,
+    DWORD                               dwFixedStructSize
+    )
+#endif
+{
+    //
+    // Since LGetAgentActivityList, LGetAgentGroupList, and LGetAgentStatus
+    // all do the same thing (& the params are more or less identical) we
+    // can safely condense all the functionality into this one procedure
+    //
+
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            pszFuncName                 // func name
+
+            )) > 0)
+    {
+        DWORD           dwTotalSize = pParams->dwActivityListTotalSize;
+        PTLINE          ptLine;
+        PTLINECLIENT    pProxy;
+
+
+        if (dwTotalSize < dwFixedStructSize)
+        {
+            lRequestID = LINEERR_STRUCTURETOOSMALL;
+            goto LGetAgentXxx_epilog;
+        }
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+            pProxy = ptLine->apProxys[dwRequestType];
+
+            if (pParams->dwAddressID >= ptLine->dwNumAddresses)
+            {
+                lRequestID = LINEERR_INVALADDRESSID;
+                goto LGetAgentXxx_epilog;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+            goto LGetAgentXxx_epilog;
+        }
+
+
+        //
+        // Save the client's buf ptr & post processing proc ptr
+        //
+
+        pAsyncRequestInfo->dwParam1 = pParams->lpAgentActivityList;
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+
+        //
+        // First check to see if there's a (local) proxy registered
+        // for this type of request on this line.  If so, build a
+        // request & send it to the proxy.
+        //
+
+        if (pProxy)
+        {
+            LONG                    lResult;
+            PPROXYREQUESTWRAPPER    pProxyRequestWrapper;
+
+
+            if ((lResult = CreateProxyRequest(
+                    pProxy,
+                    dwRequestType,
+                    2 * sizeof (DWORD),
+                    pAsyncRequestInfo,
+                    &pProxyRequestWrapper
+                    )))
+            {
+                lRequestID = lResult;
+                goto LGetAgentXxx_epilog;
+            }
+
+            pProxyRequestWrapper->ProxyRequest.GetAgentActivityList.
+                dwAddressID = pParams->dwAddressID;
+            pProxyRequestWrapper->ProxyRequest.GetAgentActivityList.
+                ActivityList.dwTotalSize = dwTotalSize;
+
+
+            //
+            // Change the async request info key so we can verify stuff
+            // when lineProxyRequest is called
+            //
+
+            pAsyncRequestInfo->dwKey = (DWORD) pProxy;
+
+            if ((lResult = SendProxyRequest(
+                    pProxy,
+                    pProxyRequestWrapper,
+                    pAsyncRequestInfo
+                    )))
+            {
+                lRequestID = lResult;
+                goto LGetAgentXxx_epilog;
+            }
+            else // success
+            {
+                pParams->lResult = (LONG) pAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // There's no proxy, so check to see if line is remote and
+        // call remotesp if so
+        //
+
+        else if ((GetLineLookupEntry (ptLine->dwDeviceID))->bRemote)
+        {
+            LPBYTE                  pBuf;
+            LPLINEAGENTACTIVITYLIST pActivityList;
+
+
+            //
+            // Alloc a shadow buf that the SP can use until it completes this
+            // request.  Make sure there's enough extra space in the buf for
+            // an ASYNCEVENTMSG header so we don't have to alloc yet another
+            // buf in the post processing proc when preparing the completion
+            // msg to send to the client, and that the msg is 64-bit aligned.
+            //
+
+            if (!(pBuf = ServerAlloc(
+                    sizeof (ASYNCEVENTMSG) + ((dwTotalSize + 8) & 0xfffffff7)
+                    )))
+            {
+                lRequestID = LINEERR_NOMEM;
+                goto LGetAgentXxx_epilog;
+            }
+
+            pAsyncRequestInfo->pfnPostProcess =
+                LGetAgentXxx_PostProcess;
+
+            pAsyncRequestInfo->dwParam2 = dwTotalSize;
+            pAsyncRequestInfo->dwParam3 = (DWORD) pBuf;
+
+            pActivityList = (LPLINEAGENTACTIVITYLIST)
+                (pBuf + sizeof (ASYNCEVENTMSG));
+
+            pActivityList->dwTotalSize = dwTotalSize;
+
+            pParams->lResult = CallSP4(
+                pRemoteSP->apfn[dwSPIOrdinal],
+                pszFuncName,
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdLine,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) pActivityList
+                );
+        }
+
+
+        //
+        // There's no registered proxy & line is not remote, so fail
+        //
+
+        else
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+
+LGetAgentXxx_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        pszFuncName
+        );
+}
+
+
+void
+WINAPI
+LGetAgentActivityList(
+    PLINEGETAGENTACTIVITYLIST_PARAMS    pParams,
+    LPBYTE                              pDataBuf,
+    LPDWORD                             pdwNumBytesReturned
+    )
+{
+    LGetAgentXxx(
+        pParams,
+        LINEPROXYREQUEST_GETAGENTACTIVITYLIST,
+        SP_LINEGETAGENTACTIVITYLIST,
+        sizeof (LINEAGENTACTIVITYLIST)
+#if DBG
+        ,
+        "GetAgentActivityList"
+#endif
+        );
+}
+
+
+void
+WINAPI
+LGetAgentCaps(
+    PLINEGETAGENTCAPS_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    DWORD               dwDeviceID = pParams->dwDeviceID;
+    HANDLE              hMutex;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hLineApp,  // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "GetAgentCaps"              // func name
+
+            )) > 0)
+    {
+        DWORD               dwTotalSize = pParams->dwAgentCapsTotalSize;
+        PTLINE              ptLine;
+        PTLINECLIENT        pProxy;
+        PTLINELOOKUPENTRY   pLookupEntry = GetLineLookupEntry (dwDeviceID);
+
+
+        if (dwTotalSize < sizeof (LINEAGENTCAPS))
+        {
+            lRequestID = LINEERR_STRUCTURETOOSMALL;
+            goto LGetAgentCaps_epilog;
+        }
+
+        if (pParams->dwAppAPIVersion != TAPI_VERSION2_0)
+        {
+            lRequestID = LINEERR_INCOMPATIBLEAPIVERSION;
+            goto LGetAgentCaps_epilog;
+        }
+
+        try
+        {
+            if (!(ptLine = pLookupEntry->ptLine))
+            {
+                lRequestID = LINEERR_OPERATIONUNAVAIL;
+                goto LGetAgentCaps_epilog;
+            }
+
+            pProxy = ptLine->apProxys[LINEPROXYREQUEST_GETAGENTCAPS];
+
+            if (pParams->dwAddressID >= ptLine->dwNumAddresses)
+            {
+                lRequestID = LINEERR_INVALADDRESSID;
+                goto LGetAgentCaps_epilog;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+            goto LGetAgentCaps_epilog;
+        }
+
+
+        //
+        // Save the client's buf ptr & post processing proc ptr
+        //
+
+        pAsyncRequestInfo->dwParam1 = pParams->lpAgentCaps;
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+
+        //
+        // First check to see if there's a (local) proxy registered
+        // for this type of request on this line.  If so, build a
+        // request & send it to the proxy.
+        //
+
+        if (pProxy)
+        {
+            LONG                    lResult;
+            PPROXYREQUESTWRAPPER    pProxyRequestWrapper;
+
+
+            if ((lResult = CreateProxyRequest(
+                    pProxy,
+                    LINEPROXYREQUEST_GETAGENTCAPS,
+                    2 * sizeof (DWORD),
+                    pAsyncRequestInfo,
+                    &pProxyRequestWrapper
+                    )))
+            {
+                lRequestID = lResult;
+                goto LGetAgentCaps_epilog;
+            }
+
+            pProxyRequestWrapper->ProxyRequest.GetAgentCaps.dwAddressID =
+                pParams->dwAddressID;
+            pProxyRequestWrapper->ProxyRequest.GetAgentCaps.
+                AgentCaps.dwTotalSize = dwTotalSize;
+
+
+            //
+            // Change the async request info key so we can verify stuff
+            // when lineProxyRequest is called
+            //
+
+            pAsyncRequestInfo->dwKey = (DWORD) pProxy;
+
+            if ((lResult = SendProxyRequest(
+                    pProxy,
+                    pProxyRequestWrapper,
+                    pAsyncRequestInfo
+                    )))
+            {
+                lRequestID = lResult;
+                goto LGetAgentCaps_epilog;
+            }
+            else // success
+            {
+                pParams->lResult = (LONG) pAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // There's no proxy, so check to see if line is remote and
+        // call remotesp if so
+        //
+
+        else if (pLookupEntry->bRemote)
+        {
+            LPBYTE          pBuf;
+            LPLINEAGENTCAPS pCaps;
+
+
+            //
+            // Alloc a shadow buf that the SP can use until it completes this
+            // request.  Make sure there's enough extra space in the buf for
+            // an ASYNCEVENTMSG header so we don't have to alloc yet another
+            // buf in the post processing proc when preparing the completion
+            // msg to send to the client, and that the msg is 64-bit aligned.
+            //
+
+            if (!(pBuf = ServerAlloc(
+                    sizeof (ASYNCEVENTMSG) + ((dwTotalSize + 8) & 0xfffffff7)
+                    )))
+            {
+                lRequestID = LINEERR_NOMEM;
+                goto LGetAgentCaps_epilog;
+            }
+
+            pAsyncRequestInfo->pfnPostProcess =
+                LGetAgentXxx_PostProcess;
+
+            pAsyncRequestInfo->dwParam2 = dwTotalSize;
+            pAsyncRequestInfo->dwParam3 = (DWORD) pBuf;
+
+            pCaps = (LPLINEAGENTCAPS) (pBuf + sizeof (ASYNCEVENTMSG));
+
+            pCaps->dwTotalSize = dwTotalSize;
+
+            // Note: RemoteSP comes up with it's own hLineApp
+
+            pParams->lResult = CallSP5(
+                pRemoteSP->apfn[SP_LINEGETAGENTCAPS],
+                "lineGetAgentCaps",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) dwDeviceID,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) pParams->dwAppAPIVersion,
+                (DWORD) pCaps
+                );
+        }
+
+
+        //
+        // There's no registered proxy & line is not remote, so fail
+        //
+
+        else
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+
+LGetAgentCaps_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "GetAgentCaps"
+        );
+}
+
+
+void
+WINAPI
+LGetAgentGroupList(
+    PLINEGETAGENTGROUPLIST_PARAMS   pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    LGetAgentXxx(
+        (PLINEGETAGENTACTIVITYLIST_PARAMS) pParams,
+        LINEPROXYREQUEST_GETAGENTGROUPLIST,
+        SP_LINEGETAGENTGROUPLIST,
+        sizeof (LINEAGENTGROUPLIST)
+#if DBG
+        ,
+        "GetAgentGroupList"
+#endif
+        );
+}
+
+
+void
+WINAPI
+LGetAgentStatus(
+    PLINEGETAGENTSTATUS_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    LGetAgentXxx(
+        (PLINEGETAGENTACTIVITYLIST_PARAMS) pParams,
+        LINEPROXYREQUEST_GETAGENTSTATUS,
+        SP_LINEGETAGENTSTATUS,
+        sizeof (LINEAGENTSTATUS)
+#if DBG
+        ,
+        "GetAgentStatus"
+#endif
+        );
+}
+
+
+void
+WINAPI
+LGetAppPriority(
+    PLINEGETAPPPRIORITY_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    DWORD   dwMediaMode = pParams->dwMediaMode,
+            dwRequestMode = pParams->dwRequestMode;
+
+
+// BUGBUG  LGetAppPriority: ext mm's
+
+    if (dwMediaMode == 0)
+    {
+        if ((dwRequestMode != LINEREQUESTMODE_MAKECALL) &&
+            (dwRequestMode != LINEREQUESTMODE_MEDIACALL))
+        {
+            pParams->lResult = LINEERR_INVALREQUESTMODE;
+            goto LGetAppPriority_return;
+        }
+    }
+    else if (IsOnlyOneBitSetInDWORD (dwMediaMode))
+    {
+        if (dwMediaMode & 0xff000000)
+        {
+        }
+        else if (dwMediaMode & ~AllMediaModes1_4)
+        {
+            pParams->lResult = LINEERR_INVALMEDIAMODE;
+            goto LGetAppPriority_return;
+        }
+    }
+    else
+    {
+        pParams->lResult = LINEERR_INVALMEDIAMODE;
+        goto LGetAppPriority_return;
+    }
+
+
+    if ((dwMediaMode & 0x00ffffff) || (dwMediaMode == 0))
+    {
+        WCHAR   szModuleName[MAX_PATH];
+        WCHAR  *pszCurrentPriorityList;
+        WCHAR  *pszLocationInPriorityList;
+
+
+        szModuleName[0] = '"';
+        lstrcpyW(szModuleName + 1, (PWSTR)(pDataBuf + pParams->dwAppNameOffset));
+        CharUpperW (szModuleName + 1);
+
+
+        //
+        // Enter the pri list critical section before we start looking
+        //
+
+        EnterCriticalSection (&gPriorityListCritSec);
+
+
+        //
+        // Determine which of the priority lists we want to look at
+        //
+
+        if (dwMediaMode)
+        {
+            DWORD dwMaskBit, dwPriorityListIndex;
+
+
+            for(
+                dwPriorityListIndex = 0, dwMaskBit = 1;
+                dwMaskBit != pParams->dwMediaMode;
+                dwPriorityListIndex++, dwMaskBit <<= 1
+                );
+
+            pszCurrentPriorityList =
+                TapiGlobals.apszPriorityList[dwPriorityListIndex];
+        }
+        else
+        {
+            pszCurrentPriorityList = (dwRequestMode == LINEREQUESTMODE_MAKECALL
+                ? TapiGlobals.pszReqMakeCallPriList :
+                TapiGlobals.pszReqMediaCallPriList);
+        }
+
+
+        if (pszCurrentPriorityList &&
+
+            (pszLocationInPriorityList = wcsstr(
+                pszCurrentPriorityList,
+                szModuleName
+                )))
+        {
+            //
+            // App is in pri list, determine it's position
+            //
+
+            WCHAR  *p = pszCurrentPriorityList + 1; // skip first '"'
+            DWORD   i;
+
+
+            for (i = 1; pszLocationInPriorityList > p; i++)
+            {
+                p = wcschr(p, '"');
+                p++;
+            }
+
+            pParams->dwPriority = i;
+        }
+        else
+        {
+            //
+            // App not listed in formal priority list, so just return 0
+            //
+            // Note: TAPI 1.4 said that if app was in soft pri list
+            //       (i.e. had line open with OWNER priv for specified
+            //       media mode) then we'd return -1 instead of 0.
+            //       But that's a pain to figure out, & we figured no
+            //       one was going to use that info anyway, so we settled
+            //       for always returning 0.
+            //
+
+            pParams->dwPriority = 0;
+        }
+
+
+        //
+        // Leave list critical section now that we're done
+        //
+
+        LeaveCriticalSection (&gPriorityListCritSec);
+
+        *pdwNumBytesReturned = sizeof (LINEGETAPPPRIORITY_PARAMS);
+    }
+
+LGetAppPriority_return:
+
+    DBGOUT((
+        3,
+        "LineEpilogSync (lineGetAppPriority) exit, returning x%x",
+        pParams->lResult
+        ));
+}
+
+
+void
+WINAPI
+LGetCallAddressID(
+    PLINEGETCALLADDRESSID_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineGetCallAddressID;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETCALLADDRESSID,    // provider func index
+            &pfnTSPI_lineGetCallAddressID,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetCallAddressID"          // func name
+
+            )) == 0)
+    {
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_lineGetCallAddressID,
+                "lineGetCallAddressID",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) &pParams->dwAddressID
+
+                )) == 0)
+        {
+            *pdwNumBytesReturned = sizeof (LINEGETCALLADDRESSID_PARAMS);
+        }
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetCallAddressID"
+        );
+}
+
+void
+WINAPI
+LGetCallInfo(
+    PLINEGETCALLINFO_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineGetCallInfo;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETCALLINFO,         // provider func index
+            &pfnTSPI_lineGetCallInfo,   // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetCallInfo"               // func name
+
+            )) == 0)
+    {
+        DWORD           dwAPIVersion, dwSPIVersion, dwTotalSize,
+                        dwFixedSizeClient, dwFixedSizeSP;
+        PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) pParams->hCall;
+        PTCALL          ptCall = ptCallClient->ptCall;
+        LPLINECALLINFO  pCallInfo = (LPLINECALLINFO) pDataBuf,
+                        pCallInfo2 = (LPLINECALLINFO) NULL;
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwAPIVersion =
+            ((PTLINECLIENT) ptCallClient->ptLineClient)->dwAPIVersion;
+
+        dwTotalSize = pParams->u.dwCallInfoTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 296;    // 69 * sizeof(DWORD) + sizeof (HLINE)
+                                        //     + sizeof (LINEDIALPARAMS)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (LINECALLINFO);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetCallInfo_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        dwSPIVersion = ((PTLINE) ptCall->ptLine)->dwSPIVersion;
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 296;        // 69 * sizeof(DWORD) + sizeof (HLINE)
+                                        //     + sizeof (LINEDIALPARAMS)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (LINECALLINFO);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pCallInfo2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGetCallInfo_epilog;
+            }
+
+            pCallInfo   = pCallInfo2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pCallInfo,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pCallInfo2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_lineGetCallInfo,
+                "lineGetCallInfo",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) pCallInfo
+
+                )) == 0)
+        {
+            //
+            // Safely add the fields we're responsible for
+            //
+
+            try
+            {
+                pCallInfo->hLine = (HLINE) ptCallClient->ptLineClient;
+
+                pCallInfo->dwMonitorDigitModes =
+                    ptCallClient->dwMonitorDigitModes;
+                pCallInfo->dwMonitorMediaModes =
+                    ptCallClient->dwMonitorMediaModes;
+
+// BUGBUG LGetCallInfo: app name
+
+                pCallInfo->dwNumOwners   = ptCall->dwNumOwners;
+                pCallInfo->dwNumMonitors = ptCall->dwNumMonitors;
+
+                InsertVarData(
+                    pCallInfo,
+                    &pCallInfo->dwAppNameSize,
+                    ptCall->pszAppName,
+                    ptCall->dwAppNameSize
+                    );
+
+                InsertVarData(
+                    pCallInfo,
+                    &pCallInfo->dwDisplayableAddressSize,
+                    ptCall->pszDisplayableAddress,
+                    ptCall->dwDisplayableAddressSize
+                    );
+
+                InsertVarData(
+                    pCallInfo,
+                    &pCallInfo->dwCalledPartySize,
+                    ptCall->pszCalledParty,
+                    ptCall->dwCalledPartySize
+                    );
+
+                InsertVarData(
+                    pCallInfo,
+                    &pCallInfo->dwCommentSize,
+                    ptCall->pszComment,
+                    ptCall->dwCommentSize
+                    );
+            }
+            myexcept
+            {
+                pParams->lResult = LINEERR_INVALCALLHANDLE;
+            }
+
+            pCallInfo->dwCallStates |= LINECALLSTATE_UNKNOWN;
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+            if (dwAPIVersion == TAPI_VERSION1_0)
+            {
+                if (pCallInfo->dwOrigin & LINECALLORIGIN_INBOUND)
+                {
+                    pCallInfo->dwOrigin = LINECALLORIGIN_UNAVAIL;
+                }
+
+                if ((pCallInfo->dwReason &
+                    (LINECALLREASON_INTRUDE | LINECALLREASON_PARKED)))
+                {
+                    pCallInfo->dwReason = LINECALLREASON_UNAVAIL;
+                }
+            }
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pCallInfo == pCallInfo2)
+            {
+                pCallInfo = (LPLINECALLINFO) pDataBuf;
+
+                CopyMemory (pCallInfo, pCallInfo2, dwFixedSizeClient);
+
+                ServerFree (pCallInfo2);
+
+                pCallInfo->dwTotalSize = pParams->u.dwCallInfoTotalSize;
+                pCallInfo->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            if (pParams->lResult == 0)
+            {
+                pParams->u.dwCallInfoOffset = 0;
+
+                *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                    pCallInfo->dwUsedSize;
+            }
+        }
+    }
+
+LGetCallInfo_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetCallInfo"
+        );
+}
+
+
+void
+WINAPI
+LGetCallStatus(
+    PLINEGETCALLSTATUS_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineGetCallStatus;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETCALLSTATUS,       // provider func index
+            &pfnTSPI_lineGetCallStatus, // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetCallStatus"             // func name
+
+            )) == 0)
+    {
+        DWORD               dwAPIVersion, dwSPIVersion, dwTotalSize,
+                            dwFixedSizeClient, dwFixedSizeSP;
+        PTCALLCLIENT        ptCallClient = (PTCALLCLIENT) pParams->hCall;
+        LPLINECALLSTATUS    pCallStatus = (LPLINECALLSTATUS) pDataBuf,
+                            pCallStatus2 = (LPLINECALLSTATUS) NULL;
+
+
+        //
+        // Determine the fixed siize of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwAPIVersion =
+            ((PTLINECLIENT) ptCallClient->ptLineClient)->dwAPIVersion;
+
+        dwTotalSize = pParams->u.dwCallStatusTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 36;     // 9 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (LINECALLSTATUS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetCallStatus_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        dwSPIVersion = ((PTLINE) ptCallClient->ptCall->ptLine)->dwSPIVersion;
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 36;         // 9 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (LINECALLSTATUS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pCallStatus2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGetCallStatus_epilog;
+            }
+
+            pCallStatus = pCallStatus2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pCallStatus,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pCallStatus2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_lineGetCallStatus,
+                "lineGetCallStatus",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) pCallStatus
+
+                )) == 0)
+        {
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+            //
+            // Add the fields we're responsible for
+            //
+
+            pCallStatus->dwCallPrivilege =
+                ((PTCALLCLIENT) pParams->hCall)->dwPrivilege;
+
+// BUGBUG LGetCallStatus: fill in pCallStatus->tStateEntrytTime?
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pCallStatus == pCallStatus2)
+            {
+                pCallStatus = (LPLINECALLSTATUS) pDataBuf;
+
+                CopyMemory (pCallStatus, pCallStatus2, dwFixedSizeClient);
+
+                ServerFree (pCallStatus2);
+
+                pCallStatus->dwTotalSize = pParams->u.dwCallStatusTotalSize;
+                pCallStatus->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwCallStatusOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pCallStatus->dwUsedSize;
+
+        }
+    }
+
+LGetCallStatus_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetCallStatus"
+        );
+}
+
+
+void
+WINAPI
+LGetConfRelatedCalls(
+    PLINEGETCONFRELATEDCALLS_PARAMS pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    DWORD               dwTotalSize = pParams->u.dwCallListTotalSize;
+    PTCALLCLIENT        ptCallClient;
+    PTLINECLIENT        ptLineClient;
+    LPLINECALLLIST      pCallList = (LPLINECALLLIST) pDataBuf;
+    TPOINTERLIST        confCallList, *pConfCallList = &confCallList;
+    PTCONFERENCELIST    pConfList;
+
+
+    if (TapiGlobals.dwNumLineInits == 0)
+    {
+        pParams->lResult = LINEERR_UNINITIALIZED;
+        return;
+    }
+
+    if (dwTotalSize < sizeof (LINECALLLIST))
+    {
+        pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+        return;
+    }
+
+    if (!(ptCallClient = IsValidCall (pParams->hCall, pParams->ptClient)))
+    {
+        pParams->lResult = LINEERR_INVALCALLHANDLE;
+        return;
+    }
+
+    try
+    {
+        ptLineClient = (PTLINECLIENT) ptCallClient->ptLineClient;
+
+        if (!(pConfList = (PTCONFERENCELIST) ptCallClient->ptCall->pConfList))
+        {
+            pParams->lResult = LINEERR_NOCONFERENCE;
+            return;
+        }
+    }
+    myexcept
+    {
+        pParams->lResult = LINEERR_INVALCALLHANDLE;
+        return;
+    }
+
+    if ((pParams->lResult = GetConfCallListFromConf(
+            pConfList,
+            &pConfCallList
+
+            )) != 0)
+    {
+        return;
+    }
+
+    {
+        DWORD   dwNeededSize = sizeof (LINECALLLIST) +
+                    pConfCallList->dwNumUsedEntries * sizeof(DWORD);
+
+
+        if (dwTotalSize < dwNeededSize)
+        {
+            pCallList->dwNeededSize = dwNeededSize;
+            pCallList->dwUsedSize = sizeof (LINECALLLIST);
+
+            FillMemory (&pCallList->dwCallsNumEntries, 3 * sizeof (DWORD), 0);
+
+            goto LGetConfRelatedCalls_fillInList;
+        }
+    }
+
+
+    //
+    // For each call in the conf list see if the app has a
+    // call client (if not create one w/ monitor privileges)
+    // and add it to the list
+    //
+
+    {
+        DWORD   dwNumCallsInList = 0, i;
+        LPHCALL lphCallsInList = (LPHCALL) (pCallList + 1);
+
+
+        for (i = 0; i < pConfCallList->dwNumUsedEntries; i++)
+        {
+            BOOL    bDupedMutex;
+            HANDLE  hMutex;
+            PTCALL  ptCall = pConfCallList->aEntries[i];
+
+
+            if (WaitForExclusivetCallAccess(
+                    (HTAPICALL) ptCall,
+                    TCALL_KEY,
+                    &hMutex,
+                    &bDupedMutex,
+                    5
+                    ))
+            {
+                ptCallClient = ptCall->ptCallClients;
+
+                while (ptCallClient &&
+                        (ptCallClient->ptLineClient != ptLineClient))
+                {
+                    ptCallClient = ptCallClient->pNextSametCall;
+                }
+
+                if (!ptCallClient)
+                {
+                    LONG    lResult;
+
+                    if ((lResult = CreatetCallClient(
+                            ptCall,
+                            ptLineClient,
+                            LINECALLPRIVILEGE_MONITOR,
+                            TRUE,
+                            TRUE,
+                            &ptCallClient,
+                            FALSE
+                            )))
+                    {
+// BUGBUG LGetConfRelatedCalls: err creating tCallClient
+                    }
+                }
+
+                *(lphCallsInList++) = (HCALL) ptCallClient;
+                dwNumCallsInList++;
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+            }
+        }
+
+        pCallList->dwUsedSize        =
+        pCallList->dwNeededSize      = sizeof (LINECALLLIST) +
+                                           dwNumCallsInList * sizeof (HCALL);
+
+        pCallList->dwCallsNumEntries = dwNumCallsInList;
+        pCallList->dwCallsSize       = dwNumCallsInList * sizeof (HCALL);
+        pCallList->dwCallsOffset     = sizeof (LINECALLLIST);
+    }
+
+
+LGetConfRelatedCalls_fillInList:
+
+    if (pConfCallList != &confCallList)
+    {
+        ServerFree (pConfCallList);
+    }
+
+    pCallList->dwTotalSize = dwTotalSize;
+
+    pParams->u.dwCallListOffset = 0;
+
+    *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pCallList->dwUsedSize;
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineGetConfRelatedCalls: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+}
+
+
+void
+WINAPI
+LGetCountry(
+    PLINEGETCOUNTRY_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    LPLINECOUNTRYLIST pCountryList = (LPLINECOUNTRYLIST) pDataBuf;
+
+
+    BuildCountryList();
+
+
+    if (pParams->u.dwCountryListTotalSize < sizeof (LINECOUNTRYLIST))
+    {
+        pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+    }
+    else if (pParams->dwCountryID == 0)
+    {
+        //
+        // Client wants entire country list
+        //
+
+        if (pParams->u.dwCountryListTotalSize >= gpCountryList->dwNeededSize)
+        {
+            CopyMemory(
+                pCountryList,
+                gpCountryList,
+                gpCountryList->dwUsedSize
+                );
+        }
+        else
+        {
+            pCountryList->dwNeededSize = gpCountryList->dwNeededSize;
+            pCountryList->dwUsedSize   = sizeof(LINECOUNTRYLIST);
+            pCountryList->dwNumCountries      = 0;
+            pCountryList->dwCountryListSize   = 0;
+            pCountryList->dwCountryListOffset = 0;
+        }
+
+        *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+             pCountryList->dwUsedSize;
+
+        pCountryList->dwTotalSize = pParams->u.dwCountryListTotalSize;
+    }
+    else
+    {
+        //
+        // Caller wants single country
+        //
+        LPLINECOUNTRYLIST   pBuildCountryList;
+
+
+        if ( NULL == ( pBuildCountryList = ServerAlloc( sizeof(LINECOUNTRYLIST) +
+                                                   sizeof(LINECOUNTRYENTRY) +
+                                                   ((MAXLEN_NAME +
+                                                     MAXLEN_RULE +
+                                                     MAXLEN_RULE +
+                                                     MAXLEN_RULE +
+                                                     100) * sizeof(WCHAR))
+                                                 ) ) )
+        {
+            DBGOUT((1, "Alloc failed for countrylist"));
+            pParams->lResult = LINEERR_NOMEM;
+        }
+        else
+        {
+            LPLINECOUNTRYENTRY  pCountryEntrySource;
+            LPLINECOUNTRYENTRY  pCountryEntryDest;
+
+
+            pCountryEntryDest = (LPLINECOUNTRYENTRY)((PBYTE)pBuildCountryList +
+                                        sizeof(LINECOUNTRYLIST));
+
+            //
+            // search through the gpCountryList looking for the entry
+            //
+
+            pCountryEntrySource = (LPLINECOUNTRYENTRY)((PBYTE)gpCountryList +
+                                        sizeof(LINECOUNTRYLIST));
+
+            while (
+                     (pCountryEntrySource->dwCountryID != pParams->dwCountryID )
+                   &&
+                     (pCountryEntrySource->dwNextCountryID)
+                  )
+            {
+                pCountryEntrySource++;
+            }
+
+
+            if ( pCountryEntrySource->dwCountryID != pParams->dwCountryID )
+            {
+                DBGOUT((1, "Invalid Countrycode (%ld) in lineGetCountry",
+                                pParams->dwCountryID));
+                pParams->lResult = LINEERR_INVALCOUNTRYCODE;
+            }
+            else
+            {
+                PBYTE pCountryListToUse;
+                PBYTE pVarOffset;
+                PBYTE pOverrideList = NULL;
+                DWORD dwNeededSize;
+
+
+                //
+                // Is the caller calling a specific country that there might be
+                // an override for?
+                //
+                if ( pParams->dwDestCountryID != 0 )
+                {
+                    HKEY hKey;
+                    HKEY hKey2;
+                    PSTR p;
+
+                    p = ServerAlloc( 256 );
+
+                    wsprintf( p, "Country List\\%ld\\Exceptions\\%ld",
+                                   pParams->dwCountryID,
+                                   pParams->dwDestCountryID
+                            );
+
+                    RegOpenKeyEx(
+                                  HKEY_LOCAL_MACHINE,
+                                  gszRegKeyTelephony,
+                                  0,
+                                  KEY_READ,
+                                  &hKey2
+                                );
+
+                    //
+                    // Is there an exception?
+                    //
+                    if ( 0 == RegOpenKeyEx(
+                                            hKey2,
+                                            p,
+                                            0,
+                                            KEY_READ,
+                                            &hKey
+                                          )
+                       )
+                    {
+                        PBYTE pVarOffset;
+
+                        pOverrideList = ServerAlloc(
+                                                 sizeof(LINECOUNTRYLIST) +
+                                                 sizeof(LINECOUNTRYENTRY) +
+                                                   ((MAXLEN_NAME +
+                                                     MAXLEN_RULE +
+                                                     MAXLEN_RULE +
+                                                     MAXLEN_RULE +
+                                                     100) * sizeof(WCHAR))
+                                               );
+
+                        pCountryListToUse = pOverrideList;
+
+                        pCountryEntrySource = (LPLINECOUNTRYENTRY)
+                                                 (pOverrideList +
+                                                  sizeof(LINECOUNTRYLIST));
+
+                        pVarOffset = pOverrideList +
+                                            sizeof(LINECOUNTRYLIST) +
+                                            sizeof(LINECOUNTRYENTRY);
+
+                        FillupACountryEntry( hKey,
+                                             pCountryListToUse,
+                                             pCountryEntrySource,
+                                             &pVarOffset
+                                           );
+
+                        RegCloseKey( hKey );
+                    }
+                    else
+                    {
+                        //
+                        // No, we tried, but there was no exception.
+                        //
+                        pCountryListToUse = (PBYTE)gpCountryList;
+                    }
+
+
+                    RegCloseKey( hKey2);
+
+                    ServerFree( p );
+
+                }
+                else
+                {
+                    pCountryListToUse = (PBYTE)gpCountryList;
+                }
+
+
+                //
+                // Fill in the buffer
+                //
+
+
+                dwNeededSize = sizeof(LINECOUNTRYLIST) +
+                               sizeof(LINECOUNTRYENTRY);
+
+                pVarOffset = (LPBYTE)pCountryEntryDest +
+                                  sizeof(LINECOUNTRYENTRY);
+
+                CopyMemory(
+                            pVarOffset,
+                            pCountryListToUse +
+                                pCountryEntrySource->dwCountryNameOffset,
+                            pCountryEntrySource->dwCountryNameSize
+                          );
+
+                pCountryEntryDest->dwCountryNameSize = 
+                           pCountryEntrySource->dwCountryNameSize;
+                pCountryEntryDest->dwCountryNameOffset = 
+                             pVarOffset - (LPBYTE)pBuildCountryList;
+                pVarOffset += pCountryEntrySource->dwCountryNameSize;
+                dwNeededSize += pCountryEntrySource->dwCountryNameSize;
+
+
+                CopyMemory(
+                            pVarOffset,
+                            pCountryListToUse +
+                                pCountryEntrySource->dwSameAreaRuleOffset,
+                            pCountryEntrySource->dwSameAreaRuleSize
+                          );
+
+                pCountryEntryDest->dwSameAreaRuleSize = 
+                           pCountryEntrySource->dwSameAreaRuleSize;
+                pCountryEntryDest->dwSameAreaRuleOffset = 
+                             pVarOffset - (LPBYTE)pBuildCountryList;
+                pVarOffset += pCountryEntrySource->dwSameAreaRuleSize;
+                dwNeededSize += pCountryEntrySource->dwSameAreaRuleSize;
+
+
+                CopyMemory(
+                            pVarOffset,
+                            pCountryListToUse +
+                                pCountryEntrySource->dwLongDistanceRuleOffset,
+                            pCountryEntrySource->dwLongDistanceRuleSize
+                          );
+
+                pCountryEntryDest->dwLongDistanceRuleSize = 
+                           pCountryEntrySource->dwLongDistanceRuleSize;
+                pCountryEntryDest->dwLongDistanceRuleOffset = 
+                             pVarOffset - (LPBYTE)pBuildCountryList;
+                pVarOffset += pCountryEntrySource->dwLongDistanceRuleSize;
+                dwNeededSize += pCountryEntrySource->dwLongDistanceRuleSize;
+
+
+                CopyMemory(
+                            pVarOffset,
+                            pCountryListToUse +
+                                pCountryEntrySource->dwInternationalRuleOffset,
+                            pCountryEntrySource->dwInternationalRuleSize
+                          );
+
+                pCountryEntryDest->dwInternationalRuleSize = 
+                           pCountryEntrySource->dwInternationalRuleSize;
+                pCountryEntryDest->dwInternationalRuleOffset = 
+                             pVarOffset - (LPBYTE)pBuildCountryList;
+                pVarOffset += pCountryEntrySource->dwInternationalRuleSize;
+                dwNeededSize += pCountryEntrySource->dwInternationalRuleSize;
+
+
+                //
+                // Is there room to put this country's info?
+                //
+                if (pParams->u.dwCountryListTotalSize >= dwNeededSize)
+                {
+                    pCountryList->dwUsedSize          = dwNeededSize;
+                    pCountryList->dwNumCountries      = 1;
+                    pCountryList->dwCountryListSize   = sizeof(LINECOUNTRYENTRY);
+                    pCountryList->dwCountryListOffset = sizeof(LINECOUNTRYLIST);
+
+                    pCountryEntryDest->dwCountryID     = pParams->dwCountryID;
+                    pCountryEntryDest->dwCountryCode   =
+                             pCountryEntrySource->dwCountryCode;
+                    pCountryEntryDest->dwNextCountryID  =
+                             pCountryEntrySource->dwNextCountryID;
+
+                    CopyMemory(
+                                (LPBYTE)pCountryList + sizeof(LINECOUNTRYLIST),
+                                (LPBYTE)pBuildCountryList + sizeof(LINECOUNTRYLIST),
+                                pCountryList->dwUsedSize - sizeof(LINECOUNTRYLIST)
+                              );
+                }
+                else
+                {
+                    //
+                    // Buffer not large enough
+                    //
+
+                    pCountryList->dwUsedSize          = sizeof(LINECOUNTRYLIST);
+                    pCountryList->dwNumCountries      = 0;
+                    pCountryList->dwCountryListSize   = 0;
+                    pCountryList->dwCountryListOffset = 0;
+                }
+
+                pCountryList->dwNeededSize = dwNeededSize;
+                pCountryList->dwTotalSize = pParams->u.dwCountryListTotalSize;
+
+                *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                    pCountryList->dwUsedSize;
+
+
+                //
+                // Did we have a "special" case?
+                //
+                if ( pOverrideList )
+                {
+                    ServerFree( pOverrideList );
+                }
+
+            }
+
+            ServerFree( pBuildCountryList );
+        }
+    }
+
+
+/*
+        WCHAR               szCountryInfo[256], *p;
+        DWORD               dwNeededSize;
+        LPLINECOUNTRYLIST   pCountryList;
+
+
+        if (LoadStringW(
+                GetModuleHandle (NULL),
+                RC_COUNTRY_ID_BASE + pParams->dwCountryID,
+                szCountryInfo,
+                256
+                ) == 0)
+        {
+            DBGOUT((
+                3,
+                "LGetCountry: LoadString failed, err=%ld",
+                GetLastError()
+                ));
+
+            pParams->lResult = LINEERR_INVALCOUNTRYCODE;
+
+            return;
+        }
+
+
+        //
+        // Note: 7 = 3 (commas) + 8 (dblquotes) - 4 (NULL terminators)
+        //
+
+        dwNeededSize = sizeof(LINECOUNTRYLIST) + sizeof(LINECOUNTRYENTRY);
+
+        p = wcschr(szCountryInfo, '\"');
+
+        dwNeededSize += ((wcslen (p) - 7)*sizeof(WCHAR));
+
+        pCountryList = (LPLINECOUNTRYLIST) pDataBuf;
+
+        if (pParams->u.dwCountryListTotalSize >= dwNeededSize)
+        {
+            //
+            // Fill in the buffer
+            //
+
+            DWORD               i,
+                                dwVarDataOffset = sizeof(LINECOUNTRYLIST) +
+                                    sizeof(LINECOUNTRYENTRY);
+            LPDWORD             pdwXxxSize;
+            LPLINECOUNTRYENTRY  pCountryEntry = (LPLINECOUNTRYENTRY)
+                                    (((LPBYTE)pCountryList) +
+                                    sizeof(LINECOUNTRYLIST));
+
+
+            pCountryList->dwUsedSize          = dwNeededSize;
+            pCountryList->dwNumCountries      = 1;
+            pCountryList->dwCountryListSize   = sizeof(LINECOUNTRYENTRY);
+            pCountryList->dwCountryListOffset = sizeof(LINECOUNTRYLIST);
+
+            pCountryEntry->dwCountryID     = pParams->dwCountryID;
+            pCountryEntry->dwCountryCode   = (DWORD) _wtoi (szCountryInfo);
+
+            p = wcschr(szCountryInfo, ',');
+            p++;
+            pCountryEntry->dwNextCountryID = (DWORD) _wtoi (p);
+
+            p = wcschr(szCountryInfo, '\"');
+            p++;
+
+
+            //
+            // Initialize all the country entry string fields
+            //
+
+            pdwXxxSize = &pCountryEntry->dwCountryNameSize;
+
+            for (i = 0; i < 4; i++)
+            {
+                WCHAR *p2 = wcschr(p, '\"');
+
+
+                *p2 = 0;
+                *pdwXxxSize       = (wcslen (p) + 1) * sizeof(WCHAR);
+                *(pdwXxxSize + 1) = dwVarDataOffset;
+
+                wcscpy((PWSTR)(((LPBYTE)pCountryList) + dwVarDataOffset), p);
+
+                dwVarDataOffset += *pdwXxxSize;
+
+                p = p2 + 3; // ","
+
+                pdwXxxSize++;
+                pdwXxxSize++;
+            }
+        }
+        else
+        {
+            //
+            // Buffer not large enough
+            //
+
+            pCountryList->dwUsedSize          = sizeof(LINECOUNTRYLIST);
+            pCountryList->dwNumCountries      =
+            pCountryList->dwCountryListSize   =
+            pCountryList->dwCountryListOffset = 0;
+        }
+
+        pCountryList->dwNeededSize = dwNeededSize;
+        pCountryList->dwTotalSize = pParams->u.dwCountryListTotalSize;
+
+        *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+            pCountryList->dwUsedSize;
+
+    }
+*/
+
+
+
+    pParams->u.dwCountryListOffset = 0;
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineGetCountry: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+}
+
+
+void
+WINAPI
+LGetDevCaps(
+    PLINEGETDEVCAPS_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwDeviceID = pParams->dwDeviceID;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineGetDevCaps;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hLineApp,  // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETDEVCAPS,          // provider func index
+            &pfnTSPI_lineGetDevCaps,    // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetDevCaps"                // func name
+
+            )) == 0)
+    {
+        DWORD           dwAPIVersion, dwSPIVersion, dwTotalSize,
+                        dwFixedSizeClient, dwFixedSizeSP;
+        LPLINEDEVCAPS   pDevCaps = (LPLINEDEVCAPS) pDataBuf,
+                        pDevCaps2 = (LPLINEDEVCAPS) NULL;
+
+
+        //
+        // Verify API & SPI version compatibility
+        //
+
+        dwAPIVersion = pParams->dwAPIVersion;
+
+        dwSPIVersion =
+            (GetLineLookupEntry (dwDeviceID))->dwSPIVersion;
+
+        if (!IsAPIVersionInRange (dwAPIVersion, dwSPIVersion))
+        {
+            pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+            goto LGetDevCaps_epilog;
+        }
+
+
+        //
+        // Verify Ext version compatibility
+        //
+
+        if (!IsValidLineExtVersion (dwDeviceID, pParams->dwExtVersion))
+        {
+            pParams->lResult = LINEERR_INCOMPATIBLEEXTVERSION;
+            goto LGetDevCaps_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwTotalSize = pParams->u.dwDevCapsTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwFixedSizeClient = 236;    // 47 * sizeof (DWORD) +
+                                        //     3 * sizeof (LINEDIALPARAMS)
+            break;
+
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 240;    // 48 * sizeof (DWORD) +
+                                        //     3 * sizeof (LINEDIALPARAMS)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (LINEDEVCAPS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetDevCaps_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwFixedSizeSP = 236;        // 47 * sizeof (DWORD) +
+                                        //     3 * sizeof (LINEDIALPARAMS)
+            break;
+
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 240;        // 48 * sizeof (DWORD) +
+                                        //     3 * sizeof (LINEDIALPARAMS)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (LINEDEVCAPS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pDevCaps2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGetDevCaps_epilog;
+            }
+
+            pDevCaps    = pDevCaps2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pDevCaps,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pDevCaps2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP4(
+                pfnTSPI_lineGetDevCaps,
+                "lineGetDevCaps",
+                SP_FUNC_SYNC,
+                (DWORD) dwDeviceID,
+                (DWORD) dwSPIVersion,
+                (DWORD) pParams->dwExtVersion,
+                (DWORD) pDevCaps
+
+                )) == 0)
+        {
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+
+            //
+            // Add the fields we're responsible for
+            //
+
+            pDevCaps->dwLineStates |= LINEDEVSTATE_OPEN |
+                                      LINEDEVSTATE_CLOSE |
+                                      LINEDEVSTATE_REINIT |
+                                      LINEDEVSTATE_TRANSLATECHANGE;
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+            if ((dwAPIVersion == TAPI_VERSION1_0) &&
+                (pDevCaps->dwMediaModes & LINEMEDIAMODE_VOICEVIEW))
+            {
+                pDevCaps->dwMediaModes = LINEMEDIAMODE_UNKNOWN |
+                    (pDevCaps->dwMediaModes & ~LINEMEDIAMODE_VOICEVIEW);
+            }
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pDevCaps == pDevCaps2)
+            {
+                pDevCaps = (LPLINEDEVCAPS) pDataBuf;
+
+                CopyMemory (pDevCaps, pDevCaps2, dwFixedSizeClient);
+
+                ServerFree (pDevCaps2);
+
+                pDevCaps->dwTotalSize = pParams->u.dwDevCapsTotalSize;
+                pDevCaps->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDevCapsOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pDevCaps->dwUsedSize;
+        }
+    }
+
+LGetDevCaps_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetDevCaps"
+        );
+}
+
+
+void
+WINAPI
+LGetDevConfig(
+    PLINEGETDEVCONFIG_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineGetDevConfig;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            0,                          // client widget handle
+            NULL,                       // provider widget handle
+            pParams->dwDeviceID,        // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETDEVCONFIG,        // provider func index
+            &pfnTSPI_lineGetDevConfig,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetDevConfig"              // func name
+
+            )) == 0)
+    {
+        WCHAR      *pszDeviceClass;
+        LPVARSTRING pConfig = (LPVARSTRING) pDataBuf;
+
+
+        //
+        // Alloc a temporary buf for the dev class, since we'll be using
+        // the existing buffer for output
+        //
+
+        if (!(pszDeviceClass = (WCHAR *) ServerAlloc( sizeof(WCHAR) * ( 1 +
+                lstrlenW((PWSTR)(pDataBuf + pParams->dwDeviceClassOffset)))
+                )))
+        {
+            pParams->lResult = LINEERR_NOMEM;
+            goto LGetDevConfig_epilog;
+        }
+
+        lstrcpyW(
+            pszDeviceClass,
+            (PWSTR)(pDataBuf + pParams->dwDeviceClassOffset)
+            );
+
+        if (!InitTapiStruct(
+                pConfig,
+                pParams->u.dwDeviceConfigTotalSize,
+                sizeof (VARSTRING),
+                TRUE
+                ))
+        {
+            ServerFree (pszDeviceClass);
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetDevConfig_epilog;
+        }
+
+
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_lineGetDevConfig,
+                "lineGetDevConfig",
+                SP_FUNC_SYNC,
+                (DWORD) pParams->dwDeviceID,
+                (DWORD) pConfig,
+                (DWORD) pszDeviceClass
+
+                )) == 0)
+        {
+            //
+            // Indicate how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDeviceConfigOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pConfig->dwUsedSize;
+        }
+
+        ServerFree (pszDeviceClass);
+    }
+
+LGetDevConfig_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetDevConfig"
+        );
+}
+
+
+void
+WINAPI
+LGetIcon(
+    PLINEGETICON_PARAMS pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    //
+    // Note: Icons are Windows NT User Objects, so. HICONs are public to
+    //       all processes, and do not need to be dup'd.
+    //
+
+    WCHAR      *pszDeviceClass;
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineGetIcon;
+
+
+    pszDeviceClass = (WCHAR *) (pParams->dwDeviceClassOffset == TAPI_NO_DATA ?
+        NULL : pDataBuf + pParams->dwDeviceClassOffset);
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            0,                          // client widget handle
+            NULL,                       // provider widget handle
+            pParams->dwDeviceID,        // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETICON,             // provider func index
+            &pfnTSPI_lineGetIcon,       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetIcon"                   // func name
+
+            )) == 0)
+    {
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_lineGetIcon,
+                "lineGetIcon",
+                SP_FUNC_SYNC,
+                pParams->dwDeviceID,
+                (DWORD) pszDeviceClass,
+                (DWORD) &pParams->hIcon
+
+                )) == 0)
+        {
+            *pdwNumBytesReturned = sizeof (LINEGETICON_PARAMS);
+        }
+    }
+    else if (pParams->lResult == LINEERR_OPERATIONUNAVAIL)
+    {
+        if ((pszDeviceClass == NULL) ||
+            (lstrcmpW(pszDeviceClass, L"tapi/line") == 0))
+        {
+            pParams->hIcon = TapiGlobals.hLineIcon;
+            pParams->lResult = 0;
+            *pdwNumBytesReturned = sizeof (LINEGETICON_PARAMS);
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALDEVICECLASS;
+        }
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetIcon"
+        );
+}
+
+
+void
+WINAPI
+LGetID(
+    PLINEGETID_PARAMS   pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwWidgetType, hdWidget, dwPrivilege;
+    HANDLE      hWidget;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineGetID;
+
+
+    if (pParams->dwSelect == LINECALLSELECT_CALL)
+    {
+        dwWidgetType = ANY_RT_HCALL;
+        hWidget      = (HANDLE) pParams->hCall;
+        dwPrivilege  = LINECALLPRIVILEGE_MONITOR;
+    }
+    else
+    {
+        dwWidgetType = ANY_RT_HLINE;
+        hWidget      = (HANDLE) pParams->hLine;
+        dwPrivilege  = 0;
+    }
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            dwWidgetType,               // widget type
+            (DWORD) hWidget,            // client widget handle
+            &hdWidget,                  // provider widget handle
+            dwPrivilege,                // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETID,               // provider func index
+            &pfnTSPI_lineGetID,         // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetID"                     // func name
+
+            )) == 0  ||  pParams->lResult == LINEERR_OPERATIONUNAVAIL)
+    {
+        WCHAR       *pszDeviceClass;
+        LPVARSTRING pID = (LPVARSTRING) pDataBuf;
+
+
+        if (!(pParams->dwSelect & AllCallSelect) ||
+            !IsOnlyOneBitSetInDWORD (pParams->dwSelect))
+        {
+            pParams->lResult = LINEERR_INVALCALLSELECT;
+            goto LGetID_epilog;
+        }
+
+
+        //
+        // We'll handle the "tapi/line" class right here rather than
+        // burden every single driver with having to support it
+        //
+
+        if (lstrcmpiW(
+                (PWSTR)(pDataBuf + pParams->dwDeviceClassOffset),
+                L"tapi/line"
+
+                ) == 0)
+        {
+            if (!InitTapiStruct(
+                    pID,
+                    pParams->u.dwDeviceIDTotalSize,
+                    sizeof (VARSTRING),
+                    TRUE
+                    ))
+            {
+                pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+                goto LGetID_epilog;
+            }
+
+            pID->dwNeededSize += sizeof (DWORD);
+
+            if (pID->dwTotalSize >= pID->dwNeededSize)
+            {
+                try
+                {
+                    if (pParams->dwSelect == LINECALLSELECT_ADDRESS)
+                    {
+                        if (pParams->dwAddressID >= ((PTLINECLIENT)
+                                pParams->hLine)->ptLine->dwNumAddresses)
+                        {
+                            pParams->lResult = LINEERR_INVALADDRESSID;
+                            goto LGetID_epilog;
+                        }
+                    }
+
+                    *((LPDWORD)(pID + 1)) =
+                        (pParams->dwSelect == LINECALLSELECT_CALL ?
+                        ((PTLINE) ((PTCALLCLIENT) pParams->hCall)->ptCall
+                            ->ptLine)->dwDeviceID :
+                        ((PTLINECLIENT) pParams->hLine)->ptLine->dwDeviceID);
+                }
+                myexcept
+                {
+                    pParams->lResult =
+                        (pParams->dwSelect == LINECALLSELECT_CALL ?
+                        LINEERR_INVALCALLHANDLE : LINEERR_INVALLINEHANDLE);
+                    goto LGetID_epilog;
+                }
+
+                pID->dwUsedSize     += sizeof (DWORD);
+                pID->dwStringFormat = STRINGFORMAT_BINARY;
+                pID->dwStringSize   = sizeof (DWORD);
+                pID->dwStringOffset = sizeof (VARSTRING);
+            }
+
+
+            //
+            // Indicate offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDeviceIDOffset = 0;
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pID->dwUsedSize;
+            goto LGetID_epilog;
+        }
+        else if (pParams->lResult ==  LINEERR_OPERATIONUNAVAIL)
+        {
+            goto LGetID_epilog;
+        }
+
+
+        //
+        // Alloc a temporary buf for the dev class, since we'll be using
+        // the existing buffer for output
+        //
+
+        if (!(pszDeviceClass = (WCHAR *) ServerAlloc( sizeof(WCHAR) * (1 +
+                lstrlenW((PWSTR)(pDataBuf + pParams->dwDeviceClassOffset)))
+                )))
+        {
+            pParams->lResult = LINEERR_NOMEM;
+            goto LGetID_epilog;
+        }
+
+        lstrcpyW(
+            pszDeviceClass,
+            (PWSTR)(pDataBuf + pParams->dwDeviceClassOffset)
+            );
+
+        if (!InitTapiStruct(
+                pID,
+                pParams->u.dwDeviceIDTotalSize,
+                sizeof (VARSTRING),
+                TRUE
+                ))
+        {
+            ServerFree (pszDeviceClass);
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetID_epilog;
+        }
+
+        if ((pParams->lResult = CallSP7(
+                pfnTSPI_lineGetID,
+                "lineGetID",
+                SP_FUNC_SYNC,
+                (dwWidgetType == ANY_RT_HCALL ? 0 : hdWidget),
+                pParams->dwAddressID,
+                (dwWidgetType == ANY_RT_HCALL ? hdWidget : 0),
+                pParams->dwSelect,
+                (DWORD) pID,
+                (DWORD) pszDeviceClass,
+                (DWORD) pParams->ptClient->hProcess
+
+                )) == 0)
+        {
+            //
+            // Indicate offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDeviceIDOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pID->dwUsedSize;
+        }
+
+        ServerFree (pszDeviceClass);
+    }
+
+LGetID_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetID"
+        );
+}
+
+
+void
+WINAPI
+LGetLineDevStatus(
+    PLINEGETLINEDEVSTATUS_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineGetLineDevStatus;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEGETLINEDEVSTATUS,    // provider func index
+            &pfnTSPI_lineGetLineDevStatus,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetLineDevStatus"          // func name
+
+            )) == 0)
+    {
+        DWORD           dwAPIVersion, dwSPIVersion, dwTotalSize,
+                        dwFixedSizeClient, dwFixedSizeSP;
+        PTLINECLIENT    ptLineClient = (PTLINECLIENT) pParams->hLine;
+        LPLINEDEVSTATUS pDevStatus = (LPLINEDEVSTATUS) pDataBuf,
+                        pDevStatus2 = (LPLINEDEVSTATUS) NULL;
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwAPIVersion = ptLineClient->dwAPIVersion;
+
+        dwTotalSize = pParams->u.dwLineDevStatusTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 76;   // 19 * sizeof (DWORD)
+            break;
+
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (LINEDEVSTATUS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+            goto LGetLineDevStatus_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        dwSPIVersion = ptLineClient->ptLine->dwSPIVersion;
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 76;   // 19 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (LINEDEVSTATUS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pDevStatus2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = LINEERR_NOMEM;
+                goto LGetLineDevStatus_epilog;
+            }
+
+            pDevStatus  = pDevStatus2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pDevStatus,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pDevStatus2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_lineGetLineDevStatus,
+                "lineGetLineDevStatus",
+                SP_FUNC_SYNC,
+                (DWORD) hdLine,
+                (DWORD) pDevStatus
+
+                )) == 0)
+        {
+            PTLINE  ptLine;
+
+
+            //
+            // Add the fields we're responsible for
+            //
+
+            try
+            {
+                ptLine = ptLineClient->ptLine;
+
+                pDevStatus->dwNumOpens       = ptLine->dwNumOpens;
+                pDevStatus->dwOpenMediaModes = ptLine->dwOpenMediaModes;
+            }
+            myexcept
+            {
+                pParams->lResult = LINEERR_INVALLINEHANDLE;
+            }
+
+
+            if (dwAPIVersion >= TAPI_VERSION2_0)
+            {
+                DWORD           dwAppInfoTotalSize, dwNumOpens, dwXxxOffset, i;
+                TPOINTERLIST    clientList, *pClientList = &clientList;
+                LPLINEAPPINFO   pAppInfo;
+
+
+                //
+                // Reset the num opens to 0 in case we return prior to
+                // filling in the app info list (so tapi32.dll doesn't
+                // blow up trying to do unicode->ascii conversion on
+                // bad data)
+                //
+
+                pDevStatus->dwNumOpens = 0;
+
+
+                //
+                // Retrieve the list of line clients & determine how big
+                // of a buffer we need to hold all the related app info
+                // data.  Do it safely in case one of the widgets is
+                // destroyed while we're reading it's data.
+                //
+
+                if (GetLineClientListFromLine (ptLine, &pClientList) != 0)
+                {
+                    goto LGetLineDevStatus_copyTmpBuffer;
+                }
+
+                dwAppInfoTotalSize = pClientList->dwNumUsedEntries *
+                    sizeof (LINEAPPINFO);
+
+                for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+                {
+                    PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                        pClientList->aEntries[i];
+
+                    try
+                    {
+                        DWORD   d;
+
+
+                        d = ((PTCLIENT) ptLineClient->ptClient)->
+                            dwComputerNameSize;
+
+                        d += ((PTCLIENT) ptLineClient->ptClient)->
+                            dwUserNameSize;
+
+                        // don't include preceding '"'
+
+                        d += ((PTLINEAPP) ptLineClient->ptLineApp)->
+                            dwModuleNameSize - sizeof (WCHAR);
+
+                        d += ((PTLINEAPP) ptLineClient->ptLineApp)->
+                            dwFriendlyNameSize;
+
+                        if (ptLineClient->dwKey == TLINECLIENT_KEY)
+                        {
+                            dwAppInfoTotalSize += d;
+                        }
+                        else
+                        {
+                            pClientList->aEntries[i] = 0;
+                        }
+                    }
+                    myexcept
+                    {
+                        pClientList->aEntries[i] = 0;
+                    }
+                }
+
+                dwAppInfoTotalSize += 3; // add 3 to guarantee DWORD alignment
+
+                pDevStatus->dwNeededSize += dwAppInfoTotalSize;
+
+
+                //
+                // Check to see if there's enough room in the app buffer
+                // for all the app info data
+                //
+
+                if ((pDevStatus->dwTotalSize - pDevStatus->dwUsedSize) <
+                        dwAppInfoTotalSize)
+                {
+                    goto LGetLineDevStatus_freeClientList;
+                }
+
+                //
+                // Now figure out where the app info goes & safely fill
+                // it in
+                //
+
+                pDevStatus->dwAppInfoSize = pClientList->dwNumUsedEntries *
+                    sizeof (LINEAPPINFO);
+
+                pDevStatus->dwAppInfoOffset = (pDevStatus->dwUsedSize + 3) &
+                    0xfffffffc;
+
+                pDevStatus->dwUsedSize += dwAppInfoTotalSize;
+
+                pAppInfo = (LPLINEAPPINFO) (((LPBYTE) pDevStatus) +
+                    pDevStatus->dwAppInfoOffset);
+
+                dwXxxOffset = pDevStatus->dwAppInfoSize +
+                    pDevStatus->dwAppInfoOffset;
+
+                dwNumOpens = 0;
+
+                for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+                {
+                    PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                        pClientList->aEntries[i];
+
+
+                    if (ptLineClient == NULL)
+                    {
+                        continue;
+                    }
+
+                    try
+                    {
+                        DWORD       d = dwXxxOffset;
+                        PTCLIENT    ptClient = (PTCLIENT)
+                                        ptLineClient->ptClient;
+                        PTLINEAPP   ptLineApp = (PTLINEAPP)
+                                        ptLineClient->ptLineApp;
+
+
+                        pAppInfo->dwMachineNameOffset = d;
+
+                        if ((pAppInfo->dwMachineNameSize =
+                                ptClient->dwComputerNameSize))
+                        {
+                            lstrcpyW(
+                                (LPWSTR) (((LPBYTE) pDevStatus) + d),
+                                ptClient->pszComputerName
+                                );
+
+                            d += pAppInfo->dwMachineNameSize;
+                        }
+
+                        pAppInfo->dwUserNameOffset = d;
+
+                        if ((pAppInfo->dwUserNameSize =
+                                ptClient->dwUserNameSize))
+                        {
+                            lstrcpyW(
+                                (LPWSTR) (((LPBYTE) pDevStatus) + d),
+                                ptClient->pszUserName
+                                );
+
+                            d += pAppInfo->dwUserNameSize;
+                        }
+
+                        pAppInfo->dwModuleFilenameOffset = d;
+
+                        if ((pAppInfo->dwModuleFilenameSize =
+                                ptLineApp->dwModuleNameSize - sizeof (WCHAR)))
+                        {
+                            // don't include preceding '"'
+
+                            lstrcpyW(
+                                (LPWSTR) (((LPBYTE) pDevStatus) + d),
+                                &ptLineApp->pszModuleName[1]
+                                );
+
+                            d += pAppInfo->dwModuleFilenameSize;
+                        }
+
+                        pAppInfo->dwFriendlyNameOffset = d;
+
+                        if ((pAppInfo->dwFriendlyNameSize =
+                                ptLineApp->dwFriendlyNameSize))
+                        {
+                            lstrcpyW(
+                                (LPWSTR) (((LPBYTE) pDevStatus) + d),
+                                ptLineApp->pszFriendlyName
+                                );
+
+                            d += pAppInfo->dwFriendlyNameSize;
+                        }
+
+                        pAppInfo->dwMediaModes = ptLineClient->dwMediaModes;
+                        pAppInfo->dwAddressID  = ptLineClient->dwAddressID;
+
+
+                        //
+                        // Finally, make sure the tLineClient is still good
+                        // so we know all the info above  is kosher, &
+                        // if so inc the appropriate vars
+                        //
+
+                        if (ptLineClient->dwKey == TLINECLIENT_KEY)
+                        {
+                            pAppInfo++;
+                            dwNumOpens++;
+                            dwXxxOffset = d;
+                        }
+                    }
+                    myexcept
+                    {
+                        // do nothing, just continue to loop
+                    }
+                }
+
+                pDevStatus->dwNumOpens    = dwNumOpens;
+                pDevStatus->dwAppInfoSize = dwNumOpens * sizeof (LINEAPPINFO);
+
+LGetLineDevStatus_freeClientList:
+
+                if (pClientList !=  &clientList)
+                {
+                    ServerFree (pClientList);
+                }
+            }
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+LGetLineDevStatus_copyTmpBuffer:
+
+            if (pDevStatus == pDevStatus2)
+            {
+                pDevStatus = (LPLINEDEVSTATUS) pDataBuf;
+
+                CopyMemory (pDevStatus, pDevStatus2, dwFixedSizeClient);
+
+                ServerFree (pDevStatus2);
+
+                pDevStatus->dwTotalSize = pParams->u.dwLineDevStatusTotalSize;
+                pDevStatus->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the API version of the hLine so tapi32.dll knows
+            // which strings to munge from ascii to unicode
+            //
+
+            pParams->dwAPIVersion = dwAPIVersion;
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwLineDevStatusOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pDevStatus->dwUsedSize;
+        }
+    }
+
+LGetLineDevStatus_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetLineDevStatus"
+        );
+}
+
+
+void
+WINAPI
+LGetNewCalls(
+    PLINEGETNEWCALLS_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    LONG            lResult = 0;
+    DWORD           dwTotalSize = pParams->u.dwCallListTotalSize, dwAddressID,
+                    dwNumNewCalls, i, j, dwSelect = pParams->dwSelect;
+    PTLINE          ptLine;
+    PTLINECLIENT    ptLineClient;
+    TPOINTERLIST    callList, *pCallList = &callList;
+    LPLINECALLLIST  pAppCallList = (LPLINECALLLIST) pDataBuf;
+
+
+    //
+    // Verify params
+    //
+
+    if (TapiGlobals.dwNumLineInits == 0)
+    {
+        pParams->lResult = LINEERR_UNINITIALIZED;
+        goto LGetNewCalls_return;
+    }
+
+    if (dwSelect == LINECALLSELECT_ADDRESS)
+    {
+        dwAddressID = pParams->dwAddressID;
+    }
+    else if (dwSelect != LINECALLSELECT_LINE)
+    {
+        pParams->lResult = LINEERR_INVALCALLSELECT;
+        goto LGetNewCalls_return;
+    }
+
+    if (dwTotalSize < sizeof (LINECALLLIST))
+    {
+        pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+        goto LGetNewCalls_return;
+    }
+
+    if (!(ptLineClient = IsValidLine (pParams->hLine, pParams->ptClient)))
+    {
+        pParams->lResult = LINEERR_INVALLINEHANDLE;
+        goto LGetNewCalls_return;
+    }
+
+
+    //
+    // Safely get the ptLine
+    //
+
+    try
+    {
+        ptLine = ptLineClient->ptLine;
+    }
+    myexcept
+    {
+        pParams->lResult = LINEERR_INVALLINEHANDLE;
+        goto LGetNewCalls_return;
+    }
+
+
+    //
+    // Get list of tCalls on the tLine
+    //
+
+    if ((lResult = GetCallListFromLine (ptLine, &pCallList)) != 0)
+    {
+        pParams->lResult = lResult;
+        goto LGetNewCalls_return;
+    }
+
+
+    //
+    // Assume worst case scenario- that we have to create a new call
+    // client for each tCall on the tLine- and make sure the app's call
+    // list is large enough to hold them all
+    //
+
+    pAppCallList->dwTotalSize = dwTotalSize;
+
+    if (dwTotalSize < (sizeof (LINECALLLIST) +
+            pCallList->dwNumUsedEntries * sizeof(HCALL)))
+    {
+        pAppCallList->dwNeededSize = sizeof (LINECALLLIST) +
+            pCallList->dwNumUsedEntries * sizeof(HCALL);
+
+        pAppCallList->dwUsedSize = sizeof (LINECALLLIST);
+
+        FillMemory (&pAppCallList->dwCallsNumEntries, 3 * sizeof (DWORD), 0);
+
+        goto LGetNewCalls_cleanup;
+    }
+
+
+    //
+    // Check to see if there's a call client for the specified
+    // line client for each of the calls on the line/address,
+    // create one with monitor privilege if not
+    //
+
+    dwNumNewCalls = 0;
+
+    for (i = 0; i < pCallList->dwNumUsedEntries; i++)
+    {
+        BOOL            bContinue = FALSE;
+        PTCALL          ptCall = (PTCALL) pCallList->aEntries[i];
+        TPOINTERLIST    callClientList, *pCallClientList = &callClientList;
+
+
+        //
+        // Check to see if the post-processing routine (for outgoing calls)
+        // or the CALLSTATE msg handler in the LineEventProc (for incoming
+        // calls) has already created the list of monitors for this tCall.
+        //
+
+        try
+        {
+            if (ptCall->bCreatedInitialMonitors == FALSE)
+            {
+                bContinue = TRUE;
+            }
+        }
+        myexcept
+        {
+            bContinue = TRUE;
+        }
+
+        if (dwSelect == LINECALLSELECT_ADDRESS)
+        {
+            try
+            {
+                if (dwAddressID != ptCall->dwAddressID)
+                {
+                    bContinue = TRUE;
+                }
+            }
+            myexcept
+            {
+                bContinue = TRUE;
+            }
+        }
+
+        if (bContinue)
+        {
+            continue;
+        }
+
+        if (GetCallClientListFromCall (ptCall, &pCallClientList) != 0)
+        {
+            continue;
+        }
+
+        for (j = 0; j < pCallClientList->dwNumUsedEntries; j++)
+        {
+            try
+            {
+                if (((PTCALLCLIENT)(pCallClientList->aEntries[j]))
+                        ->ptLineClient == ptLineClient)
+                {
+                    break;
+                }
+            }
+            myexcept
+            {
+                // just continue
+            }
+         }
+
+         if (j == pCallClientList->dwNumUsedEntries)
+         {
+            if ((lResult = CreatetCallClient(
+                    ptCall,
+                    ptLineClient,
+                    LINECALLPRIVILEGE_MONITOR,
+                    TRUE,
+                    TRUE,
+                    (PTCALLCLIENT *) (pCallList->aEntries + dwNumNewCalls),
+                    FALSE
+
+                    )) == 0)
+            {
+                dwNumNewCalls++;
+            }
+            else
+            {
+            }
+         }
+
+         if (pCallClientList != &callClientList)
+         {
+             ServerFree (pCallClientList);
+         }
+    }
+
+    {
+        DWORD   dwCallsSize = dwNumNewCalls * sizeof (HCALL);
+
+
+        CopyMemory (pAppCallList + 1, pCallList->aEntries, dwCallsSize);
+
+        pAppCallList->dwUsedSize        =
+        pAppCallList->dwNeededSize      = sizeof (LINECALLLIST) + dwCallsSize;
+
+        pAppCallList->dwCallsNumEntries = dwNumNewCalls;
+        pAppCallList->dwCallsSize       = dwCallsSize;
+        pAppCallList->dwCallsOffset     = sizeof (LINECALLLIST);
+    }
+
+LGetNewCalls_cleanup:
+
+    if (pCallList != &callList)
+    {
+        ServerFree (pCallList);
+    }
+
+    pParams->u.dwCallListOffset = 0;
+
+    *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pAppCallList->dwUsedSize;
+
+LGetNewCalls_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineGetNewCalls: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+LGetNumAddressIDs(
+    PLINEGETNUMADDRESSIDS_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetNumAddressIDs"          // func name
+
+            )) == 0)
+    {
+        try
+        {
+            pParams->dwNumAddresses =
+                ((PTLINECLIENT) pParams->hLine)->ptLine->dwNumAddresses;
+
+            *pdwNumBytesReturned = sizeof (LINEGETNUMADDRESSIDS_PARAMS);
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALLINEHANDLE;
+        }
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetNumAddressIDs"
+        );
+}
+
+
+void
+WINAPI
+LGetNumRings(
+    PLINEGETNUMRINGS_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_NONE,                    // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetNumRings"               // func name
+
+            )) == 0)
+    {
+        DWORD           i, dwNumRings = 0xffffffff,
+                        dwAddressID = pParams->dwAddressID;
+        PTLINE          ptLine;
+        TPOINTERLIST    lineClientList, *pLineClientList = &lineClientList;
+
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+
+            if (dwAddressID >= ptLine->dwNumAddresses)
+            {
+                pParams->lResult = LINEERR_INVALADDRESSID;
+                goto LGetNumRings_epilog;
+            }
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALLINEHANDLE;
+            goto LGetNumRings_epilog;
+        }
+
+        {
+            LONG    lResult;
+
+
+            if ((lResult = GetLineClientListFromLine(
+                    ptLine,
+                    &pLineClientList
+
+                    )) != 0)
+            {
+                pParams->lResult = LINEERR_INVALLINEHANDLE;
+                goto LGetNumRings_epilog;
+            }
+        }
+
+        for (i = 0; i < pLineClientList->dwNumUsedEntries; i++)
+        {
+            PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                pLineClientList->aEntries[i];
+
+            try
+            {
+               if (ptLineClient->aNumRings == NULL)
+               {
+                   continue;
+               }
+               else if (ptLineClient->aNumRings[dwAddressID] < dwNumRings)
+               {
+                   DWORD    dwNumRingsTmp =
+                                ptLineClient->aNumRings[dwAddressID];
+
+
+                   if (ptLineClient->dwKey == TLINECLIENT_KEY)
+                   {
+                       dwNumRings = dwNumRingsTmp;
+                   }
+               }
+            }
+            myexcept
+            {
+                // just continue
+            }
+        }
+
+        if (pLineClientList != &lineClientList)
+        {
+            ServerFree (pLineClientList);
+        }
+
+        pParams->dwNumRings = dwNumRings;
+
+        *pdwNumBytesReturned = sizeof (LINEGETNUMRINGS_PARAMS);
+    }
+
+LGetNumRings_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetNumRings"
+        );
+}
+
+
+void
+WINAPI
+LGetProviderList(
+    PLINEGETPROVIDERLIST_PARAMS pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    DWORD   iNumProviders, i;
+    WCHAR   *buf;
+    DWORD   dwFixedSizeClient, dwTotalSize, dwNeededSize;
+    LPBYTE  pVarData;
+    LPLINEPROVIDERLIST  pProviderList;
+    LPLINEPROVIDERENTRY pProviderEntry;
+
+    HKEY hKey;
+    DWORD dwDataSize;
+    DWORD dwDataType;
+
+
+    switch (pParams->dwAPIVersion)
+    {
+    case TAPI_VERSION1_0:
+    case TAPI_VERSION1_4:
+    case TAPI_VERSION_CURRENT:
+
+        dwFixedSizeClient = sizeof (LINEPROVIDERLIST);
+        break;
+
+    default:
+
+        pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+        goto LGetProviderList_epilog;
+    }
+
+    if ((dwTotalSize = pParams->u.dwProviderListTotalSize) < dwFixedSizeClient)
+    {
+        pParams->lResult = LINEERR_STRUCTURETOOSMALL;
+        goto LGetProviderList_epilog;
+    }
+
+
+    RegOpenKeyEx(
+        HKEY_LOCAL_MACHINE,
+        gszRegKeyProviders,
+        0,
+        KEY_ALL_ACCESS,
+        &hKey
+        );
+
+
+    dwDataSize = sizeof(iNumProviders);
+    iNumProviders = 0;
+    RegQueryValueEx(
+        hKey,
+        gszNumProviders,
+        0,
+        &dwDataType,
+        (LPBYTE)&iNumProviders,
+        &dwDataSize
+        );
+
+    dwNeededSize = dwFixedSizeClient +
+        (iNumProviders * sizeof (LINEPROVIDERENTRY));
+
+    pProviderList = (LPLINEPROVIDERLIST) pDataBuf;
+
+    pProviderEntry = (LPLINEPROVIDERENTRY) (pDataBuf + dwFixedSizeClient);
+
+    pVarData = pDataBuf + dwNeededSize;
+
+    buf = ServerAlloc (sizeof(WCHAR) * MAX_PATH);  // enough for complete provider path
+
+    for (i = 0; i < iNumProviders; i++)
+    {
+        WCHAR   szProviderXxxN[32];
+        DWORD   dwNameLen;
+
+
+        wsprintfW(szProviderXxxN, L"%ls%d", gszProviderFilenameW, i);
+
+        dwNameLen = MAX_PATH;
+        RegQueryValueExW(
+            hKey,
+            szProviderXxxN,
+            0,
+            &dwDataType,
+            (LPBYTE)buf,
+            &dwNameLen
+            );
+
+//        buf[dwNameLen] = '\0';
+
+        dwNeededSize += dwNameLen;
+
+        if (dwTotalSize >= dwNeededSize)
+        {
+            wsprintfW(szProviderXxxN, L"%ls%d", gszProviderIDW, i);
+
+            dwDataSize = sizeof(pProviderEntry->dwPermanentProviderID);
+            pProviderEntry->dwPermanentProviderID = 0;
+            RegQueryValueExW(
+                hKey,
+                szProviderXxxN,
+                0,
+                &dwDataType,
+                (LPBYTE)&(pProviderEntry->dwPermanentProviderID),
+                &dwDataSize
+                );
+
+            pProviderEntry->dwProviderFilenameSize   = dwNameLen;
+            pProviderEntry->dwProviderFilenameOffset =
+                  pVarData - ((LPBYTE) pProviderList);
+
+            CopyMemory (pVarData, buf, dwNameLen);
+
+            pVarData += dwNameLen;
+
+            pProviderEntry++;
+        }
+    }
+
+    ServerFree (buf);
+
+    pProviderList->dwTotalSize  = dwTotalSize;
+    pProviderList->dwNeededSize = dwNeededSize;
+
+    if (dwTotalSize >= dwNeededSize)
+    {
+        pProviderList->dwUsedSize           = dwNeededSize;
+        pProviderList->dwNumProviders       = (DWORD) iNumProviders;
+        pProviderList->dwProviderListSize   =
+            (DWORD) (iNumProviders * sizeof (LINEPROVIDERENTRY));
+        pProviderList->dwProviderListOffset = dwFixedSizeClient;
+    }
+    else
+    {
+        pProviderList->dwUsedSize           = dwFixedSizeClient;
+        pProviderList->dwNumProviders       =
+        pProviderList->dwProviderListSize   =
+        pProviderList->dwProviderListOffset = 0;
+    }
+
+    pParams->u.dwProviderListOffset = 0;
+
+    *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pProviderList->dwUsedSize;
+
+    RegCloseKey (hKey);
+
+
+LGetProviderList_epilog:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineGetProviderList: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+LGetRequest(
+    PLINEGETREQUEST_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    PTLINEAPP           ptLineApp;
+    PTREQUESTMAKECALL   pRequestMakeCall;
+
+
+    if ((ptLineApp = WaitForExclusiveLineAppAccess(
+            pParams->hLineApp,
+            pParams->ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            )))
+    {
+        if (pParams->dwRequestMode == LINEREQUESTMODE_MAKECALL)
+        {
+            if (!ptLineApp->pRequestRecipient)
+            {
+                pParams->lResult = LINEERR_NOTREGISTERED;
+                goto LGetRequest_releaseMutex;
+            }
+
+            EnterCriticalSection (&gPriorityListCritSec);
+
+            // note: if here guaranteed to be >=1 reqRecip obj in global list
+
+            if (lstrcmpiW(
+                    ptLineApp->pszModuleName,
+                    TapiGlobals.pHighestPriorityRequestRecipient->
+                        ptLineApp->pszModuleName
+
+                    ) == 0)
+            {
+                if ((pRequestMakeCall = TapiGlobals.pRequestMakeCallList))
+                {
+                    CopyMemory(
+                        pDataBuf,
+                        &pRequestMakeCall->LineReqMakeCall,
+                        sizeof (LINEREQMAKECALLW)
+                        );
+
+                    pParams->dwRequestBufferOffset = 0;
+                    pParams->dwSize = sizeof (LINEREQMAKECALLW);
+
+                    *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                        sizeof (LINEREQMAKECALLW);
+
+                    if (!(TapiGlobals.pRequestMakeCallList =
+                            pRequestMakeCall->pNext))
+                    {
+                        TapiGlobals.pRequestMakeCallListEnd = NULL;
+                    }
+
+                    ServerFree (pRequestMakeCall);
+                }
+                else
+                {
+                    pParams->lResult = LINEERR_NOREQUEST;
+                }
+            }
+            else
+            {
+                pParams->lResult = LINEERR_NOREQUEST;
+            }
+
+            LeaveCriticalSection (&gPriorityListCritSec);
+        }
+        else if (pParams->dwRequestMode == LINEREQUESTMODE_MEDIACALL)
+        {
+            pParams->lResult = (ptLineApp->bReqMediaCallRecipient ?
+                LINEERR_NOREQUEST : LINEERR_NOTREGISTERED);
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALREQUESTMODE;
+        }
+
+LGetRequest_releaseMutex:
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+    }
+    else
+    {
+        pParams->lResult = (TapiGlobals.dwNumLineInits == 0 ?
+            LINEERR_UNINITIALIZED : LINEERR_INVALAPPHANDLE);
+    }
+
+LGetRequest_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineGetRequest: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+LGetStatusMessages(
+    PLINEGETSTATUSMESSAGES_PARAMS   pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetStatusMessages"         // func name
+
+            )) == 0)
+    {
+        PTLINECLIENT    ptLineClient = (PTLINECLIENT) pParams->hLine;
+
+
+        pParams->dwLineStates    = ptLineClient->dwLineStates;
+        pParams->dwAddressStates = ptLineClient->dwAddressStates;
+
+        *pdwNumBytesReturned = sizeof (LINEGETSTATUSMESSAGES_PARAMS);
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetStatusMessages"
+        );
+}
+
+
+void
+WINAPI
+LHandoff(
+    PLINEHANDOFF_PARAMS pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL            bCloseMutex;
+    HANDLE          hMutex;
+    HDRVCALL        hdCall;
+    TPOINTERLIST    xxxClientList, *pXxxClientList = &xxxClientList;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "Handoff"                   // func name
+
+            )) == 0)
+    {
+        LONG            lResult;
+        DWORD           dwAPIVersion, dwValidMediaModes, i,
+                        dwMediaMode = pParams->dwMediaMode;
+        WCHAR          *pszFileName = (pParams->dwFileNameOffset==TAPI_NO_DATA
+                            ? NULL : (PWSTR)(pDataBuf + pParams->dwFileNameOffset));
+        PTLINE          ptLine;
+        PTCALL          ptCall;
+        PTCALLCLIENT    ptCallClientApp;
+        PTLINECLIENT    ptLineClientApp, ptLineClientTarget, ptLineClientTmp;
+
+
+        //
+        // Safely retrieve all the object pointers needed below, then get
+        // a list of line clients
+        //
+
+        try
+        {
+            ptCallClientApp = (PTCALLCLIENT) pParams->hCall;
+            ptCall          = ptCallClientApp->ptCall;
+            ptLineClientApp = ptCallClientApp->ptLineClient;
+            ptLine          = ptLineClientApp->ptLine;
+            dwAPIVersion    = ptLineClientApp->dwAPIVersion;
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALCALLHANDLE;
+            goto LHandoff_epilog;
+        }
+
+        if ((lResult = GetLineClientListFromLine (ptLine, &pXxxClientList)))
+        {
+            pParams->lResult = lResult;
+            goto LHandoff_epilog;
+        }
+
+// BUGBUG LHandoff: ext mm's
+
+        if (pszFileName)
+        {
+            //
+            // "Directed" handoff
+            //
+            // Walk thru the list of clients on this line & find the oldest
+            // one (that's an owner) with an app name that matches the
+            // specified app name
+            //
+            // Note: It's possible that a target app who opened the line
+            // with OWNER privilege for only DATAMODEM calls will be a
+            // target of a directed handoff for calls of a different media
+            // mode, i.e. G3FAX.  TNixon decided that it was desirable
+            // to maintain this behavior for existing apps which may rely
+            // on it.  (10/24/95)
+            //
+
+            CharUpperW(pszFileName);
+
+            ptLineClientTarget = NULL;
+
+            for (i = 0; i < pXxxClientList->dwNumUsedEntries; i++)
+            {
+                ptLineClientTmp = (PTLINECLIENT) pXxxClientList->aEntries[i];
+
+                try
+                {
+                    //
+                    // Recall that all app names start with '"'
+                    //
+
+DBGOUT((0, "Looking for [%ls]    list entry [%ls]",
+    pszFileName,
+                ((PTLINEAPP) ptLineClientTmp->ptLineApp)
+                            ->pszModuleName ));
+                    if ((lstrcmpW(
+                            pszFileName,
+                            ((PTLINEAPP) ptLineClientTmp->ptLineApp)
+                                ->pszModuleName + 1
+
+                            ) == 0) &&
+
+                        (ptLineClientTmp->dwPrivileges &
+                            LINECALLPRIVILEGE_OWNER))
+                    {
+                        ptLineClientTarget = ptLineClientTmp;
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+
+            if (ptLineClientTarget == NULL)
+            {
+                pParams->lResult = LINEERR_TARGETNOTFOUND;
+                goto LHandoff_freeXxxClientList;
+            }
+            else if (ptLineClientTarget == ptLineClientApp)
+            {
+
+// BUGBUG? LHandoff: directed handoff & target == self not an error?
+
+                goto LHandoff_freeXxxClientList;
+            }
+        }
+        else
+        {
+            //
+            // "Non-directed" handoff
+            //
+            // Validate the media mode, then walk thru the list of line
+            // clients and find the highest pri one with owner privileges
+            // that wants calls of the specified media mode
+            //
+
+            switch (dwAPIVersion)
+            {
+            case TAPI_VERSION1_0:
+
+                dwValidMediaModes = AllMediaModes1_0;
+                break;
+
+                     //case TAPI_VERSION1_4:
+            default: //case TAPI_VERSION_CURRENT:
+
+                dwValidMediaModes = AllMediaModes1_4;
+                break;
+            }
+
+            if (!IsOnlyOneBitSetInDWORD(dwMediaMode) ||
+                (dwMediaMode & (dwValidMediaModes ^ 0x00ffffff)))
+            {
+                pParams->lResult = LINEERR_INVALMEDIAMODE;
+                goto LHandoff_freeXxxClientList;
+            }
+
+            if ((ptLineClientTarget = GetHighestPriorityLineClient(
+                    ptLine,
+                    dwMediaMode,
+                    0xffffffff
+
+                    )) == NULL)
+            {
+                pParams->lResult = LINEERR_TARGETNOTFOUND;
+                goto LHandoff_freeXxxClientList;
+            }
+            else if (ptLineClientTarget == ptLineClientApp)
+            {
+                pParams->lResult = LINEERR_TARGETSELF;
+                goto LHandoff_freeXxxClientList;
+            }
+
+        }
+
+
+        //
+        // We've found a target tLineClient. See if it already has a
+        // tCallClient for this call, and if not create one.  Then set
+        // the privilege on the target's tCallClient to OWNER & send
+        // the appropriate msgs.
+        //
+
+        if (pXxxClientList != &xxxClientList)
+        {
+            ServerFree (pXxxClientList);
+        }
+
+        if ((lResult = GetCallClientListFromCall(
+                ptCall,
+                &pXxxClientList
+                )))
+        {
+            pParams->lResult = lResult;
+            goto LHandoff_epilog;
+        }
+
+        {
+            BOOL            bDupedMutex, bCreatedtCallClient;
+            HANDLE          hMutex;
+            PTCALLCLIENT    ptCallClientTarget = NULL, ptCallClientTmp;
+
+
+            for (i = 0; i < pXxxClientList->dwNumUsedEntries; i++)
+            {
+                ptCallClientTmp = (PTCALLCLIENT) pXxxClientList->aEntries[i];
+
+                try
+                {
+                    if ((PTLINECLIENT) ptCallClientTmp->ptLineClient ==
+                            ptLineClientTarget)
+                    {
+                        ptCallClientTarget = ptCallClientTmp;
+                        break;
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+
+            if (!ptCallClientTarget)
+            {
+                if ((lResult = CreatetCallClient(
+                        ptCall,
+                        ptLineClientTarget,
+                        LINECALLPRIVILEGE_OWNER,
+                        TRUE,
+                        TRUE,
+                        &ptCallClientTarget,
+                        FALSE
+
+                        )) != 0)
+                {
+                    pParams->lResult = lResult;
+                    goto LHandoff_freeXxxClientList;
+                }
+
+                bCreatedtCallClient = TRUE;
+            }
+            else
+            {
+                bCreatedtCallClient = FALSE;
+            }
+
+            if (WaitForExclusivetCallAccess(
+                    (HTAPICALL) ptCall,
+                    TCALL_KEY,
+                    &hMutex,
+                    &bDupedMutex,
+                    INFINITE
+                    ))
+            {
+                DWORD dwCallInfoState, dwCallState, dwCallStateMode;
+
+
+                if (bCreatedtCallClient)
+                {
+                    //
+                    // CreatetCallClient will have already sent out the
+                    // appropriate CALLINFO msgs & updated NumOwners field
+                    //
+
+                    dwCallInfoState = 0;
+                }
+                else if (ptCallClientTarget->dwPrivilege ==
+                            LINECALLPRIVILEGE_MONITOR)
+                {
+                    ptCallClientTarget->dwPrivilege = LINECALLPRIVILEGE_OWNER;
+
+                    ptCall->dwNumOwners++;
+                    ptCall->dwNumMonitors--;
+
+                    dwCallInfoState = LINECALLINFOSTATE_NUMOWNERINCR |
+                        LINECALLINFOSTATE_NUMMONITORS;
+                }
+                else
+                {
+                    dwCallInfoState = 0;
+                }
+
+                dwCallState     = ptCall->dwCallState;
+                dwCallStateMode = ptCall->dwCallStateMode;
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+                if (dwCallInfoState || bCreatedtCallClient)
+                {
+                    BOOL            bIndicatePrivilege = TRUE;
+                    PTCLIENT        ptClientTarget;
+                    ASYNCEVENTMSG   msg;
+
+
+                    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+                    msg.pfnPostProcessProc = 0;
+
+                    if (bCreatedtCallClient)
+                    {
+                        try
+                        {
+                            if (ptLineClientTarget->dwAPIVersion >=
+                                    TAPI_VERSION2_0)
+                            {
+                                msg.hDevice     = (DWORD) ptLineClientTarget;
+                                msg.dwMsg       = LINE_APPNEWCALL;
+                                msg.dwParam1    = ptCall->dwAddressID;
+                                msg.dwParam2    = (DWORD) ptCallClientTarget;
+                                msg.dwParam3    = LINECALLPRIVILEGE_OWNER;
+
+                                msg.pInitData = (DWORD) ((PTLINEAPP)
+                                    ptLineClientTarget->ptLineApp)->
+                                        lpfnCallback;
+
+                                msg.dwCallbackInst =
+                                    ptLineClientTarget->dwCallbackInstance;
+
+                                ptClientTarget = (PTCLIENT)
+                                    ptCallClientTarget->ptClient;
+
+                                if (ptCallClientTarget->dwKey ==
+                                        TCALLCLIENT_KEY)
+                                {
+                                    bIndicatePrivilege = FALSE;
+                                    WriteEventBuffer (ptClientTarget, &msg);
+                                }
+                            }
+                        }
+                        myexcept
+                        {
+                        }
+                    }
+
+                    msg.hDevice            = (DWORD) ptCallClientTarget;
+                    msg.dwMsg              = LINE_CALLSTATE;
+                    msg.dwParam1           = dwCallState;
+                    msg.dwParam2           = dwCallStateMode;
+                    msg.dwParam3           = (bIndicatePrivilege ?
+                                                LINECALLPRIVILEGE_OWNER : 0);
+                    try
+                    {
+                        msg.pInitData = (DWORD) ((PTLINEAPP)
+                            ptLineClientTarget->ptLineApp)->lpfnCallback;
+
+                        msg.dwCallbackInst =
+                            ptLineClientTarget->dwCallbackInstance;
+
+                        ptClientTarget = (PTCLIENT)
+                            ptCallClientTarget->ptClient;
+
+                        if (ptCallClientTarget->dwKey == TCALLCLIENT_KEY)
+                        {
+                            WriteEventBuffer (ptClientTarget, &msg);
+                        }
+                    }
+                    myexcept
+                    {
+                    }
+
+                    if (dwCallInfoState != 0)
+                    {
+                        LineEventProc(
+                            (HTAPILINE) ptLine,
+                            (HTAPICALL) ptCall,
+                            LINE_CALLINFO,
+                            dwCallInfoState,
+                            0,
+                            0
+                            );
+                    }
+                }
+            }
+        }
+
+LHandoff_freeXxxClientList:
+
+        if (pXxxClientList != &xxxClientList)
+        {
+            ServerFree (pXxxClientList);
+        }
+    }
+
+LHandoff_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "Handoff"
+        );
+}
+
+
+void
+WINAPI
+LHold(
+    PLINEHOLD_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineHold;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEHOLD,                // provider func index
+            &pfnTSPI_lineHold,          // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Hold"                      // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineHold,
+            "lineHold",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Hold"
+        );
+}
+
+
+void
+WINAPI
+LInitialize(
+    PLINEINITIALIZE_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwFriendlyNameSize, dwModuleNameSize;
+    HANDLE      hMutex;
+    PTCLIENT    ptClient = pParams->ptClient;
+    PTLINEAPP   ptLineApp;
+    // PDWORD      pdwCounter;
+
+
+    //
+    // Alloc & init a new tLineApp
+    //
+
+    dwFriendlyNameSize = sizeof(WCHAR) * (1 + lstrlenW(
+        (PWSTR)(pDataBuf + pParams->dwFriendlyNameOffset))
+        );
+
+    dwModuleNameSize = sizeof(WCHAR) * (2 + lstrlenW(
+        (PWSTR)(pDataBuf + pParams->dwModuleNameOffset))
+        );
+
+    if (!(ptLineApp = ServerAlloc(
+            sizeof(TLINEAPP) +
+            dwFriendlyNameSize +
+            dwModuleNameSize
+            )) ||
+
+        !(ptLineApp->hMutex = MyCreateMutex()))
+    {
+        pParams->lResult = LINEERR_NOMEM;
+
+        goto LInitialize_error1;
+    }
+
+    ptLineApp->dwKey        = TLINEAPP_KEY;
+    ptLineApp->ptClient     = ptClient;
+    ptLineApp->lpfnCallback = pParams->lpfnCallback;
+    ptLineApp->dwAPIVersion = pParams->dwAPIVersion;
+
+    ptLineApp->dwFriendlyNameSize = dwFriendlyNameSize;
+    ptLineApp->pszFriendlyName    = (WCHAR *) (ptLineApp + 1);
+
+    lstrcpyW(
+        ptLineApp->pszFriendlyName,
+        (PWSTR)(pDataBuf + pParams->dwFriendlyNameOffset)
+        );
+
+    //
+    // Note: we prepend the '"' char to the saved module name to aid in
+    //       priority determination for incoming calls
+    //
+
+    ptLineApp->dwModuleNameSize = dwModuleNameSize;
+    ptLineApp->pszModuleName = (WCHAR *)((LPBYTE)(ptLineApp + 1) +
+                                         dwFriendlyNameSize);
+
+    ptLineApp->pszModuleName[0] = '"';
+
+    lstrcpyW(
+        &ptLineApp->pszModuleName[1],
+        (WCHAR *)(pDataBuf + pParams->dwModuleNameOffset)
+        );
+
+    CharUpperW (&ptLineApp->pszModuleName[1]);
+
+
+    //
+    // Safely insert new tLineApp at front of tClient's tLineApp list
+    //
+
+    if (WaitForExclusiveClientAccess(
+            ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        if ((ptLineApp->pNext = ptClient->ptLineApps))
+        {
+            ptLineApp->pNext->pPrev = ptLineApp;
+        }
+
+        ptClient->ptLineApps = ptLineApp;
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+    }
+    else
+    {
+        pParams->lResult = LINEERR_OPERATIONFAILED;
+        goto LInitialize_error1;
+    }
+
+
+    //
+    // Check if global reinit flag set
+    //
+
+    if (TapiGlobals.bReinit)
+    {
+        pParams->lResult = LINEERR_REINIT;
+        goto LInitialize_error2;
+    }
+
+
+    //
+    // See if we need to go thru init
+    //
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    if ((TapiGlobals.dwNumLineInits == 0) &&
+        (TapiGlobals.dwNumPhoneInits == 0))
+    {
+
+        if ((pParams->lResult = ServerInit()) != 0)
+        {
+            ReleaseMutex (TapiGlobals.hMutex);
+            goto LInitialize_error2;
+        }
+    }
+
+
+    //
+    // Fill in the return values
+    //
+
+    pParams->hLineApp  = (HLINEAPP) ptLineApp;
+    pParams->dwNumDevs = TapiGlobals.dwNumLines;
+
+
+    //
+    // Increment total num line inits
+    //
+
+    TapiGlobals.dwNumLineInits++;
+
+    *pdwNumBytesReturned = sizeof (LINEINITIALIZE_PARAMS);
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+    goto LInitialize_return;
+
+
+LInitialize_error2:
+
+    if (WaitForExclusiveClientAccess(
+            ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        if (ptLineApp->pNext)
+        {
+            ptLineApp->pNext->pPrev = ptLineApp->pPrev;
+        }
+
+        if (ptLineApp->pPrev)
+        {
+            ptLineApp->pPrev->pNext = ptLineApp->pNext;
+        }
+        else
+        {
+            ptClient->ptLineApps = ptLineApp->pNext;
+        }
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+    }
+
+LInitialize_error1:
+
+    if (ptLineApp)
+    {
+        if (ptLineApp->hMutex)
+        {
+            CloseHandle (ptLineApp->hMutex);
+        }
+
+        ServerFree (ptLineApp);
+    }
+
+LInitialize_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineInitialize: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+LMakeCall_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    BOOL            bDupedMutex;
+    HANDLE          hMutex;
+    PTCALL          ptCall = (PTCALL) pAsyncRequestInfo->dwParam1;
+    LPHCALL         lphCall = (LPHCALL) pAsyncRequestInfo->dwParam2;
+    PTCALLCLIENT    ptCallClient;
+
+
+    if (WaitForExclusivetCallAccess(
+            (HTAPICALL) ptCall,
+            TINCOMPLETECALL_KEY,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD       dwCallInstance = pAsyncRequestInfo->dwParam5;
+
+
+        //
+        // Check to make sure this is the call we think it is (that the
+        // pointer wasn't freed by a previous call to lineClose/Shutdown
+        // and realloc'd for use as a ptCall again)
+        //
+
+        if (ptCall->dwCallInstance != dwCallInstance)
+        {
+            MyReleaseMutex (hMutex, bDupedMutex);
+            goto LMakeCall_PostProcess_bad_ptCall;
+        }
+
+        ptCallClient = (PTCALLCLIENT) ptCall->ptCallClients;
+
+        if (pAsyncEventMsg->dwParam2 == 0)  // success
+        {
+            //
+            // In general it's ok with us if service providers want to
+            // specify NULL as their hdCall (could be an index in an
+            // array).  But in the TSPI_lineForward case, the spec says
+            // that a NULL hdCall value following successful completion
+            // indicates that no call was created, so in that case we
+            // want to nuke the tCall & tCallClient we created, and
+            // indicate a NULL call handle to the client. A non-zero
+            // pAsyncRequestInfo->dwParam3 tells us that we are
+            // post-processing a lineForward request, otherwise it's a
+            // make call or similar (non-Forward) request.
+            //
+
+            if (pAsyncRequestInfo->dwParam3 && !ptCall->hdCall)
+            {
+                goto LMakeCall_PostProcess_cleanupCalls;
+            }
+
+
+            //
+            // Check to see if the app closed the line & left us with
+            // 0 call clients (in which case it'll also be taking care of
+            // cleaning up this tCall too)
+            //
+
+            if (ptCall->ptCallClients == NULL)
+            {
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+                ptCallClient = (PTCALLCLIENT) NULL;
+
+                if (pAsyncEventMsg->dwParam2 == 0)
+                {
+                    pAsyncEventMsg->dwParam2 = LINEERR_INVALLINEHANDLE;
+                }
+
+                goto LMakeCall_PostProcess_initMsgParams;
+            }
+
+
+            //
+            // Find out which address the call is on
+            //
+
+            CallSP2(
+                ptCall->ptProvider->apfn[SP_LINEGETCALLADDRESSID],
+                "lineGetCallAddressID",
+                SP_FUNC_SYNC,
+                (DWORD) ptCall->hdCall,
+                (DWORD) (&ptCall->dwAddressID)
+                );
+
+
+            //
+            // Mark the calls as valid, the release the mutex.
+            //
+
+            ptCall->dwKey       = TCALL_KEY;
+            ptCallClient->dwKey = TCALLCLIENT_KEY;
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+
+            //
+            // Create monitor tCallClients
+            //
+
+            CreateCallMonitors (ptCall);
+
+
+        }
+        else    // error
+        {
+
+LMakeCall_PostProcess_cleanupCalls:
+
+            RemoveCallFromLineList (ptCall);
+            ptCall->dwKey = INVAL_KEY;
+
+
+            //
+            // Check to see if another thread already destroyed the
+            // tCallClient (due to a lineClose/Shutdown) before trying
+            // to reference a freed object
+            //
+
+            if (ptCall->ptCallClients)
+            {
+                RemoveCallClientFromLineClientList (ptCallClient);
+                ptCallClient->dwKey = INVAL_KEY;
+                ServerFree  (ptCallClient);
+            }
+
+
+            //
+            // If we have a duped mutex handle (bDupedMutex == TRUE)
+            // then we can safely go ahead and close the ptCall->hMutex
+            // since no other thread will be waiting on it (thanks to
+            // the first WaitForSingleObject in WaitForMutex).  Also
+            // release & close the duped handle.
+            //
+            // Otherwise, we have the actual ptCall->hMutex, and we
+            // wrap the release & close in a critical section to
+            // prevent another thread "T2" from grabbing ptCall->hMutex
+            // right after we release but right before we close.  This
+            // could result in deadlock at some point when "T2" goes to
+            // release the mutex, only to find that it's handle is bad,
+            // and thread "T3", which is waiting on the mutex (or a dup'd
+            // handle) waits forever.  (See corresponding critical
+            // section in WaitForMutex.)
+            //
+
+            if (bDupedMutex)
+            {
+                CloseHandle (ptCall->hMutex);
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+            }
+            else
+            {
+                EnterCriticalSection (&gSafeMutexCritSec);
+
+                ReleaseMutex (hMutex);
+                CloseHandle (hMutex);
+
+                LeaveCriticalSection (&gSafeMutexCritSec);
+            }
+
+            FreetCall  (ptCall);
+
+            ptCallClient = NULL;
+        }
+    }
+    else
+    {
+        //
+        // If here we can assume that the call was already destroyed
+        // and just fail the request
+        //
+
+LMakeCall_PostProcess_bad_ptCall:
+
+        ptCallClient = (PTCALLCLIENT) NULL;
+
+        if (pAsyncEventMsg->dwParam2 == 0)
+        {
+            pAsyncEventMsg->dwParam2 = LINEERR_OPERATIONFAILED;
+        }
+    }
+
+
+LMakeCall_PostProcess_initMsgParams:
+
+    //
+    // Fill in the params to pass to client (important to remotesp in both
+    // the success & fail cases so it can either init or clean up drvCall)
+    //
+
+    pAsyncEventMsg->dwParam3 = (DWORD) ptCallClient;
+    pAsyncEventMsg->dwParam4 = (DWORD) lphCall;
+}
+
+
+void
+WINAPI
+LMakeCall(
+    PLINEMAKECALL_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineMakeCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEMAKECALL,            // provider func index
+            &pfnTSPI_lineMakeCall,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "MakeCall"                  // func name
+
+            )) > 0)
+    {
+        LONG                lResult;
+        PTCALL              ptCall;
+        PTCALLCLIENT        ptCallClient;
+        LPLINECALLPARAMS    pCallParamsApp, pCallParamsSP;
+
+
+        pCallParamsApp = (LPLINECALLPARAMS)
+            (pParams->dwCallParamsOffset == TAPI_NO_DATA ?
+                0 : (pDataBuf + pParams->dwCallParamsOffset));
+
+        if (pCallParamsApp)
+        {
+            DWORD           dwAPIVersion, dwSPIVersion;
+
+
+            try
+            {
+                dwAPIVersion = ((PTLINECLIENT) pParams->hLine)->dwAPIVersion;
+                dwSPIVersion =
+                    ((PTLINECLIENT) pParams->hLine)->ptLine->dwSPIVersion;
+            }
+            myexcept
+            {
+                lRequestID = LINEERR_INVALLINEHANDLE;
+                goto LMakeCall_return;
+            }
+
+            if ((lResult = ValidateCallParams(
+                    pCallParamsApp,
+                    &pCallParamsSP,
+                    dwAPIVersion,
+                    dwSPIVersion,
+                    pParams->dwAsciiCallParamsCodePage
+
+                    )) != 0)
+            {
+                lRequestID = lResult;
+                goto LMakeCall_return;
+            }
+        }
+        else
+        {
+            pCallParamsSP = (LPLINECALLPARAMS) NULL;
+        }
+
+        if (CreatetCallAndClient(
+                (PTLINECLIENT) pParams->hLine,
+                &ptCall,
+                &ptCallClient,
+                pCallParamsSP,
+                &pAsyncRequestInfo->dwParam5
+
+                ) != 0)
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LMakeCall_freeCallParams;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LMakeCall_PostProcess;
+        pAsyncRequestInfo->dwParam1 = (DWORD) ptCall;
+        pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphCall;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP7(
+            pfnTSPI_lineMakeCall,
+            "lineMakeCall",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            (DWORD) ptCall,
+            (DWORD) &ptCall->hdCall,
+            (pParams->dwDestAddressOffset == TAPI_NO_DATA ?
+                0 : (DWORD) (pDataBuf + pParams->dwDestAddressOffset)),
+            pParams->dwCountryCode,
+            (DWORD) pCallParamsSP
+            );
+
+        SetDrvCallFlags(
+            ptCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+
+LMakeCall_freeCallParams:
+
+        if (pCallParamsSP != pCallParamsApp)
+        {
+            ServerFree (pCallParamsSP);
+        }
+    }
+
+LMakeCall_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "MakeCall"
+        );
+}
+
+
+void
+WINAPI
+LMonitorDigits(
+    PLINEMONITORDIGITS_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineMonitorDigits;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEMONITORDIGITS,       // provider func index
+            &pfnTSPI_lineMonitorDigits, // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "MonitorDigits"             // func name
+
+            )) == 0)
+    {
+        DWORD           dwUnionDigitModes;
+        PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) pParams->hCall,
+                        ptCallClient2;
+
+
+        if ((pParams->dwDigitModes & (~AllDigitModes)))
+        {
+            pParams->lResult = LINEERR_INVALDIGITMODE;
+            goto LMonitorDigits_epilog;
+        }
+
+
+        //
+        // Determine the new union of modes
+        //
+
+        dwUnionDigitModes = pParams->dwDigitModes;
+
+        ptCallClient2 = (PTCALLCLIENT) ptCallClient->ptCall->ptCallClients;
+
+        while (ptCallClient2)
+        {
+            if (ptCallClient2 != ptCallClient)
+            {
+                dwUnionDigitModes |= ptCallClient2->dwMonitorDigitModes;
+            }
+
+            ptCallClient2 = ptCallClient2->pNextSametCall;
+        }
+
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_lineMonitorDigits,
+                "lineMonitorDigits",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) dwUnionDigitModes
+
+                )) == 0)
+        {
+            ptCallClient->dwMonitorDigitModes = pParams->dwDigitModes;
+        }
+    }
+
+LMonitorDigits_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "MonitorDigits"
+        );
+}
+
+
+void
+WINAPI
+LMonitorMedia(
+    PLINEMONITORMEDIA_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineMonitorMedia;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEMONITORMEDIA,        // provider func index
+            &pfnTSPI_lineMonitorMedia,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "MonitorMedia"              // func name
+
+            )) == 0)
+    {
+        DWORD           dwValidMediaModes, dwUnionMediaModes;
+        PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) pParams->hCall,
+                        ptCallClient2;
+        PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                            ptCallClient->ptLineClient;
+
+
+        //
+        // Validate the specified modes
+        //
+
+        switch (ptLineClient->dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwValidMediaModes = AllMediaModes1_0;
+            break;
+
+        default: // case TAPI_VERSION1_4:
+                 // case TAPI_VERSION_CURRENT:
+
+            dwValidMediaModes = AllMediaModes1_4;
+            break;
+        }
+
+        if (pParams->dwMediaModes & ~dwValidMediaModes)
+        {
+            pParams->lResult = LINEERR_INVALMEDIAMODE;
+            goto LMonitorMedia_epilog;
+        }
+
+
+        //
+        // Determine the new union of modes
+        //
+
+        dwUnionMediaModes = pParams->dwMediaModes;
+
+        ptCallClient2 = (PTCALLCLIENT) ptCallClient->ptCall->ptCallClients;
+
+        while (ptCallClient2)
+        {
+            if (ptCallClient2 != ptCallClient)
+            {
+                dwUnionMediaModes |= ptCallClient2->dwMonitorMediaModes;
+            }
+
+            ptCallClient2 = ptCallClient2->pNextSametCall;
+        }
+
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_lineMonitorMedia,
+                "lineMonitorMedia",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) dwUnionMediaModes
+
+                )) == 0)
+        {
+            ptCallClient->dwMonitorMediaModes = pParams->dwMediaModes;
+        }
+    }
+
+LMonitorMedia_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "MonitorMedia"
+        );
+}
+
+
+void
+WINAPI
+LMonitorTones(
+    PLINEMONITORTONES_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineMonitorTones;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEMONITORTONES,        // provider func index
+            &pfnTSPI_lineMonitorTones,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "MonitorTones"              // func name
+
+            )) == 0)
+    {
+        LPDWORD pInstData;
+
+
+        if ((pInstData = ServerAlloc (2 * sizeof (DWORD))))
+        {
+            pInstData[0] = (DWORD) pParams->hCall;
+            pInstData[1] = pParams->dwToneListID;
+
+            pParams->lResult = CallSP4(
+                pfnTSPI_lineMonitorTones,
+                "lineMonitorTones",
+                SP_FUNC_SYNC,
+                (DWORD) hdCall,
+                (DWORD) pInstData,  // used as ID
+                (pParams->dwTonesOffset == TAPI_NO_DATA ? 0 :
+                    (DWORD) pDataBuf + pParams->dwTonesOffset),
+                (DWORD) pParams->dwNumEntries / sizeof (LINEMONITORTONE)
+                );
+        }
+        else
+        {
+            pParams->lResult = LINEERR_NOMEM;
+        }
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "MonitorTones"
+        );
+}
+
+
+void
+WINAPI
+LNegotiateAPIVersion(
+    PLINENEGOTIATEAPIVERSION_PARAMS pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    //
+    // Note: TAPI_VERSION1_0 <= dwNegotiatedAPIVersion <= dwSPIVersion
+    //
+
+    DWORD   dwDeviceID = pParams->dwDeviceID;
+
+
+    if (TapiGlobals.dwNumLineInits == 0)
+    {
+        pParams->lResult = LINEERR_UNINITIALIZED;
+        goto LNegotiateAPIVersion_exit;
+    }
+
+    if (dwDeviceID < TapiGlobals.dwNumLines)
+    {
+        DWORD       dwAPIHighVersion = pParams->dwAPIHighVersion,
+                    dwAPILowVersion  = pParams->dwAPILowVersion,
+                    dwHighestValidAPIVersion;
+        PTLINEAPP   ptLineApp = (PTLINEAPP) pParams->hLineApp;
+
+
+        if (!IsValidLineApp ((HLINEAPP) ptLineApp, pParams->ptClient))
+        {
+            pParams->lResult = (TapiGlobals.dwNumLineInits ?
+                LINEERR_INVALAPPHANDLE : LINEERR_UNINITIALIZED);
+
+            goto LNegotiateAPIVersion_exit;
+        }
+
+
+        //
+        // Do a minimax test on the specified lo/hi values
+        //
+
+        if ((dwAPILowVersion > dwAPIHighVersion) ||
+            (dwAPILowVersion > TAPI_VERSION_CURRENT) ||
+            (dwAPIHighVersion < TAPI_VERSION1_0))
+        {
+            pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+            goto LNegotiateAPIVersion_exit;
+        }
+
+
+        //
+        // HACKALERT! Some dumb apps like SmarTerm negotiate specifying
+        // a dwHighVersion of 0x7fffffff or higher, which can really
+        // cause them problems (like when they try to pass down structures
+        // of a size that was fine in the TAPI version under which the app
+        // was built, but which were enlarged in subsequent versions of
+        // TAPI, and the result is lots of LINEERR_STRUCTURETOOSMALL
+        // errors).
+        //
+        // Since we're nice, accomodating people we'll try to munge the
+        // dwHighVersion in these cases to be a value that makes sense, so
+        // we don't end up negotiating a version that the app can't handle.
+        //
+
+        if (dwAPIHighVersion & 0xc0000000)
+        {
+            dwAPIHighVersion = (dwAPILowVersion > TAPI_VERSION1_0 ?
+                dwAPILowVersion : TAPI_VERSION1_0);
+        }
+
+
+        //
+        // Find the highest valid API version given the lo/hi values.
+        // Since valid vers aren't consecutive we need to check for
+        // errors that our minimax test missed.
+        //
+
+        if (dwAPIHighVersion < TAPI_VERSION_CURRENT)
+        {
+            if ((dwAPIHighVersion >= TAPI_VERSION1_4) &&
+                (dwAPILowVersion <= TAPI_VERSION1_4))
+            {
+                dwHighestValidAPIVersion = TAPI_VERSION1_4;
+            }
+            else if ((dwAPIHighVersion >= TAPI_VERSION1_0) &&
+                (dwAPILowVersion <= TAPI_VERSION1_0))
+            {
+                dwHighestValidAPIVersion = TAPI_VERSION1_0;
+            }
+            else
+            {
+                pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+                goto LNegotiateAPIVersion_exit;
+            }
+        }
+        else
+        {
+            dwHighestValidAPIVersion = TAPI_VERSION_CURRENT;
+        }
+
+
+
+        {
+        BOOL    bCloseMutex;
+        HANDLE  hMutex;
+
+
+        //
+        // WARNING!!! WARNING!!! WARNING!!! WARNING!!!
+        // This code overwrites ptLineApp and later invalidates it.
+        // Do NOT use ptLineApp after the MyReleaseMutex call.
+        //
+
+        if ((ptLineApp = WaitForExclusiveLineAppAccess(
+                        pParams->hLineApp,
+                        pParams->ptClient,
+                        &hMutex,
+                        &bCloseMutex,
+                        INFINITE
+                        )))
+        {
+
+            //
+            // Is this app trying to negotiate something valid?
+            //
+            // If an app has called lineInitalize (as opposed to
+            // lineInitializeEx), we'll clamp the max APIVersion they can
+            // negotiate to 1.4.
+            //
+            if ( ptLineApp->dwAPIVersion < TAPI_VERSION2_0 )
+            {
+                dwHighestValidAPIVersion =
+                    (dwHighestValidAPIVersion >= TAPI_VERSION1_4) ?
+                    TAPI_VERSION1_4 : TAPI_VERSION1_0;
+            }
+        
+              
+            //
+            // Save the highest valid API version the client says it supports
+            // (we need this for determining which msgs to send to it)
+            //
+
+            if (dwHighestValidAPIVersion > ptLineApp->dwAPIVersion)
+            {
+                ptLineApp->dwAPIVersion = dwHighestValidAPIVersion;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALAPPHANDLE;
+            goto LNegotiateAPIVersion_exit;
+        }
+
+        }
+
+
+
+        //
+        // See if there's a valid match with the SPI ver
+        //
+
+        {
+            DWORD               dwSPIVersion;
+            PTLINELOOKUPENTRY   pLookupEntry;
+
+
+            pLookupEntry = GetLineLookupEntry (dwDeviceID);
+            dwSPIVersion = pLookupEntry->dwSPIVersion;
+
+            if (pLookupEntry->bRemoved)
+            {
+                pParams->lResult = LINEERR_NODEVICE;
+                goto LNegotiateAPIVersion_exit;
+            }
+
+            if (pLookupEntry->ptProvider == NULL)
+            {
+                pParams->lResult = LINEERR_NODRIVER;
+                goto LNegotiateAPIVersion_exit;
+            }
+
+            if (dwAPILowVersion <= dwSPIVersion)
+            {
+                pParams->dwAPIVersion =
+                    (dwHighestValidAPIVersion > dwSPIVersion ?
+                    dwSPIVersion : dwHighestValidAPIVersion);
+
+
+                //
+                // Retrieve ext id (indicate no exts if GetExtID not exported)
+                //
+
+                if (pLookupEntry->ptProvider->apfn[SP_LINEGETEXTENSIONID])
+                {
+                    if ((pParams->lResult = CallSP3(
+                            pLookupEntry->ptProvider->
+                                apfn[SP_LINEGETEXTENSIONID],
+                            "lineGetExtensionID",
+                            SP_FUNC_SYNC,
+                            (DWORD) dwDeviceID,
+                            (DWORD) dwSPIVersion,
+                            (DWORD) pDataBuf
+
+                            )) != 0)
+                    {
+                        goto LNegotiateAPIVersion_exit;
+                    }
+                }
+                else
+                {
+                    FillMemory (pDataBuf, sizeof (LINEEXTENSIONID), 0);
+                }
+            }
+            else
+            {
+                pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+                goto LNegotiateAPIVersion_exit;
+            }
+        }
+
+        pParams->dwExtensionIDOffset = 0;
+        pParams->dwSize              = sizeof (LINEEXTENSIONID);
+
+        *pdwNumBytesReturned = sizeof (LINEEXTENSIONID) + sizeof (TAPI32_MSG);
+    }
+    else
+    {
+        pParams->lResult = LINEERR_BADDEVICEID;
+    }
+
+LNegotiateAPIVersion_exit:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineNegotiateAPIVersion: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+LNegotiateExtVersion(
+    PLINENEGOTIATEEXTVERSION_PARAMS pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwDeviceID = pParams->dwDeviceID;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineNegotiateExtVersion;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hLineApp,  // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINENEGOTIATEEXTVERSION, // provider func index
+            &pfnTSPI_lineNegotiateExtVersion,   // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "NegotiateExtVersion"       // func name
+
+            )) == 0)
+    {
+        DWORD   dwSPIVersion = (GetLineLookupEntry(dwDeviceID))->dwSPIVersion;
+
+
+        if (!IsAPIVersionInRange(
+                pParams->dwAPIVersion,
+                dwSPIVersion
+                ))
+        {
+            pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+            goto LNegotiateExtVersion_epilog;
+        }
+
+        if ((pParams->lResult = CallSP5(
+                pfnTSPI_lineNegotiateExtVersion,
+                "lineNegotiateExtVersion",
+                SP_FUNC_SYNC,
+                (DWORD) dwDeviceID,
+                (DWORD) dwSPIVersion,
+                (DWORD) pParams->dwExtLowVersion,
+                (DWORD) pParams->dwExtHighVersion,
+                (DWORD) &pParams->dwExtVersion
+
+                )) == 0)
+        {
+            if (pParams->dwExtVersion == 0)
+            {
+                pParams->lResult = LINEERR_INCOMPATIBLEEXTVERSION;
+            }
+            else
+            {
+                *pdwNumBytesReturned = sizeof (LINENEGOTIATEEXTVERSION_PARAMS);
+            }
+        }
+    }
+
+LNegotiateExtVersion_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "NegotiateExtVersion"
+        );
+}
+
+
+
+VOID
+PASCAL
+xxxLOpen(
+    PLINEOPEN_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned,
+    BOOL                bLineMapper
+    )
+{
+    BOOL                bCloseMutex,
+                        bOpenedtLine = FALSE,
+                        bDecrExtVerCountOnError = FALSE,
+                        bReleasetLineMutex = FALSE,
+                        bFreeCallParams = FALSE;
+    LONG                lResult;
+    DWORD               dwDeviceID = pParams->dwDeviceID;
+    HANDLE              hMutex;
+    PTLINE              ptLine = NULL;
+    PTPROVIDER          ptProvider = NULL;
+    PTLINECLIENT        ptLineClient = NULL;
+    PTLINELOOKUPENTRY   pLookupEntry;
+    LPLINECALLPARAMS    pCallParams = NULL;
+
+
+    if ((lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hLineApp,  // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            (bLineMapper ? "Open(LINEMAPPER)" : "Open")
+                                        // func name
+
+            )) == 0)
+    {
+        DWORD               dwPrivileges = pParams->dwPrivileges,
+                            dwAPIVersion = pParams->dwAPIVersion,
+                            dwExtVersion = pParams->dwExtVersion,
+                            dwMediaModes, dwNumProxyRequestTypes,
+                           *pdwProxyRequestTypes,
+                            i;
+        PTLINEAPP           ptLineApp;
+
+
+        //
+        // Check if the global reinit flag is set
+        //
+
+        if (TapiGlobals.bReinit)
+        {
+            lResult = LINEERR_REINIT;
+            goto xxxLOpen_cleanup;
+        }
+
+
+        //
+        // Validate params
+        //
+
+        pLookupEntry = GetLineLookupEntry (dwDeviceID);
+
+        if (!IsAPIVersionInRange(
+                dwAPIVersion,
+                pLookupEntry->dwSPIVersion
+                ))
+        {
+            lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+            goto xxxLOpen_cleanup;
+        }
+
+        ptProvider = pLookupEntry->ptProvider;
+
+
+        #define VALID_LOPEN_BITS (LINECALLPRIVILEGE_NONE       | \
+                                  LINECALLPRIVILEGE_MONITOR    | \
+                                  LINECALLPRIVILEGE_OWNER      | \
+                                  LINEOPENOPTION_SINGLEADDRESS | \
+                                  LINEOPENOPTION_PROXY)
+
+        #define VALID_PRIV_BITS  (LINECALLPRIVILEGE_NONE       | \
+                                  LINECALLPRIVILEGE_MONITOR    | \
+                                  LINECALLPRIVILEGE_OWNER)
+
+        if (!(dwPrivileges & VALID_PRIV_BITS) ||
+
+            (dwPrivileges & ~VALID_LOPEN_BITS) ||
+
+            ((dwPrivileges & LINECALLPRIVILEGE_NONE) &&
+                (dwPrivileges & (LINECALLPRIVILEGE_MONITOR |
+                    LINECALLPRIVILEGE_OWNER))))
+        {
+            lResult = LINEERR_INVALPRIVSELECT;
+            goto xxxLOpen_cleanup;
+        }
+
+        if (dwPrivileges & (LINEOPENOPTION_SINGLEADDRESS |
+                LINEOPENOPTION_PROXY)  ||
+            bLineMapper)
+        {
+            pCallParams = (LPLINECALLPARAMS)
+                (pParams->dwCallParamsOffset == TAPI_NO_DATA ?
+                    NULL : pDataBuf + pParams->dwCallParamsOffset);
+
+            if (!pCallParams)
+            {
+                lResult = LINEERR_INVALPOINTER;
+                goto xxxLOpen_cleanup;
+            }
+
+            if ((lResult = ValidateCallParams(
+                    pCallParams,
+                    &pCallParams,
+                    dwAPIVersion,
+                    dwAPIVersion,
+                    pParams->dwAsciiCallParamsCodePage
+                    )))
+            {
+                lResult = LINEERR_INVALPOINTER;
+                goto xxxLOpen_cleanup;
+            }
+
+            if (pCallParams != (LPLINECALLPARAMS)
+                    (pDataBuf + pParams->dwCallParamsOffset))
+            {
+                bFreeCallParams = TRUE;
+            }
+
+            if ((dwPrivileges & LINEOPENOPTION_SINGLEADDRESS) &&
+
+                (pCallParams->dwAddressMode != LINEADDRESSMODE_ADDRESSID))
+            {
+                DBGOUT((
+                    3,
+                    "lineOpen(SINGLEADDRESS): callParams.dwAddressMode" \
+                        "!= ADDRESSID"
+                    ));
+
+                lResult = LINEERR_INVALCALLPARAMS;
+                goto xxxLOpen_cleanup;
+            }
+
+            if (dwPrivileges & LINEOPENOPTION_PROXY)
+            {
+                //
+                // Verify the array of DWORDs (request types) in the
+                // DevSpecific var field
+                //
+
+                dwNumProxyRequestTypes =
+                    (pCallParams->dwDevSpecificSize & 0xfffffffc) /
+                        sizeof (DWORD);
+
+                if (dwNumProxyRequestTypes == 0 ||
+                    dwNumProxyRequestTypes > 8)
+                {
+                    DBGOUT((
+                        3,
+                        "lineOpen(PROXY): inval proxy request type array "\
+                            "size (callParams.dwDevSpecificSize=x%x)",
+                        pCallParams->dwDevSpecificSize
+                        ));
+
+                    lResult = LINEERR_INVALCALLPARAMS;
+                    goto xxxLOpen_cleanup;
+                }
+
+                pdwProxyRequestTypes = (LPDWORD) (((LPBYTE) pCallParams) +
+                    pCallParams->dwDevSpecificOffset);
+
+                for (i = 0; i < dwNumProxyRequestTypes; i++)
+                {
+                    if (*(pdwProxyRequestTypes + i) == 0 ||
+                        *(pdwProxyRequestTypes + i) >
+                            LINEPROXYREQUEST_GETAGENTGROUPLIST)
+                    {
+                        DBGOUT((
+                            3,
+                            "lineOpen(PROXY): inval proxy request type "\
+                                "(x%x)",
+                            *(pdwProxyRequestTypes + i)
+                            ));
+
+                        lResult = LINEERR_INVALCALLPARAMS;
+                        goto xxxLOpen_cleanup;
+                    }
+                }
+            }
+        }
+
+        if ((dwPrivileges & LINECALLPRIVILEGE_OWNER))
+        {
+            DWORD dwAllMediaModes;
+
+
+            dwMediaModes = pParams->dwMediaModes;
+
+            switch (dwAPIVersion)
+            {
+            case TAPI_VERSION1_0:
+
+                dwAllMediaModes = AllMediaModes1_0;
+                break;
+
+            default: // case TAPI_VERSION_CURRENT:
+
+                dwAllMediaModes = AllMediaModes1_4;
+                break;
+            }
+
+            if ((dwMediaModes == 0) ||
+                (dwMediaModes & (0x00ffffff & ~dwAllMediaModes)))
+            {
+                lResult = LINEERR_INVALMEDIAMODE;
+                goto xxxLOpen_cleanup;
+            }
+        }
+        else
+        {
+            dwMediaModes = 0;
+        }
+
+
+        //
+        // Create & init a tLineClient & associated resources
+        //
+
+        if (!(ptLineClient = ServerAlloc (sizeof(TLINECLIENT))))
+        {
+            lResult = LINEERR_NOMEM;
+            goto xxxLOpen_cleanup;
+        }
+
+        ptLineClient->hMutex             = MyCreateMutex();
+        ptLineClient->ptClient           = pParams->ptClient;
+        ptLineClient->ptLineApp          = (PTLINEAPP) pParams->hLineApp;
+        ptLineClient->hRemoteLine        = (pParams->hRemoteLine ?
+            (DWORD) pParams->hRemoteLine : (DWORD) ptLineClient);
+        ptLineClient->dwAPIVersion       = dwAPIVersion;
+        ptLineClient->dwPrivileges       = dwPrivileges;
+        ptLineClient->dwMediaModes       = dwMediaModes;
+        ptLineClient->dwCallbackInstance = pParams->dwCallbackInstance;
+        ptLineClient->dwAddressID        =
+            (dwPrivileges & LINEOPENOPTION_SINGLEADDRESS ?
+                pCallParams->dwAddressID : 0xffffffff);
+
+
+        //
+        // Grab the tLine's mutex, then start doing the open
+        //
+
+xxxLOpen_waitForMutex:
+
+        if (WaitForSingleObject (pLookupEntry->hMutex, INFINITE)
+                != WAIT_OBJECT_0)
+        {
+            bReleasetLineMutex = FALSE;
+            lResult = LINEERR_OPERATIONFAILED;
+            goto xxxLOpen_cleanup;
+        }
+
+        bReleasetLineMutex = TRUE;
+
+
+        //
+        // If the tLine is in the process of being destroyed then spin
+        // until it's been completely destroyed (DestroytLine() will
+        // NULLify pLookupEntry->ptLine when it's finished). Make sure
+        // to release the mutex while sleeping so we don't block
+        // DestroytLine.
+        //
+
+        try
+        {
+            while (pLookupEntry->ptLine &&
+                   pLookupEntry->ptLine->dwKey != TLINE_KEY)
+            {
+                ReleaseMutex (pLookupEntry->hMutex);
+                Sleep (0);
+                goto xxxLOpen_waitForMutex;
+            }
+        }
+        myexcept
+        {
+            // If here pLookupEntry->ptLine was NULLified, safe to continue
+        }
+
+
+        //
+        // Validate ext ver as appropriate
+        //
+
+        if (dwExtVersion != 0 &&
+            (!IsValidLineExtVersion (dwDeviceID, dwExtVersion) ||
+            ptProvider->apfn[SP_LINESELECTEXTVERSION] == NULL))
+        {
+            lResult = LINEERR_INCOMPATIBLEEXTVERSION;
+            goto xxxLOpen_cleanup;
+        }
+
+
+        //
+        // If line isn't open already then try to open it
+        //
+
+        if (!(ptLine = pLookupEntry->ptLine))
+        {
+            if (!(ptLine = ServerAlloc (sizeof(TLINE))))
+            {
+                lResult = LINEERR_NOMEM;
+                goto xxxLOpen_cleanup;
+            }
+
+            ptLine->hMutex       = pLookupEntry->hMutex;
+            ptLine->ptProvider   = ptProvider;
+            ptLine->dwDeviceID   = dwDeviceID;
+            ptLine->dwSPIVersion = pLookupEntry->dwSPIVersion;
+
+            if ((lResult = CallSP5(
+                    ptProvider->apfn[SP_LINEOPEN],
+                    "lineOpen",
+                    SP_FUNC_SYNC,
+                    dwDeviceID,
+                    (DWORD) ptLine,
+                    (DWORD) &ptLine->hdLine,
+                    (DWORD) pLookupEntry->dwSPIVersion,
+                    (DWORD) LineEventProcSP
+
+                    )) != 0)
+            {
+                ServerFree (ptLine);
+                goto xxxLOpen_cleanup;
+            }
+
+            bOpenedtLine = TRUE;
+
+            CallSP2(
+                ptProvider->apfn[SP_LINEGETNUMADDRESSIDS],
+                "lineGetNumAddressIDs",
+                SP_FUNC_SYNC,
+                (DWORD) ptLine->hdLine,
+                (DWORD) &ptLine->dwNumAddresses
+                );
+
+            // PERF
+            PerfBlock.dwLinesInUse++;
+
+        }
+
+
+        //
+        // If line is already opened & client is trying to register
+        // as a proxy then see if there's any conflicts with existing
+        // proxys
+        //
+
+        else if (dwPrivileges & LINEOPENOPTION_PROXY)
+        {
+            for (i = 0; i < dwNumProxyRequestTypes; i++)
+            {
+                DWORD dwProxyRequestType = *(pdwProxyRequestTypes + i);
+
+
+                if (ptLine->apProxys[dwProxyRequestType] != NULL)
+                {
+                    lResult = LINEERR_NOTREGISTERED;
+                    goto xxxLOpen_cleanup;
+                }
+            }
+        }
+
+        ptLineClient->ptLine = ptLine;
+
+
+        //
+        // Verify the specified addr if appropriate
+        //
+
+        if ((dwPrivileges & LINEOPENOPTION_SINGLEADDRESS) &&
+
+            (ptLineClient->dwAddressID >= ptLine->dwNumAddresses))
+        {
+            lResult = LINEERR_INVALADDRESSID;
+            goto xxxLOpen_cleanup;
+        }
+
+
+        //
+        // If the client has specified a non-zero ext version then
+        // ask the driver to enable it and/or increment the ext
+        // version count. If this fails, and we're processing a
+        // LINEMAPPER request, then return a generic error so the
+        // caller will try the next device.
+        //
+
+        if (dwExtVersion)
+        {
+            if (ptLine->dwExtVersionCount == 0)
+            {
+                if ((lResult = CallSP2(
+                        ptProvider->apfn[SP_LINESELECTEXTVERSION],
+                        "lineSelectExtVersion",
+                        SP_FUNC_SYNC,
+                        (DWORD) ptLine->hdLine,
+                        (DWORD) dwExtVersion
+
+                        )) != 0)
+                {
+                    lResult = (bLineMapper ? LINEERR_OPERATIONFAILED :
+                        lResult);
+                    goto xxxLOpen_cleanup;
+                }
+
+                ptLine->dwExtVersion =
+                ptLineClient->dwExtVersion = pParams->dwExtVersion;
+            }
+
+            ptLine->dwExtVersionCount++;
+            bDecrExtVerCountOnError = TRUE;
+        }
+
+
+        //
+        // If we're processing a LINEMAPPER request, check to see if the
+        // device supports capabilities requested by client.  If not,
+        // return a generic error so the caller will try the next device.
+        //
+
+        if (bLineMapper)
+        {
+            if (CallSP3(
+                    ptProvider->apfn[SP_LINECONDITIONALMEDIADETECTION],
+                    "lineConditionalMediaDetection",
+                    SP_FUNC_SYNC,
+                    (DWORD) ptLine->hdLine,
+                    (DWORD) dwMediaModes | ptLine->dwOpenMediaModes,
+                    (DWORD) pCallParams
+
+                    ) != 0)
+            {
+                lResult = LINEERR_OPERATIONFAILED;
+                goto xxxLOpen_cleanup;
+            }
+        }
+
+
+        //
+        // If the client is requesting OWNER privileges (it's interested
+        // in incoming calls of the specified media mode(s)), then check
+        // to see if it wants incoming calls of a media mode(s) other
+        // than that the device has already agreed to indicate, and ask
+        // the driver if it can support looking for all of them at the
+        // same time. If this fails, and we're processing a LINEMAPPER
+        // request, then return a generic error so the caller will try
+        // the next device.
+        //
+
+        if (pParams->dwPrivileges & LINECALLPRIVILEGE_OWNER)
+        {
+            if ((dwMediaModes & ptLine->dwOpenMediaModes) != dwMediaModes)
+            {
+                DWORD   dwUnionMediaModes = dwMediaModes |
+                            ptLine->dwOpenMediaModes;
+
+
+                if ((lResult  = CallSP2(
+                        ptProvider->apfn[SP_LINESETDEFAULTMEDIADETECTION],
+                        "lineSetDefaultMediaDetection",
+                        SP_FUNC_SYNC,
+                        (DWORD) ptLine->hdLine,
+                        (DWORD) dwUnionMediaModes
+
+                        )) != 0)
+                {
+                    lResult = (bLineMapper ? LINEERR_OPERATIONFAILED :
+                        lResult);
+                    goto xxxLOpen_cleanup;
+                }
+
+                ptLine->dwOpenMediaModes = dwUnionMediaModes;
+            }
+        }
+
+
+        //
+        // Set the proxy ptrs if appropriate
+        //
+
+        if (dwPrivileges & LINEOPENOPTION_PROXY)
+        {
+            for (i = 0; i < dwNumProxyRequestTypes; i++)
+            {
+                ptLine->apProxys[*(pdwProxyRequestTypes + i)] =
+                    ptLineClient;
+            }
+        }
+
+
+        //
+        // Add the tLineClient to the tLine's list & increment the
+        // number of opens
+        //
+
+        if ((ptLineClient->pNextSametLine = ptLine->ptLineClients))
+        {
+            ptLineClient->pNextSametLine->pPrevSametLine = ptLineClient;
+        }
+
+        ptLine->ptLineClients = ptLineClient;
+        ptLine->dwNumOpens++;
+
+        if (bOpenedtLine)
+        {
+            pLookupEntry->ptLine = ptLine;
+            ptLine->dwKey = TLINE_KEY;
+        }
+
+        ReleaseMutex (pLookupEntry->hMutex);
+
+        bReleasetLineMutex = FALSE;
+
+
+        //
+        // Safely add the new tLineClient to the tLineApp's list.
+        //
+
+        {
+            BOOL    bDupedMutex;
+            HANDLE  hMutex;
+
+
+            if ((ptLineApp = WaitForExclusiveLineAppAccess(
+                    pParams->hLineApp,
+                    pParams->ptClient,
+                    &hMutex,
+                    &bDupedMutex,
+                    INFINITE
+                    )))
+            {
+                if ((ptLineClient->pNextSametLineApp =
+                        ptLineApp->ptLineClients))
+                {
+                    ptLineClient->pNextSametLineApp->pPrevSametLineApp =
+                        ptLineClient;
+                }
+
+                ptLineApp->ptLineClients = ptLineClient;
+
+
+                //
+                // Note: it's important to mark the newtLineClient as
+                // valid way down here because another thread could be
+                // simultaneously trying to do an unconditional
+                // DestroytLine (due to receiving a LINE_CLOSE, etc.)
+                // and we want to make sure the tLineClient is in both
+                // tLine's & tLineApp's lists before DestroytLine calls
+                // DestroytLineClient which'll try to yank the tLineClient
+                // out of these lists.
+                //
+
+                ptLineClient->dwKey = TLINECLIENT_KEY;
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+
+                //
+                // Alert other clients that another open has occured
+                //
+
+                SendMsgToLineClients(
+                    ptLine,
+                    ptLineClient,
+                    LINE_LINEDEVSTATE,
+                    LINEDEVSTATE_OPEN,
+                    0,
+                    0
+                    );
+
+
+                //
+                // Fill in the return values
+                //
+
+                pParams->hLine = (HLINE) ptLineClient;
+                *pdwNumBytesReturned = sizeof (LINEOPEN_PARAMS);
+            }
+            else
+            {
+                //
+                // If here the app handle is bad, & we've some special
+                // case cleanup to do.  Since the tLineClient is not
+                // in the tLineApp's list, we can't simply call
+                // DestroytLine(Client) to clean things up, since the
+                // pointer-resetting code will blow up.  So we'll
+                // grab the tLine's mutex and explicitly remove the
+                // new tLineClient from it's list, then do a conditional
+                // shutdown on the tLine (in case any other clients
+                // have come along & opened it). Also deselect the
+                // ext version and/or decrement the ext version count
+                // as appropriate.
+                //
+                // Note: keep in mind that a LINE_CLOSE might be being
+                //       processed by another thread (if so, it will be
+                //       spinning on trying to destroy the tLineClient
+                //       which isn't valid at this point)
+                //
+
+                lResult = LINEERR_INVALAPPHANDLE;
+
+                WaitForSingleObject (pLookupEntry->hMutex, INFINITE);
+
+                if (ptLineClient->pNextSametLine)
+                {
+                    ptLineClient->pNextSametLine->pPrevSametLine =
+                        ptLineClient->pPrevSametLine;
+                }
+
+                if (ptLineClient->pPrevSametLine)
+                {
+                    ptLineClient->pPrevSametLine->pNextSametLine =
+                        ptLineClient->pNextSametLine;
+                }
+                else
+                {
+                    ptLine->ptLineClients = ptLineClient->pNextSametLine;
+                }
+
+                ptLine->dwNumOpens--;
+
+                if (bDecrExtVerCountOnError == TRUE)
+                {
+                    ptLine->dwExtVersionCount--;
+
+                    if (ptLine->dwExtVersionCount == 0)
+                    {
+                        ptLine->dwExtVersion = 0;
+
+                        CallSP2(
+                            ptProvider->apfn[SP_LINESELECTEXTVERSION],
+                            "lineSelectExtVersion",
+                            SP_FUNC_SYNC,
+                            (DWORD) ptLine->hdLine,
+                            (DWORD) 0
+                            );
+                    }
+                }
+
+                ReleaseMutex (pLookupEntry->hMutex);
+
+                DestroytLine (ptLine, FALSE); // conditional destroy
+
+                bOpenedtLine = FALSE; // so ptr won't get freed below
+            }
+        }
+    }
+
+xxxLOpen_cleanup:
+
+    if (bReleasetLineMutex)
+    {
+        if (lResult != 0)
+        {
+            if (bDecrExtVerCountOnError == TRUE)
+            {
+                ptLine->dwExtVersionCount--;
+
+                if (ptLine->dwExtVersionCount == 0)
+                {
+                    ptLine->dwExtVersion = 0;
+
+                    CallSP2(
+                        ptProvider->apfn[SP_LINESELECTEXTVERSION],
+                        "lineSelectExtVersion",
+                        SP_FUNC_SYNC,
+                        (DWORD) ptLine->hdLine,
+                        (DWORD) 0
+                        );
+                }
+            }
+
+            if (bOpenedtLine == TRUE)
+            {
+                CallSP1(
+                    ptProvider->apfn[SP_LINECLOSE],
+                    "lineClose",
+                    SP_FUNC_SYNC,
+                    (DWORD) ptLine->hdLine
+                    );
+            }
+        }
+
+        ReleaseMutex (pLookupEntry->hMutex);
+    }
+
+    if ((pParams->lResult = lResult) != 0)
+    {
+        if (ptLineClient)
+        {
+            if (ptLineClient->hMutex)
+            {
+                CloseHandle (ptLineClient->hMutex);
+            }
+
+            ServerFree (ptLineClient);
+        }
+
+        if (bOpenedtLine)
+        {
+            ServerFree (ptLine);
+        }
+    }
+
+    if (bFreeCallParams)
+    {
+        ServerFree (pCallParams);
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        (bLineMapper ? "Open(LINEMAPPER)" : "Open")
+        );
+}
+
+
+
+void
+WINAPI
+LOpen(
+    PLINEOPEN_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    if (pParams->dwDeviceID != LINEMAPPER)
+    {
+        xxxLOpen (pParams, pDataBuf, pdwNumBytesReturned, FALSE);
+    }
+    else
+    {
+        //
+        // Try to open each line device, starting with device 0, until
+        // either we find a device that'll handle the capabilities
+        // requested by the client or we run out of devices. If we
+        // encounter a certain subset of parameter errors the first time
+        // we call xxxLOpen we want to return these back to the app
+        // immediately to aid debugging (rather than always returning
+        // LINEMAPPERFAILED).
+        //
+
+        for(
+            pParams->dwDeviceID = 0;
+            pParams->dwDeviceID < TapiGlobals.dwNumLines;
+            pParams->dwDeviceID++
+            )
+        {
+            xxxLOpen (pParams, pDataBuf, pdwNumBytesReturned, TRUE);
+
+            if (pParams->dwDeviceID == 0)
+            {
+                switch (pParams->lResult)
+                {
+                case LINEERR_BADDEVICEID:       // 0 line devices
+                case LINEERR_INVALAPPHANDLE:
+                case LINEERR_INVALCALLPARAMS:
+                case LINEERR_INVALMEDIAMODE:
+                case LINEERR_INVALPOINTER:      // no call params, etc
+                case LINEERR_INVALPRIVSELECT:
+                case LINEERR_REINIT:
+                case LINEERR_UNINITIALIZED:
+
+                    return;
+
+                default:
+
+                    break;
+                }
+            }
+
+            if (pParams->lResult == 0)
+            {
+                break;
+            }
+        }
+
+        if (pParams->dwDeviceID >= TapiGlobals.dwNumLines)
+        {
+            pParams->lResult = LINEERR_LINEMAPPERFAILED;
+        }
+    }
+}
+
+
+void
+LPark_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    //
+    // Note: pAsyncEventMsg->dwParam1 & dwParam2 are reserved for
+    //       the request ID and result, respectively
+    //
+
+    PASYNCEVENTMSG      pNewAsyncEventMsg = (PASYNCEVENTMSG)
+                            pAsyncRequestInfo->dwParam1;
+    LPVARSTRING         pNonDirAddress = (LPVARSTRING) (pNewAsyncEventMsg + 1);
+
+
+    CopyMemory (pNewAsyncEventMsg, pAsyncEventMsg, sizeof (ASYNCEVENTMSG));
+
+    *ppBuf = (LPVOID) pNewAsyncEventMsg;
+
+    if (pAsyncEventMsg->dwParam2 == 0)  // success
+    {
+        //
+        // Add the used size of the non-dir addr, & keep the total
+        // length of the msg DWORD-aligned
+        //
+
+        pNewAsyncEventMsg->dwTotalSize +=
+            ((pNonDirAddress->dwUsedSize + 3) & 0xfffffffc);
+
+        pNewAsyncEventMsg->dwParam3 =
+            pAsyncRequestInfo->dwParam2; // lpNonDirAddr
+        pNewAsyncEventMsg->dwParam4 = pNonDirAddress->dwUsedSize;
+
+    }
+}
+
+
+void
+WINAPI
+LPark(
+    PLINEPARK_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_linePark;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEPARK,                // provider func index
+            &pfnTSPI_linePark,          // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Park"                      // func name
+
+            )) > 0)
+    {
+        LPBYTE      pBuf;
+        LPVARSTRING pNonDirAddress;
+
+
+        if (pParams->dwParkMode == LINEPARKMODE_NONDIRECTED)
+        {
+            if (pParams->u.dwNonDirAddressTotalSize < sizeof (VARSTRING))
+            {
+                lRequestID = LINEERR_STRUCTURETOOSMALL;
+                goto LPark_return;
+            }
+
+            if (!(pBuf = ServerAlloc(
+                    (pParams->u.dwNonDirAddressTotalSize +
+                        sizeof (ASYNCEVENTMSG) + 3) & 0xfffffffc
+                    )))
+            {
+                lRequestID = LINEERR_NOMEM;
+                goto LPark_return;
+            }
+
+            pNonDirAddress = (LPVARSTRING) (pBuf + sizeof (ASYNCEVENTMSG));
+
+            pNonDirAddress->dwTotalSize  = pParams->u.dwNonDirAddressTotalSize;
+            pNonDirAddress->dwNeededSize =
+            pNonDirAddress->dwUsedSize   = sizeof (VARSTRING);
+
+            pAsyncRequestInfo->pfnPostProcess = LPark_PostProcess;
+            pAsyncRequestInfo->dwParam1 = (DWORD) pBuf;
+            pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lpNonDirAddress;
+
+            pAsyncRequestInfo->pfnClientPostProcessProc =
+                pParams->pfnPostProcessProc;
+        }
+        else if (pParams->dwParkMode == LINEPARKMODE_DIRECTED)
+        {
+            pNonDirAddress = (LPVARSTRING) NULL;
+        }
+        else
+        {
+            lRequestID = LINEERR_INVALPARKMODE;
+            goto LPark_return;
+        }
+
+        pParams->lResult = CallSP5(
+            pfnTSPI_linePark,
+            "linePark",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) pParams->dwParkMode,
+            (DWORD) (pParams->dwParkMode == LINEPARKMODE_NONDIRECTED ? NULL :
+                pDataBuf + pParams->dwDirAddressOffset),
+            (DWORD) pNonDirAddress
+            );
+    }
+
+LPark_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Park"
+        );
+}
+
+
+void
+WINAPI
+LPickup(
+    PLINEPICKUP_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_linePickup;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEPICKUP,              // provider func index
+            &pfnTSPI_linePickup,        // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Pickup"                    // func name
+
+            )) > 0)
+    {
+        PTCALL          ptCall;
+        PTCALLCLIENT    ptCallClient;
+
+
+        if (CreatetCallAndClient(
+                (PTLINECLIENT) pParams->hLine,
+                &ptCall,
+                &ptCallClient,
+                NULL,
+                &pAsyncRequestInfo->dwParam5
+
+                ) != 0)
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LPickup_return;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LMakeCall_PostProcess;
+        pAsyncRequestInfo->dwParam1 = (DWORD) ptCall;
+        pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphCall;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP7(
+            pfnTSPI_linePickup,
+            "linePickup",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            (DWORD) pParams->dwAddressID,
+            (DWORD) ptCall,
+            (DWORD) &ptCall->hdCall,
+            (pParams->dwDestAddressOffset == TAPI_NO_DATA ? 0 :
+                (DWORD)(pDataBuf + pParams->dwDestAddressOffset)),
+            (pParams->dwGroupIDOffset == TAPI_NO_DATA ? 0 :
+                (DWORD)(pDataBuf + pParams->dwGroupIDOffset))
+            );
+
+        SetDrvCallFlags(
+            ptCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+    }
+
+LPickup_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Pickup"
+        );
+}
+
+
+void
+WINAPI
+LPrepareAddToConference(
+    PLINEPREPAREADDTOCONFERENCE_PARAMS  pParams,
+    LPBYTE                              pDataBuf,
+    LPDWORD                             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    HANDLE      hMutex;
+    HDRVCALL    hdConfCall;
+    TSPIPROC    pfnTSPI_linePrepareAddToConference;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hConfCall, // client widget handle
+            (LPVOID) &hdConfCall,       // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEPREPAREADDTOCONFERENCE,  // provider func index
+            &pfnTSPI_linePrepareAddToConference,// provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "PrepareAddToConference"    // func name
+
+            )) > 0)
+    {
+        LONG                lResult;
+        PTCALL              ptConsultCall;
+        PTCALLCLIENT        ptConsultCallClient;
+        PTLINECLIENT        ptLineClient;
+        LPLINECALLPARAMS    pCallParamsApp, pCallParamsSP;
+
+
+        pCallParamsApp = (LPLINECALLPARAMS)
+            (pParams->dwCallParamsOffset == TAPI_NO_DATA ?
+                0 : pDataBuf + pParams->dwCallParamsOffset);
+
+        try
+        {
+            //
+            // Safely get the ptLineClient
+            //
+
+            ptLineClient = ((PTLINECLIENT) ((PTCALLCLIENT)
+                pParams->hConfCall)->ptLineClient);
+
+
+            //
+            // Make sure the hConfCall is really a conf parent
+            //
+
+            {
+                PTCALL  ptCall;
+
+
+                ptCall = (PTCALL) ((PTCALLCLIENT) pParams->hConfCall)->ptCall;
+
+                if (((PTCONFERENCELIST) ptCall->pConfList)->aptCalls[0] !=
+                        ptCall)
+                {
+                    lRequestID = LINEERR_INVALCONFCALLHANDLE;
+                    goto LPrepareAddToConference_return;
+                }
+            }
+        }
+        myexcept
+        {
+            //
+            // If here the conf call was destroyed
+            //
+
+            lRequestID = LINEERR_INVALCONFCALLHANDLE;
+            goto LPrepareAddToConference_return;
+        }
+
+        if (pCallParamsApp)
+        {
+            DWORD   dwAPIVersion, dwSPIVersion;
+
+
+            try
+            {
+                dwAPIVersion = ptLineClient->dwAPIVersion;
+                dwSPIVersion = ptLineClient->ptLine->dwSPIVersion;
+            }
+            myexcept
+            {
+                //
+                // If here either the line client or the line was closed
+                //
+
+                lRequestID = LINEERR_INVALCONFCALLHANDLE;
+                goto LPrepareAddToConference_return;
+            }
+
+            if ((lResult = ValidateCallParams(
+                    pCallParamsApp,
+                    &pCallParamsSP,
+                    dwAPIVersion,
+                    dwSPIVersion,
+                    pParams->dwAsciiCallParamsCodePage
+
+                    )) != 0)
+            {
+                lRequestID = lResult;
+                goto LPrepareAddToConference_return;
+            }
+        }
+        else
+        {
+            pCallParamsSP = (LPLINECALLPARAMS) NULL;
+        }
+
+        if (CreatetCallAndClient(
+                ptLineClient,
+                &ptConsultCall,
+                &ptConsultCallClient,
+                pCallParamsSP,
+                &pAsyncRequestInfo->dwParam5
+
+                ) != 0)
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LPrepareAddToConference_freeCallParams;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LMakeCall_PostProcess;
+        pAsyncRequestInfo->dwParam1 = (DWORD) ptConsultCall;
+        pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphConsultCall;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP5(
+            pfnTSPI_linePrepareAddToConference,
+            "linePrepareAddToConference",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdConfCall,
+            (DWORD) ptConsultCall,
+            (DWORD) &ptConsultCall->hdCall,
+            (DWORD) pCallParamsSP
+            );
+
+        SetDrvCallFlags(
+            ptConsultCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+
+LPrepareAddToConference_freeCallParams:
+
+        if (pCallParamsSP != pCallParamsApp)
+        {
+            ServerFree (pCallParamsSP);
+        }
+    }
+
+LPrepareAddToConference_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "PrepareAddToConference"
+        );
+}
+
+
+void
+WINAPI
+LProxyMessage(
+    PLINEPROXYMESSAGE_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_NONE,                    // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "ProxyMessage"              // func name
+
+            )) == 0)
+    {
+        DWORD           dwMsg = pParams->dwMsg, i;
+        PTCALL          ptCall;
+        PTLINE          ptLine;
+        TPOINTERLIST    clientList, *pClientList = &clientList;
+        ASYNCEVENTMSG   msg;
+
+
+        //
+        // Verify params
+        //
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+
+            if (!(((PTLINECLIENT) pParams->hLine)->dwPrivileges &
+                    LINEOPENOPTION_PROXY))
+            {
+                pParams->lResult = LINEERR_NOTREGISTERED;
+                goto LProxyMessage_epilog;
+            }
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALLINEHANDLE;
+            goto LProxyMessage_epilog;
+        }
+
+        switch (dwMsg)
+        {
+        case LINE_AGENTSTATUS:
+
+            // ignore the hCall param
+
+            if (pParams->dwParam1 >= ptLine->dwNumAddresses)
+            {
+                DBGOUT((
+                    3,
+                    "ERROR: lineProxyMessage (AGENTSTATUS): dwParam1 " \
+                        "bad addr ID (=x%x, num addrs=x%x)",
+                    pParams->dwParam1,
+                    ptLine->dwNumAddresses
+                    ));
+
+                pParams->lResult = LINEERR_INVALPARAM;
+                goto LProxyMessage_epilog;
+            }
+            else if (pParams->dwParam2 == 0 ||
+                    pParams->dwParam2 & ~AllAgentStatus)
+            {
+                DBGOUT((
+                    3,
+                    "ERROR: lineProxyMessage (AGENTSTATUS): dwParam2 " \
+                        "(=x%x) bad LINEAGENTSTATUS_ flags",
+                    pParams->dwParam2
+                    ));
+
+                pParams->lResult = LINEERR_INVALPARAM;
+                goto LProxyMessage_epilog;
+            }
+            else if (pParams->dwParam2 & LINEAGENTSTATUS_STATE)
+            {
+                if (!IsOnlyOneBitSetInDWORD (pParams->dwParam3) ||
+                    pParams->dwParam3 & ~AllAgentStates)
+                {
+                    DBGOUT((
+                        3,
+                        "ERROR: lineProxyMessage (AGENTSTATUS): " \
+                            "dwParam3 (=x%x) bad LINEAGENTSTATE_ flags",
+                        pParams->dwParam3
+                        ));
+
+                    pParams->lResult = LINEERR_INVALPARAM;
+                    goto LProxyMessage_epilog;
+                }
+            }
+            else if (pParams->dwParam3 != 0)
+            {
+                // don't bother complaining about a non-zero dwParam3
+
+                pParams->dwParam3 = 0;
+            }
+
+            break;
+
+        case LINE_AGENTSPECIFIC:
+
+            // ignore dwParam1, dwParam2, & dwParam3 (app-specific)
+
+            if (pParams->hCall)
+            {
+                if (!IsValidCall (pParams->hCall, pParams->ptClient))
+                {
+                    pParams->lResult = LINEERR_INVALCALLHANDLE;
+                    goto LProxyMessage_epilog;
+                }
+
+                try
+                {
+                    ptCall = ((PTCALLCLIENT) pParams->hCall)->ptCall;
+                }
+                myexcept
+                {
+                    pParams->lResult = LINEERR_INVALCALLHANDLE;
+                    goto LProxyMessage_epilog;
+                }
+
+                goto LProxyMessage_fwdMsgToCallClients;
+            }
+
+            break;
+
+        default:
+
+            DBGOUT((
+                3,
+                "ERROR : lineProxyMessage: inval dwMsg (=x%x)",
+                pParams->dwMsg
+                ));
+
+            pParams->lResult = LINEERR_INVALPARAM;
+            goto LProxyMessage_epilog;
+
+        } // switch (dwMsg)
+
+
+        //
+        // Fwd this msg on to all line's clients who say they support
+        // >= TAPI_VERSION2_0 (not including the proxy's line client)
+        //
+
+        if ((pParams->lResult = GetLineClientListFromLine(
+                ptLine,
+                &pClientList
+
+                )) != 0)
+        {
+            goto LProxyMessage_epilog;
+        }
+
+        msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+        msg.pfnPostProcessProc = 0;
+        msg.dwMsg              = dwMsg;
+        msg.dwParam1           = pParams->dwParam1;
+        msg.dwParam2           = pParams->dwParam2;
+        msg.dwParam3           = pParams->dwParam3;
+
+        for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+        {
+            PTLINECLIENT    ptLineClient = (PTLINECLIENT)
+                                pClientList->aEntries[i];
+
+
+            if (ptLineClient != (PTLINECLIENT) pParams->hLine)
+            {
+                try
+                {
+                    if (((PTLINEAPP) ptLineClient->ptLineApp)->dwAPIVersion
+                            >= TAPI_VERSION2_0)
+                    {
+                        msg.pInitData      = (DWORD)
+                            ((PTLINEAPP) ptLineClient->ptLineApp)->lpfnCallback;
+                        msg.hDevice        = (DWORD) ptLineClient->hRemoteLine;
+                        msg.dwCallbackInst = ptLineClient->dwCallbackInstance;
+
+
+                        //
+                        // Now a final check to make sure all the
+                        // params are valid before sending the msg
+                        //
+
+                        {
+                            PTCLIENT ptClient = ptLineClient->ptClient;
+
+
+                            if (ptLineClient->dwKey == TLINECLIENT_KEY)
+                            {
+                                WriteEventBuffer (ptClient, &msg);
+                            }
+                        }
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+        }
+
+        goto LProxyMessage_freeClientList;
+
+
+        //
+        // Fwd this msg on to all call's clients who say they support
+        // >= TAPI_VERSION2_0 (not including the proxy's line client)
+        //
+
+LProxyMessage_fwdMsgToCallClients:
+
+        if ((pParams->lResult = GetCallClientListFromCall(
+                ptCall,
+                &pClientList
+
+                )) != 0)
+        {
+            goto LProxyMessage_epilog;
+        }
+
+        msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+        msg.pfnPostProcessProc = 0;
+        msg.dwMsg              = dwMsg;
+        msg.dwParam1           = pParams->dwParam1;
+        msg.dwParam2           = pParams->dwParam2;
+        msg.dwParam3           = pParams->dwParam3;
+
+        for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+        {
+            PTCALLCLIENT    ptCallClient = (PTCALLCLIENT)
+                                pClientList->aEntries[i];
+
+
+            if (ptCallClient != (PTCALLCLIENT) pParams->hCall)
+            {
+                try
+                {
+                    PTLINEAPP   ptLineApp;
+
+
+                    ptLineApp = (PTLINEAPP)
+                        ((PTLINECLIENT) ptCallClient->ptLineClient)->ptLineApp;
+
+                    if (ptLineApp->dwAPIVersion >= TAPI_VERSION2_0)
+                    {
+                        msg.pInitData      = (DWORD) ptLineApp->lpfnCallback;
+                        msg.hDevice        = (DWORD) ptCallClient->hRemoteCall;
+                        msg.dwCallbackInst =
+                            ((PTLINECLIENT) ptCallClient->ptLineClient)
+                                ->dwCallbackInstance;
+
+
+                        //
+                        // Now a final check to make sure all the
+                        // params are valid before sending the msg
+                        //
+
+                        {
+                            PTCLIENT ptClient = ptCallClient->ptClient;
+
+
+                            if (ptCallClient->dwKey == TCALLCLIENT_KEY)
+                            {
+                                WriteEventBuffer (ptClient, &msg);
+                            }
+                        }
+                    }
+                }
+                myexcept
+                {
+                    // just continue
+                }
+            }
+        }
+
+LProxyMessage_freeClientList:
+
+        if (pClientList != &clientList)
+        {
+            ServerFree (pClientList);
+        }
+
+
+    }
+
+LProxyMessage_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "ProxyMessage"
+        );
+}
+
+
+void
+WINAPI
+LProxyResponse(
+    PLINEPROXYRESPONSE_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_NONE,                    // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "ProxyResponse"             // func name
+
+            )) == 0)
+    {
+        BOOL                bDupedMutex;
+        HANDLE              hMutex;
+        PTLINECLIENT        pProxy = (PTLINECLIENT) pParams->hLine;
+        PASYNCREQUESTINFO   pAsyncRequestInfo = (PASYNCREQUESTINFO)
+                                pParams->dwInstance;
+
+
+        //
+        // Safely remove the proxy request from the list of pending requests
+        // (make sure it's a valid request on the specified line)
+        //
+
+        try
+        {
+            hMutex = pProxy->hMutex;
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALLINEHANDLE;
+            goto LProxyResponse_Epilog;
+        }
+
+
+        if (WaitForMutex(
+                hMutex,
+                &hMutex,
+                &bDupedMutex,
+                pProxy,
+                TLINECLIENT_KEY,
+                INFINITE
+                ))
+        {
+            try
+            {
+                if (pAsyncRequestInfo->dwKey != (DWORD) pProxy)
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+                    pParams->dwResult = LINEERR_OPERATIONFAILED;
+                    goto LProxyResponse_Epilog;
+                }
+            }
+            myexcept
+            {
+                MyReleaseMutex (hMutex, bDupedMutex);
+                pParams->dwResult = LINEERR_OPERATIONFAILED;
+                goto LProxyResponse_Epilog;
+            }
+
+            pAsyncRequestInfo->dwKey = TASYNC_KEY;
+
+            if (pAsyncRequestInfo->dwParam5)
+            {
+                ((PASYNCREQUESTINFO) pAsyncRequestInfo->dwParam5)->dwParam4 =
+                    pAsyncRequestInfo->dwParam4;
+            }
+
+            if (pAsyncRequestInfo->dwParam4)
+            {
+                ((PASYNCREQUESTINFO) pAsyncRequestInfo->dwParam4)->dwParam5 =
+                    pAsyncRequestInfo->dwParam5;
+            }
+            else
+            {
+                pProxy->pPendingProxyRequests = (PASYNCREQUESTINFO)
+                    pAsyncRequestInfo->dwParam5;
+            }
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+        }
+        else
+        {
+            pParams->dwResult = LINEERR_INVALLINEHANDLE;
+            goto LProxyResponse_Epilog;
+        }
+
+
+        //
+        // If this is a proxy request where there's data to be returned
+        // to the client (aside from the result) then we want to alloc
+        // a buffer & fill it with the data.  We'll make it look like a
+        // DevSpecific request that just completed, and have the DevSpecfic
+        // post process routine deal with it.
+        //
+        // Make sure buffers are 64-bit aligned
+        //
+
+        if (pParams->dwProxyResponseOffset != TAPI_NO_DATA &&
+            pParams->dwResult == 0)
+        {
+            DWORD               dwSize;
+            LPBYTE              pBuf;
+            LPLINEPROXYREQUEST  pProxyRequest = (LPLINEPROXYREQUEST)
+                                    pDataBuf + pParams->dwProxyResponseOffset;
+
+
+            if (pProxyRequest->dwRequestType == LINEPROXYREQUEST_AGENTSPECIFIC)
+            {
+                dwSize = pProxyRequest->AgentSpecific.dwSize;
+
+                if (!(pBuf = ServerAlloc(
+                        sizeof (ASYNCEVENTMSG) + ((dwSize + 7) & 0xfffffff8)
+                        )))
+                {
+                    pParams->dwResult = LINEERR_NOMEM;
+                    goto LProxyResponse_completeRequest;
+                }
+
+                CopyMemory(
+                    pBuf + sizeof (ASYNCEVENTMSG),
+                    pProxyRequest->AgentSpecific.Params,
+                    dwSize
+                    );
+            }
+            else
+            {
+                dwSize = pProxyRequest->GetAgentCaps.AgentCaps.dwUsedSize;
+
+                if (!(pBuf = ServerAlloc(
+                        sizeof (ASYNCEVENTMSG) + ((dwSize + 7) & 0xfffffff8)
+                        )))
+                {
+                    pParams->dwResult = LINEERR_NOMEM;
+                    goto LProxyResponse_completeRequest;
+                }
+
+                CopyMemory(
+                    pBuf + sizeof (ASYNCEVENTMSG),
+                    &pProxyRequest->GetAgentCaps.AgentCaps,
+                    dwSize
+                    );
+            }
+
+            pAsyncRequestInfo->pfnPostProcess = LDevSpecific_PostProcess;
+            pAsyncRequestInfo->dwParam2       = dwSize;
+            pAsyncRequestInfo->dwParam3       = (DWORD) pBuf;
+        }
+
+
+        //
+        // Now call the deferred completion proc with the "request id"
+        // & result, just like a provider would
+        //
+
+LProxyResponse_completeRequest:
+
+        CompletionProcSP ((DWORD) pAsyncRequestInfo, pParams->dwResult);
+    }
+
+LProxyResponse_Epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "ProxyResponse"
+        );
+}
+
+
+void
+WINAPI
+LRedirect(
+    PLINEREDIRECT_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineRedirect;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEREDIRECT,            // provider func index
+            &pfnTSPI_lineRedirect,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Redirect"                  // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineRedirect,
+            "lineRedirect",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) pDataBuf + pParams->dwDestAddressOffset,
+            (DWORD) pParams->dwCountryCode
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Redirect"
+        );
+}
+
+
+void
+WINAPI
+LRegisterRequestRecipient(
+    PLINEREGISTERREQUESTRECIPIENT_PARAMS    pParams,
+    LPBYTE                                  pDataBuf,
+    LPDWORD                                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    PTLINEAPP   ptLineApp;
+
+
+    if ((ptLineApp = WaitForExclusiveLineAppAccess(
+            pParams->hLineApp,
+            pParams->ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            )))
+    {
+        DWORD   dwRequestMode = pParams->dwRequestMode;
+
+
+        if (!(dwRequestMode &
+                (LINEREQUESTMODE_MAKECALL | LINEREQUESTMODE_MEDIACALL)) ||
+            (dwRequestMode &
+                (~(LINEREQUESTMODE_MAKECALL | LINEREQUESTMODE_MEDIACALL))))
+        {
+            pParams->lResult = LINEERR_INVALREQUESTMODE;
+            goto LRegisterRequestRecipient_myReleaseMutex;
+        }
+
+        if (pParams->bEnable)
+        {
+            //
+            // If app wants MEDIACALL requests see if already registered
+            //
+
+            if ((dwRequestMode & LINEREQUESTMODE_MEDIACALL) &&
+                ptLineApp->bReqMediaCallRecipient)
+            {
+                pParams->lResult = LINEERR_OPERATIONFAILED;
+                goto LRegisterRequestRecipient_myReleaseMutex;
+            }
+
+
+            //
+            // If app wants MAKECALL requests see if already registered,
+            // then prepare a request recipient object & add it to the
+            // global list
+            //
+
+            if (dwRequestMode & LINEREQUESTMODE_MAKECALL)
+            {
+                if (!ptLineApp->pRequestRecipient)
+                {
+                    //
+                    // Add to request recipient list
+                    //
+
+                    PTREQUESTRECIPIENT  pRequestRecipient;
+
+
+                    if (!(pRequestRecipient= (PTREQUESTRECIPIENT) ServerAlloc(
+                            sizeof (TREQUESTRECIPIENT)
+                            )))
+                    {
+                        pParams->lResult = LINEERR_OPERATIONFAILED;
+                        goto LRegisterRequestRecipient_myReleaseMutex;
+                    }
+
+                    pRequestRecipient->ptLineApp = ptLineApp;
+                    pRequestRecipient->dwRegistrationInstance =
+                        pParams->dwRegistrationInstance;
+
+                    EnterCriticalSection (&gPriorityListCritSec);
+
+                    if ((pRequestRecipient->pNext =
+                            TapiGlobals.pRequestRecipients))
+                    {
+                        pRequestRecipient->pNext->pPrev = pRequestRecipient;
+                    }
+
+                    TapiGlobals.pRequestRecipients = pRequestRecipient;
+
+                    LeaveCriticalSection (&gPriorityListCritSec);
+
+                    ptLineApp->pRequestRecipient = pRequestRecipient;
+
+                    TapiGlobals.pHighestPriorityRequestRecipient =
+                         GetHighestPriorityRequestRecipient();
+
+                    if (TapiGlobals.pRequestMakeCallList)
+                    {
+                        NotifyHighestPriorityRequestRecipient();
+                    }
+                }
+                else // already registered
+                {
+                    pParams->lResult = LINEERR_OPERATIONFAILED;
+                    goto LRegisterRequestRecipient_myReleaseMutex;
+                }
+            }
+
+
+            //
+            // Now register app for MEDIACALL reqs as appropriate
+            //
+
+            ptLineApp->bReqMediaCallRecipient =
+                (dwRequestMode & LINEREQUESTMODE_MEDIACALL ?
+                1 : ptLineApp->bReqMediaCallRecipient);
+        }
+        else
+        {
+            //
+            // If apps doesn't want MEDIACALL requests see if not registered
+            //
+
+            if ((dwRequestMode & LINEREQUESTMODE_MEDIACALL) &&
+                !ptLineApp->bReqMediaCallRecipient)
+            {
+                pParams->lResult = LINEERR_OPERATIONFAILED;
+                goto LRegisterRequestRecipient_myReleaseMutex;
+            }
+
+
+            //
+            // If app doesn't want MAKECALL requests see if already
+            // registered, then remove it's request recipient object
+            // from the global list
+            //
+
+            if (dwRequestMode & LINEREQUESTMODE_MAKECALL)
+            {
+                if (ptLineApp->pRequestRecipient)
+                {
+                    //
+                    // Remove from request recipient list
+                    //
+
+                    PTREQUESTRECIPIENT  pRequestRecipient =
+                                            ptLineApp->pRequestRecipient;
+
+
+                    EnterCriticalSection (&gPriorityListCritSec);
+
+                    if (pRequestRecipient->pNext)
+                    {
+                        pRequestRecipient->pNext->pPrev = pRequestRecipient->pPrev;
+                    }
+
+                    if (pRequestRecipient->pPrev)
+                    {
+                        pRequestRecipient->pPrev->pNext = pRequestRecipient->pNext;
+                    }
+                    else
+                    {
+                        TapiGlobals.pRequestRecipients = pRequestRecipient->pNext;
+                    }
+
+                    LeaveCriticalSection (&gPriorityListCritSec);
+
+                    ServerFree (pRequestRecipient);
+
+                    ptLineApp->pRequestRecipient = NULL;
+
+
+                    //
+                    // Reset the highest priority request recipient, then check to
+                    // see if there's any pending request make calls
+                    //
+
+                    TapiGlobals.pHighestPriorityRequestRecipient =
+                        GetHighestPriorityRequestRecipient();
+
+                    if (TapiGlobals.pRequestMakeCallList)
+                    {
+                        if (TapiGlobals.pHighestPriorityRequestRecipient)
+                        {
+                            NotifyHighestPriorityRequestRecipient();
+                        }
+
+// BUGBUG LRegisterRequestRecip: else if (!StartRequestRecipient())
+                        else
+                        {
+                            //
+                            // We couldn't start a request recipient so
+                            // nuke all pending request make calls
+                            //
+
+                            PTREQUESTMAKECALL   pRequestMakeCall, pNextRequestMakeCall;
+
+
+                            pRequestMakeCall = TapiGlobals.pRequestMakeCallList;
+
+                            TapiGlobals.pRequestMakeCallList    =
+                            TapiGlobals.pRequestMakeCallListEnd = NULL;
+
+                            while (pRequestMakeCall)
+                            {
+                                pNextRequestMakeCall =  pRequestMakeCall->pNext;
+                                ServerFree (pRequestMakeCall);
+                                pRequestMakeCall =  pNextRequestMakeCall;
+                            }
+
+                            DBGOUT((
+                                2,
+                                "LRegisterRequestRecipient: deleting pending " \
+                                    "MakeCall requests"
+                                ));
+                        }
+                    }
+                }
+                else // not registered
+                {
+                    pParams->lResult = LINEERR_OPERATIONFAILED;
+                }
+            }
+
+
+            //
+            // Now deregister app for MEDIACALL reqs as appropriate
+            //
+
+            ptLineApp->bReqMediaCallRecipient =
+                (dwRequestMode & LINEREQUESTMODE_MEDIACALL ?
+                0 : ptLineApp->bReqMediaCallRecipient);
+        }
+
+LRegisterRequestRecipient_myReleaseMutex:
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+    }
+    else
+    {
+        pParams->lResult = (TapiGlobals.dwNumLineInits == 0 ?
+            LINEERR_UNINITIALIZED : LINEERR_INVALAPPHANDLE);
+    }
+
+LRegisterRequestRecipient_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineRegisterRequestRecipient: exit, returning %s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+LReleaseUserUserInfo(
+    PLINEDIAL_PARAMS    pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineReleaseUserUserInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINERELEASEUSERUSERINFO, // provider func index
+            &pfnTSPI_lineReleaseUserUserInfo,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "ReleaseUserUserInfo"       // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineReleaseUserUserInfo,
+            "lineReleaseUserUserInfo",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "ReleaseUserUserInfo"
+        );
+}
+
+
+void
+LRemoveFromConference_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    if (pAsyncEventMsg->dwParam2 == 0)
+    {
+        PTCALL ptCall = (PTCALL) pAsyncRequestInfo->dwParam1;
+
+
+        SetCallConfList (ptCall, (PTCONFERENCELIST) NULL, FALSE);
+    }
+}
+
+
+void
+WINAPI
+LRemoveFromConference(
+    PLINEREMOVEFROMCONFERENCE_PARAMS    pParams,
+    LPBYTE                              pDataBuf,
+    LPDWORD                             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineRemoveFromConference;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEREMOVEFROMCONFERENCE,// provider func index
+            &pfnTSPI_lineRemoveFromConference,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "RemoveFromConference"      // func name
+
+            )) > 0)
+    {
+        PTCALL ptCall;
+
+
+        //
+        // Safely make sure the call is currently conferenced &
+        // that it's not a conf parent
+        //
+
+        try
+        {
+            PTCONFERENCELIST pConfList;
+
+
+            ptCall = ((PTCALLCLIENT) pParams->hCall)->ptCall;
+
+            pConfList = ptCall->pConfList;
+
+            if (!pConfList ||
+                (pConfList == (LPVOID) 0xffffffff) ||
+                (pConfList->aptCalls[0] == ptCall))
+            {
+                lRequestID = LINEERR_INVALCALLSTATE;
+                goto LRemoveFromConference_return;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LRemoveFromConference_return;
+        }
+
+        //
+        // Set up the async request struct & call the SP
+        //
+
+        pAsyncRequestInfo->pfnPostProcess = LRemoveFromConference_PostProcess;
+        pAsyncRequestInfo->dwParam1       = (DWORD) ptCall;
+
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineRemoveFromConference,
+            "lineRemoveFromConference",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall
+            );
+    }
+
+LRemoveFromConference_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "RemoveFromConference"
+        );
+}
+
+
+void
+WINAPI
+LSecureCall(
+    PLINESECURECALL_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSecureCall;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESECURECALL,          // provider func index
+            &pfnTSPI_lineSecureCall,    // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SecureCall"                // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineSecureCall,
+            "lineSecureCall",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SecureCall"
+        );
+}
+
+
+void
+WINAPI
+LSendUserUserInfo(
+    PLINESENDUSERUSERINFO_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSendUserUserInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESENDUSERUSERINFO,    // provider func index
+            &pfnTSPI_lineSendUserUserInfo,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SendUserUserInfo"          // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineSendUserUserInfo,
+            "lineSendUserUserInfo",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwUserUserInfoOffset),
+            (DWORD) (pParams->dwUserUserInfoOffset == TAPI_NO_DATA ? 0 :
+                pParams->dwSize)
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SendUserUserInfo"
+        );
+}
+
+
+void
+WINAPI
+LSetAppPriority(
+    PLINESETAPPPRIORITY_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    DWORD   dwMediaMode   = pParams->dwMediaMode,
+            dwRequestMode = pParams->dwRequestMode,
+            dwPriority    = pParams->dwPriority;
+
+
+// BUGBUG LSetAppPriority: ext mm's
+
+
+    if (dwMediaMode == 0)
+    {
+        if ((dwRequestMode != LINEREQUESTMODE_MAKECALL) &&
+            (dwRequestMode != LINEREQUESTMODE_MEDIACALL))
+        {
+            pParams->lResult = LINEERR_INVALREQUESTMODE;
+            goto LSetAppPriority_return;
+        }
+    }
+    else if (IsOnlyOneBitSetInDWORD (dwMediaMode))
+    {
+        if ((dwMediaMode & 0xff000000))
+        {
+        }
+        else if (dwMediaMode & ~AllMediaModes1_4)
+        {
+            pParams->lResult = LINEERR_INVALMEDIAMODE;
+            goto LSetAppPriority_return;
+        }
+    }
+    else
+    {
+        pParams->lResult = LINEERR_INVALMEDIAMODE;
+        goto LSetAppPriority_return;
+    }
+
+    if ((dwPriority & 0xfffffffe))
+    {
+        pParams->lResult = LINEERR_INVALPARAM;
+        goto LSetAppPriority_return;
+    }
+
+
+    if ((dwMediaMode & 0x00ffffff) || (dwMediaMode == 0))
+    {
+        WCHAR   szModuleName[MAX_PATH];
+        WCHAR  *pszCurrentPriorityList, **ppszCurrentPriorityList;
+        WCHAR  *pszLocationInPriorityList;
+        DWORD   dwAppNameLength;
+
+
+        szModuleName[0] = '"';
+        lstrcpyW(szModuleName + 1, (PWSTR)(pDataBuf + pParams->dwAppNameOffset));
+        CharUpperW(szModuleName + 1);
+        dwAppNameLength = (DWORD) lstrlenW(szModuleName);
+
+
+        //
+        // Enter the pri list critical section before we start munging
+        //
+
+        EnterCriticalSection (&gPriorityListCritSec);
+
+
+        //
+        // Determine which of the priority lists we want to look at
+        //
+
+        if  (dwMediaMode & 0x00ffffff)
+        {
+            DWORD   dwMaskBit, dwPriorityListIndex;
+
+
+            for(
+                dwPriorityListIndex = 0, dwMaskBit = 1;
+                dwMaskBit != dwMediaMode;
+                dwPriorityListIndex++, dwMaskBit <<= 1
+                );
+
+            ppszCurrentPriorityList =
+                TapiGlobals.apszPriorityList + dwPriorityListIndex;
+
+            pszCurrentPriorityList = *ppszCurrentPriorityList;
+        }
+        else
+        {
+            ppszCurrentPriorityList = (dwRequestMode==LINEREQUESTMODE_MAKECALL
+                ? &TapiGlobals.pszReqMakeCallPriList :
+                &TapiGlobals.pszReqMediaCallPriList);
+
+            pszCurrentPriorityList = *ppszCurrentPriorityList;
+        }
+
+
+        DBGOUT((
+            3,
+            "LSetAppPri: priList=%ls",
+            (pszCurrentPriorityList ? pszCurrentPriorityList : L"<empty>")
+            ));
+
+
+        //
+        // Add app to priority list
+        //
+
+        if (pParams->dwPriority)
+        {
+            if (pszCurrentPriorityList &&
+
+                (pszLocationInPriorityList = wcsstr(
+                    pszCurrentPriorityList,
+                    szModuleName
+                    )))
+            {
+                //
+                // App already in list. If app not currently at front of
+                // list then move it to front.
+                //
+
+                if (pszLocationInPriorityList != pszCurrentPriorityList)
+                {
+                    MoveMemory(
+                        pszCurrentPriorityList + dwAppNameLength,
+                        pszCurrentPriorityList,
+                        (pszLocationInPriorityList - pszCurrentPriorityList) * sizeof(WCHAR)
+                        );
+
+                    lstrcpyW(pszCurrentPriorityList, szModuleName);
+
+                    pszCurrentPriorityList[dwAppNameLength] = '"';
+                }
+            }
+            else
+            {
+                //
+                // App not in list, so create a new list
+                //
+
+                WCHAR *pszNewPriorityList;
+
+
+                if (!(pszNewPriorityList = ServerAlloc(
+                      sizeof(WCHAR) *
+                         (dwAppNameLength + (pszCurrentPriorityList ?
+                            lstrlenW(pszCurrentPriorityList) : 0) +
+                            1)   // for terminating NULL
+                        )))
+                {
+                    pParams->lResult = LINEERR_NOMEM;
+                }
+                else
+                {
+                    lstrcpyW(pszNewPriorityList, szModuleName);
+
+                    if (pszCurrentPriorityList)
+                    {
+                        lstrcatW(pszNewPriorityList, pszCurrentPriorityList);
+                        ServerFree (pszCurrentPriorityList);
+                    }
+
+                    *ppszCurrentPriorityList = pszNewPriorityList;
+                }
+            }
+        }
+
+
+        //
+        // Remove app from priority list for specified media mode
+        //
+        // Note: We currently do not alloc a smaller buffer to store
+        //       the new list in, we just use the existing one.
+        //
+
+        else
+        {
+            if (pszCurrentPriorityList &&
+
+                (pszLocationInPriorityList = wcsstr(
+                    pszCurrentPriorityList,
+                    szModuleName
+                    )))
+            {
+                if (*(pszLocationInPriorityList + dwAppNameLength) != 0)
+                {
+                    //
+                    // This is not the last app in the list, so move
+                    // following apps up one notch in the list
+                    //
+
+                    lstrcpyW(
+                        pszLocationInPriorityList,
+                        pszLocationInPriorityList + dwAppNameLength
+                        );
+                }
+                else if (pszLocationInPriorityList == pszCurrentPriorityList)
+                {
+                    //
+                    // This is the only app in the list, so free the buffer
+                    // & set the global pointer to NULL
+                    //
+
+                    ServerFree (pszCurrentPriorityList);
+                    *ppszCurrentPriorityList = NULL;
+                }
+                else
+                {
+                    //
+                    // This is the last app in the list, so just mark this as
+                    // the end of the list
+                    //
+
+                    *pszLocationInPriorityList = 0;
+                }
+            }
+        }
+
+
+        //
+        // We're done munging, so leave the pri list crit sec
+        //
+
+        LeaveCriticalSection (&gPriorityListCritSec);
+    }
+
+LSetAppPriority_return:
+
+
+    DBGOUT((
+        3,
+        "LineEpilogSync (lineSetAppPriority) exit, returning x%x",
+        pParams->lResult
+        ));
+}
+
+
+void
+WINAPI
+LSetAgentActivity(
+    PLINESETAGENTACTIVITY_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetAgentActivity"          // func name
+
+            )) > 0)
+    {
+        PTLINE          ptLine;
+        PTLINECLIENT    pProxy;
+
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+            pProxy = ptLine->apProxys[LINEPROXYREQUEST_SETAGENTACTIVITY];
+
+            if (pParams->dwAddressID >= ptLine->dwNumAddresses)
+            {
+                lRequestID = LINEERR_INVALADDRESSID;
+                goto LSetAgentActivity_epilog;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+            goto LSetAgentActivity_epilog;
+        }
+
+
+        //
+        // First check to see if there's a (local) proxy registered
+        // for this type of request on this line.  If so, build a
+        // request & send it to the proxy.
+        //
+
+        if (pProxy)
+        {
+            LONG                    lResult;
+            PPROXYREQUESTWRAPPER    pProxyRequestWrapper;
+
+
+            if ((lResult = CreateProxyRequest(
+                    pProxy,
+                    LINEPROXYREQUEST_SETAGENTACTIVITY,
+                    2 * sizeof (DWORD),
+                    pAsyncRequestInfo,
+                    &pProxyRequestWrapper
+                    )))
+            {
+                lRequestID = lResult;
+                goto LSetAgentActivity_epilog;
+            }
+
+            pProxyRequestWrapper->ProxyRequest.SetAgentActivity.dwAddressID  =
+                pParams->dwAddressID;
+            pProxyRequestWrapper->ProxyRequest.SetAgentActivity.dwActivityID =
+                pParams->dwActivityID;
+
+
+            //
+            // Change the async request info key so we can verify stuff
+            // when lineProxyRequest is called
+            //
+
+            pAsyncRequestInfo->dwKey = (DWORD) pProxy;
+
+            if ((lResult = SendProxyRequest(
+                    pProxy,
+                    pProxyRequestWrapper,
+                    pAsyncRequestInfo
+                    )))
+            {
+                lRequestID = lResult;
+                goto LSetAgentActivity_epilog;
+            }
+            else // success
+            {
+                pParams->lResult = (LONG) pAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // There's no proxy, so check to see if line is remote and
+        // call remotesp if so
+        //
+
+        else if ((GetLineLookupEntry (ptLine->dwDeviceID))->bRemote)
+        {
+            pParams->lResult = CallSP4(
+                pRemoteSP->apfn[SP_LINESETAGENTACTIVITY],
+                "lineSetAgentActivity",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdLine,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) pParams->dwActivityID
+                );
+        }
+
+
+        //
+        // There's no registered proxy & line is not remote, so fail
+        //
+
+        else
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+
+LSetAgentActivity_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetAgentActivity"
+        );
+}
+
+
+void
+WINAPI
+LSetAgentGroup(
+    PLINESETAGENTGROUP_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetAgentGroup"             // func name
+
+            )) > 0)
+    {
+        PTLINE                  ptLine;
+        PTLINECLIENT            pProxy;
+        LPLINEAGENTGROUPLIST    pGroupList = (LPLINEAGENTGROUPLIST)
+                                    pDataBuf + pParams->dwAgentGroupListOffset;
+
+
+        //
+        // Param verification...
+        //
+
+        {
+            DWORD                   dwTotalSize = pGroupList->dwTotalSize, i;
+            LPLINEAGENTGROUPENTRY   pGroupEntry;
+
+
+            if (dwTotalSize < sizeof (LINEAGENTGROUPLIST))
+            {
+                lRequestID = LINEERR_STRUCTURETOOSMALL;
+                goto LSetAgentGroup_epilog;
+            }
+
+            if (ISBADSIZEOFFSET(
+                    dwTotalSize,
+                    sizeof (LINEAGENTGROUPLIST),
+                    pGroupList->dwListSize,
+                    pGroupList->dwListOffset,
+                    "lineSetAgentGroup",
+                    "List"
+                    ))
+            {
+                lRequestID = LINEERR_INVALAGENTGROUP;
+                goto LSetAgentGroup_epilog;
+            }
+
+            if (pGroupList->dwNumEntries >
+                    ((dwTotalSize - sizeof (LINEAGENTGROUPLIST)) /
+                        sizeof (LINEAGENTGROUPENTRY)))
+            {
+                lRequestID = LINEERR_INVALAGENTGROUP;
+                goto LSetAgentGroup_epilog;
+            }
+
+//            pGroupEntry = (LPLINEAGENTGROUPENTRY)
+//                ((LPBYTE) pGroupList) + pGroupList->dwListOffset;
+//
+//            for (i = 0; i < pGroupList->dwNumEntries; i++)
+//            {
+//                if (ISBADSIZEOFFSET(
+//                        dwTotalSize,
+//                        sizeof (LINEAGENTGROUPLIST),
+//                        pGroupEntry->dwNameSize,
+//                        pGroupEntry->dwNameOffset,
+//                        "lineSetAgentGroup",
+//                        "Name"
+//                        ))
+//                {
+//                    lRequestID = LINEERR_INVALAGENTGROUP;
+//                    goto LSetAgentGroup_epilog;
+//                }
+//
+//                pGroupEntry++;
+//            }
+        }
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+            pProxy = ptLine->apProxys[LINEPROXYREQUEST_SETAGENTGROUP];
+
+            if (pParams->dwAddressID >= ptLine->dwNumAddresses)
+            {
+                lRequestID = LINEERR_INVALADDRESSID;
+                goto LSetAgentGroup_epilog;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+            goto LSetAgentGroup_epilog;
+        }
+
+
+        //
+        // First check to see if there's a (local) proxy registered
+        // for this type of request on this line.  If so, build a
+        // request & send it to the proxy.
+        //
+
+        if (pProxy)
+        {
+            LONG                    lResult;
+            PPROXYREQUESTWRAPPER    pProxyRequestWrapper;
+
+
+            if ((lResult = CreateProxyRequest(
+                    pProxy,
+                    LINEPROXYREQUEST_SETAGENTGROUP,
+                    sizeof (DWORD) + pGroupList->dwTotalSize,
+                    pAsyncRequestInfo,
+                    &pProxyRequestWrapper
+                    )))
+            {
+                lRequestID = lResult;
+                goto LSetAgentGroup_epilog;
+            }
+
+            pProxyRequestWrapper->ProxyRequest.SetAgentGroup.dwAddressID  =
+                pParams->dwAddressID;
+
+            CopyMemory(
+                &pProxyRequestWrapper->ProxyRequest.SetAgentGroup.GroupList,
+                pGroupList,
+                pGroupList->dwTotalSize
+                );
+
+
+            //
+            // Change the async request info key so we can verify stuff
+            // when lineProxyRequest is called
+            //
+
+            pAsyncRequestInfo->dwKey = (DWORD) pProxy;
+
+            if ((lResult = SendProxyRequest(
+                    pProxy,
+                    pProxyRequestWrapper,
+                    pAsyncRequestInfo
+                    )))
+            {
+                lRequestID = lResult;
+                goto LSetAgentGroup_epilog;
+            }
+            else // success
+            {
+                pParams->lResult = (LONG) pAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // There's no proxy, so check to see if line is remote and
+        // call remotesp if so
+        //
+
+        else if ((GetLineLookupEntry (ptLine->dwDeviceID))->bRemote)
+        {
+            pParams->lResult = CallSP4(
+                pRemoteSP->apfn[SP_LINESETAGENTGROUP],
+                "lineSetAgentGroup",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdLine,
+                (DWORD) pParams->dwAddressID,
+                (DWORD) pGroupList
+                );
+        }
+
+
+        //
+        // There's no registered proxy & line is not remote, so fail
+        //
+
+        else
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+
+LSetAgentGroup_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetAgentGroup"
+        );
+}
+
+
+void
+WINAPI
+LSetAgentState(
+    PLINESETAGENTSTATE_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetAgentState"             // func name
+
+            )) > 0)
+    {
+        DWORD           dwAddressID      = pParams->dwAddressID,
+                        dwAgentState     = pParams->dwAgentState,
+                        dwNextAgentState = pParams->dwNextAgentState;
+        PTLINE          ptLine;
+        PTLINECLIENT    pProxy;
+
+
+        //
+        // Param verification...
+        //
+
+        if (dwAgentState == 0  &&  dwNextAgentState == 0)
+        {
+            lRequestID = LINEERR_INVALAGENTSTATE;
+            goto LSetAgentState_epilog;
+        }
+
+        if (dwAgentState != 0 &&
+            (!IsOnlyOneBitSetInDWORD (dwAgentState) ||
+            dwAgentState & ~AllAgentStates))
+        {
+            lRequestID = LINEERR_INVALAGENTSTATE;
+            goto LSetAgentState_epilog;
+        }
+
+        if (dwNextAgentState != 0 &&
+            (!IsOnlyOneBitSetInDWORD (dwNextAgentState) ||
+            dwNextAgentState & ~AllAgentStates))
+        {
+            lRequestID = LINEERR_INVALAGENTSTATE;
+            goto LSetAgentState_epilog;
+        }
+
+        try
+        {
+            ptLine = ((PTLINECLIENT) pParams->hLine)->ptLine;
+            pProxy = ptLine->apProxys[LINEPROXYREQUEST_SETAGENTSTATE];
+
+            if (dwAddressID >= ptLine->dwNumAddresses)
+            {
+                lRequestID = LINEERR_INVALADDRESSID;
+                goto LSetAgentState_epilog;
+            }
+        }
+        myexcept
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+            goto LSetAgentState_epilog;
+        }
+
+
+        //
+        // First check to see if there's a (local) proxy registered
+        // for this type of request on this line.  If so, build a
+        // request & send it to the proxy.
+        //
+
+        if (pProxy)
+        {
+            LONG                    lResult;
+            PPROXYREQUESTWRAPPER    pProxyRequestWrapper;
+
+
+            if ((lResult = CreateProxyRequest(
+                    pProxy,
+                    LINEPROXYREQUEST_SETAGENTSTATE,
+                    3 * sizeof (DWORD),
+                    pAsyncRequestInfo,
+                    &pProxyRequestWrapper
+                    )))
+            {
+                lRequestID = lResult;
+                goto LSetAgentState_epilog;
+            }
+
+            pProxyRequestWrapper->ProxyRequest.SetAgentState.dwAddressID =
+                dwAddressID;
+            pProxyRequestWrapper->ProxyRequest.SetAgentState.dwAgentState =
+                dwAgentState;
+            pProxyRequestWrapper->ProxyRequest.SetAgentState.dwNextAgentState =
+                dwNextAgentState;
+
+
+            //
+            // Change the async request info key so we can verify stuff
+            // when lineProxyRequest is called
+            //
+
+            pAsyncRequestInfo->dwKey = (DWORD) pProxy;
+
+            if ((lResult = SendProxyRequest(
+                    pProxy,
+                    pProxyRequestWrapper,
+                    pAsyncRequestInfo
+                    )))
+            {
+                lRequestID = lResult;
+                goto LSetAgentState_epilog;
+            }
+            else // success
+            {
+                pParams->lResult = (LONG) pAsyncRequestInfo;
+            }
+        }
+
+
+        //
+        // There's no proxy, so check to see if line is remote and
+        // call remotesp if so
+        //
+
+        else if ((GetLineLookupEntry (ptLine->dwDeviceID))->bRemote)
+        {
+            pParams->lResult = CallSP5(
+                pRemoteSP->apfn[SP_LINESETAGENTSTATE],
+                "lineSetAgentState",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdLine,
+                (DWORD) dwAddressID,
+                (DWORD) dwAgentState,
+                (DWORD) dwNextAgentState
+                );
+        }
+
+
+        //
+        // There's no registered proxy & line is not remote, so fail
+        //
+
+        else
+        {
+            lRequestID = LINEERR_OPERATIONUNAVAIL;
+        }
+    }
+
+LSetAgentState_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetAgentState"
+        );
+}
+
+
+void
+WINAPI
+LSetAppSpecific(
+    PLINESETAPPSPECIFIC_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    TSPIPROC            pfnTSPI_lineSetAppSpecific;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETAPPSPECIFIC,      // provider func index
+            &pfnTSPI_lineSetAppSpecific,// provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetAppSpecific"            // func name
+
+            )) == 0)
+    {
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineSetAppSpecific,
+            "lineSetAppSpecific",
+            SP_FUNC_SYNC,
+            (DWORD) hdCall,
+            (DWORD) pParams->dwAppSpecific
+            );
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetAppSpecific"
+        );
+}
+
+
+void
+WINAPI
+LSetCallData(
+    PLINESETCALLDATA_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSetCallData;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETCALLDATA,         // provider func index
+            &pfnTSPI_lineSetCallData,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetCallData"               // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineSetCallData,
+            "lineSetCallData",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) (pParams->dwCallDataSize ?
+                pDataBuf + pParams->dwCallDataOffset : NULL),
+            (DWORD) pParams->dwCallDataSize
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetCallData"
+        );
+}
+
+
+void
+WINAPI
+LSetCallParams(
+    PLINESETCALLPARAMS_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSetCallParams;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETCALLPARAMS,       // provider func index
+            &pfnTSPI_lineSetCallParams, // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetCallParams"             // func name
+
+            )) > 0)
+    {
+        DWORD   dwAPIVersion, dwAllBearerModes,
+                dwBearerMode = pParams->dwBearerMode;
+
+
+        //
+        // Safely get the API ver associated with this call & make sure
+        // no invalid bearer modes are specified (high 16 bearer mode
+        // bits are extensions)
+        //
+
+        try
+        {
+            dwAPIVersion = ((PTLINECLIENT)((PTCALLCLIENT) pParams->hCall)->
+                ptLineClient)->dwAPIVersion;
+        }
+        myexcept
+        {
+        }
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwAllBearerModes = AllBearerModes1_0;
+            break;
+
+        case TAPI_VERSION1_4:
+
+            dwAllBearerModes = AllBearerModes1_4;
+            break;
+
+        case TAPI_VERSION_CURRENT:
+
+            dwAllBearerModes = AllBearerModes2_0;
+            break;
+        }
+
+        if (!IsOnlyOneBitSetInDWORD(dwBearerMode) ||
+            (dwBearerMode & ~(dwAllBearerModes | 0xffff0000)))
+        {
+            lRequestID = LINEERR_INVALBEARERMODE;
+            goto LSetCallParams_epilog;
+        }
+
+        pParams->lResult = CallSP6(
+            pfnTSPI_lineSetCallParams,
+            "lineSetCallParams",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) pParams->dwBearerMode,
+            (DWORD) pParams->dwMinRate,
+            (DWORD) pParams->dwMaxRate,
+            (DWORD) (pParams->dwDialParamsOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwDialParamsOffset)
+            );
+    }
+
+LSetCallParams_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetCallParams"
+        );
+}
+
+
+void
+WINAPI
+LSetCallPrivilege(
+    PLINESETCALLPRIVILEGE_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_MONITOR,  // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_NONE,                    // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetCallPrivilege"          // func name
+
+            )) == 0)
+    {
+        BOOL            bDupedMutex;
+        HANDLE          hMutex;
+        PTCALL          ptCall;
+        PTCALLCLIENT    ptCallClient = (PTCALLCLIENT) pParams->hCall;
+
+
+
+        if ((pParams->dwPrivilege != LINECALLPRIVILEGE_MONITOR) &&
+            (pParams->dwPrivilege != LINECALLPRIVILEGE_OWNER))
+        {
+            pParams->lResult = LINEERR_INVALCALLPRIVILEGE;
+            goto LSetCallPrivilege_epilog;
+        }
+
+        try
+        {
+            ptCall = ptCallClient->ptCall;
+            hMutex = ptCall->hMutex;
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALCALLHANDLE;
+            goto LSetCallPrivilege_epilog;
+        }
+
+        if (WaitForExclusivetCallAccess(
+                (HTAPICALL) ptCall,
+                TCALL_KEY,
+                &hMutex,
+                &bDupedMutex,
+                INFINITE
+                ))
+        {
+            if (pParams->dwPrivilege != ptCallClient->dwPrivilege)
+            {
+//                if (ptCallClient->dwPrivilege == LINECALLPRIVILEGE_OWNER &&
+//                    ptCall->dwNumOwners == 1 &&
+//                    ptCall->dwCallState != LINECALLSTATE_IDLE)
+//                {
+//                    pParams->lResult = LINEERR_INVALCALLSTATE;
+//                    goto LSetCallPrivilege_releaseMutex;
+//                }
+
+                if (pParams->dwPrivilege == LINECALLPRIVILEGE_OWNER)
+                {
+                    ptCall->dwNumOwners++;
+                    ptCall->dwNumMonitors--;
+                }
+                else
+                {
+                    ptCall->dwNumOwners--;
+                    ptCall->dwNumMonitors++;
+                }
+
+                SendMsgToCallClients(
+                    ptCall,
+                    ptCallClient,
+                    LINE_CALLINFO,
+                    LINECALLINFOSTATE_NUMMONITORS |
+                        (pParams->dwPrivilege == LINECALLPRIVILEGE_OWNER ?
+                            LINECALLINFOSTATE_NUMOWNERINCR :
+                            LINECALLINFOSTATE_NUMOWNERDECR),
+                    0,
+                    0
+                    );
+
+                ptCallClient->dwPrivilege = pParams->dwPrivilege;
+            }
+
+LSetCallPrivilege_releaseMutex:
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+LSetCallPrivilege_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetCallPrivilege"
+        );
+}
+
+
+void
+WINAPI
+LSetCallQualityOfService(
+    PLINESETCALLQUALITYOFSERVICE_PARAMS pParams,
+    LPBYTE                              pDataBuf,
+    LPDWORD                             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSetCallQualityOfService;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETCALLQUALITYOFSERVICE, // provider func index
+            &pfnTSPI_lineSetCallQualityOfService,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetCallQualityOfService"   // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP6(
+            pfnTSPI_lineSetCallQualityOfService,
+            "lineSetCallQualityOfService",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) (pDataBuf + pParams->dwSendingFlowspecOffset),
+            (DWORD) pParams->dwSendingFlowspecSize,
+            (DWORD) (pDataBuf + pParams->dwReceivingFlowspecOffset),
+            (DWORD) pParams->dwReceivingFlowspecSize
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetCallQualityOfService"
+        );
+}
+
+
+void
+WINAPI
+LSetCallTreatment(
+    PLINESETCALLTREATMENT_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSetCallTreatment;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETCALLTREATMENT,    // provider func index
+            &pfnTSPI_lineSetCallTreatment,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetCallTreatment"          // func name
+
+            )) > 0)
+    {
+        if (pParams->dwTreatment == 0  ||
+            (pParams->dwTreatment > LINECALLTREATMENT_MUSIC &&
+            pParams->dwTreatment < 0x100))
+        {
+            lRequestID = LINEERR_INVALPARAM;
+            goto LSetCallTreatment_epilog;
+        }
+
+        pParams->lResult = CallSP3(
+            pfnTSPI_lineSetCallTreatment,
+            "lineSetCallTreatment",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) pParams->dwTreatment
+            );
+    }
+
+LSetCallTreatment_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetCallTreatment"
+        );
+}
+
+
+// This code is in TAPI32.DLL now
+//
+// void
+// WINAPI
+// LSetCurrentLocation(
+//     PLINESETCURRENTLOCATION_PARAMS  pParams,
+//     LPBYTE                          pDataBuf,
+//     LPDWORD                         pdwNumBytesReturned
+//     )
+// {
+//     pParams->lResult = LINEERR_OPERATIONFAILED;
+// }
+
+
+void
+WINAPI
+LSetDefaultMediaDetection(
+    PLINESETDEFAULTMEDIADETECTION_PARAMS    pParams,
+    LPBYTE                                  pDataBuf,
+    LPDWORD                                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    TSPIPROC            pfnTSPI_lineSetDefaultMediaDetection;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETDEFAULTMEDIADETECTION,        // provider func index
+            &pfnTSPI_lineSetDefaultMediaDetection,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetDefaultMediaDetection"  // func name
+
+            )) == 0)
+    {
+        DWORD         dwMediaModes = pParams->dwMediaModes;
+        PTLINE        ptLine;
+        PTLINECLIENT  ptLineClient = (PTLINECLIENT) pParams->hLine;
+
+
+        ptLine = ptLineClient->ptLine;
+
+// BUGBUG LSetDefaultMediaDetection: mutex
+
+        if ((dwMediaModes & ptLine->dwOpenMediaModes) != dwMediaModes)
+        {
+            DWORD dwUnionMediaModes = dwMediaModes |
+                ptLine->dwOpenMediaModes;
+
+
+            if ((pParams->lResult = CallSP2(
+                    pfnTSPI_lineSetDefaultMediaDetection,
+                    "lineSetDefaultMediaDetection",
+                    SP_FUNC_SYNC,
+                    (DWORD) hdLine,
+                    dwUnionMediaModes
+
+                    )) == 0)
+            {
+                ptLine->dwOpenMediaModes = dwUnionMediaModes;
+            }
+
+        }
+
+        if (pParams->lResult == 0)
+        {
+            ptLineClient->dwPrivileges = (dwMediaModes ?
+                LINECALLPRIVILEGE_OWNER : LINECALLPRIVILEGE_NONE);
+
+            ptLineClient->dwMediaModes = dwMediaModes;
+        }
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetDefaultMediaDetection"
+        );
+}
+
+
+void
+WINAPI
+LSetDevConfig(
+    PLINESETDEVCONFIG_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    TSPIPROC            pfnTSPI_lineSetDevConfig;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            0,                          // client widget handle
+            NULL,                       // provider widget handle
+            (DWORD) pParams->dwDeviceID,// req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETDEVCONFIG,        // provider func index
+            &pfnTSPI_lineSetDevConfig,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetDevConfig"              // func name
+
+            )) == 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_lineSetDevConfig,
+            "lineSetDevConfig",
+            SP_FUNC_SYNC,
+            (DWORD) pParams->dwDeviceID,
+            (DWORD) (pParams->dwSize ?
+                pDataBuf + pParams->dwDeviceConfigOffset : NULL),
+            (DWORD) pParams->dwSize,
+            (DWORD) pDataBuf + pParams->dwDeviceClassOffset
+            );
+    }
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetDevConfig"
+        );
+}
+
+
+void
+WINAPI
+LSetLineDevStatus(
+    PLINESETLINEDEVSTATUS_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSetLineDevStatus;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETLINEDEVSTATUS,    // provider func index
+            &pfnTSPI_lineSetLineDevStatus,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetLineDevStatus"          // func name
+
+            )) > 0)
+    {
+        #define AllLineDevStatusFlags         \
+            (LINEDEVSTATUSFLAGS_CONNECTED   | \
+            LINEDEVSTATUSFLAGS_MSGWAIT      | \
+            LINEDEVSTATUSFLAGS_INSERVICE    | \
+            LINEDEVSTATUSFLAGS_LOCKED)
+
+        if (pParams->dwStatusToChange == 0 ||
+            (pParams->dwStatusToChange & ~AllLineDevStatusFlags) != 0)
+        {
+            lRequestID = LINEERR_INVALLINESTATE;
+        }
+        else
+        {
+            pParams->lResult = CallSP4(
+                pfnTSPI_lineSetLineDevStatus,
+                "lineSetLineDevStatus",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdLine,
+                (DWORD) pParams->dwStatusToChange,
+                (DWORD) pParams->fStatus
+                );
+        }
+
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetLineDevStatus"
+        );
+}
+
+
+void
+WINAPI
+LSetMediaControl(
+    PLINESETMEDIACONTROL_PARAMS pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwWidgetType, hWidget, dwPrivilege;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineSetMediaControl;
+
+
+    if (pParams->dwSelect == LINECALLSELECT_CALL)
+    {
+        dwWidgetType = ANY_RT_HCALL;
+        hWidget      = (DWORD) pParams->hCall;
+        dwPrivilege  = LINECALLPRIVILEGE_OWNER;
+    }
+    else
+    {
+        dwWidgetType = ANY_RT_HLINE;
+        hWidget      = (DWORD) pParams->hLine;
+        dwPrivilege  = 0;
+    }
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            dwWidgetType,               // widget type
+            (DWORD) hWidget,            // client widget handle
+            (LPVOID) &hWidget,          // provider widget handle
+            dwPrivilege,                // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETMEDIACONTROL,     // provider func index
+            &pfnTSPI_lineSetMediaControl,   // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetMediaControl"           // func name
+
+            )) == 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwSelect) ||
+            (pParams->dwSelect & ~AllCallSelect))
+        {
+            pParams->lResult = LINEERR_INVALCALLSELECT;
+            goto LSetMediaControl_epilog;
+        }
+
+        pParams->lResult = CallSP12(
+            pfnTSPI_lineSetMediaControl,
+            "lineSetMediaControl",
+            SP_FUNC_SYNC,
+            (DWORD) (pParams->dwSelect == LINECALLSELECT_CALL ? 0 : hWidget),
+            (DWORD) pParams->dwAddressID,
+            (DWORD) (pParams->dwSelect == LINECALLSELECT_CALL ? hWidget : 0),
+            (DWORD) pParams->dwSelect,
+            (DWORD) (pParams->dwDigitListOffset == TAPI_NO_DATA ? NULL :
+               pDataBuf + pParams->dwDigitListOffset),
+            (DWORD) pParams->dwDigitListNumEntries /
+                sizeof(LINEMEDIACONTROLDIGIT),
+            (DWORD) (pParams->dwMediaListOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwMediaListOffset),
+            (DWORD) pParams->dwMediaListNumEntries /
+                sizeof(LINEMEDIACONTROLMEDIA),
+            (DWORD) (pParams->dwToneListOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwToneListOffset),
+            (DWORD) pParams->dwToneListNumEntries /
+                sizeof(LINEMEDIACONTROLTONE),
+            (DWORD) (pParams->dwCallStateListOffset == TAPI_NO_DATA ? NULL :
+                pDataBuf + pParams->dwCallStateListOffset),
+            (DWORD) pParams->dwCallStateListNumEntries /
+                sizeof(LINEMEDIACONTROLCALLSTATE)
+            );
+    }
+
+LSetMediaControl_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetMediaControl"
+        );
+}
+
+
+void
+WINAPI
+LSetMediaMode(
+    PLINESETMEDIAMODE_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    TSPIPROC            pfnTSPI_lineSetMediaMode;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETMEDIAMODE,        // provider func index
+            &pfnTSPI_lineSetMediaMode,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetMediaMode"              // func name
+
+            )) == 0)
+    {
+        DWORD   dwAPIVersion, dwAllMediaModes;
+
+
+        //
+        // Check for 0 media mode, and if > 1 bit set without UNKNOWN bit
+        //
+
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwMediaModes) &&
+            !(pParams->dwMediaModes & LINEMEDIAMODE_UNKNOWN))
+        {
+            pParams->lResult = LINEERR_INVALMEDIAMODE;
+            goto LSetMediaMode_epilog;
+        }
+
+
+        //
+        // Now the harder checks
+        //
+
+        dwAPIVersion = ((PTLINECLIENT) ((PTCALLCLIENT)
+            pParams->hCall)->ptLineClient)->dwAPIVersion;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwAllMediaModes = AllMediaModes1_0;
+            break;
+
+        default: // case TAPI_VERSION1_4:
+                 // case TAPI_VERSION_CURRENT:
+
+            dwAllMediaModes = AllMediaModes1_4;
+            break;
+        }
+
+        if ((pParams->dwMediaModes & (dwAllMediaModes ^ 0x00ffffff)))
+        {
+            pParams->lResult = LINEERR_INVALMEDIAMODE;
+            goto LSetMediaMode_epilog;
+        }
+
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineSetMediaMode,
+            "lineSetMediaMode",
+            SP_FUNC_SYNC,
+            (DWORD) hdCall,
+            (DWORD) pParams->dwMediaModes
+            );
+    }
+
+LSetMediaMode_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetMediaMode"
+        );
+}
+
+
+void
+WINAPI
+LSetNumRings(
+    PLINESETNUMRINGS_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_NONE,                    // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetNumRings"               // func name
+
+            )) == 0)
+    {
+        BOOL            bDupedMutex;
+        HANDLE          hMutex;
+        PTLINECLIENT    ptLineClient = (PTLINECLIENT) pParams->hLine;
+
+
+        try
+        {
+            hMutex = ptLineClient->hMutex;
+        }
+        myexcept
+        {
+            pParams->lResult = LINEERR_INVALLINEHANDLE;
+            goto LSetNumRings_epilog;
+        }
+
+        if (WaitForMutex(
+                hMutex,
+                &hMutex,
+                &bDupedMutex,
+                ptLineClient,
+                TLINECLIENT_KEY,
+                INFINITE
+                ))
+        {
+            DWORD dwNumAddresses = ptLineClient->ptLine->dwNumAddresses;
+
+
+            if (pParams->dwAddressID >= dwNumAddresses)
+            {
+                pParams->lResult = LINEERR_INVALADDRESSID;
+                goto LSetNumRings_releaseMutex;
+            }
+
+            if (ptLineClient->aNumRings == NULL)
+            {
+                if (!(ptLineClient->aNumRings = ServerAlloc(
+                        dwNumAddresses * sizeof (DWORD)
+                        )))
+                {
+                    pParams->lResult = LINEERR_NOMEM;
+                    goto LSetNumRings_releaseMutex;
+                }
+
+                FillMemory(
+                    ptLineClient->aNumRings,
+                    dwNumAddresses * sizeof (DWORD),
+                    0xff
+                    );
+            }
+
+            ptLineClient->aNumRings[pParams->dwAddressID] =
+                pParams->dwNumRings;
+
+LSetNumRings_releaseMutex:
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALLINEHANDLE;
+        }
+    }
+
+LSetNumRings_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetNumRings"
+        );
+}
+
+
+void
+WINAPI
+LSetStatusMessages(
+    PLINESETSTATUSMESSAGES_PARAMS   pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineSetStatusMessages;
+
+
+    if ((pParams->lResult = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETSTATUSMESSAGES,   // provider func index
+            &pfnTSPI_lineSetStatusMessages, // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "SetStatusMessages"         // func name
+
+            )) == 0)
+    {
+        DWORD           dwUnionLineStates, dwUnionAddressStates;
+        PTLINECLIENT    ptLineClient = (PTLINECLIENT) pParams->hLine;
+        PTLINE          ptLine = ptLineClient->ptLine;
+
+
+        //
+        // Validate the params
+        //
+
+        {
+            DWORD           dwValidLineStates, dwValidAddressStates;
+
+
+            switch (ptLineClient->dwAPIVersion)
+            {
+            case TAPI_VERSION1_0:
+
+                dwValidLineStates    = AllLineStates1_0;
+                dwValidAddressStates = AllAddressStates1_0;
+                break;
+
+            case TAPI_VERSION1_4:
+
+
+                dwValidLineStates    = AllLineStates1_4;
+                dwValidAddressStates = AllAddressStates1_4;
+                break;
+
+            default: // (fix ppc bld wrn) case TAPI_VERSION_CURRENT:
+
+                dwValidLineStates    = AllLineStates1_4;
+//                dwValidAddressStates = AllAddressStates2_0;
+                dwValidAddressStates = AllAddressStates1_4;
+                break;
+            }
+
+            if (pParams->dwLineStates & ~dwValidLineStates)
+            {
+                pParams->lResult = LINEERR_INVALLINESTATE;
+                goto LSetStatusMessages_epilog;
+            }
+
+            if (pParams->dwAddressStates & ~dwValidAddressStates)
+            {
+                pParams->lResult = LINEERR_INVALADDRESSSTATE;
+                goto LSetStatusMessages_epilog;
+            }
+        }
+
+
+        //
+        // Make sure the REINIT bit is always set
+        //
+
+        pParams->dwLineStates |= LINEDEVSTATE_REINIT;
+
+
+        //
+        // Determine the new state unions of all the line clients
+        //
+
+        dwUnionLineStates    = pParams->dwLineStates;
+        dwUnionAddressStates = pParams->dwAddressStates;
+
+        {
+            PTLINECLIENT    ptLineClientTmp = ptLine->ptLineClients;
+
+
+            while (ptLineClientTmp)
+            {
+                if (ptLineClientTmp != ptLineClient)
+                {
+                    dwUnionLineStates    |= ptLineClientTmp->dwLineStates;
+                    dwUnionAddressStates |= ptLineClientTmp->dwAddressStates;
+                }
+
+                ptLineClientTmp = ptLineClientTmp->pNextSametLine;
+            }
+        }
+
+
+        //
+        // If the new state unions are the same as previous state unions
+        // just reset the fields in the tLineClient, else call the provider
+        //
+
+        if (((dwUnionLineStates == ptLine->dwUnionLineStates) &&
+             (dwUnionAddressStates == ptLine->dwUnionAddressStates)) ||
+
+            ((pParams->lResult = CallSP3(
+                pfnTSPI_lineSetStatusMessages,
+                "lineSetStatusMessages",
+                SP_FUNC_SYNC,
+                (DWORD) hdLine,
+                (DWORD) dwUnionLineStates,
+                (DWORD) dwUnionAddressStates
+
+                )) == 0))
+        {
+            ptLineClient->dwLineStates    = pParams->dwLineStates;
+            ptLineClient->dwAddressStates = pParams->dwAddressStates;
+
+            ptLine->dwUnionLineStates    = dwUnionLineStates;
+            ptLine->dwUnionAddressStates = dwUnionAddressStates;
+        }
+    }
+
+LSetStatusMessages_epilog:
+
+    LINEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetStatusMessages"
+        );
+}
+
+
+void
+WINAPI
+LSetTerminal(
+    PLINESETTERMINAL_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    DWORD               dwWidgetType, hWidget, dwPrivilege,
+                        dwSelect = pParams->dwSelect;
+    HANDLE              hMutex;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSetTerminal;
+
+
+    if (dwSelect == LINECALLSELECT_CALL)
+    {
+        dwWidgetType = ANY_RT_HCALL;
+        hWidget      = (DWORD) pParams->hCall;
+        dwPrivilege  = LINECALLPRIVILEGE_MONITOR;
+    }
+    else
+    {
+        dwWidgetType = ANY_RT_HLINE;
+        hWidget      = (DWORD) pParams->hLine;
+        dwPrivilege  = 0;
+    }
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            dwWidgetType,               // widget type
+            hWidget,                    // client widget handle
+            (LPVOID) &hWidget,          // provider widget handle
+            dwPrivilege,                // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETTERMINAL,         // provider func index
+            &pfnTSPI_lineSetTerminal,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetTerminal"               // func name
+
+            )) > 0)
+    {
+        DWORD   dwTerminalModes = pParams->dwTerminalModes;
+
+
+        if (!IsOnlyOneBitSetInDWORD (dwSelect) ||
+            (dwSelect & ~AllCallSelects))
+        {
+            lRequestID = LINEERR_INVALCALLSELECT;
+            goto LSetTerminal_epilog;
+        }
+
+        if (dwTerminalModes == 0 ||
+            (dwTerminalModes & (~AllTerminalModes)))
+        {
+            lRequestID = LINEERR_INVALTERMINALMODE;
+            goto LSetTerminal_epilog;
+        }
+
+        pParams->lResult = CallSP8(
+            pfnTSPI_lineSetTerminal,
+            "lineSetTerminal",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) (dwWidgetType == ANY_RT_HLINE ? hWidget : 0),
+            (DWORD) pParams->dwAddressID,
+            (DWORD) (dwWidgetType == ANY_RT_HCALL ? hWidget : 0),
+            (DWORD) dwSelect,
+            (DWORD) dwTerminalModes,
+            (DWORD) pParams->dwTerminalID,
+            (DWORD) pParams->bEnable
+            );
+    }
+
+LSetTerminal_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetTerminal"
+        );
+}
+
+
+// This code is in TAPI32.DLL now
+//
+// void
+// WINAPI
+// LSetTollList(
+//     PLINESETTOLLLIST_PARAMS pParams,
+//     LPBYTE                  pDataBuf,
+//     LPDWORD                 pdwNumBytesReturned
+//     )
+// {
+//     pParams->lResult = LINEERR_OPERATIONUNAVAIL;
+// }
+
+
+void
+LSetupConference_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    BOOL            bDupedMutex;
+    HANDLE          hMutex;
+    PTCALL          ptConfCall    = (PTCALL) pAsyncRequestInfo->dwParam1,
+                    ptConsultCall = (PTCALL) pAsyncRequestInfo->dwParam3,
+                    ptCall        = (PTCALL) pAsyncRequestInfo->dwParam5;
+    LPHCALL         lphConfCall = (LPHCALL) pAsyncRequestInfo->dwParam2,
+                    lphConsultCall = (LPHCALL) pAsyncRequestInfo->dwParam4;
+    PTCALLCLIENT    ptConfCallClient, ptConsultCallClient;
+
+
+// BUGBUG? LSetupConference_PostProcess: mutex on confCall too?
+//
+//         Actually, this may be ok as is- the consult call is
+//         positioned before the conf call in the tline's list,
+//         so if we can safely access the former we ought to be
+//         able to safely access the latter too
+
+    if (WaitForExclusivetCallAccess(
+            (HTAPICALL) ptConsultCall,
+            TINCOMPLETECALL_KEY,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD   dwConsultCallInstance = *(&pAsyncRequestInfo->dwParam5 + 2);
+
+
+        //
+        // Check to make sure this is the call we think it is (that the
+        // pointer wasn't freed by a previous call to lineClose/Shutdown
+        // and realloc'd for use as a ptCall again)
+        //
+
+        if (ptConsultCall->dwCallInstance != dwConsultCallInstance)
+        {
+            MyReleaseMutex (hMutex, bDupedMutex);
+            goto LSetupConference_PostProcess_bad_ptConsultCall;
+        }
+
+        ptConfCallClient    = (PTCALLCLIENT) ptConfCall->ptCallClients;
+        ptConsultCallClient = (PTCALLCLIENT) ptConsultCall->ptCallClients;
+
+        if (pAsyncEventMsg->dwParam2 == 0)  // success
+        {
+            PTCONFERENCELIST    pConfList = (PTCONFERENCELIST)
+                                    ptConfCall->pConfList;
+
+
+            //
+            // Check to see if the app closed the line & left us with
+            // 0 call clients (in which case it'll also be taking care of
+            // cleaning up this tCall too)
+            //
+
+            if (ptConsultCall->ptCallClients == NULL)
+            {
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+                ptConfCallClient = (PTCALLCLIENT) NULL;
+                ptConsultCallClient = (PTCALLCLIENT) NULL;
+
+                if (pAsyncEventMsg->dwParam2 == 0)
+                {
+                    pAsyncEventMsg->dwParam2 = LINEERR_INVALLINEHANDLE;
+                }
+
+                goto LSetupConference_PostProcess_initMsgParams;
+            }
+
+
+            //
+            // Find out which address the calls are on
+            //
+
+            CallSP2(
+                ptConfCall->ptProvider->apfn[SP_LINEGETCALLADDRESSID],
+                "lineGetCallAddressID",
+                SP_FUNC_SYNC,
+                (DWORD) ptConfCall->hdCall,
+                (DWORD) (&ptConfCall->dwAddressID)
+                );
+
+            CallSP2(
+                ptConsultCall->ptProvider->apfn[SP_LINEGETCALLADDRESSID],
+                "lineGetCallAddressID",
+                SP_FUNC_SYNC,
+                (DWORD) ptConsultCall->hdCall,
+                (DWORD) (&ptConsultCall->dwAddressID)
+                );
+
+
+            //
+            // Mark the calls as valid, the release the mutex
+            //
+
+            ptConfCall->dwKey =
+            ptConsultCall->dwKey = TCALL_KEY;
+            ptConfCallClient->dwKey =
+            ptConsultCallClient->dwKey = TCALLCLIENT_KEY;
+            pConfList->dwKey = TCONFLIST_KEY;
+
+            MyReleaseMutex (hMutex, bDupedMutex);
+
+
+            //
+            // Create monitor tCallClients
+            //
+
+            CreateCallMonitors (ptConfCall);
+            CreateCallMonitors (ptConsultCall);
+        }
+        else    // error
+        {
+            RemoveCallFromLineList (ptConfCall);
+            RemoveCallFromLineList (ptConsultCall);
+            ptConfCall->dwKey = ptConsultCall->dwKey = INVAL_KEY;
+
+
+            //
+            // Check to see if another thread already destroyed the
+            // tCallClients (due to a lineClose/Shutdown) before trying
+            // to reference a freed object
+            //
+
+            if (ptConfCall->ptCallClients)
+            {
+                RemoveCallClientFromLineClientList (ptConfCallClient);
+                ptConfCallClient->dwKey = INVAL_KEY;
+                ServerFree  (ptConfCallClient);
+            }
+
+            if (ptConsultCall->ptCallClients)
+            {
+                RemoveCallClientFromLineClientList (ptConsultCallClient);
+                ptConsultCallClient->dwKey = INVAL_KEY;
+                ServerFree  (ptConsultCallClient);
+            }
+
+
+            //
+            // If we have a duped mutex handle (bDupedMutex == TRUE)
+            // then we can safely go ahead and close the ptCall->hMutex
+            // since no other thread will be waiting on it (thanks to
+            // the first WaitForSingleObject in WaitForMutex).  Also
+            // release & close the duped handle.
+            //
+            // Otherwise, we have the actual ptCall->hMutex, and we
+            // wrap the release & close in a critical section to
+            // prevent another thread "T2" from grabbing ptCall->hMutex
+            // right after we release but right before we close.  This
+            // could result in deadlock at some point when "T2" goes to
+            // release the mutex, only to find that it's handle is bad,
+            // and thread "T3", which is waiting on the mutex (or a dup'd
+            // handle) waits forever.  (See corresponding critical
+            // section in WaitForMutex.)
+            //
+
+            if (bDupedMutex)
+            {
+                CloseHandle (ptConfCall->hMutex);
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+            }
+            else
+            {
+                EnterCriticalSection (&gSafeMutexCritSec);
+
+                ReleaseMutex (hMutex);
+                CloseHandle (hMutex);
+
+                LeaveCriticalSection (&gSafeMutexCritSec);
+            }
+
+            FreetCall  (ptConsultCall);
+
+            if (ptCall)
+            {
+                SetCallConfList (ptCall, NULL, FALSE);
+            }
+
+            ServerFree  (ptConfCall->pConfList);
+            FreetCall  (ptConfCall);
+        }
+    }
+    else
+    {
+        //
+        // If here we can assume that the call was already destroyed
+        // and just fail the request
+        //
+
+LSetupConference_PostProcess_bad_ptConsultCall:
+
+        ptConfCallClient    = (PTCALLCLIENT) NULL;
+        ptConsultCallClient = (PTCALLCLIENT) NULL;
+
+        if (pAsyncEventMsg->dwParam2 == 0)
+        {
+            pAsyncEventMsg->dwParam2 = LINEERR_OPERATIONFAILED;
+        }
+    }
+
+
+    //
+    // Fill in the params to pass to client.  Note that we have to
+    // create our our msg, since the std msg isn't large enough to
+    // hold all the info we need to send. (The caller will take
+    // care of dealloc'ing this buf.)
+    //
+    // Also, we do this for both the success & fail cases because
+    // remotesp needs the lphXxxCall ptrs back so it can either
+    // fill in or free
+    //
+
+LSetupConference_PostProcess_initMsgParams:
+
+    {
+        DWORD           dwMsgSize = sizeof (ASYNCEVENTMSG) +
+                            2 * sizeof (DWORD);
+        PASYNCEVENTMSG  pMsg;
+
+
+        if (!(pMsg = ServerAlloc (dwMsgSize)))
+        {
+            // BUGBUG it would be better if this struct was alloc'd
+            //        in the main routine
+        }
+
+        CopyMemory (pMsg, pAsyncEventMsg, sizeof (ASYNCEVENTMSG));
+
+        pMsg->dwTotalSize      = (DWORD) dwMsgSize;
+        pMsg->dwParam3         = (DWORD) ptConfCallClient;
+        pMsg->dwParam4         = (DWORD) lphConfCall;
+        *(&pMsg->dwParam4 + 1) = (DWORD) ptConsultCallClient;
+        *(&pMsg->dwParam4 + 2) = (DWORD) lphConsultCall;
+
+        *ppBuf = pMsg;
+    }
+}
+
+
+void
+WINAPI
+LSetupConference(
+    PLINESETUPCONFERENCE_PARAMS pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    DWORD       hdXxx;
+    HCALL       hCall = pParams->hCall;
+    HLINE       hLine = pParams->hLine;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_lineSetupConference;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,                      // tClient
+            (hCall ? ANY_RT_HCALL : ANY_RT_HLINE),  // widget type
+            (hCall ? (DWORD) hCall : (DWORD) hLine),// client widget handle
+            (LPVOID) &hdXxx,                        // provider widget handle
+            (hCall ? LINECALLPRIVILEGE_OWNER : 0),  // privileges or device ID
+            &hMutex,                                // mutex handle
+            &bCloseMutex,                           // close hMutex when done
+            SP_LINESETUPCONFERENCE,                 // provider func index
+            &pfnTSPI_lineSetupConference,           // provider func pointer
+            &pAsyncRequestInfo,                     // async request info
+            pParams->dwRemoteRequestID,             // client async request ID
+            "SetupConference"                       // func name
+
+            )) > 0)
+    {
+        LONG                lResult;
+        DWORD               dwNumParties;
+        PTCALL              ptCall, ptConfCall, ptConsultCall;
+        PTCALLCLIENT        ptConfCallClient, ptConsultCallClient;
+        LPLINECALLPARAMS    pCallParamsApp, pCallParamsSP;
+        PTCONFERENCELIST    pConfList;
+
+
+        //
+        // We need two more async request info params than are available,
+        // so we'll realloc a larger buf & work with it
+        //
+
+        {
+            PASYNCREQUESTINFO   pAsyncRequestInfo2;
+
+
+            if (!(pAsyncRequestInfo2 = ServerAlloc(
+                    sizeof (ASYNCREQUESTINFO) + 2 * sizeof (DWORD)
+                    )))
+            {
+                lRequestID = LINEERR_NOMEM;
+                goto LSetupConference_return;
+            }
+
+            CopyMemory(
+                pAsyncRequestInfo2,
+                pAsyncRequestInfo,
+                sizeof (ASYNCREQUESTINFO)
+                );
+
+            ServerFree (pAsyncRequestInfo);
+
+            pAsyncRequestInfo = pAsyncRequestInfo2;
+        }
+
+        pCallParamsApp = (LPLINECALLPARAMS)
+            (pParams->dwCallParamsOffset == TAPI_NO_DATA ?
+                0 : (pDataBuf + pParams->dwCallParamsOffset));
+
+        if (pCallParamsApp)
+        {
+            DWORD         dwAPIVersion, dwSPIVersion;
+            PTLINECLIENT  ptLineClient;
+
+
+            try
+            {
+                ptLineClient = (hCall ?
+                    (PTLINECLIENT) ((PTCALLCLIENT) hCall)->ptLineClient :
+                    (PTLINECLIENT) hLine);
+
+                dwAPIVersion = ptLineClient->dwAPIVersion;
+                dwSPIVersion = ptLineClient->ptLine->dwSPIVersion;
+
+            }
+            myexcept
+            {
+                lRequestID = LINEERR_OPERATIONFAILED;
+                goto LSetupConference_return;
+            }
+
+
+            if ((lResult = ValidateCallParams(
+                    pCallParamsApp,
+                    &pCallParamsSP,
+                    dwAPIVersion,
+                    dwSPIVersion,
+                    pParams->dwAsciiCallParamsCodePage
+
+                    )) != 0)
+            {
+                lRequestID = lResult;
+                goto LSetupConference_return;
+            }
+        }
+        else
+        {
+            pCallParamsSP = (LPLINECALLPARAMS) NULL;
+        }
+
+        dwNumParties = (pParams->dwNumParties > DEF_NUM_CONF_LIST_ENTRIES ?
+            pParams->dwNumParties : DEF_NUM_CONF_LIST_ENTRIES);
+
+        if (!(pConfList = (PTCONFERENCELIST) ServerAlloc(
+                sizeof (TCONFERENCELIST) + dwNumParties * sizeof(PTCALL)
+                )))
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LSetupConference_freeCallParams;
+        }
+
+        pConfList->dwNumTotalEntries = dwNumParties + 1;
+        pConfList->dwNumUsedEntries  = 1;
+
+        if (hCall)
+        {
+            try
+            {
+                ptCall = ((PTCALLCLIENT) hCall)->ptCall;
+
+                hLine = ((PTCALLCLIENT) hCall)->ptLineClient;
+            }
+            myexcept
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+                goto LSetupConference_freeConfList;
+            }
+
+            if ((lResult = SetCallConfList (ptCall, pConfList, FALSE)) != 0)
+            {
+                goto LSetupConference_freeConfList;
+            }
+        }
+        else
+        {
+            ptCall = NULL;
+        }
+
+        if ((lResult = CreatetCallAndClient(
+                (PTLINECLIENT) hLine,
+                &ptConfCall,
+                &ptConfCallClient,
+                pCallParamsSP,
+                &pAsyncRequestInfo->dwParam5 + 1    // &dwConfCallInstance
+
+                )) == 0)
+        {
+            pConfList->aptCalls[0] = ptConfCall;
+
+            if ((lResult = CreatetCallAndClient(
+                    (PTLINECLIENT) hLine,
+                    &ptConsultCall,
+                    &ptConsultCallClient,
+                    NULL,
+                    &pAsyncRequestInfo->dwParam5 + 2  // &dwConsultCallInstance
+
+                    ) == 0))
+            {
+
+                ptConfCall->pConfList = pConfList;
+
+                pAsyncRequestInfo->pfnPostProcess =
+                    LSetupConference_PostProcess;
+                pAsyncRequestInfo->dwParam1 = (DWORD) ptConfCall;
+                pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphConfCall;
+                pAsyncRequestInfo->dwParam3 = (DWORD) ptConsultCall;
+                pAsyncRequestInfo->dwParam4 = (DWORD) pParams->lphConsultCall;
+                pAsyncRequestInfo->dwParam5 = (DWORD) ptCall;
+
+                pAsyncRequestInfo->pfnClientPostProcessProc =
+                    pParams->pfnPostProcessProc;
+
+                goto LSetupConference_callSP;
+            }
+
+            SetDrvCallFlags (ptConfCall, DCF_SPIRETURNED);
+            DestroytCall (ptConfCall);
+        }
+
+LSetupConference_freeConfList:
+
+        ServerFree (pConfList);
+        lRequestID = lResult;
+        goto LSetupConference_freeCallParams;
+
+LSetupConference_callSP:
+
+        pParams->lResult = CallSP9(
+            pfnTSPI_lineSetupConference,
+            "lineSetupConference",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) (hCall ? hdXxx : 0),    // hdCall
+            (DWORD) (hCall ? 0 : hdXxx),    // hdLine
+            (DWORD) ptConfCall,
+            (DWORD) &ptConfCall->hdCall,
+            (DWORD) ptConsultCall,
+            (DWORD) &ptConsultCall->hdCall,
+            (DWORD) pParams->dwNumParties,
+            (DWORD) pCallParamsSP
+            );
+
+        SetDrvCallFlags(
+            ptConfCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+
+        SetDrvCallFlags(
+            ptConsultCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+
+LSetupConference_freeCallParams:
+
+        if (pCallParamsSP != pCallParamsApp)
+        {
+            ServerFree (pCallParamsSP);
+        }
+    }
+
+LSetupConference_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetupConference"
+        );
+}
+
+
+void
+WINAPI
+LSetupTransfer(
+    PLINESETUPTRANSFER_PARAMS   pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    HANDLE      hMutex;
+    HDRVCALL    hdCall;
+    TSPIPROC    pfnTSPI_lineSetupTransfer;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESETUPTRANSFER,       // provider func index
+            &pfnTSPI_lineSetupTransfer, // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetupTransfer"             // func name
+
+            )) > 0)
+    {
+        LONG                lResult;
+        PTCALL              ptConsultCall;
+        PTCALLCLIENT        ptConsultCallClient;
+        LPLINECALLPARAMS    pCallParamsApp, pCallParamsSP;
+
+
+        pCallParamsApp = (LPLINECALLPARAMS)
+            (pParams->dwCallParamsOffset == TAPI_NO_DATA ?
+                0 : (pDataBuf + pParams->dwCallParamsOffset));
+
+        if (pCallParamsApp)
+        {
+            DWORD         dwAPIVersion, dwSPIVersion;
+            PTLINECLIENT  ptLineClient;
+
+
+            try
+            {
+                ptLineClient = (PTLINECLIENT)
+                    ((PTCALLCLIENT) pParams->hCall)->ptLineClient;
+
+                dwAPIVersion = ptLineClient->dwAPIVersion;
+                dwSPIVersion = ptLineClient->ptLine->dwSPIVersion;
+            }
+            myexcept
+            {
+                lRequestID = LINEERR_OPERATIONFAILED;
+                goto LSetupTransfer_return;
+            }
+
+
+            if ((lResult = ValidateCallParams(
+                    pCallParamsApp,
+                    &pCallParamsSP,
+                    dwAPIVersion,
+                    dwSPIVersion,
+                    pParams->dwAsciiCallParamsCodePage
+
+                    )) != 0)
+            {
+                lRequestID = lResult;
+                goto LSetupTransfer_return;
+            }
+        }
+        else
+        {
+            pCallParamsSP = (LPLINECALLPARAMS) NULL;
+        }
+
+        if (CreatetCallAndClient(
+                (PTLINECLIENT) ((PTCALLCLIENT)(pParams->hCall))->ptLineClient,
+                &ptConsultCall,
+                &ptConsultCallClient,
+                NULL,
+                &pAsyncRequestInfo->dwParam5
+
+                ) != 0)
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LSetupTransfer_freeCallParams;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LMakeCall_PostProcess;
+        pAsyncRequestInfo->dwParam1 = (DWORD) ptConsultCall;
+        pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphConsultCall;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP5(
+            pfnTSPI_lineSetupTransfer,
+            "lineSetupTransfer",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall,
+            (DWORD) ptConsultCall,
+            (DWORD) &ptConsultCall->hdCall,
+            (pParams->dwCallParamsOffset == TAPI_NO_DATA ? 0 :
+                (DWORD)(pDataBuf + pParams->dwCallParamsOffset))
+            );
+
+        SetDrvCallFlags(
+            ptConsultCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+
+LSetupTransfer_freeCallParams:
+
+        if (pCallParamsSP != pCallParamsApp)
+        {
+            ServerFree (pCallParamsSP);
+        }
+    }
+
+LSetupTransfer_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetupTransfer"
+        );
+}
+
+
+void
+WINAPI
+LShutdown(
+    PLINESHUTDOWN_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    PTLINEAPP   ptLineApp;
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    if (!(ptLineApp = IsValidLineApp (pParams->hLineApp, pParams->ptClient)))
+    {
+        if (TapiGlobals.dwNumLineInits == 0)
+        {
+            pParams->lResult = LINEERR_UNINITIALIZED;
+        }
+        else
+        {
+            pParams->lResult = LINEERR_INVALAPPHANDLE;
+        }
+    }
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+    if (pParams->lResult == 0)
+    {
+        DestroytLineApp ((PTLINEAPP) pParams->hLineApp);
+    }
+
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "lineShutdown: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+}
+
+
+void
+WINAPI
+LSwapHold(
+    PLINESWAPHOLD_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdActiveCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineSwapHold;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hActiveCall,   // client widget handle
+            (LPVOID) &hdActiveCall,     // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINESWAPHOLD,            // provider func index
+            &pfnTSPI_lineSwapHold,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SwapHold"                  // func name
+
+            )) > 0)
+    {
+        HDRVCALL        hdHeldCall;
+        PTCALLCLIENT    ptHeldCallClient, ptActiveCallClient;
+
+
+        //
+        // Verify held call
+        //
+
+        if (!(ptHeldCallClient = IsValidCall(
+                pParams->hHeldCall,
+                pParams->ptClient
+                )))
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LSwapHold_epilog;
+        }
+
+
+        //
+        // Safely verify that client has owner privilege to held call,
+        // and that calls are on same tLine
+        //
+
+        try
+        {
+            if (!(ptHeldCallClient->dwPrivilege & LINECALLPRIVILEGE_OWNER))
+            {
+                lRequestID = LINEERR_NOTOWNER;
+                goto LSwapHold_epilog;
+            }
+
+            ptActiveCallClient = (PTCALLCLIENT) pParams->hActiveCall;
+
+            if (ptHeldCallClient->ptCall->ptLine !=
+                    ptActiveCallClient->ptCall->ptLine)
+            {
+                lRequestID = LINEERR_INVALCALLHANDLE;
+                goto LSwapHold_epilog;
+            }
+
+            hdHeldCall = ptHeldCallClient->ptCall->hdCall;
+        }
+        myexcept
+        {
+        }
+
+
+        //
+        // Are they the same call?
+        //
+
+        if (hdActiveCall == hdHeldCall)
+        {
+            lRequestID = LINEERR_INVALCALLHANDLE;
+            goto LSwapHold_epilog;
+        }
+
+        pParams->lResult = CallSP3(
+            pfnTSPI_lineSwapHold,
+            "lineSwapHold",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdActiveCall,
+            (DWORD) hdHeldCall
+            );
+    }
+
+LSwapHold_epilog:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SwapHold"
+        );
+}
+
+
+
+void
+WINAPI
+LUncompleteCall(
+    PLINEUNCOMPLETECALL_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVLINE            hdLine;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineUncompleteCall;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEUNCOMPLETECALL,      // provider func index
+            &pfnTSPI_lineUncompleteCall,// provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "UncompleteCall"            // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP3(
+            pfnTSPI_lineUncompleteCall,
+            "lineUncompleteCall",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            pParams->dwCompletionID
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "UncompleteCall"
+        );
+}
+
+
+void
+WINAPI
+LUnhold(
+    PLINEUNHOLD_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVCALL            hdCall;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_lineUnhold;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HCALL,               // widget type
+            (DWORD) pParams->hCall,     // client widget handle
+            (LPVOID) &hdCall,           // provider widget handle
+            LINECALLPRIVILEGE_OWNER,    // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEUNHOLD,              // provider func index
+            &pfnTSPI_lineUnhold,        // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Unhold"                    // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP2(
+            pfnTSPI_lineUnhold,
+            "lineUnhold",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdCall
+            );
+    }
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Unhold"
+        );
+}
+
+
+void
+WINAPI
+LUnpark(
+    PLINEUNPARK_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    LONG        lRequestID;
+    HANDLE      hMutex;
+    HDRVLINE    hdLine;
+    TSPIPROC    pfnTSPI_lineUnpark;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+    if ((lRequestID = LINEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HLINE,               // widget type
+            (DWORD) pParams->hLine,     // client widget handle
+            (LPVOID) &hdLine,           // provider widget handle
+            0,                          // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_LINEUNPARK,              // provider func index
+            &pfnTSPI_lineUnpark,        // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "Unpark"                    // func name
+
+            )) > 0)
+    {
+        PTCALL          ptCall;
+        PTCALLCLIENT    ptCallClient;
+
+
+        if (CreatetCallAndClient(
+                (PTLINECLIENT) pParams->hLine,
+                &ptCall,
+                &ptCallClient,
+                NULL,
+                &pAsyncRequestInfo->dwParam5
+
+                ) != 0)
+        {
+            lRequestID = LINEERR_NOMEM;
+            goto LUnpark_return;
+        }
+
+        pAsyncRequestInfo->pfnPostProcess = LMakeCall_PostProcess;
+        pAsyncRequestInfo->dwParam1 = (DWORD) ptCall;
+        pAsyncRequestInfo->dwParam2 = (DWORD) pParams->lphCall;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP6(
+            pfnTSPI_lineUnpark,
+            "lineUnpark",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdLine,
+            (DWORD) pParams->dwAddressID,
+            (DWORD) ptCall,
+            (DWORD) &ptCall->hdCall,
+            (DWORD) (pDataBuf + pParams->dwDestAddressOffset)
+            );
+
+        SetDrvCallFlags(
+            ptCall,
+            DCF_SPIRETURNED | (pParams->lResult > 0 ? DCF_DRVCALLVALID : 0)
+            );
+    }
+
+LUnpark_return:
+
+    LINEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "Unpark"
+        );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void
+WINAPI
+TAllocNewID(
+    P_ALLOCNEWID_PARAMS  pParams,
+    LPBYTE               pDataBuf,
+    LPDWORD              pdwNumBytesReturned
+    )
+{
+   HKEY  hKey;
+   HKEY  hKey2;
+   DWORD dwDataSize;
+   DWORD dwDataType;
+   DWORD dwNewID;
+   DWORD dwDisposition;
+
+
+   RegCreateKeyEx(
+                 HKEY_LOCAL_MACHINE,
+                 gszRegKeyTelephony,
+                 0,
+                 "",
+                 REG_OPTION_NON_VOLATILE,
+                 KEY_ALL_ACCESS,
+                 0,
+                 &hKey2,
+                 &dwDisposition
+               );
+
+   RegCreateKeyExW(
+                 hKey2,
+                 gszLocationsW,
+                 0,
+                 L"",
+                 REG_OPTION_NON_VOLATILE,
+                 KEY_ALL_ACCESS,
+                 0,
+                 &hKey,
+                 &dwDisposition
+               );
+
+   dwDataSize = sizeof(DWORD);
+
+   //
+   // Use 1 as the first ID.
+   //
+   pParams->u.dwNewID = 1;
+   RegQueryValueExW(
+                    hKey,
+                    gszNextIDW,
+                    0,
+                    &dwDataType,
+                    (LPBYTE)&pParams->u.dwNewID,
+                    &dwDataSize
+                  );
+
+
+   dwNewID = pParams->u.dwNewID + 1;
+
+   RegSetValueExW(
+                  hKey,
+                  gszNextIDW,
+                  0,
+                  REG_DWORD,
+                  (LPBYTE)&dwNewID,
+                  sizeof(DWORD)
+                );
+
+   RegCloseKey( hKey );
+   RegCloseKey( hKey2);
+
+   *pdwNumBytesReturned = sizeof(ALLOCNEWID_PARAMS);
+    
+   return;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void WriteCurrentLocationValue( UINT dwNewLocation )
+{
+   HKEY hKey;
+   HKEY hKey2;
+
+
+DBGOUT((90, "Updating curlocation value (%ld)", dwNewLocation));
+
+
+   RegOpenKeyEx(
+                 HKEY_LOCAL_MACHINE,
+                 gszRegKeyTelephony,
+                 0,
+                 KEY_ALL_ACCESS,
+                 &hKey2
+               );
+
+   RegOpenKeyExW(
+                 hKey2,
+                 gszLocationsW,
+                 0,
+                 KEY_ALL_ACCESS,
+                 &hKey
+               );
+
+   RegSetValueExW(
+                  hKey,
+                  gszCurrentIDW,
+                  0,
+                  REG_DWORD,
+                  (LPBYTE)&dwNewLocation,
+                  sizeof(dwNewLocation)
+                );
+
+   RegCloseKey( hKey );
+   RegCloseKey( hKey2);
+
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void
+WINAPI
+TWriteLocations(
+    PW_LOCATIONS_PARAMS  pParams,
+    LPBYTE               pDataBuf,
+    LPDWORD              pdwNumBytesReturned
+    )
+{
+    UINT n;
+    UINT nCurrentLocation;
+    WCHAR szCurrentLocationKey[256];
+    HKEY  hKey;
+    HKEY  hKey2;
+    PLOCATION   pLocationList;
+    DWORD dwDisposition;
+
+
+DBGOUT((40, "In writelocations"));
+
+    //
+    // Has _anything_ changed?
+    //
+    if ( pParams->dwChangedFlags )
+    {
+
+       pLocationList = (PLOCATION)( (PDWORD)pDataBuf + 3 );
+
+
+       //
+       // Has anything changed that should cause us to write out all
+       // of the location info?
+       //
+
+       RegCreateKeyEx(
+                      HKEY_LOCAL_MACHINE,
+                      gszRegKeyTelephony,
+                      0,
+                      "",
+                      REG_OPTION_NON_VOLATILE,
+                      KEY_ALL_ACCESS,
+                      0,
+                      &hKey,
+                      &dwDisposition
+                    );
+
+       RegCreateKeyExW(
+                      hKey,
+                      gszLocationsW,
+                      0,
+                      L"",
+                      REG_OPTION_NON_VOLATILE,
+                      KEY_ALL_ACCESS,
+                      0,
+                      &hKey2,
+                      &dwDisposition
+                    );
+
+       RegCloseKey( hKey );
+
+
+       if ( pParams->dwChangedFlags & CHANGEDFLAGS_REALCHANGE )
+       {
+
+DBGOUT((40, "About to write %d locations", pParams->nNumLocations));
+
+          //
+          // This var will be the # of the current location as opposed to the
+          // # in mem - if a user deleted one, we can't write LOCATIONX ...
+          //
+          nCurrentLocation = 0;
+
+          for (n = 0; n < pParams->nNumLocations; n++)
+          {
+              PLOCATION ThisLocation = &(pLocationList[n]);
+
+
+              //
+              // If the user Removed this location, don't write it.
+              //
+              if ( (WCHAR)'\0' == ThisLocation->NameW[0] )
+              {
+                 continue;  // skipit
+              }
+
+DBGOUT((50, "About to write Location#%d [id:%ld]- %ls",
+                    nCurrentLocation,
+                    ThisLocation->dwID,
+                    ThisLocation->NameW));
+
+
+              wsprintfW(szCurrentLocationKey, L"%ls%d",
+                                gszLocationW,
+                                nCurrentLocation);
+
+              {
+
+              RegCreateKeyExW(
+                              hKey2,
+                              szCurrentLocationKey,
+                              0,
+                              L"",
+                              REG_OPTION_NON_VOLATILE,
+                              KEY_ALL_ACCESS,
+                              0,
+                              &hKey,
+                              &dwDisposition
+                            );
+
+              RegSetValueExW(
+                             hKey,
+                             gszNameW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisLocation->NameW,
+                             (lstrlenW(ThisLocation->NameW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszAreaCodeW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisLocation->AreaCodeW,
+                             (lstrlenW(ThisLocation->AreaCodeW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszCountryW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&ThisLocation->dwCountry,
+                             sizeof(DWORD)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszOutsideAccessW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisLocation->OutsideAccessW,
+                             (lstrlenW(ThisLocation->OutsideAccessW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszLongDistanceAccessW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisLocation->LongDistanceAccessW,
+                             (lstrlenW(ThisLocation->LongDistanceAccessW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszIDW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&ThisLocation->dwID,
+                             sizeof(DWORD)
+                           );
+
+              //
+              // If this location has the callwaiting flag on, but nothing
+              // (besides spaces) in the callwaiting string, clear the
+              // flag and the string
+              //
+              if ( ThisLocation->dwFlags & LOCATION_HASCALLWAITING )
+              {
+                 LPWSTR pTemp;
+
+                 pTemp = ThisLocation->DisableCallWaitingW;
+
+                 while ( *pTemp )
+                 {
+                    if ( *pTemp != ' ' )
+                    {
+                       break;
+                    }
+                    pTemp++;
+                 }
+
+                 //
+                 // Did we make it to the end with only spaces?
+                 //
+                 if ( *pTemp == '\0' )
+                 {
+                    //
+                    // Yup.  Let's tidy up a bit.
+                    //
+                    ThisLocation->dwFlags &= ~LOCATION_HASCALLWAITING;
+
+                    ThisLocation->DisableCallWaitingW[0] = '\0';
+                 }
+              }
+
+              RegSetValueExW(
+                             hKey,
+                             gszDisableCallWaitingW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)&ThisLocation->DisableCallWaitingW,
+                             (lstrlenW(ThisLocation->DisableCallWaitingW)+1)*sizeof(WCHAR)
+                           );
+
+              RegSetValueExW(
+                             hKey,
+                             gszFlagsW,
+                             0,
+                             REG_DWORD,
+                             (LPBYTE)&ThisLocation->dwFlags,
+                             sizeof(DWORD)
+                           );
+
+              RegCloseKey( hKey );
+
+              }
+
+
+
+              nCurrentLocation++;
+
+          }
+
+
+          //
+          // If we "deleted" one or more locations, they're still hanging
+          // around.  Delete them now.
+          //
+          for (n = nCurrentLocation; n < pParams->nNumLocations; n++)
+          {
+             wsprintfW( szCurrentLocationKey,
+                        L"%ls%d",
+                        gszLocationW,
+                        n
+                      );
+
+             RegDeleteKeyW( hKey2,
+                           szCurrentLocationKey
+                         );
+          }
+
+
+
+          RegSetValueExW(
+                         hKey2,
+                         gszNumEntriesW,
+                         0,
+                         REG_DWORD,
+                         (LPBYTE)&nCurrentLocation,
+                         sizeof(DWORD)
+                       );
+
+       }
+
+
+
+       if ( pParams->dwChangedFlags & CHANGEDFLAGS_TOLLLIST )
+       {
+
+DBGOUT((40, "About to update tolllists for %d locations", pParams->nNumLocations));
+
+          //
+          // This var will be the # of the current location as opposed to the
+          // # in mem - if a user deleted one, we can't write LOCATIONX ...
+          //
+          nCurrentLocation = 0;
+
+          for (n = 0; n < pParams->nNumLocations; n++)
+          {
+              PLOCATION ThisLocation = &(pLocationList[n]);
+
+
+              //
+              // If the user Removed this location, don't write it.
+              //
+              if ( (WCHAR)'\0' == ThisLocation->NameW[0] )
+              {
+                 continue;  // skipit
+              }
+
+DBGOUT((40, "About to write tolllist of %ls", ThisLocation->NameW));
+
+              wsprintfW(szCurrentLocationKey, L"%ls%d",
+                                gszLocationW,
+                                nCurrentLocation);
+
+              RegOpenKeyExW(
+                            hKey2,
+                            szCurrentLocationKey,
+                            0,
+                            KEY_ALL_ACCESS,
+                            &hKey
+                          );
+              RegSetValueExW(
+                             hKey,
+                             gszTollListW,
+                             0,
+                             REG_SZ,
+                             (LPBYTE)ThisLocation->TollListW,
+                             (lstrlenW(ThisLocation->TollListW)+1)*sizeof(WCHAR)
+                           );
+              RegCloseKey(
+                           hKey
+                         );
+
+
+              nCurrentLocation++;
+          }
+
+       }
+
+
+       //
+       // Has the current country changed?
+       //
+       if ( pParams->dwChangedFlags & CHANGEDFLAGS_CURLOCATIONCHANGED )
+       {
+          WriteCurrentLocationValue( pParams->dwCurrentLocationID );
+       }
+
+
+       RegCloseKey( hKey2);
+
+
+       //
+       // We're inside "if (dwChangedFlags)", so we know _something_ changed...
+       //
+
+DBGOUT((31, "Sending LINE_LINEDEVSTATE/LINEDEVSTATE_TRANSLATECHANGE msg"));
+
+       SendAMsgToAllLineApps(
+               0x80010004,     // (OR with 0x80000000 for >= version)
+               LINE_LINEDEVSTATE,
+               LINEDEVSTATE_TRANSLATECHANGE,
+               0,
+               0
+             );
+
+       SendAMsgToAllLineApps(
+               0x00010003,
+               LINE_LINEDEVSTATE,
+               LINEDEVSTATE_REINIT,
+               LINE_LINEDEVSTATE,
+               LINEDEVSTATE_TRANSLATECHANGE
+             );
+
+    }
+
+
+    return;
+
+}
+
+
+
+void
+WINAPI
+TReadLocations(
+    PR_LOCATIONS_PARAMS  pParams,
+    LPBYTE               pDataBuf,
+    LPDWORD              pdwNumBytesReturned
+    )
+{
+
+    //dwTotalSize
+    //dwNeededSize
+    //dwUsedSize
+    //pnStuff[0]
+    //pnStuff[1]
+    //pnStuff[2]
+    //LOCATION[n]
+
+    PUINT     pnStuff       = (PUINT)    (pDataBuf + (sizeof(UINT) * 3));
+    PLOCATION pLocationList = (PLOCATION)(pDataBuf + (sizeof(UINT) * 6));
+
+    UINT n;
+    UINT nNumLocations;
+    UINT nCurrentLocationID;
+
+    WCHAR szCurrentLocationKey[64];  // Holds "LOCATIONxx" during reads
+    DWORD dwDataSize;
+    DWORD dwDataType;
+    HKEY hKey2;
+    HKEY hKey;
+
+
+    if ( pParams->dwParmsToCheckFlags & CHECKPARMS_DWHLINEAPP )
+    {
+        if ( 0 == pParams->dwhLineApp )
+        {
+            //
+            // NULL is valid for these functions...
+            //
+        }
+        else
+        {
+            if ( !IsValidLineApp((HLINEAPP)pParams->dwhLineApp, pParams->ptClient) )
+            {
+                 DBGOUT((1, "0x%lx is not a valid hLineApp", pParams->dwhLineApp));
+                 pParams->lResult = LINEERR_INVALAPPHANDLE;
+                 goto CLEANUP_ERROR;
+            }
+        }
+    }
+
+
+    if ( pParams->dwParmsToCheckFlags & CHECKPARMS_DWDEVICEID )
+    {
+        if ( pParams->dwDeviceID > TapiGlobals.dwNumLines )
+        {
+             DBGOUT((1, "%ld is not a valid dwDeviceID", pParams->dwDeviceID));
+             pParams->lResult = LINEERR_BADDEVICEID;
+             goto CLEANUP_ERROR;
+        }
+    }
+
+
+    if ( pParams->dwParmsToCheckFlags & CHECKPARMS_DWAPIVERSION )
+    {
+        if (
+              (pParams->dwAPIVersion != TAPI_VERSION2_0)
+            &&
+              (pParams->dwAPIVersion != TAPI_VERSION1_4)
+            &&
+              (pParams->dwAPIVersion != TAPI_VERSION1_0)
+           )
+        {
+             DBGOUT((1, "0x%08lx is not a valid version", pParams->dwAPIVersion));
+             pParams->lResult = LINEERR_INCOMPATIBLEAPIVERSION;
+             goto CLEANUP_ERROR;
+        }
+    }
+
+
+// BUGBUG - performance/extensibility
+//should do a read of an entire key and get the # of locations from there -
+//no need to keep a separate # locations field (name of subkeys is name of loc?)
+
+    RegOpenKeyEx(
+                  HKEY_LOCAL_MACHINE,
+                  gszRegKeyTelephony,
+                  0,
+                  KEY_READ,
+                  &hKey
+                );
+
+    RegOpenKeyExW(
+                  hKey,
+                  gszLocationsW,
+                  0,
+                  KEY_READ,
+                  &hKey2
+                );
+
+    RegCloseKey( hKey );   // Don't need this key anymore...
+
+
+    dwDataSize = sizeof(nCurrentLocationID);
+    nCurrentLocationID = 0;
+    RegQueryValueExW(
+                   hKey2,
+                   gszCurrentIDW,
+                   0,
+                   &dwDataType,
+                   (LPBYTE)&nCurrentLocationID,
+                   &dwDataSize
+                 );
+    dwDataSize = sizeof(nNumLocations);
+    nNumLocations = 0;
+    RegQueryValueExW(
+                   hKey2,
+                   gszNumEntriesW,
+                   0,
+                   &dwDataType,
+                   (LPBYTE)&nNumLocations,
+                   &dwDataSize
+                 );
+
+    //
+    // It's _REALLY_ bad if gnNumLocations is zero for any
+    // reason.  Should probably fail the function on the spot...
+    //
+    if ( 0 == nNumLocations )
+    {
+       DBGOUT((1, "  Registry says there are 0 locations"));
+       pParams->lResult = LINEERR_INIFILECORRUPT;
+       RegCloseKey( hKey2 );
+       goto CLEANUP_ERROR;
+    }
+
+
+    //
+    // Do we have enough space?
+    //
+    if ( pParams->u.dwLocationsTotalSize
+            <
+              (nNumLocations * sizeof(LOCATION) + 6 * sizeof(DWORD) )
+       )
+    {
+    
+        DBGOUT((4, "(0x%08lx) is not enough room for sizeof( 0x%08lx )",
+                   pParams->u.dwLocationsTotalSize,
+                   nNumLocations * sizeof(LOCATION) + 6 * sizeof(DWORD) ));
+
+        //
+        // We did not have enough space.  Show the user the error of his ways.
+        //
+
+        ((PDWORD)pDataBuf)[DWTOTALSIZE] = pParams->u.dwLocationsTotalSize;
+
+        pParams->lResult = 0;
+
+        ((PDWORD)pDataBuf)[DWNEEDEDSIZE] = 
+              nNumLocations * sizeof(LOCATION) + 6 * sizeof(DWORD);
+
+        ((PDWORD)pDataBuf)[DWUSEDSIZE] = 3 * sizeof(DWORD);
+        
+        pParams->u.dwLocationsOffset = 0;
+    }
+    else
+    {
+        for (n = 0; n < nNumLocations; n++)
+        {
+            PLOCATION ThisLocation = &pLocationList[n];
+
+            wsprintfW(szCurrentLocationKey, L"%ls%d",
+                        gszLocationW, n);
+
+
+            RegOpenKeyExW(
+                          hKey2,
+                          szCurrentLocationKey,
+                          0,
+                          KEY_ALL_ACCESS,
+                          &hKey
+                        );
+
+            dwDataSize = sizeof(DWORD);
+            ThisLocation->dwID = 0;
+            RegQueryValueExW(
+                             hKey,
+                             gszIDW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)&ThisLocation->dwID,
+                             &dwDataSize
+                           );
+
+            dwDataSize = sizeof(ThisLocation->NameW);
+            ThisLocation->NameW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszNameW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisLocation->NameW,
+                             &dwDataSize
+                           );
+            ThisLocation->NameW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+DBGOUT((31, "getting list entry %d is %d [%ls]",
+                         n,ThisLocation->dwID,ThisLocation->NameW));
+
+            dwDataSize = sizeof(ThisLocation->AreaCodeW);
+            ThisLocation->AreaCodeW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszAreaCodeW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisLocation->AreaCodeW,
+                             &dwDataSize
+                           );
+            ThisLocation->AreaCodeW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+            dwDataSize = sizeof(DWORD);
+            ThisLocation->dwCountry = 1;
+            RegQueryValueExW(
+                             hKey,
+                             gszCountryW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)&ThisLocation->dwCountry,
+                             &dwDataSize
+                           );
+
+            dwDataSize = sizeof(ThisLocation->OutsideAccessW);
+            ThisLocation->OutsideAccessW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszOutsideAccessW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisLocation->OutsideAccessW,
+                             &dwDataSize
+                           );
+            ThisLocation->OutsideAccessW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+            dwDataSize = sizeof(ThisLocation->LongDistanceAccessW);
+            ThisLocation->LongDistanceAccessW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszLongDistanceAccessW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisLocation->LongDistanceAccessW,
+                             &dwDataSize
+                           );
+            ThisLocation->LongDistanceAccessW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+            dwDataSize = sizeof(DWORD);
+            ThisLocation->dwFlags = 0;
+            RegQueryValueExW(
+                             hKey,
+                             gszFlagsW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)&ThisLocation->dwFlags,
+                             &dwDataSize
+                           );
+
+            dwDataSize = sizeof(ThisLocation->DisableCallWaitingW);
+            ThisLocation->DisableCallWaitingW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszDisableCallWaitingW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisLocation->DisableCallWaitingW,
+                             &dwDataSize
+                           );
+            ThisLocation->DisableCallWaitingW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+            dwDataSize = sizeof(ThisLocation->TollListW);
+            ThisLocation->TollListW[0] = '\0';
+            RegQueryValueExW(
+                             hKey,
+                             gszTollListW,
+                             0,
+                             &dwDataType,
+                             (LPBYTE)ThisLocation->TollListW,
+                             &dwDataSize
+                           );
+            ThisLocation->TollListW[dwDataSize/sizeof(WCHAR)] = '\0';
+
+
+            RegCloseKey(
+                         hKey
+                       );
+
+
+
+        }
+
+        pnStuff[0] = (UINT)nCurrentLocationID;
+        pnStuff[1] = (UINT)pLocationList;
+        pnStuff[2] = (UINT)nNumLocations;
+
+        ((PDWORD)pDataBuf)[DWTOTALSIZE] = pParams->u.dwLocationsTotalSize;
+
+        ((PDWORD)pDataBuf)[DWUSEDSIZE] = 
+            nNumLocations * sizeof(LOCATION) + 6 * sizeof(DWORD);
+
+        ((PDWORD)pDataBuf)[DWNEEDEDSIZE] =
+            nNumLocations * sizeof(LOCATION) + 6 * sizeof(DWORD);
+
+        pParams->lResult = 0;
+
+        pParams->u.dwLocationsOffset = 0;
+
+    }
+
+
+    *pdwNumBytesReturned = sizeof (TAPI32_MSG) +  ((LPDWORD)pDataBuf)[2];
+
+
+    RegCloseKey( hKey2 );
+
+
+CLEANUP_ERROR:
+
+
+    return;
+}
diff --git a/private/tapi/dev/server/line.h b/private/tapi/dev/server/line.h
new file mode 100644
index 000000000..d67010850
--- /dev/null
+++ b/private/tapi/dev/server/line.h
@@ -0,0 +1,2292 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    line.h
+
+Abstract:
+
+    Header file for
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#define MAXLEN_NAME    96
+#define MAXLEN_RULE    128
+
+
+
+#define ANY_RT_HCALL        1
+#define ANY_RT_HLINE        2
+#define DEVICE_ID           3
+
+
+#if DBG
+
+#define LINEPROLOG(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \
+        LineProlog(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
+
+#define LINEEPILOGSYNC(a1,a2,a3,a4) LineEpilogSync(a1,a2,a3,a4)
+
+#define LINEEPILOGASYNC(a1,a2,a3,a4,a5,a6) LineEpilogAsync(a1,a2,a3,a4,a5,a6)
+
+#else
+
+#define LINEPROLOG(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \
+        LineProlog(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11)
+
+#define LINEEPILOGSYNC(a1,a2,a3,a4) LineEpilogSync(a1,a2,a3)
+
+#define LINEEPILOGASYNC(a1,a2,a3,a4,a5,a6) LineEpilogAsync(a1,a2,a3,a4,a5)
+
+#endif
+
+
+#define AllAddressStates1_0               \
+    (LINEADDRESSSTATE_OTHER             | \
+    LINEADDRESSSTATE_DEVSPECIFIC        | \
+    LINEADDRESSSTATE_INUSEZERO          | \
+    LINEADDRESSSTATE_INUSEONE           | \
+    LINEADDRESSSTATE_INUSEMANY          | \
+    LINEADDRESSSTATE_NUMCALLS           | \
+    LINEADDRESSSTATE_FORWARD            | \
+    LINEADDRESSSTATE_TERMINALS)
+
+#define AllAddressStates1_4               \
+    (AllAddressStates1_0                | \
+    LINEADDRESSSTATE_CAPSCHANGE)
+
+//#define AllAddressStates2_0               \
+//    (AllAddressStates1_4                | \
+//    LINEADDRESSSTATE_AGENT              | \
+//    LINEADDRESSSTATE_AGENTSTATE         | \
+//    LINEADDRESSSTATE_AGENTACTIVITY)
+
+#define AllAgentStates                    \
+    (LINEAGENTSTATE_LOGGEDOFF           | \
+    LINEAGENTSTATE_NOTREADY             | \
+    LINEAGENTSTATE_READY                | \
+    LINEAGENTSTATE_BUSYACD              | \
+    LINEAGENTSTATE_BUSYINCOMING         | \
+    LINEAGENTSTATE_BUSYOUTBOUND         | \
+    LINEAGENTSTATE_BUSYOTHER            | \
+    LINEAGENTSTATE_WORKINGAFTERCALL     | \
+    LINEAGENTSTATE_UNKNOWN              | \
+    LINEAGENTSTATE_UNAVAIL              | \
+    0xffff0000)
+
+#define AllAgentStatus                    \
+    (LINEAGENTSTATUS_GROUP              | \
+    LINEAGENTSTATUS_STATE               | \
+    LINEAGENTSTATUS_NEXTSTATE           | \
+    LINEAGENTSTATUS_ACTIVITY            | \
+    LINEAGENTSTATUS_ACTIVITYLIST        | \
+    LINEAGENTSTATUS_GROUPLIST           | \
+    LINEAGENTSTATUS_CAPSCHANGE          | \
+    LINEAGENTSTATUS_VALIDSTATES         | \
+    LINEAGENTSTATUS_VALIDNEXTSTATES)
+
+#define AllBearerModes1_0                 \
+    (LINEBEARERMODE_VOICE               | \
+    LINEBEARERMODE_SPEECH               | \
+    LINEBEARERMODE_MULTIUSE             | \
+    LINEBEARERMODE_DATA                 | \
+    LINEBEARERMODE_ALTSPEECHDATA        | \
+    LINEBEARERMODE_NONCALLSIGNALING)
+
+#define AllBearerModes1_4                 \
+    (AllBearerModes1_0                  | \
+    LINEBEARERMODE_PASSTHROUGH)
+
+#define AllBearerModes2_0                 \
+    (AllBearerModes1_4                  | \
+    LINEBEARERMODE_RESTRICTEDDATA)
+
+#define AllCallComplModes                 \
+    (LINECALLCOMPLMODE_CAMPON           | \
+    LINECALLCOMPLMODE_CALLBACK          | \
+    LINECALLCOMPLMODE_INTRUDE           | \
+    LINECALLCOMPLMODE_MESSAGE)
+
+#define AllCallParamFlags                 \
+    (LINECALLPARAMFLAGS_SECURE          | \
+    LINECALLPARAMFLAGS_IDLE             | \
+    LINECALLPARAMFLAGS_BLOCKID          | \
+    LINECALLPARAMFLAGS_ORIGOFFHOOK      | \
+    LINECALLPARAMFLAGS_DESTOFFHOOK)
+
+#define AllCallSelects                    \
+    (LINECALLSELECT_LINE                | \
+    LINECALLSELECT_ADDRESS              | \
+    LINECALLSELECT_CALL)
+
+#define AllForwardModes1_0                \
+    (LINEFORWARDMODE_UNCOND             | \
+    LINEFORWARDMODE_UNCONDINTERNAL      | \
+    LINEFORWARDMODE_UNCONDEXTERNAL      | \
+    LINEFORWARDMODE_UNCONDSPECIFIC      | \
+    LINEFORWARDMODE_BUSY                | \
+    LINEFORWARDMODE_BUSYINTERNAL        | \
+    LINEFORWARDMODE_BUSYEXTERNAL        | \
+    LINEFORWARDMODE_BUSYSPECIFIC        | \
+    LINEFORWARDMODE_NOANSW              | \
+    LINEFORWARDMODE_NOANSWINTERNAL      | \
+    LINEFORWARDMODE_NOANSWEXTERNAL      | \
+    LINEFORWARDMODE_NOANSWSPECIFIC      | \
+    LINEFORWARDMODE_BUSYNA              | \
+    LINEFORWARDMODE_BUSYNAINTERNAL      | \
+    LINEFORWARDMODE_BUSYNAEXTERNAL      | \
+    LINEFORWARDMODE_BUSYNASPECIFIC)
+
+#define AllForwardModes1_4                \
+    (AllForwardModes1_0                 | \
+    LINEFORWARDMODE_UNKNOWN             | \
+    LINEFORWARDMODE_UNAVAIL)
+
+#define AllLineStates1_0                  \
+    (LINEDEVSTATE_OTHER                 | \
+    LINEDEVSTATE_RINGING                | \
+    LINEDEVSTATE_CONNECTED              | \
+    LINEDEVSTATE_DISCONNECTED           | \
+    LINEDEVSTATE_MSGWAITON              | \
+    LINEDEVSTATE_MSGWAITOFF             | \
+    LINEDEVSTATE_INSERVICE              | \
+    LINEDEVSTATE_OUTOFSERVICE           | \
+    LINEDEVSTATE_MAINTENANCE            | \
+    LINEDEVSTATE_OPEN                   | \
+    LINEDEVSTATE_CLOSE                  | \
+    LINEDEVSTATE_NUMCALLS               | \
+    LINEDEVSTATE_NUMCOMPLETIONS         | \
+    LINEDEVSTATE_TERMINALS              | \
+    LINEDEVSTATE_ROAMMODE               | \
+    LINEDEVSTATE_BATTERY                | \
+    LINEDEVSTATE_SIGNAL                 | \
+    LINEDEVSTATE_DEVSPECIFIC            | \
+    LINEDEVSTATE_REINIT                 | \
+    LINEDEVSTATE_LOCK)
+
+#define AllLineStates1_4                  \
+    (AllLineStates1_0                   | \
+    LINEDEVSTATE_CAPSCHANGE             | \
+    LINEDEVSTATE_CONFIGCHANGE           | \
+    LINEDEVSTATE_TRANSLATECHANGE        | \
+    LINEDEVSTATE_COMPLCANCEL            | \
+    LINEDEVSTATE_REMOVED)
+
+#define AllMediaModes1_0                  \
+    (LINEMEDIAMODE_UNKNOWN              | \
+    LINEMEDIAMODE_INTERACTIVEVOICE      | \
+    LINEMEDIAMODE_AUTOMATEDVOICE        | \
+    LINEMEDIAMODE_DIGITALDATA           | \
+    LINEMEDIAMODE_G3FAX                 | \
+    LINEMEDIAMODE_G4FAX                 | \
+    LINEMEDIAMODE_DATAMODEM             | \
+    LINEMEDIAMODE_TELETEX               | \
+    LINEMEDIAMODE_VIDEOTEX              | \
+    LINEMEDIAMODE_TELEX                 | \
+    LINEMEDIAMODE_MIXED                 | \
+    LINEMEDIAMODE_TDD                   | \
+    LINEMEDIAMODE_ADSI)
+
+#define AllMediaModes1_4                  \
+    (AllMediaModes1_0                   | \
+    LINEMEDIAMODE_VOICEVIEW)
+
+#define AllTerminalModes                  \
+    (LINETERMMODE_BUTTONS               | \
+    LINETERMMODE_LAMPS                  | \
+    LINETERMMODE_DISPLAY                | \
+    LINETERMMODE_RINGER                 | \
+    LINETERMMODE_HOOKSWITCH             | \
+    LINETERMMODE_MEDIATOLINE            | \
+    LINETERMMODE_MEDIAFROMLINE          | \
+    LINETERMMODE_MEDIABIDIRECT)
+
+
+LONG
+PASCAL
+LineProlog(
+    PTCLIENT    ptClient,
+    DWORD       dwArgType,
+    DWORD       dwArg,
+    LPVOID      phdXxx,
+    DWORD       dwPrivilege,
+    HANDLE     *phMutex,
+    BOOL       *pbCloseMutex,
+    DWORD       dwTSPIFuncIndex,
+    FARPROC    *ppfnTSPI_lineXxx,
+    PASYNCREQUESTINFO  *ppAsyncRequestInfo,
+    DWORD       dwRemoteRequestID
+#if DBG
+    ,char      *pszFuncName
+#endif
+    );
+
+void
+PASCAL
+LineEpilogSync(
+    LONG   *plResult,
+    HANDLE  hMutex,
+    BOOL    bCloseMutex
+#if DBG
+    ,char *pszFuncName
+#endif
+    );
+
+
+
+PTLINEAPP
+PASCAL
+IsValidLineApp(
+    HLINEAPP    hLineApp,
+    PTCLIENT    ptClient
+    );
+
+
+
+typedef struct _LINEACCEPT_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwUserUserInfoOffset;       // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwSize;
+
+} LINEACCEPT_PARAMS, *PLINEACCEPT_PARAMS;
+
+
+typedef struct _LINEADDTOCONFERENCE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hConfCall;
+
+    IN  HCALL       hConsultCall;
+
+} LINEADDTOCONFERENCE_PARAMS, *PLINEADDTOCONFERENCE_PARAMS;
+
+
+typedef struct _LINEADDPROVIDER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwProviderFilenameOffset;   // always valid offset
+
+    IN  HWND        hwndOwner;
+
+    OUT DWORD       dwPermanentProviderID;
+
+} LINEADDPROVIDER_PARAMS, *PLINEADDPROVIDER_PARAMS;
+
+
+typedef struct _LINEAGENTSPECIFIC_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwAgentExtensionIDIndex;
+
+    IN  DWORD       lpParams;                   // pointer to client buffer
+
+    IN  DWORD       dwParamsOffset;             // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwParamsSize;
+
+} LINEAGENTSPECIFIC_PARAMS, *PLINEAGENTSPECIFIC_PARAMS;
+
+
+typedef struct _LINEANSWER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwUserUserInfoOffset;       // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwSize;
+
+} LINEANSWER_PARAMS, *PLINEANSWER_PARAMS;
+
+
+typedef struct _LINEBLINDTRANSFER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwDestAddressOffset;        // always valid offset
+
+    IN  DWORD       dwCountryCode;
+
+} LINEBLINDTRANSFER_PARAMS, *PLINEBLINDTRANSFER_PARAMS;
+
+
+typedef struct _LINECLOSE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+} LINECLOSE_PARAMS, *PLINECLOSE_PARAMS;
+
+
+typedef struct _LINECOMPLETECALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       lpdwCompletionID;           // pointer to client buffer
+
+    IN  DWORD       dwCompletionMode;
+
+    IN  DWORD       dwMessageID;
+
+} LINECOMPLETECALL_PARAMS, *PLINECOMPLETECALL_PARAMS;
+
+
+typedef struct _LINECOMPLETETRANSFER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hCall;
+
+    IN  HCALL       hConsultCall;
+
+    IN  LPHCALL     lphConfCall;                // pointer to client buffer
+
+    IN  DWORD       dwTransferMode;
+
+} LINECOMPLETETRANSFER_PARAMS, *PLINECOMPLETETRANSFER_PARAMS;
+
+
+typedef struct _LINECONFIGDIALOG_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    IN  HWND        hwndOwner;
+
+    IN  DWORD       dwDeviceClassOffset;        // valid offset or TAPI_NO_DATA
+
+} LINECONFIGDIALOG_PARAMS, *PLINECONFIGDIALOG_PARAMS;
+
+
+typedef struct _LINECONFIGDIALOGEDIT_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    IN  HWND        hwndOwner;
+
+    IN  DWORD       dwDeviceClassOffset;        // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwDeviceConfigInOffset;     // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwDeviceConfigInSize;
+
+    union
+    {
+        IN  DWORD   dwDeviceConfigOutTotalSize; // size of client buffer
+
+        OUT DWORD   dwDeviceConfigOutOffset;    // valid offset on success
+    } u;
+
+} LINECONFIGDIALOGEDIT_PARAMS, *PLINECONFIGDIALOGEDIT_PARAMS;
+
+
+typedef struct _LINECONFIGPROVIDER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HWND        hwndOwner;
+
+    IN  DWORD       dwPermanentProviderID;
+
+} LINECONFIGPROVIDER_PARAMS, *PLINECONFIGPROVIDER_PARAMS;
+
+
+typedef struct _LINEDEALLOCATECALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+} LINEDEALLOCATECALL_PARAMS, *PLINEDEALLOCATECALL_PARAMS;
+
+
+typedef struct _LINEDEVSPECIFIC_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       lpParams;                   // pointer to client buffer
+
+    IN  DWORD       dwParamsOffset;             // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwParamsSize;
+
+} LINEDEVSPECIFIC_PARAMS, *PLINEDEVSPECIFIC_PARAMS;
+
+
+typedef struct _LINEDEVSPECIFICFEATURE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwFeature;
+
+    IN  DWORD       lpParams;                   // pointer to client buffer
+
+    IN  DWORD       dwParamsOffset;             // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwParamsSize;
+
+} LINEDEVSPECIFICFEATURE_PARAMS, *PLINEDEVSPECIFICFEATURE_PARAMS;
+
+
+typedef struct _LINEDIAL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwDestAddressOffset;        // always valid offset
+
+    IN  DWORD       dwCountryCode;
+
+} LINEDIAL_PARAMS, *PLINEDIAL_PARAMS;
+
+
+typedef struct _LINEDROP_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwUserUserInfoOffset;       // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwSize;
+
+} LINEDROP_PARAMS, *PLINEDROP_PARAMS;
+
+
+typedef struct _LINEFORWARD_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       bAllAddresses;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwForwardListOffset;        // always valid offset
+
+    IN  DWORD       dwNumRingsNoAnswer;
+
+    IN  LPHCALL     lphConsultCall;             // pointer to client buffer
+
+    IN  DWORD       dwCallParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwAsciiCallParamsCodePage;
+
+} LINEFORWARD_PARAMS, *PLINEFORWARD_PARAMS;
+
+
+typedef struct _LINEGATHERDIGITS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwDigitModes;
+
+    IN  DWORD       lpsDigits;                  // ptr to buf in client space
+
+    IN  DWORD       dwNumDigits;
+
+    IN  DWORD       dwTerminationDigitsOffset;  // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwFirstDigitTimeout;
+
+    IN  DWORD       dwInterDigitTimeout;
+
+} LINEGATHERDIGITS_PARAMS, *PLINEGATHERDIGITS_PARAMS;
+
+
+typedef struct _LINEGENERATEDIGITS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwDigitMode;
+
+    IN  DWORD       dwDigitsOffset;             // always valid offset
+
+    IN  DWORD       dwDuration;
+
+    IN  DWORD       dwEndToEndID;               // Used for remotesp only
+
+} LINEGENERATEDIGITS_PARAMS, *PLINEGENERATEDIGITS_PARAMS;
+
+
+typedef struct _LINEGENERATETONE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwToneMode;
+
+    IN  DWORD       dwDuration;
+
+    IN  DWORD       dwNumTones;
+
+    IN  DWORD       dwTonesOffset;              // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       _Unused_;                   // placeholder for following
+                                                //   Size arg on client side
+
+    IN  DWORD       dwEndToEndID;               // Used for remotesp only
+
+} LINEGENERATETONE_PARAMS, *PLINEGENERATETONE_PARAMS;
+
+
+typedef struct _LINEGETADDRESSCAPS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtVersion;
+
+    union
+    {
+        IN  DWORD   dwAddressCapsTotalSize;     // size of client buffer
+
+        OUT DWORD   dwAddressCapsOffset;        // valid offset on success
+    } u;
+
+} LINEGETADDRESSCAPS_PARAMS, *PLINEGETADDRESSCAPS_PARAMS;
+
+
+typedef struct _LINEGETADDRESSID_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    OUT DWORD       dwAddressID;
+
+    IN  DWORD       dwAddressMode;
+
+    IN  DWORD       dwAddressOffset;            // always valid offset
+
+    IN  DWORD       dwSize;
+
+} LINEGETADDRESSID_PARAMS, *PLINEGETADDRESSID_PARAMS;
+
+
+typedef struct _LINEGETADDRESSSTATUS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    union
+    {
+        IN  DWORD   dwAddressStatusTotalSize;   // size of client buffer
+
+        OUT DWORD   dwAddressStatusOffset;      // valid offset on success
+    } u;
+
+} LINEGETADDRESSSTATUS_PARAMS, *PLINEGETADDRESSSTATUS_PARAMS;
+
+
+typedef struct _LINEGETAGENTACTIVITYLIST_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       lpAgentActivityList;        // pointer to client buffer
+
+    IN  DWORD       dwActivityListTotalSize;
+
+} LINEGETAGENTACTIVITYLIST_PARAMS, *PLINEGETAGENTACTIVITYLIST_PARAMS;
+
+
+typedef struct _LINEGETAGENTCAPS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwAppAPIVersion;
+
+    IN  DWORD       lpAgentCaps;                // pointer to client buffer
+
+    IN  DWORD       dwAgentCapsTotalSize;
+
+} LINEGETAGENTCAPS_PARAMS, *PLINEGETAGENTCAPS_PARAMS;
+
+
+typedef struct _LINEGETAGENTGROUPLIST_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       lpAgentGroupList;           // pointer to client buffer
+
+    IN  DWORD       dwAgentGroupListTotalSize;
+
+} LINEGETAGENTGROUPLIST_PARAMS, *PLINEGETAGENTGROUPLIST_PARAMS;
+
+
+typedef struct _LINEGETAGENTSTATUS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       lpAgentStatus;              // pointer to client buffer
+
+    IN  DWORD       dwAgentStatusTotalSize;
+
+} LINEGETAGENTSTATUS_PARAMS, *PLINEGETAGENTSTATUS_PARAMS;
+
+
+typedef struct _LINEGETAPPPRIORITY_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwAppNameOffset;            // always valid offset
+
+    IN  DWORD       dwMediaMode;
+
+    IN  DWORD       dwExtensionIDOffset;        // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       _Unused_;                   // padding for Size type on
+                                                //   client side
+
+    IN  DWORD       dwRequestMode;
+
+    union
+    {
+        IN  DWORD   dwExtensionNameTotalSize;   // size of client buf or
+                                                //   TAPI_NO_DATA
+
+        OUT DWORD   dwExtensionNameOffset;      // valid offset or TAPI_NO_DATA
+                                                //   on success
+    } u;
+
+    OUT DWORD       dwPriority;
+
+} LINEGETAPPPRIORITY_PARAMS, *PLINEGETAPPPRIORITY_PARAMS;
+
+
+
+typedef struct _LINEGETCALLADDRESSID_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    OUT DWORD       dwAddressID;
+
+} LINEGETCALLADDRESSID_PARAMS, *PLINEGETCALLADDRESSID_PARAMS;
+
+
+typedef struct _LINEGETCALLINFO_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    union
+    {
+        IN  DWORD   dwCallInfoTotalSize;        // size of client buffer
+
+        OUT DWORD   dwCallInfoOffset;           // valid offset on success
+    } u;
+
+} LINEGETCALLINFO_PARAMS, *PLINEGETCALLINFO_PARAMS;
+
+
+typedef struct _LINEGETCALLSTATUS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    union
+    {
+        IN  DWORD   dwCallStatusTotalSize;      // size of client buffer
+
+        OUT DWORD   dwCallStatusOffset;         // valid offset on success
+    } u;
+
+} LINEGETCALLSTATUS_PARAMS, *PLINEGETCALLSTATUS_PARAMS;
+
+
+typedef struct _LINEGETCONFRELATEDCALLS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    union
+    {
+        IN  DWORD   dwCallListTotalSize;        // size of client buffer
+
+        OUT DWORD   dwCallListOffset;           // valid offset on success
+    } u;
+
+} LINEGETCONFRELATEDCALLS_PARAMS, *PLINEGETCONFRELATEDCALLS_PARAMS;
+
+
+typedef struct _LINEGETCOUNTRY_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwCountryID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwDestCountryID;
+
+    union
+    {
+        IN  DWORD   dwCountryListTotalSize;     // size of client buf
+
+        OUT DWORD   dwCountryListOffset;        // valid offset on success
+    } u;
+
+} LINEGETCOUNTRY_PARAMS, *PLINEGETCOUNTRY_PARAMS;
+
+
+typedef struct _LINEGETDEVCAPS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtVersion;
+
+    union
+    {
+        IN  DWORD   dwDevCapsTotalSize;         // size of client buffer
+
+        OUT DWORD   dwDevCapsOffset;            // valid offset on success
+    } u;
+
+} LINEGETDEVCAPS_PARAMS, *PLINEGETDEVCAPS_PARAMS;
+
+
+typedef struct _LINEGETDEVCONFIG_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    union
+    {
+        IN  DWORD   dwDeviceConfigTotalSize;    // size of client buffer
+
+        OUT DWORD   dwDeviceConfigOffset;       // valid offset on success
+    } u;
+
+    IN  DWORD   dwDeviceClassOffset;            // always valid offset
+
+} LINEGETDEVCONFIG_PARAMS, *PLINEGETDEVCONFIG_PARAMS;
+
+
+typedef struct _LINEGETICON_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwDeviceClassOffset;        // valid offset or TAPI_NO_DATA
+
+    OUT HICON       hIcon;
+
+} LINEGETICON_PARAMS, *PLINEGETICON_PARAMS;
+
+
+typedef struct _LINEGETID_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwSelect;
+
+    union
+    {
+        IN  DWORD   dwDeviceIDTotalSize;        // size of client buffer
+
+        OUT DWORD   dwDeviceIDOffset;           // valid offset on success
+    } u;
+
+    IN  DWORD       dwDeviceClassOffset;        // always valid offset
+
+} LINEGETID_PARAMS, *PLINEGETID_PARAMS;
+
+
+typedef struct _LINEGETLINEDEVSTATUS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    union
+    {
+        IN  DWORD   dwLineDevStatusTotalSize;   // size of client buffer
+
+        OUT DWORD   dwLineDevStatusOffset;      // valid offset on success
+    } u;
+
+    OUT DWORD       dwAPIVersion;
+
+} LINEGETLINEDEVSTATUS_PARAMS, *PLINEGETLINEDEVSTATUS_PARAMS;
+
+
+typedef struct _LINEGETNEWCALLS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwSelect;
+
+    union
+    {
+        IN  DWORD   dwCallListTotalSize;        // size of client buffer
+
+        OUT DWORD   dwCallListOffset;           // valid offset on success
+    } u;
+
+} LINEGETNEWCALLS_PARAMS, *PLINEGETNEWCALLS_PARAMS;
+
+
+typedef struct _LINEGETNUMADDRESSIDS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    OUT DWORD       dwNumAddresses;
+
+} LINEGETNUMADDRESSIDS_PARAMS, *PLINEGETNUMADDRESSIDS_PARAMS;
+
+
+typedef struct _LINEGETNUMRINGS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    OUT DWORD       dwNumRings;
+
+} LINEGETNUMRINGS_PARAMS, *PLINEGETNUMRINGS_PARAMS;
+
+
+typedef struct _LINEGETPROVIDERLIST_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwAPIVersion;
+
+    union
+    {
+        IN  DWORD   dwProviderListTotalSize;    // size of client buf
+
+        OUT DWORD   dwProviderListOffset;       // valid offset on success
+    } u;
+
+} LINEGETPROVIDERLIST_PARAMS, *PLINEGETPROVIDERLIST_PARAMS;
+
+
+typedef struct _LINEGETREQUEST_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwRequestMode;
+
+    OUT DWORD       dwRequestBufferOffset;      // valid offset on success
+
+    IN OUT  DWORD   dwSize;
+
+} LINEGETREQUEST_PARAMS, *PLINEGETREQUEST_PARAMS;
+
+
+typedef struct _LINEGETSTATUSMESSAGES_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    OUT DWORD       dwLineStates;
+
+    OUT DWORD       dwAddressStates;
+
+} LINEGETSTATUSMESSAGES_PARAMS, *PLINEGETSTATUSMESSAGES_PARAMS;
+
+
+//IN TAPI32.DLL now: typedef struct _LINEGETTRANSLATECAPS_PARAMS
+//IN TAPI32.DLL now: {
+//IN TAPI32.DLL now:     OUT LONG        lResult;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  PTCLIENT    ptClient;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  HLINEAPP    hLineApp;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwAPIVersion;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     union
+//IN TAPI32.DLL now:     {
+//IN TAPI32.DLL now:         IN  DWORD   dwTranslateCapsTotalSize;   // size of client buffer
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:         OUT DWORD   dwTranslateCapsOffset;      // valid offset on success
+//IN TAPI32.DLL now:     } u;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: } LINEGETTRANSLATECAPS_PARAMS, *PLINEGETTRANSLATECAPS_PARAMS;
+
+
+typedef struct _LINEHANDOFF_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwFileNameOffset;           // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwMediaMode;
+
+} LINEHANDOFF_PARAMS, *PLINEHANDOFF_PARAMS;
+
+
+typedef struct _LINEHOLD_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+} LINEHOLD_PARAMS, *PLINEHOLD_PARAMS;
+
+
+typedef struct _LINEINITIALIZE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    OUT HLINEAPP    hLineApp;
+
+    IN  HINSTANCE   hInstance;
+
+    IN  LINECALLBACK    lpfnCallback;
+
+    IN  DWORD       dwFriendlyNameOffset;       // always valid offset
+
+    OUT DWORD       dwNumDevs;
+
+    IN  DWORD       dwModuleNameOffset;         // always valid offset
+
+    IN  DWORD       dwAPIVersion;
+
+} LINEINITIALIZE_PARAMS, *PLINEINITIALIZE_PARAMS;
+
+
+typedef struct _LINEMAKECALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  LPHCALL     lphCall;                    // pointer to client buffer
+
+    IN  DWORD       dwDestAddressOffset;        // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwCountryCode;
+
+    IN  DWORD       dwCallParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwAsciiCallParamsCodePage;
+
+} LINEMAKECALL_PARAMS, *PLINEMAKECALL_PARAMS;
+
+
+typedef struct _LINEMONITORDIGITS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwDigitModes;
+
+} LINEMONITORDIGITS_PARAMS, *PLINEMONITORDIGITS_PARAMS;
+
+
+typedef struct _LINEMONITORMEDIA_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwMediaModes;
+
+} LINEMONITORMEDIA_PARAMS, *PLINEMONITORMEDIA_PARAMS;
+
+
+typedef struct _LINEMONITORTONES_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwTonesOffset;              // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwNumEntries;               // really dwNumEntries *
+                                                //   sizeof(LINEMONITORTONE)
+
+    IN  DWORD       dwToneListID;               // Used for remotesp only
+
+} LINEMONITORTONES_PARAMS, *PLINEMONITORTONES_PARAMS;
+
+
+typedef struct _LINENEGOTIATEAPIVERSION_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPILowVersion;
+
+    IN  DWORD       dwAPIHighVersion;
+
+    OUT DWORD       dwAPIVersion;
+
+    OUT DWORD       dwExtensionIDOffset;        // valid offset on success
+
+    IN OUT  DWORD   dwSize;
+
+} LINENEGOTIATEAPIVERSION_PARAMS, *PLINENEGOTIATEAPIVERSION_PARAMS;
+
+
+typedef struct _LINENEGOTIATEEXTVERSION_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtLowVersion;
+
+    IN  DWORD       dwExtHighVersion;
+
+    OUT DWORD       dwExtVersion;
+
+} LINENEGOTIATEEXTVERSION_PARAMS, *PLINENEGOTIATEEXTVERSION_PARAMS;
+
+
+typedef struct _LINEOPEN_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    OUT HLINE       hLine;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtVersion;
+
+    IN  DWORD       dwCallbackInstance;
+
+    IN  DWORD       dwPrivileges;
+
+    IN  DWORD       dwMediaModes;
+
+    IN  DWORD       dwCallParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwAsciiCallParamsCodePage;
+
+    //
+    // The following is a "remote line handle".  When the client is
+    // remotesp.tsp running on a remote machine, this will be some
+    // non-NULL value, and tapisrv should use this handle in status/etc
+    // indications to the client rather than the std hLine. If the
+    // client is not remote.tsp then this value will be NULL.
+    //
+
+    IN  HANDLE      hRemoteLine;
+
+} LINEOPEN_PARAMS, *PLINEOPEN_PARAMS;
+
+
+typedef struct _LINEPARK_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwParkMode;
+
+    IN  DWORD       dwDirAddressOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       lpNonDirAddress;            // pointer to client buffer
+
+    union
+    {
+        IN  DWORD   dwNonDirAddressTotalSize;   // size of client buffer
+
+        OUT DWORD   _Unused_;                   // for sync func would be
+                                                //   dwXxxOffset
+
+    } u;
+
+} LINEPARK_PARAMS, *PLINEPARK_PARAMS;
+
+
+typedef struct _LINEPICKUP_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  LPHCALL     lphCall;                    // pointer to client buffer
+
+    IN  DWORD       dwDestAddressOffset;        // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwGroupIDOffset;            // always valid offset
+
+} LINEPICKUP_PARAMS, *PLINEPICKUP_PARAMS;
+
+
+typedef struct _LINEPREPAREADDTOCONFERENCE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hConfCall;
+
+    IN  LPHCALL     lphConsultCall;             // pointer to client buffer
+
+    IN  DWORD       dwCallParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwAsciiCallParamsCodePage;
+
+} LINEPREPAREADDTOCONFERENCE_PARAMS, *PLINEPREPAREADDTOCONFERENCE_PARAMS;
+
+
+typedef struct _LINEPROXYMESSAGE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwMsg;
+
+    IN  DWORD       dwParam1;
+
+    IN  DWORD       dwParam2;
+
+    IN  DWORD       dwParam3;
+
+} LINEPROXYMESSAGE_PARAMS, *PLINEPROXYMESSAGE_PARAMS;
+
+
+typedef struct _LINEPROXYRESPONSE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwInstance;
+
+    IN  DWORD       dwProxyResponseOffset;      // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwResult;
+
+} LINEPROXYRESPONSE_PARAMS, *PLINEPROXYRESPONSE_PARAMS;
+
+
+typedef struct _LINEREDIRECT_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwDestAddressOffset;        // always valid offset
+
+    IN  DWORD       dwCountryCode;
+
+} LINEREDIRECT_PARAMS, *PLINEREDIRECT_PARAMS;
+
+
+typedef struct _LINEREGISTERREQUESTRECIPIENT_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+    IN  DWORD       dwRegistrationInstance;
+
+    IN  DWORD       dwRequestMode;
+
+    IN  DWORD       bEnable;
+
+} LINEREGISTERREQUESTRECIPIENT_PARAMS, *PLINEREGISTERREQUESTRECIPIENT_PARAMS;
+
+
+typedef struct _LINERELEASEUSERUSERINFO_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+} LINERELEASEUSERUSERINFO_PARAMS, *PLINERELEASEUSERUSERINFO_PARAMS;
+
+
+typedef struct _LINEREMOVEFROMCONFERENCE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+} LINEREMOVEFROMCONFERENCE_PARAMS, *PLINEREMOVEFROMCONFERENCE_PARAMS;
+
+
+typedef struct _LINEREMOVEPROVIDER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwPermanentProviderID;
+
+    IN  HWND        hwndOwner;
+
+} LINEREMOVEPROVIDER_PARAMS, *PLINEREMOVEPROVIDER_PARAMS;
+
+
+typedef struct _LINESECURECALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+} LINESECURECALL_PARAMS, *PLINESECURECALL_PARAMS;
+
+
+typedef struct _LINESENDUSERUSERINFO_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwUserUserInfoOffset;       // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwSize;
+
+} LINESENDUSERUSERINFO_PARAMS, *PLINESENDUSERUSERINFO_PARAMS;
+
+
+typedef struct _LINESETAGENTACTIVITY_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwActivityID;
+
+} LINESETAGENTACTIVITY_PARAMS, *PLINESETAGENTACTIVITY_PARAMS;
+
+
+typedef struct _LINESETAGENTGROUP_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwAgentGroupListOffset;
+
+} LINESETAGENTGROUP_PARAMS, *PLINESETAGENTGROUP_PARAMS;
+
+
+typedef struct _LINESETAGENTSTATE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwAgentState;
+
+    IN  DWORD       dwNextAgentState;
+
+} LINESETAGENTSTATE_PARAMS, *PLINESETAGENTSTATE_PARAMS;
+
+
+typedef struct _LINESETAPPPRIORITY_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwAppNameOffset;            // always valid offset
+
+    IN  DWORD       dwMediaMode;
+
+    IN  DWORD       dwExtensionIDOffset;        // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       _Unused_;                   // padding for Size type on
+                                                //   client side
+
+    IN  DWORD       dwRequestMode;
+
+    IN  DWORD       dwExtensionNameOffset;      // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwPriority;
+
+} LINESETAPPPRIORITY_PARAMS, *PLINESETAPPPRIORITY_PARAMS;
+
+
+typedef struct _LINESETAPPSPECIFIC_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwAppSpecific;
+
+} LINESETAPPSPECIFIC_PARAMS, *PLINESETAPPSPECIFIC_PARAMS;
+
+
+typedef struct _LINESETCALLDATA_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwCallDataOffset;           // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwCallDataSize;
+
+} LINESETCALLDATA_PARAMS, *PLINESETCALLDATA_PARAMS;
+
+
+typedef struct _LINESETCALLPARAMS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwBearerMode;
+
+    IN  DWORD       dwMinRate;
+
+    IN  DWORD       dwMaxRate;
+
+    IN  DWORD       dwDialParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       _Unused_;                   // placeholder for following
+                                                //   Size arg on client side
+
+} LINESETCALLPARAMS_PARAMS, *PLINESETCALLPARAMS_PARAMS;
+
+
+typedef struct _LINESETCALLPRIVILEGE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwPrivilege;
+
+} LINESETCALLPRIVILEGE_PARAMS, *PLINESETCALLPRIVILEGE_PARAMS;
+
+
+typedef struct _LINESETCALLQUALITYOFSERVICE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwSendingFlowspecOffset;    // always valid offset
+
+    IN  DWORD       dwSendingFlowspecSize;
+
+    IN  DWORD       dwReceivingFlowspecOffset;  // always valid offset
+
+    IN  DWORD       dwReceivingFlowspecSize;
+
+} LINESETCALLQUALITYOFSERVICE_PARAMS, *PLINESETCALLQUALITYOFSERVICE_PARAMS;
+
+
+typedef struct _LINESETCALLTREATMENT_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwTreatment;
+
+} LINESETCALLTREATMENT_PARAMS, *PLINESETCALLTREATMENT_PARAMS;
+
+
+//IN TAPI32.DLL now: typedef struct _LINESETCURRENTLOCATION_PARAMS
+//IN TAPI32.DLL now: {
+//IN TAPI32.DLL now:     OUT LONG        lResult;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  PTCLIENT    ptClient;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  HLINEAPP    hLineApp;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwLocation;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: } LINESETCURRENTLOCATION_PARAMS, *PLINESETCURRENTLOCATION_PARAMS;
+
+
+typedef struct _LINESETDEFAULTMEDIADETECTION_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwMediaModes;
+
+} LINESETDEFAULTMEDIADETECTION_PARAMS, *PLINESETDEFAULTMEDIADETECTION_PARAMS;
+
+
+typedef struct _LINESETDEVCONFIG_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwDeviceConfigOffset;       // always valid offset
+
+    IN  DWORD       dwSize;
+
+    IN  DWORD       dwDeviceClassOffset;        // always valid offset
+
+} LINESETDEVCONFIG_PARAMS, *PLINESETDEVCONFIG_PARAMS;
+
+
+typedef struct _LINESETLINEDEVSTATUS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwStatusToChange;
+
+    IN  DWORD       fStatus;
+
+} LINESETLINEDEVSTATUS_PARAMS, *PLINESETLINEDEVSTATUS_PARAMS;
+
+
+typedef struct _LINESETMEDIACONTROL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwSelect;
+
+    IN  DWORD       dwDigitListOffset;          // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwDigitListNumEntries;      // actually dwNumEntries *
+                                                // sizeof(LINEMEDIACONTROLDIGIT)
+
+    IN  DWORD       dwMediaListOffset;          // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwMediaListNumEntries;      // actually dwNumEntries *
+                                                // sizeof(LINEMEDIACONTROLMEDIA)
+
+    IN  DWORD       dwToneListOffset;           // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwToneListNumEntries;       // actually dwNumEntries *
+                                                // sizeof(LINEMEDIACONTROLTONE)
+
+    IN  DWORD       dwCallStateListOffset;      // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwCallStateListNumEntries;  // actually dwNumEntries *
+                                                // sizeof(LINEMEDIACONTROLCALLSTATE)
+
+} LINESETMEDIACONTROL_PARAMS, *PLINESETMEDIACONTROL_PARAMS;
+
+
+typedef struct _LINESETMEDIAMODE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwMediaModes;
+
+} LINESETMEDIAMODE_PARAMS, *PLINESETMEDIAMODE_PARAMS;
+
+
+typedef struct _LINESETNUMRINGS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  DWORD       dwNumRings;
+
+} LINESETNUMRINGS_PARAMS, *PLINESETNUMRINGS_PARAMS;
+
+
+typedef struct _LINESETSTATUSMESSAGES_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwLineStates;
+
+    IN  DWORD       dwAddressStates;
+
+} LINESETSTATUSMESSAGES_PARAMS, *PLINESETSTATUSMESSAGES_PARAMS;
+
+
+typedef struct _LINESETTERMINAL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  HCALL       hCall;
+
+    IN  DWORD       dwSelect;
+
+    IN  DWORD       dwTerminalModes;
+
+    IN  DWORD       dwTerminalID;
+
+    IN  DWORD       bEnable;
+
+} LINESETTERMINAL_PARAMS, *PLINESETTERMINAL_PARAMS;
+
+
+//IN TAPI32.DLL now: typedef struct _LINESETTOLLLIST_PARAMS
+//IN TAPI32.DLL now: {
+//IN TAPI32.DLL now:     OUT LONG        lResult;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  PTCLIENT    ptClient;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  HLINEAPP    hLineApp;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwDeviceID;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwAddressInOffset;          // always valid offset
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwTollListOption;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: } LINESETTOLLLIST_PARAMS, *PLINESETTOLLLIST_PARAMS;
+
+
+typedef struct _LINESETUPCONFERENCE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hCall;
+
+    IN  HLINE       hLine;
+
+    IN  LPHCALL     lphConfCall;                // pointer to client buffer
+
+    IN  LPHCALL     lphConsultCall;             // pointer to client buffer
+
+    IN  DWORD       dwNumParties;
+
+    IN  DWORD       dwCallParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwAsciiCallParamsCodePage;
+
+} LINESETUPCONFERENCE_PARAMS, *PLINESETUPCONFERENCE_PARAMS;
+
+
+typedef struct _LINESETUPTRANSFER_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HCALL       hCall;
+
+    IN  LPHCALL     lphConsultCall;             // pointer to client buffer
+
+    IN  DWORD       dwCallParamsOffset;         // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwAsciiCallParamsCodePage;
+
+} LINESETUPTRANSFER_PARAMS, *PLINESETUPTRANSFER_PARAMS;
+
+
+typedef struct _LINESHUTDOWN_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HLINEAPP    hLineApp;
+
+} LINESHUTDOWN_PARAMS, *PLINESHUTDOWN_PARAMS;
+
+
+typedef struct _LINESWAPHOLD_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hActiveCall;
+
+    IN  HCALL       hHeldCall;
+
+} LINESWAPHOLD_PARAMS, *PLINESWAPHOLD_PARAMS;
+
+
+//IN TAPI32.DLL now: typedef struct _LINETRANSLATEADDRESS_PARAMS
+//IN TAPI32.DLL now: {
+//IN TAPI32.DLL now:     OUT LONG        lResult;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  PTCLIENT    ptClient;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  HLINEAPP    hLineApp;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwDeviceID;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwAPIVersion;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwAddressInOffset;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwCard;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwTranslateOptions;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     union
+//IN TAPI32.DLL now:     {
+//IN TAPI32.DLL now:         IN  DWORD   dwTranslateOutputTotalSize; // size of client buffer
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:         OUT DWORD   dwTranslateOutputOffset;    // valid offset or TAPI_NO_DATA
+//IN TAPI32.DLL now:                                                 //   on success
+//IN TAPI32.DLL now:     } u;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: } LINETRANSLATEADDRESS_PARAMS, *PLINETRANSLATEADDRESS_PARAMS;
+
+
+//IN TAPI32.DLL now: typedef struct _LINETRANSLATEDIALOG_PARAMS
+//IN TAPI32.DLL now: {
+//IN TAPI32.DLL now:     OUT LONG        lResult;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  PTCLIENT    ptClient;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  HLINEAPP    hLineApp;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwDeviceID;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwAPIVersion;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  HWND        hwndOwner;
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now:     IN  DWORD       dwAddressInOffset;          // valid offset or TAPI_NO_DATA
+//IN TAPI32.DLL now: 
+//IN TAPI32.DLL now: } LINETRANSLATEDIALOG_PARAMS, *PLINETRANSLATEDIALOG_PARAMS;
+
+
+typedef struct _LINEUNCOMPLETECALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwCompletionID;
+
+} LINEUNCOMPLETECALL_PARAMS, *PLINEUNCOMPLETECALL_PARAMS;
+
+
+typedef struct _LINEUNHOLD_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HCALL       hCall;
+
+} LINEUNHOLD_PARAMS, *PLINEUNHOLD_PARAMS;
+
+
+typedef struct _LINEUNPARK_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HLINE       hLine;
+
+    IN  DWORD       dwAddressID;
+
+    IN  LPHCALL     lphCall;                    // pointer to client buffer
+
+    IN  DWORD       dwDestAddressOffset;        // always valid offset
+
+} LINEUNPARK_PARAMS, *PLINEUNPARK_PARAMS;
+
+
+
+typedef struct
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+    IN  DWORD       dwhLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwParmsToCheckFlags;
+
+    union
+    {
+        IN  DWORD   dwLocationsTotalSize;         // size of client buffer
+
+        OUT DWORD   dwLocationsOffset;            // valid offset on success
+    } u;
+
+} R_LOCATIONS_PARAMS, *PR_LOCATIONS_PARAMS;
+
+
+typedef struct
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+    IN  UINT        nNumLocations;
+
+    IN  DWORD       dwChangedFlags;
+    
+    IN  DWORD       dwCurrentLocationID;
+
+
+    IN  DWORD       dwhLineApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwParmsToCheckFlags;
+
+    union
+    {
+        IN  DWORD   dwLocationsTotalSize;         // size of client buffer
+
+        OUT DWORD   dwLocationsOffset;            // valid offset on success
+    } u;
+
+} W_LOCATIONS_PARAMS, *PW_LOCATIONS_PARAMS;
+
+
+typedef struct
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+    union
+    {
+        IN  DWORD   hKeyToUse;
+
+        OUT DWORD   dwNewID;
+    } u;
+
+} ALLOCNEWID_PARAMS, *P_ALLOCNEWID_PARAMS;
+
+
+typedef struct
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+    IN  DWORD       dwCookie;
+
+    union
+    {
+        IN  DWORD   dwPerformanceTotalSize;         // size of client buffer
+
+        OUT DWORD   dwLocationsOffset;            // valid offset on success
+    } u;
+
+} PERFORMANCE_PARAMS, *PPERFORMANCE_PARAMS;
+
+
diff --git a/private/tapi/dev/server/makefile b/private/tapi/dev/server/makefile
new file mode 100644
index 000000000..68867704a
--- /dev/null
+++ b/private/tapi/dev/server/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/server/makefile.def b/private/tapi/dev/server/makefile.def
new file mode 100644
index 000000000..d0cec18f1
--- /dev/null
+++ b/private/tapi/dev/server/makefile.def
@@ -0,0 +1,69 @@
+##############################################################################
+#
+#   TapiSrv Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+#VERSIONLIST=debug retail
+
+#!ifdef RETAIL
+#DEFAULTVERDIR=retail
+#!else
+#DEFAULTVERDIR=debug
+#!endif
+
+
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+DEFENTRY=main
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=tapisrv
+TARGETS=tapisrv.exe tapisrv.sym
+
+SRCDIR=..
+#OBJDIR=obj\i386
+
+#BUILD_COFF=1
+
+
+L32EXE=tapisrv.exe		# Name of exe.
+L32DEF=..\tapisrv.def              # Our def file.
+L32MAP=tapisrv.map		# Our map file.
+L32LIBS=$(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\shell32.lib                  \
+        $(W32LIBID)\comctl32.lib                \
+        $(W32LIBID)\advapi32.lib                \
+        $(ROOT)\dev\tools\c932\lib\rpcndr.lib   \
+        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib
+#        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+
+L32RES=server.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = server.obj line.obj phone.obj dial.obj tapsrv_s.obj \
+          rmotsp_c.obj  tapi.obj
+
+
+L32FLAGS=$(L32FLAGS) /PDB:tapisrv.pdb /MAP:tapisrv.map
+
+!include $(ROOT)\dev\master.mk
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Og
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/server/phone.c b/private/tapi/dev/server/phone.c
new file mode 100644
index 000000000..abd19f6e2
--- /dev/null
+++ b/private/tapi/dev/server/phone.c
@@ -0,0 +1,5013 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    phone.c
+
+Abstract:
+
+    Src module for tapi server phone funcs
+
+Author:
+
+    Dan Knudson (DanKn)    01-Apr-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "assert.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "..\client\client.h"
+#include "server.h"
+#include "phone.h"
+
+
+extern TAPIGLOBALS TapiGlobals;
+extern CRITICAL_SECTION gSafeMutexCritSec,
+                        gRequestIDCritSec;
+
+#if DBG
+char *
+PASCAL
+MapResultCodeToText(
+    LONG    lResult,
+    char   *pszResult
+    );
+#endif
+
+void
+DestroytPhoneClient(
+    PTPHONECLIENT   ptPhoneClient
+    );
+
+BOOL
+IsAPIVersionInRange(
+    DWORD   dwAPIVersion,
+    DWORD   dwSPIVersion
+    );
+
+BOOL
+InitTapiStruct(
+    LPVOID  pTapiStruct,
+    DWORD   dwTotalSize,
+    DWORD   dwFixedSize,
+    BOOL    bZeroInit
+    );
+
+void
+PASCAL
+SendMsgToPhoneClients(
+    PTPHONE         ptPhone,
+    PTPHONECLIENT   ptPhoneClienttoExclude,
+    DWORD           dwMsg,
+    DWORD           dwParam1,
+    DWORD           dwParam2,
+    DWORD           dwParam3
+    );
+
+PTPHONE
+PASCAL
+WaitForExclusivetPhoneAccess(
+    HTAPIPHONE  htPhone,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    );
+
+void
+PASCAL
+SendReinitMsgToAllXxxApps(
+    void
+    );
+
+PTCLIENT
+PASCAL
+WaitForExclusiveClientAccess(
+    PTCLIENT    ptClient,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    );
+
+void
+CALLBACK
+CompletionProcSP(
+    DWORD   dwRequestID,
+    LONG    lResult
+    );
+
+void
+PASCAL
+SendAMsgToAllPhoneApps(
+    DWORD dwWantVersion,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    );
+
+
+PTPHONELOOKUPENTRY
+GetPhoneLookupEntry(
+    DWORD   dwDeviceID
+    )
+{
+    DWORD               dwDeviceIDBase = 0;
+    PTPHONELOOKUPTABLE  pLookupTable = TapiGlobals.pPhoneLookup;
+
+
+    if (dwDeviceID >= TapiGlobals.dwNumPhones)
+    {
+        return ((PTPHONELOOKUPENTRY) NULL);
+    }
+
+    while (pLookupTable)
+    {
+        if (dwDeviceID < pLookupTable->dwNumTotalEntries)
+        {
+            return (pLookupTable->aEntries + dwDeviceID);
+        }
+
+        dwDeviceID -= pLookupTable->dwNumTotalEntries;
+
+        pLookupTable = pLookupTable->pNext;
+    }
+
+    return ((PTPHONELOOKUPENTRY) NULL);
+}
+
+
+BOOL
+PASCAL
+IsValidPhoneExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwExtVersion
+    )
+{
+    BOOL                bResult;
+    PTPHONE             ptPhone;
+    PTPROVIDER          ptProvider;
+    PTPHONELOOKUPENTRY  pLookupEntry;
+
+
+    if (dwExtVersion == 0)
+    {
+        return TRUE;
+    }
+
+    if (!(pLookupEntry = GetPhoneLookupEntry (dwDeviceID)))
+    {
+        return FALSE;
+    }
+
+    ptPhone = pLookupEntry->ptPhone;
+
+    if (ptPhone)
+    {
+        try
+        {
+            if (ptPhone->dwExtVersionCount)
+            {
+                bResult = (dwExtVersion == ptPhone->dwExtVersion ?
+                    TRUE : FALSE);
+
+                if (ptPhone->dwKey == TPHONE_KEY)
+                {
+                    goto IsValidPhoneExtVersion_return;
+                }
+            }
+
+        }
+        myexcept
+        {
+            //
+            // if here the phone was closed, just drop thru to the code below
+            //
+        }
+    }
+
+    ptProvider = pLookupEntry->ptProvider;
+
+    if (ptProvider->apfn[SP_PHONENEGOTIATEEXTVERSION])
+    {
+        LONG    lResult;
+        DWORD   dwNegotiatedExtVersion;
+
+
+        lResult = CallSP5(
+            ptProvider->apfn[SP_PHONENEGOTIATEEXTVERSION],
+            "lineNegotiateExtVersion",
+            SP_FUNC_SYNC,
+            (DWORD) dwDeviceID,
+            (DWORD) pLookupEntry->dwSPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) &dwNegotiatedExtVersion
+            );
+
+        bResult = ((lResult || !dwNegotiatedExtVersion) ? FALSE : TRUE);
+    }
+    else
+    {
+        bResult = FALSE;
+    }
+
+IsValidPhoneExtVersion_return:
+
+    return bResult;
+}
+
+
+PTPHONEAPP
+PASCAL
+IsValidPhoneApp(
+    HPHONEAPP   hPhoneApp,
+    PTCLIENT    ptClient
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (hPhoneApp, TPHONEAPP_KEY) ||
+            (*( ((LPDWORD) hPhoneApp) + 1) != (DWORD) ptClient))
+        {
+            hPhoneApp = (HPHONEAPP) 0;
+        }
+    }
+    myexcept
+    {
+        hPhoneApp = (HPHONEAPP) 0;
+    }
+
+    return ((PTPHONEAPP) hPhoneApp);
+}
+
+
+LONG
+PASCAL
+ValidateButtonInfo(
+    LPPHONEBUTTONINFO   pButtonInfoApp,
+    LPPHONEBUTTONINFO  *ppButtonInfoSP,
+    DWORD               dwAPIVersion,
+    DWORD               dwSPIVersion
+    )
+{
+    //
+    // This routine checks the fields in a PHONEBUTTONINFO struct,
+    // looking for invalid bit flags and making sure that the
+    // various size/offset pairs only reference data within the
+    // variable-data portion of the structure. Also, if the
+    // specified SPI version is greater than the API version and
+    // the fixed structure size differs between the two versions,
+    // a larger buffer is allocated, the var data is relocated,
+    // and the sizeof/offset pairs are patched.
+    //
+
+#if DBG
+    char    szFunc[] = "ValidateButtonInfo";
+#endif
+    DWORD   dwTotalSize = pButtonInfoApp->dwTotalSize, dwFixedSizeApp,
+            dwFixedSizeSP;
+
+
+    switch (dwAPIVersion)
+    {
+    case TAPI_VERSION1_0:
+
+        dwFixedSizeApp = 36;    // 9 * sizeof (DWORD)
+        break;
+
+    case TAPI_VERSION1_4:
+    case TAPI_VERSION_CURRENT:
+
+        dwFixedSizeApp = sizeof (PHONEBUTTONINFO);
+        break;
+
+    default:
+
+        return PHONEERR_INVALPHONEHANDLE;
+    }
+
+    switch (dwSPIVersion)
+    {
+    case TAPI_VERSION1_0:
+
+        dwFixedSizeSP = 36;     // 9 * sizeof (DWORD)
+        break;
+
+    case TAPI_VERSION1_4:
+    case TAPI_VERSION_CURRENT:
+
+        dwFixedSizeSP = sizeof (PHONEBUTTONINFO);
+        break;
+
+    default:
+
+        return PHONEERR_INVALPHONEHANDLE;
+    }
+
+    if (dwTotalSize < dwFixedSizeApp)
+    {
+        DBGOUT((
+            3,
+            "%sbad dwTotalSize, x%x (minimum valid size=x%x)",
+            szFunc,
+            dwTotalSize,
+            dwFixedSizeApp
+            ));
+
+        return PHONEERR_STRUCTURETOOSMALL;
+    }
+
+// BUGBUG ValidateButtonInfo: validate dwButtonMode, dwButtonFunction fields
+
+    if (ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pButtonInfoApp->dwButtonTextSize,
+            pButtonInfoApp->dwButtonTextOffset,
+            szFunc,
+            "ButtonText"
+            ) ||
+
+        ISBADSIZEOFFSET(
+            dwTotalSize,
+            dwFixedSizeApp,
+            pButtonInfoApp->dwDevSpecificSize,
+            pButtonInfoApp->dwDevSpecificOffset,
+            szFunc,
+            "DevSpecific"
+            ))
+    {
+        return PHONEERR_OPERATIONFAILED;
+    }
+
+    if (dwAPIVersion < TAPI_VERSION1_4)
+    {
+        goto ValidateButtonInfo_checkFixedSizes;
+    }
+
+// BUGBUG ValidateButtonInfo: validate dwButtonState field
+
+ValidateButtonInfo_checkFixedSizes:
+
+    if (dwFixedSizeApp < dwFixedSizeSP)
+    {
+        DWORD               dwFixedSizeDiff = dwFixedSizeSP - dwFixedSizeApp;
+        LPPHONEBUTTONINFO   pButtonInfoSP;
+
+
+        if (!(pButtonInfoSP = ServerAlloc (dwTotalSize + dwFixedSizeDiff)))
+        {
+            return PHONEERR_NOMEM;
+        }
+
+        CopyMemory (pButtonInfoSP, pButtonInfoApp, dwFixedSizeApp);
+
+        pButtonInfoSP->dwTotalSize = dwTotalSize + dwFixedSizeDiff;
+
+        CopyMemory(
+            ((LPBYTE) pButtonInfoSP) + dwFixedSizeSP,
+            ((LPBYTE) pButtonInfoApp) + dwFixedSizeApp,
+            dwTotalSize - dwFixedSizeApp
+            );
+
+        pButtonInfoSP->dwButtonTextOffset  += dwFixedSizeDiff;
+        pButtonInfoSP->dwDevSpecificOffset += dwFixedSizeDiff;
+
+        *ppButtonInfoSP = pButtonInfoSP;
+    }
+    else
+    {
+        *ppButtonInfoSP = pButtonInfoApp;
+    }
+
+//bjm 03/19 - not used - ValidateButtonInfo_return:
+
+    return 0; // success
+
+}
+
+
+void
+DestroytPhone(
+    PTPHONE ptPhone,
+    BOOL    bUnconditional
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    DBGOUT((3, "DestroytPhone: enter, ptPhone=x%x", ptPhone));
+
+    if (WaitForExclusivetPhoneAccess(
+            (HTAPIPHONE) ptPhone,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        //
+        // If the key is bad another thread is in the process of
+        // destroying this widget, so just release the mutex &
+        // return. Otherwise, if this is a conditional destroy
+        // & there are existing clients (which can happen when
+        // one app is closing the last client just as another app
+        // is creating one) just release the mutex & return.
+        // Otherwise, mark the widget as bad and proceed with
+        // the destroy.
+        //
+
+        {
+            BOOL bExit;
+
+
+            if (ptPhone->dwKey == TPHONE_KEY &&
+                (bUnconditional == TRUE  ||  ptPhone->ptPhoneClients == NULL))
+            {
+                SendMsgToPhoneClients (ptPhone, NULL, PHONE_CLOSE, 0, 0, 0);
+                ptPhone->dwKey = INVAL_KEY;
+                bExit = FALSE;
+            }
+            else
+            {
+                bExit = TRUE;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+
+            if (bExit)
+            {
+                return;
+            }
+        }
+
+
+        //
+        // Destroy all the widget's clients.  Note that we want to
+        // grab the mutex (and we don't have to dup it, since this
+        // thread will be the one to close it) each time we reference
+        // the list of clients, since another thread might be
+        // destroying a client too.
+        //
+
+        {
+            PTPHONECLIENT ptPhoneClient;
+
+
+            hMutex = ptPhone->hMutex;
+
+destroy_tPhoneClients:
+
+            WaitForSingleObject (hMutex, INFINITE);
+
+            ptPhoneClient = ptPhone->ptPhoneClients;
+
+            ReleaseMutex (hMutex);
+
+            if (ptPhoneClient)
+            {
+                DestroytPhoneClient (ptPhoneClient);
+                goto destroy_tPhoneClients;
+            }
+        }
+
+
+        //
+        // Tell the provider to close the widget
+        //
+
+        {
+            PTPROVIDER  ptProvider = ptPhone->ptProvider;
+
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                WaitForSingleObject (ptProvider->hMutex, INFINITE);
+            }
+
+            CallSP1(
+                ptProvider->apfn[SP_PHONECLOSE],
+                "phoneClose",
+                SP_FUNC_SYNC,
+                (DWORD) ptPhone->hdPhone
+                );
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                ReleaseMutex (ptProvider->hMutex);
+            }
+        }
+
+
+        //
+        // NULLify the ptPhone field in the lookup entry, so POpen will
+        // know it has to open the SP's phone on the next open request
+        //
+
+        {
+            PTPHONELOOKUPENTRY   pEntry;
+
+
+            pEntry = GetPhoneLookupEntry (ptPhone->dwDeviceID);
+
+// BUGBUG DestroytPhone: wrap in mutex (pEntry->ptPhone = NULL)
+
+            pEntry->ptPhone = NULL;
+        }
+
+        ServerFree (ptPhone);
+    }
+}
+
+
+void
+DestroytPhoneClient(
+    PTPHONECLIENT   ptPhoneClient
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    DBGOUT((3, "DestroytPhoneClient: enter, ptPhoneClient=x%x",ptPhoneClient));
+
+    if (WaitForMutex(
+            ptPhoneClient->hMutex,
+            &hMutex,
+            &bCloseMutex,
+            ptPhoneClient,
+            TPHONECLIENT_KEY,
+            INFINITE
+            ))
+    {
+        PTPHONE ptPhone;
+
+
+        //
+        // If the key is bad another thread is in the process of
+        // destroying this widget, so just release the mutex &
+        // return. Otherwise, mark the widget as bad, release
+        // the mutex, and continue on.
+        //
+
+        {
+            BOOL    bExit;
+
+
+            if (ptPhoneClient->dwKey == TPHONECLIENT_KEY)
+            {
+                ptPhoneClient->dwKey = INVAL_KEY;
+
+                bExit = FALSE;
+            }
+            else
+            {
+                bExit = TRUE;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+
+            if (bExit)
+            {
+                return;
+            }
+        }
+
+
+        //
+        // Remove tPhoneClient from tPhoneApp's list.  Note that we don't
+        // have to worry about dup-ing the mutex here because we know
+        // it's valid & won't get closed before we release it.
+        //
+
+        {
+            PTPHONEAPP  ptPhoneApp = (PTPHONEAPP) ptPhoneClient->ptPhoneApp;
+
+
+            WaitForSingleObject (ptPhoneApp->hMutex, INFINITE);
+
+            if (ptPhoneClient->pNextSametPhoneApp)
+            {
+                ptPhoneClient->pNextSametPhoneApp->pPrevSametPhoneApp =
+                    ptPhoneClient->pPrevSametPhoneApp;
+            }
+
+            if (ptPhoneClient->pPrevSametPhoneApp)
+            {
+                ptPhoneClient->pPrevSametPhoneApp->pNextSametPhoneApp =
+                    ptPhoneClient->pNextSametPhoneApp;
+            }
+            else
+            {
+                ptPhoneApp->ptPhoneClients = ptPhoneClient->pNextSametPhoneApp;
+            }
+
+            ReleaseMutex (ptPhoneApp->hMutex);
+        }
+
+
+        //
+        // Remove tPhoneClient from tPhone's list.  Note that we don't
+        // have to worry about dup-ing the mutex here because we know
+        // it's valid & won't get closed before we release it.
+        //
+
+        ptPhone = ptPhoneClient->ptPhone;
+
+        hMutex = ptPhone->hMutex;
+
+        WaitForSingleObject (hMutex, INFINITE);
+
+        {
+            //
+            // Also check for ext ver stuff
+            //
+
+            if (ptPhoneClient->dwExtVersion)
+            {
+                if ((--ptPhone->dwExtVersionCount) == 0)
+                {
+                    CallSP2(
+                        ptPhone->ptProvider->apfn[SP_PHONESELECTEXTVERSION],
+                        "phoneSelectExtVersion",
+                        SP_FUNC_SYNC,
+                        (DWORD) ptPhone->hdPhone,
+                        (DWORD) 0
+                        );
+
+                    ptPhone->dwExtVersion = 0;
+                }
+            }
+        }
+
+        if (ptPhoneClient->pNextSametPhone)
+        {
+            ptPhoneClient->pNextSametPhone->pPrevSametPhone =
+                ptPhoneClient->pPrevSametPhone;
+        }
+
+        if (ptPhoneClient->pPrevSametPhone)
+        {
+            ptPhoneClient->pPrevSametPhone->pNextSametPhone =
+                ptPhoneClient->pNextSametPhone;
+        }
+        else
+        {
+            ptPhone->ptPhoneClients = ptPhoneClient->pNextSametPhone;
+        }
+
+
+        //
+        // Decrement tPhone's NumOwners/Monitors as appropriate
+        //
+
+        if (ptPhoneClient->dwPrivilege == PHONEPRIVILEGE_OWNER)
+        {
+            ptPhone->dwNumOwners--;
+        }
+        else
+        {
+            ptPhone->dwNumMonitors--;
+        }
+
+
+        //
+        //
+        //
+
+        if (ptPhone->dwKey == TPHONE_KEY)
+        {
+            if (ptPhone->ptPhoneClients)
+            {
+                SendMsgToPhoneClients(
+                    ptPhone,
+                    NULL,
+                    PHONE_STATE,
+                    (ptPhoneClient->dwPrivilege == PHONEPRIVILEGE_OWNER ?
+                        PHONESTATE_OWNER : PHONESTATE_MONITORS),
+                    (ptPhoneClient->dwPrivilege == PHONEPRIVILEGE_OWNER ?
+                        0 : ptPhone->dwNumMonitors),
+                    0
+                    );
+            }
+            else
+            {
+                //
+                // This was the last client so destroy the tPhone too
+                //
+
+                ReleaseMutex (hMutex);
+                hMutex = NULL;
+                DestroytPhone (ptPhone, FALSE); // conditional destroy
+            }
+        }
+
+        if (hMutex)
+        {
+            ReleaseMutex (hMutex);
+        }
+
+
+        //
+        //
+        //
+
+        WaitForMutex(
+            ptPhoneClient->hMutex,
+            &hMutex,
+            &bCloseMutex,
+            NULL,
+            0,
+            INFINITE
+            );
+
+        if (bCloseMutex)
+        {
+            CloseHandle (ptPhoneClient->hMutex);
+            ReleaseMutex (hMutex);
+            CloseHandle (hMutex);
+        }
+        else
+        {
+            EnterCriticalSection (&gSafeMutexCritSec);
+
+            ReleaseMutex (hMutex);
+            CloseHandle (hMutex);
+
+            LeaveCriticalSection (&gSafeMutexCritSec);
+        }
+
+        ServerFree (ptPhoneClient);
+    }
+}
+
+
+void
+DestroytPhoneApp(
+    PTPHONEAPP  ptPhoneApp
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    DBGOUT((3, "DestroytPhoneApp: enter, ptPhoneApp=x%x", ptPhoneApp));
+
+    if (WaitForMutex(
+            ptPhoneApp->hMutex,
+            &hMutex,
+            &bCloseMutex,
+            ptPhoneApp,
+            TPHONEAPP_KEY,
+            INFINITE
+            ))
+    {
+        //
+        // If the key is bad another thread is in the process of
+        // destroying this widget, so just release the mutex &
+        // return. Otherwise, mark the widget as bad, release
+        // the mutex, and continue on.
+        //
+
+
+        {
+            BOOL    bExit;
+
+
+            if (ptPhoneApp->dwKey == TPHONEAPP_KEY)
+            {
+                ptPhoneApp->dwKey = INVAL_KEY;
+
+                bExit = FALSE;
+            }
+            else
+            {
+                bExit = TRUE;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+
+            if (bExit)
+            {
+                return;
+            }
+        }
+
+
+        //
+        // Destroy all the tPhoneClients.  Note that we want to grab the
+        // mutex (and we don't have to dup it, since this thread will be
+        // the one to close it) each time we reference the list of
+        // tPhoneClient's, since another thread might be destroying a
+        // tPhoneClient too.
+        //
+
+        {
+            PTPHONECLIENT   ptPhoneClient;
+
+
+            hMutex = ptPhoneApp->hMutex;
+
+destroy_tPhoneClients:
+
+            WaitForSingleObject (hMutex, INFINITE);
+
+            ptPhoneClient = ptPhoneApp->ptPhoneClients;
+
+            ReleaseMutex (hMutex);
+
+            if (ptPhoneClient)
+            {
+                DestroytPhoneClient (ptPhoneClient);
+                goto destroy_tPhoneClients;
+            }
+        }
+
+
+        //
+        // Remove ptPhoneApp from tClient's list. Note that we don't
+        // have to worry about dup-ing the mutex here because we know
+        // it's valid & won't get closed before we release it.
+        //
+
+        {
+            PTCLIENT    ptClient = (PTCLIENT) ptPhoneApp->ptClient;
+
+
+            WaitForSingleObject (ptClient->hMutex, INFINITE);
+
+            if (ptPhoneApp->pNext)
+            {
+                ptPhoneApp->pNext->pPrev = ptPhoneApp->pPrev;
+            }
+
+            if (ptPhoneApp->pPrev)
+            {
+                ptPhoneApp->pPrev->pNext = ptPhoneApp->pNext;
+            }
+            else
+            {
+                ptClient->ptPhoneApps = ptPhoneApp->pNext;
+            }
+
+            ReleaseMutex (ptClient->hMutex);
+        }
+
+
+        //
+        // Decrement total num inits & see if we need to go thru shutdown
+        //
+
+        WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+        //assert(TapiGlobals.dwNumLineInits != 0);
+
+        TapiGlobals.dwNumPhoneInits--;
+
+        if ((TapiGlobals.dwNumLineInits == 0) &&
+            (TapiGlobals.dwNumPhoneInits == 0))
+        {
+            ServerShutdown();
+        }
+
+        ReleaseMutex (TapiGlobals.hMutex);
+
+
+        //
+        // Free the resources
+        //
+
+        CloseHandle (ptPhoneApp->hMutex);
+
+        ServerFree (ptPhoneApp);
+    }
+}
+
+
+LONG
+PASCAL
+PhoneProlog(
+    PTCLIENT    ptClient,
+    DWORD       dwArgType,
+    DWORD       dwArg,
+    LPVOID      phdXxx,
+    DWORD       dwPrivilege,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTSPIFuncIndex,
+    FARPROC    *ppfnTSPI_phoneXxx,
+    PASYNCREQUESTINFO  *ppAsyncRequestInfo,
+    DWORD       dwRemoteRequestID
+#if DBG
+    ,char      *pszFuncName
+#endif
+    )
+{
+    LONG        lResult = 0;
+    PTPROVIDER  ptProvider;
+
+
+    DBGOUT((3, "PhoneProlog: (phone%s) enter", pszFuncName));
+
+    *phMutex = NULL;
+    *pbDupedMutex = FALSE;
+
+    if (ppAsyncRequestInfo)
+    {
+        *ppAsyncRequestInfo = (PASYNCREQUESTINFO) NULL;
+    }
+
+    if (TapiGlobals.dwNumPhoneInits == 0)
+    {
+        lResult = PHONEERR_UNINITIALIZED;
+        goto PhoneProlog_return;
+    }
+
+    switch (dwArgType)
+    {
+    case ANY_RT_HPHONE:
+    {
+        try
+        {
+            PTPHONECLIENT   ptPhoneClient = (PTPHONECLIENT) dwArg;
+
+
+            if (IsBadPtrKey (ptPhoneClient, TPHONECLIENT_KEY) ||
+                (ptPhoneClient->ptClient != ptClient))
+            {
+                lResult = PHONEERR_INVALPHONEHANDLE;
+                goto PhoneProlog_return;
+            }
+
+            ptProvider = ptPhoneClient->ptPhone->ptProvider;
+
+            if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+            {
+                if (!WaitForMutex(
+                        ptProvider->hMutex,
+                        phMutex,
+                        pbDupedMutex,
+                        ptProvider,
+                        TPROVIDER_KEY,
+                        INFINITE
+                        ))
+                {
+                    lResult = PHONEERR_OPERATIONFAILED;
+                    goto PhoneProlog_return;
+                }
+            }
+
+            *((HDRVPHONE *) phdXxx) = ptPhoneClient->ptPhone->hdPhone;
+
+            if (ptPhoneClient->dwPrivilege < dwPrivilege)
+            {
+                lResult = PHONEERR_NOTOWNER;
+                goto PhoneProlog_return;
+            }
+
+            if ((ptPhoneClient->dwKey != TPHONECLIENT_KEY) ||
+                (ptPhoneClient->ptClient != ptClient))
+            {
+                lResult = PHONEERR_INVALPHONEHANDLE;
+                goto PhoneProlog_return;
+            }
+        }
+        myexcept
+        {
+            lResult = PHONEERR_INVALPHONEHANDLE;
+            goto PhoneProlog_return;
+        }
+
+        break;
+    }
+    case DEVICE_ID:
+    {
+        PTPHONELOOKUPENTRY  pPhoneLookupEntry;
+
+
+        if (dwArg && !IsValidPhoneApp ((HPHONEAPP) dwArg, ptClient))
+        {
+            lResult = PHONEERR_INVALAPPHANDLE;
+            goto PhoneProlog_return;
+        }
+
+        if (!(pPhoneLookupEntry = GetPhoneLookupEntry (dwPrivilege)))
+        {
+            lResult = PHONEERR_BADDEVICEID;
+            goto PhoneProlog_return;
+        }
+
+        if (pPhoneLookupEntry->bRemoved)
+        {
+            lResult = PHONEERR_NODEVICE;
+            goto PhoneProlog_return;
+        }
+
+        if (!(ptProvider = pPhoneLookupEntry->ptProvider))
+        {
+            lResult = PHONEERR_NODRIVER;
+            goto PhoneProlog_return;
+        }
+
+// BUGBUG wrap in try/except
+
+        if (ptProvider->dwTSPIOptions & LINETSPIOPTION_NONREENTRANT)
+        {
+            if (!WaitForMutex(
+                    ptProvider->hMutex,
+                    phMutex,
+                    pbDupedMutex,
+                    ptProvider,
+                    TPROVIDER_KEY,
+                    INFINITE
+                    ))
+            {
+                lResult = PHONEERR_OPERATIONFAILED;
+                goto PhoneProlog_return;
+            }
+        }
+
+        break;
+    }
+    } // switch
+
+
+    //
+    // Make sure that if caller wants a pointer to a TSPI proc that the
+    // func is exported by the provider
+    //
+
+    if (ppfnTSPI_phoneXxx &&
+        !(*ppfnTSPI_phoneXxx = ptProvider->apfn[dwTSPIFuncIndex]))
+    {
+        lResult = PHONEERR_OPERATIONUNAVAIL;
+        goto PhoneProlog_return;
+    }
+
+
+    //
+    // See if we need to alloc & init an ASYNCREQUESTINFO struct
+    //
+
+    if (ppAsyncRequestInfo)
+    {
+        PTPHONECLIENT       ptPhoneClient = (PTPHONECLIENT) dwArg;
+        PASYNCREQUESTINFO   pAsyncRequestInfo;
+
+
+        if (!(pAsyncRequestInfo = ServerAlloc (sizeof(ASYNCREQUESTINFO))))
+        {
+            lResult = PHONEERR_NOMEM;
+            goto PhoneProlog_return;
+        }
+
+        pAsyncRequestInfo->dwKey          = TASYNC_KEY;
+        pAsyncRequestInfo->ptClient       = ptClient;
+        pAsyncRequestInfo->pInitData      =
+            (DWORD) ((PTPHONEAPP) ptPhoneClient->ptPhoneApp)->lpfnCallback;
+        pAsyncRequestInfo->dwCallbackInst = ptPhoneClient->dwCallbackInstance;
+        pAsyncRequestInfo->bLineFunc      = FALSE;
+
+        if (dwRemoteRequestID)
+        {
+            lResult = pAsyncRequestInfo->dwRequestID = dwRemoteRequestID;
+        }
+        else
+        {
+            EnterCriticalSection (&gRequestIDCritSec);
+
+            lResult =
+            pAsyncRequestInfo->dwRequestID = TapiGlobals.dwAsyncRequestID;
+
+            if (++TapiGlobals.dwAsyncRequestID & 0x80000000)
+            {
+                TapiGlobals.dwAsyncRequestID = 1;
+            }
+
+            LeaveCriticalSection (&gRequestIDCritSec);
+        }
+
+        *ppAsyncRequestInfo = pAsyncRequestInfo;
+    }
+
+PhoneProlog_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "PhoneProlog: (phone%s) exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (lResult, szResult)
+            ));
+    }
+#endif
+
+    return lResult;
+}
+
+
+void
+PASCAL
+PhoneEpilogSync(
+    LONG   *plResult,
+    HANDLE  hMutex,
+    BOOL    bCloseMutex
+#if DBG
+    ,char *pszFuncName
+#endif
+    )
+{
+    MyReleaseMutex (hMutex, bCloseMutex);
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "PhoneEpilogSync: (phone%s) exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (*plResult, szResult)
+            ));
+    }
+#endif
+}
+
+
+void
+PASCAL
+PhoneEpilogAsync(
+    LONG   *plResult,
+    LONG    lRequestID,
+    HANDLE  hMutex,
+    BOOL    bCloseMutex,
+    PASYNCREQUESTINFO pAsyncRequestInfo
+#if DBG
+    ,char *pszFuncName
+#endif
+    )
+{
+    MyReleaseMutex (hMutex, bCloseMutex);
+
+
+    if (lRequestID > 0)
+    {
+        if (*plResult != (LONG) pAsyncRequestInfo)
+        {
+            //
+            // If here the service provider returned an error (or 0,
+            // which it never should for async requests), so call
+            // CompletionProcSP like the service provider normally
+            // would, & the worker thread will take care of sending
+            // the client a REPLY msg with the request result (we'll
+            // return an async request id)
+            //
+
+            CompletionProcSP ((DWORD) pAsyncRequestInfo, *plResult);
+        }
+    }
+    else
+    {
+        //
+        // If here an error occured before we even called the service
+        // provider, so just free the async request (the error will
+        // be returned to the client synchronously)
+        //
+
+        ServerFree (pAsyncRequestInfo);
+    }
+
+    *plResult = lRequestID;
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "PhoneEpilogSync: (phone%s) exit, result=%s",
+            pszFuncName,
+            MapResultCodeToText (lRequestID, szResult)
+            ));
+    }
+#endif
+}
+
+
+PTPHONE
+PASCAL
+WaitForExclusivetPhoneAccess(
+    HTAPIPHONE  htPhone,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    )
+{
+    try
+    {
+        if (!IsBadPtrKey (htPhone, TPHONE_KEY) &&
+
+            WaitForMutex(
+                ((PTPHONE) htPhone)->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) htPhone,
+                TPHONE_KEY,
+                INFINITE
+                ))
+        {
+            if (((PTPHONE) htPhone)->dwKey == TPHONE_KEY)
+            {
+                return ((PTPHONE) htPhone);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+PTPHONEAPP
+PASCAL
+WaitForExclusivePhoneAppAccess(
+    HPHONEAPP   hPhoneApp,
+    PTCLIENT    ptClient,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    DWORD       dwTimeout
+    )
+{
+    try
+    {
+        if (IsBadPtrKey (hPhoneApp, TPHONEAPP_KEY))
+        {
+            return NULL;
+        }
+
+        if (WaitForMutex(
+                ((PTPHONEAPP) hPhoneApp)->hMutex,
+                phMutex,
+                pbDupedMutex,
+                (LPVOID) hPhoneApp,
+                TPHONEAPP_KEY,
+                dwTimeout
+                ))
+        {
+            if (((PTPHONEAPP) hPhoneApp)->dwKey == TPHONEAPP_KEY  &&
+                ((PTPHONEAPP) hPhoneApp)->ptClient == ptClient)
+            {
+                return ((PTPHONEAPP) hPhoneApp);
+            }
+
+            MyReleaseMutex (*phMutex, *pbDupedMutex);
+        }
+
+    }
+    myexcept
+    {
+        // do nothing
+    }
+
+    return NULL;
+}
+
+
+LONG
+PASCAL
+GetPhoneAppListFromClient(
+    PTCLIENT        ptClient,
+    PTPOINTERLIST  *ppList
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusiveClientAccess(
+            ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                        dwNumUsedEntries = 0;
+        PTPHONEAPP      ptPhoneApp = ptClient->ptPhoneApps;
+        PTPOINTERLIST   pList = *ppList;
+
+
+        while (ptPhoneApp)
+        {
+            if (dwNumUsedEntries == dwNumTotalEntries)
+            {
+                //
+                // We need a larger list, so alloc a new one, copy the
+                // contents of the current one, and the free the current
+                // one iff we previously alloc'd it
+                //
+
+                PTPOINTERLIST   pNewList;
+
+
+                dwNumTotalEntries <<= 1;
+
+                if (!(pNewList = ServerAlloc(
+                        sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                            (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                        )))
+                {
+                    MyReleaseMutex (hMutex, bCloseMutex);
+                    return LINEERR_NOMEM;
+                }
+
+                CopyMemory(
+                    pNewList->aEntries,
+                    pList->aEntries,
+                    dwNumUsedEntries * sizeof (LPVOID)
+                    );
+
+                if (pList != *ppList)
+                {
+                    ServerFree (pList);
+                }
+
+                pList = pNewList;
+            }
+
+            pList->aEntries[dwNumUsedEntries++] = ptPhoneApp;
+
+            ptPhoneApp = ptPhoneApp->pNext;
+        }
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+
+        pList->dwNumUsedEntries = dwNumUsedEntries;
+
+        *ppList = pList;
+    }
+    else
+    {
+        return PHONEERR_OPERATIONFAILED;
+    }
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+GetPhoneClientListFromPhone(
+    PTPHONE         ptPhone,
+    PTPOINTERLIST  *ppList
+    )
+{
+    BOOL    bDupedMutex;
+    HANDLE  hMutex;
+
+
+    if (WaitForExclusivetPhoneAccess(
+            (HTAPIPHONE) ptPhone,
+            &hMutex,
+            &bDupedMutex,
+            INFINITE
+            ))
+    {
+        DWORD           dwNumTotalEntries = DEF_NUM_PTR_LIST_ENTRIES,
+                        dwNumUsedEntries = 0;
+        PTPOINTERLIST   pList = *ppList;
+        PTPHONECLIENT   ptPhoneClient = ptPhone->ptPhoneClients;
+
+
+        while (ptPhoneClient)
+        {
+            if (dwNumUsedEntries == dwNumTotalEntries)
+            {
+                //
+                // We need a larger list, so alloc a new one, copy the
+                // contents of the current one, and the free the current
+                // one iff we previously alloc'd it
+                //
+
+                PTPOINTERLIST   pNewList;
+
+
+                dwNumTotalEntries <<= 1;
+
+                if (!(pNewList = ServerAlloc(
+                        sizeof (TPOINTERLIST) + sizeof (LPVOID) *
+                            (dwNumTotalEntries - DEF_NUM_PTR_LIST_ENTRIES)
+                        )))
+                {
+                    MyReleaseMutex (hMutex, bDupedMutex);
+                    return LINEERR_NOMEM;
+                }
+
+                CopyMemory(
+                    pNewList->aEntries,
+                    pList->aEntries,
+                    dwNumUsedEntries * sizeof (LPVOID)
+                    );
+
+                if (pList != *ppList)
+                {
+                    ServerFree (pList);
+                }
+
+                pList = pNewList;
+            }
+
+            pList->aEntries[dwNumUsedEntries++] = ptPhoneClient;
+
+            ptPhoneClient = ptPhoneClient->pNextSametPhone;
+        }
+
+        MyReleaseMutex (hMutex, bDupedMutex);
+
+        pList->dwNumUsedEntries = dwNumUsedEntries;
+
+        *ppList = pList;
+    }
+    else
+    {
+        return PHONEERR_INVALPHONEHANDLE;
+    }
+
+    return 0;
+}
+
+
+void
+PASCAL
+SendMsgToPhoneClients(
+    PTPHONE         ptPhone,
+    PTPHONECLIENT   ptPhoneClientToExclude,
+    DWORD           dwMsg,
+    DWORD           dwParam1,
+    DWORD           dwParam2,
+    DWORD           dwParam3
+    )
+{
+    DWORD           i;
+    TPOINTERLIST    clientList, *pClientList = &clientList;
+    ASYNCEVENTMSG   msg;
+
+
+    if (dwMsg == PHONE_STATE  &&  dwParam1 & PHONESTATE_REINIT)
+    {
+        SendReinitMsgToAllXxxApps();
+
+        if (dwParam1 == PHONESTATE_REINIT)
+        {
+            return;
+        }
+        else
+        {
+            dwParam1 &= ~PHONESTATE_REINIT;
+        }
+    }
+
+    if (GetPhoneClientListFromPhone (ptPhone, &pClientList) != 0)
+    {
+        return;
+    }
+
+    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+    msg.pfnPostProcessProc = 0;
+    msg.dwMsg              = dwMsg;
+    msg.dwParam1           = dwParam1;
+    msg.dwParam2           = dwParam2;
+    msg.dwParam3           = dwParam3;
+
+    for (i = 0; i < pClientList->dwNumUsedEntries; i++)
+    {
+        try
+        {
+            PTCLIENT        ptClient;
+            PTPHONECLIENT   ptPhoneClient = pClientList->aEntries[i];
+
+
+            if (ptPhoneClient == ptPhoneClientToExclude)
+            {
+                continue;
+            }
+
+            if (dwMsg == PHONE_STATE)
+            {
+                DWORD           dwPhoneStates = dwParam1;
+
+
+                //
+                // Munge the state flags so we don't pass
+                // unexpected flags to old apps
+                //
+
+                switch (ptPhoneClient->dwAPIVersion)
+                {
+                case TAPI_VERSION1_0:
+
+                    dwPhoneStates &= AllPhoneStates1_0;
+                    break;
+
+                default: // case TAPI_VERSION1_4:
+                         // case TAPI_VERSION_CURRENT:
+
+                    dwPhoneStates &= AllPhoneStates1_4;
+                    break;
+                }
+
+                if (dwParam1 & PHONESTATE_CAPSCHANGE)
+                {
+// BUGBUG send REINIT to 1_0 apps (dwParam3 = dwParam1)
+                }
+
+                if (ptPhoneClient->dwPhoneStates & dwPhoneStates)
+                {
+                    msg.dwParam1 = dwPhoneStates;
+                }
+                else
+                {
+                    continue;
+                }
+            }
+            else if (dwMsg == PHONE_BUTTON)
+            {
+                DWORD           dwButtonModes = dwParam2,
+                                dwButtonStates = dwParam3;
+
+
+                //
+                // Munge the state flags so we don't pass
+                // unexpected flags to old apps
+                //
+
+                switch (ptPhoneClient->dwAPIVersion)
+                {
+                case TAPI_VERSION1_0:
+
+                    dwButtonStates &= AllButtonStates1_0;
+                    break;
+
+                default:    // case TAPI_VERSION1_4:
+                            // case TAPI_VERSION_CURRENT:
+
+                    dwButtonStates &= AllButtonStates1_4;
+                    break;
+                }
+
+                dwButtonStates &= ptPhoneClient->dwButtonStates;
+
+                if ((dwButtonModes &= ptPhoneClient->dwButtonModes) ||
+                    dwButtonStates)
+                {
+                    msg.dwParam2 = dwButtonModes;
+                    msg.dwParam3 = dwButtonStates;
+                }
+                else
+                {
+                    continue;
+                }
+            }
+
+            msg.pInitData         = (DWORD)
+                ((PTPHONEAPP) ptPhoneClient->ptPhoneApp)->lpfnCallback;
+            msg.hDevice           = (DWORD) ptPhoneClient->hRemotePhone;
+            msg.dwCallbackInst    = ptPhoneClient->dwCallbackInstance;
+
+            ptClient = ptPhoneClient->ptClient;
+
+            if (ptPhoneClient->dwKey == TPHONECLIENT_KEY)
+            {
+                WriteEventBuffer (ptClient, &msg);
+            }
+        }
+        myexcept
+        {
+            // just continue
+        }
+    }
+
+    if (pClientList != &clientList)
+    {
+        ServerFree (pClientList);
+    }
+}
+
+
+void
+PASCAL
+PhoneEventProc(
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    switch (dwMsg)
+    {
+    case PHONE_CLOSE:
+
+        DestroytPhone ((PTPHONE) htPhone, TRUE); // unconditional destroy
+        break;
+
+    case PHONE_DEVSPECIFIC:
+    case PHONE_STATE:
+    case PHONE_BUTTON:
+
+        SendMsgToPhoneClients(
+            (PTPHONE) htPhone,
+            NULL,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        break;
+
+    case PHONE_CREATE:
+    {
+        LONG                lResult;
+        DWORD               dwDeviceID;
+        TSPIPROC            pfnTSPI_providerCreatePhoneDevice;
+        PTPROVIDER          ptProvider = (PTPROVIDER) dwParam1;
+        PTPHONELOOKUPTABLE  pTable, pPrevTable;
+        PTPHONELOOKUPENTRY  pEntry;
+
+
+        pfnTSPI_providerCreatePhoneDevice =
+                ptProvider->apfn[SP_PROVIDERCREATEPHONEDEVICE];
+
+        assert (pfnTSPI_providerCreatePhoneDevice != NULL);
+
+
+        //
+        // Search for a table entry (create a new table if we can't find
+        // a free entry in an existing table)
+        //
+
+        WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+        pTable = pPrevTable = TapiGlobals.pPhoneLookup;
+
+        while (pTable &&
+               !(pTable->dwNumUsedEntries < pTable->dwNumTotalEntries))
+        {
+            pPrevTable = pTable;
+
+            pTable = pTable->pNext;
+        }
+
+        if (!pTable)
+        {
+            if (!(pTable = ServerAlloc(
+                    sizeof (TPHONELOOKUPTABLE) +
+                        (2 * pPrevTable->dwNumTotalEntries - 1) *
+                        sizeof (TPHONELOOKUPENTRY)
+                    )))
+            {
+                ReleaseMutex (TapiGlobals.hMutex);
+                break;
+            }
+
+            pPrevTable->pNext = pTable;
+
+            pTable->dwNumTotalEntries = 2 * pPrevTable->dwNumTotalEntries;
+        }
+
+
+        //
+        // Initialize the table entry
+        //
+
+        pEntry = pTable->aEntries + pTable->dwNumUsedEntries;
+
+        dwDeviceID = TapiGlobals.dwNumPhones;
+
+        if ((pEntry->hMutex = MyCreateMutex()))
+        {
+            pEntry->ptProvider = (PTPROVIDER) dwParam1;
+
+
+            //
+            // Now call the creation & negotiation entrypoints, and if all
+            // goes well increment the counts & send msgs to the clients
+            //
+
+            if ((lResult = CallSP2(
+                    pfnTSPI_providerCreatePhoneDevice,
+                    "providerCreatePhoneDevice",
+                    SP_FUNC_SYNC,
+                    dwParam2,
+                    dwDeviceID
+
+                    )) == 0)
+            {
+                TSPIPROC    pfnTSPI_phoneNegotiateTSPIVersion =
+                                ptProvider->apfn[SP_PHONENEGOTIATETSPIVERSION];
+
+
+                if ((lResult = CallSP4(
+                        pfnTSPI_phoneNegotiateTSPIVersion,
+                        "",
+                        SP_FUNC_SYNC,
+                        dwDeviceID,
+                        TAPI_VERSION1_0,
+                        TAPI_VERSION_CURRENT,
+                        (DWORD) &pEntry->dwSPIVersion
+
+                        )) == 0)
+                {
+                    PTCLIENT        ptClient = TapiGlobals.ptClients;
+                    ASYNCEVENTMSG   msg;
+
+
+                    pTable->dwNumUsedEntries++;
+
+                    TapiGlobals.dwNumPhones++;
+
+                    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+                    msg.pfnPostProcessProc =
+                    msg.hDevice            =
+                    msg.dwCallbackInst     =
+                    msg.dwParam2           =
+                    msg.dwParam3           = 0;
+
+                    while (ptClient)
+                    {
+// BUGBUG WaitForSingleObject (ptClient->hMutex,
+
+                        PTPHONEAPP  ptPhoneApp = ptClient->ptPhoneApps;
+
+
+                        while (ptPhoneApp)
+                        {
+                            if (ptPhoneApp->dwAPIVersion == TAPI_VERSION1_0)
+                            {
+                                msg.dwMsg    = PHONE_STATE;
+                                msg.dwParam1 = PHONESTATE_REINIT;
+                            }
+                            else
+                            {
+                                msg.dwMsg    = PHONE_CREATE;
+                                msg.dwParam1 = dwDeviceID;
+                            }
+
+                            msg.pInitData = (DWORD) ptPhoneApp->lpfnCallback;
+
+                            WriteEventBuffer (ptClient, &msg);
+
+                            ptPhoneApp = ptPhoneApp->pNext;
+                        }
+
+                        ptClient = ptClient->pNext;
+                    }
+
+//                    break;
+                }
+            }
+
+            if (lResult)
+            {
+                CloseHandle (pEntry->hMutex);
+            }
+        }
+
+        ReleaseMutex (TapiGlobals.hMutex);
+        break;
+    }
+    case PHONE_REMOVE:
+    {
+        PTPHONELOOKUPENTRY pLookupEntry;
+
+
+        if (!(pLookupEntry = GetPhoneLookupEntry (dwParam1)))
+        {
+            return;
+        }
+
+
+        //
+        // Mark the lookup table entry as removed
+        //
+
+        pLookupEntry->bRemoved = 1;
+
+        DestroytPhone (pLookupEntry->ptPhone, TRUE); // unconditional destroy
+
+        SendAMsgToAllPhoneApps (TAPI_VERSION2_0, PHONE_REMOVE, dwParam1, 0, 0);
+
+        break;
+    }
+    default:
+
+        DBGOUT((3, "PhoneEventProc: unknown msg, dwMsg=%ld", dwMsg));
+        break;
+    }
+}
+
+
+void
+CALLBACK
+PhoneEventProcSP(
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    PSPEVENT    pSPEvent;
+
+    DBGOUT((
+        3,
+        "PhoneEventProc: enter\n\thtPhone=x%lx, Msg=x%lx\n" \
+            "\tP1=x%lx, P2=x%lx, P3=x%lx",
+        htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        ));
+
+    if ((pSPEvent = (PSPEVENT) ServerAlloc (sizeof (SPEVENT))))
+    {
+        pSPEvent->dwType   = SP_PHONE_EVENT;
+        pSPEvent->htPhone  = htPhone;
+        pSPEvent->dwMsg    = dwMsg;
+        pSPEvent->dwParam1 = dwParam1;
+        pSPEvent->dwParam2 = dwParam2;
+        pSPEvent->dwParam3 = dwParam3;
+
+        QueueSPEvent (pSPEvent);
+    }
+    else
+    {
+        //
+        // Alloc failed, so call the event proc within the SP's context
+        //
+
+        PhoneEventProc (htPhone, dwMsg, dwParam1, dwParam2, dwParam3);
+    }
+}
+
+void
+WINAPI
+PClose(
+    PPHONECLOSE_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneClose;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "Close"                     // func name
+
+            )) == 0)
+    {
+        DestroytPhoneClient ((PTPHONECLIENT) pParams->hPhone);
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "Close"
+        );
+}
+
+
+void
+PDevSpecific_PostProcess(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    PASYNCEVENTMSG      pAsyncEventMsg,
+    LPVOID             *ppBuf
+    )
+{
+    PASYNCEVENTMSG  pNewAsyncEventMsg = (PASYNCEVENTMSG)
+                        pAsyncRequestInfo->dwParam3;
+
+
+    CopyMemory (pNewAsyncEventMsg, pAsyncEventMsg, sizeof (ASYNCEVENTMSG));
+
+    *ppBuf = pNewAsyncEventMsg;
+
+    if (pAsyncEventMsg->dwParam2 == 0)  // success
+    {
+        //
+        // Make sure to keep the total size 64-bit aligned
+        //
+
+        pNewAsyncEventMsg->dwTotalSize +=
+            (pAsyncRequestInfo->dwParam2 + 7) & 0xfffffff8;
+
+        pNewAsyncEventMsg->dwParam3 = pAsyncRequestInfo->dwParam1; // lpParams
+        pNewAsyncEventMsg->dwParam4 = pAsyncRequestInfo->dwParam2; // dwSize
+    }
+}
+
+
+void
+WINAPI
+PDevSpecific(
+    PPHONEDEVSPECIFIC_PARAMS    pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneDevSpecific;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEDEVSPECIFIC,        // provider func index
+            &pfnTSPI_phoneDevSpecific,  // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "DevSpecific"               // func name
+
+            )) > 0)
+    {
+        LPBYTE pBuf = (LPBYTE) ServerAlloc (pParams->dwParamsSize);
+
+
+        //
+        // Alloc a shadow buf that the SP can use until it completes this
+        // request.  Make sure there's enough extra space in the buf for
+        // an ASYNCEVENTMSG header so we don't have to alloc yet another
+        // buf in the post processing proc when preparing the completion
+        // msg to send to the client, and that the msg is 64-bit aligned.
+        //
+
+        if (!(pBuf = ServerAlloc(
+                ((pParams->dwParamsSize + 7) & 0xfffffff8) +
+                    sizeof (ASYNCEVENTMSG)
+                )))
+        {
+            lRequestID = PHONEERR_NOMEM;
+            goto PDevSpecific_epilog;
+        }
+
+        CopyMemory(
+            pBuf + sizeof (ASYNCEVENTMSG),
+            pDataBuf + pParams->dwParamsOffset,
+            pParams->dwParamsSize
+            );
+
+        pAsyncRequestInfo->pfnPostProcess = PDevSpecific_PostProcess;
+        pAsyncRequestInfo->dwParam1       = (DWORD) pParams->lpParams;
+        pAsyncRequestInfo->dwParam2       = pParams->dwParamsSize;
+        pAsyncRequestInfo->dwParam3       = (DWORD) pBuf;
+
+        pAsyncRequestInfo->pfnClientPostProcessProc =
+            pParams->pfnPostProcessProc;
+
+        pParams->lResult = CallSP4(
+            pfnTSPI_phoneDevSpecific,
+            "phoneDevSpecific",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdPhone,
+            (DWORD) (pParams->dwParamsSize ?
+                pBuf + sizeof (ASYNCEVENTMSG) : NULL),
+            (DWORD) pParams->dwParamsSize
+            );
+    }
+
+PDevSpecific_epilog:
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "DevSpecific"
+        );
+}
+
+
+void
+WINAPI
+PGetButtonInfo(
+    PPHONEGETBUTTONINFO_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetButtonInfo;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETBUTTONINFO,      // provider func index
+            &pfnTSPI_phoneGetButtonInfo,// provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetButtonInfo"             // func name
+
+            )) == 0)
+    {
+        DWORD               dwAPIVersion, dwSPIVersion, dwTotalSize,
+                            dwFixedSizeClient, dwFixedSizeSP;
+        LPPHONEBUTTONINFO   pButtonInfo = (LPPHONEBUTTONINFO) pDataBuf,
+                            pButtonInfo2 = (LPPHONEBUTTONINFO) NULL;
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwAPIVersion = ((PTPHONECLIENT) pParams->hPhone)->dwAPIVersion;
+
+        dwTotalSize = pParams->u.dwButtonInfoTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwFixedSizeClient = 0x24;
+            break;
+
+        default: // case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (PHONEBUTTONINFO);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = PHONEERR_STRUCTURETOOSMALL;
+            goto PGetButtonInfo_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        dwSPIVersion = ((PTPHONECLIENT)
+            pParams->hPhone)->ptPhone->dwSPIVersion;
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+
+            dwFixedSizeSP = 0x24;
+            break;
+
+        default: // case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (PHONEBUTTONINFO);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pButtonInfo2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = PHONEERR_NOMEM;
+                goto PGetButtonInfo_epilog;
+            }
+
+            pButtonInfo = pButtonInfo2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pButtonInfo,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pButtonInfo2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_phoneGetButtonInfo,
+                "phoneGetButtonInfo",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwButtonLampID,
+                (DWORD) pButtonInfo
+
+                )) == 0)
+        {
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+            //
+            // Add the fields we're responsible for
+            //
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pButtonInfo == pButtonInfo2)
+            {
+                pButtonInfo = (LPPHONEBUTTONINFO) pDataBuf;
+
+                CopyMemory (pButtonInfo, pButtonInfo2, dwFixedSizeClient);
+
+                ServerFree (pButtonInfo2);
+
+                pButtonInfo->dwTotalSize = pParams->u.dwButtonInfoTotalSize;
+                pButtonInfo->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwButtonInfoOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pButtonInfo->dwUsedSize;
+        }
+    }
+
+PGetButtonInfo_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetButtonInfo"
+        );
+}
+
+
+void
+WINAPI
+PGetData(
+    PPHONEGETDATA_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetData;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETDATA,            // provider func index
+            &pfnTSPI_phoneGetData,      // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetData"                   // func name
+
+            )) == 0)
+    {
+        if ((pParams->lResult = CallSP4(
+                pfnTSPI_phoneGetData,
+                "phoneGetData",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwDataID,
+                (DWORD) pDataBuf,
+                (DWORD) pParams->dwSize
+
+                )) == 0)
+        {
+            //
+            // Indicate offset & how many bytes of data we're passing back
+            //
+
+            pParams->dwDataOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pParams->dwSize;
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetData"
+        );
+}
+
+
+void
+WINAPI
+PGetDevCaps(
+    PPHONEGETDEVCAPS_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwDeviceID = pParams->dwDeviceID;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_phoneGetDevCaps;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hPhoneApp, // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETDEVCAPS,         // provider func index
+            &pfnTSPI_phoneGetDevCaps,   // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetDevCaps"                // func name
+
+            )) == 0)
+    {
+        DWORD       dwAPIVersion, dwSPIVersion, dwTotalSize,
+                    dwFixedSizeClient, dwFixedSizeSP;
+        LPPHONECAPS pCaps = (LPPHONECAPS) pDataBuf,
+                    pCaps2 = (LPPHONECAPS) NULL;
+
+
+        //
+        // Verify API & SPI version compatibility
+        //
+
+        dwAPIVersion = pParams->dwAPIVersion;
+
+        dwSPIVersion =
+            (GetPhoneLookupEntry (dwDeviceID))->dwSPIVersion;
+
+        if (!IsAPIVersionInRange (dwAPIVersion, dwSPIVersion))
+        {
+            pParams->lResult = PHONEERR_INCOMPATIBLEAPIVERSION;
+            goto PGetDevCaps_epilog;
+        }
+
+
+        //
+        // Verify Ext version compatibility
+        //
+
+        if (!IsValidPhoneExtVersion (dwDeviceID, pParams->dwExtVersion))
+        {
+            pParams->lResult = PHONEERR_INCOMPATIBLEEXTVERSION;
+            goto PGetDevCaps_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwTotalSize = pParams->u.dwPhoneCapsTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 144;    // 36 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (PHONECAPS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = PHONEERR_STRUCTURETOOSMALL;
+            goto PGetDevCaps_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP =  144;       // 36 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (PHONECAPS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pCaps2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = PHONEERR_NOMEM;
+                goto PGetDevCaps_epilog;
+            }
+
+            pCaps       = pCaps2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pCaps,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pCaps2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP4(
+                pfnTSPI_phoneGetDevCaps,
+                "phoneGetDevCaps",
+                SP_FUNC_SYNC,
+                (DWORD) dwDeviceID,
+                (DWORD) dwAPIVersion,
+                (DWORD) pParams->dwExtVersion,
+                (DWORD) pCaps
+
+                )) == 0)
+        {
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+
+            //
+            // Add the fields we're responsible for
+            //
+
+            pCaps->dwPhoneStates |= PHONESTATE_OWNER |
+                                    PHONESTATE_MONITORS |
+                                    PHONESTATE_REINIT;
+
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pCaps == pCaps2)
+            {
+                pCaps = (LPPHONECAPS) pDataBuf;
+
+                CopyMemory (pCaps, pCaps2, dwFixedSizeClient);
+
+                ServerFree (pCaps2);
+
+                pCaps->dwTotalSize = pParams->u.dwPhoneCapsTotalSize;
+                pCaps->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwPhoneCapsOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pCaps->dwUsedSize;
+        }
+    }
+
+PGetDevCaps_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetDevCaps"
+        );
+}
+
+
+void
+WINAPI
+PGetDisplay(
+    PPHONEGETDISPLAY_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetDisplay;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETDISPLAY,         // provider func index
+            &pfnTSPI_phoneGetDisplay,   // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetDisplay"                // func name
+
+            )) == 0)
+    {
+        LPVARSTRING pDisplay = (LPVARSTRING) pDataBuf;
+
+
+        if (!InitTapiStruct(
+                pDisplay,
+                pParams->u.dwDisplayTotalSize,
+                sizeof (VARSTRING),
+                TRUE
+                ))
+        {
+            pParams->lResult = PHONEERR_STRUCTURETOOSMALL;
+            goto PGetDisplay_epilog;
+        }
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_phoneGetDisplay,
+                "phoneGetDisplay",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) pDisplay
+
+                )) == 0)
+        {
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+            //
+            // Indicate how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDisplayOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pDisplay->dwUsedSize;
+        }
+    }
+
+PGetDisplay_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetDisplay"
+        );
+}
+
+
+void
+WINAPI
+PGetGain(
+    PPHONEGETGAIN_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetGain;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETGAIN,            // provider func index
+            &pfnTSPI_phoneGetGain,      // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetGain"                   // func name
+
+            )) == 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwHookSwitchDev) ||
+            (pParams->dwHookSwitchDev & ~AllHookSwitchDevs))
+        {
+            pParams->lResult = PHONEERR_INVALHOOKSWITCHDEV;
+        }
+        else
+        {
+            if ((pParams->lResult = CallSP3(
+                    pfnTSPI_phoneGetGain,
+                    "phoneGetGain",
+                    SP_FUNC_SYNC,
+                    (DWORD) hdPhone,
+                    (DWORD) pParams->dwHookSwitchDev,
+                    (DWORD) &pParams->dwGain
+
+                    )) == 0)
+            {
+                *pdwNumBytesReturned = sizeof (PHONEGETGAIN_PARAMS);
+            }
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetGain"
+        );
+}
+
+
+void
+WINAPI
+PGetHookSwitch(
+    PPHONEGETHOOKSWITCH_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetHookSwitch;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETHOOKSWITCH,      // provider func index
+            &pfnTSPI_phoneGetHookSwitch,// provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetHookSwitch"             // func name
+
+            )) == 0)
+    {
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_phoneGetHookSwitch,
+                "phoneGetHookSwitch",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) &pParams->dwHookSwitchDevs
+
+                )) == 0)
+        {
+            *pdwNumBytesReturned = sizeof (PHONEGETHOOKSWITCH_PARAMS);
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetHookSwitch"
+        );
+}
+
+
+void
+WINAPI
+PGetIcon(
+    PPHONEGETICON_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    WCHAR      *pszDeviceClass;
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_phoneGetIcon;
+
+
+    pszDeviceClass = (WCHAR *) (pParams->dwDeviceClassOffset == TAPI_NO_DATA ?
+        NULL : pDataBuf + pParams->dwDeviceClassOffset);
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            0,                          // client widget handle
+            NULL,                       // provider widget handle
+            (DWORD) pParams->dwDeviceID,// privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETICON,            // provider func index
+            &pfnTSPI_phoneGetIcon,      // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetIcon"                   // func name
+
+            )) == 0)
+    {
+
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_phoneGetIcon,
+                "phoneGetIcon",
+                SP_FUNC_SYNC,
+                pParams->dwDeviceID,
+                (DWORD) pszDeviceClass,
+                (DWORD) &pParams->hIcon
+
+                )) == 0)
+        {
+            *pdwNumBytesReturned = sizeof (PHONEGETICON_PARAMS);
+        }
+    }
+    else if (pParams->lResult == PHONEERR_OPERATIONUNAVAIL)
+    {
+        if ((pszDeviceClass == NULL) ||
+            (lstrcmpW(pszDeviceClass, L"tapi/phone") == 0))
+        {
+            pParams->hIcon = TapiGlobals.hPhoneIcon;
+            pParams->lResult = 0;
+            *pdwNumBytesReturned = sizeof (PHONEGETICON_PARAMS);
+        }
+        else
+        {
+            pParams->lResult = PHONEERR_INVALDEVICECLASS;
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetIcon"
+        );
+}
+
+
+void
+WINAPI
+PGetID(
+    PPHONEGETID_PARAMS  pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetID;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETID,              // provider func index
+            &pfnTSPI_phoneGetID,        // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetID"                     // func name
+
+            )) == 0  ||  pParams->lResult == PHONEERR_OPERATIONUNAVAIL)
+    {
+        WCHAR      *pszDeviceClass;
+        LPVARSTRING pID = (LPVARSTRING) pDataBuf;
+
+
+        //
+        // We'll handle the "tapi/phone" class right here rather than
+        // burden every single driver with having to support it
+        //
+
+        if (lstrcmpiW(
+                (PWSTR)(pDataBuf + pParams->dwDeviceClassOffset),
+                L"tapi/phone"
+
+                ) == 0)
+        {
+            if (!InitTapiStruct(
+                    pID,
+                    pParams->u.dwDeviceIDTotalSize,
+                    sizeof (VARSTRING),
+                    TRUE
+                    ))
+            {
+                pParams->lResult = PHONEERR_STRUCTURETOOSMALL;
+                goto PGetID_epilog;
+            }
+
+            pID->dwNeededSize += sizeof (DWORD);
+
+            if (pID->dwTotalSize >= pID->dwNeededSize)
+            {
+                try
+                {
+                    *((LPDWORD)(pID + 1)) = ((PTPHONECLIENT) pParams->hPhone)
+                        ->ptPhone->dwDeviceID;
+                }
+                myexcept
+                {
+                    pParams->lResult = PHONEERR_INVALPHONEHANDLE;
+                    goto PGetID_epilog;
+                }
+
+                pID->dwUsedSize     += sizeof (DWORD);
+                pID->dwStringFormat = STRINGFORMAT_BINARY;
+                pID->dwStringSize   = sizeof (DWORD);
+                pID->dwStringOffset = sizeof (VARSTRING);
+            }
+
+
+            //
+            // Indicate offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDeviceIDOffset = 0;
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pID->dwUsedSize;
+            goto PGetID_epilog;
+        }
+        else if (pParams->lResult ==  PHONEERR_OPERATIONUNAVAIL)
+        {
+            goto PGetID_epilog;
+        }
+
+
+        //
+        // Alloc a temporary buf for the dev class, since we'll be using
+        // the existing buffer for output
+        //
+
+        if (!(pszDeviceClass = (WCHAR *) ServerAlloc( sizeof(WCHAR) * (1 +
+                lstrlenW ((PWSTR)(pDataBuf + pParams->dwDeviceClassOffset)))
+                )))
+        {
+            pParams->lResult = PHONEERR_NOMEM;
+            goto PGetID_epilog;
+        }
+
+        lstrcpyW(pszDeviceClass, (PWSTR)(pDataBuf + pParams->dwDeviceClassOffset));
+
+
+        if (!InitTapiStruct(
+                pID,
+                pParams->u.dwDeviceIDTotalSize,
+                sizeof (VARSTRING),
+                TRUE
+                ))
+        {
+            ServerFree (pszDeviceClass);
+            pParams->lResult = PHONEERR_STRUCTURETOOSMALL;
+            goto PGetID_epilog;
+        }
+
+        if ((pParams->lResult = CallSP4(
+                pfnTSPI_phoneGetID,
+                "phoneGetID",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) pID,
+                (DWORD) pszDeviceClass,
+                (DWORD) pParams->ptClient->hProcess
+
+                )) == 0)
+        {
+            //
+            // Indicate offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwDeviceIDOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pID->dwUsedSize;
+        }
+
+        ServerFree (pszDeviceClass);
+    }
+
+PGetID_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetID"
+        );
+}
+
+
+void
+WINAPI
+PGetLamp(
+    PPHONEGETLAMP_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetLamp;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETLAMP,            // provider func index
+            &pfnTSPI_phoneGetLamp,      // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetLamp"                   // func name
+
+            )) == 0)
+    {
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_phoneGetLamp,
+                "phoneGetLamp",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwButtonLampID,
+                (DWORD) &pParams->dwLampMode
+
+                )) == 0)
+        {
+            *pdwNumBytesReturned = sizeof (PHONEGETLAMP_PARAMS);
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetLamp"
+        );
+}
+
+
+void
+WINAPI
+PGetRing(
+    PPHONEGETRING_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetRing;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETRING,            // provider func index
+            &pfnTSPI_phoneGetRing,      // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetRing"                   // func name
+
+            )) == 0)
+    {
+        if ((pParams->lResult = CallSP3(
+                pfnTSPI_phoneGetRing,
+                "phoneGetRing",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) &pParams->dwRingMode,
+                (DWORD) &pParams->dwVolume
+
+                )) == 0)
+        {
+            *pdwNumBytesReturned = sizeof (PHONEGETRING_PARAMS);
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetRing"
+        );
+}
+
+
+void
+WINAPI
+PGetStatus(
+    PPHONEGETSTATUS_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetStatus;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETSTATUS,          // provider func index
+            &pfnTSPI_phoneGetStatus,    // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetStatus"                 // func name
+
+            )) == 0)
+    {
+        DWORD           dwAPIVersion, dwSPIVersion, dwTotalSize,
+                        dwFixedSizeClient, dwFixedSizeSP;
+        PTPHONECLIENT   ptPhoneClient = (PTPHONECLIENT) pParams->hPhone;
+        LPPHONESTATUS   pStatus = (LPPHONESTATUS) pDataBuf,
+                        pStatus2 = (LPPHONESTATUS) NULL;
+
+
+        //
+        // Determine the fixed size of the structure for the specified API
+        // version, verify client's buffer is big enough
+        //
+
+        dwAPIVersion = ptPhoneClient->dwAPIVersion;
+
+        dwTotalSize = pParams->u.dwPhoneStatusTotalSize;
+
+        switch (dwAPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeClient = 100;    // 25 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeClient = sizeof (PHONESTATUS);
+            break;
+        }
+
+        if (dwTotalSize < dwFixedSizeClient)
+        {
+            pParams->lResult = PHONEERR_STRUCTURETOOSMALL;
+            goto PGetStatus_epilog;
+        }
+
+
+        //
+        // Determine the fixed size of the structure expected by the SP
+        //
+
+        dwSPIVersion = ptPhoneClient->ptPhone->dwSPIVersion;
+
+        switch (dwSPIVersion)
+        {
+        case TAPI_VERSION1_0:
+        case TAPI_VERSION1_4:
+
+            dwFixedSizeSP = 100;        // 25 * sizeof (DWORD)
+            break;
+
+        default: // (fix ppc build wrn) case TAPI_VERSION_CURRENT:
+
+            dwFixedSizeSP = sizeof (PHONESTATUS);
+            break;
+        }
+
+
+        //
+        // If the client's buffer is < the fixed size of that expected by
+        // the SP (client is lower version than SP) then allocate an
+        // intermediate buffer
+        //
+
+        if (dwTotalSize < dwFixedSizeSP)
+        {
+            if (!(pStatus2 = ServerAlloc (dwFixedSizeSP)))
+            {
+                pParams->lResult = PHONEERR_NOMEM;
+                goto PGetStatus_epilog;
+            }
+
+            pStatus     = pStatus2;
+            dwTotalSize = dwFixedSizeSP;
+        }
+
+
+        InitTapiStruct(
+            pStatus,
+            dwTotalSize,
+            dwFixedSizeSP,
+            (pStatus2 == NULL ? TRUE : FALSE)
+            );
+
+        if ((pParams->lResult = CallSP2(
+                pfnTSPI_phoneGetStatus,
+                "phoneGetStatus",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) pStatus
+
+                )) == 0)
+        {
+            DWORD       dwRemainingSize = (pStatus->dwTotalSize -
+                            pStatus->dwUsedSize),
+                        dwNeededSize = 0, dwXxxSize;
+            PTPHONEAPP  ptPhoneApp;
+
+#if DBG
+            //
+            // Verify the info returned by the provider
+            //
+
+#endif
+
+            //
+            // Add the fields we're responsible for
+            //
+
+/*
+// BUGBUG PGetStatus: dwNumOwners, ...
+
+            pStatus->dwNumOwners   =
+            pStatus->dwNumMonitors =
+
+            dwNeededSize += (dwXxxSize = ptPhoneApp->dwAppNameSize);
+
+            if (dwXxxSize < dwRemainingSize)
+            {
+                pStatus->dwOwnerNameSize   = dwXxxSize;
+                pStatus->dwOwnerNameOffset = pStatus->dwUsedSize;
+
+                CopyMemory(
+                    ((LPBYTE) pStatus) + pCallInfo->dwOwnerNameOffset,
+                    ptPhoneApp->szAppName,
+                    dwXxxSize
+                    );
+
+                pStatus->dwUsedSize += dwXxxSize;
+
+                dwRemainingSize -= dwXxxSize;
+            }
+
+
+            pStatus->dwNeededSize += dwNeededSize;
+*/
+
+            //
+            // Munge fields where appropriate for old apps (don't want to
+            // pass back flags that they won't understand)
+            //
+
+
+            //
+            // If an intermediate buffer was used then copy the bits back
+            // to the the original buffer, & free the intermediate buffer.
+            // Also reset the dwUsedSize field to the fixed size of the
+            // structure for the specifed version, since any data in the
+            // variable portion is garbage as far as the client is concerned.
+            //
+
+            if (pStatus == pStatus2)
+            {
+                pStatus = (LPPHONESTATUS) pDataBuf;
+
+                CopyMemory (pStatus, pStatus2, dwFixedSizeClient);
+
+                ServerFree (pStatus2);
+
+                pStatus->dwTotalSize = pParams->u.dwPhoneStatusTotalSize;
+                pStatus->dwUsedSize  = dwFixedSizeClient;
+            }
+
+
+            //
+            // Indicate the offset & how many bytes of data we're passing back
+            //
+
+            pParams->u.dwPhoneStatusOffset = 0;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pStatus->dwUsedSize;
+        }
+    }
+
+PGetStatus_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetStatus"
+        );
+}
+
+
+void
+WINAPI
+PGetStatusMessages(
+    PPHONEGETSTATUSMESSAGES_PARAMS  pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetStatusMessages"         // func name
+
+            )) == 0)
+    {
+        PTPHONECLIENT ptPhoneClient = (PTPHONECLIENT) pParams->hPhone;
+
+
+        pParams->dwPhoneStates  = ptPhoneClient->dwPhoneStates;
+        pParams->dwButtonModes  = ptPhoneClient->dwButtonModes;
+        pParams->dwButtonStates = ptPhoneClient->dwButtonStates;
+
+        *pdwNumBytesReturned = sizeof (PHONEGETSTATUSMESSAGES_PARAMS);
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetStatusMessages"
+        );
+}
+
+
+void
+WINAPI
+PGetVolume(
+    PPHONEGETVOLUME_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    HANDLE      hMutex;
+    HDRVPHONE   hdPhone;
+    TSPIPROC    pfnTSPI_phoneGetVolume;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONEGETVOLUME,          // provider func index
+            &pfnTSPI_phoneGetVolume,    // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "GetVolume"                 // func name
+
+            )) == 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwHookSwitchDev) ||
+            (pParams->dwHookSwitchDev & ~AllHookSwitchDevs))
+        {
+            pParams->lResult = PHONEERR_INVALHOOKSWITCHDEV;
+        }
+        else
+        {
+            if ((pParams->lResult = CallSP3(
+                    pfnTSPI_phoneGetVolume,
+                    "phoneGetVolume",
+                    SP_FUNC_SYNC,
+                    (DWORD) hdPhone,
+                    (DWORD) pParams->dwHookSwitchDev,
+                    (DWORD) &pParams->dwVolume
+
+                    )) == 0)
+            {
+                *pdwNumBytesReturned = sizeof (PHONEGETVOLUME_PARAMS);
+            }
+        }
+    }
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "GetVolume"
+        );
+}
+
+
+void
+WINAPI
+PInitialize(
+    PPHONEINITIALIZE_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwFriendlyNameSize, dwModuleNameSize;
+    HANDLE      hMutex;
+    PTCLIENT    ptClient = pParams->ptClient;
+    PTPHONEAPP  ptPhoneApp;
+
+
+
+    //
+    // Alloc & init a new tPhoneApp
+    //
+
+    dwFriendlyNameSize = sizeof(WCHAR) * (1 + lstrlenW(
+        (PWSTR)(pDataBuf + pParams->dwFriendlyNameOffset))
+        );
+
+    dwModuleNameSize = sizeof(WCHAR) * (1 + lstrlenW(
+        (PWSTR)(pDataBuf + pParams->dwModuleNameOffset))
+        );
+
+    if (!(ptPhoneApp = ServerAlloc(
+            sizeof (TPHONEAPP) +
+            dwFriendlyNameSize +
+            dwModuleNameSize
+            )) ||
+
+        !(ptPhoneApp->hMutex = MyCreateMutex()))
+    {
+        pParams->lResult = PHONEERR_NOMEM;
+
+        goto PInitialize_error1;
+    }
+
+    ptPhoneApp->dwKey        = TPHONEAPP_KEY;
+    ptPhoneApp->ptClient     = ptClient;
+    ptPhoneApp->lpfnCallback = pParams->lpfnCallback;
+    ptPhoneApp->dwAPIVersion = pParams->dwAPIVersion;
+
+    ptPhoneApp->pszFriendlyName = (WCHAR *) (ptPhoneApp + 1);
+
+    lstrcpyW(
+        ptPhoneApp->pszFriendlyName,
+        (PWSTR)(pDataBuf + pParams->dwFriendlyNameOffset)
+        );
+
+    ptPhoneApp->pszModuleName = (PWSTR)((BYTE *) (ptPhoneApp + 1) + dwFriendlyNameSize);
+
+    lstrcpyW(
+        ptPhoneApp->pszModuleName,
+        (PWSTR)(pDataBuf + pParams->dwModuleNameOffset)
+        );
+
+
+    //
+    // Safely insert new tPhoneApp at front of tClient's tPhoneApp list
+    //
+
+    if (WaitForExclusiveClientAccess(
+            ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        if ((ptPhoneApp->pNext = ptClient->ptPhoneApps))
+        {
+            ptPhoneApp->pNext->pPrev = ptPhoneApp;
+        }
+
+        ptClient->ptPhoneApps = ptPhoneApp;
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+    }
+    else
+    {
+        pParams->lResult = PHONEERR_OPERATIONFAILED;
+        goto PInitialize_error1;
+    }
+
+
+    //
+    // Check if global reinit flag set
+    //
+
+    if (TapiGlobals.bReinit)
+    {
+        pParams->lResult = PHONEERR_REINIT;
+        goto PInitialize_error2;
+    }
+
+
+    //
+    // See if we need to go thru init
+    //
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    if ((TapiGlobals.dwNumLineInits == 0) &&
+        (TapiGlobals.dwNumPhoneInits == 0))
+    {
+        if ((pParams->lResult = ServerInit()) != 0)
+        {
+            ReleaseMutex (TapiGlobals.hMutex);
+            goto PInitialize_error2;
+        }
+    }
+
+
+    //
+    // Fill in the return values
+    //
+
+    pParams->hPhoneApp  = (HPHONEAPP) ptPhoneApp;
+    pParams->dwNumDevs = TapiGlobals.dwNumPhones;
+
+
+    //
+    // Increment total num phone inits
+    //
+
+    TapiGlobals.dwNumPhoneInits++;
+
+    *pdwNumBytesReturned = sizeof (PHONEINITIALIZE_PARAMS);
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+    goto PInitialize_return;
+
+PInitialize_error2:
+
+    if (WaitForExclusiveClientAccess(
+            ptClient,
+            &hMutex,
+            &bCloseMutex,
+            INFINITE
+            ))
+    {
+        if (ptPhoneApp->pNext)
+        {
+            ptPhoneApp->pNext->pPrev = ptPhoneApp->pPrev;
+        }
+
+        if (ptPhoneApp->pPrev)
+        {
+            ptPhoneApp->pPrev->pNext = ptPhoneApp->pNext;
+        }
+        else
+        {
+            ptClient->ptPhoneApps = ptPhoneApp->pNext;
+        }
+
+        MyReleaseMutex (hMutex, bCloseMutex);
+    }
+
+PInitialize_error1:
+
+    if (ptPhoneApp)
+    {
+        if (ptPhoneApp->hMutex)
+        {
+            CloseHandle (ptPhoneApp->hMutex);
+        }
+
+        ServerFree (ptPhoneApp);
+    }
+
+PInitialize_return:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "phoneInitialize: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+PNegotiateAPIVersion(
+    PPHONENEGOTIATEAPIVERSION_PARAMS    pParams,
+    LPBYTE                              pDataBuf,
+    LPDWORD                             pdwNumBytesReturned
+    )
+{
+    //
+    // Note: TAPI_VERSION1_0 <= dwNegotiatedAPIVersion <= dwSPIVersion
+    //
+
+    DWORD   dwDeviceID = pParams->dwDeviceID;
+
+
+    if (TapiGlobals.dwNumPhoneInits == 0)
+    {
+        pParams->lResult = PHONEERR_UNINITIALIZED;
+        goto PNegotiateAPIVersion_exit;
+    }
+
+    if (dwDeviceID < TapiGlobals.dwNumPhones)
+    {
+        DWORD       dwAPIHighVersion = pParams->dwAPIHighVersion,
+                    dwAPILowVersion  = pParams->dwAPILowVersion,
+                    dwHighestValidAPIVersion;
+        PTPHONEAPP  ptPhoneApp = (PTPHONEAPP) pParams->hPhoneApp;
+
+
+        if (!IsValidPhoneApp ((HPHONEAPP) ptPhoneApp, pParams->ptClient))
+        {
+            pParams->lResult = (TapiGlobals.dwNumPhoneInits ?
+                PHONEERR_INVALAPPHANDLE : PHONEERR_UNINITIALIZED);
+
+            goto PNegotiateAPIVersion_exit;
+        }
+
+
+        //
+        // Do a minimax test on the specified lo/hi values
+        //
+
+        if ((dwAPILowVersion > dwAPIHighVersion) ||
+            (dwAPILowVersion > TAPI_VERSION_CURRENT) ||
+            (dwAPIHighVersion < TAPI_VERSION1_0))
+        {
+            pParams->lResult = PHONEERR_INCOMPATIBLEAPIVERSION;
+            goto PNegotiateAPIVersion_exit;
+        }
+
+
+        //
+        // Find the highest valid API version given the lo/hi values.
+        // Since valid vers aren't consecutive we need to check for
+        // errors that our minimax test missed.
+        //
+
+        if (dwAPIHighVersion < TAPI_VERSION_CURRENT)
+        {
+            if ((dwAPIHighVersion >= TAPI_VERSION1_4) &&
+                (dwAPILowVersion <= TAPI_VERSION1_4))
+            {
+                dwHighestValidAPIVersion = TAPI_VERSION1_4;
+            }
+            else if ((dwAPIHighVersion >= TAPI_VERSION1_0) &&
+                (dwAPILowVersion <= TAPI_VERSION1_0))
+            {
+                dwHighestValidAPIVersion = TAPI_VERSION1_0;
+            }
+            else
+            {
+                DBGOUT((1, "   Incompatible version"));
+                pParams->lResult = PHONEERR_INCOMPATIBLEAPIVERSION;
+                goto PNegotiateAPIVersion_exit;
+            }
+        }
+        else
+        {
+            dwHighestValidAPIVersion = TAPI_VERSION_CURRENT;
+        }
+
+
+
+        {
+        BOOL    bCloseMutex;
+        HANDLE  hMutex;
+    
+
+        //
+        // WARNING!!! WARNING!!! WARNING!!! WARNING!!!
+        // This code overwrites ptPhoneApp and later invalidates it.
+        // Do NOT use ptPhoneApp after the MyReleaseMutex call.
+        //
+
+        if ((ptPhoneApp = WaitForExclusivePhoneAppAccess(
+                        pParams->hPhoneApp,
+                        pParams->ptClient,
+                        &hMutex,
+                        &bCloseMutex,
+                        INFINITE
+                        )))
+        {
+
+            //
+            // Is this app trying to negotiate something valid?
+            //
+            // If an app has called phoneInitalize (as opposed to
+            // phoneInitializeEx), we'll clamp the max APIVersion they can
+            // negotiate to 1.4.
+            //
+            if ( ptPhoneApp->dwAPIVersion < TAPI_VERSION2_0 )
+            {
+                dwHighestValidAPIVersion =
+                    (dwHighestValidAPIVersion >= TAPI_VERSION1_4) ?
+                    TAPI_VERSION1_4 : TAPI_VERSION1_0;
+            }
+            
+                  
+            //
+            // Save the highest valid API version the client says it supports
+            // (we need this for determining which msgs to send to it)
+            //
+
+            if (dwHighestValidAPIVersion > ptPhoneApp->dwAPIVersion)
+            {
+                ptPhoneApp->dwAPIVersion = dwHighestValidAPIVersion;
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+        }
+        else
+        {
+            pParams->lResult = PHONEERR_INVALAPPHANDLE;
+            goto PNegotiateAPIVersion_exit;
+        }
+
+        }
+
+
+
+        //
+        // See if there's a valid match with the SPI ver
+        //
+
+        {
+            DWORD               dwSPIVersion;
+            PTPHONELOOKUPENTRY  pLookupEntry;
+
+
+            pLookupEntry = GetPhoneLookupEntry (dwDeviceID);
+            dwSPIVersion = pLookupEntry->dwSPIVersion;
+
+            if (pLookupEntry->bRemoved)
+            {
+                DBGOUT((1, "  phone removed..."));
+                pParams->lResult = PHONEERR_NODEVICE;
+                goto PNegotiateAPIVersion_exit;
+            }
+
+            if (pLookupEntry->ptProvider == NULL)
+            {
+                DBGOUT((1, "  Provider == NULL"));
+                pParams->lResult = PHONEERR_NODRIVER;
+                goto PNegotiateAPIVersion_exit;
+            }
+
+            if (dwAPILowVersion <= dwSPIVersion)
+            {
+                pParams->dwAPIVersion =
+                    (dwHighestValidAPIVersion > dwSPIVersion ?
+                    dwSPIVersion : dwHighestValidAPIVersion);
+
+
+                //
+                // Retrieve ext id (indicate no exts if GetExtID not exported)
+                //
+
+                if (pLookupEntry->ptProvider->apfn[SP_PHONEGETEXTENSIONID])
+                {
+                    if ((pParams->lResult = CallSP3(
+                            pLookupEntry->ptProvider->
+                                apfn[SP_PHONEGETEXTENSIONID],
+                            "phoneGetExtensionID",
+                            SP_FUNC_SYNC,
+                            (DWORD) dwDeviceID,
+                            (DWORD) dwSPIVersion,
+                            (DWORD) pDataBuf
+
+                            )) != 0)
+                    {
+                        goto PNegotiateAPIVersion_exit;
+                    }
+                }
+                else
+                {
+                    FillMemory (pDataBuf, sizeof (PHONEEXTENSIONID), 0);
+                }
+            }
+            else
+            {
+                DBGOUT((1, "  API version too high"));
+                pParams->lResult = PHONEERR_INCOMPATIBLEAPIVERSION;
+                goto PNegotiateAPIVersion_exit;
+            }
+        }
+
+        pParams->dwExtensionIDOffset = 0;
+        pParams->dwSize              = sizeof (PHONEEXTENSIONID);
+
+        DBGOUT((4, "  ExtensionID0=x%08lx", *(LPDWORD)(pDataBuf+0) ));
+        DBGOUT((4, "  ExtensionID1=x%08lx", *(LPDWORD)(pDataBuf+4) ));
+        DBGOUT((4, "  ExtensionID2=x%08lx", *(LPDWORD)(pDataBuf+8) ));
+        DBGOUT((4, "  ExtensionID3=x%08lx", *(LPDWORD)(pDataBuf+12) ));
+
+        *pdwNumBytesReturned = sizeof (PHONEEXTENSIONID) + sizeof (TAPI32_MSG);
+    }
+    else
+    {
+        pParams->lResult = PHONEERR_BADDEVICEID;
+    }
+
+PNegotiateAPIVersion_exit:
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "phoneNegotiateAPIVersion: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+
+    return;
+}
+
+
+void
+WINAPI
+PNegotiateExtVersion(
+    PPHONENEGOTIATEEXTVERSION_PARAMS    pParams,
+    LPBYTE                              pDataBuf,
+    LPDWORD                             pdwNumBytesReturned
+    )
+{
+    BOOL        bCloseMutex;
+    DWORD       dwDeviceID = pParams->dwDeviceID;
+    HANDLE      hMutex;
+    TSPIPROC    pfnTSPI_phoneNegotiateExtVersion;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hPhoneApp, // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONENEGOTIATEEXTVERSION,// provider func index
+            &pfnTSPI_phoneNegotiateExtVersion,  // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "NegotiateExtVersion"       // func name
+
+            )) == 0)
+    {
+        DWORD   dwSPIVersion = (GetPhoneLookupEntry(dwDeviceID))->dwSPIVersion;
+
+
+        if (!IsAPIVersionInRange(
+                pParams->dwAPIVersion,
+                dwSPIVersion
+                ))
+        {
+            pParams->lResult = PHONEERR_INCOMPATIBLEAPIVERSION;
+            goto PNegotiateExtVersion_epilog;
+        }
+
+        if ((pParams->lResult = CallSP5(
+                pfnTSPI_phoneNegotiateExtVersion,
+                "phoneNegotiateExtVersion",
+                SP_FUNC_SYNC,
+                (DWORD) dwDeviceID,
+                (DWORD) dwSPIVersion,
+                (DWORD) pParams->dwExtLowVersion,
+                (DWORD) pParams->dwExtHighVersion,
+                (DWORD) &pParams->dwExtVersion
+
+                )) == 0)
+        {
+            if (pParams->dwExtVersion == 0)
+            {
+                pParams->lResult = PHONEERR_INCOMPATIBLEEXTVERSION;
+            }
+            else
+            {
+                *pdwNumBytesReturned = sizeof(PHONENEGOTIATEEXTVERSION_PARAMS);
+            }
+        }
+    }
+
+PNegotiateExtVersion_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "NegotiateExtVersion"
+        );
+}
+
+
+void
+WINAPI
+POpen(
+    PPHONEOPEN_PARAMS   pParams,
+    LPBYTE              pDataBuf,
+    LPDWORD             pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex,
+                        bReleasetPhoneMutex = FALSE;
+    LONG                lResult;
+    DWORD               dwDeviceID = pParams->dwDeviceID, dwNumMonitors;
+    HANDLE              hMutex;
+    PTPHONE             ptPhone = NULL;
+    PTPHONECLIENT       ptPhoneClient = NULL;
+    PTPHONELOOKUPENTRY  pLookupEntry;
+
+
+    if ((lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            DEVICE_ID,                  // widget type
+            (DWORD) pParams->hPhoneApp, // client widget handle
+            NULL,                       // provider widget handle
+            dwDeviceID,                 // privileges or device ID
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            0,                          // provider func index
+            NULL,                       // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+            "Open"                      // func name
+
+            )) == 0)
+    {
+        BOOL        bOpenedtPhone = FALSE;
+        DWORD       dwPrivilege = pParams->dwPrivilege,
+                    dwExtVersion = pParams->dwExtVersion;
+        PTPROVIDER  ptProvider;
+
+
+        //
+        // Check if the global reinit flag is set
+        //
+
+        if (TapiGlobals.bReinit)
+        {
+            lResult = PHONEERR_REINIT;
+            goto POpen_cleanup;
+        }
+
+
+        //
+        // Validate params
+        //
+
+        if ((dwPrivilege != PHONEPRIVILEGE_MONITOR) &&
+            (dwPrivilege != PHONEPRIVILEGE_OWNER))
+        {
+            lResult = PHONEERR_INVALPRIVILEGE;
+            goto POpen_cleanup;
+        }
+
+        pLookupEntry = GetPhoneLookupEntry (dwDeviceID);
+
+        if (!IsAPIVersionInRange(
+                pParams->dwAPIVersion,
+                pLookupEntry->dwSPIVersion
+                ))
+        {
+            lResult = PHONEERR_INCOMPATIBLEAPIVERSION;
+            goto POpen_cleanup;
+        }
+
+        ptProvider = pLookupEntry->ptProvider;
+
+
+        //
+        // Create & init a tPhoneClient & associated resources
+        //
+
+        if (!(ptPhoneClient = ServerAlloc (sizeof(TPHONECLIENT))))
+        {
+            lResult = PHONEERR_NOMEM;
+            goto POpen_cleanup;
+        }
+
+        ptPhoneClient->hMutex             = MyCreateMutex();
+        ptPhoneClient->ptClient           = pParams->ptClient;
+        ptPhoneClient->ptPhoneApp         = (PTPHONEAPP) pParams->hPhoneApp;
+        ptPhoneClient->hRemotePhone       = (pParams->hRemotePhone ?
+            (DWORD) pParams->hRemotePhone : (DWORD) ptPhoneClient);
+        ptPhoneClient->dwAPIVersion       = pParams->dwAPIVersion;
+        ptPhoneClient->dwPrivilege        = pParams->dwPrivilege;
+        ptPhoneClient->dwCallbackInstance = pParams->dwCallbackInstance;
+
+
+        //
+        // Grab the tPhone's mutex, then start doing the open
+        //
+
+POpen_waitForMutex:
+
+        if (WaitForSingleObject (pLookupEntry->hMutex, INFINITE)
+                != WAIT_OBJECT_0)
+        {
+            DBGOUT((1, "WaitForSingleObject failed!"));
+
+            lResult = PHONEERR_OPERATIONFAILED;
+            goto POpen_cleanup;
+        }
+
+        bReleasetPhoneMutex = TRUE;
+
+
+        //
+        // If the tPhone is in the process of being destroyed then spin
+        // until it's been completely destroyed (DestroytPhone() will
+        // NULLify pLookupEntry->ptPhone when it's finished). Make sure
+        // to release the mutex while sleeping so we don't block
+        // DestroytPhone.
+        //
+
+        try
+        {
+            while (pLookupEntry->ptPhone &&
+                   pLookupEntry->ptPhone->dwKey != TPHONE_KEY)
+            {
+                ReleaseMutex (pLookupEntry->hMutex);
+                Sleep (0);
+                goto POpen_waitForMutex;
+            }
+        }
+        myexcept
+        {
+            // If here pLookupEntry->ptPhone was NULLified, safe to continue
+        }
+
+
+        //
+        // Validate ext ver as appropriate
+        //
+
+        if (dwExtVersion != 0 &&
+            (!IsValidPhoneExtVersion (dwDeviceID, dwExtVersion) ||
+            ptProvider->apfn[SP_PHONESELECTEXTVERSION] == NULL))
+        {
+            lResult = PHONEERR_INCOMPATIBLEEXTVERSION;
+            goto POpen_cleanup;
+        }
+
+
+        //
+        // Check for exclusive ownership as appropriate
+        //
+
+        ptPhone = pLookupEntry->ptPhone;
+
+        if (dwPrivilege == PHONEPRIVILEGE_OWNER &&
+            ptPhone &&
+            (ptPhone->dwNumOwners != 0)
+            )
+        {
+            lResult = PHONEERR_INVALPRIVILEGE;
+            goto POpen_cleanup;
+        }
+
+
+        if (ptPhone == NULL)
+        {
+            if (!(ptPhone = ServerAlloc (sizeof(TPHONE))))
+            {
+                lResult = PHONEERR_NOMEM;
+                goto POpen_cleanup;
+            }
+
+            ptPhone->hMutex       = pLookupEntry->hMutex;
+            ptPhone->ptProvider   = ptProvider;
+            ptPhone->dwDeviceID   = pParams->dwDeviceID;
+            ptPhone->dwSPIVersion = pLookupEntry->dwSPIVersion;
+
+            if ((lResult = CallSP5(
+                    ptProvider->apfn[SP_PHONEOPEN],
+                    "phoneOpen",
+                    SP_FUNC_SYNC,
+                    (DWORD) pParams->dwDeviceID,
+                    (DWORD) ptPhone,
+                    (DWORD) &ptPhone->hdPhone,
+                    (DWORD) pLookupEntry->dwSPIVersion,
+                    (DWORD) PhoneEventProcSP
+
+                    )) != 0)
+            {
+                ServerFree (ptPhone);
+                goto POpen_cleanup;
+            }
+
+            bOpenedtPhone = TRUE;
+        }
+
+        ptPhoneClient->ptPhone = ptPhone;
+
+
+        //
+        // If the client has specified a non-zero ext version then
+        // ask the driver to enable it and/or increment the ext
+        // version count.
+        //
+
+        if (dwExtVersion)
+        {
+            if (ptPhone->dwExtVersionCount == 0)
+            {
+                if ((lResult = CallSP2(
+                        ptProvider->apfn[SP_PHONESELECTEXTVERSION],
+                        "phoneSelectExtVersion",
+                        SP_FUNC_SYNC,
+                        (DWORD) ptPhone->hdPhone,
+                        (DWORD) dwExtVersion
+
+                        )) != 0)
+                {
+                    if (bOpenedtPhone)
+                    {
+                        CallSP1(
+                            ptProvider->apfn[SP_PHONECLOSE],
+                            "phoneClose",
+                            SP_FUNC_SYNC,
+                            (DWORD) ptPhone->hdPhone
+                            );
+
+                        ServerFree (ptPhone);
+                    }
+
+                    goto POpen_cleanup;
+                }
+
+                ptPhone->dwExtVersion =
+                ptPhoneClient->dwExtVersion = dwExtVersion;
+            }
+
+            ptPhone->dwExtVersionCount++;
+        }
+
+
+        //
+        //
+        //
+
+        if (dwPrivilege == PHONEPRIVILEGE_OWNER)
+        {
+            ptPhone->dwNumOwners++;
+        }
+        else
+        {
+            ptPhone->dwNumMonitors++;
+            dwNumMonitors = ptPhone->dwNumMonitors;
+        }
+
+
+        //
+        // Add the tPhoneClient to the tPhone's list
+        //
+
+        if ((ptPhoneClient->pNextSametPhone = ptPhone->ptPhoneClients))
+        {
+            ptPhoneClient->pNextSametPhone->pPrevSametPhone = ptPhoneClient;
+        }
+
+        ptPhone->ptPhoneClients = ptPhoneClient;
+
+        if (bOpenedtPhone)
+        {
+            pLookupEntry->ptPhone = ptPhone;
+            ptPhone->dwKey = TPHONE_KEY;
+        }
+
+        ReleaseMutex (pLookupEntry->hMutex);
+
+        bReleasetPhoneMutex = FALSE;
+
+
+        //
+        // Safely add the new tLineClient to the tLineApp's list
+        //
+
+        {
+            BOOL        bDupedMutex;
+            HANDLE      hMutex;
+            PTPHONEAPP  ptPhoneApp;
+
+            if ((ptPhoneApp = WaitForExclusivePhoneAppAccess(
+                    pParams->hPhoneApp,
+                    pParams->ptClient,
+                    &hMutex,
+                    &bDupedMutex,
+                    INFINITE
+                    )))
+            {
+                if ((ptPhoneClient->pNextSametPhoneApp =
+                        ptPhoneApp->ptPhoneClients))
+                {
+                    ptPhoneClient->pNextSametPhoneApp->pPrevSametPhoneApp =
+                        ptPhoneClient;
+                }
+
+                ptPhoneApp->ptPhoneClients = ptPhoneClient;
+
+                ptPhoneClient->dwKey = TPHONECLIENT_KEY;
+
+                MyReleaseMutex (hMutex, bDupedMutex);
+
+
+                //
+                // Alert other clients that another open has occured
+                //
+
+                SendMsgToPhoneClients(
+                    ptPhone,
+                    ptPhoneClient,
+                    PHONE_STATE,
+                    (pParams->dwPrivilege == PHONEPRIVILEGE_OWNER ?
+                        PHONESTATE_OWNER : PHONESTATE_MONITORS),
+                    (pParams->dwPrivilege == PHONEPRIVILEGE_OWNER ?
+                        1 : dwNumMonitors),
+                    0
+                    );
+
+
+                //
+                // Fill in the return values
+                //
+
+                pParams->hPhone = (HPHONE) ptPhoneClient;
+                *pdwNumBytesReturned = sizeof (PHONEOPEN_PARAMS);
+            }
+            else
+            {
+                //
+                // If here the app handle is bad, & we've some special
+                // case cleanup to do.  Since the tPhoneClient is not
+                // in the tPhoneApp's list, we can't simply call
+                // DestroytPhone(Client) to clean things up, since the
+                // pointer-resetting code will blow up.  So we'll
+                // grab the tPhone's mutex and explicitly remove the
+                // new tPhoneClient from it's list, then do a conditional
+                // shutdown on the tPhone (in case any other clients
+                // have come along & opened it).
+                //
+                // Note: keep in mind that a PHONE_CLOSE might be being
+                //       processed by another thread (if so, it will be
+                //       spinning on trying to destroy the tPhoneClient
+                //       which isn't valid at this point)
+                //
+
+                lResult = PHONEERR_INVALAPPHANDLE;
+
+                WaitForSingleObject (pLookupEntry->hMutex, INFINITE);
+
+                //
+                // Remove the tpHOneClient from the tLine's list & decrement
+                // the number of opens
+                //
+
+                if (ptPhoneClient->pNextSametPhone)
+                {
+                    ptPhoneClient->pNextSametPhone->pPrevSametPhone =
+                        ptPhoneClient->pPrevSametPhone;
+                }
+
+                if (ptPhoneClient->pPrevSametPhone)
+                {
+                    ptPhoneClient->pPrevSametPhone->pNextSametPhone =
+                        ptPhoneClient->pNextSametPhone;
+                }
+                else
+                {
+                    ptPhone->ptPhoneClients = ptPhoneClient->pNextSametPhone;
+                }
+
+                if (dwPrivilege == PHONEPRIVILEGE_OWNER)
+                {
+                    ptPhone->dwNumOwners--;
+                }
+                else
+                {
+                    ptPhone->dwNumMonitors--;
+                }
+
+                if (dwExtVersion != 0)
+                {
+                    ptPhone->dwExtVersionCount--;
+
+                    if (ptPhone->dwExtVersionCount == 0)
+                    {
+                        ptPhone->dwExtVersion = 0;
+
+                        CallSP2(
+                            ptProvider->apfn[SP_PHONESELECTEXTVERSION],
+                            "phoneSelectExtVersion",
+                            SP_FUNC_SYNC,
+                            (DWORD) ptPhone->hdPhone,
+                            (DWORD) 0
+                            );
+                    }
+                }
+
+                ReleaseMutex (pLookupEntry->hMutex);
+
+                DestroytPhone (ptPhone, FALSE); // conditional destroy
+            }
+        }
+    }
+
+POpen_cleanup:
+
+    if (bReleasetPhoneMutex)
+    {
+        ReleaseMutex (pLookupEntry->hMutex);
+    }
+
+    if (lResult != 0)
+    {
+        if (ptPhoneClient)
+        {
+            if (ptPhoneClient->hMutex)
+            {
+                CloseHandle (ptPhoneClient->hMutex);
+            }
+
+            ServerFree (ptPhoneClient);
+        }
+    }
+
+    pParams->lResult = lResult;
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "Open"
+        );
+}
+
+
+void
+WINAPI
+PSetButtonInfo(
+    PPHONESETBUTTONINFO_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetButtonInfo;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETBUTTONINFO,      // provider func index
+            &pfnTSPI_phoneSetButtonInfo,// provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetButtonInfo"             // func name
+
+            )) > 0)
+    {
+        LONG                lResult;
+        DWORD               dwAPIVersion, dwSPIVersion;
+        LPPHONEBUTTONINFO   pButtonInfoApp = (LPPHONEBUTTONINFO)
+                                pDataBuf + pParams->dwButtonInfoOffset,
+                            pButtonInfoSP;
+
+
+        try
+        {
+            PTPHONECLIENT   ptPhoneClient = (PTPHONECLIENT) pParams->hPhone;
+
+
+            dwAPIVersion = ptPhoneClient->dwAPIVersion;
+            dwSPIVersion = ptPhoneClient->ptPhone->dwSPIVersion;
+        }
+        myexcept
+        {
+            lRequestID = PHONEERR_INVALPHONEHANDLE;
+            goto PSetButtonInfo_epilog;
+        }
+
+        if ((lResult = ValidateButtonInfo(
+                pButtonInfoApp,
+                &pButtonInfoSP,
+                dwAPIVersion,
+                dwSPIVersion
+                )))
+        {
+            lRequestID = lResult;
+            goto PSetButtonInfo_epilog;
+        }
+
+        pParams->lResult = CallSP4(
+            pfnTSPI_phoneSetButtonInfo,
+            "phoneSetButtonInfo",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdPhone,
+            (DWORD) pParams->dwButtonLampID,
+            (DWORD) pButtonInfoSP
+            );
+
+        if (pButtonInfoSP != pButtonInfoApp)
+        {
+            ServerFree (pButtonInfoSP);
+        }
+    }
+
+PSetButtonInfo_epilog:
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetButtonInfo"
+        );
+}
+
+
+void
+WINAPI
+PSetData(
+    PPHONESETDATA_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetData;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETDATA,            // provider func index
+            &pfnTSPI_phoneSetData,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetData"                   // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP5(
+            pfnTSPI_phoneSetData,
+            "phoneSetData",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdPhone,
+            (DWORD) pParams->dwDataID,
+            (DWORD) (pParams->dwSize ? pDataBuf + pParams->dwDataOffset :NULL),
+            (DWORD) pParams->dwSize
+            );
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetData"
+        );
+}
+
+
+void
+WINAPI
+PSetDisplay(
+    PPHONESETDISPLAY_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetDisplay;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETDISPLAY,         // provider func index
+            &pfnTSPI_phoneSetDisplay,   // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetDisplay"                // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP6(
+            pfnTSPI_phoneSetDisplay,
+            "phoneSetDisplay",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdPhone,
+            (DWORD) pParams->dwRow,
+            (DWORD) pParams->dwColumn,
+            (DWORD) (pParams->dwSize ?
+                pDataBuf + pParams->dwDisplayOffset : NULL),
+            (DWORD) pParams->dwSize
+            );
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetDisplay"
+        );
+}
+
+
+void
+WINAPI
+PSetGain(
+    PPHONESETGAIN_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetGain;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETGAIN,            // provider func index
+            &pfnTSPI_phoneSetGain,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetGain"                   // func name
+
+            )) > 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwHookSwitchDev) ||
+            (pParams->dwHookSwitchDev & ~AllHookSwitchDevs))
+        {
+            lRequestID = PHONEERR_INVALHOOKSWITCHDEV;
+        }
+        else
+        {
+            pParams->lResult = CallSP4(
+                pfnTSPI_phoneSetGain,
+                "phoneSetGain",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwHookSwitchDev,
+                (DWORD) (pParams->dwGain > 0x0000ffff ?
+                    0x0000ffff : pParams->dwGain)
+                );
+        }
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetGain"
+        );
+}
+
+
+void
+WINAPI
+PSetHookSwitch(
+    PPHONESETHOOKSWITCH_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetHookSwitch;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETHOOKSWITCH,      // provider func index
+            &pfnTSPI_phoneSetHookSwitch,// provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetHookSwitch"             // func name
+
+            )) > 0)
+    {
+        if (!(pParams->dwHookSwitchDevs & AllHookSwitchDevs) ||
+            (pParams->dwHookSwitchDevs & (~AllHookSwitchDevs)))
+        {
+            lRequestID = PHONEERR_INVALHOOKSWITCHDEV;
+        }
+        else if (!IsOnlyOneBitSetInDWORD (pParams->dwHookSwitchMode) ||
+            (pParams->dwHookSwitchMode & ~AllHookSwitchModes))
+        {
+            lRequestID = PHONEERR_INVALHOOKSWITCHMODE;
+        }
+        else
+        {
+            pParams->lResult = CallSP4(
+                pfnTSPI_phoneSetHookSwitch,
+                "phoneSetHookSwitch",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwHookSwitchDevs,
+                (DWORD) pParams->dwHookSwitchMode
+                );
+        }
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetHookSwitch"
+        );
+}
+
+
+void
+WINAPI
+PSetLamp(
+    PPHONESETLAMP_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetLamp;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETLAMP,            // provider func index
+            &pfnTSPI_phoneSetLamp,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetLamp"                   // func name
+
+            )) > 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwLampMode) ||
+            (pParams->dwLampMode & ~AllLampModes))
+        {
+            lRequestID = PHONEERR_INVALLAMPMODE;
+        }
+        else
+        {
+            pParams->lResult = CallSP4(
+                pfnTSPI_phoneSetLamp,
+                "phoneSetLamp",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwButtonLampID,
+                (DWORD) pParams->dwLampMode
+                );
+        }
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetLamp"
+        );
+}
+
+
+void
+WINAPI
+PSetRing(
+    PPHONESETRING_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetRing;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETRING,            // provider func index
+            &pfnTSPI_phoneSetRing,      // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetRing"                   // func name
+
+            )) > 0)
+    {
+        pParams->lResult = CallSP4(
+            pfnTSPI_phoneSetRing,
+            "phoneSetRing",
+            SP_FUNC_ASYNC,
+            (DWORD) pAsyncRequestInfo,
+            (DWORD) hdPhone,
+            (DWORD) pParams->dwRingMode,
+            (DWORD) (pParams->dwVolume > 0x0000ffff ?
+                0x0000ffff : pParams->dwVolume)
+            );
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetRing"
+        );
+}
+
+
+void
+WINAPI
+PSetStatusMessages(
+    PPHONESETSTATUSMESSAGES_PARAMS  pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    TSPIPROC            pfnTSPI_phoneSetStatusMessages;
+
+
+    if ((pParams->lResult = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_MONITOR,     // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETSTATUSMESSAGES,  // provider func index
+            &pfnTSPI_phoneSetStatusMessages,    // provider func pointer
+            NULL,                       // async request info
+            0,                          // client async request ID
+             "SetStatusMessages"        // func name
+
+            )) == 0)
+    {
+        DWORD           dwUnionPhoneStates, dwUnionButtonModes,
+                        dwUnionButtonStates;
+        PTPHONECLIENT   ptPhoneClient = (PTPHONECLIENT) pParams->hPhone;
+        PTPHONE         ptPhone = ptPhoneClient->ptPhone;
+
+
+        //
+        // Validate the params
+        //
+
+        {
+            DWORD           dwValidPhoneStates, dwValidButtonStates;
+
+
+            switch (ptPhoneClient->dwAPIVersion)
+            {
+            case TAPI_VERSION1_0:
+
+                dwValidPhoneStates  = AllPhoneStates1_0;
+                dwValidButtonStates = AllButtonStates1_0;
+                break;
+
+            default: // case TAPI_VERSION1_4:
+
+                dwValidPhoneStates  = AllPhoneStates1_4;
+                dwValidButtonStates = AllButtonStates1_4;
+                break;
+
+            }
+
+            if ((pParams->dwPhoneStates & ~dwValidPhoneStates))
+            {
+                pParams->lResult = PHONEERR_INVALPHONESTATE;
+                goto PSetStatusMessages_epilog;
+            }
+
+            if ((pParams->dwButtonStates & ~dwValidButtonStates))
+            {
+                pParams->lResult = PHONEERR_INVALBUTTONSTATE;
+                goto PSetStatusMessages_epilog;
+            }
+
+            if ((pParams->dwButtonModes & ~AllButtonModes))
+            {
+                pParams->lResult = PHONEERR_INVALBUTTONMODE;
+                goto PSetStatusMessages_epilog;
+            }
+
+            if (pParams->dwButtonModes && !pParams->dwButtonStates)
+            {
+                pParams->lResult = PHONEERR_INVALBUTTONSTATE;
+                goto PSetStatusMessages_epilog;
+            }
+        }
+
+
+        //
+        // Make sure the REINIT bit is always set
+        //
+
+        pParams->dwPhoneStates |= PHONESTATE_REINIT;
+
+
+        //
+        // Determine the new states union of all the phone clients
+        //
+
+        dwUnionPhoneStates  = pParams->dwPhoneStates;
+        dwUnionButtonModes  = pParams->dwButtonModes;
+        dwUnionButtonStates = pParams->dwButtonStates;
+
+        {
+            PTPHONECLIENT   ptPhoneClientTmp = ptPhone->ptPhoneClients;
+
+
+            while (ptPhoneClientTmp)
+            {
+                if (ptPhoneClientTmp != ptPhoneClient)
+                {
+                    dwUnionPhoneStates  = ptPhoneClientTmp->dwPhoneStates;
+                    dwUnionButtonModes  = ptPhoneClientTmp->dwButtonModes;
+                    dwUnionButtonStates = ptPhoneClientTmp->dwButtonStates;
+                }
+
+                ptPhoneClientTmp = ptPhoneClientTmp->pNextSametPhone;
+            }
+        }
+
+
+        //
+        // If the new states union is the same as previous states union
+        // just reset the fields in the tPhoneClient, else call the provider
+        //
+
+        if (((dwUnionPhoneStates  == ptPhone->dwUnionPhoneStates) &&
+             (dwUnionButtonModes  == ptPhone->dwUnionButtonModes) &&
+             (dwUnionButtonStates == ptPhone->dwUnionButtonStates))  ||
+
+            ((pParams->lResult = CallSP4(
+                pfnTSPI_phoneSetStatusMessages,
+                "phoneSetStatusMessages",
+                SP_FUNC_SYNC,
+                (DWORD) hdPhone,
+                (DWORD) dwUnionPhoneStates,
+                (DWORD) dwUnionButtonModes,
+                (DWORD) dwUnionButtonStates
+
+                )) == 0))
+        {
+            ptPhoneClient->dwPhoneStates  = pParams->dwPhoneStates;
+            ptPhoneClient->dwButtonModes  = pParams->dwButtonModes;
+            ptPhoneClient->dwButtonStates = pParams->dwButtonStates;
+
+            ptPhone->dwUnionPhoneStates  = dwUnionPhoneStates;
+            ptPhone->dwUnionButtonModes  = dwUnionButtonModes;
+            ptPhone->dwUnionButtonStates = dwUnionButtonStates;
+        }
+    }
+
+PSetStatusMessages_epilog:
+
+    PHONEEPILOGSYNC(
+        &pParams->lResult,
+        hMutex,
+        bCloseMutex,
+        "SetStatusMessages"
+        );
+}
+
+
+void
+WINAPI
+PSetVolume(
+    PPHONESETVOLUME_PARAMS  pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    BOOL                bCloseMutex;
+    LONG                lRequestID;
+    HANDLE              hMutex;
+    HDRVPHONE           hdPhone;
+    PASYNCREQUESTINFO   pAsyncRequestInfo;
+    TSPIPROC            pfnTSPI_phoneSetVolume;
+
+
+    if ((lRequestID = PHONEPROLOG(
+            pParams->ptClient,          // tClient
+            ANY_RT_HPHONE,              // widget type
+            (DWORD) pParams->hPhone,    // client widget handle
+            (LPVOID) &hdPhone,          // provider widget handle
+            PHONEPRIVILEGE_OWNER,       // req'd privileges (call only)
+            &hMutex,                    // mutex handle
+            &bCloseMutex,               // close hMutex when finished
+            SP_PHONESETVOLUME,          // provider func index
+            &pfnTSPI_phoneSetVolume,    // provider func pointer
+            &pAsyncRequestInfo,         // async request info
+            pParams->dwRemoteRequestID, // client async request ID
+            "SetVolume"                 // func name
+
+            )) > 0)
+    {
+        if (!IsOnlyOneBitSetInDWORD (pParams->dwHookSwitchDev) ||
+            (pParams->dwHookSwitchDev & ~AllHookSwitchDevs))
+        {
+            lRequestID = PHONEERR_INVALHOOKSWITCHDEV;
+        }
+        else
+        {
+            pParams->lResult = CallSP4(
+                pfnTSPI_phoneSetVolume,
+                "phoneSetVolume",
+                SP_FUNC_ASYNC,
+                (DWORD) pAsyncRequestInfo,
+                (DWORD) hdPhone,
+                (DWORD) pParams->dwHookSwitchDev,
+                (DWORD) (pParams->dwVolume > 0x0000ffff ?
+                    0x0000ffff : pParams->dwVolume)
+                );
+        }
+    }
+
+    PHONEEPILOGASYNC(
+        &pParams->lResult,
+        lRequestID,
+        hMutex,
+        bCloseMutex,
+        pAsyncRequestInfo,
+        "SetVolume"
+        );
+}
+
+
+void
+WINAPI
+PShutdown(
+    PPHONESHUTDOWN_PARAMS   pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    PTPHONEAPP  ptPhoneApp;
+
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    if (!(ptPhoneApp = IsValidPhoneApp (pParams->hPhoneApp, pParams->ptClient)))
+    {
+        if (TapiGlobals.dwNumPhoneInits == 0)
+        {
+            pParams->lResult = PHONEERR_UNINITIALIZED;
+        }
+        else
+        {
+            pParams->lResult = PHONEERR_INVALAPPHANDLE;
+        }
+    }
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+    if (pParams->lResult == 0)
+    {
+        DestroytPhoneApp ((PTPHONEAPP) pParams->hPhoneApp);
+    }
+
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "phoneShutdown: exit, result=%s",
+            MapResultCodeToText (pParams->lResult, szResult)
+            ));
+    }
+#endif
+}
diff --git a/private/tapi/dev/server/phone.h b/private/tapi/dev/server/phone.h
new file mode 100644
index 000000000..802e45bb3
--- /dev/null
+++ b/private/tapi/dev/server/phone.h
@@ -0,0 +1,655 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    phone.h
+
+Abstract:
+
+    Header file for
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#define ANY_RT_HPHONE       1
+#define ANY_RT_HPHONE_CLOSE 2
+#define ANY_RT_HPHONEAPP    3
+#define DEVICE_ID           4
+#define DEVICE_ID_OPEN      5
+
+
+#if DBG
+
+#define PHONEPROLOG(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \
+        PhoneProlog(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
+
+#define PHONEEPILOGSYNC(a1,a2,a3,a4) PhoneEpilogSync(a1,a2,a3,a4)
+
+#define PHONEEPILOGASYNC(a1,a2,a3,a4,a5,a6) PhoneEpilogAsync(a1,a2,a3,a4,a5,a6)
+
+#else
+
+#define PHONEPROLOG(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \
+        PhoneProlog(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11)
+
+#define PHONEEPILOGSYNC(a1,a2,a3,a4) PhoneEpilogSync(a1,a2,a3)
+
+#define PHONEEPILOGASYNC(a1,a2,a3,a4,a5,a6) PhoneEpilogAsync(a1,a2,a3,a4,a5)
+
+#endif
+
+typedef struct _PPHONECLOSE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+} PHONECLOSE_PARAMS, *PPHONECLOSE_PARAMS;
+
+typedef struct _PHONECONFIGDIALOG_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    IN  HWND        hwndOwner;
+
+    IN  DWORD       dwDeviceClassOffset;        // valid offset or TAPI_NO_DATA
+
+} PHONECONFIGDIALOG_PARAMS, *PPHONECONFIGDIALOG_PARAMS;
+
+typedef struct _PHONEDEVSPECIFIC_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  DWORD       pfnPostProcessProc;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       lpParams;                   // pointer to client buffer
+
+    IN  DWORD       dwParamsOffset;
+
+    IN  DWORD       dwParamsSize;
+
+} PHONEDEVSPECIFIC_PARAMS, *PPHONEDEVSPECIFIC_PARAMS;
+
+typedef struct _PHONEGETBUTTONINFO_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwButtonLampID;
+
+    union
+    {
+        IN  DWORD   dwButtonInfoTotalSize;      // size of client buffer
+
+        OUT DWORD   dwButtonInfoOffset;         // valid offset on success
+    } u;
+
+} PHONEGETBUTTONINFO_PARAMS, *PPHONEGETBUTTONINFO_PARAMS;
+
+typedef struct _PHONEGETDATA_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwDataID;
+
+    OUT DWORD       dwDataOffset;
+
+    IN  DWORD       dwSize;
+
+} PHONEGETDATA_PARAMS, *PPHONEGETDATA_PARAMS;
+
+typedef struct _PHONEGETDEVCAPS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONEAPP   hPhoneApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtVersion;
+
+    union
+    {
+        IN  DWORD   dwPhoneCapsTotalSize;       // size of client buffer
+
+        OUT DWORD   dwPhoneCapsOffset;          // valid offset on success
+    } u;
+
+} PHONEGETDEVCAPS_PARAMS, *PPHONEGETDEVCAPS_PARAMS;
+
+typedef struct _PHONEGETDISPLAY_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    union
+    {
+        IN  DWORD   dwDisplayTotalSize;         // size of client buffer
+
+        OUT DWORD   dwDisplayOffset;            // valid offset on success
+    } u;
+
+} PHONEGETDISPLAY_PARAMS, *PPHONEGETDISPLAY_PARAMS;
+
+typedef struct _PHONEGETGAIN_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwHookSwitchDev;
+
+    OUT DWORD       dwGain;
+
+} PHONEGETGAIN_PARAMS, *PPHONEGETGAIN_PARAMS;
+
+typedef struct _PHONEGETHOOKSWITCH_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    OUT DWORD       dwHookSwitchDevs;
+
+} PHONEGETHOOKSWITCH_PARAMS, *PPHONEGETHOOKSWITCH_PARAMS;
+
+typedef struct _PHONEGETICON_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwDeviceClassOffset;        // valid offset or TAPI_NO_DATA
+
+    OUT HICON       hIcon;
+
+} PHONEGETICON_PARAMS, *PPHONEGETICON_PARAMS;
+
+typedef struct _PHONEGETID_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    union
+    {
+        IN  DWORD   dwDeviceIDTotalSize;        // size of client buffer
+
+        OUT DWORD   dwDeviceIDOffset;           // valid offset on success
+    } u;
+
+    IN  DWORD       dwDeviceClassOffset;        // always valid offset
+
+} PHONEGETID_PARAMS, *PPHONEGETID_PARAMS;
+
+typedef struct _PHONEGETLAMP_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwButtonLampID;
+
+    OUT DWORD       dwLampMode;
+
+} PHONEGETLAMP_PARAMS, *PPHONEGETLAMP_PARAMS;
+
+typedef struct _PHONEGETRING_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    OUT DWORD       dwRingMode;
+
+    OUT DWORD       dwVolume;
+
+} PHONEGETRING_PARAMS, *PPHONEGETRING_PARAMS;
+
+typedef struct _PHONEGETSTATUS_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    union
+    {
+        IN  DWORD   dwPhoneStatusTotalSize;     // size of client buffer
+
+        OUT DWORD   dwPhoneStatusOffset;        // valid offset on success
+    } u;
+
+} PHONEGETSTATUS_PARAMS, *PPHONEGETSTATUS_PARAMS;
+
+typedef struct _PHONEGETSTATUSMESSAGES_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    OUT DWORD       dwPhoneStates;
+
+    OUT DWORD       dwButtonModes;
+
+    OUT DWORD       dwButtonStates;
+
+} PHONEGETSTATUSMESSAGES_PARAMS, *PPHONEGETSTATUSMESSAGES_PARAMS;
+
+typedef struct _PHONEGETVOLUME_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwHookSwitchDev;
+
+    OUT DWORD       dwVolume;
+
+} PHONEGETVOLUME_PARAMS, *PPHONEGETVOLUME_PARAMS;
+
+typedef struct _PHONEINITIALIZE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    OUT HPHONEAPP   hPhoneApp;
+
+    IN  DWORD       hInstance;
+
+    IN  PHONECALLBACK   lpfnCallback;
+
+    IN  DWORD       dwFriendlyNameOffset;       // always valid offset
+
+    OUT DWORD       dwNumDevs;
+
+    IN  DWORD       dwModuleNameOffset;         // always valid offset
+
+    IN  DWORD       dwAPIVersion;
+
+} PHONEINITIALIZE_PARAMS, *PPHONEINITIALIZE_PARAMS;
+
+typedef struct _PHONENEGOTIATEAPIVERSION_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONEAPP   hPhoneApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPILowVersion;
+
+    IN  DWORD       dwAPIHighVersion;
+
+    OUT DWORD       dwAPIVersion;
+
+    OUT DWORD       dwExtensionIDOffset;        // valid offset if success
+
+    IN OUT  DWORD   dwSize;
+
+} PHONENEGOTIATEAPIVERSION_PARAMS, *PPHONENEGOTIATEAPIVERSION_PARAMS;
+
+typedef struct _PHONENEGOTIATEEXTVERSION_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONEAPP   hPhoneApp;
+
+    IN  DWORD       dwDeviceID;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtLowVersion;
+
+    IN  DWORD       dwExtHighVersion;
+
+    OUT DWORD       dwExtVersion;
+
+} PHONENEGOTIATEEXTVERSION_PARAMS, *PPHONENEGOTIATEEXTVERSION_PARAMS;
+
+typedef struct _PHONEOPEN_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONEAPP   hPhoneApp;
+
+    IN  DWORD       dwDeviceID;
+
+    OUT HPHONE      hPhone;
+
+    IN  DWORD       dwAPIVersion;
+
+    IN  DWORD       dwExtVersion;
+
+    IN  DWORD       dwCallbackInstance;
+
+    IN  DWORD       dwPrivilege;
+
+    //
+    // The following is a "remote phone handle".  When the client is
+    // remotesp.tsp running on a remote machine, this will be some
+    // non-NULL value, and tapisrv should use this handle in status/etc
+    // indications to the client rather than the std hPhone. If the
+    // client is not remote.tsp thne this value will be NULL.
+    //
+
+    IN  HANDLE      hRemotePhone;
+
+} PHONEOPEN_PARAMS, *PPHONEOPEN_PARAMS;
+
+typedef struct _PHONESETBUTTONINFO_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwButtonLampID;
+
+    IN  DWORD       dwButtonInfoOffset;         // always valid offset
+
+} PHONESETBUTTONINFO_PARAMS, *PPHONESETBUTTONINFO_PARAMS;
+
+typedef struct _PHONESETDATA_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwDataID;
+
+    IN  DWORD       dwDataOffset;               // always valid offset
+
+    IN  DWORD       dwSize;
+
+} PHONESETDATA_PARAMS, *PPHONESETDATA_PARAMS;
+
+typedef struct _PHONESETDISPLAY_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwRow;
+
+    IN  DWORD       dwColumn;
+
+    IN  DWORD       dwDisplayOffset;            // always valid offset
+
+    IN  DWORD       dwSize;
+
+} PHONESETDISPLAY_PARAMS, *PPHONESETDISPLAY_PARAMS;
+
+typedef struct _PHONESETGAIN_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwHookSwitchDev;
+
+    IN  DWORD       dwGain;
+
+} PHONESETGAIN_PARAMS, *PPHONESETGAIN_PARAMS;
+
+typedef struct _PHONESETHOOKSWITCH_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwHookSwitchDevs;
+
+    IN  DWORD       dwHookSwitchMode;
+
+} PHONESETHOOKSWITCH_PARAMS, *PPHONESETHOOKSWITCH_PARAMS;
+
+typedef struct _PHONESETLAMP_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwButtonLampID;
+
+    IN  DWORD       dwLampMode;
+
+} PHONESETLAMP_PARAMS, *PPHONESETLAMP_PARAMS;
+
+typedef struct _PHONESETRING_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwRingMode;
+
+    IN  DWORD       dwVolume;
+
+} PHONESETRING_PARAMS, *PPHONESETRING_PARAMS;
+
+typedef struct _PHONESETSTATUSMESSAGES_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwPhoneStates;
+
+    IN  DWORD       dwButtonModes;
+
+    IN  DWORD       dwButtonStates;
+
+} PHONESETSTATUSMESSAGES_PARAMS, *PPHONESETSTATUSMESSAGES_PARAMS;
+
+typedef struct _PHONESETVOLUME_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwRemoteRequestID;
+
+    IN  HPHONE      hPhone;
+
+    IN  DWORD       dwHookSwitchDev;
+
+    IN  DWORD       dwVolume;
+
+} PHONESETVOLUME_PARAMS, *PPHONESETVOLUME_PARAMS;
+
+typedef struct _PHONESHUTDOWN_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HPHONEAPP   hPhoneApp;
+
+} PHONESHUTDOWN_PARAMS, *PPHONESHUTDOWN_PARAMS;
+
+
+#define AllPhoneStates1_0          \
+    (PHONESTATE_OTHER            | \
+    PHONESTATE_CONNECTED         | \
+    PHONESTATE_DISCONNECTED      | \
+    PHONESTATE_OWNER             | \
+    PHONESTATE_MONITORS          | \
+    PHONESTATE_DISPLAY           | \
+    PHONESTATE_LAMP              | \
+    PHONESTATE_RINGMODE          | \
+    PHONESTATE_RINGVOLUME        | \
+    PHONESTATE_HANDSETHOOKSWITCH | \
+    PHONESTATE_HANDSETVOLUME     | \
+    PHONESTATE_HANDSETGAIN       | \
+    PHONESTATE_SPEAKERHOOKSWITCH | \
+    PHONESTATE_SPEAKERVOLUME     | \
+    PHONESTATE_SPEAKERGAIN       | \
+    PHONESTATE_HEADSETHOOKSWITCH | \
+    PHONESTATE_HEADSETVOLUME     | \
+    PHONESTATE_HEADSETGAIN       | \
+    PHONESTATE_SUSPEND           | \
+    PHONESTATE_RESUME            | \
+    PHONESTATE_DEVSPECIFIC       | \
+    PHONESTATE_REINIT)
+
+#define AllPhoneStates1_4          \
+    (PHONESTATE_OTHER            | \
+    PHONESTATE_CONNECTED         | \
+    PHONESTATE_DISCONNECTED      | \
+    PHONESTATE_OWNER             | \
+    PHONESTATE_MONITORS          | \
+    PHONESTATE_DISPLAY           | \
+    PHONESTATE_LAMP              | \
+    PHONESTATE_RINGMODE          | \
+    PHONESTATE_RINGVOLUME        | \
+    PHONESTATE_HANDSETHOOKSWITCH | \
+    PHONESTATE_HANDSETVOLUME     | \
+    PHONESTATE_HANDSETGAIN       | \
+    PHONESTATE_SPEAKERHOOKSWITCH | \
+    PHONESTATE_SPEAKERVOLUME     | \
+    PHONESTATE_SPEAKERGAIN       | \
+    PHONESTATE_HEADSETHOOKSWITCH | \
+    PHONESTATE_HEADSETVOLUME     | \
+    PHONESTATE_HEADSETGAIN       | \
+    PHONESTATE_SUSPEND           | \
+    PHONESTATE_RESUME            | \
+    PHONESTATE_DEVSPECIFIC       | \
+    PHONESTATE_REINIT            | \
+    PHONESTATE_CAPSCHANGE        | \
+    PHONESTATE_REMOVED)
+
+#define AllButtonModes             \
+    (PHONEBUTTONMODE_DUMMY       | \
+    PHONEBUTTONMODE_CALL         | \
+    PHONEBUTTONMODE_FEATURE      | \
+    PHONEBUTTONMODE_KEYPAD       | \
+    PHONEBUTTONMODE_LOCAL        | \
+    PHONEBUTTONMODE_DISPLAY)
+
+#define AllButtonStates1_0         \
+    (PHONEBUTTONSTATE_UP         | \
+    PHONEBUTTONSTATE_DOWN)
+
+#define AllButtonStates1_4         \
+    (PHONEBUTTONSTATE_UP         | \
+    PHONEBUTTONSTATE_DOWN        | \
+    PHONEBUTTONSTATE_UNKNOWN     | \
+    PHONEBUTTONSTATE_UNAVAIL)
diff --git a/private/tapi/dev/server/private.h b/private/tapi/dev/server/private.h
new file mode 100644
index 000000000..0e067a518
--- /dev/null
+++ b/private/tapi/dev/server/private.h
@@ -0,0 +1,304 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    private.h
+
+Abstract:
+
+    Header file for tapi server
+
+Author:
+
+    Dan Knudson (DanKn)    01-Apr-1995
+
+Revision History:
+
+--*/
+
+
+//
+// Func protos from line.c, phone.c, tapi.c (needed for gaFuncs def)
+//
+
+void WINAPI GetAsyncEvents              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI GetUIDllName                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TUISPIDLLCallback           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI FreeDialogInstance          (LPVOID, LPBYTE, LPDWORD);
+
+void WINAPI LAccept                     (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LAddToConference            (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LAgentSpecific              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LAnswer                     (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LBlindTransfer              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LClose                      (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LCompleteCall               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LCompleteTransfer           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LDeallocateCall             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LDevSpecific                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LDevSpecificFeature         (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LDial                       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LDrop                       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LForward                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGatherDigits               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGenerateDigits             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGenerateTone               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAddressCaps             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAddressID               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAddressStatus           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAgentActivityList       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAgentCaps               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAgentGroupList          (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAgentStatus             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetAppPriority             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetCallAddressID           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetCallInfo                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetCallStatus              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetConfRelatedCalls        (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetCountry                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetDevCaps                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetDevConfig               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetIcon                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetID                      (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetLineDevStatus           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetNewCalls                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetNumAddressIDs           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetNumRings                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetProviderList            (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetRequest                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LGetStatusMessages          (LPVOID, LPBYTE, LPDWORD);
+//IN TAPI32.DLL now: void WINAPI LGetTranslateCaps           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LHandoff                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LHold                       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LInitialize                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LMakeCall                   (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LMonitorDigits              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LMonitorMedia               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LMonitorTones               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LNegotiateAPIVersion        (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LNegotiateExtVersion        (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LOpen                       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LPark                       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LPickup                     (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LPrepareAddToConference     (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LProxyMessage               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LProxyResponse              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LRedirect                   (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LRegisterRequestRecipient   (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LReleaseUserUserInfo        (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LRemoveFromConference       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSecureCall                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSendUserUserInfo           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetAgentActivity           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetAgentGroup              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetAgentState              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetAppPriority             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetAppSpecific             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetCallData                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetCallParams              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetCallPrivilege           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetCallQualityOfService    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetCallTreatment           (LPVOID, LPBYTE, LPDWORD);
+//IN TAPI32.DLL now: void WINAPI LSetCurrentLocation         (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetDefaultMediaDetection   (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetDevConfig               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetLineDevStatus           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetMediaControl            (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetMediaMode               (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetNumRings                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetStatusMessages          (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetTerminal                (LPVOID, LPBYTE, LPDWORD);
+//IN TAPI32.DLL now: void WINAPI LSetTollList                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetupConference            (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSetupTransfer              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LShutdown                   (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LSwapHold                   (LPVOID, LPBYTE, LPDWORD);
+//IN TAPI32.DLL now: void WINAPI LTranslateAddress           (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LUncompleteCall             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LUnhold                     (LPVOID, LPBYTE, LPDWORD);
+void WINAPI LUnpark                     (LPVOID, LPBYTE, LPDWORD);
+
+void WINAPI PClose                      (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PDevSpecific                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetButtonInfo              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetData                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetDevCaps                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetDisplay                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetGain                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetHookSwitch              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetID                      (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetIcon                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetLamp                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetRing                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetStatus                  (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetStatusMessages          (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PGetVolume                  (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PInitialize                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI POpen                       (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PNegotiateAPIVersion        (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PNegotiateExtVersion        (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetButtonInfo              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetData                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetDisplay                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetGain                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetHookSwitch              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetLamp                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetRing                    (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetStatusMessages          (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PSetVolume                  (LPVOID, LPBYTE, LPDWORD);
+void WINAPI PShutdown                   (LPVOID, LPBYTE, LPDWORD);
+
+//IN TAPI32.DLL now: void WINAPI TGetLocationInfo            (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TRequestDrop                (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TRequestMakeCall            (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TRequestMediaCall           (LPVOID, LPBYTE, LPDWORD);
+//void WINAPI TMarkLineEvent              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TReadLocations              (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TWriteLocations             (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TAllocNewID                 (LPVOID, LPBYTE, LPDWORD);
+void WINAPI TPerformance                (LPVOID, LPBYTE, LPDWORD);
+
+
+typedef void (WINAPI *TAPISRVPROC)(LPVOID, LPBYTE, LPDWORD);
+
+TAPISRVPROC gaFuncs[] =
+{
+    GetAsyncEvents,
+    GetUIDllName,
+    TUISPIDLLCallback,
+    FreeDialogInstance,
+
+    LAccept,
+    LAddToConference,
+    LAgentSpecific,
+    LAnswer,
+    LBlindTransfer,
+    LClose,
+    LCompleteCall,
+    LCompleteTransfer,
+    LDeallocateCall,
+    LDevSpecific,
+    LDevSpecificFeature,
+    LDial,
+    LDrop,
+    LForward,
+    LGatherDigits,
+    LGenerateDigits,
+    LGenerateTone,
+    LGetAddressCaps,
+    LGetAddressID,
+    LGetAddressStatus,
+    LGetAgentActivityList,
+    LGetAgentCaps,
+    LGetAgentGroupList,
+    LGetAgentStatus,
+    LGetAppPriority,
+    LGetCallAddressID,
+    LGetCallInfo,
+    LGetCallStatus,
+    LGetConfRelatedCalls,
+    LGetCountry,
+    LGetDevCaps,
+    LGetDevConfig,
+    LGetIcon,
+    LGetID,
+    LGetLineDevStatus,
+    LGetNewCalls,
+    LGetNumAddressIDs,
+    LGetNumRings,
+    LGetProviderList,
+    LGetRequest,
+    LGetStatusMessages,
+//IN TAPI32.DLL now:     LGetTranslateCaps,
+    LHandoff,
+    LHold,
+    LInitialize,
+    LMakeCall,
+    LMonitorDigits,
+    LMonitorMedia,
+    LMonitorTones,
+    LNegotiateAPIVersion,
+    LNegotiateExtVersion,
+    LOpen,
+    LPark,
+    LPickup,
+    LPrepareAddToConference,
+    LProxyMessage,
+    LProxyResponse,
+    LRedirect,
+    LRegisterRequestRecipient,
+    LReleaseUserUserInfo,
+    LRemoveFromConference,
+    LSecureCall,
+    LSendUserUserInfo,
+    LSetAgentActivity,
+    LSetAgentGroup,
+    LSetAgentState,
+    LSetAppPriority,
+    LSetAppSpecific,
+    LSetCallData,
+    LSetCallParams,
+    LSetCallPrivilege,
+    LSetCallQualityOfService,
+    LSetCallTreatment,
+//IN TAPI32.DLL now:     LSetCurrentLocation,
+    LSetDefaultMediaDetection,
+    LSetDevConfig,
+    LSetLineDevStatus,
+    LSetMediaControl,
+    LSetMediaMode,
+    LSetNumRings,
+    LSetStatusMessages,
+    LSetTerminal,
+//IN TAPI32.DLL now:     LSetTollList,
+    LSetupConference,
+    LSetupTransfer,
+    LShutdown,
+    LSwapHold,
+//IN TAPI32.DLL now:     LTranslateAddress,
+    LUncompleteCall,
+    LUnhold,
+    LUnpark,
+
+    PClose,
+    PDevSpecific,
+    PGetButtonInfo,
+    PGetData,
+    PGetDevCaps,
+    PGetDisplay,
+    PGetGain,
+    PGetHookSwitch,
+    PGetID,
+    PGetIcon,
+    PGetLamp,
+    PGetRing,
+    PGetStatus,
+    PGetStatusMessages,
+    PGetVolume,
+    PInitialize,
+    POpen,
+    PNegotiateAPIVersion,
+    PNegotiateExtVersion,
+    PSetButtonInfo,
+    PSetData,
+    PSetDisplay,
+    PSetGain,
+    PSetHookSwitch,
+    PSetLamp,
+    PSetRing,
+    PSetStatusMessages,
+    PSetVolume,
+    PShutdown,
+
+//IN TAPI32.DLL now:     TGetLocationInfo,
+    TRequestDrop,
+    TRequestMakeCall,
+    TRequestMediaCall,
+//    TMarkLineEvent,
+    TReadLocations,
+    TWriteLocations,
+    TAllocNewID,
+    TPerformance
+};
diff --git a/private/tapi/dev/server/resource.h b/private/tapi/dev/server/resource.h
new file mode 100644
index 000000000..b6775faf4
--- /dev/null
+++ b/private/tapi/dev/server/resource.h
@@ -0,0 +1,283 @@
+//
+// (c) 1995 Microsoft Corporation.  Portions Copyright Intel/Microsoft 1992-93.  All Rights Reserved."
+//
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by TELEPHON.RC
+//
+#define IDS_DC_GL_DRIVER_SETUP          1
+#define IDS_DT_GL_DRIVER_LIST           2
+#define IDCL_CR_HELP                    3
+#define IDS_DC_GL_LOCATION              4
+#define ID_CURRENT                      4
+#define IDS_DT_GL_LOC_LIST              5
+#define IDS_DC_GL_CALL_CARD             6
+#define ID_NEW                          6
+#define IDS_DT_GL_CARD_LIST             7
+#define IDS_TITLE                       8
+#define IDS_STATUS_LINE                 9
+#define IDHELP                          9
+#define IDS_HELP_FILE                   10
+#define IDS_CLOSE                       11
+#define IDS_CUSTOMIZE                   12
+#define IDS_ADD_LOCATION                13
+#define IDS_EDIT_LOCATION               14
+#define IDS_WRN_REMOVE_CARD             15
+#define IDS_ERR_APPLICATION             16
+#define IDS_ERR_MEMORY                  17
+#define IDS_ERR_ALREADY_IN_LIST         18
+#define IDS_ERR_READ_PRIV_INI           19
+#define IDS_ERR_WRITE_INI               20
+#define IDS_ERR_INVALID_INI             21
+#define IDS_ERR_WRITE_WIN_INI           22
+#define IDS_WRN_INVALID_STR             23
+#define IDS_WRN_INVALID_EX_NUM_STR      24
+#define IDS_WRN_INVALID_NUM             25
+#define IDS_ERR_INVALID_TAPIADDR        26
+#define IDS_WRN_INI_READ_ONLY           27
+#define IDS_DT_DS_NO_DRIVER             28
+#define IDS_ERR_NO_DRIVER               29
+#define IDS_ERR_BAD_DRIVER              30
+#define IDS_NONE                        31
+#define IDS_ADD_CALLING_CARD            32
+#define IDS_EDIT_CALLING_CARD           33
+#define IDS_CARD_REMOVE_OR_STUPID       34
+#define IDS_LOCATION_REMOVE_OR_STUPID   35
+#define IDS_DRIVER_REMOVE_OR_STUPID     36
+#define IDS_ERR_INVALID_INI_LOCATIONS   37
+#define IDS_ERR_INVALID_INI_CARDS       38
+#define IDD_BROWSE_TEMPLATE             38
+#define IDS_ERR_INVALID_INI_DRIVERS     39
+
+#ifndef CHICAGO
+#define IDS_ERR_INVALID_INI_COUNTRIES   40
+#endif
+
+#define IDS_WRN_AREA_CODE_REQUIRED      41
+#define IDS_WRN_INVALID_NUM_STR         42
+#define IDS_WRN_INVALID_LOCATION_CARD   43
+#define IDS_WRN_DRIVER_IN_USE           44
+#define IDS_ERR_DRIVER_FAILED           45
+#define IDS_ERR_MULTIPLE_INST           46
+
+#define IDS_DIAL_ASST                   47
+#define IDS_ERR_UPDATE_LOCATION          48
+#define IDS_ERR_UPDATE_CARD              49
+#define IDS_WRN_LOCATION_NAME_REQUIRED  50
+#define IDS_WRN_CANNOT_CHANGE_DEF_LOC   51
+#define IDS_WRN_LOCATION_NAME_REQUIRED  50
+
+#define IDS_PROVIDERERROR_NOT_AN_SP     52
+#define IDS_PROVIDERERROR_TOO_OLD       53
+#define IDS_PROVIDERERROR_FAILED_INIT   54
+#define IDS_WRN_CARD_NAME_REQUIRED  	 55
+#define IDS_WRN_QUITING_WIZ            56
+
+#define IDS_WRN_CANT_REMOVE_LAST_CARD   57
+
+#define IDS_WRN_CARD_NUMBER_REQUIRED    58
+#define IDS_MSG_SIMPLEMSG_MDMINSTALLED  59
+
+
+#define IDD_TELEPHONY                   101
+#define IDD_GENERIC_LIST                102
+#define IDD_TOLL_LIST                   104
+#define IDD_CREDIT_CARD                 105
+#define IDD_DIALING_RULES               106
+#define IDI_TELEPHONY                   108
+#define IDD_COPY_DIAL_RULES             109
+#define IDD_ADD_DRIVER                  111
+#define IDD_DEFINE_LOCATION             112
+#define IDD_DEFINE_LOCATION_SIMPLE      113
+#define IDD_DRIVER_SETUP                116
+#define IDD_INSTALL_DRIVER              117
+#define IDB_BITMAP1                     120
+#define IDD_DEBUG_OUT                   121
+#define ID_LIST                         303
+#define LB_UNLISTED                     306
+
+#define IDS_WRN_TITLE_WARNING           350
+#define IDS_WRN_TITLE_NAMEINUSE         351
+#define IDS_WRN_TITLE_INVALCHAR         352
+#define IDS_WRN_TITLE_SURE              353
+#define IDS_WRN_TITLE_REQUIRED          354
+
+#define IDCC_TM_CURR_LOCATION           1000
+#define IDD_INSERT_DISK                 1000
+#define IDD_BROWSE                      1001
+#define IDD_UNLISTED_DRIVERS            1002
+#define IDD_UPDATE                      1003
+#define IDD_RESTART                     1004
+#define IDD_EXISTS                      1005
+#define IDCB_TM_MULT_LOCATIONS          1007
+#define IDCB_TM_DRIVER_SETUP            1008
+#define IDCB_TM_HELP                    1009
+#define IDCB_GL_REMOVE                  1011
+#define IDCB_TL_REMOVE                  1012
+#define IDCB_TL_ADD                     1013
+#define IDCB_TL_HELP                    1014
+#define IDCK_TL_USE_AREA_CODE           1015
+#define IDCT_GL_LIST_TEXT               1017
+#define IDCB_CC_CUSTOMIZE               1018
+#define IDCB_CC_HELP                    1019
+#define IDCE_CC_CARD_NAME               1020
+#define IDCE_CC_CARD_NUM                1021
+#define IDCB_DR_COPY_FROM               1022
+#define IDCE_CC_PASSWORD_CARD_NUM       1022
+#define IDCB_DR_HELP                    1023
+#define IDCE_DR_LOCAL_NUM               1024
+#define IDCE_DR_LONG_NUM                1025
+#define IDCE_DR_INTERNATIONAL_NUM       1026
+#define IDCL_CR_RULE_LIST               1031
+#define IDCB_AD_ADD                     1032
+#define IDCB_AD_BROWSE                  1033
+#define IDCH_AD_HELP                    1034
+#define IDCE_DL_CURR_LOCATION           1035
+#define IDCE_DL_LOCAL_CALLS             1036
+#define IDCE_DL_LONG_DIST_CALLS         1037
+#define IDCE_DL_AREA_CODE               1038
+#define psh15                           0x040e
+#define IDCC_DL_COUNTRY_CODE            1039
+#define IDCC_DL_CALLING_CARD            1040
+#define chx1                            0x0410
+#define IDCB_DL_TOLL_LIST               1041
+#define IDCL_AD_DRIVER_LIST             1042
+#define IDCB_DL_CALLCARD_SETUP          1052
+#define IDCB_DL_HELP                    1053
+#define IDCC_TL_TOLL_LIST               1055
+#define IDCB_DS_EDIT                    1056
+#define IDCL_DS_LIST                    1057
+#define IDCB_DS_ADD                     1058
+#define IDCB_DS_REMOVE                  1059
+#define IDCB_DS_HELP                    1060
+#define IDCK_DR_HIDE_CARD               1061
+#define IDCS_TM_LOCAL_CALLS             1062
+#define IDCS_TM_LONG_DIST_CALLS         1063
+#define IDCS_TM_AREA_CODE               1064
+#define IDCS_TM_COUNTRY_CODE            1065
+#define IDCS_TM_CALLING_CARD            1066
+#define IDCB_INSTALL_BROWSE             1067
+#define IDC_BUTTON2                     1068
+#define IDCB_ID_HELP                    1068
+#define IDC_EDIT1                       1069
+#define IDCE_PATHNAME                   1069
+#define IDT_DEBUG                       1070
+#define IDCB_TM_CALLCARD_SETUP          1081
+#define IDCB_GL_EDIT                    1083
+#define stc1                            0x0440
+#define stc2                            0x0441
+#define IDCB_GL_ADD                     1109
+#define IDCB_GL_HELP                    1112
+#define lst1                            0x0460
+#define IDCL_GL_LIST                    1121
+#define lst2                            0x0461
+#define cmb1                            0x0470
+#define cmb2                            0x0471
+#define edt1                            0x0480
+#define ctlLast                         0x04ff
+#define IDS_NAME                        2001
+#define IDS_NAME2                       2002
+#define IDS_NOINF                       2003
+#define IDS_NOINF2                      2004
+#define IDS_OUTOFDISK                   2005
+#define IDS_NOINF3                      2006
+#define IDS_NAME3                       2007
+#define IDS_RESTARTTEXT                 2015
+#define IDS_UPDATED                     2031
+#define IDS_UNLISTED                    2034
+#define IDS_UNABLE_TOINSTALL            2049
+#define IDS_FILEINUSEADD                2053
+#define IDS_FILEINUSEREM                2055
+#define IDS_FILEINUSEREM2               2056
+#define IDS_DRIVER_EXISTS               2058
+#define IDS_DIAL_ASST_NOT_SET                2059
+#define IDS_WRN_DIAL_ASST_NOT_SET        2060
+#define ID_STATUS2                      4002
+#define IDS_FILENOTINDIR                0x2001
+#define IDS_DISKMSG                     0x2002
+#define IDS_FILEMSG                     0x2003
+#define IDS_DISKFILEMSG                 0x2004
+#define IDH_DLG_ADD_UNKNOWN             8803
+#define IDD_PATH                        0x3002
+#define IDD_TEXT                        0x3003
+#define IDD_ICON                        0x3004
+#define IDC_STATIC                      -1
+
+#define IDCC_DL_CURR_LOCATION                5000
+#define IDCB_DL_NEW_LOCATION                 5001
+#define IDCK_DL_IN_LOCAL                     5002
+#define IDCB_DL_REMOVE_LOCATION          5003
+#define IDCB_DL_CHANGE_CARD              5004
+#define IDCK_DL_CALLING_CARD                 5005
+#define IDCK_DL_CALL_WAITING                 5006
+#define IDCK_DL_PULSE_DIAL                   5007
+#define IDCC_DL_CALL_WAITING                 5008
+#define IDCE_DL_CALLING_CARD                 5009
+#define IDCS_DL_CURR_LOCATION            5010
+#define IDCS_DL_AREA_CODE                5011
+#define IDCS_DL_COUNTRY_CODE             5012
+#define IDCS_DL_OUTSIDE                  5013
+#define IDCS_DL_LOCAL_CALLS              5014
+#define IDCS_DL_LONG_DIST_CALLS          5015
+
+#define IDCS_DL_SILENTTEXT               5016
+
+
+
+#define IDCC_DR_CARD_NAME               6000
+#define IDCE_DR_CARD_NUM                6001
+#define IDCK_DR_IN_LOCAL                     6002
+#define IDCB_DR_NEW_CARD                     6003
+#define IDCB_DR_REMOVE_CARD              6004
+#define IDCB_DR_ADVANCED                     6005
+#define IDCS_DR_CARD_NAME                   6006
+#define IDCS_DR_CARD_NUM                    6007
+#define IDCS_DR_LOCAL_NUM                   6008
+#define IDCS_DR_LONG_NUM                    6009
+#define IDCS_DR_INTERNATIONAL_NUM           6010
+#define IDCB_DR_DUMMY						 6011
+
+#define IDCR_PULSE                          6050
+#define IDCR_TONE                               6051
+#define IDCS_PULSE                       6052
+#define IDCS_TONE                        6053
+
+#define IDD_NEW_LOCATION                    7000
+#define IDCE_NL_NEW_LOCATION                7001
+#define IDCS_NL_NEW_LOCATION                7002
+
+#define IDD_NEW_CARD                            8000
+#define IDCE_NC_NEW_CARD                    8001
+#define IDCS_NC_NEW_CARD                    8002
+#define IDCS_CR_RULE_LIST                   8003
+
+#define IDCS_DIAL_NUMBER_TEXT               9000
+#define IDCS_DL_DIAL_NUMBER             9001
+#define IDCS_DR_DIAL_NUMBER             9002
+#define IDCS_LOC_BMP                            9100
+#define IDCL_LOC_BMP                            9101
+#define IDCL_LOC_SIMPLE_BMP             9102
+
+#define IDD_CALLING_CARD_CHANGE         9150
+
+/* ALERT! Do NOT change this value. It is used by the RNA guys
+ * to identify the Dialing info dialog for their Modems Wizard.
+ */
+#define IDD_WIZ_DIALINFO					400
+
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        122
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1071
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
+
+
+#define RC_COUNTRY_ID_BASE      16000
+
diff --git a/private/tapi/dev/server/resource.old b/private/tapi/dev/server/resource.old
new file mode 100644
index 000000000..51daad9ed
--- /dev/null
+++ b/private/tapi/dev/server/resource.old
@@ -0,0 +1,31 @@
+#define IDCS_DL_CURR_LOCATION   1001
+#define IDCC_DL_CURR_LOCATION   1002
+#define IDCB_DL_NEW_LOCATION    1003
+#define IDCB_DL_REMOVE_LOCATION 1004
+#define IDCS_DL_AREA_CODE       1005
+#define IDCE_DL_AREA_CODE       1006
+#define IDCS_DL_COUNTRY_CODE    1007
+#define IDCC_DL_COUNTRY_CODE    1008
+#define IDCS_DL_OUTSIDE         1009
+#define IDCE_DL_LOCAL_CALLS     1010
+#define IDCS_DL_LOCAL_CALLS     1011
+#define IDCE_DL_LONG_DIST_CALLS 1012
+#define IDCS_DL_LONG_DIST_CALLS 1013
+#define IDCK_DL_CALLING_CARD    1014
+#define IDCE_DL_CALLING_CARD    1015
+#define IDCB_DL_CHANGE_CARD     1016
+#define IDCK_DL_CALL_WAITING    1017
+#define IDCC_DL_CALL_WAITING    1018
+#define IDCS_PULSE              1019
+#define IDCR_TONE               1020
+#define IDCR_PULSE              1021
+#define IDCS_DIAL_NUMBER_TEXT   1022
+#define IDCS_DL_DIAL_NUMBER     1023
+#define IDCK_DL_IN_LOCAL        1024
+
+#define IDC_STATIC              55
+
+#define IDD_DEFINE_LOCATION     112
+
+
+#define RC_COUNTRY_ID_BASE      16000
diff --git a/private/tapi/dev/server/server.c b/private/tapi/dev/server/server.c
new file mode 100644
index 000000000..b43c2984a
--- /dev/null
+++ b/private/tapi/dev/server/server.c
@@ -0,0 +1,5859 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    server.c
+
+Abstract:
+
+    Src module for tapi server
+
+Author:
+
+    Dan Knudson (DanKn)    01-Apr-1995
+
+Revision History:
+
+--*/
+
+
+#define MYTEST  1
+
+
+#include "windows.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "assert.h"
+#include "process.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "..\client\client.h"
+#include "server.h"
+#include "private.h"
+#include "tapsrv.h"
+#include "..\perfdll\tapiperf.h"
+
+// PERF
+PERFBLOCK   PerfBlock;
+BOOL InitPerf();
+
+HANDLE  ghToken;
+
+TAPIGLOBALS TapiGlobals;
+
+BOOL    gbPriorityListsInitialized = FALSE;
+BOOL    gbQueueSPEvents = FALSE;
+
+CRITICAL_SECTION    gSafeMutexCritSec,
+                    gRemoteCliEventBufCritSec,
+                    gRequestIDCritSec,
+                    gPriorityListCritSec,
+                    gSPEventQueueCritSec;
+
+PSPEVENT    gpOldestSPEvent = NULL, gpYoungestSPEvent = NULL;
+HANDLE  ghPendingSPEventsEvent;
+
+#define MIN_WAIT_HINT 60000
+
+DWORD   gdwServiceState = SERVICE_START_PENDING,
+        gdwWaitHint = MIN_WAIT_HINT,
+        gdwCheckPoint = 0;
+
+#if DBG
+//TCHAR gszDebugKey[] = "Software\\Microsoft\\Windows\\" \
+//                      "CurrentVersion\\Telephony\\Debug";
+char gszTapiSrvDebugLevel[] = "TapiSrvDebugLevel";
+#endif
+char gszProvider[] = "Provider";
+char gszNumLines[] = "NumLines";
+char gszUIDllName[] = "UIDllName";
+char gszNumPhones[] = "NumPhones";
+char gszSyncLevel[] = "SyncLevel";
+char gszProviders[] = "Providers";
+   
+WCHAR  gszProviderIDW[] = L"ProviderID";
+//char gszTelephonIni[] = "telephon.ini";
+char gszNumProviders[] = "NumProviders";
+char gszNextProviderID[] = "NextProviderID";
+WCHAR gszRequestMakeCallW[] = L"RequestMakeCall";
+WCHAR gszRequestMediaCallW[] = L"RequestMediaCall";
+WCHAR gszProviderFilenameW[] = L"ProviderFilename";
+
+char gszRegKeyHandoffPriorities[] = "Software\\Microsoft\\Windows\\" \
+        "CurrentVersion\\Telephony\\HandoffPriorities";
+
+char gszRegKeyTelephony[] = "Software\\Microsoft\\Windows\\" \
+        "CurrentVersion\\Telephony";
+
+char gszRegKeyProviders[] = "Software\\Microsoft\\Windows\\" \
+        "CurrentVersion\\Telephony\\Providers";
+
+
+WCHAR *gaszMediaModes[] =
+{
+    L"",
+    L"unknown",
+    L"interactivevoice",
+    L"automatedvoice",
+    L"datamodem",
+    L"g3fax",
+    L"tdd",
+    L"g4fax",
+    L"digitaldata",
+    L"teletex",
+    L"videotex",
+    L"telex",
+    L"mixed",
+    L"adsi",
+    L"voiceview",
+    NULL
+};
+
+char *gaszTSPIFuncNames[] =
+{
+    "TSPI_lineAccept",
+    "TSPI_lineAddToConference",
+    "TSPI_lineAgentSpecific",
+    "TSPI_lineAnswer",
+    "TSPI_lineBlindTransfer",
+    "TSPI_lineClose",
+    "TSPI_lineCloseCall",
+    "TSPI_lineCompleteCall",
+    "TSPI_lineCompleteTransfer",
+    "TSPI_lineConditionalMediaDetection",
+    "TSPI_lineDevSpecific",
+    "TSPI_lineDevSpecificFeature",
+    "TSPI_lineDial",
+    "TSPI_lineDrop",
+    "TSPI_lineForward",
+    "TSPI_lineGatherDigits",
+    "TSPI_lineGenerateDigits",
+    "TSPI_lineGenerateTone",
+    "TSPI_lineGetAddressCaps",
+    "TSPI_lineGetAddressID",
+    "TSPI_lineGetAddressStatus",
+    "TSPI_lineGetAgentActivityList",
+    "TSPI_lineGetAgentCaps",
+    "TSPI_lineGetAgentGroupList",
+    "TSPI_lineGetAgentStatus",
+    "TSPI_lineGetCallAddressID",
+    "TSPI_lineGetCallInfo",
+    "TSPI_lineGetCallStatus",
+    "TSPI_lineGetDevCaps",
+    "TSPI_lineGetDevConfig",
+    "TSPI_lineGetExtensionID",
+    "TSPI_lineGetIcon",
+    "TSPI_lineGetID",
+    "TSPI_lineGetLineDevStatus",
+    "TSPI_lineGetNumAddressIDs",
+    "TSPI_lineHold",
+    "TSPI_lineMakeCall",
+    "TSPI_lineMonitorDigits",
+    "TSPI_lineMonitorMedia",
+    "TSPI_lineMonitorTones",
+    "TSPI_lineNegotiateExtVersion",
+    "TSPI_lineNegotiateTSPIVersion",
+    "TSPI_lineOpen",
+    "TSPI_linePark",
+    "TSPI_linePickup",
+    "TSPI_linePrepareAddToConference",
+    "TSPI_lineRedirect",
+    "TSPI_lineReleaseUserUserInfo",
+    "TSPI_lineRemoveFromConference",
+    "TSPI_lineSecureCall",
+    "TSPI_lineSelectExtVersion",
+    "TSPI_lineSendUserUserInfo",
+    "TSPI_lineSetAgentActivity",
+    "TSPI_lineSetAgentGroup",
+    "TSPI_lineSetAgentState",
+    "TSPI_lineSetAppSpecific",
+    "TSPI_lineSetCallData",
+    "TSPI_lineSetCallParams",
+    "TSPI_lineSetCallQualityOfService",
+    "TSPI_lineSetCallTreatment",
+    "TSPI_lineSetCurrentLocation",
+    "TSPI_lineSetDefaultMediaDetection",
+    "TSPI_lineSetDevConfig",
+    "TSPI_lineSetLineDevStatus",
+    "TSPI_lineSetMediaControl",
+    "TSPI_lineSetMediaMode",
+    "TSPI_lineSetStatusMessages",
+    "TSPI_lineSetTerminal",
+    "TSPI_lineSetupConference",
+    "TSPI_lineSetupTransfer",
+    "TSPI_lineSwapHold",
+    "TSPI_lineUncompleteCall",
+    "TSPI_lineUnhold",
+    "TSPI_lineUnpark",
+    "TSPI_phoneClose",
+    "TSPI_phoneDevSpecific",
+    "TSPI_phoneGetButtonInfo",
+    "TSPI_phoneGetData",
+    "TSPI_phoneGetDevCaps",
+    "TSPI_phoneGetDisplay",
+    "TSPI_phoneGetExtensionID",
+    "TSPI_phoneGetGain",
+    "TSPI_phoneGetHookSwitch",
+    "TSPI_phoneGetIcon",
+    "TSPI_phoneGetID",
+    "TSPI_phoneGetLamp",
+    "TSPI_phoneGetRing",
+    "TSPI_phoneGetStatus",
+    "TSPI_phoneGetVolume",
+    "TSPI_phoneNegotiateExtVersion",
+    "TSPI_phoneNegotiateTSPIVersion",
+    "TSPI_phoneOpen",
+    "TSPI_phoneSelectExtVersion",
+    "TSPI_phoneSetButtonInfo",
+    "TSPI_phoneSetData",
+    "TSPI_phoneSetDisplay",
+    "TSPI_phoneSetGain",
+    "TSPI_phoneSetHookSwitch",
+    "TSPI_phoneSetLamp",
+    "TSPI_phoneSetRing",
+    "TSPI_phoneSetStatusMessages",
+    "TSPI_phoneSetVolume",
+    "TSPI_providerCreateLineDevice",
+    "TSPI_providerCreatePhoneDevice",
+    "TSPI_providerEnumDevices",
+    "TSPI_providerFreeDialogInstance",
+    "TSPI_providerGenericDialogData",
+    "TSPI_providerInit",
+    "TSPI_providerShutdown",
+    "TSPI_providerUIIdentify",
+    NULL
+};
+
+PTPROVIDER pRemoteSP = (PTPROVIDER) NULL;
+
+#if DBG
+DWORD   gdwDebugLevel;
+#endif
+
+
+struct
+{
+    HANDLE          hThread;
+
+    DWORD           dwEventBufferTotalSize;
+
+    DWORD           dwEventBufferUsedSize;
+
+    LPBYTE          pEventBuffer;
+
+    LPBYTE          pDataIn;
+
+    LPBYTE          pDataOut;
+
+    PASYNCEVENTMSG  pMsg;
+
+    DWORD           dwMsgSize;
+
+    HANDLE          hEvent;
+
+    BOOL            bExit;
+
+} gEventNotificationThreadParams;
+
+
+void
+EventNotificationThread(
+    LPVOID  pParams
+    );
+
+VOID
+ServiceMain(
+    DWORD   dwArgc,
+    LPTSTR *lpszArgv
+    );
+
+void
+PASCAL
+LineEventProc(
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+void
+CALLBACK
+LineEventProcSP(
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+void
+PASCAL
+PhoneEventProc(
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+void
+CALLBACK
+PhoneEventProcSP(
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+PTLINELOOKUPENTRY
+GetLineLookupEntry(
+    DWORD   dwDeviceID
+    );
+
+PTPHONELOOKUPENTRY
+GetPhoneLookupEntry(
+    DWORD   dwDeviceID
+    );
+
+char *
+PASCAL
+MapResultCodeToText(
+    LONG    lResult,
+    char   *pszResult
+    );
+
+DWORD
+InitSecurityDescriptor(
+    PSECURITY_DESCRIPTOR pSecurityDescriptor
+    );
+
+void
+PASCAL
+GetPriorityList(
+    HKEY    hKeyHandoffPriorities,
+    WCHAR  *pszListName,
+    WCHAR **ppszPriorityList
+    );
+
+void
+PASCAL
+SetPriorityList(
+    HKEY    hKeyHandoffPriorities,
+    WCHAR  *pszListName,
+    WCHAR  *pszPriorityList
+    );
+
+void
+SPEventHandlerThread(
+    LPVOID  pParams
+    );
+
+
+VOID
+__cdecl
+main(
+    void
+    )
+{
+    if (!(GetVersion() & 0x80000000)) // Win NT
+    {
+        
+        SERVICE_TABLE_ENTRY dispatchTable[] = {
+            { TEXT("Telephony Service"), (LPSERVICE_MAIN_FUNCTION) ServiceMain },
+            { NULL, NULL }
+        };
+
+        InitPerf();
+
+
+        DBGOUT((3, "main: Calling StartServiceCtrlDispatcher (NT)..."));
+
+        if (!StartServiceCtrlDispatcher(dispatchTable))
+        {
+        }
+    }
+    else // Win95
+    {
+        DBGOUT((3, "main: Calling ServiceMain (Win95)..."));
+
+        ServiceMain (0, NULL);
+    }
+
+
+    ExitProcess(0);
+}
+
+
+BOOL
+ReportStatusToSCMgr(
+    DWORD dwCurrentState,
+    DWORD dwWin32ExitCode,
+    DWORD dwCheckPoint,
+    DWORD dwWaitHint
+    )
+{
+    SERVICE_STATUS  ssStatus;
+
+
+    ssStatus.dwServiceType             = SERVICE_WIN32_OWN_PROCESS;
+    ssStatus.dwCurrentState            = dwCurrentState;
+//    ssStatus.dwControlsAccepted        = SERVICE_ACCEPT_STOP;
+    ssStatus.dwControlsAccepted        = 0;
+    ssStatus.dwWin32ExitCode           = dwWin32ExitCode;
+    ssStatus.dwServiceSpecificExitCode = 0;
+    ssStatus.dwCheckPoint              = dwCheckPoint;
+    ssStatus.dwWaitHint                = dwWaitHint;
+
+    SetServiceStatus (TapiGlobals.sshStatusHandle, &ssStatus);
+
+    return TRUE;
+}
+
+
+VOID
+ServiceControl(
+    DWORD dwCtrlCode
+    )
+{
+    switch (gdwServiceState)
+    {
+    case SERVICE_START_PENDING:
+    case SERVICE_STOP_PENDING:
+
+        ReportStatusToSCMgr(
+            gdwServiceState,
+            NO_ERROR,
+            ++gdwCheckPoint,
+            gdwWaitHint
+            );
+
+        break;
+
+    default:
+
+        ReportStatusToSCMgr(
+            gdwServiceState,
+            NO_ERROR,
+            0,
+            0
+            );
+
+        break;
+    }
+}
+
+
+#define DEFAULTRPCMINCALLS         5
+#define DEFAULTRPCMAXCALLS         5000
+#define RPCMAXMAX                  20000
+#define RPCMINMAX                  1000
+
+VOID
+ServiceMain(
+    DWORD   dwArgc,
+    LPTSTR *lpszArgv
+    )
+{
+    HANDLE  hEvent = NULL;
+    DWORD   dwMinCalls;
+    DWORD   dwMaxCalls;
+
+
+    //
+    // Grab relevent values from the registry
+    //
+
+    {
+        HKEY    hKey;
+        WCHAR   szRPCMinCalls[] = L"Min";
+        WCHAR   szRPCMaxCalls[] = L"Max";
+        WCHAR   szTelephonyKey[] =
+                    L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                szTapisrvWaitHint[] = L"TapisrvWaitHint";
+#if DBG
+        WCHAR   szTapisrvDebugLevel[] = L"TapisrvDebugLevel";
+
+
+        gdwDebugLevel = 0;
+#endif
+        if (RegOpenKeyExW(
+                HKEY_LOCAL_MACHINE,
+                szTelephonyKey,
+                0,
+                KEY_ALL_ACCESS,
+                &hKey
+
+                ) == ERROR_SUCCESS)
+        {
+            DWORD   dwDataSize = sizeof (DWORD), dwDataType;
+
+#if DBG
+            RegQueryValueExW(
+                hKey,
+                szTapisrvDebugLevel,
+                0,
+                &dwDataType,
+                (LPBYTE) &gdwDebugLevel,
+                &dwDataSize
+                );
+
+            dwDataSize = sizeof (DWORD);
+#endif
+            RegQueryValueExW(
+                hKey,
+                szTapisrvWaitHint,
+                0,
+                &dwDataType,
+                (LPBYTE) &gdwWaitHint,
+                &dwDataSize
+                );
+
+            gdwWaitHint = (gdwWaitHint < MIN_WAIT_HINT ?
+                MIN_WAIT_HINT : gdwWaitHint);
+
+            dwDataSize = sizeof (DWORD);
+            
+            if (RegQueryValueExW(
+                                 hKey,
+                                 szRPCMinCalls,
+                                 NULL,
+                                 &dwDataType,
+                                 (LPBYTE)&dwMinCalls,
+                                 &dwDataSize
+                                ) != ERROR_SUCCESS)
+            {
+                dwMinCalls = DEFAULTRPCMINCALLS;
+            }
+
+            dwDataSize = sizeof (DWORD);
+            
+            if (RegQueryValueExW(
+                                 hKey,
+                                 szRPCMaxCalls,
+                                 NULL,
+                                 &dwDataType,
+                                 (LPBYTE)&dwMaxCalls,
+                                 &dwDataSize
+                                ) != ERROR_SUCCESS)
+            {
+                dwMaxCalls = DEFAULTRPCMAXCALLS;
+            }
+
+            DBGOUT((3, "RPC min calls %lu RPC max calls %lu", dwMinCalls, dwMaxCalls));
+            
+            RegCloseKey (hKey);
+
+            // check values
+            if (dwMaxCalls == 0)
+            {
+                DBGOUT((3, "RPC max at 0.  Changed to %lu", DEFAULTRPCMAXCALLS));
+                dwMaxCalls = DEFAULTRPCMAXCALLS;
+            }
+
+            if (dwMinCalls == 0)
+            {
+                DBGOUT((3, "RPC min at 0. Changed to %lu", DEFAULTRPCMINCALLS));
+                dwMinCalls = DEFAULTRPCMINCALLS;
+            }
+
+            if (dwMaxCalls > RPCMAXMAX)
+            {
+                DBGOUT((3, "RPC max too high at %lu.  Changed to %lu", dwMaxCalls, RPCMAXMAX));
+                dwMaxCalls = RPCMAXMAX;
+            }
+
+            if (dwMinCalls > dwMaxCalls)
+            {
+                DBGOUT((3, "RPC min greater than RPC max.  Changed to %lu", dwMaxCalls));
+                dwMinCalls = dwMaxCalls;
+            }
+
+            if (dwMinCalls > RPCMINMAX)
+            {
+                DBGOUT((3, "RPC min greater than allowed at %lu.  Changed to %lu", dwMinCalls, RPCMINMAX));
+                dwMinCalls = RPCMINMAX;
+            }
+                        
+        }
+    }
+
+
+    DBGOUT((3, "ServiceMain: enter"));
+
+    FillMemory (&TapiGlobals, sizeof (TAPIGLOBALS), 0);
+
+
+    //
+    // Register the service control handler & report status to sc mgr
+    //
+
+    if (!(GetVersion() & 0x80000000)) // Win NT
+    {
+        TapiGlobals.sshStatusHandle = RegisterServiceCtrlHandler(
+            (LPCSTR)"SimpleService",
+            (LPHANDLER_FUNCTION)ServiceControl
+            );
+
+        ReportStatusToSCMgr(
+            (gdwServiceState = SERVICE_START_PENDING),
+                                   // service state
+            NO_ERROR,              // exit code
+            (gdwCheckPoint = 0),   // checkpoint
+            gdwWaitHint            // wait hint
+            );
+    }
+
+
+    //
+    //
+    //
+
+    InitializeCriticalSection (&gSafeMutexCritSec);
+    InitializeCriticalSection (&gRemoteCliEventBufCritSec);
+    InitializeCriticalSection (&gRequestIDCritSec);
+    InitializeCriticalSection (&gPriorityListCritSec);
+    InitializeCriticalSection (&gSPEventQueueCritSec);
+
+    ghPendingSPEventsEvent = CreateEvent(
+        (LPSECURITY_ATTRIBUTES) NULL,
+        TRUE,   // manual reset
+        FALSE,  // non-signaled
+        NULL    // unnamed
+        );
+
+    TapiGlobals.hProcess = GetCurrentProcess();
+
+    {
+        DWORD   dwTID;
+        HANDLE  hThread;
+
+
+        if (!(hThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) SPEventHandlerThread,
+                NULL,
+                0,
+                &dwTID
+                )))
+        {
+            DBGOUT((
+                1,
+                "CreateThread('SPEventHandlerThread') failed, err=%d",
+                GetLastError()
+                ));
+        }
+
+        CloseHandle (hThread);
+    }
+
+
+    //
+    // Init some globals
+    //
+
+    TapiGlobals.hMutex = MyCreateMutex();
+    TapiGlobals.hAsyncRequestIDMutex = MyCreateMutex();
+
+    {
+        DWORD   dwSize = (MAX_COMPUTERNAME_LENGTH + 1) * sizeof(WCHAR);
+
+
+        TapiGlobals.pszComputerName = ServerAlloc (dwSize);
+        GetComputerNameW(TapiGlobals.pszComputerName, &dwSize);
+        TapiGlobals.dwComputerNameSize = (1 +
+            lstrlenW(TapiGlobals.pszComputerName)) * sizeof(WCHAR);
+    }
+
+
+// BUGBUG ServiceMain: LocalSystem hack, can nuke when srv acct stuff correct
+
+    {
+        char   szUserName[32], szDomainName[32], szPassword[32];
+
+        HKEY    hKey;
+        DWORD   dwDataSize;
+        DWORD   dwDataType;
+        DWORD   dwTemp;
+
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            gszRegKeyProviders,
+            0,
+            KEY_ALL_ACCESS,
+            &hKey
+            );
+
+
+        dwDataSize = sizeof(dwTemp);
+        dwTemp = 0;
+        RegQueryValueEx(
+            hKey,
+            "EnableSharing",
+            0,
+            &dwDataType,
+            (LPBYTE) &dwTemp,
+            &dwDataSize
+            );
+
+
+        if (dwTemp)
+        {
+            dwDataSize = sizeof(szUserName);
+            RegQueryValueEx(
+                hKey,
+                "User",
+                0,
+                &dwDataType,
+                (LPBYTE) szUserName,
+                &dwDataSize
+                );
+
+            szUserName[dwDataSize] = '\0';
+            dwDataSize = sizeof(szDomainName);
+
+            RegQueryValueEx(
+                hKey,
+                "Domain",
+                0,
+                &dwDataType,
+                (LPBYTE)szDomainName,
+                &dwDataSize
+                );
+
+            szDomainName[dwDataSize] = '\0';
+            dwDataSize = sizeof(szPassword);
+            RegQueryValueEx(
+                hKey,
+                "Password",
+                0,
+                &dwDataType,
+                (LPBYTE)szPassword,
+                &dwDataSize
+                );
+
+            szPassword[dwDataSize] = '\0';
+
+
+            if (!LogonUser(
+                    szUserName,
+                    szDomainName,
+                    szPassword,
+                    LOGON32_LOGON_SERVICE,
+                    LOGON32_PROVIDER_DEFAULT,
+                    &ghToken
+                    ))
+            {
+                DBGOUT((
+                    1,
+                    "LogonUser(usr=%s,domain=%s) failed, err=%d",
+                    szUserName,
+                    szDomainName,
+                    GetLastError()
+                    ));
+
+                ghToken = NULL;
+            }
+        }
+        else
+        {
+            ghToken = NULL;
+        }
+
+
+        RegCloseKey(
+                     hKey
+                   );
+
+    }
+
+
+    //
+    // Alloc the EventNotificationThread resources and start the thread
+    //
+
+// BUGBUG ServiceMain: hack for spinning EventNotifyThd (sharing enabled)
+
+    if (ghToken) // hackhack
+    {
+        gEventNotificationThreadParams.dwEventBufferTotalSize = 1024;
+        gEventNotificationThreadParams.dwEventBufferUsedSize  = 0;
+
+        if (!(gEventNotificationThreadParams.pEventBuffer = ServerAlloc(
+                gEventNotificationThreadParams.dwEventBufferTotalSize
+                )))
+        {
+        }
+
+        gEventNotificationThreadParams.pDataIn  =
+        gEventNotificationThreadParams.pDataOut =
+            gEventNotificationThreadParams.pEventBuffer;
+
+        gEventNotificationThreadParams.dwMsgSize = 512;
+
+        if (!(gEventNotificationThreadParams.pMsg = ServerAlloc(
+                gEventNotificationThreadParams.dwMsgSize
+                )))
+        {
+        }
+
+        if (!(gEventNotificationThreadParams.hEvent = CreateEvent(
+                (LPSECURITY_ATTRIBUTES) NULL,   // no security attrs
+                TRUE,                           // manual reset
+                FALSE,                          // initially non-signaled
+                NULL                            // unnamed
+                )))
+        {
+        }
+
+        gEventNotificationThreadParams.bExit = FALSE;
+
+        {
+            DWORD   dwTID;
+
+
+            if (!(gEventNotificationThreadParams.hThread = CreateThread(
+                    (LPSECURITY_ATTRIBUTES) NULL,
+                    0,
+                    (LPTHREAD_START_ROUTINE) EventNotificationThread,
+                    NULL,
+                    0,
+                    &dwTID
+                    )))
+            {
+                DBGOUT((
+                    1,
+                    "CreateThread('EventNotificationThread') failed, err=%d",
+                    GetLastError()
+                    ));
+            }
+        }
+    }
+
+
+    //
+    // Init Rpc server
+    //
+
+    {
+        RPC_STATUS status;
+//        unsigned char * pszSecurity         = NULL;
+// min and max calls are read from registry above        
+//        unsigned int    cMinCalls           = 5;
+//        unsigned int    cMaxCalls           = 5000;
+        unsigned int    fDontWait           = FALSE;
+
+        SECURITY_ATTRIBUTES  sa;
+        SECURITY_DESCRIPTOR  sd;
+
+
+        InitSecurityDescriptor (&sd);
+
+        sa.nLength = sizeof(SECURITY_ATTRIBUTES) ;
+        sa.lpSecurityDescriptor = &sd;
+        sa.bInheritHandle = TRUE ;
+
+        status = RpcServerUseProtseqEp(
+            "ncacn_np",
+            (unsigned int) dwMaxCalls,
+            "\\pipe\\tapsrv",
+            &sd
+            );
+
+        DBGOUT((3, "RpcServerUseProtseqEp(np) ret'd %d", status));
+
+        if (status)
+        {
+        }
+
+        status = RpcServerUseProtseqEp(
+            "ncalrpc",
+            (unsigned int) dwMaxCalls,
+            "tapsrvlpc",
+            &sd
+            );
+
+        DBGOUT((3, "RpcServerUseProtseqEp(lrpc) ret'd %d", status));
+
+        if (status)
+        {
+        }
+
+        status = RpcServerRegisterIf(
+            tapsrv_ServerIfHandle,  // interface to register
+            NULL,                   // MgrTypeUuid
+            NULL                    // MgrEpv; null means use default
+            );
+
+        DBGOUT((3, "RpcServerRegisterIf ret'd %d", status));
+
+        if (status)
+        {
+        }
+
+        if (!(GetVersion() & 0x80000000)) // Win NT
+        {
+            ReportStatusToSCMgr(
+                (gdwServiceState = SERVICE_RUNNING),
+                                 // service state
+                NO_ERROR,        // exit code
+                0,               // checkpoint
+                0                // wait hint
+                );
+        }
+        else // Win95
+        {
+            if (!(hEvent = CreateEvent (NULL, TRUE, FALSE, "TapiSrvInited")))
+            {
+                DBGOUT((
+                    1,
+                    "CreateEvent ('TapiSrvInited') failed, err=%d",
+                    GetLastError()
+                    ));
+            }
+
+            SetEvent (hEvent);
+        }
+
+        DBGOUT((3, "Calling RpcServerListen..."));
+
+        status = RpcServerListen(
+            (unsigned int)dwMinCalls,
+            (unsigned int)dwMaxCalls,
+            fDontWait
+            );
+
+        DBGOUT((3, "RpcServerListen ret'd %d", status));
+
+        if (status)
+        {
+        }
+
+        if (fDontWait)
+        {
+            DBGOUT((3, "Calling RpcMgmtWaitServerListen..."));
+
+            status = RpcMgmtWaitServerListen();  //  wait operation
+
+            DBGOUT((3, "RpcMgmtWaitServerListen ret'd %d", status));
+
+            if (status)
+            {
+            }
+        }
+    }
+
+
+    //
+    // Free various resources
+    //
+
+    CloseHandle (TapiGlobals.hMutex);
+    CloseHandle (TapiGlobals.hAsyncRequestIDMutex);
+
+
+    //
+    // Wait for the EventHandlerThread to terminate, then clean up
+    // the related resources
+    //
+
+// BUGBUG ServiceMain: another LocalSystem hack
+
+    if (ghToken) // hackhack
+    {
+        CloseHandle (ghToken);
+
+        gEventNotificationThreadParams.bExit = TRUE;
+
+        while (WaitForSingleObject (gEventNotificationThreadParams.hThread, 0) !=
+                WAIT_OBJECT_0)
+        {
+            SetEvent (gEventNotificationThreadParams.hEvent);
+            Sleep (0);
+        }
+
+        CloseHandle (gEventNotificationThreadParams.hThread);
+        CloseHandle (gEventNotificationThreadParams.hEvent);
+        ServerFree (gEventNotificationThreadParams.pEventBuffer);
+        ServerFree (gEventNotificationThreadParams.pMsg);
+    }
+
+    DeleteCriticalSection (&gSafeMutexCritSec);
+    DeleteCriticalSection (&gRemoteCliEventBufCritSec);
+    DeleteCriticalSection (&gRequestIDCritSec);
+    DeleteCriticalSection (&gPriorityListCritSec);
+    //DeleteCriticalSection (&gSPEventQueueCritSec);
+
+
+    if (!(GetVersion() & 0x80000000)) // Win NT
+    {
+        //
+        // Report the stopped status to the service control manager.
+        //
+
+        if (TapiGlobals.sshStatusHandle)
+        {
+            ReportStatusToSCMgr ((gdwServiceState = SERVICE_STOPPED), 0, 0, 0);
+        }
+    }
+    else // Win95
+    {
+// BUGBUG ServiceMain: overlap prob (cli starts while we're shutting down)
+
+        CloseHandle (hEvent);
+    }
+
+
+    //
+    // When SERVICE MAIN FUNCTION returns in a single service
+    // process, the StartServiceCtrlDispatcher function in
+    // the main thread returns, terminating the process.
+    //
+
+    DBGOUT((3, "ServiceMain: exit"));
+
+    return;
+}
+
+
+void
+PASCAL
+QueueSPEvent(
+    PSPEVENT    pSPEvent
+    )
+{
+    //
+    // Safely queue an SP event
+    //
+
+    EnterCriticalSection (&gSPEventQueueCritSec);
+
+    if (gbQueueSPEvents == TRUE)
+    {
+        if (gpYoungestSPEvent)
+        {
+            gpYoungestSPEvent->pNext = pSPEvent;
+        }
+        else
+        {
+            //
+            // The queue was empty, so init the oldest event ptr &
+            // set the event to wake up the SPEVentHandlerThread
+            //
+
+            gpOldestSPEvent = pSPEvent;
+            SetEvent (ghPendingSPEventsEvent);
+        }
+
+        gpYoungestSPEvent = pSPEvent;
+    }
+
+    LeaveCriticalSection (&gSPEventQueueCritSec);
+}
+
+
+BOOL
+PASCAL
+DequeueSPEvent(
+    PSPEVENT   *ppSPEvent
+    )
+{
+    BOOL    bResult;
+
+
+    //
+    // Safely try to remove the oldest SP event from the queue
+    //
+
+    EnterCriticalSection (&gSPEventQueueCritSec);
+
+    if (gpOldestSPEvent)
+    {
+        *ppSPEvent = gpOldestSPEvent;
+
+        if (!(gpOldestSPEvent = gpOldestSPEvent->pNext))
+        {
+            //
+            // This was the last event in the queue, so nullify
+            // the youngest event ptr and reset the event to put
+            // the SPEVentHandlerThread to sleep
+            //
+
+            gpYoungestSPEvent = (PSPEVENT) NULL;
+            ResetEvent (ghPendingSPEventsEvent);
+        }
+
+        bResult = TRUE;
+    }
+    else
+    {
+        bResult = FALSE;
+        ResetEvent (ghPendingSPEventsEvent);
+    }
+
+    LeaveCriticalSection (&gSPEventQueueCritSec);
+
+    return bResult;
+}
+
+
+void
+SPEventHandlerThread(
+    LPVOID  pParams
+    )
+{
+    //
+    // This thread processes the events & completion notifications
+    // indicated to us by an SP at a previous time/thread context.
+    // There are a couple of reasons for doing this in a separate
+    // thread rather than within the SP's thread context:
+    //
+    //   1. for some msgs (i.e. XXX_CLOSE) TAPI will call back
+    //      into the SP, which it may not be expecting
+    //
+    //   2. we don't want to block the SP's thread by processing
+    //      the msg, forwarding it on to the appropriate clients,
+    //      etc
+    //
+
+    DBGOUT((
+        3,
+        "SPEventHandlerThread: enter (pid=%d)",
+        GetCurrentThreadId()
+        ));
+
+    while (1)
+    {
+        PSPEVENT    pSPEvent;
+
+
+        WaitForSingleObject (ghPendingSPEventsEvent, INFINITE);
+
+        while (DequeueSPEvent (&pSPEvent))
+        {
+            switch (pSPEvent->dwType)
+            {
+            case SP_LINE_EVENT:
+
+                LineEventProc(
+                    pSPEvent->htLine,
+                    pSPEvent->htCall,
+                    pSPEvent->dwMsg,
+                    pSPEvent->dwParam1,
+                    pSPEvent->dwParam2,
+                    pSPEvent->dwParam3
+                    );
+
+                break;
+
+            case TASYNC_KEY:
+
+                CompletionProc(
+                    (PASYNCREQUESTINFO) pSPEvent,
+                    ((PASYNCREQUESTINFO) pSPEvent)->lResult
+                    );
+
+                break;
+
+            case SP_PHONE_EVENT:
+
+                PhoneEventProc(
+                    pSPEvent->htPhone,
+                    pSPEvent->dwMsg,
+                    pSPEvent->dwParam1,
+                    pSPEvent->dwParam2,
+                    pSPEvent->dwParam3
+                    );
+
+                break;
+            }
+
+            ServerFree (pSPEvent);
+        }
+
+
+        //
+        // Check to see if all the clients are gone, and if so wait a
+        // while to see if anyone else attaches.  If no one else attaches
+        // in the specified amount of time then shut down.
+        //
+
+        if (TapiGlobals.ptClients == NULL)
+        {
+            DWORD       dwDeferredShutdownTimeout, dwSleepInterval,
+                        dwLoopCount, i;
+            RPC_STATUS  status;
+
+
+
+// BUGBUG SPEventHandlerThread:
+
+            dwDeferredShutdownTimeout = 30; // 30 seconds
+            dwSleepInterval = 250;          // 250 milliseconds
+            dwLoopCount = dwDeferredShutdownTimeout * 1000 / dwSleepInterval;
+
+            for (i = 0; i < dwLoopCount; i++)
+            {
+                Sleep (dwSleepInterval);
+
+                if (TapiGlobals.ptClients != NULL)
+                {
+                    break;
+                }
+            }
+
+            if (i == dwLoopCount  &&  TapiGlobals.ptClients == NULL)
+            {
+                if (!(GetVersion() & 0x80000000)) // Win NT
+                {
+                    if (TapiGlobals.sshStatusHandle)
+                    {
+                        ReportStatusToSCMgr(
+                            (gdwServiceState = SERVICE_STOP_PENDING),
+                            0,
+                            (gdwCheckPoint = 0),
+                            gdwWaitHint
+                            );
+                    }
+                }
+                else // Win95
+                {
+                }
+
+                DBGOUT((3, "Calling RpcMgmtStopServerListening"));
+
+                status = RpcMgmtStopServerListening (NULL);
+
+                DBGOUT((
+                    3,
+                    "RpcMgmtStopServerListening returned: %d",
+                    status
+                    ));
+
+                if (status)
+                {
+                    //exit (status);
+                }
+
+                DBGOUT((3, "Calling RpcServerUnregisterIf"));
+
+                status = RpcServerUnregisterIf (NULL, NULL, FALSE);
+
+                DBGOUT((3, "RpcServerUnregisterIf returned %d", status));
+
+                DBGOUT((
+                    3,
+                    "SPEventHandlerThread: exit (pid=%d)",
+                    GetCurrentThreadId()
+                    ));
+
+                ExitThread (0);
+            }
+        }
+    }
+}
+
+
+DWORD
+InitSecurityDescriptor(
+    PSECURITY_DESCRIPTOR pSecurityDescriptor
+    )
+{
+    //
+    // Note: this code was borrowed from Steve Cobb, who borrowed from RASMAN
+    //
+
+    DWORD        dwResult;
+    DWORD        cbDaclSize;
+    PULONG       pSubAuthority;
+    PSID         pObjSid    = NULL;
+    PACL         pDacl      = NULL;
+    SID_IDENTIFIER_AUTHORITY    SidIdentifierWorldAuth =
+                                    SECURITY_WORLD_SID_AUTHORITY;
+
+    //
+    // The do - while(FALSE) statement is used so that the break statement
+    // maybe used insted of the goto statement, to execute a clean up and
+    // and exit action.
+    //
+
+    do
+    {
+        dwResult = 0;
+
+
+        //
+        // Set up the SID for the admins that will be allowed to have
+        // access. This SID will have 1 sub-authorities
+        // SECURITY_BUILTIN_DOMAIN_RID.
+        //
+
+        if (!(pObjSid = (PSID) ServerAlloc (GetSidLengthRequired (1))))
+        {
+            dwResult = GetLastError();
+            break;
+        }
+
+        if (!InitializeSid (pObjSid, &SidIdentifierWorldAuth, 1))
+        {
+            dwResult = GetLastError();
+            DBGOUT((1, "InitializeSid() failed, err=%d", dwResult));
+            break;
+        }
+
+
+        //
+        // Set the sub-authorities
+        //
+
+        pSubAuthority = GetSidSubAuthority (pObjSid, 0);
+        *pSubAuthority = SECURITY_WORLD_RID;
+
+
+        //
+        // Set up the DACL that will allow all processeswith the above
+        // SID all access. It should be large enough to hold all ACEs.
+        //
+
+        cbDaclSize = sizeof(ACCESS_ALLOWED_ACE) +
+            GetLengthSid (pObjSid) +
+            sizeof(ACL);
+
+        if (!(pDacl = (PACL) ServerAlloc (cbDaclSize)))
+        {
+            dwResult = GetLastError ();
+            break;
+        }
+
+        if (!InitializeAcl (pDacl, cbDaclSize, ACL_REVISION2))
+        {
+            dwResult = GetLastError();
+            DBGOUT((1, "InitializeAcl() failed, err=%d", dwResult));
+            break;
+        }
+
+
+        //
+        // Add the ACE to the DACL
+        //
+
+        if (!AddAccessAllowedAce(
+                pDacl,
+                ACL_REVISION2,
+                STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL,
+                pObjSid
+                ))
+        {
+            dwResult = GetLastError();
+            DBGOUT((1, "AddAccessAllowedAce() failed, err=%d", dwResult));
+            break;
+        }
+
+
+        //
+        // Create the security descriptor an put the DACL in it.
+        //
+
+        if (!InitializeSecurityDescriptor (pSecurityDescriptor, 1))
+        {
+            dwResult = GetLastError();
+            DBGOUT((
+                1,
+                "InitializeSecurityDescriptor() failed, err=%d",
+                dwResult
+                ));
+
+            break;
+        }
+
+        if (!SetSecurityDescriptorDacl(
+                pSecurityDescriptor,
+                TRUE,
+                pDacl,
+                FALSE
+                ))
+        {
+            dwResult = GetLastError();
+            DBGOUT((1, "SetSecurityDescriptorDacl() failed, err=%d",dwResult));
+            break;
+        }
+
+
+        //
+        // Set owner for the descriptor
+        //
+
+        if (!SetSecurityDescriptorOwner(
+                pSecurityDescriptor,
+                NULL,
+                FALSE
+                ))
+        {
+            dwResult = GetLastError();
+            DBGOUT((1, "SetSecurityDescriptorOwnr() failed, err=%d",dwResult));
+            break;
+        }
+
+
+        //
+        // Set group for the descriptor
+        //
+
+        if (!SetSecurityDescriptorGroup(
+                pSecurityDescriptor,
+                NULL,
+                FALSE
+                ))
+        {
+            dwResult = GetLastError();
+            DBGOUT((1,"SetSecurityDescriptorGroup() failed, err=%d",dwResult));
+            break;
+        }
+
+    } while (FALSE);
+
+    return dwResult;
+}
+
+
+PASYNCEVENTMSG
+GetEventFromQueue(
+    void
+    )
+{
+    DWORD           dwUsedSize, dwMoveSize, dwMoveSizeWrapped;
+    PASYNCEVENTMSG  pMsg = gEventNotificationThreadParams.pMsg;
+
+
+    //
+    // Enter the critical section to serialize access to the event
+    // queue, and grab an event from the queue.  Copy it to our local
+    // event buf so that we can leave the critical section asap and
+    // not block other threads writing to the queue.
+    //
+
+    EnterCriticalSection (&gRemoteCliEventBufCritSec);
+
+
+    //
+    // If there are no events in the queue return NULL
+    //
+
+    if (gEventNotificationThreadParams.dwEventBufferUsedSize == 0)
+    {
+        pMsg = NULL;
+
+        goto GetEventFromQueue_done;
+    }
+
+
+    //
+    // Copy the fixed portion of the msg to the local buf
+    //
+
+    dwUsedSize = (gEventNotificationThreadParams.pEventBuffer +
+        gEventNotificationThreadParams.dwEventBufferTotalSize)  -
+        gEventNotificationThreadParams.pDataOut;
+
+    if (dwUsedSize >= sizeof (ASYNCEVENTMSG))
+    {
+        dwMoveSize        = sizeof (ASYNCEVENTMSG);
+        dwMoveSizeWrapped = 0;
+    }
+    else
+    {
+        dwMoveSize        = dwUsedSize;
+        dwMoveSizeWrapped = sizeof (ASYNCEVENTMSG) - dwUsedSize;
+    }
+
+    CopyMemory (pMsg, gEventNotificationThreadParams.pDataOut, dwMoveSize);
+
+    if (dwMoveSizeWrapped)
+    {
+        CopyMemory(
+            ((LPBYTE) pMsg) + dwMoveSize,
+            gEventNotificationThreadParams.pEventBuffer,
+            dwMoveSizeWrapped
+            );
+
+        gEventNotificationThreadParams.pDataOut =
+            gEventNotificationThreadParams.pEventBuffer + dwMoveSizeWrapped;
+    }
+    else
+    {
+        gEventNotificationThreadParams.pDataOut += dwMoveSize;
+    }
+
+
+    //
+    // See if there's any extra data in this msg
+    //
+
+    if (pMsg->dwTotalSize > sizeof (ASYNCEVENTMSG))
+    {
+        BOOL    bCopy = TRUE;
+
+
+        //
+        // See if we need to grow the msg buffer
+        //
+
+        if (pMsg->dwTotalSize > gEventNotificationThreadParams.dwMsgSize)
+        {
+            DWORD   dwNewMsgSize = pMsg->dwTotalSize + 256;
+
+
+            if ((pMsg = ServerAlloc (dwNewMsgSize)))
+            {
+                CopyMemory(
+                    pMsg,
+                    gEventNotificationThreadParams.pMsg,
+                    sizeof(ASYNCEVENTMSG)
+                    );
+
+                ServerFree (gEventNotificationThreadParams.pMsg);
+
+                gEventNotificationThreadParams.pMsg = pMsg;
+
+                gEventNotificationThreadParams.dwMsgSize = dwNewMsgSize;
+            }
+            else
+            {
+                //
+                // Couldn't alloc a bigger buf, so try to complete this
+                // msg as gracefully as possible
+                //
+
+                bCopy = FALSE;
+
+                switch (pMsg->dwMsg)
+                {
+                case LINE_REPLY:
+
+                    pMsg->dwParam2 = LINEERR_NOMEM;
+                    break;
+
+                case PHONE_REPLY:
+
+                    pMsg->dwParam2 = PHONEERR_NOMEM;
+                    break;
+
+                default:
+
+// BUGBUG GetEventFromQueue: any other msgs to special case?
+
+                    break;
+                }
+            }
+        }
+
+
+        dwUsedSize = (gEventNotificationThreadParams.pEventBuffer +
+            gEventNotificationThreadParams.dwEventBufferTotalSize)  -
+            gEventNotificationThreadParams.pDataOut;
+
+        if (dwUsedSize >= (pMsg->dwTotalSize - sizeof (ASYNCEVENTMSG)))
+        {
+            dwMoveSize        = pMsg->dwTotalSize - sizeof (ASYNCEVENTMSG);
+            dwMoveSizeWrapped = 0;
+        }
+        else
+        {
+            dwMoveSize        = dwUsedSize;
+            dwMoveSizeWrapped = (pMsg->dwTotalSize  - sizeof (ASYNCEVENTMSG)) -
+                dwUsedSize;
+        }
+
+        if (bCopy)
+        {
+            CopyMemory(
+                pMsg + 1,
+                gEventNotificationThreadParams.pDataOut,
+                dwMoveSize
+                );
+        }
+
+        if (dwMoveSizeWrapped)
+        {
+            if (bCopy)
+            {
+                CopyMemory(
+                    ((LPBYTE) (pMsg + 1)) + dwMoveSize,
+                    gEventNotificationThreadParams.pEventBuffer,
+                    dwMoveSizeWrapped
+                    );
+            }
+
+            gEventNotificationThreadParams.pDataOut =
+                gEventNotificationThreadParams.pEventBuffer +
+                    dwMoveSizeWrapped;
+        }
+        else
+        {
+            gEventNotificationThreadParams.pDataOut += dwMoveSize;
+        }
+    }
+
+    gEventNotificationThreadParams.dwEventBufferUsedSize -= pMsg->dwTotalSize;
+
+GetEventFromQueue_done:
+
+    LeaveCriticalSection (&gRemoteCliEventBufCritSec);
+
+    ResetEvent (gEventNotificationThreadParams.hEvent);
+
+    return pMsg;
+}
+
+
+void
+EventNotificationThread(
+    LPVOID  pParams
+    )
+{
+    PASYNCEVENTMSG pMsg;
+
+
+    DBGOUT((3, "EventNotificationThread: enter"));
+
+    ImpersonateLoggedOnUser (ghToken);
+
+    while (1)
+    {
+        WaitForSingleObject (gEventNotificationThreadParams.hEvent, INFINITE);
+
+        if (gEventNotificationThreadParams.bExit)
+        {
+            break;
+        }
+
+        while ((pMsg = GetEventFromQueue()))
+        {
+            PCONTEXT_HANDLE_TYPE2   phContext;
+
+
+            //
+            // Make sure the msg is destined for a valid client
+            //
+            // !!! Note the overlaoding of the pMsg->dwCallbackInst field
+            //     (see corresponding note in WriteEventBuffer())
+            //
+
+            try
+            {
+                PTCLIENT    ptClient = (PTCLIENT) pMsg->dwCallbackInst;
+
+
+                phContext = ptClient->phContext;
+
+                if (ptClient->dwKey != TCLIENT_KEY)
+                {
+                    continue;
+                }
+            }
+            myexcept
+            {
+                continue;
+            }
+
+
+            //
+            // Send the event to the client
+            //
+
+            RpcTryExcept
+            {
+                RemoteSPEventProc(
+                    phContext,
+                    (unsigned char *) pMsg,
+                    pMsg->dwTotalSize
+                    );
+            }
+            RpcExcept (1)
+            {
+                unsigned long ulResult = RpcExceptionCode();
+
+
+                DBGOUT((
+                    3,
+                    "EventNotificationThread: exception #%d",
+                    ulResult
+                    ));
+
+                if (ulResult == RPC_S_SERVER_TOO_BUSY)
+                {
+// BUGBUG EventNotificationThread: timeout, then try the op again
+                }
+                else
+                {
+// BUGBUG EventNotificationThread: consider shutting down the rpc connection
+//        (& sending REINITs?)
+                }
+            }
+            RpcEndExcept
+        }
+    }
+
+    RevertToSelf();
+
+    DBGOUT((3, "EventNotificationThread: exit"));
+
+    ExitThread (0);
+}
+
+
+
+void
+__RPC_FAR *
+__RPC_API
+midl_user_allocate(
+    size_t len
+    )
+{
+
+
+    return (ServerAlloc(len));
+}
+
+
+void
+__RPC_API
+midl_user_free(
+    void __RPC_FAR * ptr
+    )
+{
+    ServerFree (ptr);
+}
+
+
+LONG
+ClientAttach(
+    PCONTEXT_HANDLE_TYPE   *pphContext,
+    long                    lProcessID,
+    long                   *phAsyncEventsEvent,
+    wchar_t                *pszDomainUser,
+    wchar_t                *pszMachine
+    )
+{
+    PTCLIENT    ptClient;
+
+
+    DBGOUT((
+        3,
+        "ClientAttach: enter, pid=x%x, user='%ls', machine='%ls'",
+        lProcessID,
+        pszDomainUser,
+        pszMachine
+        ));
+
+
+
+    //
+    // Alloc & init a tClient struct
+    //
+
+    if (!(ptClient = ServerAlloc (sizeof(TCLIENT))))
+    {
+        goto ClientAttach_error0;
+    }
+
+    if (!(ptClient->hMutex = MyCreateMutex()))
+    {
+        goto ClientAttach_error1;
+    }
+
+    ptClient->dwUserNameSize = (lstrlenW(pszDomainUser) + 1) * sizeof(WCHAR);
+
+    if (!(ptClient->pszUserName = ServerAlloc (ptClient->dwUserNameSize)))
+    {
+        goto ClientAttach_error2;
+    }
+
+    lstrcpyW(ptClient->pszUserName, pszDomainUser);
+
+    if (lProcessID == 0xffffffff)
+    {
+        //
+        // This is a remote client
+        //
+
+        ptClient->hProcess = (HANDLE) 0xffffffff;
+
+        ptClient->dwComputerNameSize = (1 + lstrlenW(pszMachine)) * sizeof(WCHAR);
+        ptClient->pszComputerName = ServerAlloc (ptClient->dwComputerNameSize);
+        lstrcpyW(ptClient->pszComputerName, pszMachine);
+
+
+        //
+        //
+        //
+
+// BUGBUG ClientAttach: may need to serialize this for safe access to RemoteSP
+
+        {
+            RPC_STATUS              status;
+            WCHAR                  *pszStringBinding = NULL, *pszMachineName;
+            PCONTEXT_HANDLE_TYPE2   phContext = NULL;
+
+
+            pszMachineName = ServerAlloc ((lstrlenW(pszMachine) + 3) * sizeof(WCHAR));
+
+            pszMachineName[0] = pszMachineName[1] = '\\';
+
+            lstrcpyW(pszMachineName + 2, pszMachine);
+
+            if (!ImpersonateLoggedOnUser (ghToken))
+            {
+                DBGOUT((
+                    1,
+                    "ClientAttach: ImpersonateLoggedOnUser failed, err=%d",
+                    GetLastError()
+                    ));
+            }
+
+            status = RpcStringBindingComposeW(
+                NULL,               // uuid
+                L"ncacn_np",         // prot
+                pszMachineName,     // server name
+                L"\\pipe\\remotesp", // interface name
+                NULL,               // options
+                &pszStringBinding
+                );
+
+            ServerFree (pszMachineName);
+
+            if (status)
+            {
+                DBGOUT((
+                    0,
+                    "RpcStringBindingCompose failed: err=%d, szNetAddr='%s'",
+                    status,
+                    pszMachineName
+                    ));
+            }
+
+            status = RpcBindingFromStringBindingW(
+                pszStringBinding,
+                &hRemoteSP
+                );
+
+            if (status)
+            {
+                DBGOUT((
+                    0,
+                    "RpcBindingFromStringBinding failed, err=%d, szBinding='%s'",
+                    status,
+                    pszStringBinding
+                    ));
+            }
+
+            RpcTryExcept
+            {
+                RemoteSPAttach ((PCONTEXT_HANDLE_TYPE2 *) &phContext);
+            }
+            RpcExcept (1)
+            {
+// BUGBUG ClientAttach: handle rpcexcept
+            }
+            RpcEndExcept
+
+            RpcBindingFree (&hRemoteSP);
+
+            RpcStringFreeW(&pszStringBinding);
+
+            RevertToSelf();
+
+            ptClient->phContext = phContext;
+        }
+    }
+    else if ((ptClient->hProcess = OpenProcess(
+            PROCESS_DUP_HANDLE | SYNCHRONIZE | STANDARD_RIGHTS_REQUIRED,
+            FALSE,
+            lProcessID
+            )))
+    {
+        //
+        // This is a local client, so set up all the event buffer stuff
+        //
+
+        ptClient->dwComputerNameSize = TapiGlobals.dwComputerNameSize;
+        ptClient->pszComputerName    = TapiGlobals.pszComputerName;
+
+        if (!(ptClient->hEventBufferMutex = MyCreateMutex()))
+        {
+            goto ClientAttach_error3;
+        }
+
+        if (!(ptClient->hValidEventBufferDataEvent = CreateEvent(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                TRUE,   // manual-reset
+                FALSE,  // nonsignaled
+                NULL    // unnamed
+                )))
+        {
+            CloseHandle (ptClient->hEventBufferMutex);
+            goto ClientAttach_error3;
+        }
+
+        if (!(ptClient->pEventBuffer = ServerAlloc (INITIAL_EVENT_BUFFER_SIZE)))
+        {
+            CloseHandle (ptClient->hEventBufferMutex);
+            CloseHandle (ptClient->hValidEventBufferDataEvent);
+            goto ClientAttach_error3;
+        }
+
+        ptClient->dwEventBufferTotalSize = INITIAL_EVENT_BUFFER_SIZE;
+        ptClient->dwEventBufferUsedSize  = 0;
+
+        ptClient->pDataIn = ptClient->pDataOut = ptClient->pEventBuffer;
+
+        if (!DuplicateHandle(
+                TapiGlobals.hProcess,
+                ptClient->hValidEventBufferDataEvent,
+                ptClient->hProcess,
+                (HANDLE *) phAsyncEventsEvent,
+                0,
+                FALSE,
+                DUPLICATE_SAME_ACCESS
+                ))
+        {
+            DBGOUT((1, "ClientAttach: DupHandle failed, err=%d", GetLastError()));
+        }
+
+
+        //
+        // Load the priority lists if we haven't already done so
+        //
+
+        if (gbPriorityListsInitialized == FALSE)
+        {
+            RPC_STATUS  status;
+
+            if ((status = RpcImpersonateClient (0)) != RPC_S_OK)
+            {
+                DBGOUT((2, "ClientAttach: RpcImpersonateClient failed, err=%d", status));
+            }
+
+            EnterCriticalSection (&gPriorityListCritSec);
+
+            if (gbPriorityListsInitialized == FALSE)
+            {
+                HKEY    hKeyHandoffPriorities;
+                LONG    lResult;
+                DWORD   i;
+
+
+                gbPriorityListsInitialized = TRUE;
+
+                if ((lResult = RegOpenKeyEx(
+                        HKEY_CURRENT_USER,
+                        gszRegKeyHandoffPriorities,
+                        0,
+                        KEY_READ,
+                        &hKeyHandoffPriorities
+
+                        )) == ERROR_SUCCESS)
+                {
+
+// BUGBUG ClientAttach: ext media priorities (load pri lists)
+
+
+                    for (i = 1; gaszMediaModes[i] != NULL; i++)
+                    {
+                        GetPriorityList(
+                            hKeyHandoffPriorities,
+                            gaszMediaModes[i],
+                            TapiGlobals.apszPriorityList + i
+                            );
+                    }
+
+                    GetPriorityList(
+                        hKeyHandoffPriorities,
+                        gszRequestMakeCallW,
+                        &TapiGlobals.pszReqMakeCallPriList
+                        );
+
+                    GetPriorityList(
+                        hKeyHandoffPriorities,
+                        gszRequestMediaCallW,
+                        &TapiGlobals.pszReqMediaCallPriList
+                        );
+
+
+                    RegCloseKey (hKeyHandoffPriorities);
+
+                }
+                else
+                {
+                    DBGOUT((
+                        2,
+                        "RegOpenKey('\\HandoffPri') failed, err=%ld",
+                        lResult
+                        ));
+                }
+            }
+
+            LeaveCriticalSection (&gPriorityListCritSec);
+
+            if (status == RPC_S_OK)
+            {
+                RpcRevertToSelf ();
+            }
+        }
+    }
+    else
+    {
+        DBGOUT((
+            1,
+            "OpenProcess(pid=x%x) failed, err=%d",
+            lProcessID,
+            GetLastError()
+            ));
+
+        goto ClientAttach_error3;
+    }
+
+
+    //
+    // Add tClient to global list
+    //
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    if ((ptClient->pNext = TapiGlobals.ptClients))
+    {
+        ptClient->pNext->pPrev = ptClient;
+    }
+
+    TapiGlobals.ptClients = ptClient;
+
+    ptClient->dwKey = TCLIENT_KEY;
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+
+    //
+    // Fill in return values
+    //
+
+    *pphContext = (PCONTEXT_HANDLE_TYPE) ptClient;
+
+    PerfBlock.dwClientApps++;
+
+    return 0;
+
+
+    //
+    // Error cleanup
+    //
+
+ClientAttach_error3:
+
+    ServerFree (ptClient->pszUserName);
+
+ClientAttach_error2:
+
+    CloseHandle (ptClient->hMutex);
+
+ClientAttach_error1:
+
+    ServerFree (ptClient);
+
+ClientAttach_error0:
+
+    return LINEERR_NOMEM;
+}
+
+
+void
+ClientRequest(
+    PCONTEXT_HANDLE_TYPE   phContext,
+    unsigned char  *pBuffer,
+    long            lNeededSize,
+    long           *plUsedSize
+    )
+{
+    PTAPI32_MSG     pMsg = (PTAPI32_MSG) pBuffer;
+    DWORD           dwFuncIndex = pMsg->u.Req_Func;
+
+
+    //DBGOUT((
+    //    4,
+    //    "ClientRequest: phCntxt=x%, reqType x%x, needed=x%x, used=x%x",
+    //    phContext,
+    //    dwFuncIndex,
+    //    lNeededSize,
+    //    *plUsedSize
+    //    ));
+
+    pMsg->u.Ack_ReturnValue = TAPI_SUCCESS;
+    pMsg->hRpcClientInst = (DWORD) phContext;
+
+    *plUsedSize = sizeof(LONG);
+
+    (*gaFuncs[dwFuncIndex])(
+        pMsg,
+        pBuffer + sizeof(TAPI32_MSG),
+        plUsedSize
+        );
+}
+
+
+void
+ClientDetach(
+    PCONTEXT_HANDLE_TYPE   *pphContext
+    )
+{
+    DBGOUT((3, "ClientDetach: enter"));
+
+    {
+        PTCLIENT ptClient = (PTCLIENT) *pphContext;
+
+
+        if (ptClient->hProcess != (HANDLE) 0xffffffff)
+        {
+            //
+            // Write the pri lists to the registry when a local client
+            // detaches.
+            //
+            // BUGBUG This isn't the most efficient thing in the world.
+            //        Need to investigate a way to guarantee that we
+            //        can impersonate a local client on shutdown, so we
+            //        only have to do this once (need to impersonate in
+            //        order to access current user keys)
+            //
+
+            {
+                HKEY    hKeyHandoffPriorities;
+                LONG    lResult;
+                DWORD   dwDisposition, i;
+                RPC_STATUS  status;
+
+
+                if ((status = RpcImpersonateClient (0)) != RPC_S_OK)
+                {
+                    DBGOUT((2, "ClientDetach: RpcImpersonateClient failed, err=%d", status));
+                }
+
+                if ((lResult = RegCreateKeyEx(
+                        HKEY_CURRENT_USER,
+                        gszRegKeyHandoffPriorities,
+                        0,
+                        "",
+                        REG_OPTION_NON_VOLATILE,
+                        KEY_SET_VALUE,
+                        (LPSECURITY_ATTRIBUTES) NULL,
+                        &hKeyHandoffPriorities,
+                        &dwDisposition
+
+                        )) == ERROR_SUCCESS)
+                {
+                    EnterCriticalSection (&gPriorityListCritSec);
+
+                    for (i = 1; gaszMediaModes[i] != NULL; i++)
+                    {
+                        SetPriorityList(
+                            hKeyHandoffPriorities,
+                            gaszMediaModes[i],
+                            TapiGlobals.apszPriorityList[i]
+                            );
+                    }
+
+                    SetPriorityList(
+                        hKeyHandoffPriorities,
+                        gszRequestMakeCallW,
+                        TapiGlobals.pszReqMakeCallPriList
+                        );
+
+                    SetPriorityList(
+                        hKeyHandoffPriorities,
+                        gszRequestMediaCallW,
+                        TapiGlobals.pszReqMediaCallPriList
+                        );
+
+                    LeaveCriticalSection (&gPriorityListCritSec);
+
+                    RegCloseKey (hKeyHandoffPriorities);
+                }
+                else
+                {
+                    DBGOUT((
+                        3,
+                        "RegCreateKeyEx('\\HandoffPri') failed, err=%ld",
+                        lResult
+                        ));
+                }
+
+                if (status == RPC_S_OK)
+                {
+                    RpcRevertToSelf ();
+                }
+            }
+        }
+    }
+
+    PCONTEXT_HANDLE_TYPE_rundown (*pphContext);
+
+    *pphContext = (PCONTEXT_HANDLE_TYPE) NULL;
+
+    PerfBlock.dwClientApps--;
+
+    DBGOUT((3, "ClientDetach: exit"));
+}
+
+
+void
+__RPC_USER
+PCONTEXT_HANDLE_TYPE_rundown(
+    PCONTEXT_HANDLE_TYPE    phContext
+    )
+{
+    PTCLIENT ptClient = (PTCLIENT) phContext;
+
+
+    //DBGOUT((
+    //    3,
+    //    "PCONTEXT_HANDLE_TYPE_rundown: enter, phContext=x%x",
+    //    phContext
+    //    ));
+
+    //
+    // Mark client as invalid
+    //
+
+    ptClient->dwKey = INVAL_KEY;
+
+
+    //
+    // Remove it from global list
+    //
+
+    WaitForSingleObject (TapiGlobals.hMutex, INFINITE);
+
+    if (ptClient->pNext)
+    {
+        ptClient->pNext->pPrev = ptClient->pPrev;
+    }
+
+    if (ptClient->pPrev)
+    {
+        ptClient->pPrev->pNext = ptClient->pNext;
+    }
+    else
+    {
+        TapiGlobals.ptClients = ptClient->pNext;
+    }
+
+    ReleaseMutex (TapiGlobals.hMutex);
+
+
+    //
+    // If client was remote then detach
+    //
+
+    if (ptClient->hProcess == (HANDLE) 0xffffffff)
+    {
+        RpcTryExcept
+        {
+            RemoteSPDetach (&ptClient->phContext);
+        }
+        RpcExcept (1)
+        {
+            unsigned long ulResult = RpcExceptionCode();
+
+
+            DBGOUT((
+                3,
+                "rundown: exception #%d detaching from remotesp",
+                ulResult
+                ));
+
+            if (ulResult == RPC_S_SERVER_TOO_BUSY)
+            {
+// BUGBUG rundown: timeout, then try the op again
+            }
+            else
+            {
+// BUGBUG rundown: consider shutting down the rpc connection (& send REINITs?)
+            }
+        }
+        RpcEndExcept
+    }
+
+
+    //
+    // Close all XxxApps
+    //
+
+    while (ptClient->ptLineApps)
+    {
+        DestroytLineApp (ptClient->ptLineApps);
+    }
+
+    while (ptClient->ptPhoneApps)
+    {
+        DestroytPhoneApp (ptClient->ptPhoneApps);
+    }
+
+
+    //
+    // Clean up any existing ProviderXxx dialog instances
+    //
+
+    {
+        PTAPIDIALOGINSTANCE pProviderXxxDlgInst =
+                                ptClient->pProviderXxxDlgInsts,
+                            pNextProviderXxxDlgInst;
+
+
+        while (pProviderXxxDlgInst)
+        {
+            FREEDIALOGINSTANCE_PARAMS   params =
+            {
+                0,
+                ptClient,
+                (HTAPIDIALOGINSTANCE) pProviderXxxDlgInst,
+                LINEERR_OPERATIONFAILED
+            };
+
+
+            pNextProviderXxxDlgInst = pProviderXxxDlgInst->pNext;
+
+            FreeDialogInstance (&params, NULL, NULL);
+
+            pProviderXxxDlgInst = pNextProviderXxxDlgInst;
+        }
+    }
+
+
+    //
+    // Clean up associated resources
+    //
+
+    CloseHandle (ptClient->hMutex);
+
+    if (ptClient->hProcess != (HANDLE) 0xffffffff)
+    {
+        CloseHandle (ptClient->hProcess);
+        CloseHandle  (ptClient->hValidEventBufferDataEvent);
+        CloseHandle (ptClient->hEventBufferMutex);
+        ServerFree   (ptClient->pEventBuffer);
+    }
+
+    ServerFree (ptClient->pszUserName);
+
+    if (ptClient->pszComputerName != TapiGlobals.pszComputerName)
+    {
+        ServerFree (ptClient->pszComputerName);
+    }
+
+    ServerFree (ptClient);
+
+
+    //
+    // If this was the last client then alert the SPEventHandlerThread
+    // that it should begin it's deferred shutdown countdown
+    //
+
+    if (!TapiGlobals.ptClients)
+    {
+        EnterCriticalSection (&gSPEventQueueCritSec);
+        SetEvent (ghPendingSPEventsEvent);
+        LeaveCriticalSection (&gSPEventQueueCritSec);
+    }
+
+
+    //DBGOUT((3, "PCONTEXT_HANDLE_TYPE_rundown: exit"));
+}
+
+
+LPVOID
+WINAPI
+ServerAlloc(
+    DWORD   dwSize
+    )
+{
+    LPBYTE  p;
+    LPDWORD pAligned;
+
+
+    //
+    // Alloc 16 extra bytes so we can make sure the pointer we pass back
+    // is 64-bit aligned & have space to store the original pointer
+    //
+
+    if ((p = (LPBYTE) LocalAlloc (LPTR, dwSize + 16)))
+    {
+        pAligned = (LPDWORD) (p + 8 - (((DWORD) p) & 0x7));
+        *pAligned = (DWORD) p;
+        pAligned++;
+        pAligned++;
+    }
+    else
+    {
+        static BOOL fBeenThereDoneThat = FALSE;
+        static DWORD fBreakOnAllocFailed = 0;
+
+        // send reinit msg?
+
+        DBGOUT((
+            1,
+            "ServerAlloc: LocalAlloc (x%lx) failed, err=x%lx",
+            dwSize,
+            GetLastError())
+            );
+
+        pAligned = NULL;
+
+#if DBG
+        if ( !fBeenThereDoneThat )
+        {
+           HKEY    hKey;
+           WCHAR   szTelephonyKey[] =
+                       L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony";
+           WCHAR   szTapisrvDebugBreak[] = L"TapisrvDebugBreak";
+
+
+           fBeenThereDoneThat = TRUE;
+
+           if (RegOpenKeyExW(
+                   HKEY_LOCAL_MACHINE,
+                   szTelephonyKey,
+                   0,
+                   KEY_ALL_ACCESS,
+                   &hKey
+                   ) == ERROR_SUCCESS)
+           {
+               DWORD   dwDataSize = sizeof (DWORD), dwDataType;
+
+               RegQueryValueExW(
+                   hKey,
+                   szTapisrvDebugBreak,
+                   0,
+                   &dwDataType,
+                   (LPBYTE) &fBreakOnAllocFailed,
+                   &dwDataSize
+                   );
+
+               dwDataSize = sizeof (DWORD);
+
+               RegCloseKey (hKey);
+           }
+
+        }
+
+        if ( fBreakOnAllocFailed )
+        {
+           DebugBreak();
+        }
+#endif
+
+    }
+
+    return ((LPVOID) pAligned);
+}
+
+
+VOID
+WINAPI
+ServerFree(
+    LPVOID  p
+    )
+{
+    if (p != NULL)
+    {
+        LPVOID  pOrig = (LPVOID) *(((LPDWORD) p) - 2);
+
+
+        LocalFree (pOrig);
+    }
+#if DBG
+    else
+    {
+        DBGOUT((4,"----- ServerFree: ptr = NULL!"));
+    }
+#endif
+}
+
+
+BOOL
+PASCAL
+MyDuplicateHandle(
+    HANDLE      hSource,
+    LPHANDLE    phTarget
+    )
+{
+    if (!DuplicateHandle(
+            TapiGlobals.hProcess,
+            hSource,
+            TapiGlobals.hProcess,
+            phTarget,
+            0,
+            FALSE,
+            DUPLICATE_SAME_ACCESS
+            ))
+    {
+        DBGOUT((
+            1,
+            "MyDuplicateHandle: DuplicateHandle failed, err=%ld",
+            GetLastError()
+            ));
+
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+
+HANDLE
+MyCreateMutex(
+    void
+    )
+{
+    HANDLE hMutex;
+
+
+    hMutex = CreateMutex(
+        NULL,               // no security attrs
+        FALSE,              // unowned
+        NULL                // unnamed
+        );
+
+    return (hMutex);
+}
+
+
+BOOL
+WaitForMutex(
+    HANDLE      hMutex,
+    HANDLE     *phMutex,
+    BOOL       *pbDupedMutex,
+    LPVOID      pWidget,
+    DWORD       dwKey,
+    DWORD       dwTimeout
+    )
+{
+    DWORD dwResult;
+
+
+    //
+    // First try to instantaneously grab the specified mutex.  We wrap
+    // this in a critical section and preface it with widget validation
+    // to make sure that we don't happen grab a pWidget->hMutex right
+    // after it is released and right before it is closed by some other
+    // thread "T2" in a DestroyWidget routine.  This scenario could cause
+    // deadlock, since there could be thread "T3" waiting on this mutex
+    // (or a dup'd handle), and this thread "T1" would have no way to
+    // release the mutex (the handle having been subsequently closed by
+    // thread "T2" calling DestroyWidget above).
+    //
+
+    EnterCriticalSection (&gSafeMutexCritSec);
+
+    if (pWidget)
+    {
+        try
+        {
+            if (IsBadPtrKey (pWidget, dwKey))
+            {
+                LeaveCriticalSection (&gSafeMutexCritSec);
+                return FALSE;
+            }
+        }
+        myexcept
+        {
+            LeaveCriticalSection (&gSafeMutexCritSec);
+            return FALSE;
+        }
+    }
+
+    switch ((dwResult = WaitForSingleObject (hMutex, 0)))
+    {
+    case WAIT_OBJECT_0:
+
+        LeaveCriticalSection (&gSafeMutexCritSec);
+        *phMutex = hMutex;
+        *pbDupedMutex = FALSE;
+        return TRUE;
+
+    //case WAIT_ABANDONED:
+
+        //assert: no calling thread should ever be terminated!
+
+    default:
+
+        break;
+    }
+
+    LeaveCriticalSection (&gSafeMutexCritSec);
+
+
+    //
+    // If here we failed to instantaneously grab the specified mutex.
+    // Try to dup it, and then wait on the dup'd handle. We do this so
+    // that each thread which grabs a mutex is guaranteed to have a valid
+    // handle to release at some future time, as the original hMutex might
+    // get closed by some other thread calling a DestroyWidget routine.
+    //
+
+    if (!DuplicateHandle(
+            TapiGlobals.hProcess,
+            hMutex,
+            TapiGlobals.hProcess,
+            phMutex,
+            0,
+            FALSE,
+            DUPLICATE_SAME_ACCESS
+            ))
+    {
+        return FALSE;
+    }
+
+WaitForMutex_wait:
+
+    switch ((dwResult = WaitForSingleObject (*phMutex, dwTimeout)))
+    {
+    case WAIT_OBJECT_0:
+
+        *pbDupedMutex = TRUE;
+        return TRUE;
+
+    case WAIT_TIMEOUT:
+
+        try
+        {
+            if (*((LPDWORD) pWidget) == dwKey)
+            {
+                goto WaitForMutex_wait;
+            }
+        }
+        myexcept
+        {
+            // just fall thru without blowing up
+        }
+
+        CloseHandle (*phMutex);
+        break;
+
+    //case WAIT_ABANDONED:
+
+        //assert: no calling thread should ever be terminated!
+
+    default:
+
+        break;
+    }
+
+    return FALSE;
+}
+
+
+void
+MyReleaseMutex(
+    HANDLE  hMutex,
+    BOOL    bCloseMutex
+    )
+{
+    if (hMutex)
+    {
+        ReleaseMutex (hMutex);
+
+        if (bCloseMutex)
+        {
+            CloseHandle (hMutex);
+        }
+    }
+}
+
+
+void
+CALLBACK
+CompletionProcSP(
+    DWORD   dwRequestID,
+    LONG    lResult
+    )
+{
+#if DBG
+    {
+        char szResult[32];
+
+
+        DBGOUT((
+            3,
+            "CompletionProc: enter, dwReqID=x%x, lResult=%s",
+            dwRequestID,
+            MapResultCodeToText (lResult, szResult)
+            ));
+    }
+#endif
+
+    ((PASYNCREQUESTINFO) dwRequestID)->lResult = lResult;
+    QueueSPEvent ((PSPEVENT) dwRequestID);
+}
+
+
+void
+PASCAL
+CompletionProc(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    LONG                lResult
+    )
+{
+//    DWORD           dwNumBytesWritten;
+    ASYNCEVENTMSG   msg;
+
+
+    //
+    // Validate the async request structure pointer
+    //
+
+    try
+    {
+        if (IsBadPtrKey (pAsyncRequestInfo, TASYNC_KEY))
+        {
+            return;
+        }
+
+        pAsyncRequestInfo->dwKey = INVAL_KEY;
+    }
+    myexcept
+    {
+        return;
+    }
+
+
+    //
+    // Init the msg we'll send to client
+    //
+
+    msg.dwTotalSize        = sizeof (ASYNCEVENTMSG);
+    msg.pInitData          = pAsyncRequestInfo->pInitData;
+    msg.pfnPostProcessProc = pAsyncRequestInfo->pfnClientPostProcessProc;
+    msg.hDevice            = 0;
+    msg.dwMsg              = (pAsyncRequestInfo->bLineFunc ?
+                                 LINE_REPLY : PHONE_REPLY);
+    msg.dwCallbackInst     = pAsyncRequestInfo->dwCallbackInst;
+    msg.dwParam1           = pAsyncRequestInfo->dwRequestID;
+    msg.dwParam2           = lResult;
+    msg.dwParam3           = 0;
+
+
+    //
+    // If there's a post processing proc call it.  Note that ppprocs can
+    // create their own msg to pass, so we need to check for this case.
+    // Finally, write the msg to the client's event buffer.
+    //
+
+    if (pAsyncRequestInfo->pfnPostProcess)
+    {
+        LPVOID  pBuf = NULL;
+
+
+        (*pAsyncRequestInfo->pfnPostProcess)(pAsyncRequestInfo, &msg, &pBuf);
+
+        WriteEventBuffer (pAsyncRequestInfo->ptClient, (pBuf ? pBuf : &msg));
+
+        if (pBuf)
+        {
+            ServerFree (pBuf);
+        }
+    }
+    else
+    {
+        WriteEventBuffer (pAsyncRequestInfo->ptClient, &msg);
+    }
+
+    // caller will free pAsyncRequestInfo
+}
+
+
+void
+WriteEventBuffer(
+    PTCLIENT        ptClient,
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    BOOL    bCloseMutex;
+    HANDLE  hMutex;
+
+
+    try
+    {
+        hMutex = (ptClient->hProcess == (HANDLE) 0xffffffff ?
+            NULL : ptClient->hMutex);
+
+        if (ptClient->dwKey != TCLIENT_KEY)
+        {
+            return;
+        }
+    }
+    myexcept
+    {
+        return;
+    }
+
+    if (hMutex)
+    {
+        //
+        // Local client
+        //
+
+        if (WaitForMutex(
+                ptClient->hEventBufferMutex,
+                &hMutex,
+                &bCloseMutex,
+                ptClient,
+                TCLIENT_KEY,
+                INFINITE
+                ))
+        {
+            if (ptClient->dwKey == TCLIENT_KEY)
+            {
+                DWORD dwMoveSize = pMsg->dwTotalSize, dwMoveSizeWrapped = 0;
+
+
+                //
+                // Check to see if we need to grow the event buffer
+                //
+
+                if (dwMoveSize > (ptClient->dwEventBufferTotalSize -
+                        ptClient->dwEventBufferUsedSize))
+                {
+                    DWORD   dwMoveSize2, dwMoveSizeWrapped2,
+                            dwNewEventBufferTotalSize;
+                    LPBYTE  pNewEventBuffer;
+
+
+                    dwNewEventBufferTotalSize =
+                        ptClient->dwEventBufferTotalSize + dwMoveSize + 512;
+
+                    if (!(pNewEventBuffer = ServerAlloc(
+                            dwNewEventBufferTotalSize
+                            )))
+                    {
+// BUGBUG WriteEventBuffer: attempt grow event buf failed
+                    }
+
+                    if (ptClient->dwEventBufferUsedSize != 0)
+                    {
+                        if (ptClient->pDataIn > ptClient->pDataOut)
+                        {
+                            dwMoveSize2 = (DWORD) (ptClient->pDataIn -
+                                ptClient->pDataOut);
+
+                            dwMoveSizeWrapped2 = 0;
+                        }
+                        else
+                        {
+                            dwMoveSize2 = (DWORD) ((ptClient->pEventBuffer +
+                                ptClient->dwEventBufferTotalSize) -
+                                    ptClient->pDataOut);
+
+                            dwMoveSizeWrapped2 = (DWORD) (ptClient->pDataIn -
+                                ptClient->pEventBuffer);
+                        }
+
+                        CopyMemory(
+                            pNewEventBuffer,
+                            ptClient->pDataOut,
+                            dwMoveSize2
+                            );
+
+                        if (dwMoveSizeWrapped2)
+                        {
+                            CopyMemory(
+                                pNewEventBuffer + dwMoveSize2,
+                                ptClient->pEventBuffer,
+                                dwMoveSizeWrapped2
+                                );
+                        }
+
+                        ptClient->pDataIn = pNewEventBuffer + dwMoveSize2 +
+                            dwMoveSizeWrapped2;
+                    }
+                    else
+                    {
+                        ptClient->pDataIn = pNewEventBuffer;
+                    }
+
+                    ServerFree (ptClient->pEventBuffer);
+
+                    ptClient->pDataOut =
+                    ptClient->pEventBuffer = pNewEventBuffer;
+
+                    ptClient->dwEventBufferTotalSize =
+                        dwNewEventBufferTotalSize;
+
+                }
+
+                if (ptClient->pDataIn >= ptClient->pDataOut)
+                {
+                    DWORD dwFreeSize = ptClient->dwEventBufferTotalSize -
+                            (ptClient->pDataIn - ptClient->pEventBuffer);
+
+
+                    if (dwMoveSize > dwFreeSize)
+                    {
+                        dwMoveSizeWrapped = dwMoveSize - dwFreeSize;
+
+                        dwMoveSize = dwFreeSize;
+                    }
+                }
+
+                CopyMemory (ptClient->pDataIn, (LPBYTE) pMsg, dwMoveSize);
+
+                if (dwMoveSizeWrapped != 0)
+                {
+                    CopyMemory(
+                        ptClient->pEventBuffer,
+                        ((LPBYTE) pMsg) + dwMoveSize,
+                        dwMoveSizeWrapped
+                        );
+
+                    ptClient->pDataIn = ptClient->pEventBuffer + dwMoveSizeWrapped;
+                }
+                else
+                {
+                    ptClient->pDataIn += dwMoveSize;
+
+                    if (ptClient->pDataIn >= (ptClient->pEventBuffer +
+                            ptClient->dwEventBufferTotalSize))
+                    {
+                        ptClient->pDataIn = ptClient->pEventBuffer;
+                    }
+                }
+
+                ptClient->dwEventBufferUsedSize += pMsg->dwTotalSize;
+
+                SetEvent (ptClient->hValidEventBufferDataEvent);
+
+//                DBGOUT((
+//                    3,
+//                    "WriteEventBuffer: bytesWritten=x%x (local)",
+//                    dwMoveSize
+//                    ));
+            }
+
+            MyReleaseMutex (hMutex, bCloseMutex);
+        }
+    }
+    else
+    {
+        //
+        // Remote client
+        //
+
+        //
+        // !!! Note the overloading of the pMsg->dwCallbackInst field here
+        //     (the EventNotificationThread needs to know which client the
+        //     msg is destined for), which is preferable to adding yet
+        //     another 4 bytes to the ASYNCEVENTMSG struct.  Remotesp never
+        //     looks at the dwCallbackInst field in msgs anyways.
+        //
+
+        pMsg->dwCallbackInst = (DWORD) ptClient;
+
+        EnterCriticalSection (&gRemoteCliEventBufCritSec);
+
+        {
+            DWORD dwMoveSize = pMsg->dwTotalSize, dwMoveSizeWrapped = 0;
+
+
+            //
+            // Check to see if we need to grow the event buffer
+            //
+
+            if (dwMoveSize >
+                    (gEventNotificationThreadParams.dwEventBufferTotalSize -
+                    gEventNotificationThreadParams.dwEventBufferUsedSize))
+            {
+                DWORD   dwMoveSize2, dwMoveSizeWrapped2,
+                        dwNewEventBufferTotalSize;
+                LPBYTE  pNewEventBuffer;
+
+
+                dwNewEventBufferTotalSize = dwMoveSize + 512 +
+                    gEventNotificationThreadParams.dwEventBufferTotalSize;
+
+                if (!(pNewEventBuffer = ServerAlloc(
+                        dwNewEventBufferTotalSize
+                        )))
+                {
+// BUGBUG WriteEventBuffer: attempt grow event buf failed
+                }
+
+                if (gEventNotificationThreadParams.pDataIn >
+                        gEventNotificationThreadParams.pDataOut)
+                {
+                    dwMoveSize2 = (DWORD)
+                        (gEventNotificationThreadParams.pDataIn -
+                            gEventNotificationThreadParams.pDataOut);
+
+                    dwMoveSizeWrapped2 = 0;
+                }
+                else
+                {
+                    dwMoveSize2 = (DWORD)
+                        ((gEventNotificationThreadParams.pEventBuffer +
+                        gEventNotificationThreadParams.dwEventBufferTotalSize)
+                            - gEventNotificationThreadParams.pDataOut);
+
+                    dwMoveSizeWrapped2 = (DWORD)
+                        (gEventNotificationThreadParams.pDataIn -
+                            gEventNotificationThreadParams.pEventBuffer);
+                }
+
+                CopyMemory(
+                    pNewEventBuffer,
+                    gEventNotificationThreadParams.pDataOut,
+                    dwMoveSize2
+                    );
+
+                if (dwMoveSizeWrapped2)
+                {
+                    CopyMemory(
+                        pNewEventBuffer + dwMoveSize2,
+                        gEventNotificationThreadParams.pEventBuffer,
+                        dwMoveSizeWrapped2
+                        );
+                }
+
+                ServerFree (gEventNotificationThreadParams.pEventBuffer);
+
+                gEventNotificationThreadParams.pDataIn = pNewEventBuffer +
+                    dwMoveSize2 + dwMoveSizeWrapped2;
+
+                gEventNotificationThreadParams.pDataOut =
+                gEventNotificationThreadParams.pEventBuffer = pNewEventBuffer;
+
+                gEventNotificationThreadParams.dwEventBufferTotalSize =
+                    dwNewEventBufferTotalSize;
+            }
+
+            if (gEventNotificationThreadParams.pDataIn >=
+                    gEventNotificationThreadParams.pDataOut)
+            {
+                DWORD dwFreeSize;
+
+                dwFreeSize =
+                    gEventNotificationThreadParams.dwEventBufferTotalSize -
+                    (gEventNotificationThreadParams.pDataIn -
+                    gEventNotificationThreadParams.pEventBuffer);
+
+                if (dwMoveSize > dwFreeSize)
+                {
+                    dwMoveSizeWrapped = dwMoveSize - dwFreeSize;
+
+                    dwMoveSize = dwFreeSize;
+                }
+            }
+
+            CopyMemory(
+                gEventNotificationThreadParams.pDataIn,
+                (LPBYTE) pMsg,
+                dwMoveSize
+                );
+
+            if (dwMoveSizeWrapped != 0)
+            {
+                CopyMemory(
+                    gEventNotificationThreadParams.pEventBuffer,
+                    ((LPBYTE) pMsg) + dwMoveSize,
+                    dwMoveSizeWrapped
+                    );
+
+                gEventNotificationThreadParams.pDataIn =
+                    gEventNotificationThreadParams.pEventBuffer +
+                        dwMoveSizeWrapped;
+            }
+            else
+            {
+                gEventNotificationThreadParams.pDataIn += dwMoveSize;
+
+                if (gEventNotificationThreadParams.pDataIn >=
+                        (gEventNotificationThreadParams.pEventBuffer +
+                        gEventNotificationThreadParams.dwEventBufferTotalSize))
+                {
+                    gEventNotificationThreadParams.pDataIn =
+                        gEventNotificationThreadParams.pEventBuffer;
+                }
+            }
+
+            gEventNotificationThreadParams.dwEventBufferUsedSize +=
+                pMsg->dwTotalSize;
+
+            SetEvent (gEventNotificationThreadParams.hEvent);
+
+//            DBGOUT((
+//                3,
+//                "WriteEventBuffer: bytesWritten=x%x (remote)",
+//                dwMoveSize
+//                ));
+        }
+
+        LeaveCriticalSection (&gRemoteCliEventBufCritSec);
+    }
+}
+
+
+LONG
+AddLine(
+    PTPROVIDER  ptProvider,
+    DWORD       dwDeviceID,
+    BOOL        bInit
+    )
+{
+    DWORD               dwSPIVersion;
+    HANDLE              hMutex = NULL;
+    PTLINELOOKUPTABLE   pLookup;
+
+
+    //
+    // First try to negotiate an SPI ver for this device, and alloc the
+    // necessary resources
+    //
+
+    if (CallSP4(
+            ptProvider->apfn[SP_LINENEGOTIATETSPIVERSION],
+            "lineNegotiateTSPIVersion",
+            SP_FUNC_SYNC,
+            dwDeviceID,
+            TAPI_VERSION1_0,
+            TAPI_VERSION_CURRENT,
+            (DWORD) &dwSPIVersion
+
+            ) != 0)
+    {
+        //
+        // Device failed version negotiation, so we'll keep the id around
+        // (since the id's for the devices that follow have already been
+        // assigned) but mark this device as bad
+        //
+
+        ptProvider = NULL;
+    }
+
+    else if (!(hMutex = MyCreateMutex ()))
+    {
+        DBGOUT((
+            1,
+            "AddLine: MyCreateMutex failed, err=%d",
+            GetLastError()
+            ));
+
+        return LINEERR_OPERATIONFAILED;
+    }
+
+
+    //
+    // Now walk the lookup table to find a free entry
+    //
+
+    pLookup = TapiGlobals.pLineLookup;
+
+    while (pLookup->pNext)
+    {
+        pLookup = pLookup->pNext;
+    }
+
+    if (pLookup->dwNumUsedEntries == pLookup->dwNumTotalEntries)
+    {
+        PTLINELOOKUPTABLE   pNewLookup;
+
+
+        if (!(pNewLookup = ServerAlloc(
+                sizeof (TLINELOOKUPTABLE) +
+                    (2 * pLookup->dwNumTotalEntries - 1) *
+                    sizeof (TLINELOOKUPENTRY)
+                )))
+        {
+            return LINEERR_NOMEM;
+        }
+
+        pNewLookup->dwNumTotalEntries = 2 * pLookup->dwNumTotalEntries;
+
+
+        //
+        // If we're initializing we want to put everything in one big table
+        //
+
+        if (bInit)
+        {
+            pNewLookup->dwNumUsedEntries = pLookup->dwNumTotalEntries;
+
+            CopyMemory(
+                pNewLookup->aEntries,
+                pLookup->aEntries,
+                pLookup->dwNumTotalEntries * sizeof (TLINELOOKUPENTRY)
+                );
+
+            ServerFree (pLookup);
+
+            TapiGlobals.pLineLookup = pNewLookup;
+
+        }
+
+        pLookup = pNewLookup;
+    }
+
+
+    //
+    // Initialize the entry
+    //
+
+    {
+        DWORD   index = pLookup->dwNumUsedEntries;
+
+
+        pLookup->aEntries[index].dwSPIVersion = dwSPIVersion;
+        pLookup->aEntries[index].hMutex       = hMutex;
+        pLookup->aEntries[index].ptProvider   = ptProvider;
+
+        if (ptProvider &&
+            lstrcmpiW(ptProvider->szFileName, L"kmddsp.tsp") == 0)
+        {
+            pLookup->aEntries[index].bRemote = TRUE;
+        }
+    }
+
+    pLookup->dwNumUsedEntries++;
+
+    return 0;
+}
+
+
+LONG
+AddPhone(
+    PTPROVIDER  ptProvider,
+    DWORD       dwDeviceID,
+    BOOL        bInit
+    )
+{
+    DWORD               dwSPIVersion;
+    HANDLE              hMutex = NULL;
+    PTPHONELOOKUPTABLE  pLookup;
+
+
+    //
+    // First try to negotiate an SPI ver for this device, and alloc the
+    // necessary resources
+    //
+
+    if (CallSP4(
+            ptProvider->apfn[SP_PHONENEGOTIATETSPIVERSION],
+            "phoneNegotiateTSPIVersion",
+            SP_FUNC_SYNC,
+            dwDeviceID,
+            TAPI_VERSION1_0,
+            TAPI_VERSION_CURRENT,
+            (DWORD) &dwSPIVersion
+
+            ) != 0)
+    {
+        //
+        // Device failed version negotiation, so we'll keep the id around
+        // (since the id's for the devices that follow have already been
+        // assigned) but mark this device as bad
+        //
+
+        ptProvider = NULL;
+    }
+
+    else if (!(hMutex = MyCreateMutex ()))
+    {
+        DBGOUT((
+            1,
+            "AddPhone: MyCreateMutex failed, err=%d",
+            GetLastError()
+            ));
+
+        return PHONEERR_OPERATIONFAILED;
+    }
+
+
+    //
+    // Now walk the lookup table to find a free entry
+    //
+
+    pLookup = TapiGlobals.pPhoneLookup;
+
+    while (pLookup->pNext)
+    {
+        pLookup = pLookup->pNext;
+    }
+
+    if (pLookup->dwNumUsedEntries == pLookup->dwNumTotalEntries)
+    {
+        PTPHONELOOKUPTABLE  pNewLookup;
+
+
+        if (!(pNewLookup = ServerAlloc(
+                sizeof (TPHONELOOKUPTABLE) +
+                    (2 * pLookup->dwNumTotalEntries - 1) *
+                    sizeof (TPHONELOOKUPENTRY)
+                )))
+        {
+            return PHONEERR_NOMEM;
+        }
+
+        pNewLookup->dwNumTotalEntries = 2 * pLookup->dwNumTotalEntries;
+
+
+        //
+        // If we're initializing we want to put everything in one big table
+        //
+
+        if (bInit)
+        {
+            pNewLookup->dwNumUsedEntries = pLookup->dwNumTotalEntries;
+
+            CopyMemory(
+                pNewLookup->aEntries,
+                pLookup->aEntries,
+                pLookup->dwNumTotalEntries * sizeof (TPHONELOOKUPENTRY)
+                );
+
+            ServerFree (pLookup);
+
+            TapiGlobals.pPhoneLookup = pNewLookup;
+
+        }
+
+        pLookup = pNewLookup;
+    }
+
+
+    //
+    // Initialize the entry
+    //
+
+    {
+        DWORD   index = pLookup->dwNumUsedEntries;
+
+
+        pLookup->aEntries[index].dwSPIVersion = dwSPIVersion;
+        pLookup->aEntries[index].hMutex       = hMutex;
+        pLookup->aEntries[index].ptProvider   = ptProvider;
+    }
+
+    pLookup->dwNumUsedEntries++;
+
+    return 0;
+}
+
+
+void
+PASCAL
+GetPriorityList(
+    HKEY    hKeyHandoffPriorities,
+    WCHAR  *pszListName,
+    WCHAR **ppszPriorityList
+    )
+{
+    LONG    lResult;
+    DWORD   dwType, dwNumBytes;
+
+
+    *ppszPriorityList = NULL;
+
+    if ((lResult = RegQueryValueExW(
+            hKeyHandoffPriorities,
+            pszListName,
+            NULL,
+            &dwType,
+            NULL,
+            &dwNumBytes
+
+            )) == ERROR_SUCCESS &&
+
+        (dwNumBytes != 0))
+    {
+        WCHAR   *pszPriorityList = ServerAlloc ( dwNumBytes + sizeof(WCHAR));
+        // need an extra WCHAR for the extra '"'
+
+
+        if (pszPriorityList)
+        {
+            pszPriorityList[0] = '"';
+
+            if ((lResult = RegQueryValueExW(
+                    hKeyHandoffPriorities,
+                    pszListName,
+                    NULL,
+                    &dwType,
+                    (LPBYTE)(pszPriorityList + 1),
+                    &dwNumBytes
+
+                    )) == ERROR_SUCCESS)
+            {
+                CharUpperW (pszPriorityList);
+                *ppszPriorityList = pszPriorityList;
+                DBGOUT((3, "PriList: %ls=%ls", pszListName, pszPriorityList));
+            }
+        }
+        else
+        {
+            //
+            // Don't bother with the failure to alloc a priority list
+            // (list defaults to NULL anyway), we'll deal with a lack
+            // of memory at a later time
+            //
+
+            *ppszPriorityList = NULL;
+        }
+    }
+    else
+    {
+        *ppszPriorityList = NULL;
+        DBGOUT((3, "PriList: %ls=NULL", pszListName));
+    }
+}
+
+
+LONG
+ServerInit(
+    void
+    )
+{
+    UINT    uiNumProviders, i, j;
+    HKEY    hKeyTelephony, hKeyProviders;
+    DWORD   dwDataSize, dwDataType;
+
+
+    //
+    // Initialize the globals
+    //
+
+    TapiGlobals.dwAsyncRequestID = 1;
+
+    TapiGlobals.ptProviders = NULL;
+
+    TapiGlobals.pLineLookup = (PTLINELOOKUPTABLE) ServerAlloc(
+        sizeof (TLINELOOKUPTABLE) +
+            (DEF_NUM_LOOKUP_ENTRIES - 1) * sizeof (TLINELOOKUPENTRY)
+        );
+
+    TapiGlobals.pLineLookup->dwNumTotalEntries = DEF_NUM_LOOKUP_ENTRIES;
+
+    TapiGlobals.pPhoneLookup = (PTPHONELOOKUPTABLE) ServerAlloc(
+        sizeof (TPHONELOOKUPTABLE) +
+            (DEF_NUM_LOOKUP_ENTRIES - 1) * sizeof (TPHONELOOKUPENTRY)
+        );
+
+    TapiGlobals.pPhoneLookup->dwNumTotalEntries = DEF_NUM_LOOKUP_ENTRIES;
+
+    gbQueueSPEvents = TRUE;
+
+
+    //
+    // Determine number of providers
+    //
+
+    RegOpenKeyEx(
+        HKEY_LOCAL_MACHINE,
+        gszRegKeyTelephony,
+        0,
+        KEY_ALL_ACCESS,
+        &hKeyTelephony
+        );
+
+    RegOpenKeyEx(
+        HKEY_LOCAL_MACHINE,
+        gszRegKeyProviders,
+        0,
+        KEY_ALL_ACCESS,
+        &hKeyProviders
+        );
+
+    dwDataSize = sizeof(uiNumProviders);
+    uiNumProviders = 0;
+
+    RegQueryValueEx(
+        hKeyProviders,
+        gszNumProviders,
+        0,
+        &dwDataType,
+        (LPBYTE) &uiNumProviders,
+        &dwDataSize
+        );
+
+    DBGOUT((3, "ServerInit: NumProviders=%d", uiNumProviders));
+
+
+    //
+    // Load & init the providers
+    //
+
+    for (i = 0; i < uiNumProviders; i++)
+    {
+        #define FILENAME_SIZE 128
+
+        WCHAR          szFilename[FILENAME_SIZE];
+        WCHAR          buf[32];
+        LONG           lResult;
+        DWORD          dwNumLines, dwNumPhones, dwPermanentProviderID;
+        PTPROVIDER     ptProvider;
+
+
+        wsprintfW(buf, L"%ls%d", gszProviderIDW, i);
+
+        dwDataSize = sizeof(dwPermanentProviderID);
+        dwPermanentProviderID = 0;
+
+        RegQueryValueExW(
+            hKeyProviders,
+            buf,    //"ProviderID#"
+            0,
+            &dwDataType,
+            (LPBYTE) &dwPermanentProviderID,
+            &dwDataSize
+            );
+
+
+
+        //
+        // Back to the main section
+        //
+
+        dwDataSize = FILENAME_SIZE;
+
+        wsprintfW (buf, L"%ls%d", gszProviderFilenameW, i);
+
+        RegQueryValueExW(
+            hKeyProviders,
+            buf,            // "ProviderFilename#"
+            0,
+            &dwDataType,
+            (LPBYTE) szFilename,
+            &dwDataSize
+            );
+
+        szFilename[dwDataSize] = '\0';
+
+        DBGOUT((3, "ServerInit: ProviderFilename=%ls", szFilename));
+
+        if (!(ptProvider = (PTPROVIDER) ServerAlloc(
+                sizeof(TPROVIDER) + ((lstrlenW(szFilename) + 1) * sizeof(WCHAR))
+                )))
+        {
+// BUGBUG ServerInit: handle tprovider alloc failure
+
+            break;
+        }
+
+        if (!(ptProvider->hDll = LoadLibraryW (szFilename)))
+        {
+            DBGOUT((
+                3,
+                "ServerInit: LoadLibraryW(%ls) failed, err=x%x",
+                szFilename,
+                GetLastError()
+                ));
+
+            ServerFree (ptProvider);
+            continue;
+        }
+
+        lstrcpyW(ptProvider->szFileName, szFilename);
+
+
+        //
+        // Get all the TSPI proc addrs
+        //
+
+        for (j = 0; gaszTSPIFuncNames[j]; j++)
+        {
+            ptProvider->apfn[j] = (TSPIPROC) GetProcAddress(
+                ptProvider->hDll,
+                (LPCSTR) gaszTSPIFuncNames[j]
+                );
+        }
+
+
+        //
+        // A real quick check to see if a couple of required entrypoints
+        // are exported
+        //
+
+        if (!ptProvider->apfn[SP_LINENEGOTIATETSPIVERSION] ||
+            !ptProvider->apfn[SP_PROVIDERENUMDEVICES] ||
+            !ptProvider->apfn[SP_PROVIDERINIT] ||
+            !ptProvider->apfn[SP_PROVIDERSHUTDOWN]
+            )
+        {
+            goto ServerInit_validateEntrypoints;
+        }
+
+
+        //
+        // Do global provider version negotiation
+        //
+
+        lResult = CallSP4(
+            ptProvider->apfn[SP_LINENEGOTIATETSPIVERSION],
+            "lineNegotiateTSPIVersion",
+            SP_FUNC_SYNC,
+            INITIALIZE_NEGOTIATION,
+            TAPI_VERSION1_0,
+            TAPI_VERSION_CURRENT,
+            (DWORD) &ptProvider->dwSPIVersion
+            );
+
+        if (lResult != 0)
+        {
+            FreeLibrary (ptProvider->hDll);
+            ServerFree (ptProvider);
+            continue;
+        }
+
+
+        //
+        // Try to enum the devices if provider supports it, otherwise
+        // try grabbing the num lines & phones from ProviderN section
+        //
+
+        dwNumLines = dwNumPhones = 0;
+
+        lResult = CallSP6(
+            ptProvider->apfn[SP_PROVIDERENUMDEVICES],
+            "providerEnumDevices",
+            SP_FUNC_SYNC,
+            dwPermanentProviderID,
+            (DWORD) &dwNumLines,
+            (DWORD) &dwNumPhones,
+            (DWORD) ptProvider,
+            (DWORD) LineEventProcSP,
+            (DWORD) PhoneEventProcSP
+            );
+
+
+        //
+        // Init the provider
+        //
+        // !!! HACK ALERT: for kmddsp pass ptr's to dwNumXxxs
+        //
+
+        DBGOUT((3, "ServerInit: %ls: Calling TSPI_providerInit", szFilename));
+
+        if (lstrcmpiW(szFilename, L"kmddsp.tsp") == 0)
+        {
+            dwNumLines  = (DWORD) &dwNumLines;
+            dwNumPhones = (DWORD) &dwNumPhones;
+        }
+        else if (lstrcmpiW(szFilename, L"remotesp.tsp") == 0)
+        {
+            pRemoteSP = ptProvider;
+        }
+
+        lResult = CallSP8(
+            ptProvider->apfn[SP_PROVIDERINIT],
+            "providerInit",
+            SP_FUNC_SYNC,
+            (DWORD) ptProvider->dwSPIVersion,
+            (DWORD) dwPermanentProviderID,
+            (DWORD) TapiGlobals.pLineLookup->dwNumUsedEntries,
+            (DWORD) TapiGlobals.pPhoneLookup->dwNumUsedEntries,
+            (DWORD) dwNumLines,
+            (DWORD) dwNumPhones,
+            (DWORD) CompletionProcSP,
+            (DWORD) &ptProvider->dwTSPIOptions
+            );
+
+
+        if (lResult != 0)
+        {
+            DBGOUT((
+                1,
+                "ServerInit: %ls: failed TSPI_providerInit [x%x]" \
+                    " - skipping it...",
+                szFilename,
+                lResult
+                ));
+
+            FreeLibrary (ptProvider->hDll);
+            ServerFree (ptProvider);
+            continue;
+        }
+
+        DBGOUT((
+            3,
+            "ServerInit: %ls init'd, dwNumLines=%ld, dwNumPhones=%ld",
+            szFilename,
+            dwNumLines,
+            dwNumPhones
+            ));
+
+
+        //
+        // Now that we know if we have line and/or phone devs check for
+        // the required entry points
+        //
+
+ServerInit_validateEntrypoints:
+
+        {
+            DWORD adwRequiredEntrypointIndices[] =
+            {
+                SP_LINENEGOTIATETSPIVERSION,
+                SP_PROVIDERINIT,
+                SP_PROVIDERSHUTDOWN,
+
+                SP_PHONENEGOTIATETSPIVERSION,
+
+                0xffffffff
+            };
+            BOOL bRequiredEntrypointsExported = TRUE;
+
+
+            //
+            // If this provider doesn't support any phone devices then
+            // it isn't required to export phone funcs
+            //
+
+            if (dwNumPhones == 0)
+            {
+                adwRequiredEntrypointIndices[3] = 0xffffffff;
+            }
+
+//DBGOUT((0, " ptProvider=0x%08lx", ptProvider));
+            for (j = 0;
+                 adwRequiredEntrypointIndices[j] != 0xffffffff;
+                 j++
+                 )
+            {
+                if (ptProvider->apfn[adwRequiredEntrypointIndices[j]]
+                        == (TSPIPROC) NULL)
+                {
+                    DBGOUT((
+                        1,
+                        "ServerInit: %ls: can't init, func ordinal #%ld " \
+                            "not exported",
+                        szFilename,
+//                        TSPI_PROC_BASE + j
+                        500 + j
+                        ));
+
+                    bRequiredEntrypointsExported = FALSE;
+                }
+            }
+
+            if (bRequiredEntrypointsExported == FALSE)
+            {
+                FreeLibrary (ptProvider->hDll);
+                ServerFree (ptProvider);
+                continue;
+            }
+        }
+
+
+        //
+        // Do version negotiation on each device & add them to lookup lists
+        //
+
+        {
+            DWORD dwDeviceIDBase;
+
+
+            dwDeviceIDBase = TapiGlobals.pLineLookup->dwNumUsedEntries;
+
+            for (j = dwDeviceIDBase; j < (dwDeviceIDBase + dwNumLines); j++)
+            {
+                if (AddLine (ptProvider, j, TRUE))
+                {
+// BUGBUG ServerInit: handle AddLine failure
+                }
+            }
+
+            dwDeviceIDBase = TapiGlobals.pPhoneLookup->dwNumUsedEntries;
+
+            for (j = dwDeviceIDBase; j < (dwDeviceIDBase + dwNumPhones); j++)
+            {
+                if (AddPhone (ptProvider, j, TRUE))
+                {
+// BUGBUG ServerInit: handle AddPhone failure
+                }
+            }
+        }
+
+
+        //
+        //
+        //
+
+        ptProvider->hMutex = MyCreateMutex();
+
+        ptProvider->dwPermanentProviderID = dwPermanentProviderID;
+
+
+        //
+        // Add provider to head of list, mark as valid
+        //
+
+        ptProvider->pNext = TapiGlobals.ptProviders;
+        TapiGlobals.ptProviders = ptProvider;
+
+        ptProvider->dwKey = TPROVIDER_KEY;
+    }
+
+
+    RegCloseKey (hKeyProviders);
+    RegCloseKey (hKeyTelephony);
+
+
+    //
+    // Save lookup lists & num devices
+    //
+
+    TapiGlobals.dwNumLines  = TapiGlobals.pLineLookup->dwNumUsedEntries;
+    TapiGlobals.dwNumPhones = TapiGlobals.pPhoneLookup->dwNumUsedEntries;
+
+    // init perf stuff
+    PerfBlock.dwLines = TapiGlobals.dwNumLines;
+    PerfBlock.dwPhones = TapiGlobals.dwNumPhones;
+    
+    return 0;
+}
+
+
+void
+PASCAL
+SetPriorityList(
+    HKEY    hKeyHandoffPriorities,
+    WCHAR  *pszListName,
+    WCHAR  *pszPriorityList
+    )
+{
+    if (pszPriorityList == NULL)
+    {
+        //
+        // There is no pri list for this media mode or ReqXxxCall,
+        // so delete any existing value from the registry
+        //
+
+        RegDeleteValueW (hKeyHandoffPriorities, pszListName);
+    }
+    else
+    {
+        //
+        // Add the pri list to the registry (note that we don't
+        // add the preceding '"')
+        //
+
+        RegSetValueExW(
+            hKeyHandoffPriorities,
+            pszListName,
+            0,
+            REG_SZ,
+            (LPBYTE)(pszPriorityList + 1),
+            lstrlenW (pszPriorityList) * sizeof (WCHAR)
+            );
+    }
+}
+
+
+LONG
+ServerShutdown(
+    void
+    )
+{
+    DWORD       i;
+    PTPROVIDER  ptProvider;
+
+
+    //
+    // Reset the flag that says it's ok to queue sp events, & then wait
+    // for the SPEventHandlerThread to clean up the SP event queue.
+    //
+
+    EnterCriticalSection (&gSPEventQueueCritSec);
+    gbQueueSPEvents = FALSE;
+    LeaveCriticalSection (&gSPEventQueueCritSec);
+
+    while (gpOldestSPEvent != NULL)
+    {
+        Sleep (0);
+    }
+
+
+    //
+    // For each provider call the shutdown proc & then unload
+    //
+
+    ptProvider = TapiGlobals.ptProviders;
+
+    while (ptProvider)
+    {
+        PTPROVIDER ptNextProvider = ptProvider->pNext;
+        LONG lResult;
+
+
+        lResult = CallSP2(
+            ptProvider->apfn[SP_PROVIDERSHUTDOWN],
+            "providerShutdown",
+            SP_FUNC_SYNC,
+            ptProvider->dwSPIVersion,
+            ptProvider->dwPermanentProviderID
+            );
+
+
+        FreeLibrary (ptProvider->hDll);
+
+        CloseHandle (ptProvider->hMutex);
+
+        ServerFree (ptProvider);
+
+        ptProvider = ptNextProvider;
+    }
+
+
+    //
+    // Clean up lookup tables
+    //
+
+    while (TapiGlobals.pLineLookup)
+    {
+        PTLINELOOKUPTABLE pLookup = TapiGlobals.pLineLookup;
+
+
+        for (i = 0; i < pLookup->dwNumUsedEntries; i++)
+        {
+            CloseHandle (pLookup->aEntries[i].hMutex);
+        }
+
+        TapiGlobals.pLineLookup = pLookup->pNext;
+
+        ServerFree (pLookup);
+    }
+
+    while (TapiGlobals.pPhoneLookup)
+    {
+        PTPHONELOOKUPTABLE pLookup = TapiGlobals.pPhoneLookup;
+
+
+        for (i = 0; i < pLookup->dwNumUsedEntries; i++)
+        {
+            CloseHandle (pLookup->aEntries[i].hMutex);
+        }
+
+        TapiGlobals.pPhoneLookup = pLookup->pNext;
+
+        ServerFree (pLookup);
+    }
+
+    {
+        WCHAR       szPerfNumLines[] = L"Perf1";
+        WCHAR       szPerfNumPhones[] = L"Perf2";
+        HKEY        hKeyTelephony;
+        DWORD       dwValue;
+
+        RegOpenKeyEx(
+                     HKEY_LOCAL_MACHINE,
+                     gszRegKeyTelephony,
+                     0,
+                     KEY_ALL_ACCESS,
+                     &hKeyTelephony
+                    );
+
+
+        dwValue = TapiGlobals.dwNumLines + 'PERF';
+        
+        RegSetValueExW(
+                       hKeyTelephony,
+                       szPerfNumLines,
+                       0,
+                       REG_DWORD,
+                       (LPBYTE)&dwValue,
+                       sizeof(DWORD)
+                      );
+
+        dwValue = TapiGlobals.dwNumPhones + 'PERF';
+        
+        RegSetValueExW(
+                       hKeyTelephony,
+                       szPerfNumPhones,
+                       0,
+                       REG_DWORD,
+                       (LPBYTE)&dwValue,
+                       sizeof(DWORD)
+                      );
+
+        RegCloseKey(hKeyTelephony);
+        
+    }
+
+    //
+    // Reset globals
+    //
+    
+
+    TapiGlobals.bReinit = FALSE;
+
+    return 0;
+}
+
+
+void
+WINAPI
+GetAsyncEvents(
+    PGETEVENTS_PARAMS       pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    DWORD       dwMoveSize, dwMoveSizeWrapped;
+    PTCLIENT    ptClient = pParams->ptClient;
+
+
+//    DBGOUT((3, "GetAsyncEvents: enter (TID=%d)", GetCurrentThreadId()));
+
+
+DBGOUT((91, "M ebfused:x%lx  pEvtBuf: 0x%08lx  pDataOut:0x%08lx  pDataIn:0x%08lx",
+              ptClient->dwEventBufferUsedSize,
+              ptClient->pEventBuffer,
+              ptClient->pDataOut,
+              ptClient->pDataIn ));
+
+    //
+    // Copy data from ptClient's event buffer
+    //
+    // An optimization to be made is to alert client (via dwNeededSize)
+    // that it might want to alloc a larger buffer when msg traffic is
+    // real high
+    //
+
+    WaitForSingleObject (ptClient->hEventBufferMutex, INFINITE);
+
+    if (ptClient->dwEventBufferUsedSize == 0)
+    {
+        ResetEvent (ptClient->hValidEventBufferDataEvent);
+
+        pParams->dwNeededBufferSize =
+        pParams->dwUsedBufferSize   = 0;
+
+        *pdwNumBytesReturned = sizeof (TAPI32_MSG);
+
+        goto GetAsyncEvents_releaseMutex;
+    }
+
+    if (ptClient->pDataOut < ptClient->pDataIn)
+    {
+        dwMoveSize = ptClient->pDataIn - ptClient->pDataOut;
+
+        dwMoveSizeWrapped = 0;
+    }
+    else
+    {
+        dwMoveSize = ptClient->dwEventBufferTotalSize -
+             (ptClient->pDataOut - ptClient->pEventBuffer);
+
+        dwMoveSizeWrapped = ptClient->pDataIn - ptClient->pEventBuffer;
+    }
+
+    if (ptClient->dwEventBufferUsedSize < pParams->dwTotalBufferSize)
+    {
+        //
+        // If here the size of the queued event data is less than the
+        // client buffer size, so we can just blast the bits into the
+        // client buffer & return. Also make sure to reset the "events
+        // pending" event
+        //
+
+        CopyMemory (pDataBuf, ptClient->pDataOut, dwMoveSize);
+
+        if (dwMoveSizeWrapped)
+        {
+            CopyMemory(
+                pDataBuf + dwMoveSize,
+                ptClient->pEventBuffer,
+                dwMoveSizeWrapped
+                );
+        }
+
+        ptClient->dwEventBufferUsedSize = 0;
+
+        ptClient->pDataOut = ptClient->pDataIn;
+
+        ResetEvent (ptClient->hValidEventBufferDataEvent);
+
+        pParams->dwNeededBufferSize =
+        pParams->dwUsedBufferSize   = dwMoveSize + dwMoveSizeWrapped;
+
+//        DBGOUT((3, "GetAsyncEvents: usedSize=x%x", pParams->dwUsedBufferSize));
+
+        *pdwNumBytesReturned = sizeof (TAPI32_MSG) + pParams->dwUsedBufferSize;
+    }
+    else
+    {
+        //
+        // If here the size of the queued event data exceeds that
+        // of the client buffer.  Since our events aren't all the
+        // same size we need to copy them over one by one, making
+        // sure we don't overflow the client buffer.  Don't reset
+        // the "events pending" event, so async events thread will
+        // call us again as soon as it's done processing messages
+        // in the buffer.
+        //
+        //
+
+        DWORD   dwBytesLeftInClientBuffer = pParams->dwTotalBufferSize,
+                dwDataOffset = 0, dwDataOffsetWrapped = 0;
+        DWORD dwTotalMoveSize = dwMoveSize;
+
+
+
+        while (1)
+        {
+            DWORD   dwMsgSize = ((PASYNCEVENTMSG)
+                        (ptClient->pDataOut + dwDataOffset))->dwTotalSize;
+
+//DBGOUT((1, " L evntbuf:x%lx  DataOff=x%lx  DataOffWrap=x%lx  msgsize=x%lx  bytesleft=x%lx  movesiz=x%lx",
+//                  ptClient->pEventBuffer,
+//                  dwDataOffset,
+//                  dwDataOffsetWrapped,
+//                  dwMsgSize,
+//                  dwBytesLeftInClientBuffer,
+//                  dwMoveSize ));
+
+            if (dwMsgSize > dwBytesLeftInClientBuffer)
+            {
+                if ((pParams->dwUsedBufferSize = dwDataOffset) != 0)
+                {
+                    ptClient->dwEventBufferUsedSize -= dwDataOffset;
+
+                    ptClient->pDataOut += dwDataOffset;
+
+                    pParams->dwNeededBufferSize = dwDataOffset;
+                }
+                else
+                {
+//BUGBUG? Should this be out one level?  bjm 4/2/96
+                    //
+                    // Special case: the 1st msg is bigger than the entire
+                    // buffer
+                    //
+
+                    pParams->dwNeededBufferSize = dwMsgSize + 0x100;
+                }
+
+                *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                    pParams->dwUsedBufferSize;
+
+                goto GetAsyncEvents_releaseMutex;
+            }
+
+            dwBytesLeftInClientBuffer -= dwMsgSize;
+
+            if (dwMsgSize <= dwMoveSize)
+            {
+                //
+                // Msg isn't wrapped, a single copy will do
+                //
+
+                CopyMemory(
+                    pDataBuf + dwDataOffset,
+                    ptClient->pDataOut + dwDataOffset,
+                    dwMsgSize
+                    );
+
+
+                //
+                // Check to see if the msg ran to the end of the buffer,
+                // & break to the wrapped data code if so
+                //
+
+                if ((dwDataOffset += dwMsgSize) >= dwTotalMoveSize)
+                {
+                    ptClient->pDataOut = ptClient->pEventBuffer;
+                    break;
+                }
+            }
+            else
+            {
+                //
+                // This msg is wrapped.  We need to do two copies, then
+                // break out of this loop to the wrapped data code
+                //
+
+                CopyMemory(
+                    pDataBuf + dwDataOffset,
+                    ptClient->pDataOut + dwDataOffset,
+                    dwMoveSize
+                    );
+
+                dwDataOffset += dwMoveSize;
+
+                CopyMemory(
+                    pDataBuf + dwDataOffset,
+                    ptClient->pEventBuffer,
+                    dwMsgSize - dwMoveSize
+                    );
+
+                dwDataOffset += ( dwMsgSize - dwMoveSize);
+
+                ptClient->pDataOut = ptClient->pEventBuffer +
+                    (dwMsgSize - dwMoveSize);
+
+                break;
+            }
+
+            dwMoveSize -= dwMsgSize;
+        }
+
+//DBGOUT((1, " L evbufused:x%lx  pEvtBuf: x%lx  pDataOut:x%lx  pDataIn:x%lx",
+//              ptClient->dwEventBufferUsedSize,
+//              ptClient->pEventBuffer,
+//              ptClient->pDataOut,
+//              ptClient->pDataIn ));
+
+        while (1)
+        {
+            DWORD   dwMsgSize = ((PASYNCEVENTMSG) (ptClient->pDataOut +
+                        dwDataOffsetWrapped))->dwTotalSize;
+
+//ServerFree( ServerAlloc( 0x10000 ) );
+//
+//DBGOUT((1, " S evntbuf:x%lx  DataOff=x%lx  DataOffWrap=x%lx  msgsize=x%lx  bytesleft=x%lx",
+//                  ptClient->pEventBuffer,
+//                  dwDataOffset,
+//                  dwDataOffsetWrapped,
+//                  dwMsgSize,
+//                  dwBytesLeftInClientBuffer));
+
+
+            if (
+                  (dwMsgSize > dwBytesLeftInClientBuffer)
+//                ||
+//                  (dwMsgSize == 0)
+               )
+            {
+                ptClient->dwEventBufferUsedSize -=
+                    (dwDataOffset ); // + dwDataOffsetWrapped);
+
+                ptClient->pDataOut += dwDataOffsetWrapped;
+
+                pParams->dwNeededBufferSize =
+                pParams->dwUsedBufferSize   = dwDataOffset +
+                    0;  // dwDataOffsetWrapped;
+
+                *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                    pParams->dwUsedBufferSize;
+
+//DBGOUT((1, " S evbufused:x%lx  pEvtBuf: x%lx  pDataOut:x%lx  pDataIn:x%lx",
+//              ptClient->dwEventBufferUsedSize,
+//              ptClient->pEventBuffer,
+//              ptClient->pDataOut,
+//              ptClient->pDataIn ));
+
+                goto GetAsyncEvents_releaseMutex;
+            }
+
+            //
+            // Msg isn't wrapped, a single copy will do
+            //
+
+            CopyMemory(
+                pDataBuf + dwDataOffset,
+                ptClient->pDataOut + dwDataOffsetWrapped,
+                dwMsgSize
+                );
+
+            dwDataOffset += dwMsgSize;
+            dwDataOffsetWrapped += dwMsgSize;
+
+            dwBytesLeftInClientBuffer -= dwMsgSize;
+        }
+    }
+
+GetAsyncEvents_releaseMutex:
+
+    ReleaseMutex (ptClient->hEventBufferMutex);
+
+//    DBGOUT((3, "GetAsyncEvents: exit (TID=%d)", GetCurrentThreadId()));
+}
+
+
+void
+WINAPI
+GetUIDllName(
+    PGETUIDLLNAME_PARAMS    pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    LONG                lResult = 0;
+    TSPIPROC            pfnTSPI_providerUIIdentify = (TSPIPROC) NULL;
+    PTAPIDIALOGINSTANCE ptDlgInst = (PTAPIDIALOGINSTANCE) NULL;
+
+
+    switch (pParams->dwObjectType)
+    {
+    case TUISPIDLL_OBJECT_LINEID:
+    {
+        PTLINELOOKUPENTRY   pLookupEntry =
+                                GetLineLookupEntry (pParams->dwObjectID);
+
+
+        if (!pLookupEntry)
+        {
+            lResult = (TapiGlobals.dwNumLineInits == 0 ?
+                LINEERR_UNINITIALIZED : LINEERR_BADDEVICEID);
+        }
+        else if (!pLookupEntry->ptProvider || pLookupEntry->bRemoved)
+        {
+            lResult = LINEERR_NODEVICE;
+        }
+        else if (!(pfnTSPI_providerUIIdentify =
+                pLookupEntry->ptProvider->apfn[SP_PROVIDERUIIDENTIFY]))
+        {
+            lResult = LINEERR_OPERATIONUNAVAIL;
+        }
+
+        break;
+    }
+    case TUISPIDLL_OBJECT_PHONEID:
+    {
+        PTPHONELOOKUPENTRY  pLookupEntry =
+                                GetPhoneLookupEntry (pParams->dwObjectID);
+
+
+        if (!pLookupEntry)
+        {
+            lResult = (TapiGlobals.dwNumPhoneInits == 0 ?
+                PHONEERR_UNINITIALIZED : PHONEERR_BADDEVICEID);
+        }
+        else if (!pLookupEntry->ptProvider || pLookupEntry->bRemoved)
+        {
+            lResult = PHONEERR_NODEVICE;
+        }
+        else if (!(pfnTSPI_providerUIIdentify =
+                pLookupEntry->ptProvider->apfn[SP_PROVIDERUIIDENTIFY]))
+        {
+            lResult = PHONEERR_OPERATIONUNAVAIL;
+        }
+
+        break;
+    }
+    case TUISPIDLL_OBJECT_PROVIDERID:
+
+DBGOUT((1, "Looking for provider..."));
+
+        if (!(ptDlgInst = ServerAlloc (sizeof (TAPIDIALOGINSTANCE))))
+        {
+            lResult = LINEERR_NOMEM;
+            goto GetUIDllName_return;
+        }
+
+        if (pParams->dwProviderFilenameOffset == TAPI_NO_DATA)
+        {
+            //
+            // This is a providerConfig or -Remove request.  Loop thru the
+            // list of installed providers, trying to find one with a
+            // matching PPID.
+            //
+
+            int     i, iNumProviders;
+            WCHAR   szProviderXxxN[32];
+
+            HKEY  hKeyProviders;
+            DWORD dwDataSize;
+            DWORD dwDataType;
+            DWORD dwTemp;
+
+
+            if (RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    gszRegKeyProviders,
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKeyProviders
+
+                    ) != ERROR_SUCCESS)
+            {
+                DBGOUT((
+                    1,
+                    "RegOpenKeyEx(/Providers) failed, err=%d",
+                    GetLastError()
+                    ));
+
+                ServerFree (ptDlgInst);
+                lResult = LINEERR_OPERATIONFAILED;
+                goto GetUIDllName_return;
+            }
+
+            dwDataSize = sizeof(iNumProviders);
+            iNumProviders = 0;
+
+            RegQueryValueEx(
+                hKeyProviders,
+                gszNumProviders,
+                0,
+                &dwDataType,
+                (LPBYTE) &iNumProviders,
+                &dwDataSize
+                );
+
+            for (i = 0; i < iNumProviders; i++)
+            {
+                wsprintfW(szProviderXxxN, L"%ls%d", gszProviderIDW, i);
+
+                dwDataSize = sizeof(dwTemp);
+                dwTemp = 0;
+
+                RegQueryValueExW(
+                    hKeyProviders,
+                    szProviderXxxN,
+                    0,
+                    &dwDataType,
+                    (LPBYTE)&dwTemp,
+                    &dwDataSize
+                    );
+
+                if (dwTemp == pParams->dwObjectID)
+                {
+                    //
+                    // We found the provider, try to load it & get ptrs
+                    // to the relevant funcs
+                    //
+
+                    WCHAR szProviderFilename[MAX_PATH];
+
+
+                    wsprintfW(szProviderXxxN, L"%ls%d", gszProviderFilenameW, i);
+
+                    dwDataSize = MAX_PATH;
+
+                    RegQueryValueExW(
+                        hKeyProviders,
+                        szProviderXxxN,
+                        0,
+                        &dwDataType,
+                        (LPBYTE)szProviderFilename,
+                        &dwDataSize
+                        );
+
+//                    szProviderFilename[dwDataSize] = '\0';
+
+                    if (!(ptDlgInst->hTsp = LoadLibraryW(szProviderFilename)))
+                    {
+                        DBGOUT((
+                            1,
+                            "LoadLibrary('%ls') failed - err=%d",
+                            szProviderFilename,
+                            GetLastError()
+                            ));
+
+                        lResult = LINEERR_OPERATIONFAILED;
+                        goto clean_up_dlg_inst;
+                    }
+
+                    if (!(pfnTSPI_providerUIIdentify = GetProcAddress(
+                            ptDlgInst->hTsp,
+                            (LPCSTR) gaszTSPIFuncNames[SP_PROVIDERUIIDENTIFY]
+                            )))
+                    {
+                        DBGOUT((
+                            1,
+                            "GetProcAddress(TSPI_providerUIIdentify) " \
+                                "on [%ls] failed, err=%d",
+                            szProviderFilename,
+                            GetLastError()
+                            ));
+
+                        lResult = LINEERR_OPERATIONUNAVAIL;
+                        goto clean_up_dlg_inst;
+                    }
+
+                    ptDlgInst->pfnTSPI_providerGenericDialogData =
+                        GetProcAddress(
+                            ptDlgInst->hTsp,
+                            (LPCSTR) gaszTSPIFuncNames[SP_PROVIDERGENERICDIALOGDATA]
+                            );
+
+                    ptDlgInst->dwPermanentProviderID = pParams->dwObjectID;
+                    ptDlgInst->bRemoveProvider = pParams->bRemoveProvider;
+                    break;
+                }
+            }
+
+            if (i == iNumProviders)
+            {
+DBGOUT((1, "Ran out of list..."));
+                lResult = LINEERR_INVALPARAM;
+            }
+
+            RegCloseKey (hKeyProviders);
+        }
+        else
+        {
+            //
+            // This is a providerInstall request.  Try to load the provider
+            // and get ptrs to the relevant funcs,  then retrieve & increment
+            // the next provider ID value in the ini file (careful to wrap
+            // next PPID at 64K-1).
+            //
+
+            WCHAR   *pszProviderFilename;
+            DWORD   dwNameLength;
+
+            HKEY   hKeyProviders;
+            DWORD  dwDataSize;
+            DWORD  dwDataType;
+            DWORD  dwTemp;
+
+
+            pszProviderFilename = (PWSTR)(pDataBuf + pParams->dwProviderFilenameOffset);
+
+            if (!(ptDlgInst->hTsp = LoadLibraryW(pszProviderFilename)))
+            {
+                DBGOUT((
+                    1,
+                    "LoadLibrary('%ls') failed   err=%d",
+                    pszProviderFilename,
+                    GetLastError()
+                    ));
+
+                lResult = LINEERR_OPERATIONFAILED;
+                goto clean_up_dlg_inst;
+            }
+
+            if (!(pfnTSPI_providerUIIdentify = GetProcAddress(
+                    ptDlgInst->hTsp,
+                    (LPCSTR) gaszTSPIFuncNames[SP_PROVIDERUIIDENTIFY]
+                    )))
+            {
+                lResult = LINEERR_OPERATIONUNAVAIL;
+                goto clean_up_dlg_inst;
+            }
+
+            dwNameLength = (lstrlenW(pszProviderFilename) + 1) * sizeof(WCHAR);
+
+            if (!(ptDlgInst->pszProviderFilename = ServerAlloc (dwNameLength)))
+            {
+                lResult = LINEERR_NOMEM;
+                goto clean_up_dlg_inst;
+            }
+
+            CopyMemory(
+                ptDlgInst->pszProviderFilename,
+                pszProviderFilename,
+                dwNameLength
+                );
+
+            ptDlgInst->pfnTSPI_providerGenericDialogData = GetProcAddress(
+                ptDlgInst->hTsp,
+                (LPCSTR) gaszTSPIFuncNames[SP_PROVIDERGENERICDIALOGDATA]
+                );
+
+            // BUGBUG needs mutex
+
+            RegOpenKeyEx(
+                HKEY_LOCAL_MACHINE,
+                gszRegKeyProviders,
+                0,
+                KEY_ALL_ACCESS,
+                &hKeyProviders
+                );
+
+
+            dwDataSize = sizeof (DWORD);
+            ptDlgInst->dwPermanentProviderID = 1;
+
+            RegQueryValueEx(
+                hKeyProviders,
+                gszNextProviderID,
+                0,
+                &dwDataType,
+                (LPBYTE) &(ptDlgInst->dwPermanentProviderID),
+                &dwDataSize
+                );
+
+            pParams->dwObjectID = ptDlgInst->dwPermanentProviderID;
+
+//bjm 2/16            dwTemp = (ptDlgInst->dwPermanentProviderID & 0xffff0000) ?
+//bjm 2/16                1 : (ptDlgInst->dwPermanentProviderID + 1);
+            dwTemp = ((ptDlgInst->dwPermanentProviderID+1) & 0xffff0000) ?
+                1 : (ptDlgInst->dwPermanentProviderID + 1);
+
+            RegSetValueEx(
+                hKeyProviders,
+                gszNextProviderID,
+                0,
+                REG_DWORD,
+                (LPBYTE) &dwTemp,
+                sizeof(DWORD)
+                );
+
+            RegCloseKey (hKeyProviders);
+
+        }
+
+        break;
+    }
+
+
+    if (pfnTSPI_providerUIIdentify)
+    {
+        if ((lResult = CallSP1(
+                pfnTSPI_providerUIIdentify,
+                "providerUIIdentify",
+                SP_FUNC_SYNC,
+                (DWORD) pDataBuf
+
+                )) == 0)
+        {
+            pParams->dwUIDllNameOffset = 0;
+
+            pParams->dwUIDllNameSize = (lstrlenW((PWSTR)pDataBuf) + 1)*sizeof(WCHAR);
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pParams->dwUIDllNameSize;
+
+            if (ptDlgInst)
+            {
+                ptDlgInst->dwKey = TDLGINST_KEY;
+// BUGBUG mutex
+                if ((ptDlgInst->pNext =
+                        pParams->ptClient->pProviderXxxDlgInsts))
+                {
+                    ptDlgInst->pNext->pPrev = ptDlgInst;
+                }
+
+                pParams->ptClient->pProviderXxxDlgInsts = ptDlgInst;
+
+                pParams->htDlgInst = (HTAPIDIALOGINSTANCE) ptDlgInst;
+            }
+        }
+        else if (ptDlgInst)
+        {
+
+clean_up_dlg_inst:
+
+            if (ptDlgInst->hTsp)
+            {
+                FreeLibrary (ptDlgInst->hTsp);
+            }
+
+            if (ptDlgInst->pszProviderFilename)
+            {
+                ServerFree (ptDlgInst->pszProviderFilename);
+            }
+
+            ServerFree  (ptDlgInst);
+        }
+    }
+
+GetUIDllName_return:
+
+    pParams->lResult = lResult;
+
+}
+
+
+void
+WINAPI
+TUISPIDLLCallback(
+    PUIDLLCALLBACK_PARAMS   pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    LONG        lResult;
+    DWORD       dwObjectID = pParams->dwObjectID;
+    TSPIPROC    pfnTSPI_providerGenericDialogData = NULL;
+
+
+    switch (pParams->dwObjectType)
+    {
+    case TUISPIDLL_OBJECT_LINEID:
+    {
+        PTLINELOOKUPENTRY   pLine = GetLineLookupEntry (pParams->dwObjectID);
+
+
+        if (!pLine)
+        {
+            lResult = LINEERR_INVALPARAM;
+        }
+        else if (!pLine->ptProvider)
+        {
+            lResult = LINEERR_OPERATIONFAILED;
+        }
+        else
+        {
+            pfnTSPI_providerGenericDialogData =
+                pLine->ptProvider->apfn[SP_PROVIDERGENERICDIALOGDATA];
+        }
+
+        break;
+    }
+    case TUISPIDLL_OBJECT_PHONEID:
+    {
+        PTPHONELOOKUPENTRY  pPhone = GetPhoneLookupEntry (pParams->dwObjectID);
+
+
+        if (!pPhone)
+        {
+            lResult = LINEERR_INVALPARAM;
+        }
+        else if (!pPhone->ptProvider)
+        {
+            lResult = LINEERR_OPERATIONFAILED;
+        }
+        else
+        {
+            pfnTSPI_providerGenericDialogData =
+                pPhone->ptProvider->apfn[SP_PROVIDERGENERICDIALOGDATA];
+        }
+
+        break;
+    }
+    case TUISPIDLL_OBJECT_PROVIDERID:
+    {
+        PTAPIDIALOGINSTANCE ptDlgInst =
+                                pParams->ptClient->pProviderXxxDlgInsts;
+
+
+        while (ptDlgInst)
+        {
+            if (pParams->dwObjectID == ptDlgInst->dwPermanentProviderID)
+            {
+                pfnTSPI_providerGenericDialogData =
+                    ptDlgInst->pfnTSPI_providerGenericDialogData;
+
+                break;
+            }
+
+            ptDlgInst = ptDlgInst->pNext;
+        }
+
+        break;
+    }
+    case TUISPIDLL_OBJECT_DIALOGINSTANCE:
+
+        try
+        {
+            dwObjectID = (DWORD)
+                ((PTAPIDIALOGINSTANCE)pParams->dwObjectID)->hdDlgInst;
+
+            pfnTSPI_providerGenericDialogData =
+                ((PTAPIDIALOGINSTANCE) pParams->dwObjectID)->
+                    ptProvider->apfn[SP_PROVIDERGENERICDIALOGDATA];
+        }
+        myexcept
+        {
+            // just fall thru
+        }
+
+        break;
+
+    }
+
+    if (pfnTSPI_providerGenericDialogData)
+    {
+        if ((lResult = CallSP4(
+                pfnTSPI_providerGenericDialogData,
+                "providerGenericDialogData",
+                SP_FUNC_SYNC,
+                (DWORD) dwObjectID,
+                (DWORD) pParams->dwObjectType,
+                (DWORD) pDataBuf + pParams->dwParamsInOffset,
+                (DWORD) pParams->dwParamsInSize
+
+                )) == 0)
+        {
+            pParams->dwParamsOutOffset = 0;
+            pParams->dwParamsOutSize   = pParams->dwParamsInSize;
+
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pParams->dwParamsOutSize;
+        }
+    }
+    else
+    {
+        lResult = LINEERR_OPERATIONFAILED;
+    }
+
+    pParams->lResult = lResult;
+}
+
+
+void
+WINAPI
+FreeDialogInstance(
+    PFREEDIALOGINSTANCE_PARAMS  pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    HKEY  hKeyProviders;
+    DWORD dwDataSize;
+    DWORD dwDataType;
+    DWORD dwTemp;
+
+
+    PTCLIENT            ptClient = pParams->ptClient;
+    PTAPIDIALOGINSTANCE ptDlgInst = (PTAPIDIALOGINSTANCE) pParams->htDlgInst;
+
+
+    DBGOUT((3, "FreeDialogInstance: enter, pDlgInst=x%x", ptDlgInst));
+
+// BUGBUG FreeDialogInstance: needs mutex on tClient access
+
+    try
+    {
+        if (IsBadPtrKey (ptDlgInst, TDLGINST_KEY))
+        {
+            pParams->lResult = LINEERR_OPERATIONFAILED;
+        }
+        else
+        {
+            ptDlgInst->dwKey = INVAL_KEY;
+        }
+    }
+    myexcept
+    {
+        pParams->lResult = LINEERR_OPERATIONFAILED;
+    }
+
+    if (pParams->lResult)
+    {
+        return;
+    }
+
+    if (ptDlgInst->hTsp)
+    {
+        //
+        // This dlg inst was a client doing a providerConfig, -Install, or
+        // -Remove
+        //
+
+        if (ptDlgInst->pszProviderFilename)
+        {
+            if (pParams->lUIDllResult == 0)
+            {
+                //
+                // Successful provider install
+                //
+
+                DWORD   iNumProviders;
+                WCHAR   szProviderXxxN[32];
+                CHAR    szProviderXxxNA[32];
+
+                // BUGBUG mutex
+
+                RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    gszRegKeyProviders,
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKeyProviders
+                    );
+
+                dwDataSize = sizeof(iNumProviders);
+                iNumProviders = 0;
+
+                RegQueryValueEx(
+                    hKeyProviders,
+                    gszNumProviders,
+                    0,
+                    &dwDataType,
+                    (LPBYTE) &iNumProviders,
+                    &dwDataSize
+                    );
+
+                wsprintf(
+                    szProviderXxxNA,
+                    "%ls%d",
+                    gszProviderIDW,
+                    iNumProviders
+                    );
+
+                RegSetValueEx(
+                    hKeyProviders,
+                    szProviderXxxNA,
+                    0,
+                    REG_DWORD,
+                    (LPBYTE) &ptDlgInst->dwPermanentProviderID,
+                    sizeof(DWORD)
+                    );
+
+                wsprintfW(
+                    szProviderXxxN,
+                    L"%ls%d",
+                    gszProviderFilenameW,
+                    iNumProviders
+                    );
+
+                RegSetValueExW(
+                    hKeyProviders,
+                    szProviderXxxN,
+                    0,
+                    REG_SZ,
+                    (LPBYTE) ptDlgInst->pszProviderFilename,
+                    (lstrlenW((PWSTR)ptDlgInst->pszProviderFilename) + 1)*sizeof(WCHAR)
+                    );
+
+                iNumProviders++;
+
+                RegSetValueEx(
+                    hKeyProviders,
+                    gszNumProviders,
+                    0,
+                    REG_DWORD,
+                    (LPBYTE) &iNumProviders,
+                    sizeof(DWORD)
+                    );
+
+                RegCloseKey( hKeyProviders );
+
+                // BUGBUG if tapisrv is init'd then load the provider, &
+                //        send CREATE msgs for all it's devices
+            }
+            else
+            {
+                //
+                // Unsuccessful provider install.  See if we can decrement
+                // NextProviderID to free up the unused ID.
+                //
+
+                DWORD   iNextProviderID;
+
+
+                // BUGBUG mutex
+
+                RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    gszRegKeyProviders,
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKeyProviders
+                    );
+
+                dwDataSize = sizeof(iNextProviderID);
+                iNextProviderID = 0;
+
+                RegQueryValueEx(
+                    hKeyProviders,
+                    gszNextProviderID,
+                    0,
+                    &dwDataType,
+                    (LPBYTE)&iNextProviderID,
+                    &dwDataSize
+                    );
+
+                if ((ptDlgInst->dwPermanentProviderID + 1) == iNextProviderID)
+                {
+                    RegSetValueEx(
+                        hKeyProviders,
+                        gszNextProviderID,
+                        0,
+                        REG_DWORD,
+                        (LPBYTE) &(ptDlgInst->dwPermanentProviderID),
+                        sizeof(DWORD)
+                        );
+                }
+
+
+                RegCloseKey (hKeyProviders);
+            }
+
+            ServerFree (ptDlgInst->pszProviderFilename);
+        }
+        else if (ptDlgInst->bRemoveProvider)
+        {
+            if (pParams->lUIDllResult == 0)
+            {
+                //
+                // Successful provider remove.  Find the index of the
+                // provider in the list, then move all the providers
+                // that follow up a notch.
+                //
+
+                DWORD  iNumProviders, i;
+                WCHAR  *buf, szProviderXxxN[32];
+
+
+                // BUGBUG mutex
+
+                RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    gszRegKeyProviders,
+                    0,
+                    KEY_ALL_ACCESS,
+                    &hKeyProviders
+                    );
+
+
+                dwDataSize = sizeof(iNumProviders);
+                iNumProviders = 0;
+
+                RegQueryValueEx(
+                    hKeyProviders,
+                    gszNumProviders,
+                    0,
+                    &dwDataType,
+                    (LPBYTE) &iNumProviders,
+                    &dwDataSize
+                    );
+
+                for (i = 0; i < iNumProviders; i++)
+                {
+                    wsprintfW (szProviderXxxN, L"%ls%d", gszProviderIDW, i);
+
+                    dwDataSize = sizeof(dwTemp);
+                    dwTemp = 0;
+                    RegQueryValueExW(
+                        hKeyProviders,
+                        szProviderXxxN,
+                        0,
+                        &dwDataType,
+                        (LPBYTE) &dwTemp,
+                        &dwDataSize
+                        );
+
+                    if (dwTemp == ptDlgInst->dwPermanentProviderID)
+                    {
+                        break;
+                    }
+                }
+
+                buf = ServerAlloc (MAX_PATH);
+
+                for (; i < (iNumProviders - 1); i++)
+                {
+                    wsprintfW (szProviderXxxN, L"%ls%d", gszProviderIDW, i + 1);
+
+                    dwDataSize = MAX_PATH;
+
+                    RegQueryValueExW(
+                        hKeyProviders,
+                        szProviderXxxN,
+                        0,
+                        &dwDataType,
+                        (LPBYTE) buf,
+                        &dwDataSize
+                        );
+
+                    buf[dwDataSize] = '\0';
+
+                    wsprintfW (szProviderXxxN, L"%ls%d", gszProviderIDW, i);
+
+                    RegSetValueExW(
+                        hKeyProviders,
+                        szProviderXxxN,
+                        0,
+                        REG_DWORD,
+                        (LPBYTE) buf,
+                        sizeof (DWORD)
+                        );
+
+                    wsprintfW (szProviderXxxN, L"%ls%d", gszProviderFilenameW,i+1);
+
+                    dwDataSize = MAX_PATH;
+
+                    RegQueryValueExW(
+                        hKeyProviders,
+                        szProviderXxxN,
+                        0,
+                        &dwDataType,
+                        (LPBYTE) buf,
+                        &dwDataSize
+                        );
+
+                    buf[dwDataSize] = '\0';
+
+                    wsprintfW (szProviderXxxN, L"%ls%d", gszProviderFilenameW, i);
+
+                    RegSetValueExW(
+                        hKeyProviders,
+                        szProviderXxxN,
+                        0,
+                        REG_SZ,
+                        (LPBYTE) buf,
+                        (lstrlenW(buf) + 1) * sizeof(WCHAR)
+                        );
+                }
+
+
+                //
+                // Remove the last ProviderID# & ProviderFilename# entries
+                //
+
+                wsprintfW (szProviderXxxN, L"%ls%d", gszProviderIDW, i);
+
+                RegDeleteValueW (hKeyProviders, szProviderXxxN);
+
+                wsprintfW (szProviderXxxN, L"%ls%d", gszProviderFilenameW, i);
+
+                RegDeleteValueW (hKeyProviders, szProviderXxxN);
+
+
+                //
+                // Decrement the total num providers to load
+                //
+
+                iNumProviders--;
+
+                RegSetValueEx(
+                    hKeyProviders,
+                    gszNumProviders,
+                    0,
+                    REG_DWORD,
+                    (LPBYTE)&iNumProviders,
+                    sizeof(DWORD)
+                    );
+
+                // BUGBUG providerRemove- if tapi init'd shutdown provider
+            }
+            else
+            {
+                //
+                // Unsuccessful provider remove, nothing to do
+                //
+            }
+        }
+        else
+        {
+            //
+            // Nothing to do for providerConfig (success or fail)
+            //
+        }
+
+        FreeLibrary (ptDlgInst->hTsp);
+
+        pParams->lResult = pParams->lUIDllResult;
+    }
+    else
+    {
+        //
+        // The was a provider-initiated dlg inst, so tell
+        // the provider to free it's inst
+        //
+
+        CallSP1(
+            ptDlgInst->ptProvider->apfn[SP_PROVIDERFREEDIALOGINSTANCE],
+            "providerFreeDialogInstance",
+            SP_FUNC_SYNC,
+            (DWORD) ptDlgInst->hdDlgInst
+            );
+
+    }
+
+
+    //
+    // Remove the dialog instance from the tClient's list & then free it
+    //
+
+    if (ptDlgInst->pNext)
+    {
+        ptDlgInst->pNext->pPrev = ptDlgInst->pPrev;
+    }
+
+    if (ptDlgInst->pPrev)
+    {
+        ptDlgInst->pPrev->pNext = ptDlgInst->pNext;
+    }
+    else if (ptDlgInst->hTsp)
+    {
+        pParams->ptClient->pProviderXxxDlgInsts = ptDlgInst->pNext;
+    }
+    else
+    {
+        pParams->ptClient->pGenericDlgInsts = ptDlgInst->pNext;
+    }
+
+    ServerFree (ptDlgInst);
+}
+
+#pragma warning (default:4028)
+
+
+
+#if DBG
+
+char szBeforeSync[] = "Calling TSPI_%s";
+char szBeforeAsync[] = "Calling TSPI_%s, dwReqID=x%x";
+char szAfter[]  = "TSPI_%s result=%s";
+
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[1024] = "TAPISRV: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf(
+            &buf[9],
+            lpszFormat,
+            ap
+            );
+
+        lstrcat(buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+
+
+char *aszLineErrors[] =
+{
+    NULL,
+    "ALLOCATED",
+    "BADDEVICEID",
+    "BEARERMODEUNAVAIL",
+    "inval err value (0x80000004)",      // 0x80000004 isn't valid err code
+    "CALLUNAVAIL",
+    "COMPLETIONOVERRUN",
+    "CONFERENCEFULL",
+    "DIALBILLING",
+    "DIALDIALTONE",
+    "DIALPROMPT",
+    "DIALQUIET",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALADDRESS",                     // 0x80000010
+    "INVALADDRESSID",
+    "INVALADDRESSMODE",
+    "INVALADDRESSSTATE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBEARERMODE",
+    "INVALCALLCOMPLMODE",
+    "INVALCALLHANDLE",
+    "INVALCALLPARAMS",
+    "INVALCALLPRIVILEGE",
+    "INVALCALLSELECT",
+    "INVALCALLSTATE",
+    "INVALCALLSTATELIST",
+    "INVALCARD",
+    "INVALCOMPLETIONID",
+    "INVALCONFCALLHANDLE",              // 0x80000020
+    "INVALCONSULTCALLHANDLE",
+    "INVALCOUNTRYCODE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEHANDLE",
+    "INVALDIALPARAMS",
+    "INVALDIGITLIST",
+    "INVALDIGITMODE",
+    "INVALDIGITS",
+    "INVALEXTVERSION",
+    "INVALGROUPID",
+    "INVALLINEHANDLE",
+    "INVALLINESTATE",
+    "INVALLOCATION",
+    "INVALMEDIALIST",
+    "INVALMEDIAMODE",
+    "INVALMESSAGEID",                   // 0x80000030
+    "inval err value (0x80000031)",      // 0x80000031 isn't valid err code
+    "INVALPARAM",
+    "INVALPARKID",
+    "INVALPARKMODE",
+    "INVALPOINTER",
+    "INVALPRIVSELECT",
+    "INVALRATE",
+    "INVALREQUESTMODE",
+    "INVALTERMINALID",
+    "INVALTERMINALMODE",
+    "INVALTIMEOUT",
+    "INVALTONE",
+    "INVALTONELIST",
+    "INVALTONEMODE",
+    "INVALTRANSFERMODE",
+    "LINEMAPPERFAILED",                 // 0x80000040
+    "NOCONFERENCE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOREQUEST",
+    "NOTOWNER",
+    "NOTREGISTERED",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "RATEUNAVAIL",
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",
+    "STRUCTURETOOSMALL",
+    "TARGETNOTFOUND",
+    "TARGETSELF",
+    "UNINITIALIZED",                    // 0x80000050
+    "USERUSERINFOTOOBIG",
+    "REINIT",
+    "ADDRESSBLOCKED",
+    "BILLINGREJECTED",
+    "INVALFEATURE",
+    "NOMULTIPLEINSTANCE",
+    "INVALAGENTID",
+    "INVALAGENTGROUP",
+    "INVALPASSWORD",
+    "INVALAGENTSTATE",
+    "INVALAGENTACTIVITY",
+    "DIALVOICEDETECT"
+};
+
+char *aszPhoneErrors[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBUTTONLAMPID",
+    "INVALBUTTONMODE",
+    "INVALBUTTONSTATE",
+    "INVALDATAID",
+    "INVALDEVICECLASS",
+    "INVALEXTVERSION",
+    "INVALHOOKSWITCHDEV",
+    "INVALHOOKSWITCHMODE",              // 0x90000010
+    "INVALLAMPMODE",
+    "INVALPARAM",
+    "INVALPHONEHANDLE",
+    "INVALPHONESTATE",
+    "INVALPOINTER",
+    "INVALPRIVILEGE",
+    "INVALRINGMODE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOTOWNER",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "inval err value (0x9000001e)",      // 0x9000001e isn't valid err code
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",                   // 0x90000020
+    "STRUCTURETOOSMALL",
+    "UNINITIALIZED",
+    "REINIT"
+};
+
+char *aszTapiErrors[] =
+{
+    "SUCCESS",
+    "DROPPED",
+    "NOREQUESTRECIPIENT",
+    "REQUESTQUEUEFULL",
+    "INVALDESTADDRESS",
+    "INVALWINDOWHANDLE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEID",
+    "DEVICECLASSUNAVAIL",
+    "DEVICEIDUNAVAIL",
+    "DEVICEINUSE",
+    "DESTBUSY",
+    "DESTNOANSWER",
+    "DESTUNAVAIL",
+    "UNKNOWNWINHANDLE",
+    "UNKNOWNREQUESTID",
+    "REQUESTFAILED",
+    "REQUESTCANCELLED",
+    "INVALPOINTER"
+};
+
+
+char *
+PASCAL
+MapResultCodeToText(
+    LONG    lResult,
+    char   *pszResult
+    )
+{
+    if (lResult == 0)
+    {
+        wsprintf (pszResult, "SUCCESS");
+    }
+    else if (lResult > 0)
+    {
+        wsprintf (pszResult, "x%x (completing async)", lResult);
+    }
+    else if (((DWORD) lResult) <= LINEERR_DIALVOICEDETECT)
+    {
+        lResult &= 0x0fffffff;
+
+        wsprintf (pszResult, "LINEERR_%s", aszLineErrors[lResult]);
+    }
+    else if (((DWORD) lResult) <= PHONEERR_REINIT)
+    {
+        if (((DWORD) lResult) >= PHONEERR_ALLOCATED)
+        {
+            lResult &= 0x0fffffff;
+
+            wsprintf (pszResult, "PHONEERR_%s", aszPhoneErrors[lResult]);
+        }
+        else
+        {
+            goto MapResultCodeToText_badErrorCode;
+        }
+    }
+    else if (((DWORD) lResult) <= ((DWORD) TAPIERR_DROPPED) &&
+             ((DWORD) lResult) >= ((DWORD) TAPIERR_INVALPOINTER))
+    {
+        lResult = ~lResult + 1;
+
+        wsprintf (pszResult, "TAPIERR_%s", aszTapiErrors[lResult]);
+    }
+    else
+    {
+
+MapResultCodeToText_badErrorCode:
+
+        wsprintf (pszResult, "inval error value (x%x)");
+    }
+
+    return pszResult;
+}
+
+VOID
+PASCAL
+ValidateSyncSPResult(
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    LONG        lResult
+    )
+{
+    char szResult[32];
+
+    DBGOUT((
+        3,
+        szAfter,
+        lpszFuncName,
+        MapResultCodeToText (lResult, szResult)
+        ));
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        assert (lResult != 0);
+
+        if (lResult > 0)
+        {
+            assert ((DWORD) lResult == dwArg1);
+        }
+    }
+    else
+    {
+        assert (lResult <= 0);
+    }
+}
+
+
+LONG
+WINAPI
+CallSP1(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1
+    )
+{
+    LONG    lResult;
+
+
+    DBGOUT((3, szBeforeSync, lpszFuncName));
+
+    lResult = (*pfn)(dwArg1);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP2(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(dwArg1, dwArg2);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP3(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(dwArg1, dwArg2, dwArg3);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP4(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(dwArg1, dwArg2, dwArg3, dwArg4);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP5(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(dwArg1, dwArg2, dwArg3, dwArg4, dwArg5);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP6(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(dwArg1, dwArg2, dwArg3, dwArg4, dwArg5, dwArg6);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP7(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(dwArg1, dwArg2, dwArg3, dwArg4, dwArg5, dwArg6, dwArg7);
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP8(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7,
+    DWORD       dwArg8
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(
+        dwArg1,
+        dwArg2,
+        dwArg3,
+        dwArg4,
+        dwArg5,
+        dwArg6,
+        dwArg7,
+        dwArg8
+        );
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP9(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7,
+    DWORD       dwArg8,
+    DWORD       dwArg9
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(
+        dwArg1,
+        dwArg2,
+        dwArg3,
+        dwArg4,
+        dwArg5,
+        dwArg6,
+        dwArg7,
+        dwArg8,
+        dwArg9
+        );
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+CallSP12(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7,
+    DWORD       dwArg8,
+    DWORD       dwArg9,
+    DWORD       dwArg10,
+    DWORD       dwArg11,
+    DWORD       dwArg12
+    )
+{
+    LONG    lResult;
+
+
+    if (dwFlags & SP_FUNC_ASYNC)
+    {
+        DBGOUT((3, szBeforeAsync, lpszFuncName, dwArg1));
+    }
+    else
+    {
+        DBGOUT((3, szBeforeSync, lpszFuncName));
+    }
+
+    lResult = (*pfn)(
+        dwArg1,
+        dwArg2,
+        dwArg3,
+        dwArg4,
+        dwArg5,
+        dwArg6,
+        dwArg7,
+        dwArg8,
+        dwArg9,
+        dwArg10,
+        dwArg11,
+        dwArg12
+        );
+
+    ValidateSyncSPResult (lpszFuncName, dwFlags, dwArg1, lResult);
+
+    return lResult;
+}
+
+#endif // DBG
+
+/*************************************************************************\
+* BOOL InitPerf()
+*
+*   Initialize global performance data
+*
+\**************************************************************************/
+
+BOOL InitPerf()
+{
+    FillMemory(&PerfBlock,
+               sizeof(PerfBlock),
+               0);
+
+    return(TRUE);
+}
diff --git a/private/tapi/dev/server/server.h b/private/tapi/dev/server/server.h
new file mode 100644
index 000000000..e7e494c1e
--- /dev/null
+++ b/private/tapi/dev/server/server.h
@@ -0,0 +1,1072 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    server.h
+
+Abstract:
+
+    Header file for tapi server & client
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#include "rmotsp.h"
+
+
+#define INVAL_KEY                   ((DWORD) 'LVNI')
+#define TCALL_KEY                   ((DWORD) 'LLAC')
+#define TINCOMPLETECALL_KEY         ((DWORD) 'LACI')
+#define TZOMBIECALL_KEY             ((DWORD) 'LACZ')
+#define TCALLCLIENT_KEY             ((DWORD) 'ILCC')
+#define TINCOMPLETECALLCLIENT_KEY   ((DWORD) 'LCCI')
+#define TLINE_KEY                   ((DWORD) 'ENIL')
+#define TLINECLIENT_KEY             ((DWORD) 'ILCL')
+#define TPHONE_KEY                  ((DWORD) 'NOHP')
+#define TPHONECLIENT_KEY            ((DWORD) 'ILCP')
+#define TLINEAPP_KEY                ((DWORD) 'PPAL')
+#define TPHONEAPP_KEY               ((DWORD) 'PPAP')
+#define TCLIENT_KEY                 ((DWORD) 'TNLC')
+#define TPROVIDER_KEY               ((DWORD) 'VORP')
+#define TASYNC_KEY                  ((DWORD) 'CYSA')
+#define TDLGINST_KEY                ((DWORD) 'GOLD')
+#define TCONFLIST_KEY               ((DWORD) 'FNOC')
+
+#define INITIAL_EVENT_BUFFER_SIZE   1024
+
+#define DEF_NUM_LOOKUP_ENTRIES      16
+#define DEF_NUM_CONF_LIST_ENTRIES   4
+#define DEF_NUM_PTR_LIST_ENTRIES    8
+
+#define BOGUS_REQUEST_ID            0x7fffffff
+
+#define DCF_SPIRETURNED             0x00000001
+#define DCF_DRVCALLVALID            0x00000002
+#define DCF_CREATEDINITIALMONITORS  0x00000004
+#define DCF_INCOMINGCALL            0x00010000
+
+#define SYNC_REQUESTS_ALL           0
+#define SYNC_REQUESTS_PER_WIDGET    1
+#define SYNC_REQUESTS_NONE          2
+
+#define SP_NONE                     0xffffffff
+
+#define SP_LINEACCEPT                       0
+#define SP_LINEADDTOCONFERENCE              1
+#define SP_LINEAGENTSPECIFIC                2
+#define SP_LINEANSWER                       3
+#define SP_LINEBLINDTRANSFER                4
+#define SP_LINECLOSE                        5
+#define SP_LINECLOSECALL                    6
+#define SP_LINECOMPLETECALL                 7
+#define SP_LINECOMPLETETRANSFER             8
+#define SP_LINECONDITIONALMEDIADETECTION    9
+#define SP_LINEDEVSPECIFIC                  10
+#define SP_LINEDEVSPECIFICFEATURE           11
+#define SP_LINEDIAL                         12
+#define SP_LINEDROP                         13
+#define SP_LINEFORWARD                      14
+#define SP_LINEGATHERDIGITS                 15
+#define SP_LINEGENERATEDIGITS               16
+#define SP_LINEGENERATETONE                 17
+#define SP_LINEGETADDRESSCAPS               18
+#define SP_LINEGETADDRESSID                 19
+#define SP_LINEGETADDRESSSTATUS             20
+#define SP_LINEGETAGENTACTIVITYLIST         21
+#define SP_LINEGETAGENTCAPS                 22
+#define SP_LINEGETAGENTGROUPLIST            23
+#define SP_LINEGETAGENTSTATUS               24
+#define SP_LINEGETCALLADDRESSID             25
+#define SP_LINEGETCALLINFO                  26
+#define SP_LINEGETCALLSTATUS                27
+#define SP_LINEGETDEVCAPS                   28
+#define SP_LINEGETDEVCONFIG                 29
+#define SP_LINEGETEXTENSIONID               30
+#define SP_LINEGETICON                      31
+#define SP_LINEGETID                        32
+#define SP_LINEGETLINEDEVSTATUS             33
+#define SP_LINEGETNUMADDRESSIDS             34
+#define SP_LINEHOLD                         35
+#define SP_LINEMAKECALL                     36
+#define SP_LINEMONITORDIGITS                37
+#define SP_LINEMONITORMEDIA                 38
+#define SP_LINEMONITORTONES                 39
+#define SP_LINENEGOTIATEEXTVERSION          40
+#define SP_LINENEGOTIATETSPIVERSION         41
+#define SP_LINEOPEN                         42
+#define SP_LINEPARK                         43
+#define SP_LINEPICKUP                       44
+#define SP_LINEPREPAREADDTOCONFERENCE       45
+#define SP_LINEREDIRECT                     46
+#define SP_LINERELEASEUSERUSERINFO          47
+#define SP_LINEREMOVEFROMCONFERENCE         48
+#define SP_LINESECURECALL                   49
+#define SP_LINESELECTEXTVERSION             50
+#define SP_LINESENDUSERUSERINFO             51
+#define SP_LINESETAGENTACTIVITY             52
+#define SP_LINESETAGENTGROUP                53
+#define SP_LINESETAGENTSTATE                54
+#define SP_LINESETAPPSPECIFIC               55
+#define SP_LINESETCALLDATA                  56
+#define SP_LINESETCALLPARAMS                57
+#define SP_LINESETCALLQUALITYOFSERVICE      58
+#define SP_LINESETCALLTREATMENT             59
+#define SP_LINESETCURRENTLOCATION           60
+#define SP_LINESETDEFAULTMEDIADETECTION     61
+#define SP_LINESETDEVCONFIG                 62
+#define SP_LINESETLINEDEVSTATUS             63
+#define SP_LINESETMEDIACONTROL              64
+#define SP_LINESETMEDIAMODE                 65
+#define SP_LINESETSTATUSMESSAGES            66
+#define SP_LINESETTERMINAL                  67
+#define SP_LINESETUPCONFERENCE              68
+#define SP_LINESETUPTRANSFER                69
+#define SP_LINESWAPHOLD                     70
+#define SP_LINEUNCOMPLETECALL               71
+#define SP_LINEUNHOLD                       72
+#define SP_LINEUNPARK                       73
+#define SP_PHONECLOSE                       74
+#define SP_PHONEDEVSPECIFIC                 75
+#define SP_PHONEGETBUTTONINFO               76
+#define SP_PHONEGETDATA                     77
+#define SP_PHONEGETDEVCAPS                  78
+#define SP_PHONEGETDISPLAY                  79
+#define SP_PHONEGETEXTENSIONID              80
+#define SP_PHONEGETGAIN                     81
+#define SP_PHONEGETHOOKSWITCH               82
+#define SP_PHONEGETICON                     83
+#define SP_PHONEGETID                       84
+#define SP_PHONEGETLAMP                     85
+#define SP_PHONEGETRING                     86
+#define SP_PHONEGETSTATUS                   87
+#define SP_PHONEGETVOLUME                   88
+#define SP_PHONENEGOTIATEEXTVERSION         89
+#define SP_PHONENEGOTIATETSPIVERSION        90
+#define SP_PHONEOPEN                        91
+#define SP_PHONESELECTEXTVERSION            92
+#define SP_PHONESETBUTTONINFO               93
+#define SP_PHONESETDATA                     94
+#define SP_PHONESETDISPLAY                  95
+#define SP_PHONESETGAIN                     96
+#define SP_PHONESETHOOKSWITCH               97
+#define SP_PHONESETLAMP                     98
+#define SP_PHONESETRING                     99
+#define SP_PHONESETSTATUSMESSAGES           100
+#define SP_PHONESETVOLUME                   101
+#define SP_PROVIDERCREATELINEDEVICE         102
+#define SP_PROVIDERCREATEPHONEDEVICE        103
+#define SP_PROVIDERENUMDEVICES              104
+#define SP_PROVIDERFREEDIALOGINSTANCE       105
+#define SP_PROVIDERGENERICDIALOGDATA        106
+#define SP_PROVIDERINIT                     107
+#define SP_PROVIDERSHUTDOWN                 108
+#define SP_PROVIDERUIIDENTIFY               109
+#define SP_LASTPROCNUMBER                   (SP_PROVIDERUIIDENTIFY + 1)
+
+#define myexcept except(EXCEPTION_EXECUTE_HANDLER)
+
+#define IsBadPtrKey(p,key)  (((DWORD) p & 0x7) || (*((LPDWORD) p) != key) ? \
+                                TRUE : FALSE)
+
+
+typedef LONG (PASCAL *TSPIPROC)();
+
+typedef struct _TPOINTERLIST
+{
+    DWORD                   dwNumUsedEntries;
+
+    LPVOID                  aEntries[DEF_NUM_PTR_LIST_ENTRIES];
+
+} TPOINTERLIST, *PTPOINTERLIST;
+
+typedef struct _TPROVIDER
+{
+    DWORD                   dwKey;
+    HANDLE                  hMutex;
+    HINSTANCE               hDll;
+    DWORD                   dwTSPIOptions;
+
+    DWORD                   dwSPIVersion;
+    DWORD                   dwPermanentProviderID;
+    struct _TPROVIDER      *pPrev;
+    struct _TPROVIDER      *pNext;
+
+    TSPIPROC                apfn[SP_LASTPROCNUMBER];
+
+    WCHAR                   szFileName[1];
+
+} TPROVIDER, *PTPROVIDER;
+
+
+typedef struct _TCALL
+{
+    DWORD                   dwKey;
+    HANDLE                  hMutex;
+    LPVOID                  ptCallClients;
+    LPVOID                  ptLine;
+
+    PTPROVIDER              ptProvider;
+    DWORD                   dwDrvCallFlags;
+    BOOL                    bCreatedInitialMonitors;
+    HDRVCALL                hdCall;
+
+    DWORD                   dwCallInstance;
+    DWORD                   dwAddressID;
+    DWORD                   dwCallState;
+    DWORD                   dwCallStateMode;
+
+    DWORD                   dwNumOwners;
+    DWORD                   dwNumMonitors;
+    BOOL                    bAlertApps;
+    DWORD                   dwAppNameSize;
+
+    LPVOID                  pszAppName;
+    DWORD                   dwDisplayableAddressSize;
+    LPVOID                  pszDisplayableAddress;
+    DWORD                   dwCalledPartySize;
+
+    LPVOID                  pszCalledParty;
+    DWORD                   dwCommentSize;
+    LPVOID                  pszComment;
+    LPVOID                  pConfList;
+
+    struct _TCALL          *pPrev;
+    struct _TCALL          *pNext;
+
+} TCALL, *PTCALL;
+
+
+typedef struct _TCALLCLIENT
+{
+    DWORD                   dwKey;
+    LPVOID                  ptClient;
+    LPVOID                  ptLineClient;
+    PTCALL                  ptCall;
+
+    HANDLE                  hRemoteCall;
+    DWORD                   dwPrivilege;
+    DWORD                   dwMonitorDigitModes;
+    DWORD                   dwMonitorMediaModes;
+
+
+    //
+    // The following field is used to determine whether we need to
+    // set or zero the LINE_CALLSTATE\dwParam3 parameter to indicate
+    // a privilege change to the app
+    //
+
+    BOOL                    bIndicatePrivilege;
+    struct _TCALLCLIENT    *pPrevSametCall;
+    struct _TCALLCLIENT    *pNextSametCall;
+    struct _TCALLCLIENT    *pPrevSametLineClient;
+
+    struct _TCALLCLIENT    *pNextSametLineClient;
+
+} TCALLCLIENT, *PTCALLCLIENT;
+
+
+typedef struct _TCONFERENCELIST
+{
+    DWORD                   dwKey;
+    DWORD                   dwNumTotalEntries;
+    DWORD                   dwNumUsedEntries;
+    struct _TCONFERENCELIST *pNext;
+
+    PTCALL                  aptCalls[1];
+
+} TCONFERENCELIST, *PTCONFERENCELIST;
+
+
+typedef struct _TLINE
+{
+    DWORD                   dwKey;
+    HANDLE                  hMutex;
+    LPVOID                  ptLineClients;
+    LPVOID                  apProxys[9];
+
+    PTPROVIDER              ptProvider;
+    HDRVLINE                hdLine;
+    DWORD                   dwDeviceID;
+    DWORD                   dwSPIVersion;
+
+    DWORD                   dwExtVersion;
+    DWORD                   dwExtVersionCount;
+    DWORD                   dwNumAddresses;
+    DWORD                   dwOpenMediaModes;
+
+    DWORD                   dwNumOpens;
+    DWORD                   dwUnionLineStates;
+    DWORD                   dwUnionAddressStates;
+    PTCALL                  ptCalls;
+
+} TLINE, *PTLINE;
+
+
+typedef struct _TLINECLIENT
+{
+    DWORD                   dwKey;
+    LPVOID                  ptClient;
+    HANDLE                  hMutex;
+    LPVOID                  ptLineApp;
+
+    PTLINE                  ptLine;
+    DWORD                   dwAddressID;
+    PTCALLCLIENT            ptCallClients;
+    DWORD                   hRemoteLine;
+
+    DWORD                   dwAPIVersion;
+    DWORD                   dwPrivileges;
+    DWORD                   dwMediaModes;
+    DWORD                   dwCallbackInstance;
+
+    DWORD                   dwLineStates;
+    DWORD                   dwAddressStates;
+    LPDWORD                 aNumRings;
+    DWORD                   dwExtVersion;
+
+    LPVOID                  pPendingProxyRequests;
+    struct _TLINECLIENT    *pPrevSametLine;
+    struct _TLINECLIENT    *pNextSametLine;
+    struct _TLINECLIENT    *pPrevSametLineApp;
+
+    struct _TLINECLIENT    *pNextSametLineApp;
+
+} TLINECLIENT, *PTLINECLIENT;
+
+
+typedef struct _TPHONE
+{
+    DWORD                   dwKey;
+    HANDLE                  hMutex;
+    LPVOID                  ptPhoneClients;
+    PTPROVIDER              ptProvider;
+
+    HDRVPHONE               hdPhone;
+    DWORD                   dwDeviceID;
+    DWORD                   dwSPIVersion;
+    DWORD                   dwExtVersion;
+
+    DWORD                   dwExtVersionCount;
+    DWORD                   dwNumOwners;
+    DWORD                   dwNumMonitors;
+    DWORD                   dwUnionPhoneStates;
+
+    DWORD                   dwUnionButtonModes;
+    DWORD                   dwUnionButtonStates;
+
+} TPHONE, *PTPHONE;
+
+
+typedef struct _TPHONECLIENT
+{
+    DWORD                   dwKey;
+    LPVOID                  ptClient;
+    HANDLE                  hMutex;
+    LPVOID                  ptPhoneApp;
+
+    PTPHONE                 ptPhone;
+    DWORD                   hRemotePhone;
+    DWORD                   dwAPIVersion;
+    DWORD                   dwExtVersion;
+
+    DWORD                   dwPrivilege;
+    DWORD                   dwCallbackInstance;
+    DWORD                   dwPhoneStates;
+    DWORD                   dwButtonModes;
+
+    DWORD                   dwButtonStates;
+    struct _TPHONECLIENT   *pPrevSametPhone;
+    struct _TPHONECLIENT   *pNextSametPhone;
+    struct _TPHONECLIENT   *pPrevSametPhoneApp;
+
+    struct _TPHONECLIENT   *pNextSametPhoneApp;
+
+} TPHONECLIENT, *PTPHONECLIENT;
+
+
+typedef struct _TLINEAPP
+{
+    DWORD                   dwKey;
+    LPVOID                  ptClient;
+    HANDLE                  hMutex;
+    PTLINECLIENT            ptLineClients;
+
+    LINECALLBACK            lpfnCallback;
+    struct _TLINEAPP       *pPrev;
+    struct _TLINEAPP       *pNext;
+    DWORD                   dwAPIVersion;
+
+    DWORD                   bReqMediaCallRecipient;
+    LPVOID                  pRequestRecipient;
+    DWORD                   dwFriendlyNameSize;
+    WCHAR                  *pszFriendlyName;
+
+    DWORD                   dwModuleNameSize;
+    WCHAR                  *pszModuleName;
+
+} TLINEAPP, *PTLINEAPP;
+
+
+typedef struct _TPHONEAPP
+{
+    DWORD                   dwKey;
+    LPVOID                  ptClient;
+    HANDLE                  hMutex;
+    PTPHONECLIENT           ptPhoneClients;
+
+    PHONECALLBACK           lpfnCallback;
+    struct _TPHONEAPP      *pPrev;
+    struct _TPHONEAPP      *pNext;
+    DWORD                   dwAPIVersion;
+
+    DWORD                   dwFriendlyNameSize;
+    WCHAR                  *pszFriendlyName;
+    DWORD                   dwModuleNameSize;
+    WCHAR                  *pszModuleName;
+
+} TPHONEAPP, *PTPHONEAPP;
+
+
+typedef struct _TAPIDIALOGINSTANCE
+{
+    DWORD                   dwKey;
+    LPVOID                  ptClient;
+    DWORD                   dwPermanentProviderID;
+    HINSTANCE               hTsp;
+
+    TSPIPROC                pfnTSPI_providerGenericDialogData;
+    PTPROVIDER              ptProvider;
+    HDRVDIALOGINSTANCE      hdDlgInst;
+    WCHAR                  *pszProviderFilename;
+
+    DWORD                   bRemoveProvider;
+    struct _TAPIDIALOGINSTANCE *pPrev;
+    struct _TAPIDIALOGINSTANCE *pNext;
+
+} TAPIDIALOGINSTANCE, *PTAPIDIALOGINSTANCE;
+
+
+typedef struct _TCLIENT
+{
+    DWORD                   dwKey;
+    HANDLE                  hProcess;
+    HANDLE                  hMutex;
+    DWORD                   dwUserNameSize;
+
+    WCHAR                  *pszUserName;
+    DWORD                   dwComputerNameSize;
+    WCHAR                  *pszComputerName;
+    PCONTEXT_HANDLE_TYPE2   phContext;
+
+
+    //
+    // Async event ring buffer fields
+    //
+
+    HANDLE                  hValidEventBufferDataEvent;
+    HANDLE                  hEventBufferMutex;
+    DWORD                   dwEventBufferTotalSize;
+    DWORD                   dwEventBufferUsedSize;
+
+    LPBYTE                  pEventBuffer;
+    LPBYTE                  pDataIn;
+    LPBYTE                  pDataOut;
+
+
+    //
+    // Lists of line apps and phone apps associated with this client
+    //
+
+    PTLINEAPP               ptLineApps;
+
+    PTPHONEAPP              ptPhoneApps;
+
+
+    //
+    // Current dialog instances on this client
+    //
+
+    PTAPIDIALOGINSTANCE     pProviderXxxDlgInsts;
+    PTAPIDIALOGINSTANCE     pGenericDlgInsts;
+
+
+    //
+    // Previous & next tClient in the global list
+    //
+
+    struct _TCLIENT        *pPrev;
+
+    struct _TCLIENT        *pNext;
+
+} TCLIENT, *PTCLIENT;
+
+
+typedef struct _TREQUESTRECIPIENT
+{
+    PTLINEAPP               ptLineApp;
+    DWORD                   dwRegistrationInstance;
+    struct _TREQUESTRECIPIENT  *pPrev;
+    struct _TREQUESTRECIPIENT  *pNext;
+
+} TREQUESTRECIPIENT, *PTREQUESTRECIPIENT;
+
+typedef void (*SRVPOSTPROCESSPROC)(LPVOID, LPVOID, LPVOID);
+
+typedef struct _ASYNCREQUESTINFO
+{
+    DWORD                   dwKey;
+    LPVOID                  pNext;
+    LONG                    lResult;
+    PTCLIENT                ptClient;
+
+    SRVPOSTPROCESSPROC      pfnPostProcess;
+    BOOL                    bLineFunc;
+    DWORD                   pInitData;
+    DWORD                   dwCallbackInst;
+
+    DWORD                   pfnClientPostProcessProc;
+    DWORD                   dwRequestID;
+    DWORD                   dwParam1;
+    DWORD                   dwParam2;
+
+    DWORD                   dwParam3;
+    DWORD                   dwParam4;
+    DWORD                   dwParam5;
+
+} ASYNCREQUESTINFO, *PASYNCREQUESTINFO;
+
+#define SP_LINE_EVENT       1
+#define SP_COMPLETION_EVENT 2
+#define SP_PHONE_EVENT      3
+
+typedef struct _SPEVENT
+{
+    DWORD                   dwType;
+    struct _SPEVENT        *pNext;
+
+    union
+    {
+    HTAPILINE               htLine;
+    HTAPIPHONE              htPhone;
+    DWORD                   dwRequestID;
+    };
+
+    union
+    {
+    HTAPICALL               htCall;
+    LONG                    lResult;
+    };
+
+    DWORD                   dwMsg;
+
+    DWORD                   dwParam1;
+    DWORD                   dwParam2;
+    DWORD                   dwParam3;
+
+} SPEVENT, *PSPEVENT;
+
+
+
+//
+// The following XXXTUPLE types give us a quick easy way to retrieve
+// the ptProvider and ptXxx associated with the widget (the widget ID
+// is used as an index into a global array)
+//
+
+typedef struct _TLINELOOKUPENTRY
+{
+    DWORD                   dwSPIVersion;
+    PTLINE                  ptLine;
+    HANDLE                  hMutex;
+    PTPROVIDER              ptProvider;
+
+    DWORD                   bRemoved;
+    DWORD                   bRemote;
+
+} TLINELOOKUPENTRY, *PTLINELOOKUPENTRY;
+
+
+typedef struct _TLINELOOKUPTABLE
+{
+    DWORD                   dwNumTotalEntries;
+    DWORD                   dwNumUsedEntries;
+    struct _TLINELOOKUPTABLE   *pNext;
+    TLINELOOKUPENTRY        aEntries[1];
+
+} TLINELOOKUPTABLE, *PTLINELOOKUPTABLE;
+
+
+typedef struct _TPHONELOOKUPENTRY
+{
+    DWORD                   dwSPIVersion;
+    PTPHONE                 ptPhone;
+    HANDLE                  hMutex;
+    PTPROVIDER              ptProvider;
+
+    DWORD                   bRemoved;
+
+} TPHONELOOKUPENTRY, *PTPHONELOOKUPENTRY;
+
+
+typedef struct _TPHONELOOKUPTABLE
+{
+    DWORD                   dwNumTotalEntries;
+    DWORD                   dwNumUsedEntries;
+    struct _TPHONELOOKUPTABLE  *pNext;
+    TPHONELOOKUPENTRY       aEntries[1];
+
+} TPHONELOOKUPTABLE, *PTPHONELOOKUPTABLE;
+
+
+typedef struct _TREQUESTMAKECALL
+{
+    LINEREQMAKECALLW        LineReqMakeCall;
+    struct _TREQUESTMAKECALL   *pNext;
+
+} TREQUESTMAKECALL, *PTREQUESTMAKECALL;
+
+
+typedef struct _TAPIGLOBALS
+{
+    SERVICE_STATUS_HANDLE   sshStatusHandle;
+    HICON                   hLineIcon;
+    HICON                   hPhoneIcon;
+    DWORD                   dwNumAllocs;
+
+    DWORD                   dwNumTotalAllocs;
+    DWORD                   dwAsyncRequestID;
+    HANDLE                  hProcess;
+    BOOL                    bReinit;
+
+    HANDLE                  hMutex;
+    HANDLE                  hAsyncRequestIDMutex;
+    PTCLIENT                ptClients;
+    PTPROVIDER              ptProviders;
+
+    DWORD                   dwNumLineInits;
+    DWORD                   dwNumLines;
+    PTLINELOOKUPTABLE       pLineLookup;
+    DWORD                   dwNumPhoneInits;
+
+    DWORD                   dwNumPhones;
+    PTPHONELOOKUPTABLE      pPhoneLookup;
+    PTREQUESTRECIPIENT      pRequestRecipients;
+    PTREQUESTRECIPIENT      pHighestPriorityRequestRecipient;
+
+    PTREQUESTMAKECALL       pRequestMakeCallList;
+    PTREQUESTMAKECALL       pRequestMakeCallListEnd;
+    WCHAR                  *apszPriorityList[24];
+    WCHAR                  *pszReqMakeCallPriList;
+
+    WCHAR                  *pszReqMediaCallPriList;
+    DWORD                   dwComputerNameSize;
+    WCHAR                  *pszComputerName;
+
+} TAPIGLOBALS, *PTAPIGLOBALS;
+
+
+typedef struct _CLIENTATTACH_PARAMS
+{
+    OUT LONG                lResult;
+
+    IN  PTCLIENT            _Unused_;
+
+
+    IN  DWORD               dwProcessID;
+
+    OUT DWORD               hRpcClientInst;
+
+    OUT HANDLE              hDetachEvent;
+
+    OUT HANDLE              hAsyncEventsEvent;
+
+} CLIENTATTACH_PARAMS, *PCLIENTATTACH_PARAMS;
+
+
+typedef struct _GETEVENTS_PARAMS
+{
+    OUT LONG                lResult;
+
+    IN  PTCLIENT            ptClient;
+
+
+    IN  DWORD               dwTotalBufferSize;
+
+    OUT DWORD               dwNeededBufferSize;
+
+    OUT DWORD               dwUsedBufferSize;
+
+} GETEVENTS_PARAMS, *PGETEVENTS_PARAMS;
+
+
+typedef struct _GETUIDLLNAME_PARAMS
+{
+    OUT LONG                lResult;
+
+    IN  PTCLIENT            ptClient;
+
+
+    IN  DWORD               dwObjectID;
+
+    IN  DWORD               dwObjectType;
+
+    OUT DWORD               dwUIDllNameOffset;
+
+    IN OUT DWORD            dwUIDllNameSize;
+
+
+    //
+    // The following fields used only for providerConfig, -Install, & -Remove
+    //
+
+    IN  DWORD               dwProviderFilenameOffset;
+
+    IN  DWORD               bRemoveProvider;
+
+    OUT HTAPIDIALOGINSTANCE htDlgInst;
+
+} GETUIDLLNAME_PARAMS, *PGETUIDLLNAME_PARAMS;
+
+
+typedef struct _UIDLLCALLBACK_PARAMS
+{
+    OUT LONG                lResult;
+
+    IN  PTCLIENT            ptClient;
+
+
+    IN  DWORD               dwObjectID;
+
+    IN  DWORD               dwObjectType;
+
+    IN  DWORD               dwParamsInOffset;
+
+    IN  DWORD               dwParamsInSize;
+
+    OUT DWORD               dwParamsOutOffset;
+
+    IN OUT DWORD            dwParamsOutSize;
+
+} UIDLLCALLBACK_PARAMS, *PUIDLLCALLBACK_PARAMS;
+
+
+typedef struct _FREEDIALOGINSTANCE_PARAMS
+{
+    OUT LONG                lResult;
+
+    IN  PTCLIENT            ptClient;
+
+
+    IN  HTAPIDIALOGINSTANCE htDlgInst;
+
+    IN  LONG                lUIDllResult;
+
+} FREEDIALOGINSTANCE_PARAMS, *PFREEDIALOGINSTANCE_PARAMS;
+
+
+typedef struct _PROXYREQUESTWRAPPER
+{
+    ASYNCEVENTMSG           AsyncEventMsg;
+
+    LINEPROXYREQUEST        ProxyRequest;
+
+} PROXYREQUESTWRAPPER, *PPROXYREQUESTWRAPPER;
+
+
+#if DBG
+
+    #define DBGOUT(arg) DbgPrt arg
+
+    VOID
+    DbgPrt(
+        IN DWORD  dwDbgLevel,
+        IN PUCHAR DbgMessage,
+        IN ...
+        );
+
+#else
+
+    #define DBGOUT(arg)
+
+#endif
+
+
+
+
+LPVOID
+WINAPI
+ServerAlloc(
+    DWORD dwSize
+    );
+
+VOID
+WINAPI
+ServerFree(
+    LPVOID  lp
+    );
+
+HANDLE
+MyCreateMutex(
+    void
+    );
+
+BOOL
+PASCAL
+MyDuplicateHandle(
+    HANDLE      hSource,
+    LPHANDLE    phTarget
+    );
+
+void
+CALLBACK
+CompletionProc(
+    PASYNCREQUESTINFO   pAsyncRequestInfo,
+    LONG                lResult
+    );
+
+BOOL
+WaitForMutex(
+    HANDLE      hMutex,
+    HANDLE     *phMutex,
+    BOOL       *pbCloseMutex,
+    LPVOID      pWidget,
+    DWORD       dwKey,
+    DWORD       dwTimeout
+    );
+
+void
+MyReleaseMutex(
+    HANDLE  hMutex,
+    BOOL    bCloseMutex
+    );
+
+void
+PASCAL
+DestroytLineApp(
+    PTLINEAPP   ptLineApp
+    );
+
+void
+DestroytPhoneApp(
+    PTPHONEAPP  ptPhoneApp
+    );
+
+LONG
+ServerInit(
+    void
+    );
+
+LONG
+ServerShutdown(
+    void
+    );
+
+void
+WriteEventBuffer(
+    PTCLIENT        ptClient,
+    PASYNCEVENTMSG  pMsg
+    );
+
+void
+PASCAL
+QueueSPEvent(
+    PSPEVENT    pSPEvent
+    );
+
+
+#if DBG
+
+#define SP_FUNC_SYNC  0
+#define SP_FUNC_ASYNC 1
+
+LONG
+WINAPI
+CallSP1(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1
+    );
+
+LONG
+WINAPI
+CallSP2(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2
+    );
+
+LONG
+WINAPI
+CallSP3(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3
+    );
+
+LONG
+WINAPI
+CallSP4(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4
+    );
+
+LONG
+WINAPI
+CallSP5(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5
+    );
+
+LONG
+WINAPI
+CallSP6(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6
+    );
+
+LONG
+WINAPI
+CallSP7(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7
+    );
+
+LONG
+WINAPI
+CallSP8(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7,
+    DWORD       dwArg8
+    );
+
+LONG
+WINAPI
+CallSP9(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7,
+    DWORD       dwArg8,
+    DWORD       dwArg9
+    );
+
+LONG
+WINAPI
+CallSP12(
+    TSPIPROC    pfn,
+    LPCSTR      lpszFuncName,
+    DWORD       dwFlags,
+    DWORD       dwArg1,
+    DWORD       dwArg2,
+    DWORD       dwArg3,
+    DWORD       dwArg4,
+    DWORD       dwArg5,
+    DWORD       dwArg6,
+    DWORD       dwArg7,
+    DWORD       dwArg8,
+    DWORD       dwArg9,
+    DWORD       dwArg10,
+    DWORD       dwArg11,
+    DWORD       dwArg12
+    );
+
+#else
+
+#define CallSP1(pfn,nm,fl,a1)                   ((*pfn)(a1))
+#define CallSP2(pfn,nm,fl,a1,a2)                ((*pfn)(a1,a2))
+#define CallSP3(pfn,nm,fl,a1,a2,a3)             ((*pfn)(a1,a2,a3))
+#define CallSP4(pfn,nm,fl,a1,a2,a3,a4)          ((*pfn)(a1,a2,a3,a4))
+#define CallSP5(pfn,nm,fl,a1,a2,a3,a4,a5)       ((*pfn)(a1,a2,a3,a4,a5))
+#define CallSP6(pfn,nm,fl,a1,a2,a3,a4,a5,a6)    ((*pfn)(a1,a2,a3,a4,a5,a6))
+#define CallSP7(pfn,nm,fl,a1,a2,a3,a4,a5,a6,a7) ((*pfn)(a1,a2,a3,a4,a5,a6,a7))
+#define CallSP8(pfn,nm,fl,a1,a2,a3,a4,a5,a6,a7,a8) \
+                ((*pfn)(a1,a2,a3,a4,a5,a6,a7,a8))
+#define CallSP9(pfn,nm,fl,a1,a2,a3,a4,a5,a6,a7,a8,a9) \
+                ((*pfn)(a1,a2,a3,a4,a5,a6,a7,a8,a9))
+#define CallSP12(pfn,nm,fl,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \
+                ((*pfn)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12))
+
+#endif
+
+
+#if DBG
+
+BOOL
+IsBadSizeOffset(
+    DWORD dwTotalSize,
+    DWORD dwFixedSize,
+    DWORD dwXxxSize,
+    DWORD dwXxxOffset,
+    char *pszCallingFunc,
+    char *pszFieldName
+    );
+
+#define ISBADSIZEOFFSET(a1,a2,a3,a4,a5,a6) IsBadSizeOffset(a1,a2,a3,a4,a5,a6)
+
+#else
+
+BOOL
+IsBadSizeOffset(
+    DWORD dwTotalSize,
+    DWORD dwFixedSize,
+    DWORD dwXxxSize,
+    DWORD dwXxxOffset
+    );
+
+#define ISBADSIZEOFFSET(a1,a2,a3,a4,a5,a6) IsBadSizeOffset(a1,a2,a3,a4)
+
+#endif
diff --git a/private/tapi/dev/server/server.rc b/private/tapi/dev/server/server.rc
new file mode 100644
index 000000000..77aefc207
--- /dev/null
+++ b/private/tapi/dev/server/server.rc
@@ -0,0 +1,88 @@
+#include "windows.h"
+#include "resource.h"
+
+#include "country.rc"
+//#include "dial.rc"
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony Server"
+#define VER_INTERNALNAME_STR        "Telephony Service"
+#define VER_ORIGINALFILENAME_STR    "TAPISRV.EXE"
+//#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+#define VER_LEGALCOPYRIGHT_YEARS      "1994-1995"
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#if (WINVER >= 0x400)
+IDD_DEFINE_LOCATION DIALOG DISCARDABLE  10, 10, 265, 217
+#else
+IDD_DEFINE_LOCATION DIALOG DISCARDABLE  10, 10, 265, 237
+#endif
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU //| DS_3DLOOK
+CAPTION "My Locations"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    GROUPBOX        "Where I am:",IDC_STATIC,7,7,250,74
+    LTEXT           "I am &dialing from:",IDCS_DL_CURR_LOCATION,15,20,56,10
+    COMBOBOX        IDCC_DL_CURR_LOCATION,76,19,83,50,CBS_DROPDOWN | 
+                    CBS_SORT | WS_VSCROLL | WS_TABSTOP
+    PUSHBUTTON      "&New...",IDCB_DL_NEW_LOCATION,163,19,41,14
+    PUSHBUTTON      "&Remove",IDCB_DL_REMOVE_LOCATION,208,19,41,14
+    LTEXT           "The area &code is:",IDCS_DL_AREA_CODE,15,40,59,10
+    EDITTEXT        IDCE_DL_AREA_CODE,76,38,40,14,ES_AUTOHSCROLL
+    LTEXT           "",IDC_STATIC+1,120,40,56,10
+    LTEXT           "&I am in:",IDCS_DL_COUNTRY_CODE,15,59,51,10
+    COMBOBOX        IDCC_DL_COUNTRY_CODE,76,58,128,68,CBS_DROPDOWNLIST | 
+                    CBS_SORT | WS_VSCROLL | WS_TABSTOP
+    GROUPBOX        "How I dial from this location:",IDC_STATIC+2,7,88,250,90
+    LTEXT           "To access an &outside line, 1st dial:",IDCS_DL_OUTSIDE,
+                    15,104,114,10
+    EDITTEXT        IDCE_DL_LOCAL_CALLS,130,102,15,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    LTEXT           "for local,",IDCS_DL_LOCAL_CALLS,147,104,30,10
+    EDITTEXT        IDCE_DL_LONG_DIST_CALLS,181,102,15,14,ES_AUTOHSCROLL | ES_UPPERCASE
+    LTEXT           "for long dist.",IDCS_DL_LONG_DIST_CALLS,198,104,55,10
+    CONTROL         "Dial &using Calling Card:",IDCK_DL_CALLING_CARD,"Button",
+                    BS_AUTOCHECKBOX | WS_TABSTOP,15,122,88,10
+/* removed to temporarily fix bug 1156; following "LTEXT" is replacement
+    CONTROL         "",IDCE_DL_CALLING_CARD,"Static",SS_LEFTNOWORDWRAP | 
+                    SS_NOPREFIX | WS_DISABLED | WS_GROUP,104,120,98,14
+*/
+    LTEXT           "",IDCE_DL_CALLING_CARD,104,123,98,12,SS_NOPREFIX | SS_LEFTNOWORDWRAP
+    PUSHBUTTON      "C&hange...",IDCB_DL_CHANGE_CARD,208,120,42,14
+    CONTROL         "This location has call &waiting. To disable it, dial:",
+                    IDCK_DL_CALL_WAITING,"Button",BS_AUTOCHECKBOX | 
+                    WS_TABSTOP,15,141,168,10
+    COMBOBOX        IDCC_DL_CALL_WAITING,190,140,42,30,CBS_DROPDOWN |
+                    WS_VSCROLL | WS_TABSTOP
+
+    LTEXT           "The phone system at this location uses:",IDCS_PULSE,15,160,159,10
+    RADIOBUTTON     "&Tone dialing",IDCR_TONE,145,157,55,14,WS_GROUP
+    RADIOBUTTON     "&Pulse dialing",IDCR_PULSE,200,157,55,14
+
+    LTEXT           "Number to be dialed:",IDCS_DIAL_NUMBER_TEXT,15,184,70,10
+    LTEXT           "",IDCS_DL_DIAL_NUMBER,86,184,165,19,SS_NOPREFIX
+    CONTROL         "Dial as a &long distance call",IDCK_DL_IN_LOCAL,
+                    "Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,203,98,10
+#if (WINVER < 0x400)
+    PUSHBUTTON      "OK",IDOK,163,217,41,14
+    PUSHBUTTON      "Cancel",IDCANCEL,208,217,41,14
+#endif
+END
diff --git a/private/tapi/dev/server/sources b/private/tapi/dev/server/sources
new file mode 100644
index 000000000..221f35b4f
--- /dev/null
+++ b/private/tapi/dev/server/sources
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tapisrv
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+BACKGROUND_USE=1
+
+USE_CRTDLL=1
+
+SOURCES=server.c   \
+        line.c     \
+        phone.c    \
+        tapi.c     \
+        tapsrv_s.c \
+        rmotsp_c.c \
+        dial.c     \
+        server.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/server/tapi.c b/private/tapi/dev/server/tapi.c
new file mode 100644
index 000000000..fe49b4e13
--- /dev/null
+++ b/private/tapi/dev/server/tapi.c
@@ -0,0 +1,313 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    tapi.c
+
+Abstract:
+
+    Src module for tapi server line funcs
+
+Author:
+
+    Dan Knudson (DanKn)    01-Apr-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "shellapi.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "..\client\client.h"
+#include "server.h"
+#include "..\perfdll\tapiperf.h"
+#include "tapy.h"
+
+
+extern TAPIGLOBALS TapiGlobals;
+
+extern CRITICAL_SECTION gPriorityListCritSec;
+
+extern PERFBLOCK    PerfBlock;
+
+BOOL
+PASCAL
+NotifyHighestPriorityRequestRecipient(
+    void
+    );
+
+void
+WINAPI
+TGetLocationInfo(
+    PTAPIGETLOCATIONINFO_PARAMS pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    //
+    // This is currently implemented on the client side (should be moved
+    // back to server side eventually)
+    //
+}
+
+
+void
+WINAPI
+TRequestDrop(
+    PTAPIREQUESTDROP_PARAMS pParams,
+    LPBYTE                  pDataBuf,
+    LPDWORD                 pdwNumBytesReturned
+    )
+{
+    //
+    // No media call/drop support right now, since the original
+    // spec/implementation sucked and made no provision for
+    // retrieving media stream handle, etc
+    //
+
+    pParams->lResult = TAPIERR_REQUESTFAILED;
+}
+
+
+void
+WINAPI
+TRequestMakeCall(
+    PTAPIREQUESTMAKECALL_PARAMS pParams,
+    LPBYTE                      pDataBuf,
+    LPDWORD                     pdwNumBytesReturned
+    )
+{
+    BOOL                bRequestMakeCallListEmpty;
+    PTREQUESTMAKECALL   pRequestMakeCall;
+
+
+    //
+    // Check to see if the hRequestMakeCall is non-0, because if so
+    // tapi32.dll failed to exec a proxy app and it's alerting us that
+    // we need to clean up this request (we'll just nuke 'em all for now)
+    //
+
+    if (pParams->hRequestMakeCallFailed)
+    {
+        PTREQUESTMAKECALL   pRequestMakeCall, pNextRequestMakeCall;
+
+
+        EnterCriticalSection (&gPriorityListCritSec);
+
+        pRequestMakeCall = TapiGlobals.pRequestMakeCallList;
+
+        while (pRequestMakeCall)
+        {
+            pNextRequestMakeCall = pRequestMakeCall->pNext;
+            ServerFree (pRequestMakeCall);
+            pRequestMakeCall = pNextRequestMakeCall;
+        }
+
+        TapiGlobals.pRequestMakeCallList    =
+        TapiGlobals.pRequestMakeCallListEnd = NULL;
+
+        LeaveCriticalSection (&gPriorityListCritSec);
+
+        DBGOUT((
+            2,
+            "TRequestMakeCall: couldn't exec proxy, deleting requests"
+            ));
+
+        pParams->lResult = TAPIERR_NOREQUESTRECIPIENT;
+        return;
+    }
+
+
+    //
+    // Alloc & init a request make call object
+    //
+
+    if (!(pRequestMakeCall = ServerAlloc (sizeof (TREQUESTMAKECALL))))
+    {
+        pParams->lResult = TAPIERR_REQUESTFAILED;
+        return;
+    }
+
+    lstrcpynW(
+        pRequestMakeCall->LineReqMakeCall.szDestAddress,
+        (LPCWSTR) (pDataBuf + pParams->dwDestAddressOffset),
+        TAPIMAXDESTADDRESSSIZE
+        );
+
+    if (pParams->dwAppNameOffset != TAPI_NO_DATA)
+    {
+        lstrcpynW(
+            pRequestMakeCall->LineReqMakeCall.szAppName,
+            (LPCWSTR) (pDataBuf + pParams->dwAppNameOffset),
+            TAPIMAXAPPNAMESIZE
+            );
+    }
+
+    if (pParams->dwCalledPartyOffset != TAPI_NO_DATA)
+    {
+        lstrcpynW(
+            pRequestMakeCall->LineReqMakeCall.szCalledParty,
+            (LPCWSTR) (pDataBuf + pParams->dwCalledPartyOffset),
+            TAPIMAXCALLEDPARTYSIZE
+            );
+    }
+
+    if (pParams->dwCommentOffset != TAPI_NO_DATA)
+    {
+        lstrcpynW(
+            pRequestMakeCall->LineReqMakeCall.szComment,
+            (LPCWSTR) (pDataBuf + pParams->dwCommentOffset),
+            TAPIMAXCOMMENTSIZE
+            );
+    }
+
+
+    //
+    // Add object to end of global list
+    //
+
+    EnterCriticalSection (&gPriorityListCritSec);
+
+    if (TapiGlobals.pRequestMakeCallListEnd)
+    {
+        TapiGlobals.pRequestMakeCallListEnd->pNext = pRequestMakeCall;
+        bRequestMakeCallListEmpty = FALSE;
+    }
+    else
+    {
+        TapiGlobals.pRequestMakeCallList = pRequestMakeCall;
+        bRequestMakeCallListEmpty = TRUE;
+    }
+
+    TapiGlobals.pRequestMakeCallListEnd = pRequestMakeCall;
+
+    LeaveCriticalSection (&gPriorityListCritSec);
+
+
+    {
+        LPVARSTRING pProxyList = (LPVARSTRING) pDataBuf;
+
+
+        pProxyList->dwTotalSize  = pParams->u.dwProxyListTotalSize;
+        pProxyList->dwNeededSize =
+        pProxyList->dwUsedSize   = sizeof (VARSTRING);
+
+        pParams->hRequestMakeCallAttempted = 0;
+
+
+        //
+        // If the request list is currently empty then we need to notify the
+        // highest priority request recipient that there's requests for it
+        // to process.  Otherwise, we can assume that we already sent this
+        // msg and the app knows there's requests available for it to process.
+        //
+
+        if (bRequestMakeCallListEmpty)
+        {
+            if (TapiGlobals.pHighestPriorityRequestRecipient)
+            {
+                NotifyHighestPriorityRequestRecipient();
+            }
+            else
+            {
+                 EnterCriticalSection (&gPriorityListCritSec);
+
+                 if (TapiGlobals.pszReqMakeCallPriList)
+                 {
+                     //
+                     // Copy the pri list to the buffer & pass it back to
+                     // the client side, so it can try to start the proxy
+                     // app (if it fails it'll call us back to free the
+                     // pRequestMakeCall)
+                     //
+
+                     pProxyList->dwNeededSize =
+                     pProxyList->dwUsedSize   = pProxyList->dwTotalSize;
+
+                     pProxyList->dwStringSize   =
+                          pParams->u.dwProxyListTotalSize - sizeof (VARSTRING);
+                     pProxyList->dwStringOffset = sizeof (VARSTRING);
+
+                     pParams->hRequestMakeCallAttempted = (DWORD)
+                         pRequestMakeCall;
+
+                     lstrcpynW(
+                         (PWSTR)(((LPBYTE) pProxyList) + pProxyList->dwStringOffset),
+                         TapiGlobals.pszReqMakeCallPriList + 1, // no init ','
+                         pProxyList->dwStringSize
+                         );
+                 }
+                 else
+                 {
+                     TapiGlobals.pRequestMakeCallList    =
+                     TapiGlobals.pRequestMakeCallListEnd = NULL;
+
+                     ServerFree (pRequestMakeCall);
+
+                     pParams->lResult = TAPIERR_NOREQUESTRECIPIENT;
+                 }
+
+                 LeaveCriticalSection (&gPriorityListCritSec);
+            }
+        }
+
+        if (pParams->lResult == 0)
+        {
+            pParams->u.dwProxyListOffset = 0;
+            *pdwNumBytesReturned = sizeof (TAPI32_MSG) +
+                pProxyList->dwUsedSize;
+        }
+    }
+
+TRequestMakeCall_return:
+
+    DBGOUT((
+        3,
+        "TapiEpilogSync (tapiRequestMakeCall) exit, returning x%x",
+        pParams->lResult
+        ));
+}
+
+
+void
+WINAPI
+TRequestMediaCall(
+    PTAPIREQUESTMEDIACALL_PARAMS    pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+    //
+    // No media call/drop support right now, since the original
+    // spec/implementation sucked and made no provision for
+    // retrieving media stream handle, etc
+    //
+
+    pParams->lResult = TAPIERR_REQUESTFAILED;
+}
+
+void
+WINAPI
+TPerformance(
+    PTAPIPERFORMANCE_PARAMS         pParams,
+    LPBYTE                          pDataBuf,
+    LPDWORD                         pdwNumBytesReturned
+    )
+{
+
+    DBGOUT((10, "PERF: In TPerformance"));
+
+    CopyMemory(pDataBuf,
+               &PerfBlock,
+               sizeof(PERFBLOCK));
+
+    pParams->dwPerfOffset = 0;
+    
+    *pdwNumBytesReturned = sizeof(TAPI32_MSG) + sizeof(PERFBLOCK);
+
+}
diff --git a/private/tapi/dev/server/tapisrv.def b/private/tapi/dev/server/tapisrv.def
new file mode 100644
index 000000000..bfece85d2
--- /dev/null
+++ b/private/tapi/dev/server/tapisrv.def
@@ -0,0 +1,9 @@
+
+NAME         TAPISRV
+
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     1024
+STACKSIZE    8192
diff --git a/private/tapi/dev/server/tapisrv.ini b/private/tapi/dev/server/tapisrv.ini
new file mode 100644
index 000000000..9760d0c6b
--- /dev/null
+++ b/private/tapi/dev/server/tapisrv.ini
@@ -0,0 +1,29 @@
+\registry\machine\software\microsoft\windows
+\registry\machine\software\microsoft\windows\currentversion
+\registry\machine\software\microsoft\windows\currentversion\Telephony
+    TapisrvDebugLevel = REG_DWORD 0
+    Tapi32DebugLevel = REG_DWORD 0
+    KmddspDebugLevel = REG_DWORD 0
+    Atsp32DebugLevel = REG_DWORD 0
+
+\registry\machine\software\microsoft\windows\currentversion\Telephony\Providers
+    NumProviders = REG_DWORD 3
+    NextProviderID = REG_DWORD 4
+    ProviderID0 = REG_DWORD 1
+    ProviderID1 = REG_DWORD 2
+    ProviderID2 = REG_DWORD 3
+    ProviderFilename0 = REG_SZ kmddsp.tsp
+    ProviderFilename1 = REG_SZ esp32.tsp
+    ProviderFilename2 = REG_SZ atsp32.tsp
+
+\registry\machine\software\microsoft\windows\currentversion\Telephony\Provider1
+    NumLines = REG_DWORD 0
+    NumPhones = REG_DWORD 0
+
+\registry\machine\software\microsoft\windows\currentversion\Telephony\Provider2
+    NumLines = REG_DWORD 0
+    NumPhones = REG_DWORD 0
+
+\registry\machine\software\microsoft\windows\currentversion\Telephony\Provider3
+    NumLines = REG_DWORD 0
+    NumPhones = REG_DWORD 0
diff --git a/private/tapi/dev/server/tapy.h b/private/tapi/dev/server/tapy.h
new file mode 100644
index 000000000..8dfdb8122
--- /dev/null
+++ b/private/tapi/dev/server/tapy.h
@@ -0,0 +1,121 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tapy.h
+
+Abstract:
+
+    Header file for
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+typedef struct _TAPIGETLOCATIONINFO_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    OUT DWORD       dwCountryCodeOffset;
+
+    IN OUT DWORD    dwCountryCodeSize;
+
+    OUT DWORD       dwCityCodeOffset;
+
+    IN OUT DWORD    dwCityCodeSize;
+
+} TAPIGETLOCATIONINFO_PARAMS, *PTAPIGETLOCATIONINFO_PARAMS;
+
+typedef struct _TAPIREQUESTDROP_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HWND        hwnd;
+
+    IN  DWORD       wRequestID;
+
+} TAPIREQUESTDROP_PARAMS, *PTAPIREQUESTDROP_PARAMS;
+
+typedef struct _TAPIREQUESTMAKECALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  DWORD       dwDestAddressOffset;
+
+    IN  DWORD       dwAppNameOffset;            // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwCalledPartyOffset;        // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwCommentOffset;            // valid offset or TAPI_NO_DATA
+
+    union
+    {
+        IN  DWORD   dwProxyListTotalSize;       // size of client buffer
+
+        OUT DWORD   dwProxyListOffset;          // valid offset on success
+
+    } u;
+
+    IN  DWORD       hRequestMakeCallFailed;     // Non-zero if failed to
+                                                //     start proxy
+
+    OUT  DWORD      hRequestMakeCallAttempted;  // Non-zero if failed to
+                                                //     start proxy
+
+} TAPIREQUESTMAKECALL_PARAMS, *PTAPIREQUESTMAKECALL_PARAMS;
+
+typedef struct _TAPIREQUESTMEDIACALL_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+
+    IN  HWND        hwnd;
+
+    IN  DWORD       wRequestID;
+
+    IN  DWORD       dwDeviceClassOffset;
+
+    OUT DWORD       dwDeviceIDOffset;
+
+    IN OUT  DWORD   dwSize;
+
+    IN  DWORD       dwSecure;
+
+    IN  DWORD       dwDestAddressOffset;
+
+    IN  DWORD       dwAppNameOffset;            // valid offset or TAPI_NO_DATA
+
+    IN  DWORD       dwCalledPartyOffset;
+
+    IN  DWORD       dwCommentOffset;            // valid offset or TAPI_NO_DATA
+
+
+} TAPIREQUESTMEDIACALL_PARAMS, *PTAPIREQUESTMEDIACALL_PARAMS;
+
+typedef struct _TAPIPERFORMANCE_PARAMS
+{
+    OUT LONG        lResult;
+
+    IN  PTCLIENT    ptClient;
+
+    OUT DWORD       dwPerfOffset;
+
+} TAPIPERFORMANCE_PARAMS, *PTAPIPERFORMANCE_PARAMS;
diff --git a/private/tapi/dev/sp/atsp32/atsp.c b/private/tapi/dev/sp/atsp32/atsp.c
new file mode 100644
index 000000000..0141d18fc
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/atsp.c
@@ -0,0 +1,2630 @@
+/*++
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    atsp.c
+
+Notes:
+
+--*/
+
+
+#include "atsp.h"
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    if (dwReason ==  DLL_PROCESS_ATTACH)
+    {
+        ghInst = hDLL;
+
+#if DBG
+        {
+            HKEY    hKey;
+            DWORD   dwDataSize, dwDataType;
+            char    szAtsp32DebugLevel[] = "Atsp32DebugLevel";
+
+
+            RegOpenKeyExA(
+                HKEY_LOCAL_MACHINE,
+                gszAtspKey,
+                0,
+                KEY_ALL_ACCESS,
+                &hKey
+                );
+
+            dwDataSize = sizeof (DWORD);
+            gdwDebugLevel=0;
+
+            RegQueryValueEx(
+                hKey,
+                szAtsp32DebugLevel,
+                0,
+                &dwDataType,
+                (LPBYTE) &gdwDebugLevel,
+                &dwDataSize
+                );
+
+            RegCloseKey (hKey);
+        }
+#endif
+
+    }
+
+    return TRUE;
+}
+
+
+void
+CommThread(
+    PDRVLINE    pLine
+    )
+{
+    char            buf[4];
+    DWORD           dwThreadID = GetCurrentThreadId(), dwNumBytes;
+    HANDLE          hComm = pLine->hComm, hEvent;
+    LPOVERLAPPED    pOverlapped = &pLine->Overlapped;
+
+
+    DBGOUT((
+        3,
+        "CommThread (id=%d): enter, port=%s",
+        dwThreadID,
+        pLine->szComm
+        ));
+
+    hEvent = pOverlapped->hEvent;
+    buf[0] = buf[1] = '.';
+
+
+    //
+    // Loop waiting for i/o to complete (either the Write done in
+    // TSPI_lineMakeCall or the Reads done to retrieve status info).
+    // Note that TSPI_lineDrop or TSPI_lineCloseCall may set the
+    // event to alert us that they're tearing down the call, in
+    // which case we just exit.
+    //
+
+    for (;;)
+    {
+        if (WaitForSingleObject (hEvent, ATSP_TIMEOUT) == WAIT_OBJECT_0)
+        {
+            if (pLine->bDropInProgress == TRUE)
+            {
+                DBGOUT((2, "CommThread (id=%d): drop in progress"));
+                goto CommThread_exit;
+            }
+
+            GetOverlappedResult (hComm, pOverlapped, &dwNumBytes, FALSE);
+            ResetEvent (hEvent);
+        }
+        else
+        {
+            DBGOUT((2, "CommThread (id=%d): wait timeout"));
+            SetCallState (pLine, LINECALLSTATE_IDLE, 0);
+            goto CommThread_exit;
+        }
+
+        buf[1] &= 0x7f; // nuke the parity bit
+
+        DBGOUT((
+            3,
+            "CommThread (id=%d): read '%c'",
+            dwThreadID,
+            (buf[1] == '\r' ? '.' : buf[1])
+            ));
+
+        switch ((buf[0] << 8) + buf[1])
+        {
+        case 'CT':  // "CONNECT"
+        case 'OK':  // "OK"
+
+            SetCallState (pLine, LINECALLSTATE_CONNECTED, 0);
+            goto CommThread_exit;
+
+        case 'SY':  // "BUSY"
+        case 'OR':  // "ERROR"
+        case 'NO':  // "NO ANSWER", "NO DIALTONE", "NO CARRIER"
+
+            SetCallState (pLine, LINECALLSTATE_IDLE, 0);
+            goto CommThread_exit;
+
+        default:
+
+            break;
+        }
+
+        buf[0] = buf[1];
+
+        ZeroMemory (pOverlapped, sizeof (OVERLAPPED) - sizeof (HANDLE));
+        ReadFile (hComm, &buf[1], 1, &dwNumBytes, pOverlapped);
+    }
+
+CommThread_exit:
+
+    CloseHandle (hEvent);
+    DBGOUT((3, "CommThread (id=%d): exit", dwThreadID));
+    ExitThread (0);
+}
+
+
+//
+// We get a slough of C4047 (different levels of indrection) warnings down
+// below in the initialization of FUNC_PARAM structs as a result of the
+// real func prototypes having params that are types other than DWORDs,
+// so since these are known non-interesting warnings just turn them off
+//
+
+#pragma warning (disable:4047)
+
+
+//
+// --------------------------- TAPI_lineXxx funcs -----------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE    hdLine
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine, hdLine }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineClose",
+        1,
+        params,
+    };
+#endif
+
+    Prolog (&info);
+    DrvFree ((PDRVLINE) hdLine);
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL    hdCall
+    )
+{
+    PDRVLINE    pLine = (PDRVLINE) hdCall;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdCall, hdCall  }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineCloseCall",
+        1,
+        params
+    };
+#endif
+
+
+    //
+    // Note that in TAPI 2.0 TSPI_lineCloseCall can get called
+    // without TSPI_lineDrop ever being called, so we need to
+    // be prepared for either case.
+    //
+
+    Prolog (&info);
+    DropActiveCall (pLine);
+    pLine->htCall = NULL;
+    return (Epilog (&info, 0));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine,        hdLine       },
+        { "dwMediaModes",   dwMediaModes },
+        { gszlpCallParams,  lpCallParams }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineConditionalMediaDetection",
+        3,
+        params
+    };
+#endif
+
+
+    //
+    // This func is really a no-op for us, since we don't look
+    // for incoming calls (though we do say we support them to
+    // make apps happy)
+    //
+
+    Prolog (&info);
+    return (Epilog (&info, 0));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    PDRVLINE    pLine = (PDRVLINE) hdCall;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszdwRequestID,        dwRequestID     },
+        { gszhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { gszdwSize,             dwSize          }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineDrop",
+        4,
+        params
+    };
+#endif
+
+
+    Prolog (&info);
+    DropActiveCall (pLine);
+    SetCallState (pLine, LINECALLSTATE_IDLE, 0);
+    (*gpfnCompletionProc)(dwRequestID, 0);
+    return (Epilog (&info, dwRequestID));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD              dwDeviceID,
+    DWORD              dwAddressID,
+    DWORD              dwTSPIVersion,
+    DWORD              dwExtVersion,
+    LPLINEADDRESSCAPS  lpAddressCaps
+    )
+{
+
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszdwDeviceID,     dwDeviceID      },
+        { "dwAddressID",    dwAddressID     },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpAddressCaps",  lpAddressCaps   }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetAddressCaps",
+        5,
+        params
+    };
+#endif
+
+    LONG        lResult = 0;
+
+
+    Prolog (&info);
+
+    if (dwAddressID != 0)
+    {
+        lResult = LINEERR_INVALADDRESSID;
+    }
+
+    lpAddressCaps->dwNeededSize =
+    lpAddressCaps->dwUsedSize   = sizeof(LINEADDRESSCAPS);
+
+    lpAddressCaps->dwLineDeviceID       = dwDeviceID;
+    lpAddressCaps->dwAddressSharing     = LINEADDRESSSHARING_PRIVATE;
+    lpAddressCaps->dwCallInfoStates     = LINECALLINFOSTATE_MEDIAMODE |
+                                          LINECALLINFOSTATE_APPSPECIFIC;
+    lpAddressCaps->dwCallerIDFlags      =
+    lpAddressCaps->dwCalledIDFlags      =
+    lpAddressCaps->dwRedirectionIDFlags =
+    lpAddressCaps->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL;
+    lpAddressCaps->dwCallStates         = LINECALLSTATE_IDLE |
+                                          LINECALLSTATE_OFFERING |
+                                          LINECALLSTATE_ACCEPTED |
+                                          LINECALLSTATE_DIALTONE |
+                                          LINECALLSTATE_DIALING |
+                                          LINECALLSTATE_CONNECTED |
+                                          LINECALLSTATE_PROCEEDING |
+                                          LINECALLSTATE_DISCONNECTED |
+                                          LINECALLSTATE_UNKNOWN;
+    lpAddressCaps->dwDialToneModes      = LINEDIALTONEMODE_UNAVAIL;
+    lpAddressCaps->dwBusyModes          = LINEBUSYMODE_UNAVAIL;
+    lpAddressCaps->dwSpecialInfo        = LINESPECIALINFO_UNAVAIL;
+    lpAddressCaps->dwDisconnectModes    = LINEDISCONNECTMODE_NORMAL |
+                                          LINEDISCONNECTMODE_BUSY |
+                                          LINEDISCONNECTMODE_NOANSWER |
+                                          LINEDISCONNECTMODE_UNAVAIL |
+                                          LINEDISCONNECTMODE_NODIALTONE;
+    lpAddressCaps->dwMaxNumActiveCalls  = 1;
+    lpAddressCaps->dwAddrCapFlags       = LINEADDRCAPFLAGS_DIALED;
+    lpAddressCaps->dwCallFeatures       = LINECALLFEATURE_ACCEPT |
+                                          LINECALLFEATURE_ANSWER |
+                                          LINECALLFEATURE_DROP |
+                                          LINECALLFEATURE_SETCALLPARAMS;
+    lpAddressCaps->dwAddressFeatures    = LINEADDRFEATURE_MAKECALL;
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine,             hdLine         },
+        { "dwAddressID",        dwAddressID     },
+        { "lpAddressStatus",    lpAddressStatus }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetAddressStatus",
+        3,
+        params
+    };
+#endif
+
+    LONG        lResult = 0;
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+
+
+    Prolog (&info);
+
+    lpAddressStatus->dwNeededSize =
+    lpAddressStatus->dwUsedSize   = sizeof(LINEADDRESSSTATUS);
+
+    lpAddressStatus->dwNumActiveCalls  = (pLine->htCall ? 1 : 0);
+    lpAddressStatus->dwAddressFeatures = LINEADDRFEATURE_MAKECALL;
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwAddressID
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdCall,        hdCall          },
+        { "lpdwAddressID",  lpdwAddressID   }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetCallAddressID",
+        2,
+        params
+    };
+#endif
+
+
+    //
+    // We only support 1 address (id=0)
+    //
+
+    Prolog (&info);
+    *lpdwAddressID = 0;
+    return (Epilog (&info, 0));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpLineInfo
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdCall,     hdCall      },
+        { "lpLineInfo", lpLineInfo  }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetCallInfo",
+        2,
+        params
+    };
+#endif
+    LONG        lResult = 0;
+    PDRVLINE    pLine = (PDRVLINE) hdCall;
+
+
+    Prolog (&info);
+
+    lpLineInfo->dwNeededSize =
+    lpLineInfo->dwUsedSize   = sizeof(LINECALLINFO);
+
+    lpLineInfo->dwBearerMode         = LINEBEARERMODE_VOICE;
+    lpLineInfo->dwMediaMode          = pLine->dwMediaMode;
+    lpLineInfo->dwCallStates         = LINECALLSTATE_IDLE |
+                                       LINECALLSTATE_DIALTONE |
+                                       LINECALLSTATE_DIALING |
+                                       LINECALLSTATE_CONNECTED |
+                                       LINECALLSTATE_PROCEEDING |
+                                       LINECALLSTATE_DISCONNECTED |
+                                       LINECALLSTATE_UNKNOWN;
+    lpLineInfo->dwOrigin             = LINECALLORIGIN_OUTBOUND;
+    lpLineInfo->dwReason             = LINECALLREASON_DIRECT;
+    lpLineInfo->dwCallerIDFlags      =
+    lpLineInfo->dwCalledIDFlags      =
+    lpLineInfo->dwConnectedIDFlags   =
+    lpLineInfo->dwRedirectionIDFlags =
+    lpLineInfo->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL;
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpLineStatus
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdCall,         hdCall          },
+        { "lpLineStatus",   lpLineStatus    }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetCallStatus",
+        2,
+        params
+    };
+#endif
+    LONG        lResult = 0;
+    PDRVLINE    pLine = (PDRVLINE) hdCall;
+
+
+    Prolog (&info);
+
+    lpLineStatus->dwNeededSize =
+    lpLineStatus->dwUsedSize   = sizeof(LINECALLSTATUS);
+
+    lpLineStatus->dwCallState  = pLine->dwCallState;
+
+    if (pLine->dwCallState != LINECALLSTATE_IDLE)
+    {
+        lpLineStatus->dwCallFeatures = LINECALLFEATURE_DROP;
+    }
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpLineDevCaps",  lpLineDevCaps   }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetDevCaps",
+        4,
+        params
+    };
+#endif
+
+    LONG            lResult = 0;
+    static WCHAR    szProviderInfo[] = L"AT-compatible modem service provider";
+
+    #define PROVIDER_INFO_SIZE (37 * sizeof (WCHAR))
+
+    Prolog (&info);
+
+    lpLineDevCaps->dwNeededSize = sizeof (LINEDEVCAPS) + PROVIDER_INFO_SIZE +
+        (MAX_DEV_NAME_LENGTH + 1) * sizeof (WCHAR);
+
+    if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwNeededSize)
+    {
+        #define LINECONFIG_SIZE   (2 * (MAX_DEV_NAME_LENGTH + 1) + 40)
+
+        char    szLineConfig[LINECONFIG_SIZE], szLineN[16], *p;
+        HKEY    hKey;
+        DWORD   dwDataSize, dwDataType;
+
+
+        lpLineDevCaps->dwUsedSize = lpLineDevCaps->dwNeededSize;
+
+        lpLineDevCaps->dwProviderInfoSize   = PROVIDER_INFO_SIZE;
+        lpLineDevCaps->dwProviderInfoOffset = sizeof(LINEDEVCAPS);
+
+        lstrcpyW ((WCHAR *)(lpLineDevCaps + 1), szProviderInfo);
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            gszAtspKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hKey
+            );
+
+        dwDataSize = LINECONFIG_SIZE;
+        wsprintf (szLineN, "Line%d", dwDeviceID - gdwLineDeviceIDBase);
+        lstrcpy (szLineConfig, gszDefLineConfigParams);
+
+        RegQueryValueEx(
+            hKey,
+            szLineN,
+            0,
+            &dwDataType,
+            (LPBYTE) szLineConfig,
+            &dwDataSize
+            );
+
+        RegCloseKey (hKey);
+
+        for (p = szLineConfig; *p != ','; p++);
+        *p = 0;
+
+        lpLineDevCaps->dwLineNameSize   = (lstrlen (szLineConfig) + 1) *
+            sizeof (WCHAR);
+        lpLineDevCaps->dwLineNameOffset = sizeof(LINEDEVCAPS) +
+            PROVIDER_INFO_SIZE;
+
+        MultiByteToWideChar(
+            CP_ACP,
+            MB_PRECOMPOSED,
+            szLineConfig,
+            -1,
+            (WCHAR *) ((LPBYTE) (lpLineDevCaps + 1) + PROVIDER_INFO_SIZE),
+            lpLineDevCaps->dwLineNameSize
+            );
+    }
+    else
+    {
+        lpLineDevCaps->dwUsedSize = sizeof(LINEDEVCAPS);
+    }
+
+    lpLineDevCaps->dwStringFormat      = STRINGFORMAT_ASCII;
+    lpLineDevCaps->dwAddressModes      = LINEADDRESSMODE_ADDRESSID;
+    lpLineDevCaps->dwNumAddresses      = 1;
+    lpLineDevCaps->dwBearerModes       = LINEBEARERMODE_VOICE;
+    lpLineDevCaps->dwMaxRate           = 9600;
+    lpLineDevCaps->dwMediaModes        = LINEMEDIAMODE_INTERACTIVEVOICE |
+                                         LINEMEDIAMODE_DATAMODEM;
+    lpLineDevCaps->dwDevCapFlags       = LINEDEVCAPFLAGS_CLOSEDROP |
+                                         LINEDEVCAPFLAGS_DIALBILLING |
+                                         LINEDEVCAPFLAGS_DIALQUIET |
+                                         LINEDEVCAPFLAGS_DIALDIALTONE;
+    lpLineDevCaps->dwMaxNumActiveCalls = 1;
+    lpLineDevCaps->dwRingModes         = 1;
+    lpLineDevCaps->dwLineFeatures      = LINEFEATURE_MAKECALL;
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE    hdLine,
+    DWORD       dwAddressID,
+    HDRVCALL    hdCall,
+    DWORD       dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { gszhdCall,             hdCall          },
+        { "dwSelect",           dwSelect        },
+        { "lpDeviceID",         lpDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass },
+        { "hTargetProcess",     hTargetProcess  }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetID",
+        7,
+        params
+    };
+#endif
+
+    DWORD       dwNeededSize = sizeof(VARSTRING) + sizeof (DWORD);
+    LONG        lResult = 0;
+    PDRVLINE    pLine = (dwSelect == LINECALLSELECT_CALL ?
+                    (PDRVLINE) hdCall : (PDRVLINE) hdLine);
+
+
+    Prolog (&info);
+
+    if (lstrcmpiW (lpszDeviceClass, L"tapi/line") == 0)
+    {
+        if (lpDeviceID->dwTotalSize < dwNeededSize)
+        {
+            lpDeviceID->dwUsedSize = 3*sizeof(DWORD);
+        }
+        else
+        {
+            lpDeviceID->dwUsedSize = dwNeededSize;
+
+            lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+            lpDeviceID->dwStringSize   = sizeof(DWORD);
+            lpDeviceID->dwStringOffset = sizeof(VARSTRING);
+
+            *((LPDWORD)(lpDeviceID + 1)) = pLine->dwDeviceID;
+        }
+
+        lpDeviceID->dwNeededSize = dwNeededSize;
+    }
+    else if (lstrcmpiW (lpszDeviceClass, L"comm/datamodem") == 0)
+    {
+        dwNeededSize += (strlen (pLine->szComm) + 1) * sizeof (WCHAR);
+
+        if (lpDeviceID->dwTotalSize < dwNeededSize)
+        {
+            lpDeviceID->dwUsedSize = 3 * sizeof(DWORD);
+        }
+        else
+        {
+            HANDLE hCommDup = NULL;
+
+
+            if (!pLine->htCall)
+            {
+                DBGOUT((1, "TSPI_lineGetID32: error, no active call"));
+
+                lResult = LINEERR_OPERATIONFAILED;
+
+                goto TSPI_lineGetID_epilog;
+            }
+
+            if (!DuplicateHandle(
+                    GetCurrentProcess(),
+                    pLine->hComm,
+                    hTargetProcess,
+                    &hCommDup,
+                    0,
+                    TRUE,
+                    DUPLICATE_SAME_ACCESS
+                    ))
+            {
+                DBGOUT((
+                    1,
+                    "TSPI_lineGetID: DupHandle failed, err=%ld",
+                    GetLastError()
+                    ));
+
+                lResult = LINEERR_OPERATIONFAILED;
+
+                goto TSPI_lineGetID_epilog;
+            }
+
+            lpDeviceID->dwUsedSize = dwNeededSize;
+
+            lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+            lpDeviceID->dwStringSize   = dwNeededSize - sizeof(VARSTRING);
+            lpDeviceID->dwStringOffset = sizeof(VARSTRING);
+
+            *((HANDLE *)(lpDeviceID + 1)) = hCommDup;
+
+            lstrcpy(
+                ((char *)(lpDeviceID + 1)) + sizeof (HANDLE),
+                pLine->szComm
+                );
+
+            MultiByteToWideChar(
+                CP_ACP,
+                0,
+                pLine->szComm,
+                -1,
+                ((WCHAR *)(lpDeviceID + 1)) + sizeof (HANDLE),
+                256
+                );
+        }
+
+        lpDeviceID->dwNeededSize = dwNeededSize;
+    }
+    else
+    {
+        lResult = LINEERR_NODEVICE;
+    }
+
+TSPI_lineGetID_epilog:
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE        hdLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine,            hdLine          },
+        { "lpLineDevStatus",    lpLineDevStatus }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetLineDevStatus",
+        2,
+        params
+    };
+#endif
+
+    LONG        lResult = 0;
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+
+
+    Prolog (&info);
+
+    lpLineDevStatus->dwUsedSize =
+    lpLineDevStatus->dwNeededSize = sizeof (LINEDEVSTATUS);
+
+    lpLineDevStatus->dwNumActiveCalls = (pLine->htCall ? 1 : 0);
+    //lpLineDevStatus->dwLineFeatures =
+    lpLineDevStatus->dwDevStatusFlags = LINEDEVSTATUSFLAGS_CONNECTED |
+                                        LINEDEVSTATUSFLAGS_INSERVICE;
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwNumAddressIDs
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine,            hdLine            },
+        { "lpdwNumAddressIDs",  lpdwNumAddressIDs }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineGetNumAddressIDs",
+        2,
+        params
+    };
+#endif
+
+    LONG        lResult = 0;
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+
+
+    //
+    // We only support 1 address (id=0)
+    //
+
+    Prolog (&info);
+    *lpdwNumAddressIDs = 1;
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    char        szCommands[64], szCommand[64], szDestAddress[128];
+    DWORD       dwThreadID, dwNumBytes, dwError;
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszdwRequestID,       dwRequestID     },
+        { gszhdLine,            hdLine          },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    szDestAddress   },
+        { "dwCountryCode",      dwCountryCode   },
+        { gszlpCallParams,      lpCallParams    }
+    };
+    FUNC_INFO info =
+    {
+        "TSPI_lineMakeCall",
+        7,
+        params
+    };
+#endif
+
+
+    if (lpszDestAddress)
+    {
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDestAddress,
+            -1,
+            (LPSTR) szDestAddress,
+            128,
+            NULL,
+            NULL
+            );
+    }
+
+    Prolog (&info);
+
+
+    //
+    // Check to see if there's already another call
+    //
+
+    if (pLine->htCall)
+    {
+        (*gpfnCompletionProc)(dwRequestID, LINEERR_CALLUNAVAIL);
+        goto TSPI_lineMakeCall_return;
+    }
+
+
+    //
+    // Since we don't support TSPI_lineDial, fail if app tries
+    // to pass a NULL lpszDestAddress (implying that app just
+    // wants to go offhook)
+    //
+
+    if (lpszDestAddress == NULL)
+    {
+        (*gpfnCompletionProc)(dwRequestID, LINEERR_INVALADDRESS);
+        goto TSPI_lineMakeCall_return;
+    }
+
+
+    //
+    // Get the line's config info
+    //
+
+    {
+        HKEY    hKey;
+        DWORD   dwDataSize, dwDataType;
+        char    szLineN[8], *pszConfig, *p, *p2;
+
+
+        wsprintf(
+            szLineN,
+            "Line%d",
+            ((PDRVLINE) hdLine)->dwDeviceID - gdwLineDeviceIDBase
+            );
+
+        dwDataSize = 256;
+
+        pszConfig = DrvAlloc (dwDataSize);
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            gszAtspKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hKey
+            );
+
+        RegQueryValueEx(
+            hKey,
+            szLineN,
+            0,
+            &dwDataType,
+            (LPBYTE) pszConfig,
+            &dwDataSize
+            );
+
+        pszConfig[dwDataSize] = '\0';       // *pszConfig = "MyLine,COM1,L0"
+
+        RegCloseKey (hKey);
+
+
+        //
+        // szComm
+        //
+
+        for (p = pszConfig; *p != ','; p++);
+        p++;                                // *p = "COM1,L0"
+        for (p2 = p; *p2 != ','; p2++);
+        *p2 = 0;                            // *p = "COM1"
+
+        lstrcpy (pLine->szComm, p);
+
+
+        //
+        // szCommands
+        //
+
+        p2++;                               // *p2 = "L0"
+        lstrcpy (szCommands, p2);
+
+        DrvFree (pszConfig);
+    }
+
+
+    //
+    // Open the port
+    //
+
+    if ((pLine->hComm = CreateFile(
+            pLine->szComm,
+            GENERIC_READ | GENERIC_WRITE,
+            0, //FILE_SHARE_READ | FILE_SHARE_WRITE,  // BUGBUG
+            NULL, // no security attrs
+            OPEN_EXISTING,
+            FILE_FLAG_OVERLAPPED,
+            NULL  // no template file
+
+            )) == INVALID_HANDLE_VALUE)
+    {
+        DBGOUT((
+            3,
+            "TSPI_lineMakeCall: CreateFile(%s) failed, err=%ld",
+            pLine->szComm,
+            GetLastError()
+            ));
+
+        (*gpfnCompletionProc)(dwRequestID, LINEERR_RESOURCEUNAVAIL);
+        goto TSPI_lineMakeCall_return;
+    }
+
+
+    //
+    // Setup up the modem command string.  If there's an initial 'T'
+    // or 'P' (for Tone or Pulse) in the dest address then disregard
+    // it.  Also if it's a voice call add the semi colon so we return
+    // to cmd mode.
+    //
+
+    {
+        char *p = (char *) szDestAddress;
+
+
+        if (*p == 'T'  ||  *p == 'P')
+        {
+            p++;
+        }
+
+        if (lpCallParams &&
+            lpCallParams->dwMediaMode != LINEMEDIAMODE_INTERACTIVEVOICE)
+        {
+            wsprintf (szCommand, "AT%sDT%s\r", szCommands, p);
+        }
+        else
+        {
+            wsprintf (szCommand, "AT%sDT%s;\r", szCommands, p);
+        }
+    }
+
+
+    //
+    // Init the data structure & tell tapi our handle to the call
+    //
+
+    pLine->htCall          = htCall;
+    pLine->bDropInProgress = FALSE;
+    pLine->dwMediaMode     = (lpCallParams ? lpCallParams->dwMediaMode :
+        LINEMEDIAMODE_INTERACTIVEVOICE);
+
+    *lphdCall = (HDRVCALL) pLine;
+
+
+    //
+    // Do an overlapped write, the comm thread will deal with the results
+    //
+
+    pLine->Overlapped.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
+
+    if (!WriteFile(
+            pLine->hComm,
+            szCommand,
+            lstrlen (szCommand),
+            &dwNumBytes,
+            &pLine->Overlapped
+            )
+
+        && (dwError = GetLastError()) != ERROR_IO_PENDING)
+    {
+        DBGOUT((
+            1,
+            "TSPI_lineMakeCall: WriteFile(%s) failed, error=%d",
+            pLine->szComm,
+            dwError
+            ));
+
+        pLine->htCall = NULL;
+        CloseHandle (pLine->hComm);
+        CloseHandle (pLine->Overlapped.hEvent);
+        (*gpfnCompletionProc)(dwRequestID, LINEERR_OPERATIONFAILED);
+        goto TSPI_lineMakeCall_return;
+    }
+
+
+    //
+    // Complete the requests & set the initial call state
+    //
+
+    (*gpfnCompletionProc)(dwRequestID, 0);
+    SetCallState (pLine, LINECALLSTATE_DIALING, 0);
+
+
+    //
+    // Spin the comm thread to handle the results of the Write above
+    //
+
+    {
+        HANDLE hCommThread;
+
+
+        if (!(hCommThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) CommThread,
+                pLine,
+                0,
+                &dwThreadID
+                )))
+        {
+            DBGOUT((
+                1,
+                "TSPI_lineMakeCall: CreateThread failed, err=%ld",
+                GetLastError()
+                ));
+
+            GetOverlappedResult(
+                pLine->hComm,
+                &pLine->Overlapped,
+                &dwNumBytes,
+                TRUE
+                );
+
+            SetCallState (pLine, LINECALLSTATE_IDLE, 0);
+            CloseHandle (pLine->hComm);
+            CloseHandle (pLine->Overlapped.hEvent);
+            goto TSPI_lineMakeCall_return;
+        }
+
+        CloseHandle (hCommThread);
+    }
+
+
+TSPI_lineMakeCall_return:
+
+    return (Epilog (&info, dwRequestID));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszdwDeviceID,        dwDeviceID      },
+        { "dwLowVersion",       dwLowVersion    },
+        { "dwHighVersion",      dwHighVersion   },
+        { "lpdwTSPIVersion",    lpdwTSPIVersion }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineNegotiateTSPIVersion",
+        4,
+        params
+    };
+#endif
+
+    Prolog (&info);
+    *lpdwTSPIVersion = 0x00020000;
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD       dwDeviceID,
+    HTAPILINE   htLine,
+    LPHDRVLINE  lphdLine,
+    DWORD       dwTSPIVersion,
+    LINEEVENT   lpfnEventProc
+    )
+{
+    LONG        lResult;
+    PDRVLINE    pLine;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszdwDeviceID,    dwDeviceID      },
+        { "htLine",         htLine          },
+        { "lphdLine",       lphdLine        },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpfnEventProc",  lpfnEventProc   }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineOpen",
+        5,
+        params
+    };
+#endif
+
+
+    Prolog (&info);
+
+    if ((pLine = DrvAlloc (sizeof (DRVLINE))))
+    {
+        pLine->htLine       = htLine;
+        pLine->pfnEventProc = lpfnEventProc;
+        pLine->dwDeviceID   = dwDeviceID;
+
+        *lphdLine = (HDRVLINE) pLine;
+
+        lResult = 0;
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE    hdLine,
+    DWORD       dwMediaModes
+    )
+{
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { gszhdLine,        hdLine       },
+        { "dwMediaModes",   dwMediaModes }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_lineSetDefaultMediaDetection",
+        2,
+        params
+    };
+#endif
+
+
+    //
+    // This func is really a no-op for us, since we don't look
+    // for incoming calls (though we do say we support them to
+    // make apps happy)
+    //
+
+    Prolog (&info);
+    return (Epilog (&info, 0));
+}
+
+
+//
+// ------------------------- TSPI_providerXxx funcs ---------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    //
+    // Although this func is never called by TAPI v2.0, we export
+    // it so that the Telephony Control Panel Applet knows that it
+    // can configure this provider via lineConfigProvider(),
+    // otherwise Telephon.cpl will not consider it configurable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerGenericDialogData(
+    DWORD               dwObjectID,
+    DWORD               dwObjectType,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { "dwObjectID",     dwObjectID      },
+        { "dwObjectType",   dwObjectType    },
+        { "lpParams",       lpParams        },
+        { "dwSize",         dwSize          }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_providerGenericDialogData",
+        4,
+        params
+    };
+#endif
+
+
+    Prolog (&info);
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { "dwTSPIVersion",          dwTSPIVersion           },
+        { gszdwPermanentProviderID, dwPermanentProviderID   },
+        { "dwLineDeviceIDBase",     dwLineDeviceIDBase      },
+        { "dwPhoneDeviceIDBase",    dwPhoneDeviceIDBase     },
+        { "dwNumLines",             dwNumLines              },
+        { "dwNumPhones",            dwNumPhones             },
+        { "lpfnCompletionProc",     lpfnCompletionProc      }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_providerInit",
+        7,
+        params
+    };
+#endif
+
+    Prolog (&info);
+    gdwLineDeviceIDBase = dwLineDeviceIDBase;
+    gpfnCompletionProc  = lpfnCompletionProc;
+    *lpdwTSPIOptions = LINETSPIOPTION_NONREENTRANT;
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    //
+    // Although this func is never called by TAPI v2.0, we export
+    // it so that the Telephony Control Panel Applet knows that it
+    // can add this provider via lineAddProvider(), otherwise
+    // Telephon.cpl will not consider it installable
+    //
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    //
+    // Although this func is never called by TAPI v2.0, we export
+    // it so that the Telephony Control Panel Applet knows that it
+    // can remove this provider via lineRemoveProvider(), otherwise
+    // Telephon.cpl will not consider it removable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD   dwTSPIVersion,
+    DWORD   dwPermanentProviderID
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { "dwTSPIVersion",          dwTSPIVersion },
+        { gszdwPermanentProviderID, dwPermanentProviderID   }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_providerShutdown",
+        2,
+        params
+    };
+#endif
+
+
+    Prolog (&info);
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD       dwPermanentProviderID,
+    LPDWORD     lpdwNumLines,
+    LPDWORD     lpdwNumPhones,
+    HPROVIDER   hProvider,
+    LINEEVENT   lpfnLineCreateProc,
+    PHONEEVENT  lpfnPhoneCreateProc
+    )
+{
+   HKEY     hKey;
+   DWORD    dwNumLines, dwDataType, dwDataSize;
+
+
+   //
+   // Retrieve the number of devices we're
+   // configured for from our registry section
+   //
+
+   RegOpenKeyEx(
+       HKEY_LOCAL_MACHINE,
+       gszAtspKey,
+       0,
+       KEY_ALL_ACCESS,
+       &hKey
+       );
+
+   dwDataSize = sizeof(dwNumLines);
+   dwNumLines = 0;
+
+   RegQueryValueEx(
+       hKey,
+       gszNumLines,
+       0,
+       &dwDataType,
+       (LPBYTE) &dwNumLines,
+       &dwDataSize
+       );
+
+   RegCloseKey (hKey);
+
+   *lpdwNumLines  = dwNumLines;
+   *lpdwNumPhones = 0;
+   return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerUIIdentify(
+    LPWSTR   lpszUIDLLName
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { "lpsUIDLLName",  lpszUIDLLName }
+    };
+    FUNC_INFO   info =
+    {
+        "TSPI_providerUIIdentify",
+        1,
+        params
+    };
+#endif
+
+
+    Prolog (&info);
+    lstrcpyW(lpszUIDLLName, L"atsp32.tsp");
+    return (Epilog (&info, lResult));
+}
+
+
+//
+// ---------------------------- TUISPI_xxx funcs ------------------------------
+//
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+    char        szDeviceClass[128];
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { "lpfnUIDLLCallback",   lpfnUIDLLCallback },
+        { gszdwDeviceID,         dwDeviceID        },
+        { gszhwndOwner,          hwndOwner         },
+        { "lpszDeviceClass",     szDeviceClass     }
+    };
+    FUNC_INFO   info =
+    {
+        "TUISPI_lineConfigDialog",
+        4,
+        params
+    };
+#endif
+
+
+    if (lpszDeviceClass)
+    {
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDeviceClass,
+            -1,
+            (LPSTR) szDeviceClass,
+            128,
+            NULL,
+            NULL
+            );
+    }
+
+    Prolog (&info);
+
+    DialogBoxParam(
+        ghInst,
+        MAKEINTRESOURCE(IDD_DIALOG1),
+        hwndOwner,
+        (DLGPROC) ConfigDlgProc,
+        0
+        );
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerConfig(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    LONG        lResult = 0;
+#if DBG
+    FUNC_PARAM  params[] =
+    {
+        { "lpfnUIDLLCallback",      lpfnUIDLLCallback },
+        { gszhwndOwner,             hwndOwner    },
+        { gszdwPermanentProviderID, dwPermanentProviderID   }
+    };
+    FUNC_INFO   info =
+    {
+        "TUISPI_providerConfig",
+        3,
+        params
+    };
+#endif
+
+
+    Prolog (&info);
+
+    DialogBoxParam(
+        ghInst,
+        MAKEINTRESOURCE(IDD_DIALOG1),
+        hwndOwner,
+        (DLGPROC) ConfigDlgProc,
+        0
+        );
+
+    return (Epilog (&info, lResult));
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerInstall(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    LONG    lResult;
+
+
+    if ((lResult = ProviderInstall ("atsp32.tsp", TRUE)) == 0)
+    {
+        DialogBoxParam(
+            ghInst,
+            MAKEINTRESOURCE(IDD_DIALOG1),
+            hwndOwner,
+            (DLGPROC) ConfigDlgProc,
+            0
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerRemove(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    HKEY    hKey;
+    char    szSoftwareMsft[] = "Software\\Microsoft", szATSP[] = "ATSP";
+
+
+    //
+    // Clean up our registry section
+    //
+
+    RegOpenKeyExA(
+        HKEY_LOCAL_MACHINE,
+        szSoftwareMsft,
+        0,
+        KEY_ALL_ACCESS,
+        &hKey
+        );
+
+    RegDeleteKeyA (hKey, szATSP);
+    RegCloseKey (hKey);
+    return 0;
+}
+
+
+#pragma warning (default:4047)
+
+
+//
+// ---------------------- Misc private support routines -----------------------
+//
+
+void
+PASCAL
+EnableChildren(
+    HWND    hwnd,
+    BOOL    bEnable
+    )
+{
+    int i;
+    static int aiControlIDs[] =
+    {
+        IDC_DEVICES,
+        IDC_NAME,
+        IDC_PORT,
+        IDC_COMMANDS,
+        IDC_REMOVE,
+        0
+    };
+
+
+    for (i = 0; aiControlIDs[i]; i++)
+    {
+        EnableWindow (GetDlgItem (hwnd, aiControlIDs[i]), bEnable);
+    }
+}
+
+
+void
+PASCAL
+SelectDevice(
+    HWND    hwnd,
+    int     iDevice
+    )
+{
+    SendDlgItemMessage (hwnd, IDC_DEVICES, LB_SETCURSEL, iDevice, 0);
+    PostMessage(hwnd, WM_COMMAND, IDC_DEVICES | (LBN_SELCHANGE << 16), 0);
+}
+
+
+BOOL
+CALLBACK
+ConfigDlgProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static  HKEY    hAtspKey;
+
+    DWORD   dwDataSize;
+    DWORD   dwDataType;
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        char   *pBuf;
+        DWORD   i, iNumLines;
+
+
+        //
+        // Create or open our configuration key in the registry.  If the
+        // create fails it may well be that the current user does not
+        // have write access to this portion of the registry, so we'll
+        // just show a "read only" dialog and not allow user to make any
+        // changes
+        //
+
+        {
+            LONG    lResult;
+            DWORD   dwDisposition;
+
+
+            if ((lResult = RegCreateKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    gszAtspKey,
+                    0,
+                    "",
+                    REG_OPTION_NON_VOLATILE,
+                    KEY_ALL_ACCESS,
+                    (LPSECURITY_ATTRIBUTES) NULL,
+                    &hAtspKey,
+                    &dwDisposition
+
+                    )) != ERROR_SUCCESS)
+            {
+                DBGOUT((
+                    3,
+                    "RegCreateKeyEx(%s,ALL_ACCESS) failed, err=%d",
+                    gszAtspKey,
+                    lResult
+                    ));
+
+                if ((lResult = RegOpenKeyEx(
+                        HKEY_LOCAL_MACHINE,
+                        gszAtspKey,
+                        0,
+                        KEY_QUERY_VALUE,
+                        &hAtspKey
+
+                        )) != ERROR_SUCCESS)
+                {
+                    DBGOUT((
+                        3,
+                        "RegOpenKeyEx(%s,ALL_ACCESS) failed, err=%d",
+                        gszAtspKey,
+                        lResult
+                        ));
+
+                    EndDialog (hwnd, 0);
+                    return FALSE;
+                }
+
+                {
+                    int i;
+                    static int aiControlIDs[] =
+                    {
+                        IDC_NAME,
+                        IDC_PORT,
+                        IDC_COMMANDS,
+                        IDC_ADD,
+                        IDC_REMOVE,
+                        IDOK,
+                        0
+                    };
+
+
+                    for (i = 0; aiControlIDs[i]; i++)
+                    {
+                        EnableWindow(
+                            GetDlgItem (hwnd, aiControlIDs[i]),
+                            FALSE
+                            );
+                    }
+                }
+            }
+        }
+
+
+        //
+        // Retrieve our configuration info from the registry
+        //
+
+        dwDataSize = sizeof(iNumLines);
+        iNumLines = 0;
+
+        RegQueryValueEx(
+            hAtspKey,
+            gszNumLines,
+            0,
+            &dwDataType,
+            (LPBYTE) &iNumLines,
+            &dwDataSize
+            );
+
+        SendDlgItemMessage(
+            hwnd,
+            IDC_NAME,
+            EM_LIMITTEXT,
+            MAX_DEV_NAME_LENGTH,
+            0
+            );
+
+        SendDlgItemMessage(
+            hwnd,
+            IDC_COMMANDS,
+            EM_LIMITTEXT,
+            MAX_DEV_NAME_LENGTH,
+            0
+            );
+
+        pBuf = DrvAlloc (256);
+
+        for (i = 0; i < iNumLines; i++)
+        {
+            char           *p, *p2, szLineN[8];
+            PDRVLINECONFIG  pLineConfig = DrvAlloc (sizeof(DRVLINECONFIG));
+            LONG            lResult;
+
+
+            wsprintf (szLineN, "Line%d", i);
+
+            dwDataSize = 256;
+
+            lResult = RegQueryValueEx(
+                hAtspKey,
+                szLineN,
+                0,
+                &dwDataType,
+                (LPBYTE) pBuf,
+                &dwDataSize
+                );
+
+
+            //
+            // If there was a problem, use the default config
+            //
+
+            if (0 != lResult)
+            {
+               lstrcpy (pBuf, gszDefLineConfigParams);
+            }
+
+            for (p = pBuf; *p != ','; p++);
+            *p = 0;
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_ADDSTRING,
+                0,
+                (LPARAM) pBuf
+                );
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_SETITEMDATA,
+                i,
+                (LPARAM) pLineConfig
+                );
+
+            p++;
+            for (p2 = p; *p2 != ','; p2++);
+            *p2 = 0;
+
+            lstrcpy (pLineConfig->szPort, p);
+
+            p = p2 + 1;
+
+            lstrcpy (pLineConfig->szCommands, p);
+        }
+
+        DrvFree (pBuf);
+
+
+        //
+        // Fill up the various controls with configuration options
+        //
+
+        {
+            static char *aszPorts[] = { "COM1","COM2","COM3",NULL };
+
+            for (i = 0; aszPorts[i]; i++)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_PORT,
+                    LB_ADDSTRING,
+                    0,
+                    (LPARAM) aszPorts[i]
+                    );
+            }
+        }
+
+        if (iNumLines == 0)
+        {
+            EnableChildren (hwnd, FALSE);
+        }
+        else
+        {
+            SelectDevice (hwnd, 0);
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        int             iSelection;
+        PDRVLINECONFIG  pLineConfig;
+
+
+        iSelection = SendDlgItemMessage(
+            hwnd,
+            IDC_DEVICES,
+            LB_GETCURSEL,
+            0,
+            0
+            );
+
+        pLineConfig = (PDRVLINECONFIG) SendDlgItemMessage(
+            hwnd,
+            IDC_DEVICES,
+            LB_GETITEMDATA,
+            (WPARAM) iSelection,
+            0
+            );
+
+        switch (LOWORD((DWORD)wParam))
+        {
+        case IDC_DEVICES:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                char buf[MAX_DEV_NAME_LENGTH + 1];
+
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_GETTEXT,
+                    iSelection,
+                    (LPARAM) buf
+                    );
+
+                SetDlgItemText (hwnd, IDC_NAME, buf);
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_PORT,
+                    LB_SELECTSTRING,
+                    (WPARAM) -1,
+                    (LPARAM) pLineConfig->szPort
+                    );
+
+                SetDlgItemText (hwnd, IDC_COMMANDS, pLineConfig->szCommands);
+            }
+
+            break;
+
+        case IDC_NAME:
+
+            if ((HIWORD(wParam) == EN_CHANGE) && (iSelection != LB_ERR))
+            {
+                char    buf[MAX_DEV_NAME_LENGTH + 1];
+
+
+                GetDlgItemText (hwnd, IDC_NAME, buf, MAX_DEV_NAME_LENGTH);
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_DELETESTRING,
+                    iSelection,
+                    0
+                    );
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_INSERTSTRING,
+                    iSelection,
+                    (LPARAM) buf
+                    );
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_SETCURSEL,
+                    iSelection,
+                    0
+                    );
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_SETITEMDATA,
+                    iSelection,
+                    (LPARAM) pLineConfig
+                    );
+            }
+
+            break;
+
+        case IDC_PORT:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                iSelection = SendDlgItemMessage(
+                    hwnd,
+                    IDC_PORT,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_PORT,
+                    LB_GETTEXT,
+                    iSelection,
+                    (LPARAM) pLineConfig->szPort
+                    );
+            }
+
+            break;
+
+        case IDC_COMMANDS:
+
+            if ((HIWORD(wParam) == EN_CHANGE) && (iSelection != LB_ERR))
+            {
+                GetDlgItemText(
+                    hwnd,
+                    IDC_COMMANDS,
+                    pLineConfig->szCommands,
+                    63
+                    );
+            }
+
+            break;
+
+        case IDC_ADD:
+        {
+            int             iNumLines, i = 2;
+            char            szLineName[32];
+            PDRVLINECONFIG  pLineConfig = DrvAlloc (sizeof(DRVLINECONFIG));
+
+
+            iNumLines = SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_GETCOUNT,
+                0,
+                0
+                );
+
+            lstrcpy (pLineConfig->szPort, "COM1");
+
+            lstrcpy (szLineName, "my new line");
+
+find_unique_line_name:
+
+            if (SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_FINDSTRING,
+                    (WPARAM) -1,
+                    (LPARAM) szLineName
+
+                    ) != LB_ERR)
+            {
+                wsprintf (szLineName, "my new line%d", i++);
+                goto find_unique_line_name;
+            }
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_ADDSTRING,
+                0,
+                (LPARAM) szLineName
+                );
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_SETITEMDATA,
+                iNumLines,
+                (LPARAM) pLineConfig
+                );
+
+            EnableChildren (hwnd, TRUE);
+
+            SelectDevice (hwnd, iNumLines);
+
+            SetFocus (GetDlgItem (hwnd, IDC_NAME));
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_NAME,
+                EM_SETSEL,
+                0,
+                (LPARAM) -1
+                );
+
+            break;
+        }
+        case IDC_REMOVE:
+        {
+            int iNumLines;
+
+
+            DrvFree (pLineConfig);
+
+            iNumLines = SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_DELETESTRING,
+                iSelection,
+                0
+                );
+
+            if (iNumLines == 0)
+            {
+                SetDlgItemText (hwnd, IDC_NAME, "");
+                SetDlgItemText (hwnd, IDC_COMMANDS, "");
+
+                EnableChildren (hwnd, FALSE);
+            }
+            else
+            {
+                SelectDevice (hwnd, 0);
+            }
+
+            break;
+        }
+        case IDOK:
+        {
+            int     i, iNumLines;
+            char   *pBuf;
+
+
+            //
+            // Update the num lines & num phones values
+            //
+
+            pBuf = DrvAlloc (256);
+
+            iNumLines = SendDlgItemMessage(
+                hwnd,
+                IDC_DEVICES,
+                LB_GETCOUNT,
+                0,
+                0
+                );
+
+            RegSetValueEx(
+                hAtspKey,
+                gszNumLines,
+                0,
+                REG_DWORD,
+                (LPBYTE) &iNumLines,
+                sizeof(DWORD)
+                );
+
+
+            //
+            // For each installed device save it's config info
+            //
+
+            for (i = 0; i < iNumLines; i++)
+            {
+                char szLineN[8];
+                PDRVLINECONFIG pLineConfig;
+
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_GETTEXT,
+                    i,
+                    (LPARAM) pBuf
+                    );
+
+                pLineConfig = (PDRVLINECONFIG) SendDlgItemMessage(
+                    hwnd,
+                    IDC_DEVICES,
+                    LB_GETITEMDATA,
+                    i,
+                    0
+                    );
+
+                wsprintf(
+                    pBuf + strlen (pBuf),
+                    ",%s,%s",
+                    pLineConfig->szPort,
+                    pLineConfig->szCommands
+                    );
+
+                wsprintf (szLineN, "Line%d", i);
+
+                RegSetValueEx(
+                    hAtspKey,
+                    szLineN,
+                    0,
+                    REG_SZ,
+                    (LPBYTE) pBuf,
+                    lstrlen (pBuf) + 1
+                    );
+
+                DrvFree (pLineConfig);
+            }
+
+            DrvFree (pBuf);
+
+            // fall thru to EndDialog...
+        }
+        case IDCANCEL:
+
+            RegCloseKey (hAtspKey);
+            EndDialog (hwnd, 0);
+            break;
+
+        } // switch (LOWORD((DWORD)wParam))
+
+        break;
+    }
+    } // switch (msg)
+
+    return FALSE;
+}
+
+
+LPVOID
+PASCAL
+DrvAlloc(
+    DWORD dwSize
+    )
+{
+    return (LocalAlloc (LPTR, dwSize));
+}
+
+
+VOID
+PASCAL
+DrvFree(
+    LPVOID lp
+    )
+{
+    LocalFree (lp);
+}
+
+
+void
+PASCAL
+SetCallState(
+    PDRVLINE    pLine,
+    DWORD       dwCallState,
+    DWORD       dwCallStateMode
+    )
+{
+    if (dwCallState != pLine->dwCallState)
+    {
+        pLine->dwCallState     = dwCallState;
+        pLine->dwCallStateMode = dwCallStateMode;
+
+        (*pLine->pfnEventProc)(
+            pLine->htLine,
+            pLine->htCall,
+            LINE_CALLSTATE,
+            dwCallState,
+            dwCallStateMode,
+            pLine->dwMediaMode
+            );
+    }
+}
+
+
+#if DBG
+
+void
+PASCAL
+Prolog(
+    PFUNC_INFO  pInfo
+    )
+{
+    DWORD i;
+
+
+    DBGOUT((3, "%s: enter", pInfo->lpszFuncName));
+
+    for (i = 0; i < pInfo->dwNumParams; i++)
+    {
+        if (pInfo->aParams[i].dwVal &&
+            pInfo->aParams[i].lpszVal[3] == 'z') // lpszVal = "lpsz..."
+        {
+            DBGOUT((
+                3,
+                "%s%s=x%lx, '%s'",
+                gszTab,
+                pInfo->aParams[i].lpszVal,
+                pInfo->aParams[i].dwVal,
+                pInfo->aParams[i].dwVal
+                ));
+        }
+        else
+        {
+            DBGOUT((
+                3,
+                "%s%s=x%lx",
+                gszTab,
+                pInfo->aParams[i].lpszVal,
+                pInfo->aParams[i].dwVal
+                ));
+        }
+    }
+}
+
+
+LONG
+PASCAL
+Epilog(
+    PFUNC_INFO  pInfo,
+    LONG        lResult
+    )
+{
+    DBGOUT((3, "%s: returning x%x", pInfo->lpszFuncName, lResult));
+
+    return lResult;
+}
+
+
+void
+CDECL
+DebugOutput(
+    DWORD   dwDbgLevel,
+    LPCSTR  lpszFormat,
+    ...
+    )
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[128] = "ATSP32: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[8], lpszFormat, ap);
+
+        lstrcat (buf, "\n");
+
+        OutputDebugString (buf);
+
+        va_end(ap);
+    }
+}
+
+#endif
+
+
+LONG
+PASCAL
+ProviderInstall(
+    char   *pszProviderName,
+    BOOL    bNoMultipleInstance
+    )
+{
+    LONG    lResult;
+
+
+    //
+    // If only one installation instance of this provider is
+    // allowed then we want to check the provider list to see
+    // if the provider is already installed
+    //
+
+    if (bNoMultipleInstance)
+    {
+        LONG                (WINAPI *pfnGetProviderList)();
+        DWORD               dwTotalSize, i;
+        HINSTANCE           hTapi32;
+        LPLINEPROVIDERLIST  pProviderList;
+        LPLINEPROVIDERENTRY pProviderEntry;
+
+
+        //
+        // Load Tapi32.dll & get a pointer to the lineGetProviderList
+        // func.  We don't want to statically link because this module
+        // plays the part of both core SP & UI DLL, and we don't want
+        // to incur the performance hit of automatically loading
+        // Tapi32.dll when running as a core SP within Tapisrv.exe's
+        // context.
+        //
+
+        if (!(hTapi32 = LoadLibrary ("tapi32.dll")))
+        {
+            DBGOUT((
+                1,
+                "LoadLibrary(tapi32.dll) failed, err=%d",
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONFAILED;
+            goto ProviderInstall_return;
+        }
+
+        if (!((FARPROC) pfnGetProviderList = GetProcAddress(
+                hTapi32,
+                (LPCSTR) "lineGetProviderList"
+                )))
+        {
+            DBGOUT((
+                1,
+                "GetProcAddr(lineGetProviderList) failed, err=%d",
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONFAILED;
+            goto ProviderInstall_unloadTapi32;
+        }
+
+
+        //
+        // Loop until we get the full provider list
+        //
+
+        dwTotalSize = sizeof (LINEPROVIDERLIST);
+
+        goto ProviderInstall_allocProviderList;
+
+ProviderInstall_getProviderList:
+
+        if ((lResult = (*pfnGetProviderList)(0x00020000, pProviderList)) != 0)
+        {
+            goto ProviderInstall_freeProviderList;
+        }
+
+        if (pProviderList->dwNeededSize > pProviderList->dwTotalSize)
+        {
+            dwTotalSize = pProviderList->dwNeededSize;
+
+            LocalFree (pProviderList);
+
+ProviderInstall_allocProviderList:
+
+            if (!(pProviderList = LocalAlloc (LPTR, dwTotalSize)))
+            {
+                lResult = LINEERR_NOMEM;
+                goto ProviderInstall_unloadTapi32;
+            }
+
+            pProviderList->dwTotalSize = dwTotalSize;
+
+            goto ProviderInstall_getProviderList;
+        }
+
+
+        //
+        // Inspect the provider list entries to see if this provider
+        // is already installed
+        //
+
+        pProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) pProviderList) +
+            pProviderList->dwProviderListOffset);
+
+        for (i = 0; i < pProviderList->dwNumProviders; i++)
+        {
+            char   *pszInstalledProviderName = ((char *) pProviderList) +
+                        pProviderEntry->dwProviderFilenameOffset,
+                   *p;
+
+
+            //
+            // Make sure pszInstalledProviderName points at <filename>
+            // and not <path>\filename by walking backeards thru the
+            // string searching for last '\\'
+            //
+
+            p = pszInstalledProviderName +
+                lstrlen (pszInstalledProviderName) - 1;
+
+            for (; *p != '\\'  &&  p != pszInstalledProviderName; p--);
+
+            pszInstalledProviderName =
+                (p == pszInstalledProviderName ? p : p + 1);
+
+            if (lstrcmpiA (pszInstalledProviderName, pszProviderName) == 0)
+            {
+                lResult = LINEERR_NOMULTIPLEINSTANCE;
+                goto ProviderInstall_freeProviderList;
+            }
+
+            pProviderEntry++;
+        }
+
+
+        //
+        // If here then the provider isn't currently installed,
+        // so do whatever configuration stuff is necessary and
+        // indicate SUCCESS
+        //
+
+        lResult = 0;
+
+
+ProviderInstall_freeProviderList:
+
+        LocalFree (pProviderList);
+
+ProviderInstall_unloadTapi32:
+
+        FreeLibrary (hTapi32);
+    }
+    else
+    {
+        //
+        // Do whatever configuration stuff is necessary and return SUCCESS
+        //
+
+        lResult = 0;
+    }
+
+ProviderInstall_return:
+
+    return lResult;
+}
+
+
+void
+PASCAL
+DropActiveCall(
+    PDRVLINE    pLine
+    )
+{
+    if (pLine->hComm)
+    {
+        DWORD       dwNumBytes, dwError;
+        OVERLAPPED  overlapped;
+
+
+        pLine->bDropInProgress = TRUE;
+
+        SetEvent (pLine->Overlapped.hEvent);
+
+        ZeroMemory (&overlapped, sizeof (OVERLAPPED));
+
+        overlapped.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
+
+        if (pLine->dwMediaMode != LINEMEDIAMODE_INTERACTIVEVOICE)
+        {
+            if (!WriteFile(
+                    pLine->hComm,
+                    "+++\r", 4,
+                    &dwNumBytes,
+                    &overlapped
+                    ))
+            {
+                if ((dwError = GetLastError()) == ERROR_IO_PENDING)
+                {
+                    GetOverlappedResult(
+                        pLine->hComm,
+                        &overlapped,
+                        &dwNumBytes,
+                        TRUE
+                        );
+
+                    ResetEvent (overlapped.hEvent);
+                }
+                else
+                {
+                }
+            }
+        }
+
+        if (!WriteFile (pLine->hComm, "ATH\r", 4, &dwNumBytes, &overlapped))
+        {
+            if ((dwError = GetLastError()) == ERROR_IO_PENDING)
+            {
+                GetOverlappedResult(
+                    pLine->hComm,
+                    &overlapped,
+                    &dwNumBytes,
+                    TRUE
+                    );
+            }
+            else
+            {
+            }
+        }
+
+        CloseHandle (overlapped.hEvent);
+        CloseHandle (pLine->hComm);
+        pLine->hComm = NULL;
+    }
+}
diff --git a/private/tapi/dev/sp/atsp32/atsp.h b/private/tapi/dev/sp/atsp32/atsp.h
new file mode 100644
index 000000000..000963a6b
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/atsp.h
@@ -0,0 +1,204 @@
+/*++
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    atsp.h
+
+Notes:
+
+--*/
+
+#include <windows.h>
+#include "tapi.h"
+#include "tspi.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+#include "resource.h"
+
+
+#define  MAX_DEV_NAME_LENGTH    63
+#define  ATSP_TIMEOUT           60000   // milliseconds
+
+
+typedef struct _DRVLINE
+{
+    HTAPILINE               htLine;
+
+    LINEEVENT               pfnEventProc;
+
+    DWORD                   dwDeviceID;
+
+    char                    szComm[8];
+
+    HTAPICALL               htCall;
+
+    DWORD                   dwCallState;
+
+    DWORD                   dwCallStateMode;
+
+    DWORD                   dwMediaMode;
+
+    HANDLE                  hComm;
+
+    BOOL                    bDropInProgress;
+
+    OVERLAPPED              Overlapped;
+
+} DRVLINE, FAR *PDRVLINE;
+
+
+typedef struct _DRVLINECONFIG
+{
+    char                    szPort[8];
+
+    char                    szCommands[64];
+
+} DRVLINECONFIG, FAR *PDRVLINECONFIG;
+
+
+typedef struct _ASYNC_REQUEST
+{
+    DWORD                   dwRequestID;
+
+    DWORD                   dwCommand;
+
+    char                    szCommand[32];
+
+    struct _ASYNC_REQUEST  *pNext;
+
+} ASYNC_REQUEST, *PASYNC_REQUEST;
+
+
+#if DBG
+
+typedef struct _FUNC_PARAM
+{
+    char        *lpszVal;
+
+    DWORD       dwVal;
+
+} FUNC_PARAM, *PFUNC_PARAM;
+
+#endif
+
+typedef struct _FUNC_INFO
+{
+
+#if DBG
+
+    char        *lpszFuncName;
+
+    DWORD       dwNumParams;
+
+    PFUNC_PARAM aParams;
+
+#endif
+
+    LONG        lResult;
+
+} FUNC_INFO, *PFUNC_INFO;
+
+
+DWORD               gdwLineDeviceIDBase;
+DWORD               gdwPermanentProviderID;
+HANDLE              ghInst;
+ASYNC_COMPLETION    gpfnCompletionProc;
+
+char gszAtspKey[]      = "Software\\Microsoft\\ATSP";
+char gszNumLines[]     = "NumLines";
+char gszDefLineConfigParams[] = "my new line,COM1,L0";
+
+#if DBG
+
+char gszTab[]          = "    ";
+char gszhdLine[]       = "hdLine";
+char gszhdCall[]       = "hdCall";
+char gszdwSize[]       = "dwSize";
+char gszhwndOwner[]    = "hwndOwner";
+char gszdwDeviceID[]   = "dwDeviceID";
+char gszdwRequestID[]  = "dwRequestID";
+char gszlpCallParams[] = "lpCallParams";
+char gszdwPermanentProviderID[] = "dwPermanentProviderID";
+
+DWORD   gdwDebugLevel = 0;
+
+void
+CDECL
+DebugOutput(
+    DWORD   dwLevel,
+    LPCSTR  lpszFormat,
+    ...
+    );
+
+#define DBGOUT(arg) DebugOutput arg
+
+LONG
+PASCAL
+Epilog(
+    PFUNC_INFO  pInfo,
+    LONG        lResult
+    );
+
+void
+PASCAL
+Prolog(
+    PFUNC_INFO  pInfo
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#define Epilog(pAsyncRequestInfo, lResult) (lResult)
+
+#define Prolog(pAsyncRequestInfo)
+
+#endif
+
+
+LPVOID
+PASCAL
+DrvAlloc(
+    DWORD dwSize
+    );
+
+VOID
+PASCAL
+DrvFree(
+    LPVOID lp
+    );
+
+void
+PASCAL
+SetCallState(
+    PDRVLINE    pLine,
+    DWORD       dwCallState,
+    DWORD       dwCallStateMode
+    );
+
+BOOL
+CALLBACK
+ConfigDlgProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+LONG
+PASCAL
+ProviderInstall(
+    char   *pszProviderName,
+    BOOL    bNoMultipleInstance
+    );
+
+void
+PASCAL
+DropActiveCall(
+    PDRVLINE    pLine
+    );
diff --git a/private/tapi/dev/sp/atsp32/atsp.rc b/private/tapi/dev/sp/atsp32/atsp.rc
new file mode 100644
index 000000000..115761219
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/atsp.rc
@@ -0,0 +1,45 @@
+#include "windows.h"
+#include "resource.h"
+
+IDD_DIALOG1 DIALOG 6, 18, 176, 128
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "ATSP Configuration"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Installed lines:", 101, 4, 6, 54, 8
+    LISTBOX         IDC_DEVICES, 4, 16, 120, 30, WS_VSCROLL | WS_TABSTOP
+
+    GROUPBOX        "Line properties", 103, 4,  46,  120, 76
+
+    LTEXT           "Name:", 113,           7,  64,  26,  8
+    EDITTEXT        IDC_NAME,               38, 62,  80,  12, ES_AUTOHSCROLL
+
+    LTEXT           "Port:", 104,           7,  81,  19,  8
+    LISTBOX         IDC_PORT,               38, 80,  44,  26, WS_VSCROLL | WS_TABSTOP
+
+    LTEXT           "Extra", 105,           7,  101, 25,  8
+    LTEXT           "settings:", 114,       7,  109, 30,  8
+    EDITTEXT        IDC_COMMANDS,           38, 104, 80,  12, ES_AUTOHSCROLL
+
+    PUSHBUTTON      "Add", IDC_ADD, 130, 16, 40, 14
+    PUSHBUTTON      "Remove", IDC_REMOVE, 130, 35, 40, 14
+    PUSHBUTTON      "OK", IDOK, 130, 55, 40, 14
+    PUSHBUTTON      "Cancel", IDCANCEL, 130, 74, 40, 14
+END
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) 32bit AT-Compatible Modem Service Provider"
+#define VER_INTERNALNAME_STR        "atsp32"
+#define VER_ORIGINALFILENAME_STR    "ATSP32.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/atsp32/atsp32.def b/private/tapi/dev/sp/atsp32/atsp32.def
new file mode 100644
index 000000000..a991154ad
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/atsp32.def
@@ -0,0 +1,42 @@
+LIBRARY         ATSP32
+PROTMODE
+CODE            PRELOAD FIXED
+DATA            PRELOAD FIXED
+
+
+EXPORTS
+
+        TSPI_lineClose
+        TSPI_lineCloseCall
+        TSPI_lineConditionalMediaDetection
+        TSPI_lineDrop
+        TSPI_lineGetAddressCaps
+        TSPI_lineGetAddressStatus
+        TSPI_lineGetCallAddressID
+        TSPI_lineGetCallInfo
+        TSPI_lineGetCallStatus
+        TSPI_lineGetDevCaps
+        TSPI_lineGetID
+        TSPI_lineGetLineDevStatus
+        TSPI_lineGetNumAddressIDs
+        TSPI_lineMakeCall
+        TSPI_lineNegotiateTSPIVersion
+        TSPI_lineOpen
+        TSPI_lineSetDefaultMediaDetection
+
+        TSPI_providerConfig
+        TSPI_providerInit
+        TSPI_providerInstall
+        TSPI_providerRemove
+        TSPI_providerShutdown
+        TSPI_providerEnumDevices
+
+        TSPI_providerGenericDialogData
+        TSPI_providerUIIdentify
+
+        TUISPI_lineConfigDialog
+        TUISPI_providerConfig
+        TUISPI_providerInstall
+        TUISPI_providerRemove
+
+        ConfigDlgProc
diff --git a/private/tapi/dev/sp/atsp32/depend.mk b/private/tapi/dev/sp/atsp32/depend.mk
new file mode 100644
index 000000000..1163364ff
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/depend.mk
@@ -0,0 +1,3 @@
+.\atsp.obj: ..\atsp.c ..\atsp.h ..\resource.h
+
+.\atsp.res: ..\atsp.rc ..\resource.h
diff --git a/private/tapi/dev/sp/atsp32/dialogs.dlg b/private/tapi/dev/sp/atsp32/dialogs.dlg
new file mode 100644
index 000000000..5809e0054
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/dialogs.dlg
@@ -0,0 +1,22 @@
+#include "resource.h"
+
+100 DIALOG 6, 18, 184, 111
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "ATSP32 Device Configuration"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Installed devices:", 101, 8, 8, 61, 8
+    LISTBOX         IDC_DEVICES, 72, 7, 104, 20, WS_VSCROLL | WS_TABSTOP
+    GROUPBOX        "Device", 111, 8, 27, 168, 63
+    LTEXT           "Description:", 102, 16, 41, 45, 8
+    EDITTEXT        IDC_DESCRIPTION, 72, 40, 96, 9, ES_AUTOHSCROLL
+    LTEXT           "Port:", 103, 16, 57, 20, 8
+    LISTBOX         IDC_PORT, 72, 56, 96, 11, LBS_SORT | WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Commands:", 104, 16, 73, 47, 8
+    EDITTEXT        IDC_COMMANDS, 72, 72, 96, 10, ES_AUTOHSCROLL
+    PUSHBUTTON      "Add", IDC_ADD, 8, 94, 40, 14
+    PUSHBUTTON      "Remove", IDC_REMOVE, 50, 94, 40, 14
+    PUSHBUTTON      "OK", IDOK, 93, 94, 40, 14
+    PUSHBUTTON      "Cancel", IDCANCEL, 136, 94, 40, 14
+END
diff --git a/private/tapi/dev/sp/atsp32/makefile b/private/tapi/dev/sp/atsp32/makefile
new file mode 100644
index 000000000..707a71e8b
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   atsp32 Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/atsp32/makefile.def b/private/tapi/dev/sp/atsp32/makefile.def
new file mode 100644
index 000000000..0b6f58439
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/makefile.def
@@ -0,0 +1,67 @@
+##############################################################################
+#
+#   atsp32.tsp Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+WANT_C932=1
+#WANT_C1032=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+BUILDDLL=1
+DLLENTRY=DllMain
+
+DEPENDNAME=..\depend.mk
+
+CLEANLIST=*.tsp
+
+TARGETS=atsp32.tsp
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+
+L32EXE=atsp32.tsp		# Name of exe.
+L32DEF=..\atsp32.def              # Our def file.
+L32MAP=atsp32.map		# Our map file.
+L32SYM=atsp32.sym		# Our sym file.
+L32LIBS=\
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\gdi32.lib                  \
+        $(W32LIBID)\advapi32.lib                \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib     \
+        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib
+
+
+
+L32RES=atsp.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = atsp.obj
+
+
+L32FLAGS=$(L32FLAGS)
+
+
+!include $(ROOT)\dev\master.mk
+
+INCLUDE=..;..\..\..\client;..\..\..\server;$(INCLUDE)
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc -GD
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Ox
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/atsp32/resource.h b/private/tapi/dev/sp/atsp32/resource.h
new file mode 100644
index 000000000..1c54fcb2d
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/resource.h
@@ -0,0 +1,7 @@
+#define IDD_DIALOG1     101
+#define IDC_DEVICES     1001
+#define IDC_NAME        1002
+#define IDC_PORT        1003
+#define IDC_COMMANDS    1004
+#define IDC_ADD         1005
+#define IDC_REMOVE      1006
diff --git a/private/tapi/dev/sp/atsp32/sources b/private/tapi/dev/sp/atsp32/sources
new file mode 100644
index 000000000..023525573
--- /dev/null
+++ b/private/tapi/dev/sp/atsp32/sources
@@ -0,0 +1,54 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=atsp32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=TSP
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\gdi32.lib
+
+DLLBASE=0x61000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+SOURCES=atsp.c    \
+        atsp.rc
+
+C_DEFINES=-DTAPI_NT=1
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/dirs b/private/tapi/dev/sp/dirs
new file mode 100644
index 000000000..467867ebb
--- /dev/null
+++ b/private/tapi/dev/sp/dirs
@@ -0,0 +1,26 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     atsp32   \
+     esp.new  \
+     kmddsp
diff --git a/private/tapi/dev/sp/esp.new/dirs b/private/tapi/dev/sp/esp.new/dirs
new file mode 100644
index 000000000..f304d7bc5
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/dirs
@@ -0,0 +1,26 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     tsp         \
+     exe         \
+     ui
diff --git a/private/tapi/dev/sp/esp.new/espidl.acf b/private/tapi/dev/sp/esp.new/espidl.acf
new file mode 100644
index 000000000..be47cd031
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/espidl.acf
@@ -0,0 +1,5 @@
+[implicit_handle(handle_t hEsp)]
+interface esp
+{
+
+}
diff --git a/private/tapi/dev/sp/esp.new/espidl.idl b/private/tapi/dev/sp/esp.new/espidl.idl
new file mode 100644
index 000000000..eb0e8d03e
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/espidl.idl
@@ -0,0 +1,66 @@
+[ uuid(2F5F6521-CA47-1068-B31A-00DD010662DB),
+  version(1.0),
+#ifdef __midl
+        ms_union,
+#endif // __midl
+  pointer_default(unique)
+]
+
+interface esp
+
+{
+
+long
+ESPAttach(
+    [in]    long    lProcessID,
+    [out]   long   *phShutdownEvent,
+    [out]   long   *phDebugOutputEvent,
+    [out]   long   *phWidgetEventsEvent
+    );
+
+void
+ESPSetOptions(
+    [in]    long    lDebugOptions,
+    [in]    long    lCompletionMode
+    );
+
+void
+ESPCompleteRequest(
+    [in]    long    lAsyncReqInfo,
+    [in]    long    lResult
+    );
+
+long
+ESPEvent(
+    [in]    long    htDevice,
+    [in]    long    htCall,
+    [in]    long    dwMsg,
+    [in]    long    dwParam1,
+    [in]    long    dwParam2,
+    [in]    long    dwParam3
+    );
+
+void
+ESPGetDebugOutput(
+    [out, length_is(*plSize), size_is(*plSize)] char pBuffer[],
+    [in, out]   long   *plSize
+    );
+
+void
+ESPGetWidgetEvents(
+    [out, length_is(*plSize), size_is(*plSize)] char pBuffer[],
+    [in, out]   long   *plSize
+    );
+
+long
+ESPStartPBXThread(
+    [in, length_is(lSize), size_is(lSize)] char pBuffer[],
+    [in]    long    lSize
+    );
+
+long
+ESPStopPBXThread(
+    [in]    long    dummy
+    );
+
+}
diff --git a/private/tapi/dev/sp/esp.new/exe/esp.ico b/private/tapi/dev/sp/esp.new/exe/esp.ico
new file mode 100644
index 000000000..516eb3f84
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/esp.ico
diff --git a/private/tapi/dev/sp/esp.new/exe/espexe.c b/private/tapi/dev/sp/esp.new/exe/espexe.c
new file mode 100644
index 000000000..97c95e9e9
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/espexe.c
@@ -0,0 +1,3351 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    espexe.c
+
+Abstract:
+
+
+
+Author:
+
+    Dan Knudson (DanKn)    15-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "espexe.h"
+
+
+int
+WINAPI
+WinMain(
+    HINSTANCE   hInstance,
+    HINSTANCE   hPrevInstance,
+    LPSTR       lpCmdLine,
+    int         nCmdShow
+    )
+{
+    MSG msg;
+    HACCEL  hAccel;
+
+
+    ghInstance = hInstance;
+
+    ghwndMain = CreateDialog(
+        ghInstance,
+        (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG1),
+        (HWND)NULL,
+        (DLGPROC) MainWndProc
+        );
+
+    if (!ghwndMain)
+    {
+    }
+
+    hAccel = LoadAccelerators(
+        ghInstance,
+        (LPCSTR)MAKEINTRESOURCE(IDR_ACCELERATOR1)
+        );
+
+    while (GetMessage (&msg, (HWND) NULL, 0, 0))
+    {
+        if (!TranslateAccelerator (ghwndMain, hAccel, &msg))
+        {
+            TranslateMessage (&msg);
+            DispatchMessage (&msg);
+        }
+    }
+
+    DestroyWindow (ghwndMain);
+
+    DestroyAcceleratorTable (hAccel);
+
+    return 0;
+}
+
+
+void
+ESPServiceThread(
+    LPVOID  pParams
+    )
+{
+    HANDLE  hInitEvent;
+
+
+    ShowStr ("ESPServiceThread: enter");
+
+    hInitEvent = CreateEvent(
+        (LPSECURITY_ATTRIBUTES) NULL,
+        FALSE,      // auto-reset
+        FALSE,      // non-signaled
+        "ESPevent"
+        );
+
+    while (1)
+    {
+        HANDLE  ahEvents[3];
+
+
+wait_for_esp_to_init:
+
+        gbESPLoaded = FALSE;
+
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON1), FALSE);
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON2), FALSE);
+
+
+        //
+        //
+        //
+
+        {
+            DWORD       dwUsedSize;
+            RPC_STATUS  status;
+
+            #define CNLEN              25   // computer name length
+            #define UNCLEN        CNLEN+2   // \\computername
+            #define PATHLEN           260   // Path
+            #define MAXPROTSEQ         20   // protocol sequence "ncacn_np"
+
+            unsigned char   pszNetworkAddress[UNCLEN+1];
+            unsigned char * pszUuid          = NULL;
+            unsigned char * pszOptions       = NULL;
+            unsigned char * pszStringBinding = NULL;
+
+
+            pszNetworkAddress[0] = '\0';
+
+            status = RpcStringBindingCompose(
+                pszUuid,
+                "ncalrpc",
+                pszNetworkAddress,
+                "esplpc",
+                pszOptions,
+                &pszStringBinding
+                );
+
+            if (status)
+            {
+                ShowStr(
+                    "RpcStringBindingCompose failed: err=%d, szNetAddr='%s'",
+                    status,
+                    pszNetworkAddress
+                    );
+            }
+
+            status = RpcBindingFromStringBinding(
+                pszStringBinding,
+                &hEsp
+                );
+
+            if (status)
+            {
+                ShowStr(
+                    "RpcBindingFromStringBinding failed, err=%d, szBinding='%s'",
+                    status,
+                    pszStringBinding
+                    );
+            }
+
+            RpcStringFree  (&pszStringBinding);
+        }
+
+        ShowStr ("ESPServiceThread: waiting for esp init event");
+
+        WaitForSingleObject (hInitEvent, INFINITE);
+
+
+        RpcTryExcept
+        {
+            ESPAttach(
+                (long) GetCurrentProcessId(),
+                (long *) ahEvents,      // &hShutdownEvent
+                (long *) ahEvents + 1,  // &hDebugOutputEvent
+                (long *) ahEvents + 2   // &hWidgetEventsEvent
+                );
+        }
+        RpcExcept (1)
+        {
+            // BUGBUG
+        }
+        RpcEndExcept
+
+        gbESPLoaded = TRUE;
+
+        UpdateESPOptions();
+
+        gbPBXThreadRunning = FALSE;
+        EnableMenuItem (ghMenu, IDM_PBXSTART, MF_BYCOMMAND | MF_ENABLED);
+
+        ShowStr ("ESPServiceThread: esp init event signaled, attached to esp");
+
+        gpWidgets = NULL;
+
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON1), TRUE);
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON2), TRUE);
+
+
+        //
+        //
+        //
+
+        {
+            DWORD   dwBufSize = 50 * sizeof (WIDGETEVENT);
+            char   *buf = MyAlloc (dwBufSize);
+
+
+            while (1)
+            {
+                switch (WaitForMultipleObjects (3, ahEvents, FALSE, INFINITE))
+                {
+                case WAIT_OBJECT_0+1:
+                {
+                    DWORD   dwSize;
+
+get_debug_output:
+                    dwSize = dwBufSize - 1;
+
+                    RpcTryExcept
+                    {
+                        ESPGetDebugOutput (buf, &dwSize);
+                    }
+                    RpcExcept (1)
+                    {
+                        break; // BUGBUG
+                    }
+                    RpcEndExcept
+
+                    buf[dwSize] = 0;
+
+                    xxxShowStr (buf);
+
+                    if (dwSize == (dwBufSize - 1))
+                    {
+                        char *newBuf;
+
+
+                        if ((newBuf = MyAlloc (2*dwBufSize)))
+                        {
+                            MyFree (buf);
+                            buf = newBuf;
+                            dwBufSize *= 2;
+                        }
+
+                        goto get_debug_output;
+                    }
+
+                    break;
+                }
+                case WAIT_OBJECT_0+2:
+                {
+                    DWORD           dwSize, i, dwNumEvents;
+                    PWIDGETEVENT    pEvent;
+
+get_widget_events:
+                    dwSize = dwBufSize;
+
+                    RpcTryExcept
+                    {
+                        ESPGetWidgetEvents (buf, &dwSize);
+                    }
+                    RpcExcept (1)
+                    {
+                        break; // BUGBUG
+                    }
+                    RpcEndExcept
+
+                    dwNumEvents = dwSize / sizeof (WIDGETEVENT);
+
+                    pEvent = (PWIDGETEVENT) buf;
+
+                    for (i = 0; i < dwNumEvents; i++)
+                    {
+                        ProcessWidgetEvent (pEvent++);
+                    }
+
+                    if (dwSize == dwBufSize)
+                    {
+                        goto get_widget_events;
+                    }
+
+                    break;
+                }
+                default:
+
+                    RpcBindingFree (&hEsp);
+
+                    SaveIniFileSettings();
+
+                    CloseHandle (ahEvents[0]);
+                    CloseHandle (ahEvents[1]);
+                    CloseHandle (ahEvents[2]);
+
+                    MyFree (buf);
+
+                    SendMessage (ghwndList1, LB_RESETCONTENT, 0, 0);
+
+                    while (gpWidgets)
+                    {
+                        PMYWIDGET   pNextWidget = gpWidgets->pNext;
+
+
+                        MyFree (gpWidgets);
+                        gpWidgets = pNextWidget;
+                    }
+
+                    // BUGBUG disable lots of menuitems, etc.
+
+                    EnableMenuItem(
+                        ghMenu,
+                        IDM_PBXSTART,
+                        MF_BYCOMMAND | MF_GRAYED
+                        );
+
+                    EnableMenuItem(
+                        ghMenu,
+                        IDM_PBXSTOP,
+                        MF_BYCOMMAND | MF_GRAYED
+                        );
+
+                    if (gbAutoClose)
+                    {
+                        gbESPLoaded = FALSE;
+                        PostMessage (ghwndMain, WM_CLOSE, 0, 0);
+                        goto ESPServiceThread_exit;
+                    }
+
+                    goto wait_for_esp_to_init;
+
+                } // switch (WaitForMultipleObjects (...))
+
+            } // while (1)
+        }
+
+    } // while (1)
+
+ESPServiceThread_exit:
+
+    CloseHandle (hInitEvent);
+
+    ExitThread (0);
+}
+
+
+BOOL
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static int      icyButton, icyBorder, cyWnd;
+    static BOOL     bCaptured = FALSE;
+    static LONG     xCapture, cxVScroll;
+    static HFONT    hFont;
+    static HICON    hIcon;
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        char buf[64];
+        RECT rect;
+
+
+        //
+        // Init some globals
+        //
+
+        hIcon = LoadIcon (ghInstance, MAKEINTRESOURCE(IDI_ICON1));
+
+        ghwndMain  = hwnd;
+        ghwndList1 = GetDlgItem (hwnd, IDC_LIST1);
+        ghwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+        ghwndEdit  = GetDlgItem (hwnd, IDC_EDIT1);
+        ghMenu     = GetMenu (hwnd);
+
+        icyBorder = GetSystemMetrics (SM_CYFRAME);
+        GetWindowRect (GetDlgItem (hwnd, IDC_BUTTON1), &rect);
+        icyButton = (rect.bottom - rect.top) + icyBorder + 3;
+        cxVScroll = 2*GetSystemMetrics (SM_CXVSCROLL);
+
+        gbPBXThreadRunning = FALSE;
+
+        EnableMenuItem (ghMenu, IDM_PBXSTART, MF_BYCOMMAND | MF_GRAYED);
+        EnableMenuItem (ghMenu, IDM_PBXSTOP, MF_BYCOMMAND | MF_GRAYED);
+
+
+        //
+        //
+        //
+
+        {
+            typedef struct _XXX
+            {
+                DWORD    dwDefValue;
+
+                LPCSTR   pszValueName;
+
+                LPDWORD  pdwValue;
+
+            } XXX, *PXXX;
+
+            XXX axxx[] =
+            {
+                { DEF_SPI_VERSION,          "TSPIVersion",      &gdwTSPIVersion },
+                { 0,                        "AutoClose",        &gbAutoClose },
+                { DEF_NUM_LINES,            "NumLines",         &gdwNumLines },
+                { DEF_NUM_ADDRS_PER_LINE,   "NumAddrsPerLine",  &gdwNumAddrsPerLine },
+                { DEF_NUM_CALLS_PER_ADDR,   "NumCallsPerAddr",  &gdwNumCallsPerAddr },
+                { DEF_NUM_PHONES,           "NumPhones",        &gdwNumPhones },
+                { DEF_DEBUG_OPTIONS,        "DebugOutput",      &gdwDebugOptions },
+                { DEF_COMPLETION_MODE,      "Completion",       &gdwCompletionMode },
+                { 0,                        "DisableUI",        &gbDisableUI },
+                { 1,                        "AutoGatherGenerateMsgs",   &gbAutoGatherGenerateMsgs },
+                { 0,                        NULL,               NULL },
+            };
+            DWORD   i;
+
+            for (i = 0; axxx[i].pszValueName; i++)
+            {
+                *(axxx[i].pdwValue) = (DWORD) GetProfileInt(
+                    szMySection,
+                    axxx[i].pszValueName,
+                    (int) axxx[i].dwDefValue
+                    );
+            }
+
+            for (i = 0; i < 6; i++)
+            {
+                if (gdwDebugOptions & (0x1 << i))
+                {
+                    CheckMenuItem(
+                        ghMenu,
+                        IDM_SHOWFUNCENTRY + i,
+                        MF_BYCOMMAND | MF_CHECKED
+                        );
+                }
+            }
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SYNCCOMPL + gdwCompletionMode,
+                MF_BYCOMMAND | MF_CHECKED
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_AUTOCLOSE,
+                MF_BYCOMMAND | (gbAutoClose ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_AUTOGATHERGENERATEMSGS,
+                MF_BYCOMMAND |
+                    (gbAutoGatherGenerateMsgs ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_DISABLEUI,
+                MF_BYCOMMAND | (gbDisableUI ? MF_CHECKED : MF_UNCHECKED)
+                );
+        }
+
+
+        //
+        // Set control fonts
+        //
+
+        {
+            HWND hwndCtrl = GetDlgItem (hwnd, IDC_BUTTON1);
+            hFont = CreateFont(
+                13, 5, 0, 0, 400, 0, 0, 0, 0, 1, 2, 1, 34, "MS Sans Serif"
+                );
+
+            do
+            {
+                SendMessage(
+                    hwndCtrl,
+                    WM_SETFONT,
+                    (WPARAM) hFont,
+                    0
+                    );
+
+            } while ((hwndCtrl = GetNextWindow (hwndCtrl, GW_HWNDNEXT)));
+        }
+
+
+        //
+        // Read in control size ratios
+        //
+
+        cxWnd   = GetProfileInt (szMySection, "cxWnd",   100);
+        cxList1 = GetProfileInt (szMySection, "cxList1", 25);
+
+
+        //
+        // Send self WM_SIZE to position child controls correctly
+        //
+
+        GetProfileString(
+            szMySection,
+            "Left",
+            "0",
+            buf,
+            63
+            );
+
+        if (strcmp (buf, "max") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMAXIMIZED);
+        }
+        else if (strcmp (buf, "min") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMINIMIZED);
+        }
+        else
+        {
+            int left, top, right, bottom;
+            int cxScreen = GetSystemMetrics (SM_CXSCREEN);
+            int cyScreen = GetSystemMetrics (SM_CYSCREEN);
+
+
+            left   = GetProfileInt (szMySection, "Left",   0);
+            top    = GetProfileInt (szMySection, "Top",    3*cyScreen/4);
+            right  = GetProfileInt (szMySection, "Right",  cxScreen);
+            bottom = GetProfileInt (szMySection, "Bottom", cyScreen);
+
+            SetWindowPos(
+                hwnd,
+                HWND_TOP,
+                left,
+                top,
+                right - left,
+                bottom - top,
+                SWP_SHOWWINDOW
+                );
+
+            GetClientRect (hwnd, &rect);
+
+            SendMessage(
+                hwnd,
+                WM_SIZE,
+                0,
+                MAKELONG((rect.right-rect.left),(rect.bottom-rect.top))
+                );
+
+            ShowWindow (hwnd, SW_SHOW);
+        }
+
+
+        //
+        // Start the service thread
+        //
+
+        {
+            DWORD   dwThreadID;
+            HANDLE  hThread;
+
+
+            hThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) ESPServiceThread,
+                NULL,
+                0,
+                &dwThreadID
+                );
+
+            SetThreadPriority (hThread, THREAD_PRIORITY_ABOVE_NORMAL);
+
+            CloseHandle (hThread);
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        UINT uiCtrlID = (UINT) LOWORD((DWORD)wParam);
+
+
+        switch (uiCtrlID)
+        {
+        case IDM_INSTALL:
+        case IDM_UNINSTALL:
+        {
+            BOOL                bESPInstalled = FALSE;
+            LONG                lResult;
+            DWORD               i;
+            FARPROC             pfnLineGetProviderList, pfnLineAddProvider,
+                                pfnLineRemoveProvider;
+            HINSTANCE           hTapi32;
+            LINEPROVIDERLIST    providerList, *pProviderList;
+            LPLINEPROVIDERENTRY pProviderEntry;
+
+
+            if (!(hTapi32 = LoadLibrary ("tapi32.dll")))
+            {
+                ShowStr(
+                    "LoadLibrary(tapi32.dll) failed, err=%d",
+                    GetLastError()
+                    );
+
+                break;
+            }
+
+            if (!(pfnLineAddProvider = GetProcAddress(
+                    hTapi32,
+                    "lineAddProvider"
+                    )) ||
+
+                !(pfnLineGetProviderList = GetProcAddress(
+                    hTapi32,
+                    "lineGetProviderList"
+                    )) ||
+
+                !(pfnLineRemoveProvider = GetProcAddress(
+                    hTapi32,
+                    "lineRemoveProvider"
+                    )))
+            {
+                ShowStr(
+                    "GetProcAddr(tapi32,lineAddProvider) failed, err=%d",
+                    GetLastError()
+                    );
+
+                goto install_free_tapi32;
+            }
+
+            providerList.dwTotalSize = sizeof (LINEPROVIDERLIST);
+
+            if ((lResult = (*pfnLineGetProviderList)(0x20000, &providerList)))
+            {
+                ShowStr(
+                    "ESP (Un)Install: error, lineGetProviderList returned x%x",
+                    lResult
+                    );
+
+                goto install_free_tapi32;
+            }
+
+            pProviderList = MyAlloc (providerList.dwNeededSize);
+
+            pProviderList->dwTotalSize = providerList.dwNeededSize;
+
+            if ((lResult = (*pfnLineGetProviderList)(0x20000, pProviderList)))
+            {
+                ShowStr(
+                    "ESP (Un)Install: error, lineGetProviderList returned x%x",
+                    lResult
+                    );
+
+                goto install_free_provider_list;
+            }
+
+            pProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) pProviderList) +
+                pProviderList->dwProviderListOffset);
+
+            for (i = 0; i < pProviderList->dwNumProviders; i++)
+            {
+                int     j;
+                char   *pszProviderName = (char *) (((LPBYTE) pProviderList) +
+                            pProviderEntry->dwProviderFilenameOffset);
+
+
+                //
+                // Convert the string to lower case, then see if it
+                // contains "esp32.tsp"
+                //
+
+                for (j = 0; pszProviderName[j]; j++)
+                {
+                    pszProviderName[j] |= 0x20;
+                }
+
+                if (strstr (pszProviderName, "esp32.tsp"))
+                {
+                    bESPInstalled = TRUE;
+                    break;
+                }
+
+                pProviderEntry++;
+            }
+
+            if (uiCtrlID == IDM_INSTALL)
+            {
+                if (bESPInstalled)
+                {
+                    ShowStr ("ESP Install: already installed");
+                }
+                else
+                {
+                    DWORD dwPermanentProviderID;
+
+
+                    if ((lResult = (*pfnLineAddProvider)(
+                            "esp32.tsp",
+                            hwnd,
+                            &dwPermanentProviderID
+
+                            )) == 0)
+                    {
+                        ShowStr(
+                            "ESP Install: success, ProviderID=%d",
+                            dwPermanentProviderID
+                            );
+                    }
+                    else
+                    {
+                        ShowStr(
+                            "ESP Install: error, lineAddProvider returned x%x",
+                            lResult
+                            );
+                    }
+                }
+            }
+            else // IDM_UNINSTALL
+            {
+                if (bESPInstalled)
+                {
+                    if ((lResult = (*pfnLineRemoveProvider)(
+                            pProviderEntry->dwPermanentProviderID,
+                            hwnd
+
+                            )) == 0)
+                    {
+                        ShowStr ("ESP Uninstall: success");
+                    }
+                    else
+                    {
+                        ShowStr(
+                            "ESP Uninstall: error, lineRemoveProvider " \
+                                "returned x%x",
+                            lResult
+                            );
+                    }
+                }
+                else
+                {
+                    ShowStr ("ESP Uninstall: not installed");
+                }
+            }
+
+install_free_provider_list:
+
+            MyFree (pProviderList);
+
+install_free_tapi32:
+
+            FreeLibrary (hTapi32);
+
+            break;
+        }
+        case IDM_AUTOCLOSE:
+        {
+            gbAutoClose = (gbAutoClose ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_AUTOCLOSE,
+                MF_BYCOMMAND | (gbAutoClose ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            SaveIniFileSettings();
+            break;
+        }
+        case IDM_AUTOGATHERGENERATEMSGS:
+        {
+            gbAutoGatherGenerateMsgs =
+                (gbAutoGatherGenerateMsgs ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_AUTOGATHERGENERATEMSGS,
+                MF_BYCOMMAND |
+                    (gbAutoGatherGenerateMsgs ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            SaveIniFileSettings();
+            break;
+        }
+        case IDM_DISABLEUI:
+        {
+            gbDisableUI = (gbDisableUI ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_DISABLEUI,
+                MF_BYCOMMAND | (gbDisableUI ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            SaveIniFileSettings();
+            break;
+        }
+        case IDM_DEFAULTS:
+        {
+            EVENT_PARAM params[] =
+            {
+                { "TSPI Version",       PT_ORDINAL,   gdwTSPIVersion, aVersions },
+                { "Num lines",          PT_DWORD,     gdwNumLines, 0 },
+                { "Num addrs per line", PT_DWORD,     gdwNumAddrsPerLine, 0 },
+                { "Num calls per addr", PT_DWORD,     gdwNumCallsPerAddr, 0 },
+                { "Num phones",         PT_DWORD,     gdwNumPhones, 0 },
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 5, "Default values", 0, params };
+
+
+            if (DialogBoxParam(
+                    ghInstance,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    hwnd,
+                    (DLGPROC) ValuesDlgProc,
+                    (LPARAM) &paramsHeader
+
+                    ) == IDOK)
+            {
+                char *aszValueNames[] =
+                {
+                    "TSPIVersion",
+                    "NumLines",
+                    "NumAddrsPerLine",
+                    "NumCallsPerAddr",
+                    "NumPhones",
+                    NULL
+                };
+                LPDWORD lpdwValues[] =
+                {
+                    &gdwTSPIVersion,
+                    &gdwNumLines,
+                    &gdwNumAddrsPerLine,
+                    &gdwNumCallsPerAddr,
+                    &gdwNumPhones
+                };
+                int i;
+                BOOL bValuesChanged = FALSE;
+
+
+                for (i = 0; aszValueNames[i]; i++)
+                {
+                    char buf[16];
+
+                    if (*(lpdwValues[i]) != params[i].dwValue)
+                    {
+                        *(lpdwValues[i]) = params[i].dwValue;
+
+                        wsprintf (buf, "%d", params[i].dwValue);
+
+                        WriteProfileString(
+                            szMySection,
+                            aszValueNames[i],
+                            buf
+                            );
+
+                        bValuesChanged = TRUE;
+                    }
+                }
+
+                if (bValuesChanged && gbESPLoaded)
+                {
+                    MessageBox(
+                        hwnd,
+                        "New values will not take effect until provider is" \
+                            " shutdown and reinitialized",
+                        "ESP Defaults",
+                        MB_OK
+                        );
+                }
+            }
+
+            break;
+        }
+        case IDC_BUTTON1:
+        {
+            LONG lSel;
+            EVENT_PARAM params[] =
+            {
+                { "htLine",   PT_DWORD,   0, 0 },
+                { "htCall",   PT_DWORD,   0, 0 },
+                { "dwMsg",    PT_ORDINAL, 0, aLineMsgs },
+                { "dwParam1", PT_DWORD,   0, 0 },
+                { "dwParam2", PT_DWORD,   0, 0 },
+                { "dwParam3", PT_DWORD,   0, 0 },
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 6, "Line event", 0, params };
+
+
+            lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+
+            if (lSel != LB_ERR)
+            {
+                PMYWIDGET pWidget;
+
+
+                pWidget = (PMYWIDGET) SendMessage(
+                    ghwndList1,
+                    LB_GETITEMDATA,
+                    lSel,
+                    0
+                    );
+
+                if (pWidget->dwWidgetType == WIDGETTYPE_LINE)
+                {
+                    params[0].dwValue =
+                    params[0].dwDefValue = pWidget->htXxx;
+                }
+                else if (pWidget->dwWidgetType == WIDGETTYPE_CALL)
+                {
+                    params[1].dwValue =
+                    params[1].dwDefValue = pWidget->htXxx;
+
+                    do
+                    {
+                        pWidget = pWidget->pPrev;
+                    }
+                    while (pWidget->dwWidgetType != WIDGETTYPE_LINE);
+
+                    params[0].dwValue =
+                    params[0].dwDefValue = pWidget->htXxx;
+                }
+            }
+
+            if (DialogBoxParam(
+                    ghInstance,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    hwnd,
+                    (DLGPROC) ValuesDlgProc,
+                    (LPARAM) &paramsHeader
+
+                    ) == IDOK)
+            {
+                ESPEvent(
+                    params[0].dwValue,
+                    params[1].dwValue,
+                    params[2].dwValue,
+                    params[3].dwValue,
+                    params[4].dwValue,
+                    params[5].dwValue
+                    );
+            }
+
+            break;
+        }
+        case IDC_BUTTON2:
+        {
+            LONG lSel;
+            EVENT_PARAM params[] =
+            {
+                { "htPhone",  PT_DWORD,   0, 0 },
+                { "dwMsg",    PT_ORDINAL, 0, aPhoneMsgs },
+                { "dwParam1", PT_DWORD,   0, 0 },
+                { "dwParam2", PT_DWORD,   0, 0 },
+                { "dwParam3", PT_DWORD,   0, 0 },
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 5, "Phone event", 0, params };
+
+
+            lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+
+            if (lSel != LB_ERR)
+            {
+                PMYWIDGET pWidget;
+
+
+                pWidget = (PMYWIDGET) SendMessage(
+                    ghwndList1,
+                    LB_GETITEMDATA,
+                    lSel,
+                    0
+                    );
+
+                if (pWidget->dwWidgetType == WIDGETTYPE_PHONE)
+                {
+                    params[0].dwValue =
+                    params[0].dwDefValue = pWidget->htXxx;
+                }
+            }
+
+            if (DialogBoxParam(
+                    ghInstance,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    hwnd,
+                    (DLGPROC) ValuesDlgProc,
+                    (LPARAM) &paramsHeader
+
+                    ) == IDOK)
+            {
+                ESPEvent(
+                    params[0].dwValue,
+                    0,
+                    params[1].dwValue,
+                    params[2].dwValue,
+                    params[3].dwValue,
+                    params[4].dwValue
+                    );
+            }
+
+            break;
+        }
+        case IDC_ENTER:
+        {
+            HWND hwndFocus = GetFocus();
+
+
+            if (hwndFocus == ghwndList1)
+            {
+                goto show_widget_dialog;
+            }
+            else if (hwndFocus == ghwndList2)
+            {
+                goto complete_pending_request;
+            }
+
+            break;
+        }
+        case IDC_LIST1:
+        {
+            if (HIWORD(wParam) == LBN_DBLCLK)
+            {
+                LONG    lSel;
+
+show_widget_dialog:
+
+                lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+
+                if (lSel != LB_ERR)
+                {
+                    //
+                    // Determine the widget type, & put up the
+                    // appropriate properties dlg
+                    //
+
+                    PMYWIDGET pWidget;
+
+
+                    pWidget = (PMYWIDGET) SendMessage(
+                        ghwndList1,
+                        LB_GETITEMDATA,
+                        lSel,
+                        0
+                        );
+
+                    switch (pWidget->dwWidgetType)
+                    {
+                    case WIDGETTYPE_LINE:
+                    {
+                        char szTitle[32];
+                        EVENT_PARAM params[] =
+                        {
+                            { "<under construction>", PT_DWORD, 0, 0 }
+                        };
+                        EVENT_PARAM_HEADER paramsHeader =
+                            { 1, szTitle, 0, params };
+
+
+                        wsprintf(
+                            szTitle,
+                            "Line%d properties",
+                            pWidget->dwWidgetID
+                            );
+
+                        if (DialogBoxParam(
+                                ghInstance,
+                                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                                hwnd,
+                                (DLGPROC) ValuesDlgProc,
+                                (LPARAM) &paramsHeader
+
+                                ) == IDOK)
+                        {
+                        }
+
+                        break;
+                    }
+                    case WIDGETTYPE_CALL:
+                    {
+                        char szTitle[32];
+                        EVENT_PARAM params[] =
+                        {
+                            { "Call state", PT_ORDINAL, pWidget->dwCallState, aCallStates },
+                            { "Call state mode", PT_DWORD, 0, 0 }
+                        };
+                        EVENT_PARAM_HEADER paramsHeader =
+                            { 2, szTitle, 0, params };
+
+
+                        wsprintf(
+                            szTitle,
+                            "Call x%x properties",
+                            pWidget->hdXxx
+                            );
+
+                        if (DialogBoxParam(
+                                ghInstance,
+                                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                                hwnd,
+                                (DLGPROC) ValuesDlgProc,
+                                (LPARAM) &paramsHeader
+
+                                ) == IDOK)
+                        {
+                            if (params[0].dwValue != pWidget->dwCallState)
+                            {
+                                ESPEvent(
+                                    0,
+                                    pWidget->hdXxx,
+                                    LINE_CALLSTATE,
+                                    params[0].dwValue,
+                                    params[1].dwValue,
+                                    0
+                                    );
+                            }
+                        }
+
+                        break;
+                    }
+                    case WIDGETTYPE_PHONE:
+                    {
+                        char szTitle[32];
+                        EVENT_PARAM params[] =
+                        {
+                            { "<under construction>", PT_DWORD, 0, 0 }
+                        };
+                        EVENT_PARAM_HEADER paramsHeader =
+                            { 1, szTitle, 0, params };
+
+
+                        wsprintf(
+                            szTitle,
+                            "Phone%d properties",
+                            pWidget->dwWidgetID
+                            );
+
+                        if (DialogBoxParam(
+                                ghInstance,
+                                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                                hwnd,
+                                (DLGPROC) ValuesDlgProc,
+                                (LPARAM) &paramsHeader
+
+                                ) == IDOK)
+                        {
+                        }
+
+                        break;
+                    }
+                    }
+                }
+            }
+
+            break;
+        }
+        case IDC_LIST2:
+        {
+            if (HIWORD(wParam) == LBN_DBLCLK)
+            {
+                LONG    lSel;
+
+complete_pending_request:
+
+                lSel = SendMessage (ghwndList2, LB_GETCURSEL, 0, 0);
+
+                if (lSel != LB_ERR)
+                {
+                    LONG lResult = 0, pAsyncReqInfo;
+
+
+                    if (gdwDebugOptions & MANUAL_RESULTS)
+                    {
+                        EVENT_PARAM params[] =
+                        {
+                            { "lResult", PT_ORDINAL, 0, aLineErrs }
+                        };
+                        EVENT_PARAM_HEADER paramsHeader =
+                            { 1, "Completing request", 0, params };
+
+
+                        if (DialogBoxParam(
+                                ghInstance,
+                                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                                hwnd,
+                                (DLGPROC) ValuesDlgProc,
+                                (LPARAM) &paramsHeader
+
+                                ) != IDOK)
+                        {
+                            break;
+                        }
+
+                        lResult = (LONG) params[0].dwValue;
+                    }
+
+                    pAsyncReqInfo = SendMessage(
+                        ghwndList2,
+                        LB_GETITEMDATA,
+                        (WPARAM) lSel,
+                        0
+                        );
+
+                    SendMessage(
+                        ghwndList2,
+                        LB_DELETESTRING,
+                        (WPARAM) lSel,
+                        0
+                        );
+
+                    ESPCompleteRequest (pAsyncReqInfo, lResult);
+                }
+            }
+
+            break;
+        }
+        case IDC_PREVCTRL:
+        {
+            HWND hwndPrev = GetNextWindow (GetFocus (), GW_HWNDPREV);
+
+
+            if (!hwndPrev)
+            {
+                hwndPrev = GetDlgItem (hwnd, IDC_LIST2);
+            }
+
+            SetFocus (hwndPrev);
+            break;
+        }
+        case IDC_NEXTCTRL:
+        {
+            HWND hwndNext = GetNextWindow (GetFocus (), GW_HWNDNEXT);
+
+
+            if (!hwndNext)
+            {
+                hwndNext = GetDlgItem (hwnd, IDC_BUTTON1);
+            }
+
+            SetFocus (hwndNext);
+            break;
+        }
+        case IDC_BUTTON4: // "Clear"
+
+            SetWindowText (ghwndEdit, "");
+            break;
+
+        case IDM_PBXCONFIG:
+
+            DialogBox(
+                ghInstance,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG4),
+                hwnd,
+                (DLGPROC) PBXConfigDlgProc,
+                );
+
+            break;
+
+        case IDM_PBXSTART:
+        {
+            DWORD dwTID, aPBXSettings[2];
+
+
+            aPBXSettings[0] = (gPBXSettings[0].dwNumber ?
+                gPBXSettings[0].dwTime / gPBXSettings[0].dwNumber : 0);
+
+            aPBXSettings[1] = (gPBXSettings[1].dwNumber ?
+                gPBXSettings[1].dwTime / gPBXSettings[1].dwNumber : 0);
+
+            if (ESPStartPBXThread ((char *) aPBXSettings, 2 * sizeof(DWORD))
+                    == 0)
+            {
+                gbPBXThreadRunning = TRUE;
+
+                EnableMenuItem(
+                    ghMenu,
+                    IDM_PBXSTART,
+                    MF_BYCOMMAND | MF_GRAYED
+                    );
+
+                EnableMenuItem(
+                    ghMenu,
+                    IDM_PBXSTOP,
+                    MF_BYCOMMAND | MF_ENABLED
+                    );
+            }
+
+            break;
+        }
+        case IDM_PBXSTOP:
+
+            if (ESPStopPBXThread (0) == 0)
+            {
+                gbPBXThreadRunning = FALSE;
+
+                EnableMenuItem(
+                    ghMenu,
+                    IDM_PBXSTOP,
+                    MF_BYCOMMAND | MF_GRAYED
+                    );
+
+                EnableMenuItem(
+                    ghMenu,
+                    IDM_PBXSTART,
+                    MF_BYCOMMAND | MF_ENABLED
+                    );
+            }
+            break;
+
+        case IDM_USAGE:
+
+            DialogBox(
+                ghInstance,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG5),
+                (HWND) hwnd,
+                (DLGPROC) HelpDlgProc
+                );
+
+            break;
+
+        case IDM_ABOUT:
+
+            DialogBox(
+                ghInstance,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG2),
+                (HWND) hwnd,
+                (DLGPROC) AboutDlgProc
+                );
+
+            break;
+
+        case IDC_EDIT1:
+
+            if (HIWORD(wParam) == EN_CHANGE)
+            {
+                //
+                // Watch to see if the edit control is full, & if so
+                // purge the top half of the text to make room for more
+                //
+
+                int length = GetWindowTextLength (ghwndEdit);
+
+
+                if (length > 20000)
+                {
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)0 ,
+                        (LPARAM) 10000
+                        );
+
+                    SendMessage(
+                        ghwndEdit,
+                        EM_REPLACESEL,
+                        0,
+                        (LPARAM) (char far *) ""
+                        );
+
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)0xfffffffd,
+                        (LPARAM)0xfffffffe
+                        );
+                }
+
+                UpdateESPOptions();
+            }
+            break;
+
+        case IDM_SYNCCOMPL:
+        case IDM_ASYNCCOMPL:
+        case IDM_SYNCASYNCCOMPL:
+        case IDM_MANUALCOMPL:
+
+            if ((uiCtrlID - IDM_SYNCCOMPL) != gdwCompletionMode)
+            {
+                CheckMenuItem(
+                    ghMenu,
+                    IDM_SYNCCOMPL + gdwCompletionMode,
+                    MF_BYCOMMAND | MF_UNCHECKED
+                    );
+
+                gdwCompletionMode = uiCtrlID - IDM_SYNCCOMPL;
+
+                CheckMenuItem(
+                    ghMenu,
+                    uiCtrlID,
+                    MF_BYCOMMAND | MF_CHECKED
+                    );
+
+                UpdateESPOptions();
+            }
+
+            break;
+
+        case IDM_SHOWFUNCENTRY:
+        case IDM_SHOWFUNCPARAMS:
+        case IDM_SHOWFUNCEXIT:
+        case IDM_SHOWEVENTS:
+        case IDM_SHOWCOMPLETIONS:
+        case IDM_MANUALRESULTS:
+        {
+            DWORD   dwBitField = 0x1 << (uiCtrlID - IDM_SHOWFUNCENTRY);
+
+            gdwDebugOptions ^= dwBitField;
+
+            CheckMenuItem(
+                ghMenu,
+                uiCtrlID,
+                MF_BYCOMMAND | (gdwDebugOptions & dwBitField ?
+                    MF_CHECKED : MF_UNCHECKED)
+                );
+
+            UpdateESPOptions();
+
+            break;
+        }
+        case IDM_SHOWALL:
+        case IDM_SHOWNONE:
+        {
+            int i;
+
+            gdwDebugOptions = (uiCtrlID == IDM_SHOWALL ? 0xffffffff : 0);
+
+            for (i = 0; i < 5; i++)
+            {
+                CheckMenuItem(
+                    ghMenu,
+                    IDM_SHOWFUNCENTRY + i,
+                    MF_BYCOMMAND | (uiCtrlID == IDM_SHOWALL ?
+                        MF_CHECKED : MF_UNCHECKED)
+                    );
+
+                UpdateESPOptions();
+            }
+
+            break;
+        }
+        case IDM_EXIT:
+
+            goto do_wm_close;
+            break;
+
+        } // switch (LOWORD((DWORD)wParam))
+
+        break;
+    }
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+
+        BeginPaint (hwnd, &ps);
+
+        if (IsIconic (hwnd))
+        {
+            DrawIcon (ps.hdc, 0, 0, hIcon);
+        }
+        else
+        {
+            FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+#ifdef WIN32
+            MoveToEx (ps.hdc, 0, 0, NULL);
+#else
+            MoveTo (ps.hdc, 0, 0);
+#endif
+            LineTo (ps.hdc, 5000, 0);
+
+#ifdef WIN32
+            MoveToEx (ps.hdc, 0, icyButton - 4, NULL);
+#else
+            MoveTo (ps.hdc, 0, icyButton - 4);
+#endif
+            LineTo (ps.hdc, 5000, icyButton - 4);
+        }
+
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    case WM_SIZE:
+    {
+        if (wParam != SIZE_MINIMIZED)
+        {
+            LONG width = (LONG)LOWORD(lParam);
+
+
+            //
+            // Adjust globals based on new size
+            //
+
+            cxWnd = (cxWnd ? cxWnd : 1);    // avoid div by 0
+
+            cxList1 = (cxList1 * width) / cxWnd;
+            cxWnd = width;
+            cyWnd = ((int)HIWORD(lParam)) - icyButton;
+
+
+            //
+            // Now reposition the child windows
+            //
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                0,
+                icyButton,
+                (int) cxList1,
+                2*cyWnd/3,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndList2,
+                GetNextWindow (ghwndList2, GW_HWNDPREV),
+                0,
+                icyButton + 2*cyWnd/3 + icyBorder,
+                (int) cxList1,
+                cyWnd/3 - icyBorder,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndEdit,
+                GetNextWindow (ghwndEdit, GW_HWNDPREV),
+                (int) cxList1 + icyBorder,
+                icyButton,
+                (int)width - ((int)cxList1 + icyBorder),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+
+            InvalidateRect (hwnd, NULL, TRUE);
+        }
+        break;
+    }
+    case WM_MOUSEMOVE:
+    {
+        LONG x = (LONG)((short)LOWORD(lParam));
+        int y = (int)((short)HIWORD(lParam));
+        int cxList1New;
+
+
+        if (((y > icyButton) && (x > cxList1)) || bCaptured)
+        {
+            SetCursor(
+                LoadCursor ((HINSTANCE) NULL, MAKEINTRESOURCE(IDC_SIZEWE))
+                );
+        }
+
+        if (bCaptured)
+        {
+            x = (x < cxVScroll ?  cxVScroll : x);
+            x = (x > (cxWnd - cxVScroll) ?  (cxWnd - cxVScroll) : x);
+
+            cxList1New = (int) (cxList1 + x - xCapture);
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                0,
+                icyButton,
+                cxList1New,
+                2*cyWnd/3,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndList2,
+                GetNextWindow (ghwndList2, GW_HWNDPREV),
+                0,
+                icyButton + 2*cyWnd/3 + icyBorder,
+                cxList1New,
+                cyWnd/3 - icyBorder,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndEdit,
+                GetNextWindow (ghwndEdit, GW_HWNDPREV),
+                (int) cxList1New + icyBorder,
+                icyButton,
+                (int)cxWnd - (cxList1New + icyBorder),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+        }
+
+        break;
+    }
+    case WM_LBUTTONDOWN:
+    {
+        if (((int)((short)HIWORD(lParam)) > icyButton) &&
+             ((int)((short)LOWORD(lParam)) > cxList1))
+        {
+            xCapture = (LONG)LOWORD(lParam);
+
+            SetCapture (hwnd);
+
+            bCaptured = TRUE;
+        }
+
+        break;
+    }
+    case WM_LBUTTONUP:
+    {
+        if (bCaptured)
+        {
+            POINT p;
+            LONG  x;
+
+            GetCursorPos (&p);
+            MapWindowPoints (HWND_DESKTOP, hwnd, &p, 1);
+            x = (LONG) p.x;
+
+            ReleaseCapture();
+
+            x = (x < cxVScroll ? cxVScroll : x);
+            x = (x > (cxWnd - cxVScroll) ? (cxWnd - cxVScroll) : x);
+
+            cxList1 = cxList1 + (x - xCapture);
+
+            bCaptured = FALSE;
+
+            InvalidateRect (hwnd, NULL, TRUE);
+        }
+
+        break;
+    }
+    case WM_CLOSE:
+
+do_wm_close:
+
+        if (!gbESPLoaded)
+        {
+            SaveIniFileSettings();
+            DestroyIcon (hIcon);
+            DeleteObject (hFont);
+            PostQuitMessage (0);
+        }
+
+        break;
+
+    } // switch (msg)
+
+    return FALSE;
+}
+
+
+void
+UpdateSummary(
+    HWND hwnd,
+    PPBXSETTING pPBXSettings
+    )
+{
+    int i, j;
+
+
+    SendDlgItemMessage (hwnd, IDC_LIST4, LB_RESETCONTENT, 0, 0);
+
+    for (i = 0, j= 0; i < NUM_PBXSETTINGS; i++)
+    {
+        if (pPBXSettings[i].dwNumber)
+        {
+            char buf[64];
+
+
+            wsprintf(
+                buf, "%s %s per %s",
+                aPBXNumbers[pPBXSettings[i].dwNumber].pszVal,
+                pPBXSettings[i].pszEvent,
+                aPBXTimes[pPBXSettings[i].dwTime].pszVal
+                );
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST4,
+                LB_ADDSTRING,
+                0,
+                (LPARAM) buf
+                );
+
+            SendDlgItemMessage (hwnd, IDC_LIST4, LB_SETITEMDATA, j, i);
+
+            j++;
+        }
+    }
+}
+
+
+BOOL
+CALLBACK
+PBXConfigDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    static PBXSETTING pbxSettings[NUM_PBXSETTINGS];
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        int i, j;
+
+
+        //
+        // Mkae a local copy of the global PBX settings
+        //
+
+        for (i = 0; i < NUM_PBXSETTINGS; i++)
+        {
+
+            pbxSettings[i].pszEvent = gPBXSettings[i].pszEvent;
+
+            //
+            // For Number & time fields convert from values to indexes
+            //
+
+            for (j = 0; aPBXNumbers[j].pszVal; j++)
+            {
+                if (gPBXSettings[i].dwNumber == aPBXNumbers[j].dwVal)
+                {
+                    pbxSettings[i].dwNumber = j;
+                }
+            }
+
+            for (j = 0; aPBXTimes[j].pszVal; j++)
+            {
+                if (gPBXSettings[i].dwTime == aPBXTimes[j].dwVal)
+                {
+                    pbxSettings[i].dwTime = j;
+                }
+            }
+        }
+
+        if (gbPBXThreadRunning)
+        {
+            EnableWindow (GetDlgItem (hwnd, IDC_RESET), FALSE);
+        }
+        else
+        {
+            for (i = 0; aPBXNumbers[i].pszVal; i++)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_ADDSTRING,
+                    0,
+                    (LPARAM) aPBXNumbers[i].pszVal
+                    );
+            }
+
+            for (i = 0; i < NUM_PBXSETTINGS; i++)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_ADDSTRING,
+                    0,
+                    (LPARAM) pbxSettings[i].pszEvent
+                    );
+            }
+
+            for (i = 0; aPBXTimes[i].pszVal; i++)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST3,
+                    LB_ADDSTRING,
+                    0,
+                    (LPARAM) aPBXTimes[i].pszVal
+                    );
+            }
+        }
+
+        UpdateSummary (hwnd, pbxSettings);
+
+        break;
+    }
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDC_LIST1:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                LONG    lSelSetting, lSelNumber;
+
+
+                lSelSetting = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+                lSelNumber = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+                pbxSettings[lSelSetting].dwNumber = lSelNumber;
+
+                UpdateSummary (hwnd, pbxSettings);
+            }
+
+            break;
+
+        case IDC_LIST2:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                LONG    lSelSetting;
+
+
+                lSelSetting = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+               SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_SETCURSEL,
+                    pbxSettings[lSelSetting].dwNumber,
+                    0
+                    );
+
+               SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST3,
+                    LB_SETCURSEL,
+                    pbxSettings[lSelSetting].dwTime,
+                    0
+                    );
+
+                UpdateSummary (hwnd, pbxSettings);
+            }
+
+            break;
+
+        case IDC_LIST3:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                LONG    lSelSetting, lSelTime;
+
+
+                lSelSetting = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+                lSelTime = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST3,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+                pbxSettings[lSelSetting].dwTime = lSelTime;
+
+                UpdateSummary (hwnd, pbxSettings);
+            }
+
+            break;
+
+        case IDC_LIST4:
+
+            if ((HIWORD(wParam) == LBN_SELCHANGE) && !gbPBXThreadRunning)
+            {
+                LONG    lSel, lEntryToSel;
+
+
+                lSel = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST4,
+                    LB_GETCURSEL,
+                    0,
+                    0
+                    );
+
+                lEntryToSel = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST4,
+                    LB_GETITEMDATA,
+                    lSel,
+                    0
+                    );
+
+               SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_SETCURSEL,
+                    pbxSettings[lEntryToSel].dwNumber,
+                    0
+                    );
+
+               SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_SETCURSEL,
+                    lEntryToSel,
+                    0
+                    );
+
+               SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST3,
+                    LB_SETCURSEL,
+                    pbxSettings[lEntryToSel].dwTime,
+                    0
+                    );
+            }
+
+            break;
+
+        case IDC_RESET:
+
+            memset (pbxSettings, 0, NUM_PBXSETTINGS * sizeof(PBXSETTING));
+
+            UpdateSummary (hwnd, pbxSettings);
+
+            break;
+
+        case IDOK:
+        {
+            int i;
+
+            // convert from indexes to values
+
+            for (i = 0; i < NUM_PBXSETTINGS; i++)
+            {
+                gPBXSettings[i].dwNumber =
+                    aPBXNumbers[pbxSettings[i].dwNumber].dwVal;
+                gPBXSettings[i].dwTime =
+                    aPBXTimes[pbxSettings[i].dwTime].dwVal;
+            }
+
+            // drop thru to IDM_CANCEL code
+
+        }
+        case IDCANCEL:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    } // switch (msg)
+
+    return FALSE;
+}
+
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+CALLBACK
+HelpDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        static char szUsageText[] =
+
+            "ABSTRACT:\r\n"                                               \
+            "    ESP is a TAPI Service Provider that supports\r\n"        \
+            "multiple virtual line and phone devices. It is\r\n"          \
+            "configurable, requires no special hardware,\r\n"             \
+            "and implements the entire Telephony Service\r\n"             \
+            "Provider Interface (including Win95 TAPI\r\n"                \
+            "extensions). ESP will work in both Windows 3.1/\r\n"         \
+            "TAPI 1.0 and Windows95/TAPI 1.1 systems.\r\n"                \
+
+            "\r\nGETTING STARTED:\r\n"                                    \
+            "    1. Choose 'File/Install' to install ESP.\r\n"            \
+            "    2. Start a TAPI application and try to make\r\n"         \
+            "a call on one of ESP's line devices (watch for\r\n"          \
+            "messages appearing in the ESP window).\r\n"                  \
+            "    *. Choose 'File/Uninstall' to uninstall ESP.\r\n"        \
+
+            "\r\nMORE INFO:\r\n"                                          \
+            "    *  Double-click on a line, call, or phone\r\n"           \
+            "widget (in upper-left listbox) to view/modify\r\n"           \
+            "properties. The 'hd'widget field is the driver\r\n"          \
+            "handle; the 'ht' field is the TAPI handle.\r\n"              \
+            "    *  Press the 'LEvt' or 'PEvt' button to\r\n"             \
+            "indicate a line or phone event to TAPI.DLL.\r\n"             \
+            "Press the 'Call+' button to indicate an incoming\r\n"        \
+            " call.\r\n"                                                  \
+            "    *  Choose 'Options/Default values...' to\r\n"            \
+            "modify provider paramters (SPI version, etc.)\r\n"           \
+            "    *  All parameter values displayed in\r\n"                \
+            "hexadecimal unless specified otherwise (strings\r\n"         \
+            "displayed by contents).\r\n"                                 \
+            "    *  Choose 'Options/Complete async requests/Xxx'\r\n"     \
+            "to specify async requests completion behavior.\r\n"          \
+            "Manually-completed requests appear in lower-left\r\n"        \
+            "listbox.";
+
+        SetDlgItemText (hwnd, IDC_EDIT1, szUsageText);
+
+        break;
+    }
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+void
+ProcessWidgetEvent(
+    PWIDGETEVENT    pEvent
+    )
+{
+    char        buf[64];
+    long        lIndex = 0xfffffffe;
+    PMYWIDGET   pWidget = gpWidgets;
+
+
+    switch (pEvent->dwWidgetType)
+    {
+    case WIDGETTYPE_ASYNCREQUEST:
+    {
+        wsprintf (buf, "ReqID=x%x", pEvent->dwWidgetID);
+
+        // BUGBUG want to incl the req type at some point (str table lookup)
+
+        lIndex = SendMessage (ghwndList2, LB_ADDSTRING, 0, (LPARAM) buf);
+
+        SendMessage(
+            ghwndList2,
+            LB_SETITEMDATA,
+            (WPARAM) lIndex,
+            (LPARAM) pEvent->pAsyncReqInfo
+            );
+
+        return;
+    }
+    case WIDGETTYPE_LINE:
+    {
+        for (lIndex = 0;; lIndex++)
+        {
+            if ((pWidget->dwWidgetType == WIDGETTYPE_LINE) &&
+                (pWidget->dwWidgetID == pEvent->dwWidgetID))
+            {
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+
+        if (pEvent->htXxx == 0)
+        {
+            PMYWIDGET   pWidget2 = pWidget->pNext;
+
+
+            // line closing so nuke all following calls (listbox & widg list)
+
+            while (pWidget2->dwWidgetType == WIDGETTYPE_CALL)
+            {
+                pWidget->pNext = pWidget2->pNext;
+
+                MyFree (pWidget2);
+
+                pWidget2 = pWidget->pNext;
+
+                SendMessage(
+                    ghwndList1,
+                    LB_DELETESTRING,
+                    (WPARAM) lIndex + 1,
+                    (LPARAM) 0
+                    );
+            }
+
+            if (pWidget2)
+            {
+                pWidget2->pPrev = pWidget;
+            }
+
+            wsprintf (buf, "Line%d (CLOSED)", pEvent->dwWidgetID);
+
+        }
+        else
+        {
+            wsprintf (buf, "Line%d, hd=x%x, ht=x%x",
+                pEvent->dwWidgetID,
+                pEvent->hdXxx,
+                pEvent->htXxx
+                );
+        }
+
+        pWidget->hdXxx = pEvent->hdXxx;
+        pWidget->htXxx = pEvent->htXxx;
+
+        break;
+    }
+    case WIDGETTYPE_CALL:
+    {
+        long        lIndexLine = 0;
+        PMYWIDGET   pLine = NULL;
+
+
+        for (lIndex = 0; pWidget; lIndex++)
+        {
+            if ((pWidget->dwWidgetType == WIDGETTYPE_LINE) &&
+                (pWidget->dwWidgetID == pEvent->dwWidgetID))
+            {
+                pLine = pWidget;
+                lIndexLine = lIndex;
+            }
+
+            if ((pWidget->dwWidgetType == WIDGETTYPE_CALL) &&
+                (pWidget->hdXxx == pEvent->hdXxx))
+            {
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+
+        if (pWidget)
+        {
+            //
+            // Found call in list
+            //
+
+            if (pEvent->htXxx)
+            {
+                //
+                // Update the call's listbox entry
+                //
+
+                int i;
+
+
+                for (i = 0; pEvent->dwCallState != aCallStates[i].dwVal; i++);
+
+                wsprintf(
+                    buf,
+                    "  hdCall=x%x, ht=x%x, %s Addr=%d",
+                    pEvent->hdXxx,
+                    pEvent->htXxx,
+                    aCallStates[i].pszVal,
+                    pEvent->dwCallAddressID
+                    );
+
+                pWidget->dwCallState = pEvent->dwCallState;
+            }
+            else
+            {
+                //
+                // Call was destroyed, so remove it from the listbox &
+                // widget lists and nuke the data structure
+                //
+
+                SendMessage(
+                    ghwndList1,
+                    LB_DELETESTRING,
+                    (WPARAM) lIndex,
+                    (LPARAM) 0
+                    );
+
+                pWidget->pPrev->pNext = pWidget->pNext;
+
+                if (pWidget->pNext)
+                {
+                    pWidget->pNext->pPrev = pWidget->pPrev;
+                }
+
+                MyFree (pWidget);
+
+                return;
+            }
+        }
+        else if (pEvent->htXxx)
+        {
+            //
+            // Call wasn't in the list, but it's valid so add it to
+            // listbox & widget lists
+            //
+
+            int i;
+
+
+            pWidget = MyAlloc (sizeof (MYWIDGET));
+
+            memcpy (pWidget, pEvent, sizeof (WIDGETEVENT));
+
+            if ((pWidget->pNext = pLine->pNext))
+            {
+                pWidget->pNext->pPrev = pWidget;
+            }
+
+            pWidget->pPrev = pLine;
+            pLine->pNext = pWidget;
+
+            for (i = 0; pEvent->dwCallState != aCallStates[i].dwVal; i++);
+
+            wsprintf(
+                buf,
+                "  hdCall=x%x, ht=x%x, %s Addr=%d",
+                pEvent->hdXxx,
+                pEvent->htXxx,
+                aCallStates[i].pszVal,
+                pEvent->dwCallAddressID
+                );
+
+            SendMessage(
+                ghwndList1,
+                LB_INSERTSTRING,
+                (WPARAM) lIndexLine + 1,
+                (LPARAM) buf
+                );
+
+            SendMessage(
+                ghwndList1,
+                LB_SETITEMDATA,
+                (WPARAM) lIndexLine + 1,
+                (LPARAM) pWidget
+                );
+
+            return;
+        }
+
+        break;
+    }
+    case WIDGETTYPE_PHONE:
+    {
+        for (lIndex = 0;; lIndex++)
+        {
+            if ((pWidget->dwWidgetType == WIDGETTYPE_PHONE) &&
+                (pWidget->dwWidgetID == pEvent->dwWidgetID))
+            {
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+
+        if (pEvent->htXxx == 0)
+        {
+            wsprintf (buf, "Phone%d (CLOSED)", pEvent->dwWidgetID);
+        }
+        else
+        {
+            wsprintf (buf, "Phone%d, hd=x%x, ht=x%x",
+                pEvent->dwWidgetID,
+                pEvent->hdXxx,
+                pEvent->htXxx
+                );
+        }
+
+        pWidget->hdXxx = pEvent->hdXxx;
+        pWidget->htXxx = pEvent->htXxx;
+
+        break;
+    }
+    case WIDGETTYPE_STARTUP:
+    {
+        //
+        // Build widget list for "static" devices
+        //
+
+        DWORD       i, j;
+        PMYWIDGET   pWidget, pLastWidget = NULL;
+
+
+        for (i = 0; i < pEvent->dwNumLines; i++)
+        {
+            pWidget = MyAlloc (sizeof (MYWIDGET));
+
+            pWidget->dwWidgetID   = i + pEvent->dwLineDeviceIDBase;
+            pWidget->dwWidgetType = WIDGETTYPE_LINE;
+
+            if ((pWidget->pPrev = pLastWidget))
+            {
+                pLastWidget->pNext = pWidget;
+            }
+            else
+            {
+                gpWidgets = pWidget;
+            }
+
+            pLastWidget = pWidget;
+
+            wsprintf (buf, "Line%d (CLOSED)", pWidget->dwWidgetID);
+
+            SendMessage (ghwndList1, LB_ADDSTRING, 0, (LPARAM) buf);
+            SendMessage (ghwndList1, LB_SETITEMDATA, i, (LPARAM) pWidget);
+        }
+
+        for (j = 0; j < pEvent->dwNumPhones; j++)
+        {
+            pWidget = MyAlloc (sizeof (MYWIDGET));
+
+            pWidget->dwWidgetID   = j + pEvent->dwPhoneDeviceIDBase;
+            pWidget->dwWidgetType = WIDGETTYPE_PHONE;
+
+            if ((pWidget->pPrev = pLastWidget))
+            {
+                pLastWidget->pNext = pWidget;
+            }
+            else
+            {
+                gpWidgets = pWidget;
+            }
+
+            pLastWidget = pWidget;
+
+            wsprintf (buf, "Phone%d (CLOSED)", pWidget->dwWidgetID);
+
+            SendMessage (ghwndList1, LB_ADDSTRING, 0, (LPARAM) buf);
+            SendMessage (ghwndList1, LB_SETITEMDATA, i + j, (LPARAM) pWidget);
+        }
+
+        return;
+    }
+    } // switch (pEvent->dwWidgetType)
+
+
+    //
+    // Update the widget's listbox entry given the index &
+    // description filled in above
+    //
+
+    SendMessage (ghwndList1, LB_DELETESTRING, (WPARAM) lIndex, (LPARAM) 0);
+    SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM) lIndex, (LPARAM) buf);
+    SendMessage (ghwndList1, LB_SETITEMDATA, (WPARAM) lIndex, (LPARAM)pWidget);
+}
+
+
+void
+UpdateESPOptions(
+    void
+    )
+{
+    if (gbESPLoaded)
+    {
+        RpcTryExcept
+        {
+            ESPSetOptions(
+                (long) gdwDebugOptions,
+                (long) gdwCompletionMode
+                );
+        }
+        RpcExcept (1)
+        {
+            // BUGBUG
+        }
+        RpcEndExcept
+    }
+}
+
+
+void
+SaveIniFileSettings(
+    void
+    )
+{
+    RECT rect;
+
+
+    GetWindowRect (ghwndMain, &rect);
+
+    {
+        typedef struct _YYY
+        {
+            LPCSTR   pszValueName;
+
+            DWORD    dwValue;
+
+        } YYY, *PYYY;
+
+        YYY ayyy[] =
+        {
+            { "Left",               (DWORD) rect.left             },
+            { "Top",                (DWORD) rect.top              },
+            { "Right",              (DWORD) rect.right            },
+            { "Bottom",             (DWORD) rect.bottom           },
+            { "cxWnd",              (DWORD) cxWnd                 },
+            { "cxList1",            (DWORD) cxList1               },
+            { "AutoClose",          (DWORD) gbAutoClose           },
+            { "DebugOutput",        (DWORD) gdwDebugOptions       },
+            { "Completion",         (DWORD) gdwCompletionMode     },
+            { "TSPIVersion",        (DWORD) gdwTSPIVersion        },
+            { "NumLines",           (DWORD) gdwNumLines           },
+            { "NumAddrsPerLine",    (DWORD) gdwNumAddrsPerLine    },
+            { "NumCallsPerAddr",    (DWORD) gdwNumCallsPerAddr    },
+            { "NumPhones",          (DWORD) gdwNumPhones          },
+            { "AutoGatherGenerateMsgs", (DWORD) gbAutoGatherGenerateMsgs },
+            { "DisableUI",          (DWORD) gbDisableUI           },
+            { NULL,                 (DWORD) 0                     }
+        };
+        DWORD   i = (IsIconic (ghwndMain) ? 6 : 0); // don't chg pos if iconic
+
+
+        for (i = 0; ayyy[i].pszValueName; i++)
+        {
+            char buf[16];
+
+
+            wsprintf (buf, "%d", ayyy[i].dwValue);
+
+            WriteProfileString (szMySection, ayyy[i].pszValueName, buf);
+        }
+    }
+}
+
+
+void
+xxxShowStr(
+    char   *psz
+    )
+{
+    SendMessage (ghwndEdit, EM_SETSEL, (WPARAM)0xfffffffd, (LPARAM)0xfffffffe);
+    SendMessage (ghwndEdit, EM_REPLACESEL, 0, (LPARAM) psz);
+    SendMessage (ghwndEdit, EM_SCROLLCARET, 0, 0);
+}
+
+
+void
+ShowStr(
+    char   *pszFormat,
+    ...
+    )
+{
+    char    buf[256];
+    va_list ap;
+
+
+    va_start(ap, pszFormat);
+
+    wvsprintf (buf, pszFormat, ap);
+
+    strcat (buf, "\r\n");
+
+    xxxShowStr (buf);
+
+    va_end(ap);
+}
+
+
+LPVOID
+MyAlloc(
+    size_t numBytes
+    )
+{
+    LPVOID p = (LPVOID) LocalAlloc (LPTR, numBytes);
+
+
+    if (!p)
+    {
+        ShowStr ("Error: MyAlloc () failed");
+    }
+
+    return p;
+}
+
+
+void
+MyFree(
+    LPVOID  p
+    )
+{
+#if DBG
+
+    //
+    // Fill the buf to free with 0x5a's to facilitate debugging
+    //
+
+    memset (p, 0x5a, (size_t) LocalSize (LocalHandle (p)));
+
+#endif
+
+    LocalFree (p);
+}
+
+
+void
+__RPC_FAR *
+__RPC_API
+midl_user_allocate(
+    size_t len
+    )
+{
+    return NULL;
+}
+
+
+void
+__RPC_API
+midl_user_free(
+    void __RPC_FAR * ptr
+    )
+{
+}
+
+
+BOOL
+ScanForDWORD(
+   char far *pBuf,
+   LPDWORD  lpdw
+   )
+{
+    char  c;
+    BOOL  bValid = FALSE;
+    DWORD d = 0;
+
+    while ((c = *pBuf))
+    {
+        if ((c >= '0') && (c <= '9'))
+        {
+            c -= '0';
+        }
+        else if ((c >= 'a') && (c <= 'f'))
+        {
+            c -= ('a' - 10);
+        }
+        else if ((c >= 'A') && (c <= 'F'))
+        {
+            c -= ('A' - 10);
+        }
+        else
+        {
+            break;
+        }
+
+        bValid = TRUE;
+
+        d *= 16;
+
+        d += (DWORD) c;
+
+        pBuf++;
+    }
+
+    if (bValid)
+    {
+        *lpdw = d;
+    }
+
+    return bValid;
+}
+
+
+BOOL
+CALLBACK
+ValuesDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    DWORD   i;
+
+    static  HWND                hwndCombo, hwndList1, hwndList2;
+    static  LONG                lLastSel;
+    static  char                szComboText[MAX_STRING_PARAM_SIZE];
+    static  PEVENT_PARAM_HEADER pParamsHeader;
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        hwndList1 = GetDlgItem (hwnd, IDC_LIST1);
+        hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+        hwndCombo = GetDlgItem (hwnd, IDC_COMBO1);
+
+        lLastSel = -1;
+        pParamsHeader = (PEVENT_PARAM_HEADER) lParam;
+
+
+        //
+        // Limit the max text length for the combobox's edit field
+        // (NOTE: A combobox ctrl actually has two child windows: a
+        // edit ctrl & a listbox.  We need to get the hwnd of the
+        // child edit ctrl & send it the LIMITTEXT msg.)
+        //
+
+        {
+            HWND hwndChild = GetWindow (hwndCombo, GW_CHILD);
+
+
+            while (hwndChild)
+            {
+                char buf[8];
+
+
+                GetClassName (hwndChild, buf, 7);
+
+                if (_stricmp (buf, "edit") == 0)
+                {
+                    break;
+                }
+
+                hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+            }
+
+            SendMessage(
+                hwndChild,
+                EM_LIMITTEXT,
+                (WPARAM) MAX_STRING_PARAM_SIZE - 1,
+                0
+                );
+        }
+
+
+        //
+        // Misc other init
+        //
+
+        SetWindowText (hwnd, pParamsHeader->pszDlgTitle);
+
+        for (i = 0; i < pParamsHeader->dwNumParams; i++)
+        {
+            SendMessage(
+                hwndList1,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) pParamsHeader->aParams[i].szName
+                );
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            if (lLastSel != -1)
+            {
+                char buf[MAX_STRING_PARAM_SIZE];
+
+
+                //
+                // Save val of currently selected param
+                //
+
+                i = GetDlgItemText(
+                    hwnd,
+                    IDC_COMBO1,
+                    buf,
+                    MAX_STRING_PARAM_SIZE - 1
+                    );
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    LONG lComboSel;
+
+
+                    lComboSel = SendMessage (hwndCombo, CB_GETCURSEL, 0, 0);
+
+                    if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                    {
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD) 0;
+                    }
+                    else // "Valid string"
+                    {
+                        strncpy(
+                            pParamsHeader->aParams[lLastSel].buf,
+                            buf,
+                            MAX_STRING_PARAM_SIZE - 1
+                            );
+
+                        pParamsHeader->aParams[lLastSel].buf[MAX_STRING_PARAM_SIZE-1] = 0;
+
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                            pParamsHeader->aParams[lLastSel].buf;
+                    }
+
+                    break;
+                }
+                case PT_DWORD:
+                case PT_FLAGS:
+                case PT_ORDINAL:
+                {
+                    if (!ScanForDWORD(
+                            buf,
+                            &pParamsHeader->aParams[lLastSel].dwValue
+                            ))
+                    {
+                        //
+                        // Default to 0
+                        //
+
+                        pParamsHeader->aParams[lLastSel].dwValue = 0;
+                    }
+
+                    break;
+                }
+                } // switch
+            }
+
+            // Drop thru to IDCANCEL cleanup code
+
+        case IDCANCEL:
+
+            EndDialog (hwnd, (int)LOWORD(wParam));
+            break;
+
+        case IDC_LIST1:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                char    buf[MAX_STRING_PARAM_SIZE] = "";
+                LPCSTR  lpstr = buf;
+                LONG    lSel = SendMessage (hwndList1, LB_GETCURSEL, 0, 0);
+
+
+                if (lLastSel != -1)
+                {
+                    //
+                    // Save the old param value
+                    //
+
+                    i = GetWindowText(
+                        hwndCombo,
+                        buf,
+                        MAX_STRING_PARAM_SIZE - 1
+                        );
+
+                    switch (pParamsHeader->aParams[lLastSel].dwType)
+                    {
+                    case PT_STRING:
+                    {
+                        LONG lComboSel;
+
+
+                        lComboSel = SendMessage (hwndCombo, CB_GETCURSEL, 0,0);
+
+                        if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                        {
+                            pParamsHeader->aParams[lLastSel].dwValue =
+                                (DWORD)0;
+                        }
+                        else // "Valid string" or no sel
+                        {
+                            strncpy(
+                                pParamsHeader->aParams[lLastSel].buf,
+                                buf,
+                                MAX_STRING_PARAM_SIZE - 1
+                                );
+
+                            pParamsHeader->aParams[lLastSel].buf[MAX_STRING_PARAM_SIZE - 1] = 0;
+
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                                pParamsHeader->aParams[lLastSel].buf;
+                        }
+
+                        break;
+                    }
+                    case PT_DWORD:
+                    case PT_FLAGS:
+                    case PT_ORDINAL:
+                    {
+                        if (!ScanForDWORD(
+                                buf,
+                                &pParamsHeader->aParams[lLastSel].dwValue
+                                ))
+                        {
+                            //
+                            // Default to 0
+                            //
+
+                            pParamsHeader->aParams[lLastSel].dwValue = 0;
+                        }
+
+                        break;
+                    }
+                    } // switch
+                }
+
+
+                SendMessage (hwndList2, LB_RESETCONTENT, 0, 0);
+                SendMessage (hwndCombo, CB_RESETCONTENT, 0, 0);
+
+                switch (pParamsHeader->aParams[lSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    char * aszOptions[] =
+                    {
+                        "NUL (dwXxxSize=0)",
+                        "Valid string"
+                    };
+
+
+                    for (i = 0; i < 2; i++)
+                    {
+                        SendMessage(
+                            hwndCombo,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) aszOptions[i]
+                            );
+                    }
+
+                    if (pParamsHeader->aParams[lSel].dwValue == 0)
+                    {
+                        i = 0;
+                        buf[0] = 0;
+                    }
+                    else
+                    {
+                        i = 1;
+                        lpstr = (LPCSTR) pParamsHeader->aParams[lSel].dwValue;
+                    }
+
+                    SendMessage (hwndCombo, CB_SETCURSEL, (WPARAM) i, 0);
+
+                    break;
+                }
+                case PT_DWORD:
+                {
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "0000000"
+                        );
+
+                    if (pParamsHeader->aParams[lSel].dwDefValue)
+                    {
+                        //
+                        // Add the default val string to the combo
+                        //
+
+                        wsprintf(
+                            buf,
+                            "%08lx",
+                            pParamsHeader->aParams[lSel].dwDefValue
+                            );
+
+                        SendMessage(
+                            hwndCombo,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) buf
+                            );
+                    }
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "ffffffff"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_ORDINAL:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].pszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue ==
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_FLAGS:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].pszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue &
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select all"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                } //switch
+
+                SetWindowText (hwndCombo, lpstr);
+
+                lLastSel = lSel;
+            }
+            break;
+
+        case IDC_LIST2:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                //
+                // BUGBUG in the PT_ORDINAL case we should compare the
+                // currently selected item(s) against the previous DWORD
+                // val and figure out which item we need to deselect,
+                // if any, in order to maintain a mutex of values
+                //
+
+                PLOOKUP pLookup = (PLOOKUP)
+                    pParamsHeader->aParams[lLastSel].pLookup;
+                char buf[16];
+                DWORD dwValue = 0;
+                int far *ai;
+                LONG i, lSelCount =
+                    SendMessage (hwndList2, LB_GETSELCOUNT, 0, 0);
+
+
+                ai = (int far *) MyAlloc ((size_t)lSelCount * sizeof(int));
+
+                SendMessage(
+                    hwndList2,
+                    LB_GETSELITEMS,
+                    (WPARAM) lSelCount,
+                    (LPARAM) ai
+                    );
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_FLAGS)
+                {
+                    for (i = 0; i < lSelCount; i++)
+                    {
+                        dwValue |= pLookup[ai[i]].dwVal;
+                    }
+                }
+                else // if (.dwType == PT_ORDINAL)
+                {
+                    if (lSelCount == 1)
+                    {
+                        dwValue = pLookup[ai[0]].dwVal;
+                    }
+                    else if (lSelCount == 2)
+                    {
+                        //
+                        // Figure out which item we need to de-select, since
+                        // we're doing ordinals & only want 1 item selected
+                        // at a time
+                        //
+
+                        GetWindowText (hwndCombo, buf, 16);
+
+                        if (ScanForDWORD (buf, &dwValue))
+                        {
+                            if (pLookup[ai[0]].dwVal == dwValue)
+                            {
+                                SendMessage(
+                                    hwndList2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[0]
+                                    );
+
+                                dwValue = pLookup[ai[1]].dwVal;
+                            }
+                            else
+                            {
+                                SendMessage(
+                                    hwndList2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[1]
+                                    );
+
+                                dwValue = pLookup[ai[0]].dwVal;
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                    else if (lSelCount > 2)
+                    {
+                        //
+                        // Determine previous selection & de-select all the
+                        // latest selections
+                        //
+
+                        GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                        if (ScanForDWORD (buf, &dwValue))
+                        {
+                            for (i = 0; i < lSelCount; i++)
+                            {
+                                if (pLookup[ai[i]].dwVal != dwValue)
+                                {
+                                    SendMessage(
+                                        hwndList2,
+                                        LB_SETSEL,
+                                        0,
+                                        (LPARAM) ai[i]
+                                        );
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                }
+
+                MyFree (ai);
+                wsprintf (buf, "%08lx", dwValue);
+                SetWindowText (hwndCombo, buf);
+            }
+            break;
+
+        case IDC_COMBO1:
+
+            switch (HIWORD(wParam))
+            {
+            case CBN_SELCHANGE:
+            {
+                LONG    lSel =  SendMessage (hwndCombo, CB_GETCURSEL, 0, 0);
+
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_ORDINAL:
+
+                    //
+                    // The only option here is "select none"
+                    //
+
+                    strcpy (szComboText, "00000000");
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+                    break;
+
+                case PT_FLAGS:
+                {
+                    BOOL bSelect = (lSel ? TRUE : FALSE);
+
+                    SendMessage(
+                        hwndList2,
+                        LB_SETSEL,
+                        (WPARAM) bSelect,
+                        (LPARAM) -1
+                        );
+
+                    if (bSelect)
+                    {
+                        PLOOKUP pLookup = (PLOOKUP)
+                            pParamsHeader->aParams[lLastSel].pLookup;
+                        DWORD dwValue = 0;
+                        int far *ai;
+                        LONG i, lSelCount =
+                            SendMessage (hwndList2, LB_GETSELCOUNT, 0, 0);
+
+
+                        ai = (int far *) MyAlloc(
+                            (size_t)lSelCount * sizeof(int)
+                            );
+
+                        SendMessage(
+                            hwndList2,
+                            LB_GETSELITEMS,
+                            (WPARAM) lSelCount,
+                            (LPARAM) ai
+                            );
+
+                        for (i = 0; i < lSelCount; i++)
+                        {
+                            dwValue |= pLookup[ai[i]].dwVal;
+                        }
+
+                        MyFree (ai);
+                        wsprintf (szComboText, "%08lx", dwValue);
+
+                    }
+                    else
+                    {
+                        strcpy (szComboText, "00000000");
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+                }
+                case PT_STRING:
+
+                    if (lSel == 1)
+                    {
+                        strncpy(
+                            szComboText,
+                            pParamsHeader->aParams[lLastSel].buf,
+                            MAX_STRING_PARAM_SIZE
+                            );
+
+                        szComboText[MAX_STRING_PARAM_SIZE-1] = 0;
+                    }
+                    else
+                    {
+                        szComboText[0] = 0;
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+
+                case PT_DWORD:
+
+                    break;
+
+                } // switch
+                break;
+            }
+            case CBN_EDITCHANGE:
+            {
+                //
+                // If user entered text in the edit field then copy the
+                // text to our buffer
+                //
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_STRING)
+                {
+                    char buf[MAX_STRING_PARAM_SIZE];
+
+
+                    GetWindowText (hwndCombo, buf, MAX_STRING_PARAM_SIZE);
+
+                    strncpy(
+                        pParamsHeader->aParams[lLastSel].buf,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    pParamsHeader->aParams[lLastSel].buf
+                        [MAX_STRING_PARAM_SIZE-1] = 0;
+                }
+                break;
+            }
+            } // switch
+
+        } // switch
+
+        break;
+    }
+    case WM_USER+55:
+
+        SetWindowText (hwndCombo, szComboText);
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
diff --git a/private/tapi/dev/sp/esp.new/exe/espexe.def b/private/tapi/dev/sp/esp.new/exe/espexe.def
new file mode 100644
index 000000000..ed1eea8b6
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/espexe.def
@@ -0,0 +1,13 @@
+NAME         ESPEXE
+STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD   MOVEABLE MULTIPLE
+HEAPSIZE     2048
+STACKSIZE    16384
+
+EXPORTS
+             MainWndProc
+             PBXConfigDlgProc
+             AboutDlgProc
+             HelpDlgProc
+             ValuesDlgProc
diff --git a/private/tapi/dev/sp/esp.new/exe/espexe.h b/private/tapi/dev/sp/esp.new/exe/espexe.h
new file mode 100644
index 000000000..a2209be92
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/espexe.h
@@ -0,0 +1,410 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    espexe.h
+
+Abstract:
+
+
+
+Author:
+
+    Dan Knudson (DanKn)    15-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "..\tsp\intrface.h"
+#include "resource.h"
+#include "espidl.h"
+
+
+#define MAX_STRING_PARAM_SIZE   32
+
+#define PT_DWORD                1
+#define PT_FLAGS                2
+#define PT_STRING               3
+#define PT_ORDINAL              4
+
+typedef struct _MYWIDGET
+{
+    DWORD               dwWidgetID;
+
+    DWORD               dwWidgetType;
+
+    DWORD               hdXxx;
+
+    DWORD               htXxx;
+
+    DWORD               dwCallState;
+
+    DWORD               dwCallAddressID;
+
+    struct _MYWIDGET   *pPrev;
+
+    struct _MYWIDGET   *pNext;
+
+} MYWIDGET, *PMYWIDGET;
+
+
+typedef struct _LOOKUP
+{
+    DWORD               dwVal;
+
+    char far           *pszVal;
+
+} LOOKUP, *PLOOKUP;
+
+
+typedef struct _PBXSETTING
+{
+    DWORD               dwNumber;
+
+    LPCSTR              pszEvent;
+
+    DWORD               dwTime;
+
+} PBXSETTING, *PPBXSETTING;
+
+
+typedef struct _EVENT_PARAM
+{
+    char far           *szName;
+
+    DWORD               dwType;
+
+    DWORD               dwValue;
+
+    union
+    {
+        PLOOKUP         pLookup;
+
+        char far       *buf;
+
+        LPVOID          ptr;
+
+        DWORD           dwDefValue;
+
+    };
+
+} EVENT_PARAM, far *PEVENT_PARAM;
+
+
+typedef struct _EVENT_PARAM_HEADER
+{
+    DWORD               dwNumParams;
+
+    LPSTR               pszDlgTitle;
+
+    DWORD               dwEventType;
+
+    PEVENT_PARAM        aParams;
+
+} EVENT_PARAM_HEADER, far *PEVENT_PARAM_HEADER;
+
+
+
+LOOKUP aPBXNumbers[] =
+{
+    { 0,    "0"     },
+    { 1,    "1"     },
+    { 2,    "2"     },
+    { 5,    "5"     },
+    { 10,   "10"    },
+    { 20,   "20"    },
+    { 50,   "50"    },
+    { 100,  "100"   },
+    { 200,  "200"   },
+    { 500,  "500"   },
+    { 1000, "1000"  },
+    { 0,    NULL    }
+};
+
+
+LOOKUP aPBXTimes[] =
+{
+    { 1000,      "second" },
+    { 60000,     "minute" },
+    { 3600000,   "hour"   },
+    { 86400000,  "day"    },
+    { 604800000, "week"   },
+    { 0,         NULL     }
+};
+
+
+#define NUM_PBXSETTINGS 2
+
+
+PBXSETTING gPBXSettings[NUM_PBXSETTINGS] =
+{
+    { 0, "incoming calls", 0 },
+    { 0, "disconnections", 0 }
+};
+
+
+LOOKUP aCallStates[] =
+{
+    { LINECALLSTATE_IDLE               ,"IDLE"               },
+    { LINECALLSTATE_OFFERING           ,"OFFERING"           },
+    { LINECALLSTATE_ACCEPTED           ,"ACCEPTED"           },
+    { LINECALLSTATE_DIALTONE           ,"DIALTONE"           },
+    { LINECALLSTATE_DIALING            ,"DIALING"            },
+    { LINECALLSTATE_RINGBACK           ,"RINGBACK"           },
+    { LINECALLSTATE_BUSY               ,"BUSY"               },
+    { LINECALLSTATE_SPECIALINFO        ,"SPECIALINFO"        },
+    { LINECALLSTATE_CONNECTED          ,"CONNECTED"          },
+    { LINECALLSTATE_PROCEEDING         ,"PROCEEDING"         },
+    { LINECALLSTATE_ONHOLD             ,"ONHOLD"             },
+    { LINECALLSTATE_CONFERENCED        ,"CONFERENCED"        },
+    { LINECALLSTATE_ONHOLDPENDCONF     ,"ONHOLDPENDCONF"     },
+    { LINECALLSTATE_ONHOLDPENDTRANSFER ,"ONHOLDPENDTRANSFER" },
+    { LINECALLSTATE_DISCONNECTED       ,"DISCONNECTED"       },
+    { LINECALLSTATE_UNKNOWN            ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP aLineErrs[] =
+{
+    { 0                                ,"<SUCCESS>"              },
+    { LINEERR_ALLOCATED                ,"ALLOCATED"              },
+    { LINEERR_BADDEVICEID              ,"BADDEVICEID"            },
+    { LINEERR_BEARERMODEUNAVAIL        ,"BEARERMODEUNAVAIL"      },
+    { LINEERR_CALLUNAVAIL              ,"CALLUNAVAIL"            },
+    { LINEERR_COMPLETIONOVERRUN        ,"COMPLETIONOVERRUN"      },
+    { LINEERR_CONFERENCEFULL           ,"CONFERENCEFULL"         },
+    { LINEERR_DIALBILLING              ,"DIALBILLING"            },
+    { LINEERR_DIALDIALTONE             ,"DIALDIALTONE"           },
+    { LINEERR_DIALPROMPT               ,"DIALPROMPT"             },
+    { LINEERR_DIALQUIET                ,"DIALQUIET"              },
+    { LINEERR_INCOMPATIBLEAPIVERSION   ,"INCOMPATIBLEAPIVERSION" },
+    { LINEERR_INCOMPATIBLEEXTVERSION   ,"INCOMPATIBLEEXTVERSION" },
+    { LINEERR_INIFILECORRUPT           ,"INIFILECORRUPT"         },
+    { LINEERR_INUSE                    ,"INUSE"                  },
+    { LINEERR_INVALADDRESS             ,"INVALADDRESS"           },
+    { LINEERR_INVALADDRESSID           ,"INVALADDRESSID"         },
+    { LINEERR_INVALADDRESSMODE         ,"INVALADDRESSMODE"       },
+    { LINEERR_INVALADDRESSSTATE        ,"INVALADDRESSSTATE"      },
+    { LINEERR_INVALAPPHANDLE           ,"INVALAPPHANDLE"         },
+    { LINEERR_INVALAPPNAME             ,"INVALAPPNAME"           },
+    { LINEERR_INVALBEARERMODE          ,"INVALBEARERMODE"        },
+    { LINEERR_INVALCALLCOMPLMODE       ,"INVALCALLCOMPLMODE"     },
+    { LINEERR_INVALCALLHANDLE          ,"INVALCALLHANDLE"        },
+    { LINEERR_INVALCALLPARAMS          ,"INVALCALLPARAMS"        },
+    { LINEERR_INVALCALLPRIVILEGE       ,"INVALCALLPRIVILEGE"     },
+    { LINEERR_INVALCALLSELECT          ,"INVALCALLSELECT"        },
+    { LINEERR_INVALCALLSTATE           ,"INVALCALLSTATE"         },
+    { LINEERR_INVALCALLSTATELIST       ,"INVALCALLSTATELIST"     },
+    { LINEERR_INVALCARD                ,"INVALCARD"              },
+    { LINEERR_INVALCOMPLETIONID        ,"INVALCOMPLETIONID"      },
+    { LINEERR_INVALCONFCALLHANDLE      ,"INVALCONFCALLHANDLE"    },
+    { LINEERR_INVALCONSULTCALLHANDLE   ,"INVALCONSULTCALLHANDLE" },
+    { LINEERR_INVALCOUNTRYCODE         ,"INVALCOUNTRYCODE"       },
+    { LINEERR_INVALDEVICECLASS         ,"INVALDEVICECLASS"       },
+    { LINEERR_INVALDEVICEHANDLE        ,"INVALDEVICEHANDLE"      },
+    { LINEERR_INVALDIALPARAMS          ,"INVALDIALPARAMS"        },
+    { LINEERR_INVALDIGITLIST           ,"INVALDIGITLIST"         },
+    { LINEERR_INVALDIGITMODE           ,"INVALDIGITMODE"         },
+    { LINEERR_INVALDIGITS              ,"INVALDIGITS"            },
+    { LINEERR_INVALEXTVERSION          ,"INVALEXTVERSION"        },
+    { LINEERR_INVALGROUPID             ,"INVALGROUPID"           },
+    { LINEERR_INVALLINEHANDLE          ,"INVALLINEHANDLE"        },
+    { LINEERR_INVALLINESTATE           ,"INVALLINESTATE"         },
+    { LINEERR_INVALLOCATION            ,"INVALLOCATION"          },
+    { LINEERR_INVALMEDIALIST           ,"INVALMEDIALIST"         },
+    { LINEERR_INVALMEDIAMODE           ,"INVALMEDIAMODE"         },
+    { LINEERR_INVALMESSAGEID           ,"INVALMESSAGEID"         },
+    { LINEERR_INVALPARAM               ,"INVALPARAM"             },
+    { LINEERR_INVALPARKID              ,"INVALPARKID"            },
+    { LINEERR_INVALPARKMODE            ,"INVALPARKMODE"          },
+    { LINEERR_INVALPOINTER             ,"INVALPOINTER"           },
+    { LINEERR_INVALPRIVSELECT          ,"INVALPRIVSELECT"        },
+    { LINEERR_INVALRATE                ,"INVALRATE"              },
+    { LINEERR_INVALREQUESTMODE         ,"INVALREQUESTMODE"       },
+    { LINEERR_INVALTERMINALID          ,"INVALTERMINALID"        },
+    { LINEERR_INVALTERMINALMODE        ,"INVALTERMINALMODE"      },
+    { LINEERR_INVALTIMEOUT             ,"INVALTIMEOUT"           },
+    { LINEERR_INVALTONE                ,"INVALTONE"              },
+    { LINEERR_INVALTONELIST            ,"INVALTONELIST"          },
+    { LINEERR_INVALTONEMODE            ,"INVALTONEMODE"          },
+    { LINEERR_INVALTRANSFERMODE        ,"INVALTRANSFERMODE"      },
+    { LINEERR_LINEMAPPERFAILED         ,"LINEMAPPERFAILED"       },
+    { LINEERR_NOCONFERENCE             ,"NOCONFERENCE"           },
+    { LINEERR_NODEVICE                 ,"NODEVICE"               },
+    { LINEERR_NODRIVER                 ,"NODRIVER"               },
+    { LINEERR_NOMEM                    ,"NOMEM"                  },
+    { LINEERR_NOREQUEST                ,"NOREQUEST"              },
+    { LINEERR_NOTOWNER                 ,"NOTOWNER"               },
+    { LINEERR_NOTREGISTERED            ,"NOTREGISTERED"          },
+    { LINEERR_OPERATIONFAILED          ,"OPERATIONFAILED"        },
+    { LINEERR_OPERATIONUNAVAIL         ,"OPERATIONUNAVAIL"       },
+    { LINEERR_RATEUNAVAIL              ,"RATEUNAVAIL"            },
+    { LINEERR_RESOURCEUNAVAIL          ,"RESOURCEUNAVAIL"        },
+    { LINEERR_REQUESTOVERRUN           ,"REQUESTOVERRUN"         },
+    { LINEERR_STRUCTURETOOSMALL        ,"STRUCTURETOOSMALL"      },
+    { LINEERR_TARGETNOTFOUND           ,"TARGETNOTFOUND"         },
+    { LINEERR_TARGETSELF               ,"TARGETSELF"             },
+    { LINEERR_UNINITIALIZED            ,"UNINITIALIZED"          },
+    { LINEERR_USERUSERINFOTOOBIG       ,"USERUSERINFOTOOBIG"     },
+    { LINEERR_REINIT                   ,"REINIT"                 },
+    { LINEERR_ADDRESSBLOCKED           ,"ADDRESSBLOCKED"         },
+    { LINEERR_BILLINGREJECTED          ,"BILLINGREJECTED"        },
+    { LINEERR_INVALFEATURE             ,"INVALFEATURE"           },
+    { LINEERR_NOMULTIPLEINSTANCE       ,"NOMULTIPLEINSTANCE"     },
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP aLineMsgs[] =
+{
+    { LINE_ADDRESSSTATE                ,"ADDRESSSTATE"           },
+    { LINE_CALLDEVSPECIFIC             ,"CALLDEVSPECIFIC"        },
+    { LINE_CALLDEVSPECIFICFEATURE      ,"CALLDEVSPECIFICFEATURE" },
+    { LINE_CREATEDIALOGINSTANCE        ,"CREATEDIALOGINSTANCE"   },
+    { LINE_CLOSE                       ,"CLOSE"                  },
+    { LINE_DEVSPECIFIC                 ,"DEVSPECIFIC"            },
+    { LINE_DEVSPECIFICFEATURE          ,"DEVSPECIFICFEATURE"     },
+    { LINE_GATHERDIGITS                ,"GATHERDIGITS"           },
+    { LINE_GENERATE                    ,"GENERATE"               },
+    { LINE_LINEDEVSTATE                ,"LINEDEVSTATE"           },
+    { LINE_MONITORDIGITS               ,"MONITORDIGITS"          },
+    { LINE_MONITORMEDIA                ,"MONITORMEDIA"           },
+    { LINE_MONITORTONE                 ,"MONITORTONE"            },
+    { LINE_SENDDIALOGINSTANCEDATA      ,"SENDDIALOGINSTANCEDATA" },
+    { LINE_REMOVE                      ,"REMOVE"                  },
+    { 0xffffffff                       ,""                       }
+};
+
+
+LOOKUP aPhoneMsgs[] =
+{
+    { PHONE_BUTTON                     ,"BUTTON"                 },
+    { PHONE_CLOSE                      ,"CLOSE"                  },
+    { PHONE_DEVSPECIFIC                ,"DEVSPECIFIC"            },
+    { PHONE_STATE                      ,"STATE"                  },
+    { PHONE_REMOVE                     ,"REMOVE"                  },
+    { 0xffffffff                       ,""                       }
+};
+
+
+LOOKUP aVersions[] =
+{
+    { 0x00010003                       ,"1.0"                    },
+    { 0x00010004                       ,"1.4"                    },
+    { 0x00020000                       ,"2.0"                    },
+    { 0xffffffff                       ,""                       }
+};
+
+
+BOOL        gbESPLoaded = FALSE;
+            gbPBXThreadRunning,
+            gbAutoClose,
+            gbDisableUI;
+LONG        cxList1,
+            cxWnd;
+HWND        ghwndMain,
+            ghwndList1,
+            ghwndList2,
+            ghwndEdit;
+DWORD       gdwTSPIVersion,
+            gdwNumLines,
+            gdwNumAddrsPerLine,
+            gdwNumCallsPerAddr,
+            gdwNumPhones,
+            gdwDebugOptions,
+            gdwCompletionMode,
+            gbAutoGatherGenerateMsgs;
+HMENU       ghMenu;
+HINSTANCE   ghInstance;
+PMYWIDGET   gpWidgets;
+
+char        szMySection[] = "ESP32";
+
+BOOL
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+BOOL
+CALLBACK
+PBXConfigDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+BOOL
+CALLBACK
+HelpDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+void
+ProcessWidgetEvent(
+    PWIDGETEVENT    pEvent
+    );
+
+void
+UpdateESPOptions(
+    void
+    );
+
+void
+SaveIniFileSettings(
+    void
+    );
+
+void
+xxxShowStr(
+    char   *psz
+    );
+
+void
+ShowStr(
+    char   *pszFormat,
+    ...
+    );
+
+LPVOID
+MyAlloc(
+    size_t numBytes
+    );
+
+void
+MyFree(
+    LPVOID  p
+    );
+
+BOOL
+CALLBACK
+ValuesDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
diff --git a/private/tapi/dev/sp/esp.new/exe/espexe.rc b/private/tapi/dev/sp/esp.new/exe/espexe.rc
new file mode 100644
index 000000000..eeda5ab8f
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/espexe.rc
@@ -0,0 +1,251 @@
+//Microsoft App Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#ifdef WIN32
+#include "windows.h"
+#else
+#include "afxres.h"
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+#ifdef APSTUDIO_INVOKED
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 292, 217
+STYLE WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU | 
+    WS_THICKFRAME | WS_CLIPCHILDREN
+CAPTION "ESP: The Economical Service Provider"
+MENU IDR_MENU2
+FONT 6, "Courier"
+BEGIN
+    PUSHBUTTON      "LEvt",IDC_BUTTON1,1,1,16,16,WS_DISABLED
+    PUSHBUTTON      "PEvt",IDC_BUTTON2,19,1,16,16,WS_DISABLED
+    PUSHBUTTON      "Call+",IDC_BUTTON3,37,1,16,16,WS_DISABLED
+    PUSHBUTTON      "Clear",IDC_BUTTON4,55,1,16,16
+    EDITTEXT        IDC_EDIT1,129,19,117,195,ES_MULTILINE | ES_AUTOVSCROLL | 
+                    ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL | 0x1000
+    LISTBOX         IDC_LIST1,62,17,65,197,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LISTBOX         IDC_LIST2,0,0,0,0,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+END
+
+IDD_DIALOG2 DIALOG DISCARDABLE  0, 0, 185, 69
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "About ESPExe"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,69,50,50,14
+    LTEXT           "ESP v2.0",38,88,12,70,7
+    LTEXT           "Copyright (c) 1995 Microsoft Corporation",70,24,30,160,
+                    12
+    ICON            IDI_ICON1,IDC_STATIC1,60,5,18,20
+END
+
+IDD_DIALOG3 DIALOG DISCARDABLE  0, 0, 205, 192
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Parameters:",55,4,6,42,7
+    LISTBOX         IDC_LIST1,4,16,100,148,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Value:",56,116,6,30,7
+    COMBOBOX        IDC_COMBO1,116,16,80,47,CBS_SIMPLE | CBS_AUTOHSCROLL |
+                    CBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Options:",57,116,66,40,9
+    LISTBOX         IDC_LIST2,116,75,80,89,LBS_MULTIPLESEL | 
+                    LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,116,171,36,14
+    PUSHBUTTON      "Cancel",IDCANCEL,160,171,37,14
+END
+
+
+IDD_DIALOG4 DIALOG 6, 18, 192, 138
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU |
+    WS_CLIPCHILDREN
+CAPTION "PBX Simulation"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LISTBOX         IDC_LIST1, 4, 18, 50, 40, WS_VSCROLL | WS_TABSTOP
+    LISTBOX         IDC_LIST2, 60, 18, 70, 40, WS_VSCROLL | WS_TABSTOP
+    LISTBOX         IDC_LIST3, 136, 18, 50, 40, WS_VSCROLL | WS_TABSTOP
+    LISTBOX         IDC_LIST4, 4, 72, 182, 40, WS_VSCROLL | WS_TABSTOP
+    PUSHBUTTON      "Reset", IDC_RESET, 16, 119, 40, 14
+    PUSHBUTTON      "OK", IDOK, 74, 119, 40, 14
+    PUSHBUTTON      "Cancel", IDCANCEL, 134, 119, 40, 14
+    LTEXT           "Number...", 107, 4, 9, 39, 8
+    LTEXT           "of Events...", 108, 60, 9, 49, 8
+    LTEXT           "per Time", 109, 136, 9, 33, 8
+    LTEXT           "Summary", 110, 5, 62, 34, 8
+END
+
+
+IDD_DIALOG5 DIALOG 6, 18, 192, 173
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU |
+    WS_CLIPCHILDREN
+CAPTION "Using ESPExe"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "OK", IDOK, 66, 157, 60, 14
+    EDITTEXT        IDC_EDIT1, 4, 4, 184, 150, ES_MULTILINE | ES_AUTOVSCROLL |
+                    ES_AUTOHSCROLL | ES_READONLY | WS_VSCROLL
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MENU2 MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Install",                            IDM_INSTALL
+        MENUITEM "&Uninstall",                          IDM_UNINSTALL
+        MENUITEM SEPARATOR
+        MENUITEM "&Dump globals",                       IDM_DUMPGLOBALS
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                               IDM_EXIT
+    END
+    POPUP "&Options"
+    BEGIN
+        MENUITEM "&Default values...",                  IDM_DEFAULTS
+        MENUITEM SEPARATOR
+        MENUITEM "Disable UI (for faster auto-testing)",IDM_DISABLEUI
+        MENUITEM SEPARATOR
+        MENUITEM "&Outgoing call state progress...",    IDM_OUTCALLSTATEPROG
+        MENUITEM SEPARATOR
+        POPUP "D&ebug Output"
+        BEGIN
+            MENUITEM "Show function &entry",            IDM_SHOWFUNCENTRY
+            MENUITEM "Show &parameters",                IDM_SHOWFUNCPARAMS
+            MENUITEM "Show function e&xit",             IDM_SHOWFUNCEXIT
+            MENUITEM "Show event &notifications",       IDM_SHOWEVENTS
+            MENUITEM "Show &completion notifications",  IDM_SHOWCOMPLETIONS
+            MENUITEM SEPARATOR
+            MENUITEM "Show &all",                       IDM_SHOWALL
+            MENUITEM "Show n&one",                      IDM_SHOWNONE
+        END
+        MENUITEM "Debug&Break() on function entry",     IDM_DEBUGBREAK
+        MENUITEM SEPARATOR
+
+        POPUP "Complete async requests"
+        BEGIN
+            MENUITEM "Synchronously",                   IDM_SYNCCOMPL
+            MENUITEM "Asynchronously",                  IDM_ASYNCCOMPL
+            MENUITEM "Sync and Async",                  IDM_SYNCASYNCCOMPL
+            MENUITEM "Manually",                        IDM_MANUALCOMPL
+        END
+        MENUITEM "User-specified request results",      IDM_MANUALRESULTS
+        MENUITEM SEPARATOR
+        MENUITEM "PBX simulation config...",            IDM_PBXCONFIG
+        MENUITEM "PBX simulation start",                IDM_PBXSTART
+        MENUITEM "PBX simulation stop",                 IDM_PBXSTOP
+        MENUITEM SEPARATOR
+        MENUITEM "Automatic GATHER/GENERATE msgs",      IDM_AUTOGATHERGENERATEMSGS
+        MENUITEM SEPARATOR
+        MENUITEM "Close &window on shutdown",           IDM_AUTOCLOSE
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Using ESP...",                       IDM_USAGE
+        MENUITEM SEPARATOR
+        MENUITEM "&About...",                           IDM_ABOUT
+    END
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+IDI_ICON1               ICON    DISCARDABLE     "ESP.ICO"
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDR_ACCELERATOR1 ACCELERATORS DISCARDABLE
+BEGIN
+    VK_F1,     IDM_USAGE,    VIRTKEY
+    VK_TAB,    IDC_PREVCTRL, VIRTKEY, SHIFT
+    VK_TAB,    IDC_NEXTCTRL, VIRTKEY
+    VK_RETURN, IDC_ENTER,    VIRTKEY
+END
+
+
+#ifndef APSTUDIO_INVOKED
+////////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Economical Service Provider Application"
+#define VER_INTERNALNAME_STR        "espexe"
+#define VER_ORIGINALFILENAME_STR    "ESPEXE.EXE"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
diff --git a/private/tapi/dev/sp/esp.new/exe/makefile b/private/tapi/dev/sp/esp.new/exe/makefile
new file mode 100644
index 000000000..23524cb99
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/makefile
@@ -0,0 +1,11 @@
+!ifndef NTMAKEENV
+NTMAKEENV=.
+!endif
+
+
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/esp.new/exe/resource.h b/private/tapi/dev/sp/esp.new/exe/resource.h
new file mode 100644
index 000000000..ab20242b8
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/resource.h
@@ -0,0 +1,67 @@
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by ESP.RC
+//
+#define IDR_MENU1                       101
+#define IDD_DIALOG1                     102
+#define IDD_DIALOG2                     103
+#define IDI_ICON1                       104
+#define IDD_DIALOG3                     105
+#define IDD_DIALOG4                     106
+#define IDD_DIALOG5                     107
+#define IDR_ACCELERATOR1                108
+#define IDC_LIST1                       1000
+#define IDC_LIST2                       1001
+#define IDC_LIST3                       1002
+#define IDC_EDIT1                       1003
+#define IDC_STATIC1                     1004
+#define IDC_BUTTON1                     1005
+#define IDC_BUTTON2                     1006
+#define IDC_BUTTON3                     1007
+#define IDC_BUTTON4                     1009
+#define IDC_COMBO1                      1010
+#define IDC_F1HELP                      1011
+#define IDC_PREVCTRL                    1012
+#define IDC_NEXTCTRL                    1013
+#define IDC_ENTER                       1014
+#define IDC_LIST4                       1015
+#define IDC_RESET                       1016
+#define IDM_ABOUT                       40000
+#define IDM_EXIT                        40001
+#define IDM_SHOWFUNCENTRY               40002
+#define IDM_SHOWFUNCPARAMS              40003
+#define IDM_SHOWFUNCEXIT                40004
+#define IDM_SHOWEVENTS                  40005
+#define IDM_SHOWCOMPLETIONS             40006
+#define IDM_MANUALRESULTS               40007
+#define IDM_DEBUGBREAK                  40008
+#define IDM_SHOWALL                     40009
+#define IDM_SHOWNONE                    40010
+#define IDM_OUTCALLSTATEPROG            40011
+#define IDM_AUTOCLOSE                   40012
+#define IDM_INSTALL                     40013
+#define IDM_UNINSTALL                   40014
+#define IDM_USAGE                       40015
+#define IDM_DUMPGLOBALS                 40016
+#define IDM_SYNCCOMPL                   40017
+#define IDM_ASYNCCOMPL                  40018
+#define IDM_SYNCASYNCCOMPL              40019
+#define IDM_MANUALCOMPL                 40020
+#define IDM_DEFAULTS                    40021
+#define IDM_DISABLEUI                   40022
+#define IDM_PBXCONFIG                   40023
+#define IDM_PBXSTART                    40024
+#define IDM_PBXSTOP                     40025
+#define IDM_AUTOGATHERGENERATEMSGS      40026
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        109
+#define _APS_NEXT_COMMAND_VALUE         40027
+#define _APS_NEXT_CONTROL_VALUE         1017
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/sp/esp.new/exe/sources b/private/tapi/dev/sp/esp.new/exe/sources
new file mode 100644
index 000000000..93eed7442
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/exe/sources
@@ -0,0 +1,58 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=espexe
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\gdi32.lib    \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib   \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=espexe.c     \
+        espidl_c.c   \
+        espexe.rc
+
+C_DEFINES=-DTAPI_NT=1
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/esp.new/makefil0 b/private/tapi/dev/sp/esp.new/makefil0
new file mode 100644
index 000000000..caa8b1f9c
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/makefil0
@@ -0,0 +1,71 @@
+#
+# this is the midl compile phase of the build process.
+#
+# The following is where you put the name of your .idl file without
+# the .idl extension:
+#
+
+
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.plt
+
+SDKINC = $(BASEDIR)\public\sdk\inc
+SDKCRTINC = $(BASEDIR)\public\sdk\inc\crt
+INCS  = -I$(SDKINC)  -I$(SDKCRTINC)
+
+CPP = -cpp_cmd "$(MIDL_CPP)" $(MIDL_FLAGS) $(C_DEFINES) $(NET_C_DEFINES)
+
+!else
+
+FLAGS = -D_X86_ -Di386 -D_WCHAR_T_DEFINED
+CPP = -cpp_cmd "cl" -cpp_opt "-E $(FLAGS) $(INCS) $(C_DEFINES)"
+
+HEADER_TARGETS =
+
+!endif
+
+
+
+IDL_NAME  = espidl
+
+CLIENT_TARGETS =   exe\$(IDL_NAME)_c.c  \
+
+SERVER_TARGETS =   tsp\$(IDL_NAME)_s.c
+
+EXTRN_DEPENDS =
+
+
+#
+# Define Products and Dependencies
+#
+
+all:    $(CLIENT_TARGETS) $(SERVER_TARGETS) $(EXTRN_DEPENDS)
+!IF "$(BUILDMSG)" != ""
+    @ech ; $(BUILDMSG) ;
+!ENDIF
+
+clean: delete_source all
+
+delete_source:
+    -erase $(CLIENT_TARGETS) $(SERVER_TARGETS)
+
+#
+# MIDL COMPILE
+#
+
+$(CLIENT_TARGETS) : $(IDL_NAME).idl $(EXTRN_DEPENDS)
+    midl -Oi -server none -oldnames -error allocation -error ref -ms_ext -c_ext $(CPP) $(IDL_NAME).idl $(INCS)
+    IF EXIST $(IDL_NAME)_c.c copy $(IDL_NAME)_c.c .\exe
+    IF EXIST $(IDL_NAME)_c.c del  $(IDL_NAME)_c.c
+
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h .\exe
+
+
+$(SERVER_TARGETS) : $(IDL_NAME).idl $(EXTRN_DEPENDS)
+    midl -client none -oldnames -error stub_data -error allocation -error ref -ms_ext -c_ext $(CPP) $(IDL_NAME).idl $(INCS)
+    IF EXIST $(IDL_NAME)_s.c copy $(IDL_NAME)_s.c .\tsp
+    IF EXIST $(IDL_NAME)_s.c del  $(IDL_NAME)_s.c
+
+    IF EXIST $(IDL_NAME).h copy $(IDL_NAME).h .\tsp
+    IF EXIST $(IDL_NAME).h del  $(IDL_NAME).h
diff --git a/private/tapi/dev/sp/esp.new/tsp/devspec.h b/private/tapi/dev/sp/esp.new/tsp/devspec.h
new file mode 100644
index 000000000..2c8134663
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/devspec.h
@@ -0,0 +1,200 @@
+/*++
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    devspec.h
+
+Abstract:
+
+    This module contains the line/phoneDevSpecific interface
+    definitions for tapi apps to pass data to esp32.tsp,
+    i.e. msgs the app wants esp32.tsp to indicate
+
+Author:
+
+    Dan Knudson (DanKn)    25-Apr-1996
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+
+#define ESPDEVSPECIFIC_KEY  ((DWORD) 'DPSE')
+
+#define ESP_DEVSPEC_MSG     1
+#define ESP_DEVSPEC_RESULT  2
+
+
+//
+// The following structure is used when an app wants to tell esp to
+// indicate a certain message, i.e. LINE_ADDRESSSTATE.  Note that
+// the fields must be filled in with values that are valid at the
+// SPI level, which are not necessarily the same as those at the
+// API level. (Consult the win32 sdk for more info.)  For example,
+// there is no LINE_CALLDEVSPECIFIC message defined a the API level,
+// but it is used at the SPI level to denote that TAPI should pass
+// the corresponding call handle (rather than the line handle) to
+// apps in the hDevice parameter of the LINE_DEVSPECIFIC message
+//
+
+typedef struct _ESPDEVSPECMSG
+{
+    DWORD           dwMsg;
+    DWORD           dwParam1;
+    DWORD           dwParam2;
+    DWORD           dwParam3;
+
+} ESPDEVSPECMSG, *PESPDEVSPECMSG;
+
+
+//
+// The following structure is used when an app wants to tell esp how
+// to complete next request.  (Bear in mind that esp may override the
+// app's request if it encounters an "internal" error somewhere along
+// the way.)  Valid values for the "lResult" field are 0 or any of
+// the LINEERR_XXX / PHONEERR_XXX constants defined in tapi.h.  Valid
+// values for the "dwCompletionType" field are any of the ESP_RESULT_XXX
+// values defined below.
+//
+// This operation allows for testing the following scenarios for
+// synchronous telephony APIs:
+//
+//      1.  Service provider's TSPI_xxx function returns success.
+//          App recives success result
+//
+//      2.  Service provider's TSPI_xxx function returns error.
+//          App recives error result
+//
+// This operation allows for testing the following scenarios for
+// ASYNCHRONOUS telephony APIs (in each case, app recieves a request
+// id from the API, then later a LINE/PHONE_REPLY msg with a matching
+// request id (dwParam1) and result (dwParam2)):
+//
+//      1.  Service provider's TSPI_xxx func calls tapi's completion proc
+//          with success result
+//
+//      2.  Service provider's worker thread calls tapi's completion proc
+//          with success result
+//
+//      3.  Service provider's TSPI_xxx function returns error
+//
+//      4.  Service provider's TSPI_xxx func calls tapi's completion proc
+//          with error result
+//
+//      5.  Service provider's worker thread calls tapi's completion proc
+//          with error result
+//
+
+typedef struct _ESPDEVSPECRESULT
+{
+    LONG            lResult;            // 0, LINEERR_XXX, PHONEERR_XXX
+    DWORD           dwCompletionType;   // ESP_RESULT_XXX
+
+} ESPDEVSPECRESULT, *PESPDEVSPECRESULT;
+
+#define ESP_RESULT_RETURNRESULT         0
+#define ESP_RESULT_CALLCOMPLPROCSYNC    1
+#define ESP_RESULT_CALLCOMPLPROCASYNC   2
+
+
+//
+// The following structure is the device specific information
+// "wrapper".  The app must initialize the dwKey & dwType fields
+// to create a valid header and fill in the appropriate
+// union substructure before passing the info to esp32.tsp via
+// line/phoneDevSpecific.
+//
+// If esp32.tsp detects an invalid parameter(s) it will return an
+// OPERATIONFAILED error, and spit out relevant debug information
+// in the espexe.exe window.
+//
+
+typedef struct _ESPDEVSPECIFICINFO
+{
+    DWORD           dwKey;      // App must init this to ESPDEVSPECIFIC_KEY
+    DWORD           dwType;     // App must init this to ESP_DEVSPEC_MSG, ...
+
+    union
+    {
+
+    ESPDEVSPECMSG       EspMsg;
+    ESPDEVSPECRESULT    EspResult;
+
+    } u;
+
+} ESPDEVSPECIFICINFO, *PESPDEVSPECIFICINFO;
+
+
+/*
+
+//
+// Example: if an app wanted esp32.tsp to indicate a
+//          LINE_LINEDEVSTATE\RENINIT msg it would do
+//          the following
+//
+
+{
+    LONG                 lResult;
+    HLINE                hLine;
+    ESPDEVSPECIFICINFO   info;
+
+
+    // do a lineInitialize, lineNegotiateAPIVersion, lineOpen, etc...
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+
+    info.u.EspMsg.dwMsg    = LINE_LINEDEVSTATE;
+    info.u.EspMsg.dwParam1 = LINEDEVSTATE_REINIT;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lResult = lineDevSpecific (hLine, 0, NULL, &info, sizeof (info));
+
+    // some time later a LINE_LINEDEVSTATE\REINIT msg will show up
+}
+
+
+//
+// Example: if an app wanted esp32.tsp to fail a request
+//          to lineMakeCall asynchronously with the error
+//          LINEERR_CALLUNAVAIL it would do the following
+//          (ESP's worker thread would complete the request
+//          in this case)
+//
+
+{
+    LONG                 lResult, lResult2;
+    HCALL                hCall;
+    HLINE                hLine;
+    ESPDEVSPECIFICINFO   info;
+
+
+    // do a lineInitialize, lineNegotiateAPIVersion, lineOpen, etc...
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+    info.u.EspResult.lResult          = LINEERR_CALLUNAVAIL;
+    info.u.EspResult.dwCompletionType = ESP_RESULT_CALLCOMPLPROCASYNC;
+
+    lResult = lineDevSpecific (hLine, 0, NULL, &info, sizeof (info));
+
+    lResult2 = lineMakeCall (hLine, &hCall, "555-1212", 1, NULL);
+
+    // some time later a LINE_REPLY will show for for both the DevSpecific
+    // & MakeCall requests.  the LINE_REPLY for the MakeCall will have
+    // dwParam1 = lResult2, and dwParam2 = LINEERR_CALLUNAVAIL
+}
+
+
+*/
diff --git a/private/tapi/dev/sp/esp.new/tsp/esp.c b/private/tapi/dev/sp/esp.new/tsp/esp.c
new file mode 100644
index 000000000..682166e1e
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/esp.c
@@ -0,0 +1,11878 @@
+/*++
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    esp.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    18-Sep-1995
+
+Revision History:
+
+
+Notes:
+
+    1. Regarding the SP filling in structures with variable length fields
+       (dwXxxSize/dwXxxOffset) : "The SP's variable size fields start
+       immediately after the fixed part of the data structure.  The order
+       of filling of the variable size fields owned by the SP is not
+       specified.  The SP can fill them in any order it desires.  Filling
+       should be contiguous, starting at the beginning of the variable
+       part." (Taken from Chapter 2 of the SPI Programmer's Guide.)
+
+--*/
+
+
+#include "stdarg.h"
+#include "stdio.h"
+#include "stdlib.h"
+//#include "malloc.h"
+#include "string.h"
+#include "esp.h"
+#include "devspec.h"
+#include "vars.h"
+
+
+#define MAX_NUM_PARKED_CALLS 16
+
+LONG        glNextRequestResult = 0;
+DWORD       gdwNextRequestCompletionType;
+DWORD       gdwDevSpecificRequestID;
+DWORD       gdwCallID = 1;
+BOOL        gbExitPBXThread;
+BOOL        gbDisableUI;
+BOOL        gbAutoGatherGenerateMsgs;
+BOOL        gbManualResults = FALSE;
+BOOL        gbInteractWithDesktop = FALSE;
+DWORD       gdwCallInstance = 0;
+WCHAR       gszProviderInfo[] = L"ESP v2.0";
+HANDLE      ghPBXThread = NULL;
+PDRVCALL    gaParkedCalls[MAX_NUM_PARKED_CALLS];
+
+static WCHAR *aszDeviceClasses[] =
+{
+    L"tapi/line",
+    L"tapi/phone",
+    L"wave",
+    L"wave/in",
+    L"wave/out",
+    L"comm",
+    L"comm/datamodem",
+    (WCHAR *) NULL
+};
+
+
+BOOL
+PASCAL
+IsValidDrvCall(
+    PDRVCALL    pCall,
+    LPDWORD     pdwCallInstance
+    );
+
+BOOL
+CALLBACK
+ValuesDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+LONG
+PASCAL
+CreateIncomingCall(
+    LPCWSTR             lpszDestAddress,
+    LPLINECALLPARAMS    lpCallParams,
+    PDRVCALL            pOutgoingCall,
+    BOOL               *pbValidESPAddress,
+    PDRVLINE           *ppIncomingLine,
+    PDRVCALL           *ppIncomingCall
+    );
+
+LONG
+PASCAL
+TransferCall(
+    PFUNC_INFO  pInfo,
+    PDRVCALL    pCall,
+    DWORD       dwValidCurrentCallStates,
+    DWORD       dwNewCallState,
+    LPCWSTR     lpszDestAddress
+    );
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    static BOOL   bLoadedByTapisrv;
+    static HANDLE hInitEvent;
+
+
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+    {
+        UINT uiResult;
+
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            OutputDebugString ("ESP: DllMain: _CRT_INIT() failed\n\r");
+        }
+
+        ghInstance = hDLL;
+
+
+        //
+        // Grab ini file settings
+        //
+#if DBG
+
+        {
+        HKEY    hKey;
+        DWORD   dwDataSize, dwDataType;
+        TCHAR   szTelephonyKey[] =
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                szEsp32DebugLevel[] = "Esp32DebugLevel";
+
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            szTelephonyKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hKey
+            );
+
+        dwDataSize = sizeof (DWORD);
+        gdwDebugLevel=0;
+
+        RegQueryValueEx(
+            hKey,
+            szEsp32DebugLevel,
+            0,
+            &dwDataType,
+            (LPBYTE) &gdwDebugLevel,
+            &dwDataSize
+            );
+
+        RegCloseKey (hKey);
+        }
+
+#endif
+        //
+        // Determine whether we're being loaded by tapisrv or some
+        // other process (i.e. telephony ctrl panel)- this will tell
+        // us whether we need to go thru all the necessary init or not
+        //
+
+        {
+            char           *pszProcessName;
+            STARTUPINFO     si;
+
+
+            GetStartupInfoA (&si);
+
+            pszProcessName = si.lpTitle + (lstrlenA (si.lpTitle) - 1);
+
+            for (; pszProcessName != si.lpTitle; pszProcessName--)
+            {
+                if (*pszProcessName == '\\')
+                {
+                    pszProcessName++;
+                    break;
+                }
+            }
+
+            bLoadedByTapisrv = (lstrcmpiA (pszProcessName, "tapisrv.exe") == 0
+                ? TRUE : FALSE);
+        }
+
+        if (bLoadedByTapisrv)
+        {
+            {
+                typedef struct _XXX
+                {
+                    DWORD    dwDefValue;
+
+                    LPCSTR   pszValueName;
+
+                    LPDWORD  pdwValue;
+
+                } XXX, *PXXX;
+
+                XXX axxx[] =
+                {
+                    {   DEF_SPI_VERSION,
+                        "TSPIVersion",
+                        &gESPGlobals.dwSPIVersion },
+                    {   DEF_NUM_LINES,
+                        "NumLines",
+                        &gESPGlobals.dwNumLines },
+                    {   DEF_NUM_ADDRS_PER_LINE,
+                        "NumAddrsPerLine",
+                        &gESPGlobals.dwNumAddressesPerLine },
+                    {   DEF_NUM_CALLS_PER_ADDR,
+                        "NumCallsPerAddr",
+                        &gESPGlobals.dwNumCallsPerAddress },
+                    {   DEF_NUM_PHONES,
+                        "NumPhones",
+                        &gESPGlobals.dwNumPhones },
+                    {   DEF_DEBUG_OPTIONS,
+                        "DebugOutput",
+                        &gESPGlobals.dwDebugOptions },
+                    {   DEF_COMPLETION_MODE,
+                        "Completion",
+                        &gESPGlobals.dwCompletionMode },
+                    {   0,
+                        "DisableUI",
+                        &gbDisableUI },
+                    {   1,
+                        "AutoGatherGenerateMsgs",
+                        &gbAutoGatherGenerateMsgs },
+                    {   0,
+                        NULL,
+                        NULL },
+                };
+                DWORD   i;
+
+
+                for (i = 0; axxx[i].pszValueName; i++)
+                {
+                    *(axxx[i].pdwValue) = (DWORD) GetProfileInt(
+                        "ESP32",
+                        axxx[i].pszValueName,
+                        (int) axxx[i].dwDefValue
+                        );
+
+                }
+            }
+
+
+            //
+            //
+            //
+
+            InitializeCriticalSection (&gESPGlobals.CallListCritSec);
+            InitializeCriticalSection (&gESPGlobals.PhoneCritSec);
+            InitializeCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+
+            if (gbDisableUI)
+            {
+                //
+                // Don't bother doing all the stuff to sync/start up espexe.
+                // However, we do want to make sure that we're not wasting
+                // time spewing dbg output nor completing async requests in
+                // any way other than inline (synchronously), since we're
+                // not real smart about cleaning up pending async requests
+                // when a call or line is closed/destroyed.
+                //
+
+                gESPGlobals.dwDebugOptions = 0;
+                gESPGlobals.dwCompletionMode =
+                    COMPLETE_ASYNC_EVENTS_SYNCHRONOUSLY;
+                gbAutoGatherGenerateMsgs = FALSE; //TRUE;
+            }
+            else
+            {
+                //
+                // Check to see if tapisrv has the "interact with
+                // desktop" privilege enabled
+                //
+
+                {
+                    SC_HANDLE hSCManager, hTapisrvSvc;
+
+
+                    if ((hSCManager = OpenSCManager(
+                            NULL,
+                            NULL,
+                            GENERIC_READ
+                            )))
+                    {
+                        if ((hTapisrvSvc = OpenService(
+                                hSCManager,
+                                "tapisrv",
+                                SERVICE_QUERY_CONFIG
+                                )))
+                        {
+                            DWORD                   dwNeededSize;
+                            QUERY_SERVICE_CONFIG    config;
+
+
+                            if (!QueryServiceConfig(
+                                    hTapisrvSvc,
+                                    &config,
+                                    sizeof (QUERY_SERVICE_CONFIG),
+                                    &dwNeededSize
+                                    ))
+                            {
+                                QUERY_SERVICE_CONFIG   *pConfig;
+
+
+                                config.dwServiceType = 0;
+
+                                if (GetLastError() ==
+                                        ERROR_INSUFFICIENT_BUFFER)
+                                {
+                                    if ((pConfig = DrvAlloc (dwNeededSize)))
+                                    {
+                                        if (QueryServiceConfig(
+                                                hTapisrvSvc,
+                                                pConfig,
+                                                dwNeededSize,
+                                                &dwNeededSize
+                                                ))
+                                        {
+                                            config.dwServiceType =
+                                                pConfig->dwServiceType;
+                                        }
+
+                                        DrvFree (pConfig);
+                                    }
+                                }
+                            }
+
+                            gbInteractWithDesktop = (BOOL)
+                                (config.dwServiceType &
+                                SERVICE_INTERACTIVE_PROCESS);
+
+                            CloseServiceHandle (hTapisrvSvc);
+                        }
+
+                        CloseServiceHandle (hSCManager);
+                    }
+                }
+
+                if (!gbInteractWithDesktop)
+                {
+                    gESPGlobals.dwDebugOptions &= ~MANUAL_RESULTS;
+                }
+
+
+                //
+                //
+                //
+
+                InitializeCriticalSection (&gESPGlobals.DebugBufferCritSec);
+                InitializeCriticalSection (&gESPGlobals.EventBufferCritSec);
+
+                gESPGlobals.dwDebugBufferTotalSize = 2048;
+                gESPGlobals.dwDebugBufferUsedSize  = 0;
+
+                gESPGlobals.pDebugBuffer =
+                gESPGlobals.pDebugBufferIn =
+                gESPGlobals.pDebugBufferOut = DrvAlloc(
+                    gESPGlobals.dwDebugBufferTotalSize
+                    );
+
+                gESPGlobals.dwEventBufferTotalSize = 40 * sizeof (WIDGETEVENT);
+                gESPGlobals.dwEventBufferUsedSize  = 0;
+
+                gESPGlobals.pEventBuffer =
+                gESPGlobals.pEventBufferIn =
+                gESPGlobals.pEventBufferOut = DrvAlloc(
+                    gESPGlobals.dwEventBufferTotalSize
+                    );
+
+
+                //
+                // Create the events used to sync up w/ espexe, and
+                // start espexe if it's not already running
+                //
+
+                ghDebugOutputEvent = CreateEvent(
+                    (LPSECURITY_ATTRIBUTES) NULL,
+                    TRUE,           // manual reset
+                    FALSE,          // non-signaled
+                    NULL            // unnamed
+                    );
+
+                ghWidgetEventsEvent = CreateEvent(
+                    (LPSECURITY_ATTRIBUTES) NULL,
+                    TRUE,           // manual reset
+                    FALSE,          // non-signaled
+                    NULL            // unnamed
+                    );
+
+                ghShutdownEvent = CreateEvent(
+                    (LPSECURITY_ATTRIBUTES) NULL,
+                    FALSE,          // auto reset
+                    FALSE,          // non-signaled
+                    NULL            // unnamed
+                    );
+
+
+                //
+                // Enable rpc server interface
+                //
+
+                {
+                    RPC_STATUS  status;
+                    unsigned char * pszSecurity         = NULL;
+                    unsigned int    cMaxCalls           = 20;
+
+
+                    status = RpcServerUseProtseqEp(
+                        "ncalrpc",
+                        cMaxCalls,
+                        "esplpc",
+                        pszSecurity             // Security descriptor
+                        );
+
+                    DBGOUT((3, "RpcServerUseProtseqEp(lrpc) ret'd %d", status));
+
+                    if (status)
+                    {
+                    }
+
+                    status = RpcServerRegisterIf(
+                        esp_ServerIfHandle,     // interface to register
+                        NULL,                   // MgrTypeUuid
+                        NULL                    // MgrEpv; null means use default
+                        );
+
+                    DBGOUT((3, "RpcServerRegisterIf ret'd %d", status));
+
+                    if (status)
+                    {
+                    }
+                }
+
+
+                if ((hInitEvent = OpenEvent(
+                        EVENT_ALL_ACCESS,
+                        FALSE, "ESPevent"
+                        )))
+                {
+                    SetEvent (hInitEvent);
+                }
+                else
+                {
+                    hInitEvent = CreateEvent(
+                        (LPSECURITY_ATTRIBUTES) NULL,
+                        FALSE,      // auto reset
+                        TRUE,       // signaled
+                        "ESPevent"
+                        );
+
+                    DBGOUT((3, "Starting espexe..."));
+
+                    if ((uiResult = WinExec ("espexe.exe", SW_SHOW)) < 32)
+                    {
+                        DBGOUT((
+                            1,
+                            "WinExec(espexe.exe) failed, err=%d",
+                            uiResult
+                            ));
+
+                        gESPGlobals.dwDebugOptions = 0;
+                        gESPGlobals.dwCompletionMode =
+                            COMPLETE_ASYNC_EVENTS_SYNCHRONOUSLY;
+                    }
+#if DBG
+                    else
+                    {
+                        DBGOUT((3, "started espexe"));
+                    }
+#endif
+                }
+            }
+        }
+
+        break;
+    }
+    case DLL_PROCESS_DETACH:
+
+        if (bLoadedByTapisrv)
+        {
+            if (gbDisableUI == FALSE)
+            {
+                SetEvent (ghShutdownEvent);
+
+                //
+                // Unregister out rpc server interface
+                //
+
+                {
+                    RPC_STATUS  status;
+
+
+                    status = RpcServerUnregisterIf(
+                        esp_ServerIfHandle,         // interface to register
+                        NULL,                       // MgrTypeUuid
+                        0                           // wait for calls to complete
+                        );
+
+                    DBGOUT((3, "RpcServerUntegisterIf ret'd %d", status));
+                }
+
+                CloseHandle (ghDebugOutputEvent);
+                CloseHandle (ghWidgetEventsEvent);
+                CloseHandle (ghShutdownEvent);
+                CloseHandle (hInitEvent);
+
+                DeleteCriticalSection (&gESPGlobals.DebugBufferCritSec);
+                DeleteCriticalSection (&gESPGlobals.EventBufferCritSec);
+
+                DrvFree (gESPGlobals.pDebugBuffer);
+                DrvFree (gESPGlobals.pEventBuffer);
+            }
+
+            DeleteCriticalSection (&gESPGlobals.CallListCritSec);
+            DeleteCriticalSection (&gESPGlobals.PhoneCritSec);
+            DeleteCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+        }
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            OutputDebugString ("ESP: DllMain: _CRT_INIT() failed\n\r");
+        }
+
+        break;
+
+    default:
+
+        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+        {
+            OutputDebugString ("ESP: DllMain: _CRT_INIT() failed\n\r");
+        }
+
+        break;
+    }
+
+    return TRUE;
+}
+
+
+void
+AsyncEventQueueServiceThread(
+    LPVOID  pParams
+    )
+{
+    while (1)
+    {
+        WaitForSingleObject (gESPGlobals.hAsyncEventsPendingEvent, INFINITE);
+
+        while (1)
+        {
+            PASYNC_REQUEST_INFO pAsyncReqInfo;
+
+
+            EnterCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+
+            if (gESPGlobals.dwNumUsedQueueEntries == 0)
+            {
+                ResetEvent (gESPGlobals.hAsyncEventsPendingEvent);
+                LeaveCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+                break;
+            }
+
+            pAsyncReqInfo = (PASYNC_REQUEST_INFO)
+                (*gESPGlobals.pAsyncRequestQueueOut);
+
+            gESPGlobals.pAsyncRequestQueueOut++;
+
+            if (gESPGlobals.pAsyncRequestQueueOut ==
+                    (gESPGlobals.pAsyncRequestQueue +
+                        gESPGlobals.dwNumTotalQueueEntries))
+            {
+                gESPGlobals.pAsyncRequestQueueOut =
+                    gESPGlobals.pAsyncRequestQueue;
+            }
+
+            gESPGlobals.dwNumUsedQueueEntries--;
+
+            LeaveCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+
+            if (pAsyncReqInfo->pfnPostProcessProc)
+            {
+                (*(pAsyncReqInfo->pfnPostProcessProc))(
+                    pAsyncReqInfo,
+                    ASYNC
+                    );
+            }
+            else
+            {
+                DoCompletion (pAsyncReqInfo, ASYNC);
+            }
+
+            DrvFree (pAsyncReqInfo);
+        }
+
+        if (gESPGlobals.bProviderShutdown)
+        {
+            break;
+        }
+    }
+
+    ExitThread (0);
+}
+
+
+void
+PBXThread(
+    LPVOID  pParams
+    )
+{
+    DWORD  *pPBXSettings = (LPDWORD) pParams,
+            dwTickCount, dwElapsedTime,
+            dwTimePerNewCall = pPBXSettings[0], dwLastNewCallTickCount,
+            dwTimePerDisconnect = pPBXSettings[1], dwLastDisconnectTickCount;
+
+/*
+    DWORD   dwTickCount, dwElapsedTime,
+            dwLastNewCallTickCount, dwLastDisconnectTickCount,
+            dwTimePerNewCall = (gPBXSettings[0].dwNumber ?
+                gPBXSettings[0].dwTime / gPBXSettings[0].dwNumber : 0),
+            dwTimePerDisconnect = (gPBXSettings[1].dwNumber ?
+                gPBXSettings[1].dwTime / gPBXSettings[1].dwNumber : 0);
+*/
+
+    ShowStr (TRUE, "PBXThread: enter");
+
+    // BUGBUG acct for 49.7 day tick count wrap
+
+    dwTickCount =
+    dwLastNewCallTickCount =
+    dwLastDisconnectTickCount = GetTickCount();
+
+    ShowStr(
+        TRUE,
+        "dwTimePerNewCall = %d, dwTimePerDisconnect = %d",
+        dwTimePerNewCall,
+        dwTimePerDisconnect
+        );
+
+    while (1)
+    {
+        Sleep (1000);
+
+        if (gbExitPBXThread)
+        {
+            break;
+        }
+
+        dwTickCount += 1000;
+
+        if (dwTimePerNewCall)
+        {
+            dwElapsedTime = dwTickCount - dwLastNewCallTickCount;
+
+            while (dwElapsedTime >= dwTimePerNewCall)
+            {
+                //
+                // Generate new call (random line, random media mode)
+                //
+
+                DWORD   i = rand(), j;
+
+
+                for (j = 0; j < gESPGlobals.dwInitialNumLines; j++)
+                {
+                    PDRVLINE    pLine = GetLineFromID(
+                                    i % gESPGlobals.dwInitialNumLines +
+                                    gESPGlobals.dwLineDeviceIDBase
+                                    );
+
+
+                    if (pLine->dwMediaModes)
+                    {
+                        DWORD       dwMediaMode;
+                        PDRVCALL    pCall;
+
+
+                        for(
+                            dwMediaMode =
+                                (LINEMEDIAMODE_INTERACTIVEVOICE << i % 13);
+                            dwMediaMode <= LAST_LINEMEDIAMODE;
+                            dwMediaMode <<= 1
+                            )
+                        {
+                            if (pLine->dwMediaModes & dwMediaMode)
+                            {
+                                goto PBXThread_allocCall;
+                            }
+                        }
+
+                        for(
+                            dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+                            dwMediaMode <= LAST_LINEMEDIAMODE;
+                            dwMediaMode <<= 1
+                            )
+                        {
+                            if (pLine->dwMediaModes & dwMediaMode)
+                            {
+                                break;
+                            }
+                        }
+
+PBXThread_allocCall:
+                        if (AllocCall (pLine, NULL, NULL, &pCall) == 0)
+                        {
+                            pCall->dwMediaMode = dwMediaMode;
+
+                            SendLineEvent(
+                                pLine,
+                                NULL,
+                                LINE_NEWCALL,
+                                (DWORD) pCall,
+                                (DWORD) &pCall->htCall,
+                                0
+                                );
+
+                            if (!pCall->htCall)
+                            {
+                                FreeCall (pCall, pCall->dwCallInstance);
+                                continue;
+                            }
+
+                            SetCallState(
+                                pCall,
+                                pCall->dwCallInstance,
+                                0xffffffff,
+                                LINECALLSTATE_OFFERING,
+                                0,
+                                FALSE
+                                );
+
+                            break;
+                        }
+
+                    }
+
+                    i++;
+                }
+
+                dwElapsedTime -= dwTimePerNewCall;
+
+                dwLastNewCallTickCount = dwTickCount;
+            }
+        }
+
+        if (dwTimePerDisconnect)
+        {
+            dwElapsedTime = dwTickCount - dwLastDisconnectTickCount;
+
+            while (dwElapsedTime >= dwTimePerDisconnect)
+            {
+                //
+                // Disconnect a random (non-idle) call (random disconnect mode)
+                //
+
+                DWORD   i = rand(), j, k;
+
+
+                for (j = 0; j < gESPGlobals.dwInitialNumLines; j++)
+                {
+                    DWORD       dwInitialAddrID =
+                                    i % gESPGlobals.dwNumAddressesPerLine,
+                                dwLastAddrID =
+                                    gESPGlobals.dwNumAddressesPerLine;
+                    PDRVLINE    pLine = GetLineFromID(
+                                    i % gESPGlobals.dwInitialNumLines +
+                                    gESPGlobals.dwLineDeviceIDBase
+                                    );
+
+PBXThread_findCallToDisconnect:
+
+                    for (
+                        k = dwInitialAddrID;
+                        k < dwLastAddrID;
+                        k++
+                        )
+                    {
+                        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (pLine->aAddrs[k].dwNumCalls)
+                        {
+                            PDRVCALL pCall = pLine->aAddrs[k].pCalls;
+
+                            while (pCall &&
+                                   pCall->dwCallState == LINECALLSTATE_IDLE)
+                            {
+                                pCall = pCall->pNext;
+                            }
+
+                            if (pCall)
+                            {
+                                DWORD   dwDisconnectMode =
+                                          LINEDISCONNECTMODE_NORMAL;
+
+
+                                // BUGBUG disconnectMode depends on curr state
+
+                                SetCallState(
+                                    pCall,
+                                    pCall->dwCallInstance,
+                                    0xffffffff,
+                                    LINECALLSTATE_DISCONNECTED,
+                                    dwDisconnectMode,
+                                    FALSE
+                                    );
+
+                                SetCallState(
+                                    pCall,
+                                    pCall->dwCallInstance,
+                                    0xffffffff,
+                                    LINECALLSTATE_IDLE,
+                                    0,
+                                    FALSE
+                                    );
+
+                                LeaveCriticalSection(
+                                    &gESPGlobals.CallListCritSec
+                                    );
+
+                                goto PBXThread_droppedCall;
+                            }
+                        }
+
+                        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+                    }
+
+                    if (dwInitialAddrID != 0)
+                    {
+                        dwLastAddrID = dwInitialAddrID;
+                        dwInitialAddrID = 0;
+                        goto PBXThread_findCallToDisconnect;
+                    }
+
+                    i++;
+                }
+
+PBXThread_droppedCall:
+
+                dwElapsedTime -= dwTimePerDisconnect;
+
+                dwLastDisconnectTickCount = dwTickCount;
+            }
+        }
+    }
+
+    DrvFree (pPBXSettings);
+
+    ShowStr (TRUE, "PBXThread: exit");
+
+    ExitThread (0);
+}
+
+
+void
+PASCAL
+InsertVarData(
+    LPVOID      lpXxx,
+    LPDWORD     pdwXxxSize,
+    LPVOID      pData,
+    DWORD       dwDataSize
+    )
+{
+    DWORD       dwAlignedSize, dwUsedSize;
+    LPVARSTRING lpVarString = (LPVARSTRING) lpXxx;
+
+
+    if (dwDataSize != 0)
+    {
+        //
+        // Align var data on 64-bit boundaries
+        //
+
+        if ((dwAlignedSize = dwDataSize) & 7)
+        {
+            dwAlignedSize += 8;
+            dwAlignedSize &= 0xfffffff8;
+
+        }
+
+
+        //
+        // The following if statement should only be TRUE the first time
+        // we're inserting data into a given structure that does not have
+        // an even number of DWORD fields
+        //
+
+        if ((dwUsedSize = lpVarString->dwUsedSize) & 7)
+        {
+            dwUsedSize += 8;
+            dwUsedSize &= 0xfffffff8;
+
+            lpVarString->dwNeededSize += dwUsedSize - lpVarString->dwUsedSize;
+        }
+
+        lpVarString->dwNeededSize += dwAlignedSize;
+
+        if ((dwUsedSize + dwAlignedSize) <= lpVarString->dwTotalSize)
+        {
+            CopyMemory(
+                ((LPBYTE) lpVarString) + dwUsedSize,
+                pData,
+                dwDataSize
+                );
+
+            *pdwXxxSize = dwDataSize;
+            pdwXxxSize++;             // pdwXxxSize = pdwXxxOffset
+            *pdwXxxSize = dwUsedSize;
+
+            lpVarString->dwUsedSize = dwUsedSize + dwAlignedSize;
+        }
+
+    }
+}
+
+
+void
+PASCAL
+InsertVarDataString(
+    LPVOID      lpXxx,
+    LPDWORD     pdwXxxSize,
+    WCHAR      *psz
+    )
+{
+    DWORD       dwRealSize = (lstrlenW (psz) + 1) * sizeof (WCHAR),
+                dwAlignedSize;
+    LPVARSTRING lpVarString = (LPVARSTRING) lpXxx;
+
+
+    if (dwRealSize % 4)
+    {
+        dwAlignedSize = dwRealSize - (dwRealSize % 4) + 4;
+    }
+    else
+    {
+        dwAlignedSize = dwRealSize;
+    }
+
+    lpVarString->dwNeededSize += dwAlignedSize;
+
+    if ((lpVarString->dwUsedSize + dwAlignedSize) <= lpVarString->dwTotalSize)
+    {
+        CopyMemory(
+            ((LPBYTE) lpVarString) + lpVarString->dwUsedSize,
+            psz,
+            dwRealSize
+            );
+
+        *pdwXxxSize = dwRealSize;
+        pdwXxxSize++;
+        *pdwXxxSize = lpVarString->dwUsedSize;
+
+        lpVarString->dwUsedSize += dwAlignedSize;
+    }
+}
+
+
+//
+// We get a slough of C4047 (different levels of indrection) warnings down
+// below in the initialization of FUNC_PARAM structs as a result of the
+// real func prototypes having params that are types other than DWORDs,
+// so since these are known non-interesting warnings just turn them off
+//
+
+#pragma warning (disable:4047)
+
+
+//
+// --------------------------- TSPI_lineXxx funcs -----------------------------
+//
+
+void
+FAR
+PASCAL
+TSPI_lineAccept_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD      dwCallInstThen = pAsyncReqInfo->dwParam2;
+        PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+        pAsyncReqInfo->lResult = SetCallState(
+            pCall,
+            dwCallInstThen,
+            LINECALLSTATE_OFFERING,
+            LINECALLSTATE_ACCEPTED,
+            0,
+            TRUE
+            );
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "lineAccept";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_lineAccept_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam2))
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineAddToConference_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD      dwConfCallInstThen = pAsyncReqInfo->dwParam3,
+                   dwConsultCallInstThen = pAsyncReqInfo->dwParam4,
+                   dwConfCallInstNow;
+        PDRVCALL   pConfCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+        PDRVCALL   pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pConfCall, &dwConfCallInstNow)  &&
+            dwConfCallInstNow == dwConfCallInstThen)
+        {
+            if ((pAsyncReqInfo->lResult = SetCallState(
+                    pConsultCall,
+                    dwConsultCallInstThen,
+                    0xffffffff,
+                    LINECALLSTATE_CONFERENCED,
+                    0,
+                    TRUE
+
+                    )) == 0)
+            {
+                pConsultCall->pConfParent = pConfCall;
+                pConsultCall->pNextConfChild = pConfCall->pNextConfChild;
+
+                pConfCall->pNextConfChild = pConsultCall;
+            }
+        }
+        else
+        {
+            pAsyncReqInfo->lResult == LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdConfCall,
+    HDRVCALL        hdConsultCall
+    )
+{
+    static char szFuncName[] = "lineAddToConference";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { "hdConfCall",     hdConfCall      },
+        { "hdConsultCall",  hdConsultCall   }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        3,
+        params,
+        TSPI_lineAddToConference_postProcess
+    };
+    PDRVCALL pConfCall = (PDRVCALL) hdConfCall;
+    PDRVCALL pConsultCall = (PDRVCALL) hdConsultCall;
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall(
+                (PDRVCALL) hdConfCall,
+                &info.pAsyncReqInfo->dwParam3
+                ) &&
+
+            IsValidDrvCall(
+                (PDRVCALL) hdConsultCall,
+                &info.pAsyncReqInfo->dwParam4
+                ))
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdConfCall;
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdConsultCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineAnswer_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD      dwCallInstThen = pAsyncReqInfo->dwParam2;
+        PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+        pAsyncReqInfo->lResult = SetCallState(
+            pCall,
+            dwCallInstThen,
+            LINECALLSTATE_OFFERING | LINECALLSTATE_ACCEPTED,
+            LINECALLSTATE_CONNECTED,
+            0,
+            TRUE
+            );
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "lineAnswer";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_lineAnswer_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam2))
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    static char szFuncName[] = "lineBlindTransfer";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 4, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+        info.lResult = TransferCall(
+            &info,
+            (PDRVCALL) hdCall,
+            LINECALLSTATE_CONNECTED | LINECALLSTATE_ONHOLD,
+            LINECALLSTATE_OFFERING,
+            lpszDestAddress
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE    hdLine
+    )
+{
+    static char szFuncName[] = "lineClose";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine, hdLine  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 1, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    //
+    // This is more of a "command" than a request, in that TAPI.DLL is
+    // going to consider the line closed whether we like it or not.
+    // Therefore we want to free up the line even if the user chooses
+    // to return an error.
+    //
+
+    Prolog (&info);
+
+    pLine->htLine = (HTAPILINE) NULL;
+    pLine->dwMediaModes = 0;
+
+    WriteEventBuffer (pLine->dwDeviceID,  WIDGETTYPE_LINE, 0, 0, 0, 0);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL    hdCall
+    )
+{
+    DWORD       dwCallInst;
+    static char szFuncName[] = "lineCloseCall";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall, hdCall  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 1, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    //
+    // This is more of a "command" than a request, in that TAPI.DLL is
+    // going to consider the call closed whether we like it or not.
+    // Therefore we want to free up the call even if the user chooses
+    // to return an error.
+    //
+
+    Prolog (&info);
+
+    if (IsValidDrvCall (pCall, &dwCallInst))
+    {
+        WriteEventBuffer(
+            ((PDRVLINE) pCall->pLine)->dwDeviceID, // BUGBUG: AV potential
+            WIDGETTYPE_CALL,
+            (DWORD) pCall,
+            0,
+            0,
+            0
+            );
+
+        FreeCall (pCall, dwCallInst);
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPDWORD         lpdwCompletionID,
+    DWORD           dwCompletionMode,
+    DWORD           dwMessageID
+    )
+{
+    static char szFuncName[] = "lineCompleteCall";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { szhdCall,             hdCall              },
+        { "lpdwCompletionID",   lpdwCompletionID    },
+        { "dwCompletionMode",   dwCompletionMode    },
+        { "dwMessageID",        dwMessageID         }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 5, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+        if (dwMessageID >= MAX_NUM_COMPLETION_MESSAGES)
+        {
+            info.lResult = LINEERR_INVALMESSAGEID;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineCompleteTransfer_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD      dwCallInstThen        = pAsyncReqInfo->dwParam1,
+               dwConsultCallInstThen = pAsyncReqInfo->dwParam2,
+               dwConfCallInstThen    = pAsyncReqInfo->dwParam6,
+               dwCallInstNow, dwConsultCallInstNow, dwConfCallInstNow;
+    PDRVCALL   pCall        = (PDRVCALL) pAsyncReqInfo->dwParam3,
+               pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam4,
+               pConfCall    = (PDRVCALL) pAsyncReqInfo->dwParam5;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, &dwCallInstNow)  &&
+            dwCallInstNow == dwCallInstThen  &&
+            IsValidDrvCall (pConsultCall, &dwConsultCallInstNow)  &&
+            dwConsultCallInstNow == dwConsultCallInstThen)
+        {
+            if (pConfCall)
+            {
+                if (IsValidDrvCall (pConfCall, &dwConfCallInstNow)  &&
+                    dwConfCallInstNow == dwConfCallInstThen)
+                {
+                    pConfCall->pNextConfChild = pCall;
+                    pCall->pNextConfChild     = pConsultCall;
+                    pCall->pConfParent        = pConfCall;
+                    pConsultCall->pConfParent = pConfCall;
+                }
+                else
+                {
+                    pAsyncReqInfo->lResult = LINEERR_INVALCALLHANDLE;
+                }
+            }
+        }
+        else
+        {
+            pAsyncReqInfo->lResult = LINEERR_INVALCALLHANDLE;
+
+            if (pConfCall)
+            {
+                FreeCall (pConfCall, dwConfCallInstThen);
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if (pConfCall)
+        {
+            if (SetCallState(
+                    pConfCall,
+                    dwConfCallInstNow,
+                    0xffffffff, // BUGBUG specify valid call states
+                    LINECALLSTATE_CONNECTED,
+                    0,
+                    TRUE
+
+                    ) == 0)
+            {
+                SetCallState(
+                    pCall,
+                    dwCallInstNow,
+                    0xffffffff, // BUGBUG specify valid call states
+                    LINECALLSTATE_CONFERENCED,
+                    0,
+                    TRUE
+                    );
+
+                SetCallState(
+                    pConsultCall,
+                    dwConsultCallInstNow,
+                    0xffffffff, // BUGBUG specify valid call states
+                    LINECALLSTATE_CONFERENCED,
+                    0,
+                    TRUE
+                    );
+            }
+        }
+        else
+        {
+            SetCallState(
+                pCall,
+                dwCallInstNow,
+                0xffffffff, // BUGBUG specify valid call states
+                LINECALLSTATE_IDLE,
+                0,
+                TRUE
+                );
+
+            SetCallState(
+                pConsultCall,
+                dwConsultCallInstNow,
+                0xffffffff, // BUGBUG specify valid call states
+                LINECALLSTATE_IDLE,
+                0,
+                TRUE
+                );
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    HDRVCALL        hdConsultCall,
+    HTAPICALL       htConfCall,
+    LPHDRVCALL      lphdConfCall,
+    DWORD           dwTransferMode
+    )
+{
+    static char szFuncName[] = "lineCompleteTransfer";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdCall,         hdCall          },
+        { "hdConsultCall",  hdConsultCall   },
+        { "htConfCall",     htConfCall      },
+        { "lphdConfCall",   lphdConfCall    },
+        { "dwTransferMode", dwTransferMode, aTransferModes  }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        6,
+        params,
+        TSPI_lineCompleteTransfer_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall(
+                (PDRVCALL) hdCall,
+                &info.pAsyncReqInfo->dwParam1
+                ) &&
+
+            IsValidDrvCall(
+                (PDRVCALL) hdConsultCall,
+                &info.pAsyncReqInfo->dwParam2
+                ))
+        {
+            info.pAsyncReqInfo->dwParam3 = (DWORD) hdCall;
+            info.pAsyncReqInfo->dwParam4 = (DWORD) hdConsultCall;
+
+            if (dwTransferMode == LINETRANSFERMODE_CONFERENCE)
+            {
+                LONG        lResult;
+                PDRVCALL    pConfCall;
+                PDRVLINE    pLine = ((PDRVCALL) hdCall)->pLine; // BUGBUG: AV
+
+
+                if ((lResult = AllocCall(
+                        pLine,
+                        htConfCall,
+                        NULL,
+                        &pConfCall
+
+                        )) == 0)
+                {
+                    *lphdConfCall = (HDRVCALL) pConfCall;
+                    info.pAsyncReqInfo->dwParam5 = (DWORD) pConfCall;
+                    info.pAsyncReqInfo->dwParam6 = pConfCall->dwCallInstance;
+                }
+                else
+                {
+                    info.lResult = lResult;
+                }
+            }
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static char szFuncName[] = "lineConditionalMediaDetection";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine                      },
+        { "dwMediaModes",   dwMediaModes,   aMediaModes },
+        { szlpCallParams,   lpCallParams                }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineDevSpecific_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    LPVOID lpParams = pAsyncReqInfo->dwParam1;
+    DWORD  dwSize   = pAsyncReqInfo->dwParam2;
+
+
+    if (pAsyncReqInfo->lResult == 0 && dwSize >= 22)
+    {
+        lstrcpyA (lpParams, "ESP dev specific info");
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "lineDevSpecific";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdLine,         hdLine          },
+        { "dwAddressID",    dwAddressID     },
+        { szhdCall,         hdCall          },
+        { "lpParams",       lpParams        },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        6,
+        params
+    };
+    PESPDEVSPECIFICINFO pInfo = (PESPDEVSPECIFICINFO) lpParams;
+
+
+    if (Prolog (&info))
+    {
+        if (dwSize >= sizeof (ESPDEVSPECIFICINFO)  &&
+            pInfo->dwKey == ESPDEVSPECIFIC_KEY)
+        {
+            switch (pInfo->dwType)
+            {
+            case ESP_DEVSPEC_MSG:
+
+                switch (pInfo->u.EspMsg.dwMsg)
+                {
+                case LINE_ADDRESSSTATE:
+                case LINE_CLOSE:
+                case LINE_DEVSPECIFIC:
+                case LINE_DEVSPECIFICFEATURE:
+                case LINE_LINEDEVSTATE:
+
+                    SendLineEvent(
+                        (PDRVLINE) hdLine,
+                        NULL,
+                        pInfo->u.EspMsg.dwMsg,
+                        pInfo->u.EspMsg.dwParam1,
+                        pInfo->u.EspMsg.dwParam2,
+                        pInfo->u.EspMsg.dwParam3
+                        );
+
+                    break;
+
+                case LINE_CALLDEVSPECIFIC:
+                case LINE_CALLDEVSPECIFICFEATURE:
+                case LINE_CALLINFO:
+                case LINE_MONITORDIGITS:
+                case LINE_MONITORMEDIA:
+
+                    if (hdCall)
+                    {
+                        SendLineEvent(
+                            (PDRVLINE) hdLine,
+                            (PDRVCALL) hdCall,
+                            pInfo->u.EspMsg.dwMsg,
+                            pInfo->u.EspMsg.dwParam1,
+                            pInfo->u.EspMsg.dwParam2,
+                            pInfo->u.EspMsg.dwParam3
+                            );
+                    }
+                    else
+                    {
+                        info.lResult = LINEERR_OPERATIONFAILED;
+                    }
+
+                    break;
+
+                case LINE_GATHERDIGITS:
+
+                    if (hdCall)
+                    {
+                        DWORD       dwEndToEndID = 0;
+                        PDRVCALL    pCall = (PDRVCALL) hdCall;
+
+
+                        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (IsValidDrvCall (pCall, NULL))
+                        {
+                            if ((dwEndToEndID =
+                                    pCall->dwGatherDigitsEndToEndID))
+                            {
+                                pCall->dwGatherDigitsEndToEndID = 0;
+                            }
+                            else
+                            {
+                                info.lResult = LINEERR_OPERATIONFAILED;
+                            }
+                        }
+                        else
+                        {
+                            info.lResult = LINEERR_INVALCALLHANDLE;
+                        }
+
+                        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (dwEndToEndID)
+                        {
+                            SendLineEvent(
+                                (PDRVLINE) hdLine,
+                                (PDRVCALL) hdCall,
+                                LINE_GATHERDIGITS,
+                                pInfo->u.EspMsg.dwParam1,
+                                dwEndToEndID,
+                                0
+                                );
+                        }
+                        else if (info.lResult == LINEERR_OPERATIONFAILED)
+                        {
+                            ShowStr(
+                                TRUE,
+                                "ERROR: TSPI_lineDevSpecific: attempt to " \
+                                "send GATHERDIGITS msg with no " \
+                                "lineGatherDigits request pending"
+                                );
+                        }
+                    }
+                    else
+                    {
+                        info.lResult = LINEERR_OPERATIONFAILED;
+                    }
+
+                    break;
+
+                case LINE_GENERATE:
+
+                    if (hdCall)
+                    {
+                        DWORD       dwEndToEndID = 0, *pdwXxxEndToEndID;
+                        PDRVCALL    pCall = (PDRVCALL) hdCall;
+
+
+                        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (IsValidDrvCall (pCall, NULL))
+                        {
+                            pdwXxxEndToEndID = (pInfo->u.EspMsg.dwParam3 ?
+                                &pCall->dwGenerateToneEndToEndID :
+                                &pCall->dwGenerateDigitsEndToEndID
+                                );
+
+                            if ((dwEndToEndID = *pdwXxxEndToEndID))
+                            {
+                                *pdwXxxEndToEndID = 0;
+                            }
+                            else
+                            {
+                                info.lResult = LINEERR_OPERATIONFAILED;
+                            }
+                        }
+
+                        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (dwEndToEndID)
+                        {
+                            SendLineEvent(
+                                (PDRVLINE) hdLine,
+                                (PDRVCALL) hdCall,
+                                LINE_GENERATE,
+                                pInfo->u.EspMsg.dwParam1,
+                                dwEndToEndID,
+                                0
+                                );
+                        }
+                        else if (info.lResult == LINEERR_OPERATIONFAILED)
+                        {
+                            ShowStr(
+                                TRUE,
+                                "ERROR: TSPI_lineDevSpecific: attempt to " \
+                                "send GENERATE msg with no " \
+                                "lineGenerateXxx request pending"
+                                );
+                        }
+                    }
+                    else
+                    {
+                        info.lResult = LINEERR_OPERATIONFAILED;
+                    }
+
+                    break;
+
+                case LINE_MONITORTONE:
+
+                    if (hdCall)
+                    {
+                        DWORD       dwToneListID = 0;
+                        PDRVCALL    pCall = (PDRVCALL) hdCall;
+
+
+                        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (IsValidDrvCall (pCall, NULL))
+                        {
+                            if ((dwToneListID =
+                                    pCall->dwMonitorToneListID))
+                            {
+                                pCall->dwMonitorToneListID = 0;
+                            }
+                            else
+                            {
+                                info.lResult = LINEERR_OPERATIONFAILED;
+                            }
+                        }
+                        else
+                        {
+                            info.lResult = LINEERR_INVALCALLHANDLE;
+                        }
+
+                        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+                        if (dwToneListID)
+                        {
+                            SendLineEvent(
+                                (PDRVLINE) hdLine,
+                                (PDRVCALL) hdCall,
+                                LINE_MONITORTONE,
+                                pInfo->u.EspMsg.dwParam1,
+                                dwToneListID,
+                                0
+                                );
+                        }
+                        else if (info.lResult == LINEERR_OPERATIONFAILED)
+                        {
+                            ShowStr(
+                                TRUE,
+                                "ERROR: TSPI_lineDevSpecific: attempt to " \
+                                "send MONITORTONE msg with no " \
+                                "lineMonitorTone request pending"
+                                );
+                        }
+                    }
+                    else
+                    {
+                        info.lResult = LINEERR_OPERATIONFAILED;
+                    }
+
+                    break;
+
+                case LINE_CALLSTATE:
+                {
+                    DWORD   dwCallInst;
+
+
+                    if (hdCall  &&
+                        IsValidDrvCall ((PDRVCALL) hdCall, &dwCallInst))
+                    {
+                        LONG lResult;
+
+
+                        // BUGBUG changing to/from conf state cause ptr probs?
+                        // BUGBUG check for bad call state vals
+
+                        if ((lResult = SetCallState(
+                                (PDRVCALL) hdCall,
+                                dwCallInst,
+                                0xffffffff,
+                                pInfo->u.EspMsg.dwParam1,
+                                pInfo->u.EspMsg.dwParam2,
+                                TRUE
+
+                                )) != 0)
+                        {
+                            info.lResult = lResult;
+                        }
+                    }
+                    else
+                    {
+                        info.lResult = LINEERR_OPERATIONFAILED;
+                    }
+
+                    break;
+                }
+                case LINE_CREATE: // BUGBUG
+
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_lineDevSpecific: no support " \
+                            "for indicating LINE_CREATE yet"
+                        );
+
+                    info.lResult = LINEERR_OPERATIONFAILED;
+                    break;
+
+                case LINE_NEWCALL: // BUGBUG
+
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_lineDevSpecific: no support " \
+                            "for indicating LINE_NEWCALL yet"
+                        );
+
+                    info.lResult = LINEERR_OPERATIONFAILED;
+                    break;
+
+                default:
+
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_lineDevSpecific: unrecognized " \
+                            "ESPDEVSPECIFICINFO.u.EspMsg.dwMsg (=x%x)",
+                        pInfo->u.EspMsg.dwMsg
+                        );
+
+                    info.lResult = LINEERR_OPERATIONFAILED;
+                    break;
+                }
+
+                break;
+
+            case ESP_DEVSPEC_RESULT:
+            {
+                DWORD   dwResult = pInfo->u.EspResult.lResult;
+
+
+                if (dwResult != 0  &&
+                    (dwResult < LINEERR_ALLOCATED ||
+                    dwResult > PHONEERR_REINIT ||
+                    (dwResult > LINEERR_DIALVOICEDETECT &&
+                    dwResult < PHONEERR_ALLOCATED)))
+                {
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_lineDevSpecific: invalid request" \
+                            "result value (x%x)",
+                        dwResult
+                        );
+
+                    info.lResult = LINEERR_OPERATIONFAILED;
+                }
+                else if (pInfo->u.EspResult.dwCompletionType >
+                            ESP_RESULT_CALLCOMPLPROCASYNC)
+                {
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_lineDevSpecific: invalid request" \
+                            "completion type (x%x)",
+                        pInfo->u.EspResult.dwCompletionType
+                        );
+
+                    info.lResult = LINEERR_OPERATIONFAILED;
+                }
+                else
+                {
+                    glNextRequestResult = (LONG) dwResult;
+                    gdwNextRequestCompletionType =
+                        pInfo->u.EspResult.dwCompletionType;
+                    gdwDevSpecificRequestID = dwRequestID;
+                }
+
+                break;
+            }
+            default:
+
+                ShowStr(
+                    TRUE,
+                    "ERROR: TSPI_lineDevSpecific: unrecognized " \
+                        "ESPDEVSPECIFICINFO.dwType (=x%x)",
+                    pInfo->dwType
+                    );
+
+                info.lResult = LINEERR_OPERATIONFAILED;
+                break;
+            }
+        }
+        else
+        {
+            info.pAsyncReqInfo->dwParam1 = lpParams;
+            info.pAsyncReqInfo->dwParam2 = dwSize;
+
+            info.pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+                TSPI_lineDevSpecific_postProcess;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwFeature,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "lineDevSpecificFeature";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdLine,         hdLine          },
+        { "dwFeature",      dwFeature       },
+        { "lpParams",       lpParams        },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        5,
+        params,
+        TSPI_lineDevSpecific_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        info.pAsyncReqInfo->dwParam1 = lpParams;
+        info.pAsyncReqInfo->dwParam2 = dwSize;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    static char szFuncName[] = "lineDial";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 4, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineDrop_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        DWORD       dwCallInstThen = pAsyncReqInfo->dwParam2;
+        PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+        //
+        // We need to make sure pCall is pointing at a valid call
+        // structure because it's possible that tapi immediately
+        // followed the drop request with a closeCall request
+        // (without waiting for the result from the drop)
+        //
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (SetCallState(
+                pCall,
+                dwCallInstThen,
+                0xffffffff,
+                LINECALLSTATE_IDLE,
+                0,
+                TRUE
+
+                ) == 0)
+        {
+            if (pCall->pConfParent)
+            {
+                //
+                // Call is a conf child, so remove from conf list
+                //
+
+                PDRVCALL    pCall2 = pCall->pConfParent;
+
+
+                while (pCall2 && (pCall2->pNextConfChild != pCall))
+                {
+                    pCall2 = pCall2->pNextConfChild;
+                }
+
+                if (pCall2)
+                {
+                    pCall2->pNextConfChild = pCall->pNextConfChild;
+                }
+
+                pCall->pConfParent = NULL;
+            }
+            else if (pCall->pNextConfChild)
+            {
+                //
+                // Call is a conf parent, so IDLE-ize all children &
+                // remove them from list
+                //
+
+                PDRVCALL    pConfChild = pCall->pNextConfChild;
+
+
+                pCall->pNextConfChild = NULL;
+
+                while (pConfChild)
+                {
+                    PDRVCALL    pNextConfChild = pConfChild->pNextConfChild;
+
+
+                    pConfChild->pConfParent =
+                    pConfChild->pNextConfChild = NULL;
+
+                    SetCallState(
+                        pConfChild,
+                        pConfChild->dwCallInstance,
+                        0xffffffff,
+                        LINECALLSTATE_IDLE,
+                        0,
+                        TRUE
+                        );
+
+                    pConfChild = pNextConfChild;
+                }
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "lineDrop";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_lineDrop_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam2))
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineForward_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwConsultCallInstThen = pAsyncReqInfo->dwParam2;
+    PDRVCALL    pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState(
+            pConsultCall,
+            dwConsultCallInstThen,
+            0xffffffff, // BUGBUG specify valid call states
+            LINECALLSTATE_CONNECTED,
+            0,
+            TRUE
+            );
+    }
+    else
+    {
+        FreeCall (pConsultCall, dwConsultCallInstThen);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static char szFuncName[] = "lineForward";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { szhdLine,             hdLine              },
+        { "bAllAddresses",      bAllAddresses       },
+        { "dwAddressID",        dwAddressID         },
+        { "lpForwardList",      lpForwardList       },
+        { "dwNumRingsNoAnswer", dwNumRingsNoAnswer  },
+        { "htConsultCall",      htConsultCall       },
+        { "lphdConsultCall",    lphdConsultCall     },
+        { szlpCallParams,       lpCallParams        }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        9,
+        params,
+        TSPI_lineForward_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (bAllAddresses  ||
+            dwAddressID < gESPGlobals.dwNumAddressesPerLine)
+        {
+            if (lpForwardList)
+            {
+                LONG        lResult;
+                PDRVCALL    pConsultCall;
+
+
+                if ((lResult = AllocCall(
+                        (PDRVLINE) hdLine,
+                        htConsultCall,
+                        lpCallParams,
+                        &pConsultCall
+
+                        )) == 0)
+                {
+                    info.pAsyncReqInfo->dwParam1 = (DWORD) pConsultCall;
+                    info.pAsyncReqInfo->dwParam2 = pConsultCall->dwCallInstance;
+
+                    *lphdConsultCall = (HDRVCALL) pConsultCall;
+                }
+                else
+                {
+                    info.lResult = lResult;
+                }
+            }
+            else
+            {
+                info.pAsyncReqInfo->pfnPostProcessProc = NULL;
+                *lphdConsultCall = (HDRVCALL) NULL;
+            }
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALADDRESSID;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwEndToEndID,
+    DWORD       dwDigitModes,
+    LPWSTR      lpsDigits,
+    DWORD       dwNumDigits,
+    LPCWSTR     lpszTerminationDigits,
+    DWORD       dwFirstDigitTimeout,
+    DWORD       dwInterDigitTimeout
+    )
+{
+    static char szFuncName[] = "lineGatherDigits";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,                 hdCall                  },
+        { "dwEndToEndID",           dwEndToEndID            },
+        { "dwDigitModes",           dwDigitModes,   aDigitModes },
+        { "lpsDigits",              lpsDigits               },
+        { "dwNumDigits",            dwNumDigits             },
+        { "lpszTerminationDigits",  lpszTerminationDigits   },
+        { "dwFirstDigitTimeout",    dwFirstDigitTimeout     },
+        { "dwInterDigitTimeout",    dwInterDigitTimeout     }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 8, params };
+    PDRVCALL    pCall = (PDRVCALL) hdCall;
+    DWORD       dwReason = 0;
+    HTAPILINE   htLine;
+    HTAPICALL   htCall;
+
+
+    if (Prolog (&info))
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            htLine = ((PDRVLINE) pCall->pLine)->htLine;
+            htCall = pCall->htCall;
+
+            if (lpsDigits)
+            {
+                lstrcpynW (lpsDigits, L"1234567890", dwNumDigits);
+
+                if (dwNumDigits == 10)
+                {
+                    lpsDigits[9] = L'0';
+                }
+            }
+
+            if (gbAutoGatherGenerateMsgs)
+            {
+                if (lpsDigits)
+                {
+                    dwReason = (dwNumDigits > 10 ? LINEGATHERTERM_INTERTIMEOUT
+                        : LINEGATHERTERM_BUFFERFULL);
+                }
+            }
+            else
+            {
+                DWORD dwEndToEndIDTmp = dwEndToEndID;
+
+
+                if ((dwEndToEndID = pCall->dwGatherDigitsEndToEndID))
+                {
+                    dwReason = LINEGATHERTERM_CANCEL;
+                }
+
+                pCall->dwGatherDigitsEndToEndID = (lpsDigits ?
+                    dwEndToEndIDTmp : 0);
+            }
+        }
+        else
+        {
+            htLine = (HTAPILINE) (htCall = (HTAPICALL) NULL);
+            dwReason = (lpsDigits ? LINEGATHERTERM_CANCEL : 0);
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (dwReason)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                htLine,
+                htCall,
+                LINE_GATHERDIGITS,
+                dwReason,
+                dwEndToEndID,
+                0
+                );
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwEndToEndID,
+    DWORD       dwDigitMode,
+    LPCWSTR     lpszDigits,
+    DWORD       dwDuration
+    )
+{
+    static char szFuncName[] = "lineGenerateDigits";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwEndToEndID",   dwEndToEndID    },
+        { "dwDigitMode",    dwDigitMode,    aDigitModes },
+        { "lpszDigits",     lpszDigits      },
+        { "dwDuration",     dwDuration      }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 5, params };
+    PDRVCALL    pCall = (PDRVCALL) hdCall;
+    HTAPILINE   htLine;
+    HTAPICALL   htCall;
+    DWORD       dwReason = 0;
+
+
+    if (Prolog (&info))
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            htLine = ((PDRVLINE) pCall->pLine)->htLine;
+            htCall = pCall->htCall;
+
+            if (gbAutoGatherGenerateMsgs)
+            {
+                dwReason = (lpszDigits ? LINEGENERATETERM_DONE : 0);
+            }
+            else
+            {
+                DWORD dwEndToEndIDTmp = dwEndToEndID;
+
+
+                if ((dwEndToEndID = pCall->dwGenerateDigitsEndToEndID))
+                {
+                    dwReason = LINEGENERATETERM_CANCEL;
+                }
+
+                pCall->dwGenerateDigitsEndToEndID = (lpszDigits ?
+                    dwEndToEndIDTmp : 0);
+            }
+        }
+        else
+        {
+            htLine = (HTAPILINE) (htCall = (HTAPICALL) NULL);
+            dwReason = (lpszDigits ? LINEGENERATETERM_CANCEL : 0);
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (dwReason)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                htLine,
+                htCall,
+                LINE_GENERATE,
+                dwReason,
+                dwEndToEndID,
+                0
+                );
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+{
+    static char szFuncName[] = "lineGenerateTone";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwEndToEndID",   dwEndToEndID    },
+        { "dwToneMode",     dwToneMode, aToneModes  },
+        { "dwDuration",     dwDuration      },
+        { "dwNumTones",     dwNumTones      },
+        { "lpTones",        lpTones         }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 6, params };
+    PDRVCALL    pCall = (PDRVCALL) hdCall;
+    HTAPILINE   htLine;
+    HTAPICALL   htCall;
+    DWORD       dwReason = 0;
+
+
+    if (Prolog (&info))
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            htLine = ((PDRVLINE) pCall->pLine)->htLine;
+            htCall = pCall->htCall;
+
+            if (gbAutoGatherGenerateMsgs)
+            {
+                dwReason = (dwToneMode ? LINEGENERATETERM_DONE : 0);
+            }
+            else
+            {
+                DWORD dwEndToEndIDTmp = dwEndToEndID;
+
+
+                if ((dwEndToEndID = pCall->dwGenerateToneEndToEndID))
+                {
+                    dwReason = LINEGENERATETERM_CANCEL;
+                }
+
+                pCall->dwGenerateToneEndToEndID = (dwToneMode ?
+                    dwEndToEndIDTmp : 0);
+            }
+        }
+        else
+        {
+            htLine = (HTAPILINE) (htCall = (HTAPICALL) NULL);
+            dwReason = (dwToneMode ? LINEGENERATETERM_CANCEL : 0);
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (dwReason)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                htLine,
+                htCall,
+                LINE_GENERATE,
+                dwReason,
+                dwEndToEndID,
+                0
+                );
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD              dwDeviceID,
+    DWORD              dwAddressID,
+    DWORD              dwTSPIVersion,
+    DWORD              dwExtVersion,
+    LPLINEADDRESSCAPS  lpAddressCaps
+    )
+{
+    static char szFuncName[] = "lineGetAddressCaps";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwAddressID",    dwAddressID     },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpAddressCaps",  lpAddressCaps   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 5, params };
+    DWORD dwUsedSize;
+    PDRVLINE pLine = GetLineFromID (dwDeviceID);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    if (dwAddressID >= gESPGlobals.dwNumAddressesPerLine)
+    {
+        info.lResult = LINEERR_INVALADDRESSID;
+        return (Epilog (&info));
+    }
+
+    //lpAddressCaps->dwTotalSize
+    //lpAddressCaps->dwNeededSize
+    //lpAddressCaps->dwUsedSize
+    //lpAddressCaps->dwLineDeviceID
+    //
+    //lpAddressCaps->dwAddressOffset
+
+    {
+        WCHAR buf[20];
+
+
+        wsprintfW (buf, L"%d#%d", dwDeviceID, dwAddressID);
+
+        InsertVarDataString(
+            lpAddressCaps,
+            &lpAddressCaps->dwAddressSize,
+            buf
+            );
+    }
+
+    //lpAddressCaps->dwDevSpecificSize
+    //lpAddressCaps->dwDevSpecificOffset
+    //lpAddressCaps->dwAddressSharing
+    //lpAddressCaps->dwAddressStates
+    //lpAddressCaps->dwCallInfoStates
+    //lpAddressCaps->dwCallerIDFlags
+    //lpAddressCaps->dwCalledIDFlags
+    //lpAddressCaps->dwConnectedIDFlags
+    //lpAddressCaps->dwRedirectionIDFlags
+    //lpAddressCaps->dwRedirectingIDFlags
+    //lpAddressCaps->dwCallStates
+    //lpAddressCaps->dwDialToneModes
+    //lpAddressCaps->dwBusyModes
+    //lpAddressCaps->dwSpecialInfo
+    //lpAddressCaps->dwDisconnectModes
+    lpAddressCaps->dwMaxNumActiveCalls = gESPGlobals.dwNumCallsPerAddress;
+    //lpAddressCaps->dwMaxNumOnHoldCalls
+    //lpAddressCaps->dwMaxNumOnHoldPendingCalls
+    //lpAddressCaps->dwMaxNumConference
+    //lpAddressCaps->dwMaxNumTransConf
+    lpAddressCaps->dwAddrCapFlags = AllAddrCaps1_0;
+    lpAddressCaps->dwCallFeatures = AllCallFeatures1_0;
+    //lpAddressCaps->dwRemoveFromConfCaps
+    //lpAddressCaps->dwRemoveFromConfState
+    //lpAddressCaps->dwTransferModes
+    //lpAddressCaps->dwParkModes
+    //lpAddressCaps->dwForwardModes
+    //lpAddressCaps->dwMaxForwardEntries
+    //lpAddressCaps->dwMaxSpecificEntries
+    //lpAddressCaps->dwMinFwdNumRings
+    //lpAddressCaps->dwMaxFwdNumRings
+    //lpAddressCaps->dwMaxCallCompletions
+    //lpAddressCaps->dwCallCompletionConds
+    //lpAddressCaps->dwCallCompletionModes
+    lpAddressCaps->dwNumCompletionMessages = MAX_NUM_COMPLETION_MESSAGES;
+    //lpAddressCaps->dwCompletionMsgTextEntrySize
+    //lpAddressCaps->dwCompletionMsgTextSize
+    //lpAddressCaps->dwCompletionMsgTextOffset
+
+    if (dwTSPIVersion >= 0x00010004)
+    {
+        lpAddressCaps->dwCallFeatures = AllCallFeatures1_4;
+
+        lpAddressCaps->dwAddressFeatures = AllAddrFeatures1_0;
+
+        if (dwTSPIVersion >= 0x00020000)
+        {
+            lpAddressCaps->dwAddrCapFlags = AllAddrCaps2_0;
+            lpAddressCaps->dwCallFeatures = AllCallFeatures2_0;
+            lpAddressCaps->dwAddressFeatures = AllAddrFeatures2_0;
+
+            //lpAddressCaps->dwPredictiveAutoTransferStates
+            //lpAddressCaps->dwNumCallTreatments
+            //lpAddressCaps->dwCallTreatmentListSize
+            //lpAddressCaps->dwCallTreatmentListOffset
+            //lpAddressCaps->dwDeviceClassesSize
+            //lpAddressCaps->dwDeviceClassesOffset
+            //lpAddressCaps->dwMaxCallDataSize
+            lpAddressCaps->dwCallFeatures2 = AllCallFeaturesTwo;
+            //lpAddressCaps->dwMaxNoAnswerTimeout
+            //lpAddressCaps->dwConnectedModes
+            //lpAddressCaps->dwOfferingModes
+            lpAddressCaps->dwAvailableMediaModes = AllMediaModes1_4;
+        }
+    }
+
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwAddressID,
+    DWORD       dwAddressMode,
+    LPCWSTR     lpsAddress,
+    DWORD       dwSize
+    )
+{
+    static char szFuncName[] = "lineGetAddressID";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine          },
+        { "lpdwAddressID",  lpdwAddressID   },
+        { "dwAddressMode",  dwAddressMode   },
+        { "lpsAddress",     lpsAddress      },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 5, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    static char szFuncName[] = "lineGetAddressStatus";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { "lpAddressStatus",    lpAddressStatus }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    if (dwAddressID >= gESPGlobals.dwNumAddressesPerLine)
+    {
+        info.lResult = LINEERR_INVALADDRESSID;
+        return (Epilog (&info));
+    }
+
+    //lpAddressStatus->dwNeededSize
+    //lpAddressStatus->dwUsedSize
+    //lpAddressStatus->dwNumInUse
+
+    if (pLine->aAddrs[dwAddressID].dwNumCalls != 0)
+    {
+        PDRVCALL    pCall;
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        for(
+            pCall = pLine->aAddrs[dwAddressID].pCalls;
+            pCall != NULL;
+            pCall = pCall->pNext
+            )
+        {
+            switch (pCall->dwCallState)
+            {
+            case LINECALLSTATE_IDLE:
+
+                continue;
+
+            case LINECALLSTATE_ONHOLD:
+
+                lpAddressStatus->dwNumOnHoldCalls++;
+                continue;
+
+            case LINECALLSTATE_ONHOLDPENDCONF:
+            case LINECALLSTATE_ONHOLDPENDTRANSFER:
+
+                lpAddressStatus->dwNumOnHoldPendCalls++;
+                continue;
+
+            default:
+
+                lpAddressStatus->dwNumActiveCalls++;
+                continue;
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    lpAddressStatus->dwAddressFeatures = (gESPGlobals.dwSPIVersion > 0x10004 ?
+        AllAddrFeatures1_0 : AllAddrFeatures2_0);
+    //lpAddressStatus->dwNumRingsNoAnswer
+    //lpAddressStatus->dwForwardNumEntries
+    //lpAddressStatus->dwForwardSize
+    //lpAddressStatus->dwForwardOffset
+    //lpAddressStatus->dwTerminalModesSize
+    //lpAddressStatus->dwTerminalModesOffset
+    //lpAddressStatus->dwDevSpecificSize
+    //lpAddressStatus->dwDevSpecificOffset
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL    hdCall,
+    LPDWORD     lpdwAddressID
+    )
+{
+    static char szFuncName[] = "lineGetCallAddressID";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "lpdwAddressID",  lpdwAddressID   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+        *lpdwAddressID = ((PDRVCALL) hdCall)->dwAddressID;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    static char szFuncName[] = "lineGetCallInfo";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,     hdCall      },
+        { "lpCallInfo", lpCallInfo  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+    PDRVCALL  pCall = (PDRVCALL) hdCall;
+    DWORD     dwUsedSize;
+
+
+    if (Prolog (&info))
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            //lpCallInfo->dwNeededSize
+            //lpCallInfo->dwUsedSize
+            lpCallInfo->dwLineDeviceID = ((PDRVLINE) pCall->pLine)->dwDeviceID;
+            lpCallInfo->dwAddressID    = pCall->dwAddressID;
+            lpCallInfo->dwBearerMode   = pCall->dwBearerMode;
+            //lpCallInfo->dwRate
+            lpCallInfo->dwMediaMode    = pCall->dwMediaMode;
+            lpCallInfo->dwAppSpecific  = pCall->dwAppSpecific;
+            lpCallInfo->dwCallID       = pCall->dwCallID;
+            //lpCallInfo->dwRelatedCallID
+            //lpCallInfo->dwCallParamFlags
+            //lpCallInfo->dwCallStates
+
+            CopyMemory(
+                &lpCallInfo->DialParams,
+                &pCall->DialParams,
+                sizeof(LINEDIALPARAMS)
+                );
+
+            //lpCallInfo->dwOrigin
+            //lpCallInfo->dwReason
+            //lpCallInfo->dwCompletionID
+            //lpCallInfo->dwCountryCode
+            //lpCallInfo->dwTrunk
+            //lpCallInfo->dwCallerIDFlags
+            //lpCallInfo->dwCallerIDSize
+            //lpCallInfo->dwCallerIDOffset
+            //lpCallInfo->dwCallerIDNameSize
+            //lpCallInfo->dwCallerIDNameOffset
+            //lpCallInfo->dwCalledIDFlags
+            //lpCallInfo->dwCalledIDSize
+            //lpCallInfo->dwCalledIDOffset
+            //lpCallInfo->dwCalledIDNameSize
+            //lpCallInfo->dwCalledIDNameOffset
+            //lpCallInfo->dwConnectedIDFlags
+            //lpCallInfo->dwConnectedIDSize
+            //lpCallInfo->dwConnectedIDOffset
+            //lpCallInfo->dwConnectedIDNameSize
+            //lpCallInfo->dwConnectedIDNameOffset
+            //lpCallInfo->dwRedirectionIDFlags
+            //lpCallInfo->dwRedirectionIDSize
+            //lpCallInfo->dwRedirectionIDOffset
+            //lpCallInfo->dwRedirectionIDNameSize
+            //lpCallInfo->dwRedirectionIDNameOffset
+            //lpCallInfo->dwRedirectingIDFlags
+            //lpCallInfo->dwRedirectingIDSize
+            //lpCallInfo->dwRedirectingIDOffset
+            //lpCallInfo->dwRedirectingIDNameSize
+            //lpCallInfo->dwRedirectingIDNameOffset
+            //lpCallInfo->dwDisplaySize
+            //lpCallInfo->dwDisplayOffset
+            //lpCallInfo->dwUserUserInfoSize
+            //lpCallInfo->dwUserUserInfoOffset
+            //lpCallInfo->dwHighLevelCompSize
+            //lpCallInfo->dwHighLevelCompOffset
+            //lpCallInfo->dwLowLevelCompSize
+            //lpCallInfo->dwLowLevelCompOffset
+            //lpCallInfo->dwChargingInfoSize
+            //lpCallInfo->dwChargingInfoOffset
+            //lpCallInfo->dwTerminalModesSize
+            //lpCallInfo->dwTerminalModesOffset
+            //lpCallInfo->dwDevSpecificSize
+            //lpCallInfo->dwDevSpecificOffset
+
+            if (gESPGlobals.dwSPIVersion >= 0x00020000)
+            {
+                lpCallInfo->dwCallTreatment = pCall->dwTreatment;
+
+                InsertVarData(
+                    lpCallInfo,
+                    &lpCallInfo->dwCallDataSize,
+                    pCall->pCallData,
+                    pCall->dwCallDataSize
+                    );
+
+                InsertVarData(
+                    lpCallInfo,
+                    &lpCallInfo->dwSendingFlowspecSize,
+                    pCall->pSendingFlowspec,
+                    pCall->dwSendingFlowspecSize
+                    );
+
+                InsertVarData(
+                    lpCallInfo,
+                    &lpCallInfo->dwReceivingFlowspecSize,
+                    pCall->pReceivingFlowspec,
+                    pCall->dwReceivingFlowspecSize
+                    );
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    DWORD   dwCallState, dwCallStateMode;
+    static char szFuncName[] = "lineGetCallStatus";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "lpCallStatus",   lpCallStatus    }
+    };
+    PDRVCALL  pCall = (PDRVCALL) hdCall;
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (IsValidDrvCall (pCall, NULL))
+    {
+        dwCallState     = pCall->dwCallState;
+        dwCallStateMode = pCall->dwCallStateMode;
+
+    }
+    else
+    {
+        info.lResult = LINEERR_INVALCALLHANDLE;
+    }
+
+    LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (info.lResult == 0)
+    {
+        //lpCallStatus->dwNeededSize
+        //lpCallStatus->dwUsedSize
+        lpCallStatus->dwCallState     = dwCallState;
+        lpCallStatus->dwCallStateMode = dwCallStateMode;
+
+
+        //
+        // If the call is IDLE we won't let apps do anything with it,
+        // otherwise they can do anything they want to (all valid
+        // 1.0/1.4 LINECALLFEATURE_XXX flags)
+        //
+
+        switch (dwCallState)
+        {
+        case LINECALLSTATE_IDLE:
+
+            lpCallStatus->dwCallFeatures = 0;
+            break;
+
+        default:
+
+            lpCallStatus->dwCallFeatures =
+                (gESPGlobals.dwSPIVersion == 0x10003 ?
+                AllCallFeatures1_0 : AllCallFeatures1_4);
+            break;
+        }
+
+        //lpCallStatus->dwDevSpecificSize
+        //lpCallStatus->dwDevSpecificOffset
+
+        if (gESPGlobals.dwSPIVersion >= 0x00020000)
+        {
+            switch (dwCallState)
+            {
+            case LINECALLSTATE_IDLE:
+
+                lpCallStatus->dwCallFeatures = LINECALLFEATURE_SETCALLDATA;
+                break;
+
+            default:
+
+                lpCallStatus->dwCallFeatures  = AllCallFeatures2_0;
+                lpCallStatus->dwCallFeatures2 = AllCallFeaturesTwo;
+                break;
+            }
+
+            //lpCallStatus->dwCallFeatures2
+            //lpCallStatus->tStateEntryTime
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    static char szFuncName[] = "lineGetDevCaps";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpLineDevCaps",  lpLineDevCaps   }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 4, params };
+    PDRVLINE    pLine = GetLineFromID (dwDeviceID);
+    WCHAR       buf[32];
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    InsertVarDataString(
+        lpLineDevCaps,
+        &lpLineDevCaps->dwProviderInfoSize,
+        gszProviderInfo
+        );
+
+    InsertVarDataString(
+        lpLineDevCaps,
+        &lpLineDevCaps->dwSwitchInfoSize,
+        L"ESP switch info"
+        );
+
+    lpLineDevCaps->dwPermanentLineID =
+        (gESPGlobals.dwPermanentProviderID << 16) |
+            (dwDeviceID - gESPGlobals.dwLineDeviceIDBase);
+
+    wsprintfW (buf, L"ESP Line %d", dwDeviceID);
+
+    InsertVarDataString(
+        lpLineDevCaps,
+        &lpLineDevCaps->dwLineNameSize,
+        buf
+        );
+
+    lpLineDevCaps->dwStringFormat = STRINGFORMAT_ASCII;
+    lpLineDevCaps->dwAddressModes = LINEADDRESSMODE_ADDRESSID |
+                                    LINEADDRESSMODE_DIALABLEADDR;
+    lpLineDevCaps->dwNumAddresses = gESPGlobals.dwNumAddressesPerLine;
+    lpLineDevCaps->dwBearerModes  = AllBearerModes1_0;
+    lpLineDevCaps->dwMaxRate      = 0x00100000;
+    lpLineDevCaps->dwMediaModes   = AllMediaModes1_0;
+    //lpLineDevCaps->dwGenerateToneModes
+    //lpLineDevCaps->dwGenerateToneMaxNumFreq
+    //lpLineDevCaps->dwGenerateDigitModes
+    //lpLineDevCaps->dwMonitorToneMaxNumFreq
+    //lpLineDevCaps->dwMonitorToneMaxNumEntries
+    //lpLineDevCaps->dwMonitorDigitModes
+    //lpLineDevCaps->dwGatherDigitsMinTimeout
+    //lpLineDevCaps->dwGatherDigitsMaxTimeout
+    //lpLineDevCaps->dwMedCtlDigitMaxListSize
+    //lpLineDevCaps->dwMedCtlMediaMaxListSize
+    //lpLineDevCaps->dwMedCtlToneMaxListSize;
+    //lpLineDevCaps->dwMedCtlCallStateMaxListSize
+    //lpLineDevCaps->dwDevCapFlags
+    lpLineDevCaps->dwMaxNumActiveCalls = gESPGlobals.dwNumAddressesPerLine *
+                                         gESPGlobals.dwNumCallsPerAddress;
+    //lpLineDevCaps->dwAnswerMode
+    //lpLineDevCaps->dwRingModes
+    //lpLineDevCaps->dwLineStates
+    //lpLineDevCaps->dwUUIAcceptSize
+    //lpLineDevCaps->dwUUIAnswerSize
+    //lpLineDevCaps->dwUUIMakeCallSize
+    //lpLineDevCaps->dwUUIDropSize
+    //lpLineDevCaps->dwUUISendUserUserInfoSize
+    //lpLineDevCaps->dwUUICallInfoSize
+    //lpLineDevCaps->MinDialParams
+    //lpLineDevCaps->MaxDialParams
+    //lpLineDevCaps->DefaultDialParams
+    //lpLineDevCaps->dwNumTerminals
+    //lpLineDevCaps->dwTerminalCapsSize
+    //lpLineDevCaps->dwTerminalCapsOffset
+    //lpLineDevCaps->dwTerminalTextEntrySize
+    //lpLineDevCaps->dwTerminalTextSize;
+    //lpLineDevCaps->dwTerminalTextOffset
+    //lpLineDevCaps->dwDevSpecificSize
+    //lpLineDevCaps->dwDevSpecificOffset
+
+    if (dwTSPIVersion >= 0x00010004)
+    {
+        lpLineDevCaps->dwBearerModes = AllBearerModes1_4;
+        lpLineDevCaps->dwMediaModes  = AllMediaModes1_4;
+
+        lpLineDevCaps->dwLineFeatures = AllLineFeatures1_0;
+
+        if (dwTSPIVersion >= 0x00020000)
+        {
+            lpLineDevCaps->dwBearerModes  = AllBearerModes2_0;
+
+            lpLineDevCaps->dwLineFeatures = AllLineFeatures2_0;
+
+            //lpLineDevCaps->dwSettableDevStatus
+            //lpLineDevCaps->dwDeviceClassesSize
+            //lpLineDevCaps->dwDeviceClassesOffset
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD       dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCWSTR     lpszDeviceClass
+    )
+{
+    static char szFuncName[] = "lineGetDevConfig";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpDeviceConfig",     lpDeviceConfig  },
+        { "lpszDeviceClass",    lpszDeviceClass }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+        // BUGBUG TSPI_lineGetDevConfig: fill in dev config
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+    static char szFuncName[] = "lineGetExtensionID";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpExtensionID",  lpExtensionID   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+        // BUGBUG TSPI_lineGetExtensionID: fill in ext id
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD   dwDeviceID,
+    LPCWSTR lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    static char szFuncName[] = "lineGetIcon";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass },
+        { "lphIcon",            lphIcon         }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+        if (lpszDeviceClass  &&
+            lstrcmpiW (lpszDeviceClass, L"tapi/InvalidDeviceClass") == 0)
+        {
+            info.lResult = LINEERR_INVALDEVICECLASS;
+        }
+        else
+        {
+            *lphIcon = gESPGlobals.hIconLine;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE    hdLine,
+    DWORD       dwAddressID,
+    HDRVCALL    hdCall,
+    DWORD       dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+{
+    static char szFuncName[] = "lineGetID";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { szhdCall,             hdCall          },
+        { "dwSelect",           dwSelect,   aCallSelects    },
+        { "lpDeviceID",         lpDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass },
+        { "hTargetProcess",     hTargetProcess }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 7, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+    DWORD    i, dwDeviceID, dwNeededSize = sizeof(VARSTRING) + sizeof(DWORD);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    for (i = 0; aszDeviceClasses[i]; i++)
+    {
+        if (lstrcmpiW (lpszDeviceClass, aszDeviceClasses[i]) == 0)
+        {
+            break;
+        }
+    }
+
+    if (!aszDeviceClasses[i])
+    {
+        info.lResult = LINEERR_NODEVICE;
+        return (Epilog (&info));
+    }
+
+    if (dwSelect == LINECALLSELECT_ADDRESS  &&
+        dwAddressID >= gESPGlobals.dwNumAddressesPerLine)
+    {
+        info.lResult = LINEERR_INVALADDRESSID;
+        return (Epilog (&info));
+    }
+
+    if (lpDeviceID->dwTotalSize < dwNeededSize)
+    {
+        lpDeviceID->dwNeededSize = dwNeededSize;
+        lpDeviceID->dwUsedSize = 3 * sizeof(DWORD);
+
+        return (Epilog (&info));
+    }
+
+    if (i == 0)
+    {
+        if (dwSelect == LINECALLSELECT_CALL)
+        {
+            dwDeviceID = ((PDRVLINE) pCall->pLine)->dwDeviceID;
+        }
+        else
+        {
+            dwDeviceID = pLine->dwDeviceID;
+        }
+    }
+    else
+    {
+// BUGBUG TSPI_lineGetID: if (gbShowLineGetIDDlg)
+//        {
+//        }
+//        else
+//        {
+            dwDeviceID = 0;
+//        }
+    }
+
+    lpDeviceID->dwNeededSize   =
+    lpDeviceID->dwUsedSize     = dwNeededSize;
+    lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+    lpDeviceID->dwStringSize   = sizeof(DWORD);
+    lpDeviceID->dwStringOffset = sizeof(VARSTRING);
+
+    *((LPDWORD)(lpDeviceID + 1)) = dwDeviceID;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE        hdLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    static char szFuncName[] = "lineGetLineDevStatus";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "lpLineDevStatus",    lpLineDevStatus }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 2, params };
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+    DWORD       dwTotalSize, dwNeededSize;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    //lpLineDevStatus->dwNeededSize
+    //lpLineDevStatus->dwUsedSize
+    //lpLineDevStatus->dwNumOpens             tapi fills this in
+    //lpLineDevStatus->dwOpenMediaModes       tapi fills this in
+
+
+    //
+    // Safely determine the # of active, on hold, & onhold pending
+    // conference/transfer calls on this line
+    //
+
+    {
+        DWORD       i;
+        PDRVCALL    pCall;
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        for (i = 0; i < gESPGlobals.dwNumAddressesPerLine; i++)
+        {
+            for(
+                pCall = pLine->aAddrs[i].pCalls;
+                pCall != NULL;
+                pCall = pCall->pNext
+                )
+            {
+                switch (pCall->dwCallState)
+                {
+                case LINECALLSTATE_IDLE:
+
+                    continue;
+
+                case LINECALLSTATE_ONHOLD:
+
+                    lpLineDevStatus->dwNumOnHoldCalls++;
+                    continue;
+
+                case LINECALLSTATE_ONHOLDPENDCONF:
+                case LINECALLSTATE_ONHOLDPENDTRANSFER:
+
+                    lpLineDevStatus->dwNumOnHoldPendCalls++;
+                    continue;
+
+                default:
+
+                    lpLineDevStatus->dwNumActiveCalls++;
+                    continue;
+                }
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    lpLineDevStatus->dwLineFeatures = AllLineFeatures1_0;
+    //lpLineDevStatus->dwNumCallCompletions
+    //lpLineDevStatus->dwRingMode
+    //lpLineDevStatus->dwSignalLevel
+    //lpLineDevStatus->dwBatteryLevel
+    //lpLineDevStatus->dwRoamMode
+    lpLineDevStatus->dwDevStatusFlags = LINEDEVSTATUSFLAGS_CONNECTED |
+                                        LINEDEVSTATUSFLAGS_INSERVICE;
+    //lpLineDevStatus->dwTerminalModesSize
+    //lpLineDevStatus->dwTerminalModesOffset
+    //lpLineDevStatus->dwDevSpecificSize
+    //lpLineDevStatus->dwDevSpecificOffset
+
+    if (gESPGlobals.dwSPIVersion >= 0x20000)
+    {
+        lpLineDevStatus->dwLineFeatures = AllLineFeatures2_0;
+
+        lpLineDevStatus->dwAvailableMediaModes = AllMediaModes1_4;
+
+        //lpLineDevStatus->dwAppInfoSize;     tapi fills this in
+        //lpLineDevStatus->dwAppInfoOffset;   tapi fills this in
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwNumAddressIDs
+    )
+{
+    static char szFuncName[] = "lineGetNumAddressIDs";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine              },
+        { "lpdwNumAddressIDs",  lpdwNumAddressIDs   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (Prolog (&info))
+    {
+        *lpdwNumAddressIDs = gESPGlobals.dwNumAddressesPerLine;
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineHold_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam2;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        pAsyncReqInfo->lResult = SetCallState(
+            pCall,
+            dwCallInstThen,
+            LINECALLSTATE_CONNECTED,
+            LINECALLSTATE_ONHOLD,
+            0,
+            TRUE
+            );
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static char szFuncName[] = "lineHold";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        2,
+        params,
+        TSPI_lineHold_postProcess
+
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam2))
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineMakeCall_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       bDestAddress   = pAsyncReqInfo->dwParam3,
+                bValidLineID   = pAsyncReqInfo->dwParam4,
+                dwCallInstThen = pAsyncReqInfo->dwParam6,
+                dwCallInstNow;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam1,
+                pDestCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+    PDRVLINE    pDestLine = (PDRVLINE) pAsyncReqInfo->dwParam5;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if (bDestAddress)
+        {
+            if (bValidLineID && !pDestCall)
+            {
+                SetCallState(
+                    pCall,
+                    dwCallInstThen,
+                    0xffffffff,
+                    LINECALLSTATE_BUSY,
+                    LINEBUSYMODE_UNAVAIL,
+                    TRUE
+                    );
+            }
+            else
+            {
+                SetCallState(
+                    pCall,
+                    dwCallInstThen,
+                    0xffffffff,
+                    LINECALLSTATE_DIALING,
+                    0,
+                    FALSE
+                    );
+
+                SetCallState(
+                    pCall,
+                    dwCallInstThen,
+                    0xffffffff,
+                    LINECALLSTATE_RINGBACK,
+                    0,
+                    TRUE
+                    );
+            }
+
+            if (pDestCall)
+            {
+                EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+                if (IsValidDrvCall (pCall, &dwCallInstNow) &&
+                    dwCallInstNow == dwCallInstThen)
+                {
+                    SendLineEvent(
+                        pDestLine,
+                        NULL,
+                        LINE_NEWCALL,
+                        (DWORD) pDestCall,
+                        (DWORD) &pDestCall->htCall,
+                        0
+                        );
+
+                    if (pDestCall->htCall != NULL)
+                    {
+                        SetCallState(
+                            pDestCall,
+                            pDestCall->dwCallInstance,
+                            0xffffffff,
+                            LINECALLSTATE_OFFERING,
+                            0,
+                            TRUE
+                            );
+                    }
+                    else
+                    {
+                        FreeCall (pDestCall, pDestCall->dwCallInstance);
+                    }
+                }
+                else
+                {
+                    FreeCall (pDestCall, pDestCall->dwCallInstance);
+                }
+
+                LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+            }
+        }
+        else
+        {
+            SetCallState(
+                pCall,
+                dwCallInstThen,
+                0xffffffff,
+                LINECALLSTATE_DIALTONE,
+                0,
+                TRUE
+                );
+        }
+    }
+    else
+    {
+        FreeCall (pCall, dwCallInstThen);
+
+        if (pDestCall)
+        {
+            FreeCall (pDestCall, pDestCall->dwCallInstance);
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static char szFuncName[] = "lineMakeCall";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   },
+        { szlpCallParams,       lpCallParams    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        7,
+        params,
+        TSPI_lineMakeCall_postProcess
+
+    };
+
+    if (Prolog (&info))
+    {
+        BOOL        bValidLineID = FALSE;
+        LONG        lResult;
+        PDRVCALL    pCall, pDestCall;
+        PDRVLINE    pLine = (PDRVLINE) hdLine, pDestLine;
+
+
+        if ((lResult = AllocCall (pLine, htCall, lpCallParams, &pCall)) == 0)
+        {
+            *lphdCall = (HDRVCALL) pCall;
+
+            CreateIncomingCall(
+                lpszDestAddress,
+                lpCallParams,
+                pCall,
+                &bValidLineID,
+                &pDestLine,
+                &pDestCall
+                );
+
+            info.pAsyncReqInfo->dwParam1 = pCall;
+            info.pAsyncReqInfo->dwParam2 = pDestCall;
+            info.pAsyncReqInfo->dwParam3 = (DWORD) lpszDestAddress;
+            info.pAsyncReqInfo->dwParam4 = (DWORD) bValidLineID;
+            info.pAsyncReqInfo->dwParam5 = pDestLine;
+            info.pAsyncReqInfo->dwParam6 = pCall->dwCallInstance;
+        }
+        else
+        {
+            info.lResult = lResult;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwDigitModes
+    )
+{
+    static char szFuncName[] = "lineMonitorDigits";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwDigitModes",   dwDigitModes,   aDigitModes }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaModes
+    )
+{
+    static char szFuncName[] = "lineMonitorMedia";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall                      },
+        { "dwMediaModes",   dwMediaModes,   aMediaModes }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+{
+    static char szFuncName[] = "lineMonitorTones";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwToneListID",   dwToneListID    },
+        { "lpToneList",     lpToneList      },
+        { "dwNumEntries",   dwNumEntries    }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (Prolog (&info))
+    {
+        DWORD       dwLastToneListID = 0;
+        HTAPICALL   htCall;
+        HTAPILINE   htLine;
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            htLine = ((PDRVLINE) pCall->pLine)->htLine;
+            htCall = pCall->htCall;
+
+            if (gbAutoGatherGenerateMsgs)
+            {
+                dwLastToneListID = dwToneListID;
+            }
+            else
+            {
+                dwLastToneListID = pCall->dwMonitorToneListID;
+                pCall->dwMonitorToneListID = dwToneListID;
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (dwLastToneListID)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                htLine,
+                htCall,
+                LINE_MONITORTONE,
+                0,
+                dwLastToneListID,
+                0
+                );
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    static char szFuncName[] = "lineNegotiateExtVersion";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwLowVersion",   dwLowVersion    },
+        { "dwHighVersion",  dwHighVersion   },
+        { "lpdwExtVersion", lpdwExtVersion  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 5, params };
+
+
+    if (Prolog (&info))
+    {
+        if (dwLowVersion == 0 ||
+            dwHighVersion == 0xffffffff ||
+            dwLowVersion > dwHighVersion)
+        {
+            info.lResult = LINEERR_INCOMPATIBLEEXTVERSION;
+        }
+        else
+        {
+            *lpdwExtVersion = dwHighVersion;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    static char szFuncName[] = "lineNegotiateTSPIVersion";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "dwLowVersion",       dwLowVersion    },
+        { "dwHighVersion",      dwHighVersion   },
+        { "lpdwTSPIVersion",    lpdwTSPIVersion }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+
+
+    if (Prolog (&info))
+    {
+        *lpdwTSPIVersion = gESPGlobals.dwSPIVersion;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD       dwDeviceID,
+    HTAPILINE   htLine,
+    LPHDRVLINE  lphdLine,
+    DWORD       dwTSPIVersion,
+    LINEEVENT   lpfnEventProc
+    )
+{
+    static char szFuncName[] = "lineOpen";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "htLine",         htLine          },
+        { "lphdLine",       lphdLine        },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpfnEventProc",  lpfnEventProc   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 5, params };
+    PDRVLINE pLine;
+
+
+    if (Prolog (&info))
+    {
+        if ((pLine = GetLineFromID (dwDeviceID)))
+        {
+            pLine->htLine = htLine;
+
+            *lphdLine = (HDRVLINE) pLine;
+
+            WriteEventBuffer(
+                pLine->dwDeviceID,
+                WIDGETTYPE_LINE,
+                (DWORD) pLine,
+                (DWORD) htLine,
+                0,
+                0
+                );
+        }
+        else
+        {
+            info.lResult = LINEERR_OPERATIONFAILED;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_linePark_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam2,
+                dwParkIndex = pAsyncReqInfo->dwParam4;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam1,
+                pParkedCall = (PDRVCALL) pAsyncReqInfo->dwParam3,
+                pDestCall;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        pDestCall = pCall->pDestCall;
+        pCall->pDestCall = NULL;
+
+        pParkedCall->bConnectedToDestCall =
+            pCall->bConnectedToDestCall;
+
+        pAsyncReqInfo->lResult = SetCallState(
+            pCall,
+            dwCallInstThen,
+            LINECALLSTATE_CONNECTED | LINECALLSTATE_ONHOLD,
+            LINECALLSTATE_IDLE,
+            0,
+            TRUE
+            );
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pDestCall, NULL))
+        {
+            pDestCall->pDestCall = pParkedCall;
+            pParkedCall->pDestCall = pDestCall;
+        }
+
+// BUGBUG TSPI_linePark: what if dest call state chg while buddy parked???
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+    else
+    {
+        //
+        // Clean up parked call
+        //
+
+        if (pParkedCall->pSendingFlowspec)
+        {
+            DrvFree (pParkedCall->pSendingFlowspec);
+        }
+
+        if (pParkedCall->pReceivingFlowspec)
+        {
+            DrvFree (pParkedCall->pReceivingFlowspec);
+        }
+
+        if (pParkedCall->pCallData)
+        {
+            DrvFree (pParkedCall->pCallData);
+        }
+
+        DrvFree (pParkedCall);
+
+        gaParkedCalls[dwParkIndex] = NULL;
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    DWORD           dwParkMode,
+    LPCWSTR         lpszDirAddress,
+    LPVARSTRING     lpNonDirAddress
+    )
+{
+    static char szFuncName[] = "linePark";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "dwParkMode",         dwParkMode      },
+        { "lpszDirAddress",     lpszDirAddress  },
+        { "lpNonDirAddress",    lpNonDirAddress }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 5, params, NULL };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (Prolog (&info))
+    {
+        if (dwParkMode == LINEPARKMODE_DIRECTED)
+        {
+            info.lResult = TransferCall(
+                &info,
+                pCall,
+                LINECALLSTATE_CONNECTED | LINECALLSTATE_ONHOLD,
+                LINECALLSTATE_ONHOLD,
+                lpszDirAddress
+                );
+        }
+        else
+        {
+            //
+            // First check to see if buf is big enough to return parked addr
+            //
+
+            if (lpNonDirAddress->dwTotalSize <
+                    (sizeof (VARSTRING) + 9 * sizeof(WCHAR))) // L"9999#123"
+            {
+                lpNonDirAddress->dwNeededSize = sizeof (VARSTRING) +
+                    9 * sizeof(WCHAR);
+
+                info.lResult = LINEERR_STRUCTURETOOSMALL;
+
+                return (Epilog (&info));
+            }
+
+            EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+            if (IsValidDrvCall (pCall, NULL) == FALSE)
+            {
+                info.lResult = LINEERR_INVALCALLHANDLE;
+            }
+            else if (pCall->dwCallState != LINECALLSTATE_CONNECTED  &&
+                     pCall->dwCallState != LINECALLSTATE_ONHOLD)
+            {
+                info.lResult = LINEERR_INVALCALLSTATE;
+            }
+            else
+            {
+                DWORD i;
+
+
+                for (i = 0; i < MAX_NUM_PARKED_CALLS; i++)
+                {
+                    if (gaParkedCalls[i] == NULL)
+                    {
+                        break;
+                    }
+                }
+
+                if (i < MAX_NUM_PARKED_CALLS)
+                {
+                    //
+                    // Create a new call struct, dup-ing all the info of
+                    // the existing call, & stick it in the parking place
+                    //
+
+                    DWORD       dwStringSize;
+                    PDRVCALL    pParkedCall;
+
+
+                    if ((pParkedCall = DrvAlloc (sizeof (DRVCALL))))
+                    {
+                        char buf[16];
+
+
+                        CopyMemory(
+                            &pParkedCall->dwMediaMode,
+                            &pCall->dwMediaMode,
+                            8 * sizeof (DWORD) + sizeof (LINEDIALPARAMS)
+                            );
+
+                        if (pCall->pSendingFlowspec  &&
+                            (pParkedCall->pSendingFlowspec =
+                                DrvAlloc (pCall->dwSendingFlowspecSize)))
+
+                        {
+                            pParkedCall->dwSendingFlowspecSize =
+                                pCall->dwSendingFlowspecSize;
+                        }
+
+                        if (pCall->pReceivingFlowspec  &&
+                            (pParkedCall->pReceivingFlowspec =
+                                DrvAlloc (pCall->dwReceivingFlowspecSize)))
+
+                        {
+                            pParkedCall->dwReceivingFlowspecSize =
+                                pCall->dwReceivingFlowspecSize;
+                        }
+
+                        if (pCall->pCallData  &&
+                            (pParkedCall->pCallData =
+                                DrvAlloc (pCall->dwCallDataSize)))
+                        {
+                            pParkedCall->dwCallDataSize =
+                                pCall->dwCallDataSize;
+                        }
+
+                        pParkedCall->dwCallInstance = gdwCallInstance++;
+                        pParkedCall->dwCallID = pCall->dwCallID;
+
+                        gaParkedCalls[i] = pParkedCall;
+
+                        wsprintf (buf, "9999#%d", i);
+
+                        dwStringSize = (DWORD) MultiByteToWideChar(
+                           GetACP(),
+                           MB_PRECOMPOSED,
+                           (LPCSTR) buf,
+                           lstrlenA (buf) + 1,
+                           (LPWSTR) (lpNonDirAddress + 1),
+                           9
+                           ) * sizeof (WCHAR);
+
+                        lpNonDirAddress->dwNeededSize += dwStringSize;
+                        lpNonDirAddress->dwUsedSize   += dwStringSize;
+
+                        lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+                        lpNonDirAddress->dwStringSize   = dwStringSize;
+                        lpNonDirAddress->dwStringOffset = sizeof (VARSTRING);
+
+                        info.pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+                            TSPI_linePark_postProcess;
+
+                        info.pAsyncReqInfo->dwParam1 = pCall;
+                        info.pAsyncReqInfo->dwParam2 = pCall->dwCallInstance;
+                        info.pAsyncReqInfo->dwParam3 = pParkedCall;
+                        info.pAsyncReqInfo->dwParam4 = i;
+                    }
+                    else
+                    {
+                        info.lResult = LINEERR_NOMEM;
+                    }
+                }
+                else
+                {
+                    ShowStr(
+                        TRUE,
+                        "TSPI_linePark (undirected): no available " \
+                            "parking spaces"
+                        );
+
+                    info.lResult = LINEERR_OPERATIONFAILED;
+                }
+            }
+
+            LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_linePickup_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD      dwCallInstThen = pAsyncReqInfo->dwParam2;
+    PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState(
+            pCall,
+            dwCallInstThen,
+            0xffffffff,
+            LINECALLSTATE_OFFERING,
+            0,
+            TRUE
+            );
+    }
+    else
+    {
+        FreeCall (pCall, dwCallInstThen);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCWSTR         lpszDestAddress,
+    LPCWSTR         lpszGroupID
+    )
+{
+    static char szFuncName[] = "linePickup";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "lpszGroupID",        lpszGroupID     }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        7,
+        params,
+        TSPI_linePickup_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        LONG        lResult;
+        PDRVCALL    pCall;
+
+
+        if ((lResult = AllocCall(
+                (PDRVLINE) hdLine,
+                htCall,
+                NULL,
+                &pCall
+
+                )) == 0)
+        {
+            // BUGBUG deal w/ addr id
+
+            *lphdCall = (HDRVCALL) pCall;
+
+            info.pAsyncReqInfo->dwParam1 = (DWORD) pCall;
+            info.pAsyncReqInfo->dwParam2 = pCall->dwCallInstance;
+        }
+        else
+        {
+            info.lResult = lResult;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_linePrepareAddToConference_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwConfCallInstThen    = pAsyncReqInfo->dwParam1,
+                dwConsultCallInstThen = pAsyncReqInfo->dwParam4;
+    PDRVCALL    pConfCall    = (PDRVCALL) pAsyncReqInfo->dwParam2,
+                pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam3;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState(
+            pConfCall,
+            dwConfCallInstThen,
+            0xffffffff,
+            LINECALLSTATE_ONHOLDPENDCONF,
+            0,
+            TRUE
+            );
+
+        SetCallState(
+            pConsultCall,
+            dwConsultCallInstThen,
+            0xffffffff,
+            LINECALLSTATE_DIALTONE,
+            0,
+            TRUE
+            );
+    }
+    else
+    {
+        FreeCall (pConsultCall, dwConsultCallInstThen);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG        lResult;
+    PDRVCALL    pConsultCall;
+    static char szFuncName[] = "linePrepareAddToConference";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { "hdConfCall",         hdConfCall          },
+        { "htConsultCall",      htConsultCall       },
+        { "lphdConsultCall",    lphdConsultCall     },
+        { szlpCallParams,       lpCallParams        }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        5,
+        params,
+        TSPI_linePrepareAddToConference_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall(
+                (PDRVCALL) hdConfCall,
+                &info.pAsyncReqInfo->dwParam1
+                ))
+        {
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdConfCall;
+
+            if ((lResult = AllocCall(
+                    ((PDRVCALL) hdConfCall)->pLine, // BUGBUG: AV potential
+                    htConsultCall,
+                    lpCallParams,
+                    &pConsultCall
+
+                    )) == 0)
+            {
+                info.pAsyncReqInfo->dwParam3 = (DWORD) pConsultCall;
+                info.pAsyncReqInfo->dwParam4 = pConsultCall->dwCallInstance;
+
+                *lphdConsultCall = (HDRVCALL) pConsultCall;
+            }
+            else
+            {
+                info.lResult = lResult;
+            }
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    static char szFuncName[] = "lineRedirect";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 4, params, NULL };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (Prolog (&info))
+    {
+        info.lResult = TransferCall(
+            &info,
+            (PDRVCALL) hdCall,
+            LINECALLSTATE_OFFERING,
+            LINECALLSTATE_OFFERING,
+            lpszDestAddress
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineReleaseUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static char szFuncName[] = "lineReleaseUserUserInfo";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 2, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineRemoveFromConference_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    if (pAsyncReqInfo->lResult == 0)
+    {
+
+        DWORD      dwCallInstThen = pAsyncReqInfo->dwParam2;
+        PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if ((pAsyncReqInfo->lResult = SetCallState(
+                pCall,
+                dwCallInstThen,
+                LINECALLSTATE_CONFERENCED,
+                LINECALLSTATE_CONNECTED,
+                0,
+                TRUE
+
+                )) == 0)
+        {
+            PDRVCALL   pCall2 = (PDRVCALL) pCall->pConfParent;
+
+
+            while (pCall2 && (pCall2->pNextConfChild != pCall))
+            {
+                pCall2 = pCall2->pNextConfChild;
+            }
+
+            if (pCall2)
+            {
+                pCall2->pNextConfChild = pCall->pNextConfChild;
+            }
+
+            pCall->pConfParent = NULL;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static char szFuncName[] = "lineRemoveFromConference";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        2,
+        params,
+        TSPI_lineRemoveFromConference_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam2))
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static char szFuncName[] = "lineSecureCall";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 2, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE    hdLine,
+    DWORD       dwExtVersion
+    )
+{
+    static char szFuncName[] = "lineSelectExtVersion";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine          },
+        { "dwExtVersion",   dwExtVersion    }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "lineSendUserUserInfo";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 4, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL    hdCall,
+    DWORD       dwAppSpecific
+    )
+{
+    static char szFuncName[] = "lineSetAppSpecific";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwAppSpecific",  dwAppSpecific   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+        PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            if (pCall->dwAppSpecific != dwAppSpecific)
+            {
+                pCall->dwAppSpecific = dwAppSpecific;
+
+                SendLineEvent(
+                    pCall->pLine,
+                    pCall,
+                    LINE_CALLINFO,
+                    LINECALLINFOSTATE_APPSPECIFIC,
+                    0,
+                    0
+                    );
+            }
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetCallData_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam1, dwCallInstNow,
+                dwCallDataSize = pAsyncReqInfo->dwParam4;
+    LPVOID      pCallData = (LPVOID) pAsyncReqInfo->dwParam3, pToFree;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, &dwCallInstNow) &&
+            dwCallInstNow == dwCallInstThen)
+        {
+            pToFree               = pCall->pCallData;
+            pCall->pCallData      = pCallData;
+            pCall->dwCallDataSize = dwCallDataSize;
+
+            SendLineEvent(
+                pCall->pLine,
+                pCall,
+                LINE_CALLINFO,
+                LINECALLINFOSTATE_CALLDATA,
+                0,
+                0
+                );
+        }
+        else
+        {
+            pToFree = NULL;
+            pAsyncReqInfo->lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+        DrvFree (pToFree);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult != 0)
+    {
+        DrvFree (pCallData);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallData(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPVOID              lpCallData,
+    DWORD               dwSize
+    )
+{
+    static char szFuncName[] = "lineSetCallData";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      },
+        { "lpCallData",     lpCallData  },
+        { szdwSize,         dwSize      }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_lineSetCallData_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall(
+                (PDRVCALL) hdCall,
+                &info.pAsyncReqInfo->dwParam1
+                ))
+        {
+            LPVOID  pCallData;
+
+
+            if (dwSize)
+            {
+                if ((pCallData = DrvAlloc (dwSize)))
+                {
+                    CopyMemory (pCallData, lpCallData, dwSize);
+                }
+                else
+                {
+                    info.lResult = LINEERR_NOMEM;
+                }
+            }
+            else
+            {
+                pCallData = NULL;
+            }
+
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+            info.pAsyncReqInfo->dwParam3 = (DWORD) pCallData;
+            info.pAsyncReqInfo->dwParam4 = (DWORD) dwSize;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetCallParams_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD               dwCallInstThen = pAsyncReqInfo->dwParam1,
+                        dwCallInstNow,
+                        dwBearerMode = pAsyncReqInfo->dwParam3,
+                        dwMinRate = pAsyncReqInfo->dwParam4,
+                        dwMaxRate = pAsyncReqInfo->dwParam5;
+    PDRVCALL            pCall = pAsyncReqInfo->dwParam2;
+    LPLINEDIALPARAMS    pDialParams = pAsyncReqInfo->dwParam6;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, &dwCallInstNow)  &&
+            dwCallInstNow == dwCallInstThen)
+        {
+            DWORD   dwCallInfoStates = 0;
+
+
+            if (pCall->dwBearerMode != dwBearerMode)
+            {
+                pCall->dwBearerMode = dwBearerMode;
+                dwCallInfoStates |= LINECALLINFOSTATE_BEARERMODE;
+            }
+
+            if (pCall->dwMinRate != dwMinRate ||
+                pCall->dwMaxRate != dwMaxRate)
+            {
+                pCall->dwMinRate = dwMinRate;
+                pCall->dwMaxRate = dwMaxRate;
+                dwCallInfoStates |= LINECALLINFOSTATE_RATE;
+            }
+
+            if (pDialParams &&
+                (pCall->DialParams.dwDialPause != pDialParams->dwDialPause ||
+                pCall->DialParams.dwDialSpeed  != pDialParams->dwDialSpeed ||
+                pCall->DialParams.dwDigitDuration !=
+                    pDialParams->dwDigitDuration ||
+                pCall->DialParams.dwWaitForDialtone !=
+                    pDialParams->dwWaitForDialtone))
+            {
+                pCall->DialParams.dwDialPause       = pDialParams->dwDialPause;
+                pCall->DialParams.dwDialSpeed       = pDialParams->dwDialSpeed;
+                pCall->DialParams.dwDigitDuration   =
+                    pDialParams->dwDigitDuration;
+                pCall->DialParams.dwWaitForDialtone =
+                    pDialParams->dwWaitForDialtone;
+
+                dwCallInfoStates |= LINECALLINFOSTATE_DIALPARAMS;
+            }
+
+            if (dwCallInfoStates)
+            {
+                SendLineEvent(
+                    pCall->pLine,
+                    pCall,
+                    LINE_CALLINFO,
+                    dwCallInfoStates,
+                    0,
+                    0
+                    );
+            }
+        }
+        else
+        {
+            pAsyncReqInfo->lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pDialParams)
+    {
+        DrvFree (pDialParams);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+    static char szFuncName[] = "lineSetCallParams";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID                     },
+        { szhdCall,         hdCall                          },
+        { "dwBearerMode",   dwBearerMode,   aBearerModes    },
+        { "dwMinRate",      dwMinRate                       },
+        { "dwMaxRate",      dwMaxRate                       },
+        { "lpDialParams",   lpDialParams                    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        6,
+        params,
+        TSPI_lineSetCallParams_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall(
+                (PDRVCALL) hdCall,
+                &info.pAsyncReqInfo->dwParam1
+                ))
+        {
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+            info.pAsyncReqInfo->dwParam3 = dwBearerMode;
+            info.pAsyncReqInfo->dwParam4 = dwMinRate;
+            info.pAsyncReqInfo->dwParam5 = dwMaxRate;
+
+            if (lpDialParams)
+            {
+                LPLINEDIALPARAMS pDialParams;
+
+
+                if ((pDialParams = DrvAlloc (sizeof (LINEDIALPARAMS))))
+                {
+                    CopyMemory(
+                        pDialParams,
+                        lpDialParams,
+                        sizeof (LINEDIALPARAMS)
+                        );
+
+                    info.pAsyncReqInfo->dwParam8 = (DWORD) pDialParams;
+                }
+                else
+                {
+                    info.lResult = LINEERR_NOMEM;
+                }
+            }
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetCallQualityOfService_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam1, dwCallInstNow,
+                dwSendingFlowspecSize = pAsyncReqInfo->dwParam4,
+                dwReceivingFlowspecSize = pAsyncReqInfo->dwParam6;
+    LPVOID      pSendingFlowspec = (LPVOID) pAsyncReqInfo->dwParam3,
+                pReceivingFlowspec = (LPVOID) pAsyncReqInfo->dwParam5,
+                pToFree, pToFree2;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, &dwCallInstNow)  &&
+            dwCallInstNow == dwCallInstThen)
+        {
+            pToFree                      = pCall->pSendingFlowspec;
+            pCall->pSendingFlowspec      = pSendingFlowspec;
+            pCall->dwSendingFlowspecSize = dwSendingFlowspecSize;
+
+            pToFree2                       = pCall->pReceivingFlowspec;
+            pCall->pReceivingFlowspec      = pReceivingFlowspec;
+            pCall->dwReceivingFlowspecSize = dwReceivingFlowspecSize;
+
+            SendLineEvent(
+                pCall->pLine,
+                pCall,
+                LINE_CALLINFO,
+                LINECALLINFOSTATE_QOS,
+                0,
+                0
+                );
+        }
+        else
+        {
+            pToFree = pToFree2 = NULL;
+            pAsyncReqInfo->lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+        DrvFree (pToFree);
+        DrvFree (pToFree2);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult != 0)
+    {
+        DrvFree (pSendingFlowspec);
+        DrvFree (pReceivingFlowspec);
+    }
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallQualityOfService(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPVOID              lpSendingFlowspec,
+    DWORD               dwSendingFlowspecSize,
+    LPVOID              lpReceivingFlowspec,
+    DWORD               dwReceivingFlowspecSize
+    )
+{
+    static char szFuncName[] = "lineSetCallQualityOfService";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,                dwRequestID             },
+        { szhdCall,                     hdCall                  },
+        { "lpSendingFlowspec",          lpSendingFlowspec       },
+        { "dwSendingFlowspecSize",      dwSendingFlowspecSize   },
+        { "lpReceivingFlowspec",        lpReceivingFlowspec     },
+        { "dwReceivingFlowspecSize",    dwReceivingFlowspecSize }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        6,
+        params,
+        TSPI_lineSetCallQualityOfService_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam1))
+        {
+            LPVOID  pSendingFlowspec, pReceivingFlowspec;
+
+
+            if (dwSendingFlowspecSize)
+            {
+                if ((pSendingFlowspec = DrvAlloc (dwSendingFlowspecSize)))
+                {
+                    CopyMemory(
+                        pSendingFlowspec,
+                        lpSendingFlowspec,
+                        dwSendingFlowspecSize
+                        );
+                }
+                else
+                {
+                    info.lResult = LINEERR_NOMEM;
+                    goto TSPI_lineSetCallQualityOfService_epilog;
+                }
+            }
+            else
+            {
+                pSendingFlowspec = NULL;
+            }
+
+            if (dwReceivingFlowspecSize)
+            {
+                if ((pReceivingFlowspec = DrvAlloc (dwReceivingFlowspecSize)))
+                {
+                    CopyMemory(
+                        pReceivingFlowspec,
+                        lpReceivingFlowspec,
+                        dwReceivingFlowspecSize
+                        );
+                }
+                else
+                {
+                    info.lResult = LINEERR_NOMEM;
+
+                    if (pSendingFlowspec)
+                    {
+                        DrvFree (pSendingFlowspec);
+
+                    }
+
+                    goto TSPI_lineSetCallQualityOfService_epilog;
+                }
+            }
+            else
+            {
+                pReceivingFlowspec = NULL;
+            }
+
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+            info.pAsyncReqInfo->dwParam3 = (DWORD) pSendingFlowspec;
+            info.pAsyncReqInfo->dwParam4 = (DWORD) dwSendingFlowspecSize;
+            info.pAsyncReqInfo->dwParam5 = (DWORD) pReceivingFlowspec;
+            info.pAsyncReqInfo->dwParam6 = (DWORD) dwReceivingFlowspecSize;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+TSPI_lineSetCallQualityOfService_epilog:
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetCallTreatment_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam1, dwCallInstNow,
+                dwTreatment = pAsyncReqInfo->dwParam3;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, &dwCallInstNow) &&
+            dwCallInstNow == dwCallInstThen)
+        {
+            if (pCall->dwTreatment != dwTreatment)
+            {
+                pCall->dwTreatment = dwTreatment;
+
+                SendLineEvent(
+                    pCall->pLine,
+                    pCall,
+                    LINE_CALLINFO,
+                    LINECALLINFOSTATE_TREATMENT,
+                    0,
+                    0
+                    );
+            }
+        }
+        else
+        {
+            pAsyncReqInfo->lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallTreatment(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwTreatment
+    )
+{
+    static char szFuncName[] = "lineSetCallTreatment";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      },
+        { "dwTreatment",    dwTreatment }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        3,
+        params,
+        TSPI_lineSetCallTreatment_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam1))
+        {
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+            info.pAsyncReqInfo->dwParam3 = dwTreatment;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCurrentLocation(
+    DWORD   dwLocation
+    )
+{
+    static char szFuncName[] = "lineSetCurrentLocation";
+    FUNC_PARAM params[] =
+    {
+        { "dwLocation", dwLocation }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 1, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE    hdLine,
+    DWORD       dwMediaModes
+    )
+{
+    static char szFuncName[] = "lineSetDefaultMediaDetection";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine                      },
+        { "dwMediaModes",   dwMediaModes,   aMediaModes }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 2, params };
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+
+
+    if (Prolog (&info))
+    {
+        pLine->dwMediaModes = dwMediaModes;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    static char szFuncName[] = "lineSetDevConfig";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpDeviceConfig",     lpDeviceConfig  },
+        { szdwSize,             dwSize          },
+        { "lpszDeviceClass",    lpszDeviceClass }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetLineDevStatus(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwStatusToChange,
+    DWORD               fStatus
+    )
+{
+    static char szFuncName[] = "lineSetLineDevStatus";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID      },
+        { szhdLine,             hdLine           },
+        { "dwStatusToChange",   dwStatusToChange },
+        { "fStatus",            fStatus          }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 4, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    )
+{
+    static char szFuncName[] = "lineSetMediaControl";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,                 hdLine                  },
+        { "dwAddressID",            dwAddressID             },
+        { szhdCall,                 hdCall                  },
+        { "dwSelect",               dwSelect,   aCallSelects    },
+        { "lpDigitList",            lpDigitList             },
+        { "dwDigitNumEntries",      dwDigitNumEntries       },
+        { "lpMediaList",            lpMediaList             },
+        { "dwMediaNumEntries",      dwMediaNumEntries       },
+        { "lpToneList",             lpToneList              },
+        { "dwToneNumEntries",       dwToneNumEntries        },
+        { "lpCallStateList",        lpCallStateList         },
+        { "dwCallStateNumEntries",  dwCallStateNumEntries   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 12, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaMode
+    )
+{
+    static char szFuncName[] = "lineSetMediaMode";
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         szhdCall                  },
+        { "dwMediaMode",    dwMediaMode,  aMediaModes }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+        PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall (pCall, NULL))
+        {
+            if (pCall->dwMediaMode != dwMediaMode)
+            {
+                pCall->dwMediaMode = dwMediaMode;
+
+                SendLineEvent(
+                    pCall->pLine,
+                    pCall,
+                    LINE_CALLINFO,
+                    LINECALLINFOSTATE_MEDIAMODE,
+                    0,
+                    0
+                    );
+            }
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE    hdLine,
+    DWORD       dwLineStates,
+    DWORD       dwAddressStates
+    )
+{
+    static char szFuncName[] = "lineSetStatusMessages";
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "dwLineStates",       dwLineStates,   aLineStates },
+        { "dwAddressStates",    dwAddressStates,    aAddressStates  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    DWORD           dwSelect,
+    DWORD           dwTerminalModes,
+    DWORD           dwTerminalID,
+    DWORD           bEnable
+    )
+{
+    static char szFuncName[] = "lineSetTerminal";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { szhdCall,             hdCall          },
+        { "dwSelect",           dwSelect,   aCallSelects    },
+        { "dwTerminalModes",    dwTerminalModes,    aTerminalModes  },
+        { "dwTerminalID",       dwTerminalID    },
+        { "bEnable",            bEnable         }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 8, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetupConference_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam1,
+                dwConfCallInstThen = pAsyncReqInfo->dwParam4,
+                dwConsultCallInstThen = pAsyncReqInfo->dwParam6;
+    PDRVCALL    pCall        = (PDRVCALL) pAsyncReqInfo->dwParam2,
+                pConfCall    = (PDRVCALL) pAsyncReqInfo->dwParam3,
+                pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam5;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (SetCallState(
+                pConfCall,
+                dwConfCallInstThen,
+                0xffffffff, // BUGBUG specify vald call states
+                LINECALLSTATE_ONHOLDPENDCONF,
+                0,
+                TRUE
+
+                ) == 0)
+        {
+            if (pCall  &&
+                SetCallState(
+                    pCall,
+                    dwCallInstThen,
+                    0xffffffff, // BUGBUG specify vald call states
+                    LINECALLSTATE_CONFERENCED,
+                    0,
+                    TRUE
+
+                    ) == 0)
+            {
+                pCall->pConfParent = pConfCall;
+                pConfCall->pNextConfChild = pCall;
+            }
+
+            // The consult call isn't in the conf initially
+
+            SetCallState(
+                pConsultCall,
+                dwConsultCallInstThen,
+                0xffffffff, // BUGBUG specify vald call states
+                LINECALLSTATE_DIALTONE,
+                0,
+                TRUE
+                );
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+    else
+    {
+        FreeCall (pConfCall, dwConfCallInstThen);
+        FreeCall (pConsultCall, dwConsultCallInstThen);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static char szFuncName[] = "lineSetupConference";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { szhdLine,             hdLine          },
+        { "htConfCall",         htConfCall      },
+        { "lphdConfCall",       lphdConfCall    },
+        { "htConsultCall",      htConsultCall   },
+        { "lphdConsultCall",    lphdConsultCall },
+        { "dwNumParties",       dwNumParties    },
+        { szlpCallParams,       lpCallParams    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        9,
+        params,
+        TSPI_lineSetupConference_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        LONG        lResult;
+        PDRVCALL    pConfCall, pConsultCall;
+        PDRVLINE    pLine;
+
+
+        //info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (hdCall  &&
+            !IsValidDrvCall(
+                (PDRVCALL) hdCall,
+                &info.pAsyncReqInfo->dwParam1
+                ))
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+            goto TSPI_lineSetupConference_leaveCritSec;
+        }
+
+        pLine = (hdCall ? (PDRVLINE) ((PDRVCALL) hdCall)->pLine :
+            (PDRVLINE) hdLine);
+
+        if ((lResult = AllocCall(
+                pLine,
+                htConfCall,
+                lpCallParams,
+                &pConfCall
+
+                )) == 0)
+        {
+            if ((lResult = AllocCall(
+                    pLine,
+                    htConsultCall,
+                    lpCallParams,
+                    &pConsultCall
+
+                    )) == 0)
+            {
+                info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+                info.pAsyncReqInfo->dwParam3 = (DWORD) pConfCall;
+                info.pAsyncReqInfo->dwParam4 = pConfCall->dwCallInstance;
+                info.pAsyncReqInfo->dwParam5 = (DWORD) pConsultCall;
+                info.pAsyncReqInfo->dwParam6 = pConsultCall->dwCallInstance;
+
+                *lphdConfCall = (HDRVCALL) pConfCall;
+                *lphdConsultCall = (HDRVCALL) pConsultCall;
+            }
+            else
+            {
+                FreeCall (pConfCall, pConfCall->dwCallInstance);
+                info.lResult = lResult;
+            }
+        }
+        else
+        {
+            info.lResult = lResult;
+        }
+
+TSPI_lineSetupConference_leaveCritSec:
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetupTransfer_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam1,
+                dwConsultCallInstThen = pAsyncReqInfo->dwParam4;
+    PDRVCALL    pCall        = (PDRVCALL) pAsyncReqInfo->dwParam2,
+                pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam3;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if (SetCallState(
+                pConsultCall,
+                dwConsultCallInstThen,
+                0xffffffff, // BUGBUG specify vald call states
+                LINECALLSTATE_DIALTONE,
+                0,
+                TRUE
+
+                )  == 0)
+        {
+            SetCallState(
+                pCall,
+                dwCallInstThen,
+                0xffffffff, // BUGBUG specify vald call states
+                LINECALLSTATE_ONHOLD,
+                0,
+                TRUE
+                );
+        }
+    }
+    else
+    {
+        FreeCall (pConsultCall, dwConsultCallInstThen);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static char szFuncName[] = "lineSetupTransfer";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "htConsultCall",      htConsultCall   },
+        { "lphdConsultCall",    lphdConsultCall },
+        { szlpCallParams,       lpCallParams    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        5,
+        params,
+        TSPI_lineSetupTransfer_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam1))
+        {
+            LONG        lResult;
+            PDRVCALL    pConsultCall;
+
+
+            if ((lResult = AllocCall(
+                    ((PDRVCALL) hdCall)->pLine,
+                    htConsultCall,
+                    lpCallParams,
+                    &pConsultCall
+
+                    )) == 0)
+            {
+                *lphdConsultCall = (HDRVCALL) pConsultCall;
+
+                info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+                info.pAsyncReqInfo->dwParam3 = (DWORD) pConsultCall;
+                info.pAsyncReqInfo->dwParam4 = pConsultCall->dwCallInstance;
+            }
+            else
+            {
+                info.lResult = lResult;
+            }
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSwapHold_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwActiveCallInstThen = pAsyncReqInfo->dwParam1,
+                dwHeldCallInstThen   = pAsyncReqInfo->dwParam2,
+                dwActiveCallInstNow, dwHeldCallInstNow;
+    PDRVCALL    pActiveCall = (PDRVCALL) pAsyncReqInfo->dwParam3,
+                pHeldCall = (PDRVCALL) pAsyncReqInfo->dwParam4;
+
+
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        if (SetCallState(
+                pActiveCall,
+                dwActiveCallInstThen,
+                0xffffffff, // BUGBUG specify vald call states
+                LINECALLSTATE_ONHOLD,
+                0,
+                TRUE
+
+                ) == 0)
+        {
+            SetCallState(
+                pHeldCall,
+                dwHeldCallInstThen,
+                0xffffffff, // BUGBUG specify vald call states
+                LINECALLSTATE_CONNECTED,
+                0,
+                TRUE
+                );
+        }
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdActiveCall,
+    HDRVCALL        hdHeldCall
+    )
+{
+    static char szFuncName[] = "lineSwapHold";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { "hdActiveCall",   hdActiveCall    },
+        { "hdHeldCall",     hdHeldCall      }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        3,
+        params,
+        TSPI_lineSwapHold_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall(
+                (PDRVCALL) hdActiveCall,
+                &info.pAsyncReqInfo->dwParam1
+                ) &&
+
+            IsValidDrvCall(
+                (PDRVCALL) hdHeldCall,
+                &info.pAsyncReqInfo->dwParam2
+                ))
+        {
+            info.pAsyncReqInfo->dwParam3 = (DWORD) hdActiveCall;
+            info.pAsyncReqInfo->dwParam4 = (DWORD) hdHeldCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwCompletionID
+    )
+{
+    static char szFuncName[] = "lineUncompleteCall";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdLine,         hdLine          },
+        { "dwCompletionID", dwCompletionID  }
+    };
+    FUNC_INFO info = { szFuncName, ASYNC, 3, params, NULL };
+
+
+    if (Prolog (&info))
+    {
+        if (dwCompletionID == 0xffffffff)
+        {
+            info.lResult = LINEERR_INVALCOMPLETIONID;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineUnhold_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD      dwCallInstThen = pAsyncReqInfo->dwParam1;
+        PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+
+
+        pAsyncReqInfo->lResult == SetCallState(
+            pCall,
+            dwCallInstThen,
+            LINECALLSTATE_ONHOLD,
+            LINECALLSTATE_CONNECTED,
+            0,
+            TRUE
+            );
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static char szFuncName[] = "lineUnhold";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      },
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        2,
+        params,
+        TSPI_lineUnhold_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (IsValidDrvCall ((PDRVCALL) hdCall, &info.pAsyncReqInfo->dwParam1))
+        {
+            info.pAsyncReqInfo->dwParam2 = (DWORD) hdCall;
+        }
+        else
+        {
+            info.lResult = LINEERR_INVALCALLHANDLE;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineUnpark_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD      dwCallInstThen = pAsyncReqInfo->dwParam2,
+               dwParkIndex = pAsyncReqInfo->dwParam3,
+               dwCallInstNow;
+    PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        //
+        // Make sure there's still a call there to unpark
+        //
+
+        if (gaParkedCalls[dwParkIndex] == NULL)
+        {
+            pAsyncReqInfo->lResult = LINEERR_OPERATIONFAILED;
+        }
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+        if (gaParkedCalls[dwParkIndex] != NULL  &&
+            IsValidDrvCall (pCall, &dwCallInstNow)  &&
+            dwCallInstNow == dwCallInstThen)
+        {
+            //
+            // Copy all the data from the parked call to the new call,
+            // then free the parked call
+            //
+
+            PDRVCALL    pParkedCall = gaParkedCalls[dwParkIndex];
+
+
+            gaParkedCalls[dwParkIndex] = NULL;
+
+            CopyMemory(
+                &pCall->dwMediaMode,
+                &pParkedCall->dwMediaMode,
+                14 * sizeof (DWORD) + sizeof (LINEDIALPARAMS)
+                );
+
+            if ((pCall->pDestCall = pParkedCall->pDestCall))
+            {
+                pCall->pDestCall->pDestCall = pCall;
+                pCall->bConnectedToDestCall =
+                    pParkedCall->bConnectedToDestCall;
+            }
+
+            CopyMemory(
+                &pCall->dwGatherDigitsEndToEndID,
+                &pParkedCall->dwGatherDigitsEndToEndID,
+                5 * sizeof (DWORD)
+                );
+
+
+            //
+            // Reset call state to 0 so SetCallState will do the indication
+            //
+
+            {
+                DWORD   dwCallState = pCall->dwCallState;
+
+
+                pCall->dwCallState = 0;
+
+                SetCallState(
+                    pCall,
+                    dwCallInstThen,
+                    0xffffffff, // BUGBUG specify valid call states
+                    dwCallState,
+                    0,
+                    TRUE
+                    );
+            }
+
+            pParkedCall->dwKey = INVAL_KEY;
+            DrvFree (pParkedCall);
+        }
+        else
+        {
+            SetCallState(
+                pCall,
+                dwCallInstThen,
+                0xffffffff, // BUGBUG specify valid call states
+                LINECALLSTATE_IDLE,
+                0,
+                TRUE
+                );
+        }
+
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+    }
+    else
+    {
+        FreeCall (pCall, dwCallInstThen);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCWSTR         lpszDestAddress
+    )
+{
+    static char szFuncName[] = "lineUnpark";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    lpszDestAddress }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        6,
+        params,
+        NULL
+    };
+
+
+    if (Prolog (&info))
+    {
+        //
+        // See if the park addr is valid, & if there's actually a
+        // call parked there now
+        //
+
+        char   *pszDestAddress, *p, c;
+        DWORD   length, dwParkIndex;
+
+
+        //
+        // Convert dest addr from unicode to ascii
+        //
+
+        length = (lstrlenW (lpszDestAddress) + 1) * sizeof (WCHAR);
+
+        if (!(pszDestAddress = DrvAlloc (length)))
+        {
+            info.lResult = LINEERR_NOMEM;
+            return (Epilog);
+        }
+
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDestAddress,
+            -1,
+            pszDestAddress,
+            length,
+            NULL,
+            NULL
+            );
+
+        p = pszDestAddress;
+
+
+        //
+        // See if destination address is in the format of "9999#<addr id>"
+        //
+
+        if (*p++ != '9'  ||
+            *p++ != '9'  ||
+            *p++ != '9'  ||
+            *p++ != '9'  ||
+            *p++ != '#'  ||
+            *p < '0'     ||
+            *p > '9')
+        {
+            info.lResult = LINEERR_INVALADDRESS;
+            goto TSPI_lineUnpark_freeDestAddress;
+        }
+
+        for (dwParkIndex = 0; (c = *p); p++)
+        {
+            if (c >= '0' && c <= '9')
+            {
+                dwParkIndex *= 10;
+                dwParkIndex += ((DWORD)(c - '0'));
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        if (c != '\0'  ||  dwParkIndex >= MAX_NUM_PARKED_CALLS)
+        {
+            info.lResult = LINEERR_INVALADDRESS;
+            goto TSPI_lineUnpark_freeDestAddress;
+        }
+
+        if (gaParkedCalls[dwParkIndex] != NULL)
+        {
+            PDRVCALL        pCall;
+            LINECALLPARAMS  callParams;
+
+
+            ZeroMemory (&callParams, sizeof (LINECALLPARAMS));
+
+            callParams.dwTotalSize = sizeof (LINECALLPARAMS);
+
+            callParams.dwAddressID = dwAddressID;
+            callParams.dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+
+            if ((info.lResult = AllocCall(
+                    (PDRVLINE) hdLine,
+                    htCall,
+                    &callParams,
+                    &pCall
+
+                    )) == 0)
+            {
+                info.pAsyncReqInfo->dwParam1 = (DWORD) pCall;
+                info.pAsyncReqInfo->dwParam2 = pCall->dwCallInstance;
+                info.pAsyncReqInfo->dwParam3 = dwParkIndex;
+
+                *lphdCall = (HDRVCALL) pCall;
+
+                info.pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+                    TSPI_lineUnpark_postProcess;
+            }
+        }
+        else
+        {
+            info.lResult = LINEERR_OPERATIONFAILED;
+        }
+
+TSPI_lineUnpark_freeDestAddress:
+
+        DrvFree (pszDestAddress);
+    }
+
+    return (Epilog (&info));
+}
+
+
+
+//
+// -------------------------- TSPI_phoneXxx funcs -----------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE   hdPhone
+    )
+{
+    static char szFuncName[] = "phoneClose";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,    hdPhone }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 1, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    //
+    // This is more of a "command" than a request, in that TAPI.DLL is
+    // going to consider the phone closed whether we like it or not.
+    // Therefore we want to free up the phone even if the user chooses
+    // to return an error.
+    //
+
+    Prolog (&info);
+
+    pPhone->htPhone = (HTAPIPHONE) NULL;
+
+    WriteEventBuffer (pPhone->dwDeviceID,  WIDGETTYPE_PHONE, 0, 0, 0, 0);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "phoneDevSpecific";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdPhone,        hdPhone     },
+        { "lpParams",       lpParams    },
+        { szdwSize,         dwSize      }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params
+    };
+
+
+    if (Prolog (&info))
+    {
+        PESPDEVSPECIFICINFO pInfo = (PESPDEVSPECIFICINFO) lpParams;
+
+
+        if (dwSize >= sizeof (ESPDEVSPECIFICINFO)  &&
+            pInfo->dwKey == ESPDEVSPECIFIC_KEY)
+        {
+            switch (pInfo->dwType)
+            {
+            case ESP_DEVSPEC_MSG:
+
+                switch (pInfo->u.EspMsg.dwMsg)
+                {
+                case PHONE_BUTTON:
+                case PHONE_CLOSE:
+                case PHONE_DEVSPECIFIC:
+                case PHONE_STATE:
+
+                    SendPhoneEvent(
+                        (PDRVPHONE) hdPhone,
+                        pInfo->u.EspMsg.dwMsg,
+                        pInfo->u.EspMsg.dwParam1,
+                        pInfo->u.EspMsg.dwParam2,
+                        pInfo->u.EspMsg.dwParam3
+                        );
+
+                    break;
+
+                case PHONE_CREATE: // BUGBUG
+
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_phoneDevSpecific: no support " \
+                            "for indicating PHONE_CREATE yet"
+                        );
+
+                    info.lResult = PHONEERR_OPERATIONFAILED;
+                    break;
+
+                default:
+
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_phoneDevSpecific: unrecognized " \
+                            "ESPDEVSPECIFICINFO.u.EspMsg.dwMsg (=x%x)",
+                        pInfo->u.EspMsg.dwMsg
+                        );
+
+                    info.lResult = PHONEERR_OPERATIONFAILED;
+                    break;
+                }
+
+                break;
+
+            case ESP_DEVSPEC_RESULT:
+            {
+                DWORD   dwResult = pInfo->u.EspResult.lResult;
+
+
+                if (dwResult != 0  &&
+                    (dwResult < LINEERR_ALLOCATED ||
+                    dwResult > PHONEERR_REINIT ||
+                    (dwResult > LINEERR_DIALVOICEDETECT &&
+                    dwResult < PHONEERR_ALLOCATED)))
+                {
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_phoneDevSpecific: invalid request" \
+                            "result value (x%x)",
+                        dwResult
+                        );
+
+                    info.lResult = PHONEERR_OPERATIONFAILED;
+                }
+                else if (pInfo->u.EspResult.dwCompletionType >
+                            ESP_RESULT_CALLCOMPLPROCASYNC)
+                {
+                    ShowStr(
+                        TRUE,
+                        "ERROR: TSPI_phoneDevSpecific: invalid request" \
+                            "completion type (x%x)",
+                        pInfo->u.EspResult.dwCompletionType
+                        );
+
+                    info.lResult = PHONEERR_OPERATIONFAILED;
+                }
+                else
+                {
+                    glNextRequestResult = (LONG) dwResult;
+                    gdwNextRequestCompletionType =
+                        pInfo->u.EspResult.dwCompletionType;
+                    gdwDevSpecificRequestID = dwRequestID;
+                }
+
+                break;
+            }
+            default:
+
+                ShowStr(
+                    TRUE,
+                    "ERROR: TSPI_phoneDevSpecific: unrecognized " \
+                        "ESPDEVSPECIFICINFO.dwType (=x%x)",
+                    pInfo->dwType
+                    );
+
+                info.lResult = PHONEERR_OPERATIONFAILED;
+                break;
+            }
+        }
+        else
+        {
+            info.pAsyncReqInfo->dwParam1 = lpParams;
+            info.pAsyncReqInfo->dwParam2 = dwSize;
+
+            info.pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+                TSPI_lineDevSpecific_postProcess;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    static char szFuncName[] = "phoneGetButtonInfo";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "lpButtonInfo",   lpButtonInfo    }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 3, params };
+    PDRVPHONE   pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        if (dwButtonLampID == 0)
+        {
+            if (pPhone->pButtonInfo)
+            {
+                if (pPhone->pButtonInfo->dwUsedSize <=
+                        lpButtonInfo->dwTotalSize)
+                {
+                    CopyMemory(
+                        (LPBYTE) &lpButtonInfo->dwNeededSize,
+                        (LPBYTE) &pPhone->pButtonInfo->dwNeededSize,
+                        pPhone->pButtonInfo->dwUsedSize - sizeof (DWORD)
+                        );
+                }
+                else
+                {
+                    lpButtonInfo->dwNeededSize =
+                        pPhone->pButtonInfo->dwUsedSize;
+                }
+            }
+        }
+        else
+        {
+            info.lResult = PHONEERR_INVALBUTTONLAMPID;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE   hdPhone,
+    DWORD       dwDataID,
+    LPVOID      lpData,
+    DWORD       dwSize
+    )
+{
+    static char szFuncName[] = "phoneGetData";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,    hdPhone     },
+        { "dwDataID",   dwDataID    },
+        { "lpData",     lpData      },
+        { szdwSize,     dwSize      }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        if (dwDataID != 0)
+        {
+            info.lResult = PHONEERR_INVALDATAID;
+        }
+        else if (pPhone->pData)
+        {
+            CopyMemory(
+                lpData,
+                pPhone->pData,
+                (dwSize > pPhone->dwDataSize ? pPhone->dwDataSize : dwSize)
+                );
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD       dwDeviceID,
+    DWORD       dwTSPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    static char szFuncName[] = "phoneGetDevCaps";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpPhoneCaps",    lpPhoneCaps     }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 4, params };
+    WCHAR       buf[32];
+    DWORD       dwDummy;
+    PDRVPHONE   pPhone = GetPhoneFromID (dwDeviceID);
+
+
+    if (Prolog (&info))
+    {
+        //lpPhoneCaps->dwNeededSize
+        //lpPhoneCaps->dwUsedSize
+
+        InsertVarDataString(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwProviderInfoSize,
+            gszProviderInfo
+            );
+
+        //lpPhoneCaps->dwPhoneInfoSize
+        //lpPhoneCaps->dwPhoneInfoOffset
+
+        lpPhoneCaps->dwPermanentPhoneID =
+            (gESPGlobals.dwPermanentProviderID << 16) |
+                (dwDeviceID - gESPGlobals.dwPhoneDeviceIDBase);
+
+        wsprintfW (buf, L"ESP Phone %d", dwDeviceID);
+
+        InsertVarDataString(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwPhoneNameSize,
+            buf
+            );
+
+        lpPhoneCaps->dwStringFormat = STRINGFORMAT_ASCII;
+        //lpPhoneCaps->dwPhoneStates
+        lpPhoneCaps->dwHookSwitchDevs = AllHookSwitchDevs;
+        lpPhoneCaps->dwHandsetHookSwitchModes =
+        lpPhoneCaps->dwSpeakerHookSwitchModes =
+        lpPhoneCaps->dwHeadsetHookSwitchModes = AllHookSwitchModes;
+        lpPhoneCaps->dwVolumeFlags = AllHookSwitchDevs;
+        lpPhoneCaps->dwGainFlags = AllHookSwitchDevs;
+        lpPhoneCaps->dwDisplayNumRows = 1;
+        lpPhoneCaps->dwDisplayNumColumns = PHONE_DISPLAY_SIZE_IN_CHARS;
+        lpPhoneCaps->dwNumRingModes = 0xffffffff;
+
+        lpPhoneCaps->dwNumButtonLamps = 1;
+
+        dwDummy = PHONEBUTTONMODE_FEATURE;
+
+        InsertVarData(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwButtonModesSize,
+            (LPVOID) &dwDummy,
+            sizeof (DWORD)
+            );
+
+        dwDummy = PHONEBUTTONFUNCTION_UNKNOWN;
+
+        InsertVarData(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwButtonFunctionsSize,
+            (LPVOID) &dwDummy,
+            sizeof (DWORD)
+            );
+
+        dwDummy = PHONELAMPMODE_OFF;
+
+        InsertVarData(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwLampModesSize,
+            (LPVOID) &dwDummy,
+            sizeof (DWORD)
+            );
+
+
+        lpPhoneCaps->dwNumSetData = 1;
+
+        dwDummy = MAX_VAR_DATA_SIZE;
+
+        InsertVarData(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwSetDataSize,
+            (LPVOID) &dwDummy,
+            sizeof (DWORD)
+            );
+
+        lpPhoneCaps->dwNumGetData = 1;
+
+        InsertVarData(
+            lpPhoneCaps,
+            &lpPhoneCaps->dwGetDataSize,
+            (LPVOID) &dwDummy,
+            sizeof (DWORD)
+            );
+
+        //lpPhoneCaps->dwDevSpecificSize
+        //lpPhoneCaps->dwDevSpecificOffset
+
+        if (gESPGlobals.dwSPIVersion >= 0x00020000)
+        {
+            //lpPhoneCaps->dwDeviceClassesSize
+            //lpPhoneCaps->dwDeviceClassesOffset
+            lpPhoneCaps->dwPhoneFeatures = AllPhoneFeatures;
+            lpPhoneCaps->dwSettableHandsetHookSwitchModes =
+            lpPhoneCaps->dwSettableSpeakerHookSwitchModes =
+            lpPhoneCaps->dwSettableHeadsetHookSwitchModes = AllHookSwitchModes;
+            //lpPhoneCaps->dwMonitoredHandsetHookSwitchModes
+            //lpPhoneCaps->dwMonitoredSpeakerHookSwitchModes
+            //lpPhoneCaps->dwMonitoredHeadsetHookSwitchModes
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDisplay
+    )
+{
+    static char szFuncName[] = "phoneGetDisplay";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,    hdPhone     },
+        { "lpDisplay",  lpDisplay   }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 2, params };
+    PDRVPHONE   pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        static DWORD    dwNeededSize = sizeof(VARSTRING) +
+                            PHONE_DISPLAY_SIZE_IN_BYTES;
+
+
+        if (lpDisplay->dwTotalSize >= dwNeededSize)
+        {
+            if (pPhone->pDisplay)
+            {
+                CopyMemory(
+                    lpDisplay + 1,
+                    pPhone->pDisplay,
+                    PHONE_DISPLAY_SIZE_IN_BYTES
+                    );
+            }
+            else
+            {
+                ZeroMemory (lpDisplay + 1, PHONE_DISPLAY_SIZE_IN_BYTES);
+            }
+
+            lpDisplay->dwUsedSize     = dwNeededSize;
+            lpDisplay->dwStringFormat = STRINGFORMAT_ASCII;
+            lpDisplay->dwStringSize   = PHONE_DISPLAY_SIZE_IN_BYTES;
+            lpDisplay->dwStringOffset = sizeof (VARSTRING);
+        }
+
+        lpDisplay->dwNeededSize = dwNeededSize;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    static char szFuncName[] = "phoneGetExtensionID";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpExtensionID",  lpExtensionID   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+        // BUGBUG TSPI_phoneGetExtensionID:
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE   hdPhone,
+    DWORD       dwHookSwitchDev,
+    LPDWORD     lpdwGain
+    )
+{
+    static char szFuncName[] = "phoneGetGain";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev },
+        { "lpdwGain",           lpdwGain        }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        switch (dwHookSwitchDev)
+        {
+        case PHONEHOOKSWITCHDEV_HANDSET:
+
+            *lpdwGain = pPhone->dwHandsetGain;
+            break;
+
+        case PHONEHOOKSWITCHDEV_SPEAKER:
+
+            *lpdwGain = pPhone->dwSpeakerGain;
+            break;
+
+        case PHONEHOOKSWITCHDEV_HEADSET:
+
+            *lpdwGain = pPhone->dwHeadsetGain;
+            break;
+
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE   hdPhone,
+    LPDWORD     lpdwHookSwitchDevs
+    )
+{
+    static char szFuncName[] = "phoneGetHookSwitch";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone             },
+        { "lpdwHookSwitchDevs", lpdwHookSwitchDevs  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        *lpdwHookSwitchDevs = 0;
+
+        if (!(pPhone->dwHandsetHookSwitchMode & PHONEHOOKSWITCHMODE_ONHOOK))
+        {
+            *lpdwHookSwitchDevs |= PHONEHOOKSWITCHDEV_HANDSET;
+        }
+
+        if (!(pPhone->dwSpeakerHookSwitchMode & PHONEHOOKSWITCHMODE_ONHOOK))
+        {
+            *lpdwHookSwitchDevs |= PHONEHOOKSWITCHDEV_SPEAKER;
+        }
+
+        if (!(pPhone->dwHeadsetHookSwitchMode & PHONEHOOKSWITCHMODE_ONHOOK))
+        {
+            *lpdwHookSwitchDevs |= PHONEHOOKSWITCHDEV_HEADSET;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD   dwDeviceID,
+    LPCWSTR lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    static char szFuncName[] = "phoneGetIcon";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass },
+        { "lphIcon",            lphIcon         }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+        if (lpszDeviceClass  &&
+            lstrcmpiW (lpszDeviceClass, L"tapi/InvalidDeviceClass") == 0)
+        {
+            info.lResult = PHONEERR_INVALDEVICECLASS;
+        }
+        else
+        {
+            *lphIcon = gESPGlobals.hIconPhone;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+{
+    static char szFuncName[] = "phoneGetID";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone         },
+        { "lpDeviceID",         lpDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass }
+        ,{ "hTargetProcess",     hTargetProcess }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+    DWORD    i, dwDeviceID, dwNeededSize = sizeof(VARSTRING) + sizeof(DWORD);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    for (i = 0; aszDeviceClasses[i]; i++)
+    {
+        if (lstrcmpiW (lpszDeviceClass, aszDeviceClasses[i]) == 0)
+        {
+            break;
+        }
+    }
+
+    if (!aszDeviceClasses[i])
+    {
+        info.lResult = PHONEERR_NODEVICE;
+        return (Epilog (&info));
+    }
+
+    if (lpDeviceID->dwTotalSize < dwNeededSize)
+    {
+        lpDeviceID->dwNeededSize = dwNeededSize;
+        lpDeviceID->dwUsedSize = 3 * sizeof(DWORD);
+
+        return (Epilog (&info));
+    }
+
+    if (i == 1)
+    {
+        dwDeviceID = pPhone->dwDeviceID;
+    }
+    else
+    {
+/*  BUGBUG TSPI_phoneGetID:    if (gbShowLineGetIDDlg)
+        {
+            char szDlgTitle[64];
+            EVENT_PARAM params[] =
+            {
+                { "dwDeviceID", PT_DWORD, gdwDefLineGetIDID, 0 }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 1, szDlgTitle, 0, params };
+            HWND hwnd;
+
+
+            if (strlen (lpszDeviceClass) > 20)
+            {
+                ((char far *)lpszDeviceClass)[19] = 0;
+            }
+
+            wsprintf(
+                szDlgTitle,
+                "TSPI_phoneGetID: select ID for class '%s'",
+                lpszDeviceClass
+                );
+
+            hwnd = CreateDialogParam(
+                ghInstance,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) NULL,
+                (DLGPROC) CallDlgProc,
+                (LPARAM) &paramsHeader
+                );
+
+            MsgLoopInTAPIClientContext (hwnd);
+
+            dwDeviceID = params[0].dwValue;
+        }
+        else
+        {
+*/
+            dwDeviceID = 0;
+//        }
+    }
+
+    lpDeviceID->dwNeededSize   =
+    lpDeviceID->dwUsedSize     = dwNeededSize;
+    lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+    lpDeviceID->dwStringSize   = sizeof(DWORD);
+    lpDeviceID->dwStringOffset = sizeof(VARSTRING);
+
+    *((LPDWORD)(lpDeviceID + 1)) = dwDeviceID;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE   hdPhone,
+    DWORD       dwButtonLampID,
+    LPDWORD     lpdwLampMode
+    )
+{
+    static char szFuncName[] = "phoneGetLamp";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "lpdwLampMode",   lpdwLampMode    }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+
+
+    if (Prolog (&info))
+    {
+        *lpdwLampMode = ((PDRVPHONE) hdPhone)->dwLampMode;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE   hdPhone,
+    LPDWORD     lpdwRingMode,
+    LPDWORD     lpdwVolume
+    )
+{
+    static char szFuncName[] = "phoneGetRing";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "lpdwRingMode",   lpdwRingMode    },
+        { "lpdwVolume",     lpdwVolume      }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        *lpdwRingMode = pPhone->dwRingMode;
+        *lpdwVolume   = pPhone->dwRingVolume;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE       hdPhone,
+    LPPHONESTATUS   lpPhoneStatus
+    )
+{
+    static char szFuncName[] = "phoneGetStatus";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "lpPhoneStatus",  lpPhoneStatus   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        //lpPhoneStatus->dwStatusFlags;
+        lpPhoneStatus->dwRingMode      = pPhone->dwRingMode;
+        lpPhoneStatus->dwRingVolume    = pPhone->dwRingVolume;
+        lpPhoneStatus->dwHandsetHookSwitchMode =
+            pPhone->dwHandsetHookSwitchMode;
+        lpPhoneStatus->dwHandsetVolume = pPhone->dwHandsetVolume;
+        lpPhoneStatus->dwHandsetGain   = pPhone->dwHandsetGain;
+        lpPhoneStatus->dwSpeakerHookSwitchMode =
+            pPhone->dwSpeakerHookSwitchMode;
+        lpPhoneStatus->dwSpeakerVolume = pPhone->dwSpeakerVolume;
+        lpPhoneStatus->dwSpeakerGain   = pPhone->dwSpeakerGain;
+        lpPhoneStatus->dwHeadsetHookSwitchMode =
+            pPhone->dwHeadsetHookSwitchMode;
+        lpPhoneStatus->dwHeadsetVolume = pPhone->dwHeadsetVolume;
+        lpPhoneStatus->dwHeadsetGain   = pPhone->dwHeadsetGain;
+
+        // BUGBUG TSPI_phoneGetStatus: copy 0's to display buf if !pDisplay
+
+        InsertVarData(
+            lpPhoneStatus,
+            &lpPhoneStatus->dwDisplaySize,
+            (LPVOID) pPhone->pDisplay,
+            (pPhone->pDisplay ? PHONE_DISPLAY_SIZE_IN_BYTES : 0)
+            );
+
+        InsertVarData(
+            lpPhoneStatus,
+            &lpPhoneStatus->dwLampModesSize,
+            (LPVOID) &pPhone->dwLampMode,
+            sizeof (DWORD)
+            );
+
+        //lpPhoneStatus->dwDevSpecificSize;
+        //lpPhoneStatus->dwDevSpecificOffset;
+
+        if (gESPGlobals.dwSPIVersion >= 0x00020000)
+        {
+            //lpPhoneStatus->
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE   hdPhone,
+    DWORD       dwHookSwitchDev,
+    LPDWORD     lpdwVolume
+    )
+{
+    static char szFuncName[] = "phoneGetVolume";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev,    aHookSwitchDevs },
+        { "lpdwVolume",         lpdwVolume      }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (Prolog (&info))
+    {
+        switch (dwHookSwitchDev)
+        {
+        case PHONEHOOKSWITCHDEV_HANDSET:
+
+            *lpdwVolume = pPhone->dwHandsetVolume;
+            break;
+
+        case PHONEHOOKSWITCHDEV_SPEAKER:
+
+            *lpdwVolume = pPhone->dwSpeakerVolume;
+            break;
+
+        case PHONEHOOKSWITCHDEV_HEADSET:
+
+            *lpdwVolume = pPhone->dwHeadsetVolume;
+            break;
+
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    static char szFuncName[] = "phoneNegotiateExtVersion";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwLowVersion",   dwLowVersion    },
+        { "dwHighVersion",  dwHighVersion   },
+        { "lpdwExtVersion", lpdwExtVersion  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 5, params };
+
+
+    if (Prolog (&info))
+    {
+        if (dwLowVersion == 0 ||
+            dwHighVersion == 0xffffffff ||
+            dwLowVersion > dwHighVersion)
+        {
+            info.lResult = PHONEERR_INCOMPATIBLEEXTVERSION;
+        }
+        else
+        {
+            *lpdwExtVersion = dwHighVersion;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    static char szFuncName[] = "phoneNegotiateTSPIVersion";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "dwLowVersion",       dwLowVersion    },
+        { "dwHighVersion",      dwHighVersion   },
+        { "lpdwTSPIVersion",    lpdwTSPIVersion }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+
+
+    if (Prolog (&info))
+    {
+        *lpdwTSPIVersion = gESPGlobals.dwSPIVersion;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneOpen(
+    DWORD       dwDeviceID,
+    HTAPIPHONE  htPhone,
+    LPHDRVPHONE lphdPhone,
+    DWORD       dwTSPIVersion,
+    PHONEEVENT  lpfnEventProc
+    )
+{
+    static char szFuncName[] = "phoneOpen";
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "htPhone",        htPhone         },
+        { "lphdPhone",      lphdPhone       },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpfnEventProc",  lpfnEventProc   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 5, params };
+
+
+    if (Prolog (&info))
+    {
+        PDRVPHONE pPhone;
+
+
+        if (!(pPhone = GetPhoneFromID (dwDeviceID)))
+        {
+            // BUGBUG
+        }
+
+        pPhone->htPhone = htPhone;
+
+        *lphdPhone = (HDRVPHONE) pPhone;
+
+        WriteEventBuffer(
+            pPhone->dwDeviceID,
+            WIDGETTYPE_PHONE,
+            (DWORD) pPhone,
+            (DWORD) htPhone,
+            0,
+            0
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE   hdPhone,
+    DWORD       dwExtVersion
+    )
+{
+    static char szFuncName[] = "phoneSelectExtVersion";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwExtVersion",   dwExtVersion    }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetButtonInfo_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    PDRVPHONE           pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+    LPPHONEBUTTONINFO   pButtonInfo = (LPPHONEBUTTONINFO)
+                            pAsyncReqInfo->dwParam2, pToFree;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.PhoneCritSec);
+
+        pToFree = pPhone->pButtonInfo;
+        pPhone->pButtonInfo = pButtonInfo;
+
+        LeaveCriticalSection (&gESPGlobals.PhoneCritSec);
+
+        DrvFree (pToFree);
+
+        // no msg to send for this one?
+    }
+    else
+    {
+        DrvFree (pButtonInfo);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+    static char szFuncName[] = "phoneSetButtonInfo";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "lpButtonInfo",   lpButtonInfo    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_phoneSetButtonInfo_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (dwButtonLampID == 0)
+        {
+            DWORD               dwNeededSize;
+            LPPHONEBUTTONINFO   pMyButtonInfo;
+
+
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+
+            dwNeededSize = sizeof (PHONEBUTTONINFO) +
+                lpButtonInfo->dwButtonTextSize +
+                lpButtonInfo->dwDevSpecificSize +
+                16;                             // 64-bit align var fields
+
+            if ((pMyButtonInfo = (LPPHONEBUTTONINFO) DrvAlloc (dwNeededSize)))
+            {
+                info.pAsyncReqInfo->dwParam2 = (DWORD) pMyButtonInfo;
+
+                CopyMemory(
+                    pMyButtonInfo,
+                    lpButtonInfo,
+                    (gESPGlobals.dwSPIVersion > 0x00010003 ?
+                        sizeof (PHONEBUTTONINFO) : 9 * sizeof (DWORD))
+                    );
+
+                pMyButtonInfo->dwTotalSize  = dwNeededSize;
+                pMyButtonInfo->dwNeededSize =
+                pMyButtonInfo->dwUsedSize   = sizeof (PHONEBUTTONINFO);
+
+                InsertVarData(
+                    pMyButtonInfo,
+                    &pMyButtonInfo->dwButtonTextSize,
+                    ((LPBYTE) lpButtonInfo) +
+                        lpButtonInfo->dwButtonTextOffset,
+                    lpButtonInfo->dwButtonTextSize
+                    );
+
+                InsertVarData(
+                    pMyButtonInfo,
+                    &pMyButtonInfo->dwDevSpecificSize,
+                    ((LPBYTE) lpButtonInfo) +
+                        lpButtonInfo->dwDevSpecificOffset,
+                    lpButtonInfo->dwDevSpecificSize
+                    );
+            }
+            else
+            {
+                info.lResult = PHONEERR_NOMEM;
+            }
+        }
+        else
+        {
+            info.lResult = PHONEERR_INVALBUTTONLAMPID;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetData_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwNewDataSize = pAsyncReqInfo->dwParam3;
+    LPVOID      pNewData = (LPVOID) pAsyncReqInfo->dwParam2, pToFree;
+    PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.PhoneCritSec);
+
+        pToFree            = pPhone->pData;
+        pPhone->pData      = pNewData;
+        pPhone->dwDataSize = dwNewDataSize;
+
+        LeaveCriticalSection (&gESPGlobals.PhoneCritSec);
+
+        DrvFree (pToFree);
+
+        // no msg to send for this one?
+    }
+    else
+    {
+        DrvFree (pNewData);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwDataID,
+    LPVOID          const lpData,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "phoneSetData";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdPhone,        hdPhone         },
+        { "dwDataID",       dwDataID        },
+        { "lpData",         lpData          },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        5,
+        params,
+        TSPI_phoneSetData_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (dwDataID != 0)
+        {
+            info.lResult = PHONEERR_INVALDATAID;
+        }
+        else
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+
+            if (dwSize)
+            {
+                info.pAsyncReqInfo->dwParam2 = (DWORD) DrvAlloc (dwSize);
+
+                if (info.pAsyncReqInfo->dwParam2 == 0)
+                {
+                    info.lResult = PHONEERR_NOMEM;
+                    return (Epilog (&info));
+                }
+
+                CopyMemory(
+                    (LPVOID) info.pAsyncReqInfo->dwParam2,
+                    lpData,
+                    dwSize
+                    );
+            }
+            else
+            {
+                info.pAsyncReqInfo->dwParam2 = 0;
+            }
+
+            info.pAsyncReqInfo->dwParam3 = (DWORD) dwSize;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetDisplay_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwColumn = pAsyncReqInfo->dwParam2,
+                dwSize =  pAsyncReqInfo->dwParam4;
+    WCHAR      *pDisplay = (LPVOID) pAsyncReqInfo->dwParam3;
+    PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        EnterCriticalSection (&gESPGlobals.PhoneCritSec);
+
+        if (pPhone->pDisplay ||
+            (pPhone->pDisplay = DrvAlloc (PHONE_DISPLAY_SIZE_IN_BYTES)))
+        {
+            CopyMemory(
+                pPhone->pDisplay + dwColumn,
+                pDisplay,
+                dwSize
+                );
+
+            SendPhoneEvent (pPhone, PHONE_STATE, PHONESTATE_DISPLAY, 0, 0);
+        }
+        else
+        {
+            pAsyncReqInfo->lResult = PHONEERR_NOMEM;
+        }
+
+        LeaveCriticalSection (&gESPGlobals.PhoneCritSec);
+    }
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    DrvFree (pDisplay);
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwRow,
+    DWORD           dwColumn,
+    LPCWSTR         lpsDisplay,
+    DWORD           dwSize
+    )
+{
+    static char szFuncName[] = "phoneSetDisplay";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdPhone,        hdPhone     },
+        { "dwRow",          dwRow       },
+        { "dwColumn",       dwColumn    },
+        { "lpsDisplay",     lpsDisplay  },
+        { szdwSize,         dwSize      }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        6,
+        params,
+        TSPI_phoneSetDisplay_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (dwRow == 0 &&
+            dwColumn < PHONE_DISPLAY_SIZE_IN_CHARS &&
+            dwSize <= PHONE_DISPLAY_SIZE_IN_BYTES &&
+            (dwColumn * sizeof (WCHAR) + dwSize - sizeof (WCHAR)) <
+                PHONE_DISPLAY_SIZE_IN_BYTES)
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+            info.pAsyncReqInfo->dwParam2 = (DWORD) dwColumn;
+
+            if (dwSize)
+            {
+                info.pAsyncReqInfo->dwParam3 = (DWORD) DrvAlloc (dwSize);
+
+                if (info.pAsyncReqInfo->dwParam3 == 0)
+                {
+                    info.lResult = PHONEERR_NOMEM;
+                    return (Epilog (&info));
+                }
+
+                CopyMemory(
+                    (LPVOID) info.pAsyncReqInfo->dwParam3,
+                    lpsDisplay,
+                    dwSize
+                    );
+            }
+            else
+            {
+                info.pAsyncReqInfo->dwParam3 = 0;
+            }
+
+            info.pAsyncReqInfo->dwParam4 = (DWORD) dwSize;
+
+        }
+        else
+        {
+            info.lResult = PHONEERR_INVALPARAM;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetGain_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD       dwHookSwitchDev = pAsyncReqInfo->dwParam2,
+                    dwGain = pAsyncReqInfo->dwParam3,
+                   *pdwXxxGain, dwPhoneState;
+        PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+        switch (dwHookSwitchDev)
+        {
+        case PHONEHOOKSWITCHDEV_HANDSET:
+
+            pdwXxxGain = &pPhone->dwHandsetGain;
+            dwPhoneState = PHONESTATE_HANDSETGAIN;
+            break;
+
+        case PHONEHOOKSWITCHDEV_SPEAKER:
+
+            pdwXxxGain = &pPhone->dwSpeakerGain;
+            dwPhoneState = PHONESTATE_SPEAKERGAIN;
+            break;
+
+        default: // case PHONEHOOKSWITCHDEV_HEADSET:
+
+            pdwXxxGain = &pPhone->dwHeadsetGain;
+            dwPhoneState = PHONESTATE_HEADSETGAIN;
+            break;
+        }
+
+        if (*pdwXxxGain != dwGain)
+        {
+            *pdwXxxGain = dwGain;
+            SendPhoneEvent (pPhone, PHONE_STATE, dwPhoneState, 0, 0);
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDev,
+    DWORD           dwGain
+    )
+{
+    static char szFuncName[] = "phoneSetGain";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev,    aHookSwitchDevs },
+        { "dwGain",             dwGain          }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_phoneSetGain_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+        info.pAsyncReqInfo->dwParam2 = (DWORD) dwHookSwitchDev;
+        info.pAsyncReqInfo->dwParam3 = (DWORD) dwGain;
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetHookSwitch_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD       dwHookSwitchDevs = pAsyncReqInfo->dwParam2,
+                    dwHookSwitchMode = pAsyncReqInfo->dwParam3,
+                    dwPhoneStates = 0;
+        PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+        if (dwHookSwitchDevs & PHONEHOOKSWITCHDEV_HANDSET &&
+            pPhone->dwHandsetHookSwitchMode != dwHookSwitchMode)
+        {
+            pPhone->dwHandsetHookSwitchMode = dwHookSwitchMode;
+            dwPhoneStates |= PHONESTATE_HANDSETHOOKSWITCH;
+        }
+
+        if (dwHookSwitchDevs & PHONEHOOKSWITCHDEV_SPEAKER &&
+            pPhone->dwSpeakerHookSwitchMode != dwHookSwitchMode)
+        {
+            pPhone->dwSpeakerHookSwitchMode = dwHookSwitchMode;
+            dwPhoneStates |= PHONESTATE_SPEAKERHOOKSWITCH;
+        }
+
+        if (dwHookSwitchDevs & PHONEHOOKSWITCHDEV_HEADSET &&
+            pPhone->dwHeadsetHookSwitchMode != dwHookSwitchMode)
+        {
+            pPhone->dwHeadsetHookSwitchMode = dwHookSwitchMode;
+            dwPhoneStates |= PHONESTATE_HEADSETHOOKSWITCH;
+        }
+
+        if (dwPhoneStates)
+        {
+            SendPhoneEvent(
+                pPhone,
+                PHONE_STATE,
+                dwPhoneStates,
+                dwHookSwitchMode,
+                0
+                );
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDevs,
+    DWORD           dwHookSwitchMode
+    )
+{
+    static char szFuncName[] = "phoneSetHookSwitch";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { szhdPhone,            hdPhone             },
+        { "dwHookSwitchDevs",   dwHookSwitchDevs,   aHookSwitchDevs },
+        { "dwHookSwitchMode",   dwHookSwitchMode,   aHookSwitchModes    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_phoneSetHookSwitch_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+        info.pAsyncReqInfo->dwParam2 = (DWORD) dwHookSwitchDevs;
+        info.pAsyncReqInfo->dwParam3 = (DWORD) dwHookSwitchMode;
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetLamp_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD       dwLampMode = pAsyncReqInfo->dwParam2;
+        PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+        if (pPhone->dwLampMode != dwLampMode)
+        {
+            pPhone->dwLampMode = dwLampMode;
+            SendPhoneEvent (pPhone, PHONE_STATE, PHONESTATE_LAMP, 0, 0);
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwButtonLampID,
+    DWORD           dwLampMode
+    )
+{
+    static char szFuncName[] = "phoneSetLamp";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "dwLampMode",     dwLampMode, aLampModes   }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_phoneSetLamp_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        if (dwButtonLampID == 0)
+        {
+            info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+            info.pAsyncReqInfo->dwParam2 = (DWORD) dwLampMode;
+        }
+        else
+        {
+            info.lResult = PHONEERR_INVALBUTTONLAMPID;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetRing_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD       dwRingMode = pAsyncReqInfo->dwParam2,
+                    dwRingVolume = pAsyncReqInfo->dwParam3,
+                    dwPhoneStates = 0;
+        PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+        if (pPhone->dwRingMode != dwRingMode)
+        {
+            pPhone->dwRingMode = dwRingMode;
+            dwPhoneStates |= PHONESTATE_RINGMODE;
+        }
+
+        if (pPhone->dwRingVolume != dwRingVolume)
+        {
+            pPhone->dwRingVolume = dwRingVolume;
+            dwPhoneStates |= PHONESTATE_RINGVOLUME;
+        }
+
+        if (dwPhoneStates)
+        {
+            SendPhoneEvent(
+                pPhone,
+                PHONE_STATE,
+                dwPhoneStates,
+                0,
+                0
+                );
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwRingMode,
+    DWORD           dwVolume
+    )
+{
+    static char szFuncName[] = "phoneSetRing";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdPhone,        hdPhone     },
+        { "dwRingMode",     dwRingMode  },
+        { "dwVolume",       dwVolume    }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_phoneSetRing_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+        info.pAsyncReqInfo->dwParam2 = (DWORD) dwRingMode;
+        info.pAsyncReqInfo->dwParam3 = (DWORD) dwVolume;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE   hdPhone,
+    DWORD       dwPhoneStates,
+    DWORD       dwButtonModes,
+    DWORD       dwButtonStates
+    )
+{
+    static char szFuncName[] = "phoneSetStatusMessages";
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwPhoneStates",  dwPhoneStates,  aPhoneStates    },
+        { "dwButtonModes",  dwButtonModes,  aButtonModes    },
+        { "dwButtonStates", dwButtonStates, aButtonStates   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+
+
+    if (Prolog (&info))
+    {
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_phoneSetVolume_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        DWORD       dwHookSwitchDev = pAsyncReqInfo->dwParam2,
+                    dwVolume = pAsyncReqInfo->dwParam3,
+                   *pdwXxxVolume, dwPhoneState;
+        PDRVPHONE   pPhone = (PDRVPHONE) pAsyncReqInfo->dwParam1;
+
+
+        switch (dwHookSwitchDev)
+        {
+        case PHONEHOOKSWITCHDEV_HANDSET:
+
+            pdwXxxVolume = &pPhone->dwHandsetVolume;
+            dwPhoneState = PHONESTATE_HANDSETVOLUME;
+            break;
+
+        case PHONEHOOKSWITCHDEV_SPEAKER:
+
+            pdwXxxVolume = &pPhone->dwSpeakerVolume;
+            dwPhoneState = PHONESTATE_SPEAKERVOLUME;
+            break;
+
+        default: // case PHONEHOOKSWITCHDEV_HEADSET:
+
+            pdwXxxVolume = &pPhone->dwHeadsetVolume;
+            dwPhoneState = PHONESTATE_HEADSETVOLUME;
+            break;
+        }
+
+        if (*pdwXxxVolume != dwVolume)
+        {
+            *pdwXxxVolume = dwVolume;
+            SendPhoneEvent (pPhone, PHONE_STATE, dwPhoneState, 0, 0);
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDev,
+    DWORD           dwVolume
+    )
+{
+    static char szFuncName[] = "phoneSetVolume";
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev }, // BUGBUG lookup
+        { "dwVolume",           dwVolume        }
+    };
+    FUNC_INFO info =
+    {
+        szFuncName,
+        ASYNC,
+        4,
+        params,
+        TSPI_phoneSetVolume_postProcess
+    };
+
+
+    if (Prolog (&info))
+    {
+        info.pAsyncReqInfo->dwParam1 = (DWORD) hdPhone;
+        info.pAsyncReqInfo->dwParam2 = (DWORD) dwHookSwitchDev;
+        info.pAsyncReqInfo->dwParam3 = (DWORD) dwVolume;
+    }
+
+    return (Epilog (&info));
+}
+
+
+
+//
+// ------------------------- TSPI_providerXxx funcs ---------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    //
+    // 32-bit TAPI never actually calls this function (the corresponding
+    // TUISPI_ func has taken it's place), but the Telephony control
+    // panel applet does look to see if this function is exported to
+    // determine whether or not the provider is configurable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreateLineDevice(
+    DWORD   dwTempID,
+    DWORD   dwDeviceID
+    )
+{
+    static char szFuncName[] = "providerCreateLineDevice";
+    FUNC_PARAM params[] =
+    {
+        { "dwTempID",   dwTempID    },
+        { szdwDeviceID, dwDeviceID  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+        // BUGBUG TSPI_providerCreateLineDevice: alloc new line
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreatePhoneDevice(
+    DWORD   dwTempID,
+    DWORD   dwDeviceID
+    )
+{
+    static char szFuncName[] = "providerCreatePhoneDevice";
+    FUNC_PARAM params[] =
+    {
+        { "dwTempID",   dwTempID    },
+        { szdwDeviceID, dwDeviceID  }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 2, params };
+
+
+    if (Prolog (&info))
+    {
+        // BUGBUG TSPI_providerCreatePhoneDevice: alloc new phone
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD       dwPermanentProviderID,
+    LPDWORD     lpdwNumLines,
+    LPDWORD     lpdwNumPhones,
+    HPROVIDER   hProvider,
+    LINEEVENT   lpfnLineCreateProc,
+    PHONEEVENT  lpfnPhoneCreateProc
+    )
+{
+    static char szFuncName[] = "providerEnumDevices";
+    FUNC_PARAM params[] =
+    {
+        { szdwPermanentProviderID,  dwPermanentProviderID   },
+        { "lpdwNumLines",           lpdwNumLines            },
+        { "lpdwNumPhones",          lpdwNumPhones           },
+        { "hProvider",              hProvider               },
+        { "lpfnLineCreateProc",     lpfnLineCreateProc      },
+        { "lpfnPhoneCreateProc",    lpfnPhoneCreateProc     }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 6, params };
+
+
+    if (Prolog (&info))
+    {
+        *lpdwNumLines  = gESPGlobals.dwNumLines;
+        *lpdwNumPhones = gESPGlobals.dwNumPhones;
+
+        gESPGlobals.pfnLineEvent  = lpfnLineCreateProc;
+        gESPGlobals.pfnPhoneEvent = lpfnPhoneCreateProc;
+
+        gESPGlobals.hProvider = hProvider;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerFreeDialogInstance(
+    HDRVDIALOGINSTANCE  hdDlgInst
+    )
+{
+    static char szFuncName[] = "providerFreeDialogInstance";
+    FUNC_PARAM params[] =
+    {
+        { "hdDlgInst",  hdDlgInst   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 1, params };
+
+
+    Prolog (&info);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerGenericDialogData(
+    DWORD   dwObjectID,
+    DWORD   dwObjectType,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    static char szFuncName[] = "providerGenericDialogData";
+    FUNC_PARAM params[] =
+    {
+        { "dwObjectID",     dwObjectID      },
+        { "dwObjectType",   dwObjectType    },
+        { "lpszParams",      lpParams       },
+        { "dwSize",         dwSize          }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 4, params };
+
+
+    Prolog (&info);
+
+    lstrcpyA (lpParams, "espDlgData");
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions
+    )
+{
+    static char szFuncName[] = "providerInit";
+    FUNC_PARAM params[] =
+    {
+        { "dwTSPIVersion",          dwTSPIVersion           },
+        { szdwPermanentProviderID,  dwPermanentProviderID   },
+        { "dwLineDeviceIDBase",     dwLineDeviceIDBase      },
+        { "dwPhoneDeviceIDBase",    dwPhoneDeviceIDBase     },
+        { "dwNumLines",             dwNumLines              },
+        { "dwNumPhones",            dwNumPhones             },
+        { "lpfnCompletionProc",     lpfnCompletionProc      }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 7, params };
+    DWORD       i, dwNumTotalEntries;
+    PDRVLINE    pLine;
+    PDRVPHONE   pPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    //
+    //
+    //
+
+    // BUGBUG zero out he approp gESPGlobals stuff
+
+    gESPGlobals.bProviderShutdown = FALSE;
+
+    ZeroMemory (gaParkedCalls, MAX_NUM_PARKED_CALLS * sizeof (PDRVCALL));
+
+
+    //
+    // Alloc a queue for storing async requests for async completion,
+    // and start a thread to service that queue
+    //
+
+//    if (gbDisableUI == FALSE) IF THIS IS UNCOMMENTED MUST MUNGE ERROR CLEANUP
+    {
+        gESPGlobals.dwNumTotalQueueEntries = DEF_NUM_ASYNC_REQUESTS_IN_QUEUE;
+
+        if (!(gESPGlobals.pAsyncRequestQueue = DrvAlloc(
+                gESPGlobals.dwNumTotalQueueEntries * sizeof (DWORD)
+
+                )))
+        {
+            goto TSPI_providerInit_error0;
+        }
+
+        gESPGlobals.pAsyncRequestQueueIn =
+        gESPGlobals.pAsyncRequestQueueOut = gESPGlobals.pAsyncRequestQueue;
+
+        if (!(gESPGlobals.hAsyncEventsPendingEvent = CreateEvent(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                TRUE,   // manual reset
+                FALSE,  // non-signaled
+                NULL    // unnamed
+                )))
+        {
+            goto TSPI_providerInit_error1;
+        }
+
+        if (!(gESPGlobals.hAsyncEventQueueServiceThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,      // def stack size
+                (LPTHREAD_START_ROUTINE) AsyncEventQueueServiceThread,
+                NULL,   // thread param
+                0,      // creation flags
+                &i      // &dwThreadID
+                )))
+        {
+            goto TSPI_providerInit_error2;
+        }
+    }
+
+
+    //
+    // Init sundry globals
+    //
+
+    gESPGlobals.dwPermanentProviderID = dwPermanentProviderID;
+    gESPGlobals.dwLineDeviceIDBase    = dwLineDeviceIDBase;
+    gESPGlobals.dwPhoneDeviceIDBase   = dwPhoneDeviceIDBase;
+    gESPGlobals.dwInitialNumLines     = dwNumLines;
+    gESPGlobals.dwInitialNumPhones    = dwNumPhones;
+    gESPGlobals.pfnCompletion         = lpfnCompletionProc;
+
+    gESPGlobals.hIconLine = LoadIcon(
+        ghInstance,
+        (LPCSTR)MAKEINTRESOURCE(PHONE_ICON) // the id's are reversed
+        );
+
+    gESPGlobals.hIconPhone = LoadIcon(
+        ghInstance,
+        (LPCSTR)MAKEINTRESOURCE(LINE_ICON)
+        );
+
+
+    //
+    // Init the line lookup table & crit sec for accessing call lists
+    //
+
+    dwNumTotalEntries = dwNumLines + DEF_NUM_EXTRA_LOOKUP_ENTRIES - 1;
+
+    if (!(gESPGlobals.pLines = DrvAlloc(
+            sizeof (DRVLINETABLE) + sizeof (DRVLINE) * dwNumTotalEntries
+            )))
+    {
+        goto TSPI_providerInit_error3;
+    }
+
+    gESPGlobals.pLines->dwNumTotalEntries = dwNumTotalEntries;
+    gESPGlobals.pLines->dwNumUsedEntries  = dwNumLines;
+
+    for (
+        i = dwLineDeviceIDBase, pLine = gESPGlobals.pLines->aLines;
+        i < (dwLineDeviceIDBase + dwNumLines);
+        i++, pLine++
+        )
+    {
+        pLine->dwDeviceID = i;
+
+        if (!(pLine->aAddrs = DrvAlloc(
+                sizeof (DRVADDRESS) * gESPGlobals.dwNumAddressesPerLine
+                )))
+        {
+            goto TSPI_providerInit_error4;
+        }
+    }
+
+
+    //
+    // Init the phone lookup table
+    //
+
+    dwNumTotalEntries = dwNumPhones + DEF_NUM_EXTRA_LOOKUP_ENTRIES - 1;
+
+    if (!(gESPGlobals.pPhones = DrvAlloc(
+            sizeof (DRVPHONETABLE) + dwNumTotalEntries * sizeof(DRVPHONE)
+            )))
+    {
+        goto TSPI_providerInit_error4;
+    }
+
+    gESPGlobals.pPhones->dwNumTotalEntries = dwNumTotalEntries;
+    gESPGlobals.pPhones->dwNumUsedEntries  = dwNumPhones;
+
+    for (
+        i = dwPhoneDeviceIDBase, pPhone = gESPGlobals.pPhones->aPhones;
+        i < (dwPhoneDeviceIDBase + dwNumPhones);
+        i++, pPhone++
+        )
+    {
+        pPhone->dwDeviceID = i;
+    }
+
+    if (gbDisableUI == FALSE)
+    {
+        WriteEventBuffer(
+            0,
+            WIDGETTYPE_STARTUP,
+            dwNumLines,
+            dwNumPhones,
+            dwLineDeviceIDBase,
+            dwPhoneDeviceIDBase
+            );
+    }
+
+    goto TSPI_providerInit_return;
+
+
+TSPI_providerInit_error4:
+
+    for (
+        i = dwLineDeviceIDBase, pLine = gESPGlobals.pLines->aLines;
+        i < (dwLineDeviceIDBase + dwNumLines);
+        i++, pLine++
+        )
+    {
+        if (pLine->aAddrs)
+        {
+            DrvFree (pLine->aAddrs);
+        }
+    }
+
+    DrvFree (gESPGlobals.pLines);
+
+TSPI_providerInit_error3:
+
+    gESPGlobals.bProviderShutdown = TRUE;
+
+    while (WaitForSingleObject(
+            gESPGlobals.hAsyncEventQueueServiceThread,
+            0
+            ) != WAIT_OBJECT_0)
+    {
+        SetEvent (gESPGlobals.hAsyncEventsPendingEvent);
+        Sleep (0);
+    }
+
+    CloseHandle (gESPGlobals.hAsyncEventQueueServiceThread);
+
+TSPI_providerInit_error2:
+
+    CloseHandle (gESPGlobals.hAsyncEventsPendingEvent);
+
+TSPI_providerInit_error1:
+
+    DrvFree (gESPGlobals.pAsyncRequestQueue);
+
+TSPI_providerInit_error0:
+
+    info.lResult = LINEERR_NOMEM;
+
+TSPI_providerInit_return:
+
+    return (Epilog (&info)); // BUGBUG TSPI_providerInit: return 0 by default
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    //
+    // 32-bit TAPI never actually calls this function (the corresponding
+    // TUISPI_ func has taken it's place), but the Telephony control
+    // panel applet does look to see if this function is exported to
+    // determine whether or not the provider is installable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    //
+    // 32-bit TAPI never actually calls this function (the corresponding
+    // TUISPI_ func has taken it's place), but the Telephony control
+    // panel applet does look to see if this function is exported to
+    // determine whether or not the provider is removeable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD   dwTSPIVersion,
+    DWORD   dwPermanentProviderID
+    )
+{
+    static char szFuncName[] = "providerShutdown";
+    FUNC_PARAM params[] =
+    {
+        { "dwTSPIVersion",  dwTSPIVersion },
+        { szdwPermanentProviderID,  dwPermanentProviderID   }
+    };
+    FUNC_INFO   info = { szFuncName, SYNC, 2, params };
+    LONG        lResult;
+    DWORD       i;
+
+
+    Prolog (&info);
+
+    DestroyIcon (gESPGlobals.hIconLine);
+    DestroyIcon (gESPGlobals.hIconPhone);
+
+
+    //
+    //
+    //
+
+//    if (gbDisableUI == FALSE)
+//    {
+        gESPGlobals.bProviderShutdown = TRUE;
+
+        while (WaitForSingleObject(
+                gESPGlobals.hAsyncEventQueueServiceThread,
+                0
+                ) != WAIT_OBJECT_0)
+        {
+            SetEvent (gESPGlobals.hAsyncEventsPendingEvent);
+            Sleep (0);
+        }
+
+        CloseHandle (gESPGlobals.hAsyncEventQueueServiceThread);
+        CloseHandle (gESPGlobals.hAsyncEventsPendingEvent);
+
+        DrvFree (gESPGlobals.pAsyncRequestQueue);
+//    }
+
+
+    //
+    // Free the device tables & call list crit sec
+    //
+
+    {
+        PDRVLINETABLE   pTable = gESPGlobals.pLines;
+
+
+        while (pTable)
+        {
+            PDRVLINETABLE   pNextTable = pTable->pNext;
+
+
+            for (i = 0; i < pTable->dwNumUsedEntries; i++)
+            {
+                DrvFree (pTable->aLines[i].aAddrs);
+            }
+
+            DrvFree (pTable);
+            pTable = pNextTable;
+        }
+    }
+
+    {
+        PDRVPHONETABLE  pTable = gESPGlobals.pPhones;
+
+
+        while (pTable)
+        {
+            PDRVPHONE       pPhone = pTable->aPhones;
+            PDRVPHONETABLE  pNextTable = pTable->pNext;
+
+
+            for (i = 0; i < pTable->dwNumUsedEntries; i++, pPhone++)
+            {
+                if (pPhone->pData)
+                {
+                    DrvFree (pPhone->pData);
+                }
+
+                if (pPhone->pButtonInfo)
+                {
+                    DrvFree (pPhone->pButtonInfo);
+                }
+
+                if (pPhone->pDisplay)
+                {
+                    DrvFree (pPhone->pDisplay);
+                }
+            }
+
+            DrvFree (pTable);
+            pTable = pNextTable;
+        }
+    }
+
+
+    //
+    //
+    //
+
+    if (ghPBXThread)
+    {
+        ESPStopPBXThread (0);
+    }
+
+
+    //
+    // Clean up any parked calls
+    //
+
+    for (i = 0; i < MAX_NUM_PARKED_CALLS; i++)
+    {
+        if (gaParkedCalls[i])
+        {
+            if (gaParkedCalls[i]->pSendingFlowspec)
+            {
+                DrvFree (gaParkedCalls[i]->pSendingFlowspec);
+            }
+
+            if (gaParkedCalls[i]->pReceivingFlowspec)
+            {
+                DrvFree (gaParkedCalls[i]->pReceivingFlowspec);
+            }
+
+            if (gaParkedCalls[i]->pCallData)
+            {
+                DrvFree (gaParkedCalls[i]->pCallData);
+            }
+
+            DrvFree (gaParkedCalls[i]);
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerUIIdentify(
+    LPWSTR   lpszUIDLLName
+    )
+{
+    static char szFuncName[] = "providerUIIdentify";
+    FUNC_PARAM params[] =
+    {
+        { "pszUIDLLName",   lpszUIDLLName   }
+    };
+    FUNC_INFO info = { szFuncName, SYNC, 1, params };
+
+
+    Prolog (&info);
+
+    wcscpy (lpszUIDLLName, szESPUIDLL);
+
+    return (Epilog (&info));
+}
+
+#pragma warning (default:4047)
+
+//
+// ------------------------ Private support routines --------------------------
+//
+
+
+BOOL
+PASCAL
+IsValidDrvCall(
+    PDRVCALL    pCall,
+    LPDWORD     pdwCallInstance
+    )
+{
+    try
+    {
+        if (pdwCallInstance)
+        {
+            *pdwCallInstance = pCall->dwCallInstance;
+        }
+
+        if (pCall->dwKey != DRVCALL_KEY)
+        {
+            return FALSE;
+        }
+    }
+    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+
+VOID
+ShowStr(
+    BOOL    bAlertApp,
+    char   *format,
+    ...
+    )
+{
+    char    buf[256];
+    DWORD   dwTotalSize, dwMoveSize, dwMoveSizeWrapped = 0;
+    va_list ap;
+
+
+    if (gbDisableUI == TRUE)
+    {
+        return;
+    }
+
+    va_start(ap, format);
+
+    dwTotalSize = wvsprintf (buf, format, ap);
+    buf[dwTotalSize++] = '\r';
+    buf[dwTotalSize++] = '\n';
+
+    dwMoveSize = dwTotalSize;
+
+    EnterCriticalSection (&gESPGlobals.DebugBufferCritSec);
+
+
+    //
+    // Check to see if there's enough room in the the buffer for the new
+    // data, alloc more if not
+    //
+
+    if (dwMoveSize > (gESPGlobals.dwDebugBufferTotalSize -
+            gESPGlobals.dwDebugBufferUsedSize))
+    {
+        char   *pNewDebugBuffer;
+        DWORD   dwMoveSize2, dwMoveSizeWrapped2;
+
+
+        if (!(pNewDebugBuffer = DrvAlloc(
+                2 * gESPGlobals.dwDebugBufferTotalSize
+                )))
+        {
+            LeaveCriticalSection (&gESPGlobals.DebugBufferCritSec);
+            return;
+        }
+
+        if (gESPGlobals.pDebugBufferIn > gESPGlobals.pDebugBufferOut)
+        {
+            dwMoveSize2 = (DWORD) (gESPGlobals.pDebugBufferIn -
+                gESPGlobals.pDebugBufferOut);
+
+            dwMoveSizeWrapped2 = 0;
+        }
+        else
+        {
+            dwMoveSize2 = (DWORD) ((gESPGlobals.pDebugBuffer +
+                gESPGlobals.dwDebugBufferTotalSize) -
+                gESPGlobals.pDebugBufferOut);
+
+            dwMoveSizeWrapped2 = (DWORD) (gESPGlobals.pDebugBufferIn -
+                gESPGlobals.pDebugBuffer);
+        }
+
+        CopyMemory(
+            pNewDebugBuffer,
+            gESPGlobals.pDebugBufferOut,
+            dwMoveSize2
+            );
+
+        if (dwMoveSizeWrapped2)
+        {
+            CopyMemory(
+                pNewDebugBuffer + dwMoveSize2,
+                gESPGlobals.pDebugBuffer,
+                dwMoveSizeWrapped2
+                );
+        }
+
+        DrvFree (gESPGlobals.pDebugBuffer);
+
+        gESPGlobals.pDebugBufferIn = pNewDebugBuffer + dwMoveSize2 +
+            dwMoveSizeWrapped2;
+
+        gESPGlobals.pDebugBuffer =
+        gESPGlobals.pDebugBufferOut = pNewDebugBuffer;
+
+        gESPGlobals.dwDebugBufferTotalSize *= 2;
+    }
+
+    if (gESPGlobals.pDebugBufferIn >= gESPGlobals.pDebugBufferOut)
+    {
+        DWORD dwFreeSize = gESPGlobals.dwDebugBufferTotalSize -
+                (gESPGlobals.pDebugBufferIn - gESPGlobals.pDebugBuffer);
+
+
+        if (dwMoveSize > dwFreeSize)
+        {
+            dwMoveSizeWrapped = dwMoveSize - dwFreeSize;
+
+            dwMoveSize = dwFreeSize;
+        }
+    }
+
+    CopyMemory (gESPGlobals.pDebugBufferIn, buf, dwMoveSize);
+
+    if (dwMoveSizeWrapped != 0)
+    {
+        CopyMemory(
+            gESPGlobals.pDebugBuffer,
+            buf + dwMoveSize,
+            dwMoveSizeWrapped
+            );
+
+        gESPGlobals.pDebugBufferIn = gESPGlobals.pDebugBuffer +
+            dwMoveSizeWrapped;
+    }
+    else
+    {
+        gESPGlobals.pDebugBufferIn += dwMoveSize;
+    }
+
+    gESPGlobals.dwDebugBufferUsedSize += dwTotalSize;
+
+    LeaveCriticalSection (&gESPGlobals.DebugBufferCritSec);
+
+    if (bAlertApp)
+    {
+        SetEvent (ghDebugOutputEvent);
+    }
+
+    va_end(ap);
+}
+
+
+char far *
+GetFlags(
+    DWORD    dwFlags,
+    PLOOKUP  pLookup
+    )
+{
+    int i;
+    static char buf[256];
+    char far *p = (char far *) NULL;
+
+
+    if (gbDisableUI == TRUE)
+    {
+        return NULL;
+    }
+
+    buf[0] = 0;
+
+    for (i = 0; (dwFlags && (pLookup[i].dwVal != 0xffffffff)); i++)
+    {
+        if (dwFlags & pLookup[i].dwVal)
+        {
+            lstrcatA (buf, pLookup[i].lpszVal);
+            lstrcatA (buf, " ");
+
+            dwFlags = dwFlags & (~pLookup[i].dwVal);
+        }
+    }
+
+    if (buf[0])
+    {
+        if ((p = (char far *) DrvAlloc (lstrlenA (buf) + 1)))
+        {
+            lstrcpyA (p, buf);
+        }
+    }
+
+    return p;
+}
+
+
+void
+ShowLineEvent(
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    if (gESPGlobals.dwDebugOptions & SHOW_EVENT_NOTIFICATIONS)
+    {
+        static DWORD adwLineMsgs[] =
+        {
+            LINE_ADDRESSSTATE,
+            LINE_CALLINFO,
+            LINE_CALLSTATE,
+            LINE_CLOSE,
+            LINE_DEVSPECIFIC,
+            LINE_DEVSPECIFICFEATURE,
+            LINE_GATHERDIGITS,
+            LINE_GENERATE,
+            LINE_LINEDEVSTATE,
+            LINE_MONITORDIGITS,
+            LINE_MONITORMEDIA,
+            LINE_MONITORTONE,
+
+            LINE_CREATE,
+
+            LINE_NEWCALL,
+            LINE_CALLDEVSPECIFIC,
+            LINE_CALLDEVSPECIFICFEATURE,
+
+            LINE_REMOVE,
+
+            0xffffffff
+        };
+
+        static char *aszLineMsgs[] =
+        {
+            "LINE_ADDRESSSTATE",
+            "LINE_CALLINFO",
+            "LINE_CALLSTATE",
+            "LINE_CLOSE",
+            "LINE_DEVSPECIFIC",
+            "LINE_DEVSPECIFICFEATURE",
+            "LINE_GATHERDIGITS",
+            "LINE_GENERATE",
+            "LINE_LINEDEVSTATE",
+            "LINE_MONITORDIGITS",
+            "LINE_MONITORMEDIA",
+            "LINE_MONITORTONE",
+
+            "LINE_CREATE",
+
+            "LINE_NEWCALL",
+            "LINE_CALLDEVSPECIFIC",
+            "LINE_CALLDEVSPECIFICFEATURE",
+
+            "LINE_REMOVE"
+        };
+
+        int       i;
+        char far *lpszParam1 = (char far *) NULL;
+        char far *lpszParam2 = (char far *) NULL;
+        char far *lpszParam3 = (char far *) NULL;
+
+
+        for (i = 0; adwLineMsgs[i] != 0xffffffff; i++)
+        {
+            if (dwMsg == adwLineMsgs[i])
+            {
+                ShowStr(
+                    FALSE,
+                    "%ssent %s : htLine=x%x, htCall=x%x",
+                    szCallUp,
+                    aszLineMsgs[i],
+                    htLine,
+                    htCall
+                    );
+
+                break;
+            }
+        }
+
+        if (adwLineMsgs[i] == 0xffffffff)
+        {
+            ShowStr(
+                FALSE,
+                "%ssent <unknown msg id, x%x> : htLine=x%x, htCall=x%x",
+                szCallUp,
+                dwMsg,
+                htLine,
+                htCall
+                );
+        }
+
+        switch (dwMsg)
+        {
+        case LINE_ADDRESSSTATE:
+
+            lpszParam2 = GetFlags (dwParam2, aAddressStates);
+            break;
+
+        case LINE_CALLINFO:
+
+            lpszParam1 = GetFlags (dwParam1, aCallInfoStates);
+            break;
+
+        case LINE_CALLSTATE:
+
+            lpszParam1 = GetFlags (dwParam1, aCallStates);
+            break;
+
+        case LINE_LINEDEVSTATE:
+
+            lpszParam1 = GetFlags (dwParam1, aLineStates);
+            break;
+
+        } // switch
+
+        ShowStr(
+            FALSE,
+            "%s%sdwParam1=x%x, %s",
+            szCallUp,
+            szTab,
+            dwParam1,
+            (lpszParam1 ? lpszParam1 : "")
+            );
+
+        ShowStr(
+            FALSE,
+            "%s%sdwParam2=x%x, %s",
+            szCallUp,
+            szTab,
+            dwParam2,
+            (lpszParam2 ? lpszParam2 : "")
+            );
+
+        ShowStr(
+            TRUE,
+            "%s%sdwParam3=x%x, %s",
+            szCallUp,
+            szTab,
+            dwParam3,
+            (lpszParam3 ? lpszParam3 : "")
+            );
+
+        if (lpszParam1)
+        {
+            DrvFree (lpszParam1);
+        }
+
+        if (lpszParam2)
+        {
+            DrvFree (lpszParam2);
+        }
+
+        if (lpszParam3)
+        {
+            DrvFree (lpszParam3);
+        }
+    }
+}
+
+
+void
+ShowPhoneEvent(
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    if (gESPGlobals.dwDebugOptions & SHOW_EVENT_NOTIFICATIONS)
+    {
+        static DWORD adwPhoneMsgs[] =
+        {
+            PHONE_BUTTON,
+            PHONE_CLOSE,
+            PHONE_DEVSPECIFIC,
+            PHONE_STATE,
+            PHONE_CREATE,
+            PHONE_REMOVE,
+            0xffffffff
+        };
+
+        static char *aszPhoneMsgs[] =
+        {
+            "PHONE_BUTTON",
+            "PHONE_CLOSE",
+            "PHONE_DEVSPECIFIC",
+            "PHONE_STATE",
+            "PHONE_CREATE",
+            "PHONE_REMOVE"
+        };
+        char far *lpszParam1 = (char far *) NULL;
+        char far *lpszParam2 = (char far *) NULL;
+        char far *lpszParam3 = (char far *) NULL;
+        DWORD   i;
+
+
+        for (i = 0; adwPhoneMsgs[i] != 0xffffffff; i++)
+        {
+            if (dwMsg == adwPhoneMsgs[i])
+            {
+                ShowStr(
+                    FALSE,
+                    "%ssent %s : htPhone=x%x",
+                    szCallUp,
+                    aszPhoneMsgs[i],
+                    htPhone
+                    );
+
+                break;
+            }
+        }
+
+        if (adwPhoneMsgs[i] == 0xffffffff)
+        {
+            ShowStr(
+                FALSE,
+                "%ssent <unknown msg id, x%x> : htPhone=x%x",
+                szCallUp,
+                dwMsg,
+                htPhone
+                );
+        }
+
+        switch (dwMsg)
+        {
+        case PHONE_BUTTON:
+
+            lpszParam2 = GetFlags (dwParam2, aButtonModes);
+            lpszParam3 = GetFlags (dwParam3, aButtonStates);
+            break;
+
+        case PHONE_STATE:
+
+            lpszParam1 = GetFlags (dwParam1, aPhoneStates);
+            break;
+
+        } // switch
+
+        ShowStr(
+            FALSE,
+            "%s%sdwParam1=x%x, %s",
+            szCallUp,
+            szTab,
+            dwParam1,
+            (lpszParam1 ? lpszParam1 : "")
+            );
+
+        ShowStr(
+            FALSE,
+            "%s%sdwParam2=x%x, %s",
+            szCallUp,
+            szTab,
+            dwParam2,
+            (lpszParam2 ? lpszParam2 : "")
+            );
+
+        ShowStr(
+            TRUE,
+            "%s%sdwParam3=x%x, %s",
+            szCallUp,
+            szTab,
+            dwParam3,
+            (lpszParam3 ? lpszParam3 : "")
+            );
+
+        if (lpszParam1)
+        {
+            DrvFree (lpszParam1);
+        }
+
+        if (lpszParam2)
+        {
+            DrvFree (lpszParam2);
+        }
+
+        if (lpszParam3)
+        {
+            DrvFree (lpszParam3);
+        }
+    }
+}
+
+
+BOOL
+Prolog(
+    PFUNC_INFO pInfo
+    )
+{
+    BOOL  bLineFunc = (pInfo->pszFuncName[1] != 'h');
+    DWORD i, j;
+
+
+    if (gESPGlobals.dwDebugOptions & SHOW_FUNC_ENTRY)
+    {
+        ShowStr (FALSE, "TSPI_%s: enter", pInfo->pszFuncName);
+    }
+
+    if (gESPGlobals.dwDebugOptions & SHOW_PARAMETERS)
+    {
+        for (i = 0; i < pInfo->dwNumParams; i++)
+        {
+            if (pInfo->aParams[i].dwVal &&
+                pInfo->aParams[i].lpszVal[3] == 'z') // "lpszXxx"
+            {
+                ShowStr(
+                    FALSE,
+                    "%s%s=x%x, '%ws'",
+                    szTab,
+                    pInfo->aParams[i].lpszVal,
+                    pInfo->aParams[i].dwVal,
+                    pInfo->aParams[i].dwVal
+                    );
+            }
+            else if (pInfo->aParams[i].pLookup)
+            {
+                char buf[90];
+                PLOOKUP pLookup = pInfo->aParams[i].pLookup;
+
+
+                wsprintf(
+                    buf,
+                    "%s%s=x%x, ",
+                    szTab,
+                    pInfo->aParams[i].lpszVal,
+                    pInfo->aParams[i].dwVal
+                    );
+
+                for (j = 0; pLookup[j].dwVal != 0xffffffff; j++)
+                {
+                    if (pInfo->aParams[i].dwVal & pLookup[j].dwVal)
+                    {
+                        lstrcatA (buf, pLookup[j].lpszVal);
+                        lstrcatA (buf, " ");
+
+                        if (lstrlenA (buf) > 60)
+                        {
+                            ShowStr (FALSE, buf);
+                            wsprintfA (buf, "%s%s", szTab, szTab);
+                        }
+                    }
+                }
+
+                ShowStr (FALSE, buf);
+            }
+            else
+            {
+                ShowStr(
+                    FALSE,
+                    "%s%s=x%x",
+                    szTab,
+                    pInfo->aParams[i].lpszVal,
+                    pInfo->aParams[i].dwVal
+                    );
+            }
+        }
+    }
+
+    if (gESPGlobals.dwDebugOptions & (SHOW_PARAMETERS | SHOW_FUNC_ENTRY))
+    {
+        SetEvent (ghDebugOutputEvent);
+    }
+
+
+    //
+    //
+    //
+
+    if (gdwDevSpecificRequestID  &&
+         glNextRequestResult != 0  &&
+         (pInfo->bAsync == FALSE  ||
+             gdwNextRequestCompletionType == ESP_RESULT_RETURNRESULT)
+         )
+    {
+        gdwDevSpecificRequestID = 0;
+        pInfo->lResult = glNextRequestResult;
+        return FALSE;
+    }
+
+
+    if (gESPGlobals.dwDebugOptions & MANUAL_RESULTS)
+    {
+        char szDlgTitle[64];
+        EVENT_PARAM params[] =
+        {
+            { "lResult", PT_ORDINAL, 0, (bLineFunc ? aLineErrs : aPhoneErrs) }
+        };
+        EVENT_PARAM_HEADER paramsHeader =
+            { 1, szDlgTitle, 0, params };
+        HWND hwnd;
+
+
+        wsprintf (szDlgTitle, "TSPI_%s request result", pInfo->pszFuncName);
+
+        DialogBoxParam(
+            ghInstance,
+            (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG1),
+            (HWND) NULL,
+            (DLGPROC) ValuesDlgProc,
+            (LPARAM) &paramsHeader
+            );
+
+
+        //
+        // If user selected to synchronously return an error we'll save
+        // the error & return FALSE to indicate to caller that it should
+        // return immediately.
+        //
+
+        if (params[0].dwValue)
+        {
+            pInfo->lResult = (LONG) params[0].dwValue;
+
+            return FALSE;
+        }
+    }
+
+
+    if (pInfo->bAsync)
+    {
+        //
+        // Alloc & init an async request info structure
+        //
+
+        PASYNC_REQUEST_INFO pAsyncReqInfo = (PASYNC_REQUEST_INFO)
+            DrvAlloc (sizeof(ASYNC_REQUEST_INFO));
+
+
+        if ((pInfo->pAsyncReqInfo = pAsyncReqInfo))
+        {
+            pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+                pInfo->pfnPostProcessProc;
+            pAsyncReqInfo->dwRequestID        = pInfo->aParams[0].dwVal;
+
+            pAsyncReqInfo->pszFuncName = pInfo->pszFuncName;
+        }
+        else
+        {
+            pInfo->lResult = (bLineFunc ?
+                LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+LONG
+Epilog(
+    PFUNC_INFO pInfo
+    )
+{
+    if (pInfo->bAsync)
+    {
+        PASYNC_REQUEST_INFO pAsyncReqInfo = pInfo->pAsyncReqInfo;
+
+
+        if (pInfo->lResult == 0)
+        {
+            //
+            //
+            //
+
+            if (gdwDevSpecificRequestID  &&
+                pInfo->aParams[0].dwVal != gdwDevSpecificRequestID)
+            {
+                gdwDevSpecificRequestID = 0;
+
+                if (glNextRequestResult != 0)
+                {
+                    pAsyncReqInfo->lResult = glNextRequestResult;
+                }
+
+                if (gdwNextRequestCompletionType ==
+                        ESP_RESULT_CALLCOMPLPROCASYNC)
+                {
+                    goto complete_event_async;
+                }
+                else
+                {
+                    goto complete_event_sync;
+                }
+            }
+
+            switch (gESPGlobals.dwCompletionMode)
+            {
+            case COMPLETE_ASYNC_EVENTS_SYNCHRONOUSLY:
+
+                //
+                // We're completing this async request synchronously, so call
+                // the post processing proc (if there is one) or call the
+                // completion routine directly
+                //
+
+complete_event_sync:
+
+                if (pInfo->pAsyncReqInfo->pfnPostProcessProc)
+                {
+                    (*((POSTPROCESSPROC) pAsyncReqInfo->pfnPostProcessProc))(
+                        pInfo->pAsyncReqInfo,
+                        SYNC
+                        );
+                }
+                else
+                {
+                    DoCompletion (pAsyncReqInfo, SYNC);
+                }
+
+                DrvFree (pAsyncReqInfo);
+
+                break;
+
+            case COMPLETE_ASYNC_EVENTS_ASYNCHRONOUSLY:
+
+                //
+                // Safely add the async request to the queue (careful to
+                // reset pDataIn when we reach the end of the buffer)
+                //
+
+complete_event_async:
+
+                EnterCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+
+                if (gESPGlobals.dwNumUsedQueueEntries ==
+                        gESPGlobals.dwNumTotalQueueEntries)
+                {
+                    //
+                    // We've max'd out our ring buf, so try to grow it
+                    //
+
+                    DWORD  *pNewAsyncRequestQueue, dwMoveSize;
+
+
+                    if (!(pNewAsyncRequestQueue = DrvAlloc(
+                            2 * gESPGlobals.dwNumTotalQueueEntries *
+                            sizeof (DWORD)
+                            )))
+                    {
+                        LeaveCriticalSection(
+                            &gESPGlobals.AsyncEventQueueCritSec
+                            );
+
+                        goto complete_event_sync;
+                    }
+
+                    dwMoveSize = ((gESPGlobals.pAsyncRequestQueue +
+                        gESPGlobals.dwNumTotalQueueEntries) -
+                        gESPGlobals.pAsyncRequestQueueOut) * sizeof (DWORD);
+
+                    CopyMemory(
+                        pNewAsyncRequestQueue,
+                        gESPGlobals.pAsyncRequestQueueOut,
+                        dwMoveSize
+                        );
+
+                    CopyMemory(
+                        ((LPBYTE) pNewAsyncRequestQueue) + dwMoveSize,
+                        gESPGlobals.pAsyncRequestQueue,
+                        (gESPGlobals.pAsyncRequestQueueOut -
+                            gESPGlobals.pAsyncRequestQueue) * sizeof (DWORD)
+                        );
+
+                    DrvFree (gESPGlobals.pAsyncRequestQueue);
+
+                    gESPGlobals.pAsyncRequestQueue    =
+                    gESPGlobals.pAsyncRequestQueueOut = pNewAsyncRequestQueue;
+
+                    gESPGlobals.pAsyncRequestQueueIn = pNewAsyncRequestQueue +
+                        gESPGlobals.dwNumTotalQueueEntries;
+
+                    gESPGlobals.dwNumTotalQueueEntries *= 2;
+                }
+
+                *(gESPGlobals.pAsyncRequestQueueIn) = (DWORD) pAsyncReqInfo;
+
+                gESPGlobals.pAsyncRequestQueueIn++;
+
+                if (gESPGlobals.pAsyncRequestQueueIn ==
+                        (gESPGlobals.pAsyncRequestQueue +
+                            gESPGlobals.dwNumTotalQueueEntries))
+                {
+                    gESPGlobals.pAsyncRequestQueueIn =
+                        gESPGlobals.pAsyncRequestQueue;
+                }
+
+                gESPGlobals.dwNumUsedQueueEntries++;
+
+                if (gESPGlobals.dwNumUsedQueueEntries == 1)
+                {
+                    SetEvent (gESPGlobals.hAsyncEventsPendingEvent);
+                }
+
+                LeaveCriticalSection (&gESPGlobals.AsyncEventQueueCritSec);
+
+                break;
+
+            case COMPLETE_ASYNC_EVENTS_SYNC_AND_ASYNC:
+            {
+                //
+                // Decide whether to complete this request sync or async,
+                // then jump to the right place
+                //
+
+                static i = 0;
+
+
+                if (i++ % 2)
+                {
+                    goto complete_event_sync;
+                }
+                else
+                {
+                    goto complete_event_async;
+                }
+
+                break;
+            }
+            case COMPLETE_ASYNC_EVENTS_MANUALLY:
+
+                WriteEventBuffer(
+                    (DWORD) pAsyncReqInfo->dwRequestID,
+                    WIDGETTYPE_ASYNCREQUEST,
+                    (DWORD) pAsyncReqInfo,
+                    0,
+                    0,
+                    0
+                    );
+
+                break;
+            }
+
+
+            //
+            // Finally, return the request ID
+            //
+
+            pInfo->lResult = pInfo->aParams[0].dwVal;
+        }
+        else if (pAsyncReqInfo)
+        {
+            DrvFree (pAsyncReqInfo);
+        }
+    }
+
+    if (gESPGlobals.dwDebugOptions & SHOW_FUNC_EXIT)
+    {
+        ShowStr(
+            TRUE,
+            "TSPI_%s: exit, returning x%x",
+            pInfo->pszFuncName,
+            pInfo->lResult
+            );
+    }
+
+    return (pInfo->lResult);
+}
+
+
+void
+PASCAL
+SendLineEvent(
+    PDRVLINE    pLine,
+    PDRVCALL    pCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    //
+    //
+    //
+
+    (*(gESPGlobals.pfnLineEvent))(
+        pLine->htLine,
+        (pCall ? pCall->htCall : (HTAPICALL) NULL),
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+
+    if (dwMsg == LINE_CALLSTATE)
+    {
+        //PostUpdateWidgetListMsg();
+    }
+
+    ShowLineEvent(
+        pLine->htLine,
+        (pCall ? pCall->htCall : (HTAPICALL) NULL),
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+}
+
+
+void
+PASCAL
+SendPhoneEvent(
+    PDRVPHONE   pPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    //
+    //
+    //
+
+    (*(gESPGlobals.pfnPhoneEvent))(
+        pPhone->htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+
+    ShowPhoneEvent(
+        pPhone->htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+}
+
+
+void
+PASCAL
+DoCompletion(
+    PASYNC_REQUEST_INFO pAsyncRequestInfo,
+    BOOL                bAsync
+    )
+{
+    (*(gESPGlobals.pfnCompletion))(
+        pAsyncRequestInfo->dwRequestID,
+        pAsyncRequestInfo->lResult
+        );
+
+    if (gESPGlobals.dwDebugOptions & SHOW_COMPLETION_NOTIFICATIONS)
+    {
+        ShowStr(
+            TRUE,
+            "%sTSPI_%s: calling compl proc (%ssync), dwReqID=x%x, lResult = x%x",
+            szCallUp,
+            pAsyncRequestInfo->pszFuncName,
+            (bAsync ? "a" : ""),
+            pAsyncRequestInfo->dwRequestID,
+            pAsyncRequestInfo->lResult
+            );
+    }
+}
+
+
+LONG
+PASCAL
+SetCallState(
+    PDRVCALL pCall,
+    DWORD    dwExpectedCallInstance,
+    DWORD    dwValidCurrentStates,
+    DWORD    dwNewCallState,
+    DWORD    dwNewCallStateMode,
+    BOOL     bSendStateMsgToExe
+    )
+{
+    LONG    lResult = 0;
+    DWORD   dwActualCallInstance;
+
+
+    EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (!IsValidDrvCall (pCall, &dwActualCallInstance)  ||
+        dwActualCallInstance != dwExpectedCallInstance)
+    {
+        LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+    if (lResult == 0)
+    {
+        //
+        // Check to see that the call is in a valid (expected) state.
+        // If dwValidCurrentStates == 0xffffffff then we want to chg the
+        // state regardless of the current state.
+        //
+
+        if ((dwValidCurrentStates != 0xffffffff) &&
+            !(dwValidCurrentStates & pCall->dwCallState))
+        {
+            LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+            return LINEERR_INVALCALLSTATE;
+        }
+
+
+        //
+        // Only chg the call state if it differs from the existing one
+        //
+
+        if (dwNewCallState != pCall->dwCallState)
+        {
+            pCall->dwCallState     = dwNewCallState;
+            pCall->dwCallStateMode = dwNewCallStateMode;
+
+            SendLineEvent(
+                pCall->pLine,
+                pCall,
+                LINE_CALLSTATE,
+                dwNewCallState,
+                dwNewCallStateMode,
+                pCall->dwMediaMode
+                );
+
+            if (bSendStateMsgToExe)
+            {
+                WriteEventBuffer(
+                    ((PDRVLINE) pCall->pLine)->dwDeviceID,
+                    WIDGETTYPE_CALL,
+                    (DWORD) pCall,
+                    (DWORD) pCall->htCall,
+                    dwNewCallState,
+                    pCall->dwAddressID
+                    );
+            }
+
+
+            //
+            // If this call has an associated call/endpoint then pass
+            // connected (1st time only) or disconnected msgs to that
+            // call so they know if we've answered or hung up
+            //
+
+            if (pCall->pDestCall)
+            {
+                if (dwNewCallState == LINECALLSTATE_CONNECTED)
+                {
+                    if (!pCall->bConnectedToDestCall)
+                    {
+                        if (IsValidDrvCall (pCall->pDestCall, NULL))
+                        {
+                            if (SetCallState(
+                                    pCall->pDestCall,
+                                    pCall->pDestCall->dwCallInstance,
+                                    0xffffffff,
+                                    LINECALLSTATE_CONNECTED,
+                                    0,
+                                    TRUE
+
+                                    ) == 0)
+                            {
+                                // NOTE: use 0x55 to aid in debugging
+                                //       wild writes
+
+                                pCall->bConnectedToDestCall =
+                                pCall->pDestCall->bConnectedToDestCall = 0x55;
+                            }
+                        }
+                        else
+                        {
+                            pCall->pDestCall = NULL;
+                        }
+                    }
+                }
+                else if (dwNewCallState == LINECALLSTATE_IDLE ||
+                         dwNewCallState == LINECALLSTATE_DISCONNECTED)
+                {
+                    pCall->pDestCall->pDestCall = NULL;
+
+                    SetCallState(
+                        pCall->pDestCall,
+                        pCall->pDestCall->dwCallInstance,
+                        0xffffffff,
+                        LINECALLSTATE_DISCONNECTED,
+                        (dwNewCallState == LINECALLSTATE_DISCONNECTED ?
+                            dwNewCallStateMode : LINEDISCONNECTMODE_NORMAL),
+                        TRUE
+                        );
+
+                    pCall->pDestCall = NULL;
+                }
+            }
+        }
+    }
+
+    LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+    return lResult;
+}
+
+
+void
+PASCAL
+WriteEventBuffer(
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3,
+    DWORD   dwParam4,
+    DWORD   dwParam5,
+    DWORD   dwParam6
+    )
+{
+    WIDGETEVENT event ={dwParam1,dwParam2,dwParam3,dwParam4,dwParam5,dwParam6};
+
+
+    if (gbDisableUI == TRUE)
+    {
+        return;
+    }
+
+    EnterCriticalSection (&gESPGlobals.EventBufferCritSec);
+
+    if ((gESPGlobals.dwEventBufferUsedSize + sizeof (WIDGETEVENT)) >
+            gESPGlobals.dwEventBufferTotalSize)
+    {
+        //
+        // We've max'd out our ring buf, so try to grow it
+        //
+
+        char   *pNewEventBuffer;
+        DWORD   dwMoveSize;
+
+
+        if (!(pNewEventBuffer = DrvAlloc (
+                2 * gESPGlobals.dwEventBufferTotalSize
+                )))
+        {
+            LeaveCriticalSection (&gESPGlobals.EventBufferCritSec);
+
+            // log some sort of error
+
+            return;
+        }
+
+        dwMoveSize = (gESPGlobals.pEventBuffer +
+            gESPGlobals.dwEventBufferTotalSize) - gESPGlobals.pEventBufferOut;
+
+        CopyMemory (pNewEventBuffer, gESPGlobals.pEventBufferOut, dwMoveSize);
+
+        CopyMemory(
+            pNewEventBuffer + dwMoveSize,
+            gESPGlobals.pEventBuffer,
+            gESPGlobals.pEventBufferOut - gESPGlobals.pEventBuffer
+            );
+
+        DrvFree (gESPGlobals.pEventBuffer);
+
+        gESPGlobals.pEventBuffer    =
+        gESPGlobals.pEventBufferOut = pNewEventBuffer;
+
+        gESPGlobals.pEventBufferIn = pNewEventBuffer +
+            gESPGlobals.dwEventBufferTotalSize;
+
+        gESPGlobals.dwEventBufferTotalSize *= 2;
+    }
+
+    CopyMemory (gESPGlobals.pEventBufferIn, &event, sizeof (WIDGETEVENT));
+
+    gESPGlobals.dwEventBufferUsedSize += sizeof (WIDGETEVENT);
+
+    if ((gESPGlobals.pEventBufferIn +=  sizeof (WIDGETEVENT)) >=
+            (gESPGlobals.pEventBuffer + gESPGlobals.dwEventBufferTotalSize))
+    {
+         gESPGlobals.pEventBufferIn = gESPGlobals.pEventBuffer;
+    }
+
+    SetEvent (ghWidgetEventsEvent);
+
+    LeaveCriticalSection (&gESPGlobals.EventBufferCritSec);
+}
+
+
+LPVOID
+DrvAlloc(
+    size_t numBytes
+    )
+{
+    LPVOID p = (LPVOID) LocalAlloc (LPTR, numBytes);
+
+
+    if (!p)
+    {
+        ShowStr (TRUE, "Error: DrvAlloc (x%x) failed", (DWORD) numBytes);
+    }
+
+    return p;
+}
+
+
+void
+DrvFree(
+    LPVOID  p
+    )
+{
+    if (p)
+    {
+#if DBG
+        //
+        // Fill the buf to free with 0xa5's to facilitate debugging
+        //
+
+        FillMemory (p, LocalSize (LocalHandle (p)), 0xa5);
+#endif
+        LocalFree (p);
+    }
+}
+
+
+PDRVADDRESS
+PASCAL
+FindFreeAddress(
+    PDRVLINE    pLine
+    )
+{
+    DWORD       i;
+    PDRVADDRESS pAddr = pLine->aAddrs;
+
+
+    for (i = 0; i < gESPGlobals.dwNumAddressesPerLine; i++)
+    {
+        if (pAddr->dwNumCalls < gESPGlobals.dwNumCallsPerAddress)
+        {
+            return pAddr;
+        }
+
+        pAddr++;
+    }
+
+    return NULL;
+}
+
+
+LONG
+PASCAL
+AllocCall(
+    PDRVLINE            pLine,
+    HTAPICALL           htCall,
+    LPLINECALLPARAMS    pCallParams,
+    PDRVCALL           *ppCall
+    )
+{
+    LONG        lResult = 0;
+    DWORD       i;
+    PDRVCALL    pCall;
+    PDRVADDRESS pAddr;
+
+
+    if (!(pCall = (PDRVCALL) DrvAlloc (sizeof (DRVCALL))))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    pCall->pLine = pLine;
+    pCall->htCall = htCall;
+
+
+    EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (!pCallParams)
+    {
+        if (!(pAddr = FindFreeAddress (pLine)))
+        {
+            lResult = LINEERR_CALLUNAVAIL;
+            goto AllocCall_cleanup;
+        }
+
+        pCall->dwMediaMode  = LINEMEDIAMODE_INTERACTIVEVOICE;
+        pCall->dwBearerMode = LINEBEARERMODE_VOICE;
+    }
+    else
+    {
+
+AllocCall_findTheAddr:
+
+        if (pCallParams->dwAddressMode == LINEADDRESSMODE_ADDRESSID)
+        {
+            if (pCallParams->dwAddressID >= gESPGlobals.dwNumAddressesPerLine)
+            {
+                lResult = LINEERR_INVALADDRESSID;
+                goto AllocCall_cleanup;
+            }
+
+            if (pCallParams->dwAddressID == 0)
+            {
+                //
+                // App doesn't care which addr to make call on
+                //
+
+                if (!(pAddr = FindFreeAddress (pLine)))
+                {
+                    lResult = LINEERR_CALLUNAVAIL;
+                    goto AllocCall_cleanup;
+                }
+            }
+            else
+            {
+                //
+                // App wants call on a particular addr
+                //
+
+                pAddr = pLine->aAddrs + pCallParams->dwAddressID;
+
+                if (pAddr->dwNumCalls > gESPGlobals.dwNumCallsPerAddress)
+                {
+                    lResult = LINEERR_CALLUNAVAIL;
+                    goto AllocCall_cleanup;
+                }
+            }
+        }
+        else // (pCallParams->dwAddressMode == LINEADDRESSMODE_DIALABLEADDR)
+        {
+
+// BUGBUG AllocCall: handle dialable addr
+
+            pCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+            pCallParams->dwAddressID = 0;
+            goto AllocCall_findTheAddr;
+        }
+
+        pCall->dwMediaMode  = pCallParams->dwMediaMode;
+        pCall->dwBearerMode = pCallParams->dwBearerMode;
+    }
+
+
+    //
+    // Call was successfully "made", so do all the common stuff like
+    // adding it to the addr's list, setting the attributes, etc...
+    //
+
+    if ((pCall->pNext = pAddr->pCalls))
+    {
+        pCall->pNext->pPrev = pCall;
+    }
+
+    pAddr->pCalls = pCall;
+
+    pAddr->dwNumCalls++;
+
+    pCall->dwKey          = DRVCALL_KEY;
+    pCall->pLine          = pLine;
+    pCall->dwAddressID    = pAddr - pLine->aAddrs;
+    pCall->dwCallInstance = gdwCallInstance++;
+    pCall->dwCallID       = gdwCallID++;
+
+
+AllocCall_cleanup:
+
+    LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (lResult == 0)
+    {
+        *ppCall = pCall;
+    }
+    else
+    {
+        DrvFree (pCall);
+    }
+
+    return lResult;
+}
+
+
+void
+PASCAL
+FreeCall(
+    PDRVCALL    pCall,
+    DWORD       dwExpectedCallInstance
+    )
+{
+    DWORD   dwActualCallInstance;
+
+
+    EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (IsValidDrvCall (pCall, &dwActualCallInstance)  &&
+        dwActualCallInstance == dwExpectedCallInstance)
+    {
+        PDRVADDRESS pAddr;
+
+
+        pCall->dwKey = INVAL_KEY;
+
+        pAddr = ((PDRVLINE) pCall->pLine)->aAddrs + pCall->dwAddressID;
+        if (pCall->pNext)
+        {
+            pCall->pNext->pPrev = pCall->pPrev;
+        }
+
+        if (pCall->pPrev)
+        {
+            pCall->pPrev->pNext = pCall->pNext;
+        }
+        else
+        {
+            pAddr->pCalls = pCall->pNext;
+        }
+
+        if (pCall->pDestCall)
+        {
+            pCall->pDestCall->pDestCall = NULL;
+        }
+
+        pAddr->dwNumCalls--;
+    }
+    else
+    {
+        pCall = NULL;
+    }
+
+    LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (pCall)
+    {
+        if (pCall->pSendingFlowspec)
+        {
+            DrvFree (pCall->pSendingFlowspec);
+        }
+
+        if (pCall->pReceivingFlowspec)
+        {
+            DrvFree (pCall->pReceivingFlowspec);
+        }
+
+        if (pCall->pCallData)
+        {
+            DrvFree (pCall->pCallData);
+        }
+
+        if (pCall->dwGatherDigitsEndToEndID)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                ((PDRVLINE) pCall->pLine)->htLine,
+                pCall->htCall,
+                LINE_GATHERDIGITS,
+                LINEGATHERTERM_CANCEL,
+                pCall->dwGatherDigitsEndToEndID,
+                0
+                );
+        }
+
+        if (pCall->dwGenerateDigitsEndToEndID)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                ((PDRVLINE) pCall->pLine)->htLine,
+                pCall->htCall,
+                LINE_GENERATE,
+                LINEGENERATETERM_CANCEL,
+                pCall->dwGenerateDigitsEndToEndID,
+                0
+                );
+        }
+
+        if (pCall->dwGenerateToneEndToEndID)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                ((PDRVLINE) pCall->pLine)->htLine,
+                pCall->htCall,
+                LINE_GENERATE,
+                LINEGENERATETERM_CANCEL,
+                pCall->dwGenerateToneEndToEndID,
+                0
+                );
+        }
+
+        if (pCall->dwMonitorToneListID)
+        {
+            (gESPGlobals.pfnLineEvent)(
+                ((PDRVLINE) pCall->pLine)->htLine,
+                pCall->htCall,
+                LINE_MONITORTONE,
+                0,
+                pCall->dwMonitorToneListID,
+                0
+                );
+        }
+
+        DrvFree (pCall);
+    }
+}
+
+
+PDRVLINE
+PASCAL
+GetLineFromID(
+    DWORD   dwDeviceID
+    )
+{
+    PDRVLINE    pLine;
+
+
+    if (dwDeviceID < gESPGlobals.dwLineDeviceIDBase)
+    {
+        pLine = (PDRVLINE) NULL;
+    }
+    else if (dwDeviceID < (gESPGlobals.dwLineDeviceIDBase +
+                gESPGlobals.dwInitialNumLines))
+    {
+        pLine = gESPGlobals.pLines->aLines +
+            (dwDeviceID - gESPGlobals.dwLineDeviceIDBase);
+    }
+    else
+    {
+        // BUGBUG GetLineFromID: find a line created on the fly
+        pLine = (PDRVLINE) NULL;
+    }
+
+    return pLine;
+}
+
+
+PDRVPHONE
+PASCAL
+GetPhoneFromID(
+    DWORD   dwDeviceID
+    )
+{
+    PDRVPHONE   pPhone;
+
+
+    if (dwDeviceID < (gESPGlobals.dwPhoneDeviceIDBase +
+            gESPGlobals.dwInitialNumPhones))
+    {
+        pPhone = gESPGlobals.pPhones->aPhones +
+            (dwDeviceID - gESPGlobals.dwPhoneDeviceIDBase);
+    }
+    else
+    {
+        // BUGBUG GetPhoneFromID: find a phone created on the fly
+        pPhone = (PDRVPHONE) NULL;
+    }
+
+    return pPhone;
+}
+
+
+long
+ESPAttach(
+    long    lProcessID,
+    long   *phShutdownEvent,
+    long   *phDebugOutputEvent,
+    long   *phWidgetEventsEvent
+    )
+{
+    HANDLE hMyProcess, hEspExeProcess;
+
+
+    hMyProcess = GetCurrentProcess();
+
+    hEspExeProcess = OpenProcess(
+        PROCESS_DUP_HANDLE,
+        TRUE,
+        (DWORD) lProcessID
+        );
+
+    if (!DuplicateHandle(
+            hMyProcess,
+            ghDebugOutputEvent,
+            hEspExeProcess,
+            (HANDLE *) phDebugOutputEvent,
+            0,
+            FALSE,
+            DUPLICATE_SAME_ACCESS
+            ) ||
+
+        !DuplicateHandle(
+            hMyProcess,
+            ghShutdownEvent,
+            hEspExeProcess,
+            (HANDLE *) phShutdownEvent,
+            0,
+            FALSE,
+            DUPLICATE_SAME_ACCESS
+            ) ||
+
+        !DuplicateHandle(
+            hMyProcess,
+            ghWidgetEventsEvent,
+            hEspExeProcess,
+            (HANDLE *) phWidgetEventsEvent,
+            0,
+            FALSE,
+            DUPLICATE_SAME_ACCESS
+            ))
+    {
+        DBGOUT((1, "ESPAttach: DupHandle failed, err=%d", GetLastError()));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+void
+ESPSetOptions(
+    long    lDebugOptions,
+    long    lCompletionMode
+    )
+{
+    gESPGlobals.dwDebugOptions   = (DWORD) lDebugOptions;
+    gESPGlobals.dwCompletionMode = (DWORD) lCompletionMode;
+
+    if (!gbInteractWithDesktop)
+    {
+        gESPGlobals.dwDebugOptions &= ~MANUAL_RESULTS;
+    }
+}
+
+
+void
+ESPCompleteRequest(
+    long    lAsyncReqInfo,
+    long    lResult
+    )
+{
+    PASYNC_REQUEST_INFO pAsyncReqInfo = (PASYNC_REQUEST_INFO) lAsyncReqInfo;
+
+
+    pAsyncReqInfo->lResult = lResult;
+
+    if (pAsyncReqInfo->pfnPostProcessProc)
+    {
+        (*((POSTPROCESSPROC) pAsyncReqInfo->pfnPostProcessProc))(
+            pAsyncReqInfo,
+            ASYNC
+            );
+    }
+    else
+    {
+        DoCompletion (pAsyncReqInfo, ASYNC);
+    }
+
+    DrvFree (pAsyncReqInfo);
+}
+
+
+long
+ESPEvent(
+    long    htDevice,
+    long    htCall,
+    long    dwMsg,
+    long    dwParam1,
+    long    dwParam2,
+    long    dwParam3
+    )
+{
+    switch (dwMsg)
+    {
+    case LINE_CALLSTATE:
+    {
+        DWORD   dwCallInst;
+
+// BUGBUG when state == conf or prevState == conf need to add/rem conf list
+
+        try
+        {
+            dwCallInst = ((PDRVCALL) htCall)->dwCallInstance;
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+            break;
+        }
+
+        SetCallState(
+            (PDRVCALL) htCall,
+            dwCallInst,
+            0xffffffff,
+            dwParam1,
+            dwParam2,
+            TRUE
+            );
+
+        break;
+    }
+    case LINE_ADDRESSSTATE:
+    case LINE_CALLDEVSPECIFIC:
+    case LINE_CALLDEVSPECIFICFEATURE:
+    case LINE_CALLINFO:
+    case LINE_CLOSE:
+    case LINE_DEVSPECIFIC:
+    case LINE_DEVSPECIFICFEATURE:
+    case LINE_GATHERDIGITS:
+    case LINE_GENERATE:
+    case LINE_LINEDEVSTATE:
+    case LINE_MONITORDIGITS:
+    case LINE_MONITORMEDIA:
+    case LINE_MONITORTONE:
+    case LINE_REMOVE:
+
+        (*gESPGlobals.pfnLineEvent)(
+            (HTAPILINE) htDevice,
+            (HTAPICALL) htCall,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        ShowLineEvent(
+            (HTAPILINE) htDevice,
+            (HTAPICALL) htCall,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        break;
+
+    case LINE_CREATEDIALOGINSTANCE:
+    {
+        TUISPICREATEDIALOGINSTANCEPARAMS createDlgParams;
+
+
+        ZeroMemory(
+            &createDlgParams,
+            sizeof (TUISPICREATEDIALOGINSTANCEPARAMS)
+            );
+
+        createDlgParams.dwRequestID   = dwParam1;
+        createDlgParams.hdDlgInst     = (HDRVDIALOGINSTANCE) 0x55;
+        createDlgParams.lpszUIDLLName = szESPUIDLL;
+        createDlgParams.lpParams      = "genDlg params";
+        createDlgParams.dwSize        = 14;
+
+        (*gESPGlobals.pfnLineEvent)(
+            (HTAPILINE) gESPGlobals.hProvider,
+            (HTAPICALL) NULL,
+            (DWORD) LINE_CREATEDIALOGINSTANCE,
+            (DWORD) &createDlgParams,
+            0,
+            0
+            );
+
+        ShowLineEvent(
+            (HTAPILINE) gESPGlobals.hProvider,
+            NULL,
+            LINE_CREATEDIALOGINSTANCE,
+            (DWORD) &createDlgParams,
+            0,
+            0
+            );
+
+            break;
+    }
+    case LINE_SENDDIALOGINSTANCEDATA:
+    {
+        char data[] = "dlgInstData";
+
+
+        (*gESPGlobals.pfnLineEvent)(
+            (HTAPILINE) dwParam1,
+            (HTAPICALL) NULL,
+            (DWORD) LINE_SENDDIALOGINSTANCEDATA,
+            (DWORD) data,
+            12,
+            0
+            );
+
+        ShowLineEvent(
+            (HTAPILINE) dwParam1,
+            NULL,
+            LINE_CREATEDIALOGINSTANCE,
+            (DWORD) data,
+            12,
+            0
+            );
+
+            break;
+    }
+    case PHONE_BUTTON:
+    case PHONE_CLOSE:
+    case PHONE_DEVSPECIFIC:
+    case PHONE_STATE:
+    case PHONE_REMOVE:
+
+        (*gESPGlobals.pfnPhoneEvent)(
+            (HTAPIPHONE) htDevice,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        ShowPhoneEvent(
+            (HTAPIPHONE) htDevice,
+            dwMsg,
+            dwParam1,
+            dwParam2,
+            dwParam3
+            );
+
+        break;
+    }
+
+    return 0;
+}
+
+
+void
+ESPGetDebugOutput(
+    unsigned char  *pBuffer,
+    long           *plSize
+    )
+{
+    DWORD   dwTotalSize, dwMoveSize, dwMoveSizeWrapped;
+
+
+    EnterCriticalSection (&gESPGlobals.DebugBufferCritSec);
+
+    dwMoveSize =
+    dwTotalSize = ((DWORD) *plSize < gESPGlobals.dwDebugBufferUsedSize ?
+        (DWORD)*plSize : gESPGlobals.dwDebugBufferUsedSize);
+
+    if ((DWORD) (gESPGlobals.pDebugBuffer + gESPGlobals.dwDebugBufferTotalSize
+            - gESPGlobals.pDebugBufferOut) > dwTotalSize)
+    {
+        dwMoveSizeWrapped = 0;
+    }
+    else
+    {
+        dwMoveSize = (gESPGlobals.pDebugBuffer +
+            gESPGlobals.dwDebugBufferTotalSize - gESPGlobals.pDebugBufferOut);
+
+        dwMoveSizeWrapped = dwTotalSize - dwMoveSize;
+    }
+
+    CopyMemory(
+        pBuffer,
+        gESPGlobals.pDebugBufferOut,
+        dwMoveSize
+        );
+
+    if (dwMoveSizeWrapped)
+    {
+        CopyMemory(
+            pBuffer + dwMoveSize,
+            gESPGlobals.pDebugBuffer,
+            dwMoveSizeWrapped
+            );
+
+        gESPGlobals.pDebugBufferOut = gESPGlobals.pDebugBuffer +
+            dwMoveSizeWrapped;
+    }
+    else
+    {
+        gESPGlobals.pDebugBufferOut += dwTotalSize;
+    }
+
+    gESPGlobals.dwDebugBufferUsedSize -= dwTotalSize;
+
+    LeaveCriticalSection (&gESPGlobals.DebugBufferCritSec);
+
+    ResetEvent (ghDebugOutputEvent);
+
+    *plSize = (long) dwTotalSize;
+}
+
+
+void
+ESPGetWidgetEvents(
+    unsigned char  *pBuffer,
+    long           *plSize
+    )
+{
+    DWORD   dwTotalSize, dwMoveSize, dwMoveSizeWrapped;
+
+
+    EnterCriticalSection (&gESPGlobals.EventBufferCritSec);
+
+    dwMoveSize =
+    dwTotalSize = ((DWORD) *plSize < gESPGlobals.dwEventBufferUsedSize ?
+        (DWORD)*plSize : gESPGlobals.dwEventBufferUsedSize);
+
+    if ((DWORD) (gESPGlobals.pEventBuffer + gESPGlobals.dwEventBufferTotalSize
+            - gESPGlobals.pEventBufferOut) > dwTotalSize)
+    {
+        dwMoveSizeWrapped = 0;
+    }
+    else
+    {
+        dwMoveSize = (gESPGlobals.pEventBuffer +
+            gESPGlobals.dwEventBufferTotalSize - gESPGlobals.pEventBufferOut);
+
+        dwMoveSizeWrapped = dwTotalSize - dwMoveSize;
+    }
+
+    CopyMemory(
+        pBuffer,
+        gESPGlobals.pEventBufferOut,
+        dwMoveSize
+        );
+
+    if (dwMoveSizeWrapped)
+    {
+        CopyMemory(
+            pBuffer + dwMoveSize,
+            gESPGlobals.pEventBuffer,
+            dwMoveSizeWrapped
+            );
+
+        gESPGlobals.pEventBufferOut = gESPGlobals.pEventBuffer +
+            dwMoveSizeWrapped;
+    }
+    else
+    {
+        gESPGlobals.pEventBufferOut += dwTotalSize;
+    }
+
+    gESPGlobals.dwEventBufferUsedSize -= dwTotalSize;
+
+    LeaveCriticalSection (&gESPGlobals.EventBufferCritSec);
+
+    ResetEvent (ghWidgetEventsEvent);
+
+    *plSize = (long) dwTotalSize;
+}
+
+
+long
+ESPStartPBXThread(
+    unsigned char  *pBuffer,
+    long            lSize
+    )
+{
+    long   *pPBXSettings;
+    DWORD   dwThreadID;
+
+    if ((pPBXSettings = DrvAlloc (lSize)))
+    {
+        CopyMemory (pPBXSettings, pBuffer, lSize);
+
+        gbExitPBXThread = FALSE;
+
+        if ((ghPBXThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) PBXThread,
+                (LPVOID) pPBXSettings,
+                0,
+                &dwThreadID
+                )))
+        {
+            return 0;
+        }
+
+        DrvFree (pPBXSettings);
+    }
+
+    return -1;
+}
+
+
+long
+ESPStopPBXThread(
+    long    lDummy
+    )
+{
+    gbExitPBXThread = TRUE;
+
+    WaitForSingleObject (ghPBXThread, INFINITE);
+
+    CloseHandle (ghPBXThread);
+
+    ghPBXThread = NULL;
+
+    return 0;
+}
+
+
+void
+__RPC_FAR *
+__RPC_API
+midl_user_allocate(
+    size_t len
+    )
+{
+
+
+    return (DrvAlloc (len));
+}
+
+
+void
+__RPC_API
+midl_user_free(
+    void __RPC_FAR * ptr
+    )
+{
+    DrvFree (ptr);
+}
+
+
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[128] = "ESP32: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+        wvsprintf (&buf[7], lpszFormat, ap);
+        lstrcatA (buf, "\n");
+        OutputDebugStringA (buf);
+        va_end(ap);
+    }
+}
+#endif
+
+BOOL
+ScanForDWORD(
+   char far *pBuf,
+   LPDWORD  lpdw
+   )
+{
+    char  c;
+    BOOL  bValid = FALSE;
+    DWORD d = 0;
+
+    while ((c = *pBuf))
+    {
+        if ((c >= '0') && (c <= '9'))
+        {
+            c -= '0';
+        }
+        else if ((c >= 'a') && (c <= 'f'))
+        {
+            c -= ('a' - 10);
+        }
+        else if ((c >= 'A') && (c <= 'F'))
+        {
+            c -= ('A' - 10);
+        }
+        else
+        {
+            break;
+        }
+
+        bValid = TRUE;
+
+        d *= 16;
+
+        d += (DWORD) c;
+
+        pBuf++;
+    }
+
+    if (bValid)
+    {
+        *lpdw = d;
+    }
+
+    return bValid;
+}
+
+
+BOOL
+CALLBACK
+ValuesDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    DWORD   i;
+
+    static  HWND                hwndCombo, hwndList1, hwndList2;
+    static  LONG                lLastSel;
+    static  char                szComboText[MAX_STRING_PARAM_SIZE];
+    static  PEVENT_PARAM_HEADER pParamsHeader;
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        hwndList1 = GetDlgItem (hwnd, IDC_LIST1);
+        hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+        hwndCombo = GetDlgItem (hwnd, IDC_COMBO1);
+
+        lLastSel = -1;
+        pParamsHeader = (PEVENT_PARAM_HEADER) lParam;
+
+
+        //
+        // Limit the max text length for the combobox's edit field
+        // (NOTE: A combobox ctrl actually has two child windows: a
+        // edit ctrl & a listbox.  We need to get the hwnd of the
+        // child edit ctrl & send it the LIMITTEXT msg.)
+        //
+
+        {
+            HWND hwndChild = GetWindow (hwndCombo, GW_CHILD);
+
+
+            while (hwndChild)
+            {
+                char buf[8];
+
+
+                GetClassName (hwndChild, buf, 7);
+
+                if (_stricmp (buf, "edit") == 0)
+                {
+                    break;
+                }
+
+                hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+            }
+
+            SendMessage(
+                hwndChild,
+                EM_LIMITTEXT,
+                (WPARAM) MAX_STRING_PARAM_SIZE - 1,
+                0
+                );
+        }
+
+
+        //
+        // Misc other init
+        //
+
+        SetWindowText (hwnd, pParamsHeader->pszDlgTitle);
+
+        for (i = 0; i < pParamsHeader->dwNumParams; i++)
+        {
+            SendMessage(
+                hwndList1,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) pParamsHeader->aParams[i].szName
+                );
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            if (lLastSel != -1)
+            {
+                char buf[MAX_STRING_PARAM_SIZE];
+
+
+                //
+                // Save val of currently selected param
+                //
+
+                i = GetDlgItemText(
+                    hwnd,
+                    IDC_COMBO1,
+                    buf,
+                    MAX_STRING_PARAM_SIZE - 1
+                    );
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    LONG lComboSel;
+
+
+                    lComboSel = SendMessage (hwndCombo, CB_GETCURSEL, 0, 0);
+
+                    if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                    {
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD) 0;
+                    }
+                    else // "Valid string"
+                    {
+                        strncpy(
+                            pParamsHeader->aParams[lLastSel].buf,
+                            buf,
+                            MAX_STRING_PARAM_SIZE - 1
+                            );
+
+                        pParamsHeader->aParams[lLastSel].buf[MAX_STRING_PARAM_SIZE-1] = 0;
+
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                            pParamsHeader->aParams[lLastSel].buf;
+                    }
+
+                    break;
+                }
+                case PT_DWORD:
+                case PT_FLAGS:
+                case PT_ORDINAL:
+                {
+                    if (!ScanForDWORD(
+                            buf,
+                            &pParamsHeader->aParams[lLastSel].dwValue
+                            ))
+                    {
+                        //
+                        // Default to 0
+                        //
+
+                        pParamsHeader->aParams[lLastSel].dwValue = 0;
+                    }
+
+                    break;
+                }
+                } // switch
+            }
+
+            // Drop thru to IDCANCEL cleanup code
+
+        case IDCANCEL:
+
+            EndDialog (hwnd, (int)LOWORD(wParam));
+            break;
+
+        case IDC_LIST1:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                char    buf[MAX_STRING_PARAM_SIZE] = "";
+                LPCSTR  lpstr = buf;
+                LONG    lSel = SendMessage (hwndList1, LB_GETCURSEL, 0, 0);
+
+
+                if (lLastSel != -1)
+                {
+                    //
+                    // Save the old param value
+                    //
+
+                    i = GetWindowText(
+                        hwndCombo,
+                        buf,
+                        MAX_STRING_PARAM_SIZE - 1
+                        );
+
+                    switch (pParamsHeader->aParams[lLastSel].dwType)
+                    {
+                    case PT_STRING:
+                    {
+                        LONG lComboSel;
+
+
+                        lComboSel = SendMessage (hwndCombo, CB_GETCURSEL, 0,0);
+
+                        if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                        {
+                            pParamsHeader->aParams[lLastSel].dwValue =
+                                (DWORD)0;
+                        }
+                        else // "Valid string" or no sel
+                        {
+                            strncpy(
+                                pParamsHeader->aParams[lLastSel].buf,
+                                buf,
+                                MAX_STRING_PARAM_SIZE - 1
+                                );
+
+                            pParamsHeader->aParams[lLastSel].buf[MAX_STRING_PARAM_SIZE - 1] = 0;
+
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                                pParamsHeader->aParams[lLastSel].buf;
+                        }
+
+                        break;
+                    }
+                    case PT_DWORD:
+                    case PT_FLAGS:
+                    case PT_ORDINAL:
+                    {
+                        if (!ScanForDWORD(
+                                buf,
+                                &pParamsHeader->aParams[lLastSel].dwValue
+                                ))
+                        {
+                            //
+                            // Default to 0
+                            //
+
+                            pParamsHeader->aParams[lLastSel].dwValue = 0;
+                        }
+
+                        break;
+                    }
+                    } // switch
+                }
+
+
+                SendMessage (hwndList2, LB_RESETCONTENT, 0, 0);
+                SendMessage (hwndCombo, CB_RESETCONTENT, 0, 0);
+
+                switch (pParamsHeader->aParams[lSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    char * aszOptions[] =
+                    {
+                        "NUL (dwXxxSize=0)",
+                        "Valid string"
+                    };
+
+
+                    for (i = 0; i < 2; i++)
+                    {
+                        SendMessage(
+                            hwndCombo,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) aszOptions[i]
+                            );
+                    }
+
+                    if (pParamsHeader->aParams[lSel].dwValue == 0)
+                    {
+                        i = 0;
+                        buf[0] = 0;
+                    }
+                    else
+                    {
+                        i = 1;
+                        lpstr = (LPCSTR) pParamsHeader->aParams[lSel].dwValue;
+                    }
+
+                    SendMessage (hwndCombo, CB_SETCURSEL, (WPARAM) i, 0);
+
+                    break;
+                }
+                case PT_DWORD:
+                {
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "0000000"
+                        );
+
+                    if (pParamsHeader->aParams[lSel].dwDefValue)
+                    {
+                        //
+                        // Add the default val string to the combo
+                        //
+
+                        wsprintf(
+                            buf,
+                            "%08lx",
+                            pParamsHeader->aParams[lSel].dwDefValue
+                            );
+
+                        SendMessage(
+                            hwndCombo,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) buf
+                            );
+                    }
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "ffffffff"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_ORDINAL:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue ==
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_FLAGS:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue &
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    SendMessage(
+                        hwndCombo,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select all"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                } //switch
+
+                SetWindowText (hwndCombo, lpstr);
+
+                lLastSel = lSel;
+            }
+            break;
+
+        case IDC_LIST2:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                //
+                // BUGBUG in the PT_ORDINAL case we should compare the
+                // currently selected item(s) against the previous DWORD
+                // val and figure out which item we need to deselect,
+                // if any, in order to maintain a mutex of values
+                //
+
+                PLOOKUP pLookup = (PLOOKUP)
+                    pParamsHeader->aParams[lLastSel].pLookup;
+                char buf[16];
+                DWORD dwValue = 0;
+                int far *ai;
+                LONG i, lSelCount =
+                    SendMessage (hwndList2, LB_GETSELCOUNT, 0, 0);
+
+
+                ai = (int far *) DrvAlloc ((size_t)lSelCount * sizeof(int));
+
+                SendMessage(
+                    hwndList2,
+                    LB_GETSELITEMS,
+                    (WPARAM) lSelCount,
+                    (LPARAM) ai
+                    );
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_FLAGS)
+                {
+                    for (i = 0; i < lSelCount; i++)
+                    {
+                        dwValue |= pLookup[ai[i]].dwVal;
+                    }
+                }
+                else // if (.dwType == PT_ORDINAL)
+                {
+                    if (lSelCount == 1)
+                    {
+                        dwValue = pLookup[ai[0]].dwVal;
+                    }
+                    else if (lSelCount == 2)
+                    {
+                        //
+                        // Figure out which item we need to de-select, since
+                        // we're doing ordinals & only want 1 item selected
+                        // at a time
+                        //
+
+                        GetWindowText (hwndCombo, buf, 16);
+
+                        if (ScanForDWORD (buf, &dwValue))
+                        {
+                            if (pLookup[ai[0]].dwVal == dwValue)
+                            {
+                                SendMessage(
+                                    hwndList2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[0]
+                                    );
+
+                                dwValue = pLookup[ai[1]].dwVal;
+                            }
+                            else
+                            {
+                                SendMessage(
+                                    hwndList2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[1]
+                                    );
+
+                                dwValue = pLookup[ai[0]].dwVal;
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                    else if (lSelCount > 2)
+                    {
+                        //
+                        // Determine previous selection & de-select all the
+                        // latest selections
+                        //
+
+                        GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                        if (ScanForDWORD (buf, &dwValue))
+                        {
+                            for (i = 0; i < lSelCount; i++)
+                            {
+                                if (pLookup[ai[i]].dwVal != dwValue)
+                                {
+                                    SendMessage(
+                                        hwndList2,
+                                        LB_SETSEL,
+                                        0,
+                                        (LPARAM) ai[i]
+                                        );
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                }
+
+                DrvFree (ai);
+                wsprintf (buf, "%08lx", dwValue);
+                SetWindowText (hwndCombo, buf);
+            }
+            break;
+
+        case IDC_COMBO1:
+
+            switch (HIWORD(wParam))
+            {
+            case CBN_SELCHANGE:
+            {
+                LONG    lSel =  SendMessage (hwndCombo, CB_GETCURSEL, 0, 0);
+
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_ORDINAL:
+
+                    //
+                    // The only option here is "select none"
+                    //
+
+                    strcpy (szComboText, "00000000");
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+                    break;
+
+                case PT_FLAGS:
+                {
+                    BOOL bSelect = (lSel ? TRUE : FALSE);
+
+                    SendMessage(
+                        hwndList2,
+                        LB_SETSEL,
+                        (WPARAM) bSelect,
+                        (LPARAM) -1
+                        );
+
+                    if (bSelect)
+                    {
+                        PLOOKUP pLookup = (PLOOKUP)
+                            pParamsHeader->aParams[lLastSel].pLookup;
+                        DWORD dwValue = 0;
+                        int far *ai;
+                        LONG i, lSelCount =
+                            SendMessage (hwndList2, LB_GETSELCOUNT, 0, 0);
+
+
+                        ai = (int far *) DrvAlloc(
+                            (size_t)lSelCount * sizeof(int)
+                            );
+
+                        SendMessage(
+                            hwndList2,
+                            LB_GETSELITEMS,
+                            (WPARAM) lSelCount,
+                            (LPARAM) ai
+                            );
+
+                        for (i = 0; i < lSelCount; i++)
+                        {
+                            dwValue |= pLookup[ai[i]].dwVal;
+                        }
+
+                        DrvFree (ai);
+                        wsprintf (szComboText, "%08lx", dwValue);
+
+                    }
+                    else
+                    {
+                        strcpy (szComboText, "00000000");
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+                }
+                case PT_STRING:
+
+                    if (lSel == 1)
+                    {
+                        strncpy(
+                            szComboText,
+                            pParamsHeader->aParams[lLastSel].buf,
+                            MAX_STRING_PARAM_SIZE
+                            );
+
+                        szComboText[MAX_STRING_PARAM_SIZE-1] = 0;
+                    }
+                    else
+                    {
+                        szComboText[0] = 0;
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+
+                case PT_DWORD:
+
+                    break;
+
+                } // switch
+                break;
+            }
+            case CBN_EDITCHANGE:
+            {
+                //
+                // If user entered text in the edit field then copy the
+                // text to our buffer
+                //
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_STRING)
+                {
+                    char buf[MAX_STRING_PARAM_SIZE];
+
+
+                    GetWindowText (hwndCombo, buf, MAX_STRING_PARAM_SIZE);
+
+                    strncpy(
+                        pParamsHeader->aParams[lLastSel].buf,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    pParamsHeader->aParams[lLastSel].buf
+                        [MAX_STRING_PARAM_SIZE-1] = 0;
+                }
+                break;
+            }
+            } // switch
+
+        } // switch
+
+        break;
+    }
+    case WM_USER+55:
+
+        SetWindowText (hwndCombo, szComboText);
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+PASCAL
+IsValidESPAddress(
+    LPCWSTR     lpszDestAddress,
+    PDRVLINE   *ppLine,
+    LPDWORD     pdwAddressID
+    )
+{
+    char   *pszDestAddress, *p, c;
+    BOOL    bResult = FALSE;
+    DWORD   length, dwDestLineID, dwAddressID;
+
+
+    if (!lpszDestAddress)
+    {
+        return FALSE;
+    }
+
+
+    //
+    // Convert destination address from unicode to ascii
+    //
+
+    length = (lstrlenW (lpszDestAddress) + 1) * sizeof (WCHAR);
+
+    if (!(pszDestAddress = DrvAlloc (length)))
+    {
+        return FALSE;
+    }
+
+    WideCharToMultiByte(
+        CP_ACP,
+        0,
+        lpszDestAddress,
+        -1,
+        pszDestAddress,
+        length,
+        NULL,
+        NULL
+        );
+
+    p = pszDestAddress;
+
+
+    //
+    // See if destination address is in the format of either
+    // "<esp line id>" or "<esp line id>#<esp address id>"
+    //
+
+    if (*p < '0'  ||  *p > '9')
+    {
+        goto ISESPAddress_freeAddr;
+    }
+
+    for (dwDestLineID = 0; (c = *p); p++)
+    {
+        if (c >= '0' && c <= '9')
+        {
+            dwDestLineID *= 10;
+            dwDestLineID += ((DWORD)(c - '0'));
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    if (c != '\0'  &&  c != '#')
+    {
+        goto ISESPAddress_freeAddr;
+    }
+
+    if (dwDestLineID < gESPGlobals.dwLineDeviceIDBase ||
+        dwDestLineID >= (gESPGlobals.dwNumLines +
+            gESPGlobals.dwLineDeviceIDBase))
+    {
+        goto ISESPAddress_freeAddr;
+    }
+
+    if (c == '\0')
+    {
+        *pdwAddressID = 0;
+        goto ISESPAddress_success;
+    }
+
+    p++;
+
+    if (*p < '0'  ||  *p > '9')
+    {
+        goto ISESPAddress_freeAddr;
+    }
+
+    for (dwAddressID = 0; (c = *p); p++)
+    {
+        if (c >= '0' && c <= '9')
+        {
+            dwAddressID *= 10;
+            dwAddressID += ((DWORD)(c - '0'));
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    if (c != '\0'  ||  dwAddressID >= gESPGlobals.dwNumAddressesPerLine)
+    {
+        goto ISESPAddress_freeAddr;
+    }
+
+    *pdwAddressID = dwAddressID;
+
+ISESPAddress_success:
+
+    *ppLine = GetLineFromID (dwDestLineID);
+    bResult = TRUE;
+
+ISESPAddress_freeAddr:
+
+    DrvFree (pszDestAddress);
+    return bResult;
+}
+
+
+LONG
+PASCAL
+CreateIncomingCall(
+    LPCWSTR             lpszDestAddress,
+    LPLINECALLPARAMS    lpCallParams,
+    PDRVCALL            pOutgoingCall,
+    BOOL               *pbValidESPAddress,
+    PDRVLINE           *ppIncomingLine,
+    PDRVCALL           *ppIncomingCall
+    )
+{
+    LONG                lResult;
+    DWORD               dwIncomingAddressID;
+    PDRVCALL            pIncomingCall;
+    PDRVLINE            pIncomingLine;
+    LINECALLPARAMS      callParams;
+
+
+    *pbValidESPAddress = FALSE;
+    *ppIncomingLine = NULL;
+    *ppIncomingCall = NULL;
+
+    if (!IsValidESPAddress(
+            lpszDestAddress,
+            &pIncomingLine,
+            &dwIncomingAddressID
+            ))
+    {
+        return LINEERR_INVALADDRESS;
+    }
+
+    *pbValidESPAddress = TRUE;
+
+    if (pIncomingLine->htLine == NULL ||
+        (pOutgoingCall &&
+        !(pIncomingLine->dwMediaModes & pOutgoingCall->dwMediaMode)))
+    {
+        return LINEERR_INVALMEDIAMODE;
+    }
+
+    if (!lpCallParams)
+    {
+        lpCallParams = &callParams;
+
+        ZeroMemory (&callParams, sizeof (LINECALLPARAMS));
+
+        callParams.dwTotalSize = sizeof (LINECALLPARAMS);
+        callParams.dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+        callParams.dwBearerMode = LINEBEARERMODE_VOICE;
+    }
+
+    lpCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
+    lpCallParams->dwAddressID = dwIncomingAddressID;
+
+    if ((lResult = AllocCall(
+            pIncomingLine,
+            0,
+            lpCallParams,
+            &pIncomingCall
+
+            )) == 0)
+    {
+        if (pOutgoingCall)
+        {
+            pOutgoingCall->pDestCall = pIncomingCall;
+            pIncomingCall->pDestCall = pOutgoingCall;
+        }
+
+        *ppIncomingLine = pIncomingLine;
+        *ppIncomingCall = pIncomingCall;
+    }
+    else
+    {
+        ShowStr(
+             TRUE,
+             "lineMakeCall couldn't create incoming call on" \
+                 "line/addr id %d/%d, exceeded max calls per line/addr",
+             pIncomingLine->dwDeviceID,
+             dwIncomingAddressID
+             );
+    }
+
+    return lResult;
+}
+
+
+void
+FAR
+PASCAL
+TransferCall_postProcess(
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bAsync
+    )
+{
+    DWORD       dwCallInstThen = pAsyncReqInfo->dwParam2,
+                dwValidCurrentCallStates = pAsyncReqInfo->dwParam5,
+                dwNewCallState = pAsyncReqInfo->dwParam6,
+                dwCallInstNow;
+    PDRVCALL    pCall = (PDRVCALL) pAsyncReqInfo->dwParam1,
+                pDestCall = (PDRVCALL) pAsyncReqInfo->dwParam4;
+    PDRVLINE    pDestLine = (PDRVLINE) pAsyncReqInfo->dwParam3;
+
+
+    DoCompletion (pAsyncReqInfo, bAsync);
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = SetCallState(
+                pCall,
+                dwCallInstThen,
+                dwValidCurrentCallStates,
+                LINECALLSTATE_IDLE,
+                0,
+                TRUE
+
+                )) != 0)
+        {
+            goto TSPI_lineBlindTransfer_postProcess_freeDestCall;
+        }
+
+        if (pDestCall)
+        {
+            EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+            if (IsValidDrvCall (pCall, &dwCallInstNow) &&
+                dwCallInstNow == dwCallInstThen)
+            {
+                SendLineEvent(
+                    pDestLine,
+                    NULL,
+                    LINE_NEWCALL,
+                    (DWORD) pDestCall,
+                    (DWORD) &pDestCall->htCall,
+                    0
+                    );
+
+                if (pDestCall->htCall)
+                {
+                    SetCallState(
+                        pDestCall,
+                        pDestCall->dwCallInstance,
+                        0xffffffff,
+                        dwNewCallState,
+                        0,
+                        TRUE
+                        );
+                }
+                else
+                {
+                    FreeCall (pDestCall, pDestCall->dwCallInstance);
+                }
+            }
+            else
+            {
+                FreeCall (pDestCall, pDestCall->dwCallInstance);
+            }
+
+            LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+        }
+
+    }
+    else
+    {
+
+TSPI_lineBlindTransfer_postProcess_freeDestCall:
+
+        if (pDestCall)
+        {
+            FreeCall (pDestCall, pDestCall->dwCallInstance);
+        }
+    }
+}
+
+
+
+
+LONG
+PASCAL
+TransferCall(
+    PFUNC_INFO  pInfo,
+    PDRVCALL    pCall,
+    DWORD       dwValidCurrentCallStates,
+    DWORD       dwNewCallState, // initial call state of new incoming call
+    LPCWSTR     lpszDestAddress
+    )
+{
+    BOOL        bValidESPAddress;
+    LONG        lResult = 0;
+    PDRVLINE    pDestLine;
+    PDRVCALL    pDestCall;
+
+
+    EnterCriticalSection (&gESPGlobals.CallListCritSec);
+
+    if (IsValidDrvCall (pCall, NULL) == FALSE)
+    {
+        lResult = LINEERR_INVALCALLHANDLE;
+    }
+    else if ((pCall->dwCallState & dwValidCurrentCallStates) == 0)
+    {
+        lResult = LINEERR_INVALCALLSTATE;
+    }
+    else
+    {
+        PDRVCALL        pDestCallOrig = pCall->pDestCall;
+        LINECALLPARAMS  callParams;
+
+
+        if (IsValidDrvCall (pDestCallOrig, NULL) == FALSE)
+        {
+            pDestCallOrig = NULL;
+        }
+
+        ZeroMemory (&callParams, sizeof (LINECALLPARAMS));
+
+        callParams.dwTotalSize  = sizeof (LINECALLPARAMS);
+        callParams.dwMediaMode  = pCall->dwMediaMode;
+        callParams.dwBearerMode = pCall->dwBearerMode;
+        callParams.dwMinRate    = pCall->dwMinRate;
+        callParams.dwMaxRate    = pCall->dwMaxRate;
+
+        if (CreateIncomingCall(
+                lpszDestAddress,
+                &callParams,
+                pDestCallOrig,
+                &bValidESPAddress,
+                &pDestLine,
+                &pDestCall
+
+                ) == 0)
+        {
+            pCall->pDestCall = NULL;
+            pDestCall->dwCallID = pCall->dwCallID;
+
+            if (pCall->dwCallDataSize  &&
+                (pDestCall->pCallData = DrvAlloc (pCall->dwCallDataSize)))
+            {
+                CopyMemory(
+                    pDestCall->pCallData,
+                    pCall->pCallData,
+                    (pDestCall->dwCallDataSize = pCall->dwCallDataSize)
+                    );
+            }
+        }
+
+        pInfo->pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+            TransferCall_postProcess;
+
+        pInfo->pAsyncReqInfo->dwParam1 = (DWORD) pCall;
+        pInfo->pAsyncReqInfo->dwParam2 = (DWORD) pCall->dwCallInstance;
+        pInfo->pAsyncReqInfo->dwParam3 = (DWORD) pDestLine;
+        pInfo->pAsyncReqInfo->dwParam4 = (DWORD) pDestCall;
+        pInfo->pAsyncReqInfo->dwParam5 = (DWORD) dwValidCurrentCallStates;
+        pInfo->pAsyncReqInfo->dwParam6 = (DWORD) dwNewCallState;
+    }
+
+    LeaveCriticalSection (&gESPGlobals.CallListCritSec);
+
+    return lResult;
+}
diff --git a/private/tapi/dev/sp/esp.new/tsp/esp.h b/private/tapi/dev/sp/esp.new/tsp/esp.h
new file mode 100644
index 000000000..54ca0494d
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/esp.h
@@ -0,0 +1,653 @@
+/*++
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    esp.h
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    18-Sep-1995
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+
+#include "windows.h"
+#include "intrface.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "espidl.h"
+
+
+#define DRVCALL_KEY                             ((DWORD) 'LLAC')
+#define INVAL_KEY                               ((DWORD) 'XXXX')
+
+#define SYNC                                    0
+#define ASYNC                                   1
+
+#define LINE_ICON                               1
+#define PHONE_ICON                              2
+#define IDD_DIALOG1                             3
+
+#define IDC_LIST1                               1001
+#define IDC_COMBO1                              1002
+#define IDC_LIST2                               1003
+
+#define MAX_STRING_PARAM_SIZE                   32
+
+#define PT_DWORD                                1
+#define PT_FLAGS                                2
+#define PT_STRING                               3
+#define PT_ORDINAL                              4
+
+#define DEF_NUM_ASYNC_REQUESTS_IN_QUEUE         256
+#define DEF_NUM_EXTRA_LOOKUP_ENTRIES            16
+
+#define MAX_VAR_DATA_SIZE                       1024
+
+#define MAX_NUM_COMPLETION_MESSAGES             100
+
+#define PHONE_DISPLAY_SIZE_IN_CHARS             32
+#define PHONE_DISPLAY_SIZE_IN_BYTES             (PHONE_DISPLAY_SIZE_IN_CHARS * sizeof (WCHAR))
+
+#define AllAddrCaps1_0                            \
+        (LINEADDRCAPFLAGS_FWDNUMRINGS           | \
+        LINEADDRCAPFLAGS_PICKUPGROUPID          | \
+        LINEADDRCAPFLAGS_SECURE                 | \
+        LINEADDRCAPFLAGS_BLOCKIDDEFAULT         | \
+        LINEADDRCAPFLAGS_BLOCKIDOVERRIDE        | \
+        LINEADDRCAPFLAGS_DIALED                 | \
+        LINEADDRCAPFLAGS_ORIGOFFHOOK            | \
+        LINEADDRCAPFLAGS_DESTOFFHOOK            | \
+        LINEADDRCAPFLAGS_FWDCONSULT             | \
+        LINEADDRCAPFLAGS_SETUPCONFNULL          | \
+        LINEADDRCAPFLAGS_AUTORECONNECT          | \
+        LINEADDRCAPFLAGS_COMPLETIONID           | \
+        LINEADDRCAPFLAGS_TRANSFERHELD           | \
+        LINEADDRCAPFLAGS_TRANSFERMAKE           | \
+        LINEADDRCAPFLAGS_CONFERENCEHELD         | \
+        LINEADDRCAPFLAGS_CONFERENCEMAKE         | \
+        LINEADDRCAPFLAGS_PARTIALDIAL            | \
+        LINEADDRCAPFLAGS_FWDSTATUSVALID         | \
+        LINEADDRCAPFLAGS_FWDINTEXTADDR          | \
+        LINEADDRCAPFLAGS_FWDBUSYNAADDR          | \
+        LINEADDRCAPFLAGS_ACCEPTTOALERT          | \
+        LINEADDRCAPFLAGS_CONFDROP               | \
+        LINEADDRCAPFLAGS_PICKUPCALLWAIT)
+
+#define AllAddrCaps2_0                            \
+        (AllAddrCaps1_0                         | \
+        LINEADDRCAPFLAGS_PREDICTIVEDIALER       | \
+        LINEADDRCAPFLAGS_QUEUE                  | \
+        LINEADDRCAPFLAGS_ROUTEPOINT             | \
+        LINEADDRCAPFLAGS_HOLDMAKESNEW           | \
+        LINEADDRCAPFLAGS_NOINTERNALCALLS        | \
+        LINEADDRCAPFLAGS_NOEXTERNALCALLS        | \
+        LINEADDRCAPFLAGS_SETCALLINGID)
+
+#define AllAddrFeatures1_0                        \
+        (LINEADDRFEATURE_FORWARD                | \
+        LINEADDRFEATURE_MAKECALL                | \
+        LINEADDRFEATURE_PICKUP                  | \
+        LINEADDRFEATURE_SETMEDIACONTROL         | \
+        LINEADDRFEATURE_SETTERMINAL             | \
+        LINEADDRFEATURE_SETUPCONF               | \
+        LINEADDRFEATURE_UNCOMPLETECALL          | \
+        LINEADDRFEATURE_UNPARK)
+
+#define AllAddrFeatures2_0                        \
+        (AllAddrFeatures1_0                     | \
+        LINEADDRFEATURE_PICKUPHELD              | \
+        LINEADDRFEATURE_PICKUPGROUP             | \
+        LINEADDRFEATURE_PICKUPDIRECT            | \
+        LINEADDRFEATURE_PICKUPWAITING           | \
+        LINEADDRFEATURE_FORWARDFWD              | \
+        LINEADDRFEATURE_FORWARDDND)
+
+#define AllBearerModes1_0                         \
+        (LINEBEARERMODE_VOICE                   | \
+        LINEBEARERMODE_SPEECH                   | \
+        LINEBEARERMODE_MULTIUSE                 | \
+        LINEBEARERMODE_DATA                     | \
+        LINEBEARERMODE_ALTSPEECHDATA            | \
+        LINEBEARERMODE_NONCALLSIGNALING)
+
+#define AllBearerModes1_4                         \
+        (AllBearerModes1_0                      | \
+        LINEBEARERMODE_PASSTHROUGH)
+
+#define AllBearerModes2_0                         \
+        (AllBearerModes1_4                      | \
+        LINEBEARERMODE_RESTRICTEDDATA)
+
+#define AllCallFeatures1_0                        \
+        (LINECALLFEATURE_ACCEPT                 | \
+        LINECALLFEATURE_ADDTOCONF               | \
+        LINECALLFEATURE_ANSWER                  | \
+        LINECALLFEATURE_BLINDTRANSFER           | \
+        LINECALLFEATURE_COMPLETECALL            | \
+        LINECALLFEATURE_COMPLETETRANSF          | \
+        LINECALLFEATURE_DIAL                    | \
+        LINECALLFEATURE_DROP                    | \
+        LINECALLFEATURE_GATHERDIGITS            | \
+        LINECALLFEATURE_GENERATEDIGITS          | \
+        LINECALLFEATURE_GENERATETONE            | \
+        LINECALLFEATURE_HOLD                    | \
+        LINECALLFEATURE_MONITORDIGITS           | \
+        LINECALLFEATURE_MONITORMEDIA            | \
+        LINECALLFEATURE_MONITORTONES            | \
+        LINECALLFEATURE_PARK                    | \
+        LINECALLFEATURE_PREPAREADDCONF          | \
+        LINECALLFEATURE_REDIRECT                | \
+        LINECALLFEATURE_REMOVEFROMCONF          | \
+        LINECALLFEATURE_SECURECALL              | \
+        LINECALLFEATURE_SENDUSERUSER            | \
+        LINECALLFEATURE_SETCALLPARAMS           | \
+        LINECALLFEATURE_SETMEDIACONTROL         | \
+        LINECALLFEATURE_SETTERMINAL             | \
+        LINECALLFEATURE_SETUPCONF               | \
+        LINECALLFEATURE_SETUPTRANSFER           | \
+        LINECALLFEATURE_SWAPHOLD                | \
+        LINECALLFEATURE_UNHOLD)
+
+#define AllCallFeatures1_4                        \
+        (AllCallFeatures1_0                     | \
+        LINECALLFEATURE_RELEASEUSERUSERINFO)
+
+#define AllCallFeatures2_0                        \
+        (AllCallFeatures1_4                     | \
+        LINECALLFEATURE_SETTREATMENT            | \
+        LINECALLFEATURE_SETQOS                  | \
+        LINECALLFEATURE_SETCALLDATA)
+
+#define AllCallFeaturesTwo                        \
+        (LINECALLFEATURE2_NOHOLDCONFERENCE      | \
+        LINECALLFEATURE2_ONESTEPTRANSFER        | \
+        LINECALLFEATURE2_COMPLCAMPON            | \
+        LINECALLFEATURE2_COMPLCALLBACK          | \
+        LINECALLFEATURE2_COMPLINTRUDE           | \
+        LINECALLFEATURE2_COMPLMESSAGE           | \
+        LINECALLFEATURE2_TRANSFERNORM           | \
+        LINECALLFEATURE2_TRANSFERCONF           | \
+        LINECALLFEATURE2_PARKDIRECT             | \
+        LINECALLFEATURE2_PARKNONDIRECT)
+
+#define AllLineFeatures1_0                        \
+        (LINEFEATURE_DEVSPECIFIC                | \
+        LINEFEATURE_DEVSPECIFICFEAT             | \
+        LINEFEATURE_FORWARD                     | \
+        LINEFEATURE_MAKECALL                    | \
+        LINEFEATURE_SETMEDIACONTROL             | \
+        LINEFEATURE_SETTERMINAL)
+
+#define AllLineFeatures2_0                        \
+        (AllLineFeatures1_0                     | \
+        LINEFEATURE_SETDEVSTATUS                | \
+        LINEFEATURE_FORWARDFWD                  | \
+        LINEFEATURE_FORWARDDND)
+
+#define AllMediaModes1_0                          \
+        (LINEMEDIAMODE_UNKNOWN                  | \
+        LINEMEDIAMODE_INTERACTIVEVOICE          | \
+        LINEMEDIAMODE_AUTOMATEDVOICE            | \
+        LINEMEDIAMODE_DATAMODEM                 | \
+        LINEMEDIAMODE_G3FAX                     | \
+        LINEMEDIAMODE_TDD                       | \
+        LINEMEDIAMODE_G4FAX                     | \
+        LINEMEDIAMODE_DIGITALDATA               | \
+        LINEMEDIAMODE_TELETEX                   | \
+        LINEMEDIAMODE_VIDEOTEX                  | \
+        LINEMEDIAMODE_TELEX                     | \
+        LINEMEDIAMODE_MIXED                     | \
+        LINEMEDIAMODE_ADSI)
+
+#define AllMediaModes1_4                          \
+        (AllMediaModes1_0                       | \
+        LINEMEDIAMODE_VOICEVIEW)
+
+#define AllHookSwitchDevs                         \
+        (PHONEHOOKSWITCHDEV_HANDSET             | \
+        PHONEHOOKSWITCHDEV_SPEAKER              | \
+        PHONEHOOKSWITCHDEV_HEADSET)
+
+#define AllHookSwitchModes                        \
+        (PHONEHOOKSWITCHMODE_ONHOOK             | \
+        PHONEHOOKSWITCHMODE_MIC                 | \
+        PHONEHOOKSWITCHMODE_SPEAKER             | \
+        PHONEHOOKSWITCHMODE_MICSPEAKER          | \
+        PHONEHOOKSWITCHMODE_UNKNOWN)
+
+#define AllPhoneFeatures                          \
+        (PHONEFEATURE_GETBUTTONINFO             | \
+        PHONEFEATURE_GETDATA                    | \
+        PHONEFEATURE_GETDISPLAY                 | \
+        PHONEFEATURE_GETGAINHANDSET             | \
+        PHONEFEATURE_GETGAINSPEAKER             | \
+        PHONEFEATURE_GETGAINHEADSET             | \
+        PHONEFEATURE_GETHOOKSWITCHHANDSET       | \
+        PHONEFEATURE_GETHOOKSWITCHSPEAKER       | \
+        PHONEFEATURE_GETHOOKSWITCHHEADSET       | \
+        PHONEFEATURE_GETLAMP                    | \
+        PHONEFEATURE_GETRING                    | \
+        PHONEFEATURE_GETVOLUMEHANDSET           | \
+        PHONEFEATURE_GETVOLUMESPEAKER           | \
+        PHONEFEATURE_GETVOLUMEHEADSET           | \
+        PHONEFEATURE_SETBUTTONINFO              | \
+        PHONEFEATURE_SETDATA                    | \
+        PHONEFEATURE_SETDISPLAY                 | \
+        PHONEFEATURE_SETGAINHANDSET             | \
+        PHONEFEATURE_SETGAINSPEAKER             | \
+        PHONEFEATURE_SETGAINHEADSET             | \
+        PHONEFEATURE_SETHOOKSWITCHHANDSET       | \
+        PHONEFEATURE_SETHOOKSWITCHSPEAKER       | \
+        PHONEFEATURE_SETHOOKSWITCHHEADSET       | \
+        PHONEFEATURE_SETLAMP                    | \
+        PHONEFEATURE_SETRING                    | \
+        PHONEFEATURE_SETVOLUMEHANDSET           | \
+        PHONEFEATURE_SETVOLUMESPEAKER           | \
+        PHONEFEATURE_SETVOLUMEHEADSET)
+
+typedef struct _DRVCALL
+{
+    DWORD                   dwKey;
+    LPVOID                  pLine;
+    HTAPICALL               htCall;
+    DWORD                   dwAddressID;
+
+    DWORD                   dwMediaMode;
+    DWORD                   dwBearerMode;
+    DWORD                   dwMinRate;
+    DWORD                   dwMaxRate;
+
+    LINEDIALPARAMS          DialParams;
+
+    DWORD                   dwTreatment;
+    DWORD                   dwCallState;
+    DWORD                   dwCallStateMode;
+    DWORD                   dwAppSpecific;
+
+    DWORD                   dwSendingFlowspecSize;
+    LPVOID                  pSendingFlowspec;
+    DWORD                   dwReceivingFlowspecSize;
+    LPVOID                  pReceivingFlowspec;
+
+    DWORD                   dwCallDataSize;
+    LPVOID                  pCallData;
+    struct _DRVCALL        *pPrev;
+    struct _DRVCALL        *pNext;
+
+    struct _DRVCALL        *pConfParent;
+    struct _DRVCALL        *pNextConfChild;
+    struct _DRVCALL        *pDestCall;
+    DWORD                   bConnectedToDestCall;
+
+    DWORD                   dwCallInstance;
+    DWORD                   dwGatherDigitsEndToEndID;
+    DWORD                   dwGenerateDigitsEndToEndID;
+    DWORD                   dwGenerateToneEndToEndID;
+
+    DWORD                   dwMonitorToneListID;
+    DWORD                   dwCallID;
+
+} DRVCALL, *PDRVCALL;
+
+
+typedef struct _DRVADDRESS
+{
+    DWORD                   dwNumCalls;
+    PDRVCALL                pCalls;
+
+} DRVADDRESS, *PDRVADDRESS;
+
+
+typedef struct _DRVLINE
+{
+    DWORD                   dwDeviceID;
+    HTAPILINE               htLine;
+    DWORD                   dwMediaModes;
+    PDRVADDRESS             aAddrs;
+
+} DRVLINE, *PDRVLINE;
+
+
+typedef struct _DRVLINETABLE
+{
+    DWORD                   dwNumTotalEntries;
+    DWORD                   dwNumUsedEntries;
+    struct _DRVLINETABLE   *pNext;
+    DRVLINE                 aLines[1];
+
+} DRVLINETABLE, *PDRVLINETABLE;
+
+
+typedef struct _DRVPHONE
+{
+    DWORD                   dwDeviceID;
+    HTAPIPHONE              htPhone;
+    DWORD                   dwHandsetGain;
+    DWORD                   dwSpeakerGain;
+
+    DWORD                   dwHeadsetGain;
+    DWORD                   dwHandsetHookSwitchMode;
+    DWORD                   dwSpeakerHookSwitchMode;
+    DWORD                   dwHeadsetHookSwitchMode;
+
+    DWORD                   dwHandsetVolume;
+    DWORD                   dwSpeakerVolume;
+    DWORD                   dwHeadsetVolume;
+    DWORD                   dwRingMode;
+
+    DWORD                   dwRingVolume;
+    DWORD                   dwLampMode;
+    DWORD                   dwDataSize;
+    LPVOID                  pData;
+
+    LPPHONEBUTTONINFO       pButtonInfo;
+    WCHAR                  *pDisplay;
+
+} DRVPHONE, *PDRVPHONE;
+
+
+typedef struct _DRVPHONETABLE
+{
+    DWORD                   dwNumTotalEntries;
+    DWORD                   dwNumUsedEntries;
+    struct _DRVPHONETABLE  *pNext;
+    DRVPHONE                aPhones[1];
+
+} DRVPHONETABLE, *PDRVPHONETABLE;
+
+
+typedef struct _ESPGLOBALS
+{
+    DWORD                   dwDebugOptions;
+    DWORD                   dwCompletionMode;
+    DWORD                   dwNumLines;
+    DWORD                   dwNumAddressesPerLine;
+
+    DWORD                   dwNumCallsPerAddress;
+    DWORD                   dwNumPhones;
+    DWORD                   dwSPIVersion;
+    CRITICAL_SECTION        CallListCritSec;
+
+    CRITICAL_SECTION        PhoneCritSec;
+    HICON                   hIconLine;
+    HICON                   hIconPhone;
+    LINEEVENT               pfnLineEvent;
+
+    PHONEEVENT              pfnPhoneEvent;
+    ASYNC_COMPLETION        pfnCompletion;
+    HPROVIDER               hProvider;
+    DWORD                   dwPermanentProviderID;
+
+    DWORD                   dwLineDeviceIDBase;
+    DWORD                   dwPhoneDeviceIDBase;
+    DWORD                   dwInitialNumLines;
+    DWORD                   dwInitialNumPhones;
+
+    PDRVLINETABLE           pLines;
+    PDRVPHONETABLE          pPhones;
+    BOOL                    bProviderShutdown;
+    HANDLE                  hAsyncEventQueueServiceThread;
+
+    HANDLE                  hAsyncEventsPendingEvent;
+    CRITICAL_SECTION        AsyncEventQueueCritSec;
+    DWORD                   dwNumTotalQueueEntries;
+    DWORD                   dwNumUsedQueueEntries;
+
+    DWORD                  *pAsyncRequestQueue;
+    DWORD                  *pAsyncRequestQueueIn;
+    DWORD                  *pAsyncRequestQueueOut;
+    CRITICAL_SECTION        DebugBufferCritSec;
+
+    DWORD                   dwDebugBufferTotalSize;
+    DWORD                   dwDebugBufferUsedSize;
+    char                   *pDebugBuffer;
+    char                   *pDebugBufferIn;
+
+    char                   *pDebugBufferOut;
+    CRITICAL_SECTION        EventBufferCritSec;
+    DWORD                   dwEventBufferTotalSize;
+    DWORD                   dwEventBufferUsedSize;
+
+    char                   *pEventBuffer;
+    char                   *pEventBufferIn;
+    char                   *pEventBufferOut;
+
+} ESPGLOBALS, *PESPGLOBALS;
+
+
+typedef struct _LOOKUP
+{
+    DWORD                   dwVal;
+    char                   *lpszVal;
+
+} LOOKUP, *PLOOKUP;
+
+
+typedef struct _ASYNC_REQUEST_INFO
+{
+    FARPROC                 pfnPostProcessProc;
+    DWORD                   dwRequestID;
+    LONG                    lResult;
+    DWORD                   dwParam1;
+
+    DWORD                   dwParam2;
+    DWORD                   dwParam3;
+    DWORD                   dwParam4;
+    DWORD                   dwParam5;
+
+    DWORD                   dwParam6;
+    DWORD                   dwParam7;
+    DWORD                   dwParam8;
+    char                   *pszFuncName;
+
+} ASYNC_REQUEST_INFO, far *PASYNC_REQUEST_INFO;
+
+
+typedef void (FAR PASCAL *POSTPROCESSPROC)(PASYNC_REQUEST_INFO, BOOL);
+
+
+typedef struct _FUNC_PARAM
+{
+    char                    *lpszVal;
+    DWORD                   dwVal;
+    PLOOKUP                 pLookup;
+
+} FUNC_PARAM, *PFUNC_PARAM;
+
+
+typedef struct _FUNC_INFO
+{
+    char                   *pszFuncName;
+    DWORD                   bAsync;
+    DWORD                   dwNumParams;
+    PFUNC_PARAM             aParams;
+
+    POSTPROCESSPROC         pfnPostProcessProc;
+    PASYNC_REQUEST_INFO     pAsyncReqInfo;
+    LONG                    lResult;
+
+} FUNC_INFO, *PFUNC_INFO;
+
+typedef struct _EVENT_PARAM
+{
+    char far           *szName;
+
+    DWORD               dwType;
+
+    DWORD               dwValue;
+
+    union
+    {
+        PLOOKUP         pLookup;
+
+        char far       *buf;
+
+        LPVOID          ptr;
+
+        DWORD           dwDefValue;
+
+    };
+
+} EVENT_PARAM, far *PEVENT_PARAM;
+
+
+typedef struct _EVENT_PARAM_HEADER
+{
+    DWORD               dwNumParams;
+
+    LPSTR               pszDlgTitle;
+
+    DWORD               dwEventType;
+
+    PEVENT_PARAM        aParams;
+
+} EVENT_PARAM_HEADER, far *PEVENT_PARAM_HEADER;
+
+
+
+
+#if DBG
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+DWORD   gdwDebugLevel;
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
+
+BOOL
+Prolog(
+    PFUNC_INFO pInfo
+    );
+
+LONG
+Epilog(
+    PFUNC_INFO pInfo
+    );
+
+void
+PASCAL
+DoCompletion(
+    PASYNC_REQUEST_INFO pAsyncRequestInfo,
+    BOOL                bAsync
+    );
+
+LONG
+PASCAL
+SetCallState(
+    PDRVCALL pCall,
+    DWORD    dwExpectedCallInstance,
+    DWORD    dwValidCurrentStates,
+    DWORD    dwNewCallState,
+    DWORD    dwNewCallStateMode,
+    BOOL     bSendStateMsgToExe
+    );
+
+void
+PASCAL
+WriteEventBuffer(
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3,
+    DWORD   dwParam4,
+    DWORD   dwParam5,
+    DWORD   dwParam6
+    );
+
+LPVOID
+DrvAlloc(
+    size_t numBytes
+    );
+
+void
+DrvFree(
+    LPVOID  p
+    );
+
+LONG
+PASCAL
+AllocCall(
+    PDRVLINE            pLine,
+    HTAPICALL           htCall,
+    LPLINECALLPARAMS    pCallParams,
+    PDRVCALL           *ppCall
+    );
+
+void
+PASCAL
+FreeCall(
+    PDRVCALL    pCall,
+    DWORD       dwExpectedCallInstance
+    );
+
+PDRVLINE
+PASCAL
+GetLineFromID(
+    DWORD   dwDeviceID
+    );
+
+PDRVPHONE
+PASCAL
+GetPhoneFromID(
+    DWORD   dwDeviceID
+    );
+
+BOOL
+WINAPI
+_CRT_INIT(
+    HINSTANCE   hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    );
+
+VOID
+ShowStr(
+    BOOL    bAlertApp,
+    char   *format,
+    ...
+    );
+
+void
+PASCAL
+SendLineEvent(
+    PDRVLINE    pLine,
+    PDRVCALL    pCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+void
+PASCAL
+SendPhoneEvent(
+    PDRVPHONE   pPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
diff --git a/private/tapi/dev/sp/esp.new/tsp/esp.rc b/private/tapi/dev/sp/esp.new/tsp/esp.rc
new file mode 100644
index 000000000..4c0a4be90
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/esp.rc
@@ -0,0 +1,38 @@
+#include "windows.h"
+#include "esp.h"
+
+LINE_ICON   ICON  DISCARDABLE  "PHONE.ICO"
+PHONE_ICON  ICON  DISCARDABLE  "LINE.ICO"
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 205, 192
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+FONT 8, "MS Shell Dlg"
+BEGIN
+    LTEXT           "Parameters:",55,4,6,42,7
+    LISTBOX         IDC_LIST1,4,16,100,148,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Value:",56,116,6,30,7
+    COMBOBOX        IDC_COMBO1,116,16,80,47,CBS_SIMPLE | CBS_AUTOHSCROLL |
+                    CBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Options:",57,116,66,40,9
+    LISTBOX         IDC_LIST2,116,75,80,89,LBS_MULTIPLESEL | 
+                    LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,116,171,36,14
+    PUSHBUTTON      "Cancel",IDCANCEL,160,171,37,14
+END
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Economical Service Provider"
+#define VER_INTERNALNAME_STR        "esp"
+#define VER_ORIGINALFILENAME_STR    "ESP32.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/esp.new/tsp/esp32.def b/private/tapi/dev/sp/esp.new/tsp/esp32.def
new file mode 100644
index 000000000..e99da9648
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/esp32.def
@@ -0,0 +1,113 @@
+LIBRARY     ESP32
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept
+        TSPI_lineAddToConference
+        TSPI_lineAnswer
+        TSPI_lineBlindTransfer
+        TSPI_lineClose
+        TSPI_lineCloseCall
+        TSPI_lineCompleteCall
+        TSPI_lineCompleteTransfer
+        TSPI_lineConditionalMediaDetection
+        TSPI_lineDevSpecific
+        TSPI_lineDevSpecificFeature
+        TSPI_lineDial
+        TSPI_lineDrop
+        TSPI_lineForward
+        TSPI_lineGatherDigits
+        TSPI_lineGenerateDigits
+        TSPI_lineGenerateTone
+        TSPI_lineGetAddressCaps
+        TSPI_lineGetAddressID
+        TSPI_lineGetAddressStatus
+        TSPI_lineGetCallAddressID
+        TSPI_lineGetCallInfo
+        TSPI_lineGetCallStatus
+        TSPI_lineGetDevCaps
+        TSPI_lineGetDevConfig
+        TSPI_lineGetExtensionID
+        TSPI_lineGetIcon
+        TSPI_lineGetID
+        TSPI_lineGetLineDevStatus
+        TSPI_lineGetNumAddressIDs
+        TSPI_lineHold
+        TSPI_lineMakeCall
+        TSPI_lineMonitorDigits
+        TSPI_lineMonitorMedia
+        TSPI_lineMonitorTones
+        TSPI_lineNegotiateExtVersion
+        TSPI_lineNegotiateTSPIVersion
+        TSPI_lineOpen
+        TSPI_linePark
+        TSPI_linePickup
+        TSPI_linePrepareAddToConference
+        TSPI_lineRedirect
+        TSPI_lineReleaseUserUserInfo
+        TSPI_lineRemoveFromConference
+        TSPI_lineSecureCall
+        TSPI_lineSelectExtVersion
+        TSPI_lineSendUserUserInfo
+        TSPI_lineSetAppSpecific
+        TSPI_lineSetCallData
+        TSPI_lineSetCallParams
+        TSPI_lineSetCallQualityOfService
+        TSPI_lineSetCallTreatment
+        TSPI_lineSetCurrentLocation
+        TSPI_lineSetDefaultMediaDetection
+        TSPI_lineSetDevConfig
+        TSPI_lineSetLineDevStatus
+        TSPI_lineSetMediaControl
+        TSPI_lineSetMediaMode
+        TSPI_lineSetStatusMessages
+        TSPI_lineSetTerminal
+        TSPI_lineSetupConference
+        TSPI_lineSetupTransfer
+        TSPI_lineSwapHold
+        TSPI_lineUncompleteCall
+        TSPI_lineUnhold
+        TSPI_lineUnpark
+        TSPI_phoneClose
+        TSPI_phoneDevSpecific
+        TSPI_phoneGetButtonInfo
+        TSPI_phoneGetData
+        TSPI_phoneGetDevCaps
+        TSPI_phoneGetDisplay
+        TSPI_phoneGetExtensionID
+        TSPI_phoneGetGain
+        TSPI_phoneGetHookSwitch
+        TSPI_phoneGetIcon
+        TSPI_phoneGetID
+        TSPI_phoneGetLamp
+        TSPI_phoneGetRing
+        TSPI_phoneGetStatus
+        TSPI_phoneGetVolume
+        TSPI_phoneNegotiateExtVersion
+        TSPI_phoneNegotiateTSPIVersion
+        TSPI_phoneOpen
+        TSPI_phoneSelectExtVersion
+        TSPI_phoneSetButtonInfo
+        TSPI_phoneSetData
+        TSPI_phoneSetDisplay
+        TSPI_phoneSetGain
+        TSPI_phoneSetHookSwitch
+        TSPI_phoneSetLamp
+        TSPI_phoneSetRing
+        TSPI_phoneSetStatusMessages
+        TSPI_phoneSetVolume
+        TSPI_providerConfig
+        TSPI_providerCreateLineDevice
+        TSPI_providerCreatePhoneDevice
+        TSPI_providerEnumDevices
+        TSPI_providerFreeDialogInstance
+        TSPI_providerGenericDialogData
+        TSPI_providerInit
+        TSPI_providerInstall
+        TSPI_providerRemove
+        TSPI_providerShutdown
+        TSPI_providerUIIdentify
+
+        ValuesDlgProc
diff --git a/private/tapi/dev/sp/esp.new/tsp/intrface.h b/private/tapi/dev/sp/esp.new/tsp/intrface.h
new file mode 100644
index 000000000..041131a33
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/intrface.h
@@ -0,0 +1,67 @@
+#define SHOW_FUNC_ENTRY                         0x00000001
+#define SHOW_PARAMETERS                         0x00000002
+#define SHOW_FUNC_EXIT                          0x00000004
+#define SHOW_EVENT_NOTIFICATIONS                0x00000008
+#define SHOW_COMPLETION_NOTIFICATIONS           0x00000010
+#define MANUAL_RESULTS                          0x00000020
+
+#define DEF_DEBUG_OPTIONS                       SHOW_FUNC_ENTRY
+
+#define COMPLETE_ASYNC_EVENTS_SYNCHRONOUSLY     0L
+#define COMPLETE_ASYNC_EVENTS_ASYNCHRONOUSLY    1L
+#define COMPLETE_ASYNC_EVENTS_SYNC_AND_ASYNC    2L
+#define COMPLETE_ASYNC_EVENTS_MANUALLY          3L
+
+#define DEF_COMPLETION_MODE                     2L
+
+#define DEF_NUM_LINES                           3
+#define DEF_NUM_ADDRS_PER_LINE                  2
+#define DEF_NUM_CALLS_PER_ADDR                  1
+#define DEF_NUM_PHONES                          2
+#define DEF_SPI_VERSION                         0x20000
+
+#define WIDGETTYPE_LINE                         0L
+#define WIDGETTYPE_CALL                         1L
+#define WIDGETTYPE_PHONE                        2L
+#define WIDGETTYPE_ASYNCREQUEST                 3L
+#define WIDGETTYPE_STARTUP                      4L
+
+typedef struct _WIDGETEVENT
+{
+    DWORD                   dwWidgetID;
+
+    DWORD                   dwWidgetType;       // WIDGETYPE_*
+
+    union
+    {
+        DWORD               hdXxx;              // hdXxx (NULL for AsyncReq)
+
+        DWORD               dwNumLines;
+
+        DWORD               pAsyncReqInfo;
+    };
+
+    union
+    {
+        DWORD               htXxx;             // htXxx (NULL for AsyncReq)
+
+        DWORD               dwNumPhones;
+    };
+
+    union
+    {
+        DWORD               dwCallState;
+
+        DWORD               dwRequestType;      // func ord for lookup
+
+        DWORD               dwLineDeviceIDBase;
+    };
+
+    union
+    {
+        DWORD               dwCallAddressID;
+
+        DWORD               dwPhoneDeviceIDBase;
+    };
+
+} WIDGETEVENT, *PWIDGETEVENT;
diff --git a/private/tapi/dev/sp/esp.new/tsp/line.ico b/private/tapi/dev/sp/esp.new/tsp/line.ico
new file mode 100644
index 000000000..6c2186e09
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/line.ico
diff --git a/private/tapi/dev/sp/esp.new/tsp/makefile b/private/tapi/dev/sp/esp.new/tsp/makefile
new file mode 100644
index 000000000..23524cb99
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/makefile
@@ -0,0 +1,11 @@
+!ifndef NTMAKEENV
+NTMAKEENV=.
+!endif
+
+
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/esp.new/tsp/phone.ico b/private/tapi/dev/sp/esp.new/tsp/phone.ico
new file mode 100644
index 000000000..ee34203e3
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/phone.ico
diff --git a/private/tapi/dev/sp/esp.new/tsp/sources b/private/tapi/dev/sp/esp.new/tsp/sources
new file mode 100644
index 000000000..409908852
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/sources
@@ -0,0 +1,60 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=esp32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=tsp
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\gdi32.lib    \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib   \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib
+
+C_DEFINES=-DTAPI_NT=1
+
+DLLBASE=0x60000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=esp.c      \
+        espidl_s.c \
+        vars.c     \
+        esp.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/esp.new/tsp/vars.c b/private/tapi/dev/sp/esp.new/tsp/vars.c
new file mode 100644
index 000000000..337a1dd7d
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/vars.c
@@ -0,0 +1,445 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    vars.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    18-Sep-1995
+
+Revision History:
+
+
+Notes:
+
+--*/
+
+
+#include "esp.h"
+
+
+char        szTab[]          = "    ";
+char        szhdLine[]       = "hdLine";
+char        szhdCall[]       = "hdCall";
+char        szdwSize[]       = "dwSize";
+char        szCallUp[]       = "^^^^";
+char        szEspTsp[]       = "esp.tsp";
+char        szhdPhone[]      = "hdPhone";
+char        szProvider[]     = "Provider";
+WCHAR       szESPUIDLL[]     = L"espui.dll";
+char        szhwndOwner[]    = "hwndOwner";
+char        szMySection[]    = "ESP32";
+char        szProviders[]    = "Providers";
+char        szProviderID[]   = "ProviderID";
+char        szdwDeviceID[]   = "dwDeviceID";
+char        szdwRequestID[]  = "dwRequestID";
+char        szTelephonIni[]  = "telephon.ini";
+char        szlpCallParams[] = "lpCallParams";
+char        szNumProviders[] = "NumProviders";
+char        szNextProviderID[] = "NextProviderID";
+char        szProviderFilename[] = "ProviderFileName";
+char        szdwPermanentProviderID[] = "dwPermanentProviderID";
+
+#if DBG
+DWORD       gdwDebugLevel;
+#endif
+
+HANDLE      ghInstance;
+HANDLE      ghDebugOutputEvent;
+HANDLE      ghShutdownEvent;
+HANDLE      ghWidgetEventsEvent;
+
+ESPGLOBALS  gESPGlobals;
+
+LOOKUP  aAddressStates[] =
+{
+    { LINEADDRESSSTATE_OTHER           ,"OTHER"              },
+    { LINEADDRESSSTATE_DEVSPECIFIC     ,"DEVSPECIFIC"        },
+    { LINEADDRESSSTATE_INUSEZERO       ,"INUSEZERO"          },
+    { LINEADDRESSSTATE_INUSEONE        ,"INUSEONE"           },
+    { LINEADDRESSSTATE_INUSEMANY       ,"INUSEMANY"          },
+    { LINEADDRESSSTATE_NUMCALLS        ,"NUMCALLS"           },
+    { LINEADDRESSSTATE_FORWARD         ,"FORWARD"            },
+    { LINEADDRESSSTATE_TERMINALS       ,"TERMINALS"          },
+    { LINEADDRESSSTATE_CAPSCHANGE      ,"CAPSCHANGE"         },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aBearerModes[] =
+{
+    { LINEBEARERMODE_VOICE             ,"VOICE"              },
+    { LINEBEARERMODE_SPEECH            ,"SPEECH"             },
+    { LINEBEARERMODE_MULTIUSE          ,"MULTIUSE"           },
+    { LINEBEARERMODE_DATA              ,"DATA"               },
+    { LINEBEARERMODE_ALTSPEECHDATA     ,"ALTSPEECHDATA"      },
+    { LINEBEARERMODE_NONCALLSIGNALING  ,"NONCALLSIGNALING"   },
+    { LINEBEARERMODE_PASSTHROUGH       ,"PASSTHROUGH"        },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aButtonModes[] =
+{
+    { PHONEBUTTONMODE_DUMMY            ,"DUMMY"              },
+    { PHONEBUTTONMODE_CALL             ,"CALL"               },
+    { PHONEBUTTONMODE_FEATURE          ,"FEATURE"            },
+    { PHONEBUTTONMODE_KEYPAD           ,"KEYPAD"             },
+    { PHONEBUTTONMODE_LOCAL            ,"LOCAL"              },
+    { PHONEBUTTONMODE_DISPLAY          ,"DISPLAY"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aButtonStates[] =
+{
+    { PHONEBUTTONSTATE_UP              ,"UP"                 },
+    { PHONEBUTTONSTATE_DOWN            ,"DOWN"               },
+    { PHONEBUTTONSTATE_UNKNOWN         ,"UNKNOWN"            },
+    { PHONEBUTTONSTATE_UNAVAIL         ,"UNAVAIL"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aCallInfoStates[] =
+{
+    { LINECALLINFOSTATE_OTHER          ,"OTHER"              },
+    { LINECALLINFOSTATE_DEVSPECIFIC    ,"DEVSPECIFIC"        },
+    { LINECALLINFOSTATE_BEARERMODE     ,"BEARERMODE"         },
+    { LINECALLINFOSTATE_RATE           ,"RATE"               },
+    { LINECALLINFOSTATE_MEDIAMODE      ,"MEDIAMODE"          },
+    { LINECALLINFOSTATE_APPSPECIFIC    ,"APPSPECIFIC"        },
+    { LINECALLINFOSTATE_CALLID         ,"CALLID"             },
+    { LINECALLINFOSTATE_RELATEDCALLID  ,"RELATEDCALLID"      },
+    { LINECALLINFOSTATE_ORIGIN         ,"ORIGIN"             },
+    { LINECALLINFOSTATE_REASON         ,"REASON"             },
+    { LINECALLINFOSTATE_COMPLETIONID   ,"COMPLETIONID"       },
+    { LINECALLINFOSTATE_NUMOWNERINCR   ,"NUMOWNERINCR"       },
+    { LINECALLINFOSTATE_NUMOWNERDECR   ,"NUMOWNERDECR"       },
+    { LINECALLINFOSTATE_NUMMONITORS    ,"NUMMONITORS"        },
+    { LINECALLINFOSTATE_TRUNK          ,"TRUNK"              },
+    { LINECALLINFOSTATE_CALLERID       ,"CALLERID"           },
+    { LINECALLINFOSTATE_CALLEDID       ,"CALLEDID"           },
+    { LINECALLINFOSTATE_CONNECTEDID    ,"CONNECTEDID"        },
+    { LINECALLINFOSTATE_REDIRECTIONID  ,"REDIRECTIONID"      },
+    { LINECALLINFOSTATE_REDIRECTINGID  ,"REDIRECTINGID"      },
+    { LINECALLINFOSTATE_DISPLAY        ,"DISPLAY"            },
+    { LINECALLINFOSTATE_USERUSERINFO   ,"USERUSERINFO"       },
+    { LINECALLINFOSTATE_HIGHLEVELCOMP  ,"HIGHLEVELCOMP"      },
+    { LINECALLINFOSTATE_LOWLEVELCOMP   ,"LOWLEVELCOMP"       },
+    { LINECALLINFOSTATE_CHARGINGINFO   ,"CHARGINGINFO"       },
+    { LINECALLINFOSTATE_TERMINAL       ,"TERMINAL"           },
+    { LINECALLINFOSTATE_DIALPARAMS     ,"DIALPARAMS"         },
+    { LINECALLINFOSTATE_MONITORMODES   ,"MONITORMODES"       },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aCallSelects[] =
+{
+    { LINECALLSELECT_LINE              ,"LINE"               },
+    { LINECALLSELECT_ADDRESS           ,"ADDRESS"            },
+    { LINECALLSELECT_CALL              ,"CALL"               },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aCallStates[] =
+{
+    { LINECALLSTATE_IDLE               ,"IDLE"               },
+    { LINECALLSTATE_OFFERING           ,"OFFERING"           },
+    { LINECALLSTATE_ACCEPTED           ,"ACCEPTED"           },
+    { LINECALLSTATE_DIALTONE           ,"DIALTONE"           },
+    { LINECALLSTATE_DIALING            ,"DIALING"            },
+    { LINECALLSTATE_RINGBACK           ,"RINGBACK"           },
+    { LINECALLSTATE_BUSY               ,"BUSY"               },
+    { LINECALLSTATE_SPECIALINFO        ,"SPECIALINFO"        },
+    { LINECALLSTATE_CONNECTED          ,"CONNECTED"          },
+    { LINECALLSTATE_PROCEEDING         ,"PROCEEDING"         },
+    { LINECALLSTATE_ONHOLD             ,"ONHOLD"             },
+    { LINECALLSTATE_CONFERENCED        ,"CONFERENCED"        },
+    { LINECALLSTATE_ONHOLDPENDCONF     ,"ONHOLDPENDCONF"     },
+    { LINECALLSTATE_ONHOLDPENDTRANSFER ,"ONHOLDPENDTRANSFER" },
+    { LINECALLSTATE_DISCONNECTED       ,"DISCONNECTED"       },
+    { LINECALLSTATE_UNKNOWN            ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aDigitModes[] =
+{
+    { LINEDIGITMODE_PULSE              ,"PULSE"              },
+    { LINEDIGITMODE_DTMF               ,"DTMF"               },
+    { LINEDIGITMODE_DTMFEND            ,"DTMFEND"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aHookSwitchDevs[] =
+{
+    { PHONEHOOKSWITCHDEV_HANDSET       ,"HANDSET"            },
+    { PHONEHOOKSWITCHDEV_SPEAKER       ,"SPEAKER"            },
+    { PHONEHOOKSWITCHDEV_HEADSET       ,"HEADSET"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aHookSwitchModes[] =
+{
+    { PHONEHOOKSWITCHMODE_ONHOOK       ,"ONHOOK"             },
+    { PHONEHOOKSWITCHMODE_MIC          ,"MIC"                },
+    { PHONEHOOKSWITCHMODE_SPEAKER      ,"SPEAKER"            },
+    { PHONEHOOKSWITCHMODE_MICSPEAKER   ,"MICSPEAKER"         },
+    { PHONEHOOKSWITCHMODE_UNKNOWN      ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aLampModes[] =
+{
+    { PHONELAMPMODE_DUMMY              ,"DUMMY"              },
+    { PHONELAMPMODE_OFF                ,"OFF"                },
+    { PHONELAMPMODE_STEADY             ,"STEADY"             },
+    { PHONELAMPMODE_WINK               ,"WINK"               },
+    { PHONELAMPMODE_FLASH              ,"FLASH"              },
+    { PHONELAMPMODE_FLUTTER            ,"FLUTTER"            },
+    { PHONELAMPMODE_BROKENFLUTTER      ,"BROKENFLUTTER"      },
+    { PHONELAMPMODE_UNKNOWN            ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aLineStates[] =
+{
+    { LINEDEVSTATE_OTHER               ,"OTHER"              },
+    { LINEDEVSTATE_RINGING             ,"RINGING"            },
+    { LINEDEVSTATE_CONNECTED           ,"CONNECTED"          },
+    { LINEDEVSTATE_DISCONNECTED        ,"DISCONNECTED"       },
+    { LINEDEVSTATE_MSGWAITON           ,"MSGWAITON"          },
+    { LINEDEVSTATE_MSGWAITOFF          ,"MSGWAITOFF"         },
+    { LINEDEVSTATE_INSERVICE           ,"INSERVICE"          },
+    { LINEDEVSTATE_OUTOFSERVICE        ,"OUTOFSERVICE"       },
+    { LINEDEVSTATE_MAINTENANCE         ,"MAINTENANCE"        },
+    { LINEDEVSTATE_OPEN                ,"OPEN"               },
+    { LINEDEVSTATE_CLOSE               ,"CLOSE"              },
+    { LINEDEVSTATE_NUMCALLS            ,"NUMCALLS"           },
+    { LINEDEVSTATE_NUMCOMPLETIONS      ,"NUMCOMPLETIONS"     },
+    { LINEDEVSTATE_TERMINALS           ,"TERMINALS"          },
+    { LINEDEVSTATE_ROAMMODE            ,"ROAMMODE"           },
+    { LINEDEVSTATE_BATTERY             ,"BATTERY"            },
+    { LINEDEVSTATE_SIGNAL              ,"SIGNAL"             },
+    { LINEDEVSTATE_DEVSPECIFIC         ,"DEVSPECIFIC"        },
+    { LINEDEVSTATE_REINIT              ,"REINIT"             },
+    { LINEDEVSTATE_LOCK                ,"LOCK"               },
+    { LINEDEVSTATE_CAPSCHANGE          ,"CAPSCHANGE"         },
+    { LINEDEVSTATE_CONFIGCHANGE        ,"CONFIGCHANGE"       },
+    { LINEDEVSTATE_TRANSLATECHANGE     ,"TRANSLATECHANGE"    },
+    { LINEDEVSTATE_COMPLCANCEL         ,"COMPLCANCEL"        },
+    { LINEDEVSTATE_REMOVED             ,"REMOVED"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aMediaModes[] =
+{
+    { LINEMEDIAMODE_UNKNOWN            ,"UNKNOWN"            },
+    { LINEMEDIAMODE_INTERACTIVEVOICE   ,"INTERACTIVEVOICE"   },
+    { LINEMEDIAMODE_AUTOMATEDVOICE     ,"AUTOMATEDVOICE"     },
+    { LINEMEDIAMODE_DATAMODEM          ,"DATAMODEM"          },
+    { LINEMEDIAMODE_G3FAX              ,"G3FAX"              },
+    { LINEMEDIAMODE_TDD                ,"TDD"                },
+    { LINEMEDIAMODE_G4FAX              ,"G4FAX"              },
+    { LINEMEDIAMODE_DIGITALDATA        ,"DIGITALDATA"        },
+    { LINEMEDIAMODE_TELETEX            ,"TELETEX"            },
+    { LINEMEDIAMODE_VIDEOTEX           ,"VIDEOTEX"           },
+    { LINEMEDIAMODE_TELEX              ,"TELEX"              },
+    { LINEMEDIAMODE_MIXED              ,"MIXED"              },
+    { LINEMEDIAMODE_ADSI               ,"ADSI"               },
+    { LINEMEDIAMODE_VOICEVIEW          ,"VOICEVIEW"          },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aPhoneStates[] =
+{
+    { PHONESTATE_OTHER                 ,"OTHER"              },
+    { PHONESTATE_CONNECTED             ,"CONNECTED"          },
+    { PHONESTATE_DISCONNECTED          ,"DISCONNECTED"       },
+    { PHONESTATE_OWNER                 ,"OWNER"              },
+    { PHONESTATE_MONITORS              ,"MONITORS"           },
+    { PHONESTATE_DISPLAY               ,"DISPLAY"            },
+    { PHONESTATE_LAMP                  ,"LAMP"               },
+    { PHONESTATE_RINGMODE              ,"RINGMODE"           },
+    { PHONESTATE_RINGVOLUME            ,"RINGVOLUME"         },
+    { PHONESTATE_HANDSETHOOKSWITCH     ,"HANDSETHOOKSWITCH"  },
+    { PHONESTATE_HANDSETVOLUME         ,"HANDSETVOLUME"      },
+    { PHONESTATE_HANDSETGAIN           ,"HANDSETGAIN"        },
+    { PHONESTATE_SPEAKERHOOKSWITCH     ,"SPEAKERHOOKSWITCH"  },
+    { PHONESTATE_SPEAKERVOLUME         ,"SPEAKERVOLUME"      },
+    { PHONESTATE_SPEAKERGAIN           ,"SPEAKERGAIN"        },
+    { PHONESTATE_HEADSETHOOKSWITCH     ,"HEADSETHOOKSWITCH"  },
+    { PHONESTATE_HEADSETVOLUME         ,"HEADSETVOLUME"      },
+    { PHONESTATE_HEADSETGAIN           ,"HEADSETGAIN"        },
+    { PHONESTATE_SUSPEND               ,"SUSPEND"            },
+    { PHONESTATE_RESUME                ,"RESUME"             },
+    { PHONESTATE_DEVSPECIFIC           ,"DEVSPECIFIC"        },
+    { PHONESTATE_REINIT                ,"REINIT"             },
+    { PHONESTATE_CAPSCHANGE            ,"CAPSCHANGE"         },
+    { PHONESTATE_REMOVED               ,"REMOVED"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aTerminalModes[] =
+{
+    { LINETERMMODE_BUTTONS             ,"BUTTONS"            },
+    { LINETERMMODE_LAMPS               ,"LAMPS"              },
+    { LINETERMMODE_DISPLAY             ,"DISPLAY"            },
+    { LINETERMMODE_RINGER              ,"RINGER"             },
+    { LINETERMMODE_HOOKSWITCH          ,"HOOKSWITCH"         },
+    { LINETERMMODE_MEDIATOLINE         ,"MEDIATOLINE"        },
+    { LINETERMMODE_MEDIAFROMLINE       ,"MEDIAFROMLINE"      },
+    { LINETERMMODE_MEDIABIDIRECT       ,"MEDIABIDIRECT"      },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aToneModes[] =
+{
+    { LINETONEMODE_CUSTOM              ,"CUSTOM"             },
+    { LINETONEMODE_RINGBACK            ,"RINGBACK"           },
+    { LINETONEMODE_BUSY                ,"BUSY"               },
+    { LINETONEMODE_BEEP                ,"BEEP"               },
+    { LINETONEMODE_BILLING             ,"BILLING"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP  aTransferModes[] =
+{
+    { LINETRANSFERMODE_TRANSFER        ,"TRANSFER"           },
+    { LINETRANSFERMODE_CONFERENCE      ,"CONFERENCE"         },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP aLineErrs[] =
+{
+    { 0                                ,"<SUCCESS>"              },
+    { LINEERR_ALLOCATED                ,"ALLOCATED"              },
+    { LINEERR_BADDEVICEID              ,"BADDEVICEID"            },
+    { LINEERR_BEARERMODEUNAVAIL        ,"BEARERMODEUNAVAIL"      },
+    { LINEERR_CALLUNAVAIL              ,"CALLUNAVAIL"            },
+    { LINEERR_COMPLETIONOVERRUN        ,"COMPLETIONOVERRUN"      },
+    { LINEERR_CONFERENCEFULL           ,"CONFERENCEFULL"         },
+    { LINEERR_DIALBILLING              ,"DIALBILLING"            },
+    { LINEERR_DIALDIALTONE             ,"DIALDIALTONE"           },
+    { LINEERR_DIALPROMPT               ,"DIALPROMPT"             },
+    { LINEERR_DIALQUIET                ,"DIALQUIET"              },
+    { LINEERR_INCOMPATIBLEAPIVERSION   ,"INCOMPATIBLEAPIVERSION" },
+    { LINEERR_INCOMPATIBLEEXTVERSION   ,"INCOMPATIBLEEXTVERSION" },
+    { LINEERR_INIFILECORRUPT           ,"INIFILECORRUPT"         },
+    { LINEERR_INUSE                    ,"INUSE"                  },
+    { LINEERR_INVALADDRESS             ,"INVALADDRESS"           },
+    { LINEERR_INVALADDRESSID           ,"INVALADDRESSID"         },
+    { LINEERR_INVALADDRESSMODE         ,"INVALADDRESSMODE"       },
+    { LINEERR_INVALADDRESSSTATE        ,"INVALADDRESSSTATE"      },
+    { LINEERR_INVALAPPHANDLE           ,"INVALAPPHANDLE"         },
+    { LINEERR_INVALAPPNAME             ,"INVALAPPNAME"           },
+    { LINEERR_INVALBEARERMODE          ,"INVALBEARERMODE"        },
+    { LINEERR_INVALCALLCOMPLMODE       ,"INVALCALLCOMPLMODE"     },
+    { LINEERR_INVALCALLHANDLE          ,"INVALCALLHANDLE"        },
+    { LINEERR_INVALCALLPARAMS          ,"INVALCALLPARAMS"        },
+    { LINEERR_INVALCALLPRIVILEGE       ,"INVALCALLPRIVILEGE"     },
+    { LINEERR_INVALCALLSELECT          ,"INVALCALLSELECT"        },
+    { LINEERR_INVALCALLSTATE           ,"INVALCALLSTATE"         },
+    { LINEERR_INVALCALLSTATELIST       ,"INVALCALLSTATELIST"     },
+    { LINEERR_INVALCARD                ,"INVALCARD"              },
+    { LINEERR_INVALCOMPLETIONID        ,"INVALCOMPLETIONID"      },
+    { LINEERR_INVALCONFCALLHANDLE      ,"INVALCONFCALLHANDLE"    },
+    { LINEERR_INVALCONSULTCALLHANDLE   ,"INVALCONSULTCALLHANDLE" },
+    { LINEERR_INVALCOUNTRYCODE         ,"INVALCOUNTRYCODE"       },
+    { LINEERR_INVALDEVICECLASS         ,"INVALDEVICECLASS"       },
+    { LINEERR_INVALDEVICEHANDLE        ,"INVALDEVICEHANDLE"      },
+    { LINEERR_INVALDIALPARAMS          ,"INVALDIALPARAMS"        },
+    { LINEERR_INVALDIGITLIST           ,"INVALDIGITLIST"         },
+    { LINEERR_INVALDIGITMODE           ,"INVALDIGITMODE"         },
+    { LINEERR_INVALDIGITS              ,"INVALDIGITS"            },
+    { LINEERR_INVALEXTVERSION          ,"INVALEXTVERSION"        },
+    { LINEERR_INVALGROUPID             ,"INVALGROUPID"           },
+    { LINEERR_INVALLINEHANDLE          ,"INVALLINEHANDLE"        },
+    { LINEERR_INVALLINESTATE           ,"INVALLINESTATE"         },
+    { LINEERR_INVALLOCATION            ,"INVALLOCATION"          },
+    { LINEERR_INVALMEDIALIST           ,"INVALMEDIALIST"         },
+    { LINEERR_INVALMEDIAMODE           ,"INVALMEDIAMODE"         },
+    { LINEERR_INVALMESSAGEID           ,"INVALMESSAGEID"         },
+    { LINEERR_INVALPARAM               ,"INVALPARAM"             },
+    { LINEERR_INVALPARKID              ,"INVALPARKID"            },
+    { LINEERR_INVALPARKMODE            ,"INVALPARKMODE"          },
+    { LINEERR_INVALPOINTER             ,"INVALPOINTER"           },
+    { LINEERR_INVALPRIVSELECT          ,"INVALPRIVSELECT"        },
+    { LINEERR_INVALRATE                ,"INVALRATE"              },
+    { LINEERR_INVALREQUESTMODE         ,"INVALREQUESTMODE"       },
+    { LINEERR_INVALTERMINALID          ,"INVALTERMINALID"        },
+    { LINEERR_INVALTERMINALMODE        ,"INVALTERMINALMODE"      },
+    { LINEERR_INVALTIMEOUT             ,"INVALTIMEOUT"           },
+    { LINEERR_INVALTONE                ,"INVALTONE"              },
+    { LINEERR_INVALTONELIST            ,"INVALTONELIST"          },
+    { LINEERR_INVALTONEMODE            ,"INVALTONEMODE"          },
+    { LINEERR_INVALTRANSFERMODE        ,"INVALTRANSFERMODE"      },
+    { LINEERR_LINEMAPPERFAILED         ,"LINEMAPPERFAILED"       },
+    { LINEERR_NOCONFERENCE             ,"NOCONFERENCE"           },
+    { LINEERR_NODEVICE                 ,"NODEVICE"               },
+    { LINEERR_NODRIVER                 ,"NODRIVER"               },
+    { LINEERR_NOMEM                    ,"NOMEM"                  },
+    { LINEERR_NOREQUEST                ,"NOREQUEST"              },
+    { LINEERR_NOTOWNER                 ,"NOTOWNER"               },
+    { LINEERR_NOTREGISTERED            ,"NOTREGISTERED"          },
+    { LINEERR_OPERATIONFAILED          ,"OPERATIONFAILED"        },
+    { LINEERR_OPERATIONUNAVAIL         ,"OPERATIONUNAVAIL"       },
+    { LINEERR_RATEUNAVAIL              ,"RATEUNAVAIL"            },
+    { LINEERR_RESOURCEUNAVAIL          ,"RESOURCEUNAVAIL"        },
+    { LINEERR_REQUESTOVERRUN           ,"REQUESTOVERRUN"         },
+    { LINEERR_STRUCTURETOOSMALL        ,"STRUCTURETOOSMALL"      },
+    { LINEERR_TARGETNOTFOUND           ,"TARGETNOTFOUND"         },
+    { LINEERR_TARGETSELF               ,"TARGETSELF"             },
+    { LINEERR_UNINITIALIZED            ,"UNINITIALIZED"          },
+    { LINEERR_USERUSERINFOTOOBIG       ,"USERUSERINFOTOOBIG"     },
+    { LINEERR_REINIT                   ,"REINIT"                 },
+    { LINEERR_ADDRESSBLOCKED           ,"ADDRESSBLOCKED"         },
+    { LINEERR_BILLINGREJECTED          ,"BILLINGREJECTED"        },
+    { LINEERR_INVALFEATURE             ,"INVALFEATURE"           },
+    { LINEERR_NOMULTIPLEINSTANCE       ,"NOMULTIPLEINSTANCE"     },
+    { 0xffffffff                       ,""                       }
+};
+
+
+LOOKUP aPhoneErrs[] =
+{
+    { 0                                ,"<SUCCESS>"              },
+    { PHONEERR_ALLOCATED               ,"ALLOCATED"              },
+    { PHONEERR_BADDEVICEID             ,"BADDEVICEID"            },
+    { PHONEERR_INCOMPATIBLEAPIVERSION  ,"INCOMPATIBLEAPIVERSION" },
+    { PHONEERR_INCOMPATIBLEEXTVERSION  ,"INCOMPATIBLEEXTVERSION" },
+    { PHONEERR_INIFILECORRUPT          ,"INIFILECORRUPT"         },
+    { PHONEERR_INUSE                   ,"INUSE"                  },
+    { PHONEERR_INVALAPPHANDLE          ,"INVALAPPHANDLE"         },
+    { PHONEERR_INVALAPPNAME            ,"INVALAPPNAME"           },
+    { PHONEERR_INVALBUTTONLAMPID       ,"INVALBUTTONLAMPID"      },
+    { PHONEERR_INVALBUTTONMODE         ,"INVALBUTTONMODE"        },
+    { PHONEERR_INVALBUTTONSTATE        ,"INVALBUTTONSTATE"       },
+    { PHONEERR_INVALDATAID             ,"INVALDATAID"            },
+    { PHONEERR_INVALDEVICECLASS        ,"INVALDEVICECLASS"       },
+    { PHONEERR_INVALEXTVERSION         ,"INVALEXTVERSION"        },
+    { PHONEERR_INVALHOOKSWITCHDEV      ,"INVALHOOKSWITCHDEV"     },
+    { PHONEERR_INVALHOOKSWITCHMODE     ,"INVALHOOKSWITCHMODE"    },
+    { PHONEERR_INVALLAMPMODE           ,"INVALLAMPMODE"          },
+    { PHONEERR_INVALPARAM              ,"INVALPARAM"             },
+    { PHONEERR_INVALPHONEHANDLE        ,"INVALPHONEHANDLE"       },
+    { PHONEERR_INVALPHONESTATE         ,"INVALPHONESTATE"        },
+    { PHONEERR_INVALPOINTER            ,"INVALPOINTER"           },
+    { PHONEERR_INVALPRIVILEGE          ,"INVALPRIVILEGE"         },
+    { PHONEERR_INVALRINGMODE           ,"INVALRINGMODE"          },
+    { PHONEERR_NODEVICE                ,"NODEVICE"               },
+    { PHONEERR_NODRIVER                ,"NODRIVER"               },
+    { PHONEERR_NOMEM                   ,"NOMEM"                  },
+    { PHONEERR_NOTOWNER                ,"NOTOWNER"               },
+    { PHONEERR_OPERATIONFAILED         ,"OPERATIONFAILED"        },
+    { PHONEERR_OPERATIONUNAVAIL        ,"OPERATIONUNAVAIL"       },
+    { PHONEERR_RESOURCEUNAVAIL         ,"RESOURCEUNAVAIL"        },
+    { PHONEERR_REQUESTOVERRUN          ,"REQUESTOVERRUN"         },
+    { PHONEERR_STRUCTURETOOSMALL       ,"STRUCTURETOOSMALL"      },
+    { PHONEERR_UNINITIALIZED           ,"UNINITIALIZED"          },
+    { PHONEERR_REINIT                  ,"REINIT"                 },
+    { 0xffffffff                       ,""                       }
+};
diff --git a/private/tapi/dev/sp/esp.new/tsp/vars.h b/private/tapi/dev/sp/esp.new/tsp/vars.h
new file mode 100644
index 000000000..712d66c65
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/tsp/vars.h
@@ -0,0 +1,76 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    vars.h
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    18-Sep-1995
+
+Revision History:
+
+
+Notes:
+
+--*/
+
+
+extern char         szTab[];
+extern char         szdwSize[];
+extern char         szhdLine[];
+extern char         szCallUp[];
+extern char         szEspTsp[];
+extern char         szhdCall[];
+extern char         szhdPhone[];
+extern char         szProvider[];
+extern WCHAR        szESPUIDLL[];
+extern char         szhwndOwner[];
+extern char         szMySection[];
+extern char         szProviders[];
+extern char         szdwDeviceID[];
+extern char         szProviderID[];
+extern char         szdwRequestID[];
+extern char         szTelephonIni[];
+extern char         szlpCallParams[];
+extern char         szNumProviders[];
+extern char         szNextProviderID[];
+extern char         szProviderFilename[];
+extern char         szdwPermanentProviderID[];
+
+#if DBG
+extern DWORD        gdwDebugLevel;
+#endif
+
+extern HANDLE       ghInstance;
+extern HANDLE       ghDebugOutputEvent;
+extern HANDLE       ghShutdownEvent;
+extern HANDLE       ghWidgetEventsEvent;
+
+extern LOOKUP       aAddressStates[];
+extern LOOKUP       aBearerModes[];
+extern LOOKUP       aButtonModes[];
+extern LOOKUP       aButtonStates[];
+extern LOOKUP       aCallInfoStates[];
+extern LOOKUP       aCallSelects[];
+extern LOOKUP       aCallStates[];
+extern LOOKUP       aDigitModes[];
+extern LOOKUP       aHookSwitchDevs[];
+extern LOOKUP       aHookSwitchModes[];
+extern LOOKUP       aLampModes[];
+extern LOOKUP       aLineStates[];
+extern LOOKUP       aMediaModes[];
+extern LOOKUP       aPhoneStates[];
+extern LOOKUP       aTerminalModes[];
+extern LOOKUP       aToneModes[];
+extern LOOKUP       aTransferModes[];
+extern LOOKUP       aLineErrs[];
+extern LOOKUP       aPhoneErrs[];
+
+extern ESPGLOBALS   gESPGlobals;
diff --git a/private/tapi/dev/sp/esp.new/ui/espui.c b/private/tapi/dev/sp/esp.new/ui/espui.c
new file mode 100644
index 000000000..d223ef1bb
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/ui/espui.c
@@ -0,0 +1,788 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    espui.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    30-Sep-1995
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+
+#include "windows.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "stdarg.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+#include "string.h"
+
+
+typedef struct _MYDIALOGPARAMS
+{
+    char               *pszTitle;
+
+    char               *pszDataIn;
+
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback;
+
+    DWORD               dwObjectID;
+
+    DWORD               dwObjectType;
+
+    LONG                lResult;
+
+} MYDIALOGPARAMS, *PMYDIALOGPARAMS;
+
+
+HINSTANCE   ghInstance;
+char        szMySection[] = "ESP32";
+char        szShowProviderXxxDlgs[] = "ShowProviderXxxDlgs";
+
+#if DBG
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+DWORD   gdwDebugLevel;
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
+
+BOOL
+CALLBACK
+GenericDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+BOOL
+WINAPI
+_CRT_INIT(
+    HINSTANCE   hDLL,
+    DWORD       dwReason,
+    LPVOID      lpReserved
+    );
+
+LONG
+PASCAL
+ProviderInstall(
+    char   *pszProviderName,
+    BOOL    bNoMultipleInstance
+    );
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    static HANDLE hInitEvent;
+
+
+    if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+    {
+        OutputDebugString ("ESPUI: DllMain: _CRT_INIT() failed\n\r");
+    }
+
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+
+#if DBG
+
+    {
+        HKEY    hKey;
+        DWORD   dwDataSize, dwDataType;
+        TCHAR   szTelephonyKey[] =
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                szEsp32DebugLevel[] = "Esp32DebugLevel";
+
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            szTelephonyKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hKey
+            );
+
+        dwDataSize = sizeof (DWORD);
+        gdwDebugLevel=0;
+
+        RegQueryValueEx(
+            hKey,
+            szEsp32DebugLevel,
+            0,
+            &dwDataType,
+            (LPBYTE) &gdwDebugLevel,
+            &dwDataSize
+            );
+
+        RegCloseKey (hKey);
+    }
+
+#endif
+        ghInstance = hDLL;
+        break;
+
+    case DLL_PROCESS_DETACH:
+
+        break;
+    }
+
+    return TRUE;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+    char buf[64];
+    MYDIALOGPARAMS params =
+    {
+        "TUISPI_lineConfigDialog",
+        buf,
+        lpfnUIDLLCallback,
+        dwDeviceID,
+        TUISPIDLL_OBJECT_LINEID,
+        0
+    };
+
+
+    wsprintf(
+        buf,
+        "devID=%d, devClass='%ws'",
+        dwDeviceID,
+        (lpszDeviceClass ? lpszDeviceClass : L"")
+        );
+
+    DialogBoxParam(
+        ghInstance,
+        MAKEINTRESOURCE(100),
+        hwndOwner,
+        (DLGPROC) GenericDlgProc,
+        (LPARAM) &params
+        );
+
+    return params.lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialogEdit(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+    char buf[64];
+    MYDIALOGPARAMS params =
+    {
+        "TUISPI_lineConfigDialogEdit",
+        buf,
+        lpfnUIDLLCallback,
+        dwDeviceID,
+        TUISPIDLL_OBJECT_LINEID,
+        0
+    };
+
+
+    wsprintf(
+        buf,
+        "devID=%d, devClass='%ws'",
+        dwDeviceID,
+        (lpszDeviceClass ? lpszDeviceClass : L"")
+        );
+
+    DialogBoxParam(
+        ghInstance,
+        MAKEINTRESOURCE(100),
+        hwndOwner,
+        (DLGPROC) GenericDlgProc,
+        (LPARAM) &params
+        );
+
+    return params.lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_phoneConfigDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+    char buf[64];
+    MYDIALOGPARAMS params =
+    {
+        "TUISPI_phoneConfigDialog",
+        buf,
+        lpfnUIDLLCallback,
+        dwDeviceID,
+        TUISPIDLL_OBJECT_PHONEID,
+        0
+    };
+
+
+    wsprintf(
+        buf,
+        "devID=%d, devClass='%ws'",
+        dwDeviceID,
+        (lpszDeviceClass ? lpszDeviceClass : L"")
+        );
+
+    DialogBoxParam(
+        ghInstance,
+        MAKEINTRESOURCE(100),
+        hwndOwner,
+        (DLGPROC) GenericDlgProc,
+        (LPARAM) &params
+        );
+
+    if (params.lResult)
+    {
+        params.lResult = PHONEERR_OPERATIONFAILED;
+    }
+
+    return params.lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerConfig(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    char buf[64];
+    MYDIALOGPARAMS params =
+    {
+        "TUISPI_providerConfig",
+        buf,
+        lpfnUIDLLCallback,
+        dwPermanentProviderID,
+        TUISPIDLL_OBJECT_PROVIDERID,
+        0
+    };
+
+
+    wsprintf (buf, "providerID=%d", dwPermanentProviderID);
+
+    DialogBoxParam(
+        ghInstance,
+        MAKEINTRESOURCE(100),
+        hwndOwner,
+        (DLGPROC) GenericDlgProc,
+        (LPARAM) &params
+        );
+
+    return params.lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerGenericDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HTAPIDIALOGINSTANCE htDlgInst,
+    LPVOID              lpParams,
+    DWORD               dwSize,
+    HANDLE              hEvent
+    )
+{
+    char buf[80];
+    MYDIALOGPARAMS params =
+    {
+        "TUISPI_providerGenericDialog",
+        buf,
+        lpfnUIDLLCallback,
+        (DWORD) htDlgInst,
+        TUISPIDLL_OBJECT_DIALOGINSTANCE
+    };
+
+
+    SetEvent (hEvent);
+
+    wsprintf(
+        buf,
+        "htDlgInst=x%x, lpParams='%s', dwSize=x%x",
+        htDlgInst,
+        lpParams,
+        dwSize
+        );
+
+    DialogBoxParam(
+        ghInstance,
+        MAKEINTRESOURCE(100),
+        NULL,
+        (DLGPROC) GenericDlgProc,
+        (LPARAM) &params
+        );
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerGenericDialogData(
+    HTAPIDIALOGINSTANCE htDlgInst,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    DBGOUT((3, "TUISPI_providerGenericDialogData: enter"));
+    DBGOUT((
+        3,
+        "\thtDlgInst=x%x, lpParams='%s', dwSize=x%x",
+        htDlgInst,
+        lpParams,
+        dwSize
+        ));
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerInstall(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    char            buf[64];
+    LONG            lResult;
+    MYDIALOGPARAMS  params =
+    {
+        "TUISPI_providerInstall",
+        buf,
+        lpfnUIDLLCallback,
+        dwPermanentProviderID,
+        TUISPIDLL_OBJECT_PROVIDERID,
+        0
+    };
+    BOOL    bShowDlgs = (BOOL) GetProfileInt(
+                szMySection,
+                szShowProviderXxxDlgs,
+                0
+                );
+
+
+    if ((lResult = ProviderInstall ("esp32.tsp", TRUE)) == 0)
+    {
+        if (bShowDlgs)
+        {
+            wsprintf (buf, "providerID=%d", dwPermanentProviderID);
+
+            DialogBoxParam(
+                ghInstance,
+                MAKEINTRESOURCE(100),
+                hwndOwner,
+                (DLGPROC) GenericDlgProc,
+                (LPARAM) &params
+                );
+
+            lResult = params.lResult;
+        }
+    }
+    else
+    {
+        if (bShowDlgs)
+        {
+            MessageBox(
+                hwndOwner,
+                "ESP32 already installed",
+                "ESP32.TSP",
+                MB_OK
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerRemove(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    LONG    lResult = 0;
+
+
+    if (GetProfileInt (szMySection, szShowProviderXxxDlgs, 0) != 0)
+    {
+        char buf[64];
+        MYDIALOGPARAMS params =
+        {
+            "TUISPI_providerRemove",
+            buf,
+            lpfnUIDLLCallback,
+            dwPermanentProviderID,
+            TUISPIDLL_OBJECT_PROVIDERID,
+            0
+        };
+
+
+        wsprintf (buf, "providerID=%d", dwPermanentProviderID);
+
+        DialogBoxParam(
+            ghInstance,
+            MAKEINTRESOURCE(100),
+            hwndOwner,
+            (DLGPROC) GenericDlgProc,
+            (LPARAM) &params
+            );
+
+        lResult = params.lResult;
+    }
+
+    return lResult;
+}
+
+
+BOOL
+CALLBACK
+GenericDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        PMYDIALOGPARAMS pParams = (PMYDIALOGPARAMS) lParam;
+
+
+        SetWindowText (hwnd, pParams->pszTitle);
+        SetDlgItemText (hwnd, 104, pParams->pszDataIn);
+        SetWindowLong (hwnd, GWL_USERDATA, (LONG) pParams);
+
+        break;
+    }
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+        case IDCANCEL:
+        {
+            PMYDIALOGPARAMS pParams;
+
+
+            pParams = (PMYDIALOGPARAMS) GetWindowLong (hwnd, GWL_USERDATA);
+
+            pParams->lResult = (LOWORD(wParam) == IDOK ?
+                0 : LINEERR_OPERATIONFAILED);
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        case 102: // send data
+        {
+            #define BUFSIZE 32
+
+            char buf[BUFSIZE] = "espui data";
+            PMYDIALOGPARAMS pParams;
+
+
+            pParams = (PMYDIALOGPARAMS) GetWindowLong (hwnd, GWL_USERDATA);
+
+            (*pParams->lpfnUIDLLCallback)(
+                pParams->dwObjectID,
+                pParams->dwObjectType,
+                (LPVOID) buf,
+                BUFSIZE
+                );
+
+            DBGOUT((3, buf));
+
+            break;
+        }
+        }
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+LONG
+PASCAL
+ProviderInstall(
+    char   *pszProviderName,
+    BOOL    bNoMultipleInstance
+    )
+{
+    LONG    lResult;
+
+
+    //
+    // If only one installation instance of this provider is
+    // allowed then we want to check the provider list to see
+    // if the provider is already installed
+    //
+
+    if (bNoMultipleInstance)
+    {
+        LONG                (WINAPI *pfnGetProviderList)();
+        DWORD               dwTotalSize, i;
+        HINSTANCE           hTapi32;
+        LPLINEPROVIDERLIST  pProviderList;
+        LPLINEPROVIDERENTRY pProviderEntry;
+
+
+        //
+        // Load Tapi32.dll & get a pointer to the lineGetProviderList
+        // func.  We could just statically link with Tapi32.lib and
+        // avoid the hassle (and this wouldn't have any adverse
+        // performance effects because of the fact that this
+        // implementation has a separate ui dll that runs only on the
+        // client context), but a provider who implemented these funcs
+        // in it's TSP module would want to do an explicit load like
+        // we do here to prevent the performance hit of Tapi32.dll
+        // always getting loaded in Tapisrv.exe's context.
+        //
+
+        if (!(hTapi32 = LoadLibrary ("tapi32.dll")))
+        {
+            DBGOUT((
+                1,
+                "LoadLibrary(tapi32.dll) failed, err=%d",
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONFAILED;
+            goto ProviderInstall_return;
+        }
+
+        if (!((FARPROC) pfnGetProviderList = GetProcAddress(
+                hTapi32,
+                (LPCSTR) "lineGetProviderList"
+                )))
+        {
+            DBGOUT((
+                1,
+                "GetProcAddr(lineGetProviderList) failed, err=%d",
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONFAILED;
+            goto ProviderInstall_unloadTapi32;
+        }
+
+
+        //
+        // Loop until we get the full provider list
+        //
+
+        dwTotalSize = sizeof (LINEPROVIDERLIST);
+
+        goto ProviderInstall_allocProviderList;
+
+ProviderInstall_getProviderList:
+
+        if ((lResult = (*pfnGetProviderList)(0x00020000, pProviderList)) != 0)
+        {
+            goto ProviderInstall_freeProviderList;
+        }
+
+        if (pProviderList->dwNeededSize > pProviderList->dwTotalSize)
+        {
+            dwTotalSize = pProviderList->dwNeededSize;
+
+            LocalFree (pProviderList);
+
+ProviderInstall_allocProviderList:
+
+            if (!(pProviderList = LocalAlloc (LPTR, dwTotalSize)))
+            {
+                lResult = LINEERR_NOMEM;
+                goto ProviderInstall_unloadTapi32;
+            }
+
+            pProviderList->dwTotalSize = dwTotalSize;
+
+            goto ProviderInstall_getProviderList;
+        }
+
+
+        //
+        // Inspect the provider list entries to see if this provider
+        // is already installed
+        //
+
+        pProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) pProviderList) +
+            pProviderList->dwProviderListOffset);
+
+        for (i = 0; i < pProviderList->dwNumProviders; i++)
+        {
+            char   *pszInstalledProviderName = ((char *) pProviderList) +
+                        pProviderEntry->dwProviderFilenameOffset,
+                   *psz;
+
+
+            if ((psz = strrchr (pszInstalledProviderName, '\\')))
+            {
+                pszInstalledProviderName = psz + 1;
+            }
+
+            if (lstrcmpi (pszInstalledProviderName, pszProviderName) == 0)
+            {
+                lResult = LINEERR_NOMULTIPLEINSTANCE;
+                goto ProviderInstall_freeProviderList;
+            }
+
+            pProviderEntry++;
+        }
+
+
+        //
+        // If here then the provider isn't currently installed,
+        // so do whatever configuration stuff is necessary and
+        // indicate SUCCESS
+        //
+
+        lResult = 0;
+
+
+ProviderInstall_freeProviderList:
+
+        LocalFree (pProviderList);
+
+ProviderInstall_unloadTapi32:
+
+        FreeLibrary (hTapi32);
+    }
+    else
+    {
+        //
+        // Do whatever configuration stuff is necessary and return SUCCESS
+        //
+
+        lResult = 0;
+    }
+
+ProviderInstall_return:
+
+    return lResult;
+}
+
+
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[128] = "ESPUI: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        vsprintf (&buf[7],
+                  lpszFormat,
+                  ap
+                  );
+
+        strcat (buf, "\n");
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
diff --git a/private/tapi/dev/sp/esp.new/ui/espui.def b/private/tapi/dev/sp/esp.new/ui/espui.def
new file mode 100644
index 000000000..a87af28a6
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/ui/espui.def
@@ -0,0 +1,16 @@
+LIBRARY     ESPUI
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TUISPI_lineConfigDialog
+        TUISPI_lineConfigDialogEdit
+        TUISPI_phoneConfigDialog
+        TUISPI_providerConfig
+        TUISPI_providerGenericDialog
+        TUISPI_providerGenericDialogData
+        TUISPI_providerInstall
+        TUISPI_providerRemove
+
+        GenericDlgProc
diff --git a/private/tapi/dev/sp/esp.new/ui/espui.rc b/private/tapi/dev/sp/esp.new/ui/espui.rc
new file mode 100644
index 000000000..6aa4516c3
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/ui/espui.rc
@@ -0,0 +1,32 @@
+#include "windows.h"
+
+
+100 DIALOG 6, 18, 205, 67
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "TUISPI_providerGenericDialog"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    DEFPUSHBUTTON   "Success", IDOK, 20, 46, 40, 14
+    PUSHBUTTON      "Error", IDCANCEL, 80, 46, 40, 14
+    PUSHBUTTON      "Send data", 102, 140, 46, 40, 14
+    LTEXT           "Data in:", 103, 6, 10, 34, 8
+    EDITTEXT        104, 42, 9, 159, 12, ES_AUTOHSCROLL | ES_READONLY
+END
+
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Economical Service Provider Configuration"
+#define VER_INTERNALNAME_STR        "espui"
+#define VER_ORIGINALFILENAME_STR    "ESPUI.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/esp.new/ui/makefile b/private/tapi/dev/sp/esp.new/ui/makefile
new file mode 100644
index 000000000..23524cb99
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/ui/makefile
@@ -0,0 +1,11 @@
+!ifndef NTMAKEENV
+NTMAKEENV=.
+!endif
+
+
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/esp.new/ui/sources b/private/tapi/dev/sp/esp.new/ui/sources
new file mode 100644
index 000000000..1d6fc2b10
--- /dev/null
+++ b/private/tapi/dev/sp/esp.new/ui/sources
@@ -0,0 +1,56 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=espui
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=dll
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\gdi32.lib
+
+C_DEFINES=-DTAPI_NT=1
+
+DLLBASE=0x60000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=espui.c  \
+        espui.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/esp/esp.c b/private/tapi/dev/sp/esp/esp.c
new file mode 100644
index 000000000..30cf48b5d
--- /dev/null
+++ b/private/tapi/dev/sp/esp/esp.c
@@ -0,0 +1,9641 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    esp.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+
+Notes:
+
+    1. Regarding the SP filling in structures with variable length fields
+       (dwXxxSize/dwXxxOffset) : "The SP's variable size fields start
+       immediately after the fixed part of the data structure.  The order
+       of filling of the variable size fields owned by the SP is not
+       specified.  The SP can fill them in any order it desires.  Filling
+       should be contiguous, starting at the beginning of the variable
+       part." (Taken from Chapter 2 of the SPI Programmer's Guide.)
+
+    2. The cheesey hack in the MsgLoopInTAPIClientContext() function of
+       having an in-line (within the calling app context) msg loop should
+       NOT be implemented by any real service provider.  The only place a
+       real provider should have a msg loop (explicit or implicit [i.e. as
+       a result of calling DialogBox()]) is in one of the
+       TSPI_xxxConfigDialog[Edit] functions.  If you need a msg processing
+       context (for handling comm events or whatever) then start up a
+       companion exe- it's cheap & easy.
+
+       // BUGBUG no SendMessage's in calling app context either
+
+       Examples of problems with having a msg loop in a service provider
+       in the calling app context:
+
+           * A call to the 16-bit GetMessage() will return a msg that
+             has a 16-bit WPARAM.  If this msg is destined for a 32-bit
+             window, the high word of the WPARAM, which is 32-bit for
+             Win32 apps, will have been discarded. However, there is code
+             in the 16-bit system functions DialogBox(), MessageBox(), etc.
+             to deal with this and insure 32-bit WPARAM integrity.
+
+           * Applications can get re-entered when they don't expect it.
+             Consider an app that makes what it thinks will be an atomic
+             function call into TAPI; it waits to get the result back
+             before doing any manipulation of it's various data structures.
+             But in the meantime a service provider enters a Get\Dispatch
+             loop, which in turn causes the app's TapiCallback to be called
+             because there are some completion and/or async event
+             notification msgs available.
+
+
+--*/
+
+
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+#include "esp.h"
+#include "vars.h"
+
+
+HANDLE   hInst;
+LONG     cxList1, cxWnd;
+
+
+#ifdef WIN32
+HANDLE   ghMsgLoopThread = NULL;
+#endif
+
+char szdwRequestID[]  = "dwRequestID";
+char szdwDeviceID[]   = "dwDeviceID";
+char szhdLine[]       = "hdLine";
+char szhdCall[]       = "hdCall";
+char szhdPhone[]      = "hdPhone";
+char szdwSize[]       = "dwSize";
+char szlpCallParams[] = "lpCallParams";
+char szTab[]          = "    ";
+char szTelephonIni[]  = "telephon.ini";
+char szhwndOwner[]    = "hwndOwner";
+char szMySection[]    = "ESPExe";
+char szCallUp[]       = "^^^^";
+char szEspTsp[]       = "esp.tsp";
+char szProvider[]     = "Provider";
+char szProviders[]    = "Providers";
+char szProviderID[]   = "ProviderID";
+char szNumProviders[] = "NumProviders";
+char szNextProviderID[] = "NextProviderID";
+char szProviderFilename[] = "ProviderFileName";
+char szdwPermanentProviderID[] = "dwPermanentProviderID";
+
+static char far *aszDeviceClasses[] =
+{
+    "tapi/line",
+    "tapi/phone",
+    "wave",
+    "wave/in",
+    "wave/out",
+    "comm",
+    "comm/datamodem",
+    (char far *) NULL
+};
+
+void
+PASCAL
+SendLineEvent(
+    PDRVLINE    pLine,
+    PDRVCALL    pCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+void
+PASCAL
+SendPhoneEvent(
+    PDRVPHONE   pPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    );
+
+void
+PASCAL
+DoCompletion(
+    char far *lpszFuncName,
+    DWORD     dwRequestID,
+    LONG      lResult,
+    BOOL      bSync
+    );
+
+void
+PASCAL
+SetCallState(
+    PDRVCALL pCall,
+    DWORD    dwCallState,
+    DWORD    dwCallStateMode
+    );
+
+void
+UpdateTelephonIni(
+    DWORD dwPermanentProviderID
+    );
+
+void
+MsgLoopInTAPIClientContext(
+    HWND hwnd
+    );
+
+void
+SaveIniSettings(
+    void
+    );
+
+
+BOOL
+__loadds
+CALLBACK
+CallDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+#ifdef WIN32
+
+HANDLE ghShowStrBufMutex;
+
+
+BOOL
+WINAPI
+_CRT_INIT(
+    HINSTANCE   hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    );
+
+BOOL
+IsESPInstalled(
+    HWND    hwnd
+    );
+
+
+void
+MsgLoopThread(
+    void
+    )
+{
+    DllMsgLoop();
+
+    ExitThread (0);
+}
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    if (!_CRT_INIT (hInst, dwReason, lpReserved))
+    {
+        OutputDebugString ("ESP: DllMain: _CRT_INIT() failed\n\r");
+    }
+
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+
+        hInst = hDLL;
+
+        ghShowStrBufMutex = CreateMutex(
+            NULL,   // no security attrs
+            FALSE,  // unowned
+            NULL    // unnamed
+            );
+
+        break;
+
+    case DLL_PROCESS_DETACH:
+
+        CloseHandle (ghShowStrBufMutex);
+        break;
+
+    } // switch
+
+    return TRUE;
+}
+
+#else
+
+int
+FAR
+PASCAL
+LibMain(
+    HANDLE  hInstance,
+    WORD    wDataSegment,
+    WORD    wHeapSize,
+    LPSTR   lpszCmdLine
+    )
+{                      
+    hInst = hInstance;
+
+    return TRUE;
+}
+
+#endif
+
+
+//
+// We get a slough of C4047 (different levels of indrection) warnings down
+// below in the initialization of FUNC_PARAM structs as a result of the
+// real func prototypes having params that are types other than DWORDs,
+// so since these are known non-interesting warnings just turn them off
+//
+
+#pragma warning (disable:4047)
+
+
+//
+// --------------------------- TAPI_lineXxx funcs -----------------------------
+//
+
+void
+FAR
+PASCAL
+TSPI_lineAccept_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        SetCallState(
+            (PDRVCALL) pAsyncReqInfo->dwParam1,
+            LINECALLSTATE_ACCEPTED,
+            0
+            );
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info = { "lineAccept", ASYNC, 4, params, TSPI_lineAccept_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineAddToConference_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        PDRVCALL   pConfCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+        PDRVCALL   pConsultCall = (PDRVCALL) pAsyncReqInfo->dwParam2;
+
+
+        pConsultCall->pConfParent = pConfCall;
+        pConsultCall->pNextConfChild = pConfCall->pNextConfChild;
+
+        pConfCall->pNextConfChild = pConsultCall;
+
+        SetCallState (pConsultCall, LINECALLSTATE_CONFERENCED, 0);
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdConfCall,
+    HDRVCALL        hdConsultCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { "hdConfCall",     hdConfCall      },
+        { "hdConsultCall",  hdConsultCall   }
+    };
+    FUNC_INFO info = { "lineAddToConference", ASYNC, 3, params, TSPI_lineAddToConference_postProcess };
+    PDRVCALL pConfCall = (PDRVCALL) hdConfCall;
+    PDRVCALL pConsultCall = (PDRVCALL) hdConsultCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdConfCall;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) hdConsultCall;
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineAnswer_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        SetCallState(
+            (PDRVCALL) pAsyncReqInfo->dwParam1,
+            LINECALLSTATE_CONNECTED,
+            0
+            );
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info = { "lineAnswer", ASYNC, 4, params, TSPI_lineAnswer_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   }
+    };
+    FUNC_INFO info = { "lineBlindTransfer", ASYNC, 4, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE    hdLine
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine, hdLine  }
+    };
+    FUNC_INFO info = { "lineClose", SYNC, 1, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    //
+    // This is more of a "command" than a request, in that TAPI.DLL is
+    // going to consider the line closed whether we like it or not.
+    // Therefore we want to free up the line even if the user chooses
+    // to return an error.
+    //
+
+    if (!Prolog (&info))
+    {
+        // return (Epilog (&info));
+    }
+
+    pLine->htLine = (HTAPILINE) NULL;
+
+    //UpdateWidgetList();
+    PostUpdateWidgetListMsg();
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL    hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall, hdCall  }
+    };
+    FUNC_INFO info = { "lineCloseCall", SYNC, 1, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    //
+    // This is more of a "command" than a request, in that TAPI.DLL is
+    // going to consider the call closed whether we like it or not.
+    // Therefore we want to free up the call even if the user chooses
+    // to return an error.
+    //
+
+    if (!Prolog (&info))
+    {
+        // return (Epilog (&info));
+    }
+
+    FreeCall (pCall);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPDWORD         lpdwCompletionID,
+    DWORD           dwCompletionMode,
+    DWORD           dwMessageID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { szhdCall,             hdCall              },
+        { "lpdwCompletionID",   lpdwCompletionID    },
+        { "dwCompletionMode",   dwCompletionMode    },
+        { "dwMessageID",        dwMessageID         }
+    };
+    FUNC_INFO info = { "lineCompleteCall", ASYNC, 5, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineCompleteTransfer_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL   pConfCall    = (PDRVCALL) NULL;
+    PDRVCALL   pCall        = pAsyncReqInfo->dwParam1;
+    PDRVCALL   pConsultCall = pAsyncReqInfo->dwParam2;
+    HTAPICALL  htConfCall   = pAsyncReqInfo->dwParam3;
+    LPHDRVCALL lphdConfCall = pAsyncReqInfo->dwParam4;
+
+
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        if (htConfCall)
+        {
+            if ((pAsyncReqInfo->lResult = AllocCall (
+                    pCall->pLine,
+                    htConfCall,
+                    NULL,
+                    &pConfCall
+                    )) == 0)
+            {
+                *lphdConfCall = (HDRVCALL) pCall;
+            }
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        if (pConfCall)
+        {
+            SetCallState (pConfCall, LINECALLSTATE_CONNECTED, 0);
+            SetCallState (pCall, LINECALLSTATE_CONFERENCED, 0);
+            SetCallState (pConsultCall, LINECALLSTATE_CONFERENCED, 0);
+        }
+        else
+        {
+            SetCallState(
+                pCall,
+                LINECALLSTATE_DISCONNECTED,
+                LINEDISCONNECTMODE_NORMAL
+                );
+
+            SetCallState (pCall, LINECALLSTATE_IDLE, 0);
+
+            SetCallState(
+                pConsultCall,
+                LINECALLSTATE_DISCONNECTED,
+                LINEDISCONNECTMODE_NORMAL
+                );
+
+            SetCallState (pConsultCall, LINECALLSTATE_IDLE, 0);
+        }
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    HDRVCALL        hdConsultCall,
+    HTAPICALL       htConfCall,
+    LPHDRVCALL      lphdConfCall,
+    DWORD           dwTransferMode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdCall,         hdCall          },
+        { "hdConsultCall",  hdConsultCall   },
+        { "htConfCall",     htConfCall      },
+        { "lphdConfCall",   lphdConfCall    },
+        { "dwTransferMode", dwTransferMode, aTransferModes  }
+    };
+    FUNC_INFO info = { "lineCompleteTransfer", ASYNC, 6, params, TSPI_lineCompleteTransfer_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) hdConsultCall;
+
+    if (dwTransferMode == LINETRANSFERMODE_CONFERENCE)
+    {
+        info.pAsyncReqInfo->dwParam3 = (DWORD) htConfCall;
+        info.pAsyncReqInfo->dwParam4 = (DWORD) lphdConfCall;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine                      },
+        { "dwMediaModes",   dwMediaModes,   aMediaModes },
+        { szlpCallParams,   lpCallParams                }
+    };
+    FUNC_INFO info = { "lineConditionalMediaDetection", SYNC, 3, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { szhwndOwner,          hwndOwner       },
+        { "lpszDeviceClass",    lpszDeviceClass }
+    };
+    FUNC_INFO info = { "lineConfigDialog", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+#ifdef WIN32
+
+    //
+    // In Win32...
+    //
+
+    MessageBox(
+        hwndOwner,
+        "Config dlg for ESP line device",
+        "TSPI_lineConfigDialog",
+        MB_OK // | MB_SERVICE_NOTIFICATION
+        );
+
+#else
+
+    //
+    // Note: MessageBox() implements a get/dispatch msg loop which allows
+    //       other apps (or other windows within the calling app) to gain
+    //       focus.  Once these other windows/apps have focus, it's
+    //       possible that they will call into TAPI, and this service
+    //       provider could be re-entered.
+    //
+
+    MessageBox(
+        hwndOwner,
+        "Config dlg for ESP line device",
+        "TSPI_lineConfigDialog",
+        MB_OK
+        );
+#endif
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConfigDialogEdit(
+    DWORD       dwDeviceID,
+    HWND        hwndOwner,
+    LPCSTR      lpszDeviceClass,
+    LPVOID      lpDeviceConfigIn,
+    DWORD       dwSize,
+    LPVARSTRING lpDeviceConfigOut
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID          },
+        { szhwndOwner,          hwndOwner           },
+        { "lpszDeviceClass",    lpszDeviceClass     },
+        { "lpDeviceConfigIn",   lpDeviceConfigIn    },
+        { szdwSize,             dwSize              },
+        { "lpDeviceConfigOut",  lpDeviceConfigOut   }
+    };
+    FUNC_INFO   info = { "lineConfigDialogEdit", SYNC, 6, params };
+    static char szData[] = "device config out data";
+    DWORD       len;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+#ifdef WIN32
+
+    //
+    // In Win32...
+    //
+
+    MessageBox(
+        (HWND) NULL, // NOTE: if hwndOwner specified dlg never appears
+        "Config dlg for ESP line device",
+        "TSPI_lineConfigDialogEdit",
+        MB_OK | MB_SERVICE_NOTIFICATION
+        );
+
+#else
+
+    //
+    // Note: MessageBox() implements a get/dispatch msg loop which allows
+    //       other apps (or other windows within the calling app) to gain
+    //       focus.  Once these other windows/apps have focus, it's
+    //       possible that they will call into TAPI, and this service
+    //       provider could be re-entered.
+    //
+
+    MessageBox(
+        hwndOwner,
+        "Config dlg for ESP line device",
+        "TSPI_lineConfigDialogEdit",
+        MB_OK
+        );
+
+#endif
+
+    len = strlen (szData) + 1;
+
+    lpDeviceConfigOut->dwNeededSize = sizeof (VARSTRING) + len;
+
+    if (lpDeviceConfigOut->dwTotalSize >= lpDeviceConfigOut->dwNeededSize)
+    {
+        lpDeviceConfigOut->dwUsedSize = lpDeviceConfigOut->dwNeededSize;
+
+        lpDeviceConfigOut->dwStringFormat = STRINGFORMAT_BINARY;
+        lpDeviceConfigOut->dwStringSize   = len;
+        lpDeviceConfigOut->dwStringOffset = sizeof (VARSTRING);
+
+        strcpy ((char *)(lpDeviceConfigOut + 1), szData);
+    }
+    else
+    {
+        lpDeviceConfigOut->dwUsedSize = 3 * sizeof(DWORD);
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineDevSpecific_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    LPVOID lpParams = pAsyncReqInfo->dwParam1;
+    DWORD  dwSize   = pAsyncReqInfo->dwParam2;
+
+
+    if (pAsyncReqInfo->lResult == 0 && dwSize >= 22)
+    {
+        strcpy (lpParams, "ESP dev specific info");
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdLine,         hdLine          },
+        { "dwAddressID",    dwAddressID     },
+        { szhdCall,         hdCall          },
+        { "lpParams",       lpParams        },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        "lineDevSpecific",
+        ASYNC,
+        6,
+        params,
+        TSPI_lineDevSpecific_postProcess
+    };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = lpParams;
+    info.pAsyncReqInfo->dwParam2 = dwSize;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwFeature,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdLine,         hdLine          },
+        { "dwFeature",      dwFeature       },
+        { "lpParams",       lpParams        },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info =
+    {
+        "lineDevSpecificFeature",
+        ASYNC,
+        5,
+        params,
+        TSPI_lineDevSpecific_postProcess
+    };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = lpParams;
+    info.pAsyncReqInfo->dwParam2 = dwSize;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   }
+    };
+    FUNC_INFO info = { "lineDial", ASYNC, 4, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineDrop_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        SetCallState(
+            (PDRVCALL) pAsyncReqInfo->dwParam1,
+            LINECALLSTATE_IDLE,
+            0
+            );
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info = { "lineDrop", ASYNC, 4, params, TSPI_lineDrop_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+    return (Epilog (&info));
+}
+
+LONG
+TSPIAPI
+TSPI_lineDropOnClose(
+    HDRVCALL    hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall, hdCall  }
+    };
+    FUNC_INFO info = { "lineDropOnClose", SYNC, 1, params };
+    PDRVCALL   pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    //
+    // Don't bother indicating call state, TAPI will follow up with
+    // a CloseCall request regardless
+    //
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDropNoOwner(
+    HDRVCALL    hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall, hdCall  }
+    };
+    FUNC_INFO info = { "lineDropNoOwner", SYNC, 1, params };
+    PDRVCALL   pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    SetCallState ((PDRVCALL) hdCall, LINECALLSTATE_IDLE, 0);
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineForward_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL   pConsultCall;
+    PDRVLINE   pLine                = (PDRVLINE) pAsyncReqInfo->dwParam1;
+    BOOL       bAllAddresses        = (BOOL) pAsyncReqInfo->dwParam2;
+    DWORD      dwAddressID          = pAsyncReqInfo->dwParam3;
+    LPLINEFORWARDLIST lpForwardList = (LPLINEFORWARDLIST) pAsyncReqInfo->dwParam4;
+    DWORD      dwNumRingsNoAnswer   = pAsyncReqInfo->dwParam5;
+    HTAPICALL  htConsultCall        = (HTAPICALL)  pAsyncReqInfo->dwParam6;
+    LPHDRVCALL lphdConsultCall      = (LPHDRVCALL) pAsyncReqInfo->dwParam7;
+    LPLINECALLPARAMS lpCallParams   = (LPLINECALLPARAMS) pAsyncReqInfo->dwParam8;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall (
+                pLine,
+                htConsultCall,
+                lpCallParams,
+                &pConsultCall
+                )) == 0)
+        {
+            // BUGBUG deal w/ addr id
+
+            *lphdConsultCall = (HDRVCALL) pConsultCall;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState (pConsultCall, LINECALLSTATE_CONNECTED, 0);
+    }
+
+    if (lpForwardList)
+    {
+        DrvFree (lpForwardList);
+    }
+
+    if (lpCallParams)
+    {
+        DrvFree (lpCallParams);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { szhdLine,             hdLine              },
+        { "bAllAddresses",      bAllAddresses       },
+        { "dwAddressID",        dwAddressID         },
+        { "lpForwardList",      lpForwardList       },
+        { "dwNumRingsNoAnswer", dwNumRingsNoAnswer  },
+        { "htConsultCall",      htConsultCall       },
+        { "lphdConsultCall",    lphdConsultCall     },
+        { szlpCallParams,       lpCallParams        }
+    };
+    FUNC_INFO info = { "lineForward", ASYNC, 9, params, TSPI_lineForward_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdLine;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) bAllAddresses;
+    info.pAsyncReqInfo->dwParam3 = dwAddressID;
+
+    if (lpForwardList)
+    {
+        info.pAsyncReqInfo->dwParam4 = (DWORD) DrvAlloc(
+            (size_t) lpForwardList->dwTotalSize
+            );
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam4,
+            (void far *) lpForwardList,
+            (size_t) lpForwardList->dwTotalSize
+            );
+    }
+
+    info.pAsyncReqInfo->dwParam5 = dwNumRingsNoAnswer;
+    info.pAsyncReqInfo->dwParam6 = (DWORD) htConsultCall;
+    info.pAsyncReqInfo->dwParam7 = (DWORD) lphdConsultCall;
+
+    if (lpCallParams)
+    {
+        info.pAsyncReqInfo->dwParam8 = (DWORD) DrvAlloc(
+            (size_t) lpCallParams->dwTotalSize
+            );
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam8,
+            (void far *) lpCallParams,
+            (size_t) lpCallParams->dwTotalSize
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwEndToEndID,
+    DWORD       dwDigitModes,
+    LPSTR       lpsDigits,
+    DWORD       dwNumDigits,
+    LPCSTR      lpszTerminationDigits,
+    DWORD       dwFirstDigitTimeout,
+    DWORD       dwInterDigitTimeout
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,                 hdCall                  },
+        { "dwEndToEndID",           dwEndToEndID            },
+        { "dwDigitModes",           dwDigitModes,   aDigitModes },
+        { "lpsDigits",              lpsDigits               },
+        { "dwNumDigits",            dwNumDigits             },
+        { "lpszTerminationDigits",  lpszTerminationDigits   },
+        { "dwFirstDigitTimeout",    dwFirstDigitTimeout     },
+        { "dwInterDigitTimeout",    dwInterDigitTimeout     }
+    };
+    FUNC_INFO info = { "lineGatherDigits", SYNC, 8, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwEndToEndID,
+    DWORD       dwDigitMode,
+    LPCSTR      lpszDigits,
+    DWORD       dwDuration
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwEndToEndID",   dwEndToEndID    },
+        { "dwDigitMode",    dwDigitMode,    aDigitModes },
+        { "lpszDigits",     lpszDigits      },
+        { "dwDuration",     dwDuration      }
+    };
+    FUNC_INFO info = { "lineGenerateDigits", SYNC, 5, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwEndToEndID",   dwEndToEndID    },
+        { "dwToneMode",     dwToneMode, aToneModes  },
+        { "dwDuration",     dwDuration      },
+        { "dwNumTones",     dwNumTones      },
+        { "lpTones",        lpTones         }
+    };
+    FUNC_INFO info = { "lineGenerateTone", SYNC, 6, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD              dwDeviceID,
+    DWORD              dwAddressID,
+    DWORD              dwTSPIVersion,
+    DWORD              dwExtVersion,
+    LPLINEADDRESSCAPS  lpAddressCaps
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwAddressID",    dwAddressID     },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpAddressCaps",  lpAddressCaps   }
+    };
+    FUNC_INFO info = { "lineGetAddressCaps", SYNC, 5, params };
+    DWORD dwUsedSize;
+    PDRVLINE pLine = GetLine (dwDeviceID);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    if (dwAddressID >= pLine->LineDevCaps.dwNumAddresses)
+    {
+        info.lResult = LINEERR_INVALADDRESSID;
+        return (Epilog (&info));
+    }
+
+
+    //
+    // Figure out how much caps data to copy (don't bother with var length
+    // fields if there's not room enough for all of them)
+    //
+
+    if (lpAddressCaps->dwTotalSize >= pLine->LineAddrCaps.dwNeededSize)
+    {
+        dwUsedSize = pLine->LineAddrCaps.dwNeededSize;
+    }
+    else if (lpAddressCaps->dwTotalSize >= sizeof(LINEADDRESSCAPS))
+    {
+        dwUsedSize = sizeof(LINEADDRESSCAPS);
+    }
+    else // it's a 1.3 app looking for just fixed 1.3 data struct size
+    {
+        dwUsedSize = sizeof(LINEADDRESSCAPS) - sizeof(DWORD);
+    }
+
+    memcpy(
+        &lpAddressCaps->dwNeededSize,
+        &pLine->LineAddrCaps.dwNeededSize,
+        (size_t) dwUsedSize - 4 // - 4 since not overwriting dwTotalSize
+        );
+
+    lpAddressCaps->dwUsedSize = dwUsedSize;
+
+
+    //
+    // If there's no room for the var length fields then we need to zero
+    // out all the dwXxxSize fields; otherwise, fill in the address field
+    //
+
+    if (lpAddressCaps->dwTotalSize < pLine->LineAddrCaps.dwNeededSize)
+    {
+        //lpAddessCaps->dwAddressSize =
+        //lpAddessCaps->dwDevSpecificSize =
+        //lpAddessCaps->dwCompletionMsgTextSize = 0;
+    }
+    else
+    {
+        char far *p = ((char far *) lpAddressCaps) +
+            lpAddressCaps->dwAddressOffset;
+
+        wsprintf (p, "%ld.%ld", dwDeviceID, dwAddressID);
+
+        lpAddressCaps->dwAddressSize = strlen (p) + 1;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwAddressID,
+    DWORD       dwAddressMode,
+    LPCSTR      lpsAddress,
+    DWORD       dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine          },
+        { "lpdwAddressID",  lpdwAddressID   },
+        { "dwAddressMode",  dwAddressMode   },
+        { "lpsAddress",     lpsAddress      },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info = { "lineGetAddressID", SYNC, 5, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { "lpAddressStatus",    lpAddressStatus }
+    };
+    FUNC_INFO info = { "lineGetAddressStatus", SYNC, 3, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    if (lpAddressStatus->dwTotalSize >= pLine->LineAddrStatus.dwNeededSize)
+    {
+        memcpy(
+            &lpAddressStatus->dwNeededSize,
+            &pLine->LineAddrStatus.dwNeededSize,
+            pLine->LineAddrStatus.dwNeededSize  - sizeof (DWORD)
+            );
+    }
+    else
+    {
+        lpAddressStatus->dwNeededSize = pLine->LineAddrStatus.dwNeededSize;
+        lpAddressStatus->dwUsedSize   = 3 * sizeof (DWORD);
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL    hdCall,
+    LPDWORD     lpdwAddressID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "lpdwAddressID",  lpdwAddressID   }
+    };
+    FUNC_INFO info = { "lineGetCallAddressID", SYNC, 2, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    *lpdwAddressID = ((PDRVCALL) hdCall)->LineCallInfo.dwAddressID;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,     hdCall      },
+        { "lpCallInfo", lpCallInfo  }
+    };
+    FUNC_INFO info = { "lineGetCallInfo", SYNC, 2, params };
+    PDRVCALL  pCall = (PDRVCALL) hdCall;
+    DWORD     dwUsedSize;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    //
+    // Figure out how much data to copy (don't bother with var length fields
+    // if there's not room enough for all of them)
+    //
+
+    if (lpCallInfo->dwTotalSize >= pCall->LineCallInfo.dwNeededSize)
+    {
+        dwUsedSize = pCall->LineCallInfo.dwNeededSize;
+    }
+    else
+    {
+        dwUsedSize = sizeof(LINECALLINFO);
+    }
+
+
+    memcpy(
+        &lpCallInfo->dwNeededSize,
+        &pCall->LineCallInfo.dwNeededSize,
+        (size_t) dwUsedSize - 4 // - 4 since not overwriting dwTotalSize
+        );
+
+    lpCallInfo->dwUsedSize = dwUsedSize;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "lpCallStatus",   lpCallStatus    }
+    };
+    FUNC_INFO info = { "lineGetCallStatus", SYNC, 2, params };
+    PDRVCALL  pCall = (PDRVCALL) hdCall;
+    DWORD     dwDevSpecificSize = pCall->LineCallInfo.dwDevSpecificSize;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    lpCallStatus->dwUsedSize   = sizeof (LINECALLSTATUS);
+    lpCallStatus->dwNeededSize = sizeof (LINECALLSTATUS) + dwDevSpecificSize;
+
+    lpCallStatus->dwCallState     = pCall->dwCallState;
+    lpCallStatus->dwCallStateMode = pCall->dwCallStateMode;
+    lpCallStatus->dwCallFeatures  = pCall->dwCallFeatures;
+
+
+    //
+    // We're getting the DevSpecific field from the CalInfo
+    //
+
+    if (dwDevSpecificSize &&
+        (lpCallStatus->dwTotalSize >= lpCallStatus->dwNeededSize))
+    {
+        lpCallStatus->dwDevSpecificSize   = dwDevSpecificSize;
+        lpCallStatus->dwDevSpecificOffset = sizeof(LINECALLSTATUS);
+
+        strcpy(
+            ((char far *) lpCallStatus) + sizeof(LINECALLSTATUS),
+            ((char far *) &pCall->LineCallInfo) +
+                pCall->LineCallInfo.dwDevSpecificOffset
+            );
+
+        lpCallStatus->dwUsedSize = lpCallStatus->dwNeededSize;
+    }
+    else
+    {
+        lpCallStatus->dwDevSpecificSize   =
+        lpCallStatus->dwDevSpecificOffset = 0;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpLineDevCaps",  lpLineDevCaps   }
+    };
+    FUNC_INFO info = { "lineGetDevCaps", SYNC, 4, params };
+    DWORD dwUsedSize;
+    PDRVLINE pLine = GetLine (dwDeviceID);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    //
+    // Figure out how much caps data to copy (don't bother with var length
+    // fields if there's not room enough for all of them)
+    //
+
+    if (lpLineDevCaps->dwTotalSize >= pLine->LineDevCaps.dwNeededSize)
+    {
+        dwUsedSize = pLine->LineDevCaps.dwNeededSize;
+    }
+    else if (lpLineDevCaps->dwTotalSize >= sizeof(LINEDEVCAPS))
+    {
+        dwUsedSize = sizeof(LINEDEVCAPS);
+    }
+    else // it's a 1.3 app looking for just fixed 1.3 data struct size
+    {
+        dwUsedSize = sizeof(LINEDEVCAPS) - sizeof(DWORD);
+    }
+
+
+    memcpy(
+        &lpLineDevCaps->dwNeededSize,
+        &pLine->LineDevCaps.dwNeededSize,
+        (size_t) dwUsedSize - 4 // - 4 since not overwriting dwTotalSize
+        );
+
+    lpLineDevCaps->dwUsedSize = dwUsedSize;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD       dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCSTR      lpszDeviceClass
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpDeviceConfig",     lpDeviceConfig  },
+        { "lpszDeviceClass",    lpszDeviceClass }
+    };
+    FUNC_INFO info = { "lineGetDevConfig", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpExtensionID",  lpExtensionID   }
+    };
+    FUNC_INFO info = { "lineGetExtensionID", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    memcpy (lpExtensionID, &gLineExtID, sizeof(LINEEXTENSIONID));
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass },
+        { "lphIcon",            lphIcon         }
+    };
+    FUNC_INFO info = { "lineGetIcon", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    *lphIcon = ghIconLine;
+
+    return (Epilog (&info));
+}
+
+
+#ifdef WIN32
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE    hdLine,
+    DWORD       dwAddressID,
+    HDRVCALL    hdCall,
+    DWORD       dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+#else
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE    hdLine,
+    DWORD       dwAddressID,
+    HDRVCALL    hdCall,
+    DWORD       dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass
+    )
+#endif
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { szhdCall,             hdCall          },
+        { "dwSelect",           dwSelect,   aCallSelects    },
+        { "lpDeviceID",         lpDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass }
+#ifdef WIN32
+        ,{ "hTargetProcess",    hTargetProcess }
+#endif
+    };
+#ifdef WIN32
+    FUNC_INFO info = { "lineGetID", SYNC, 7, params };
+#else
+    FUNC_INFO info = { "lineGetID", SYNC, 6, params };
+#endif
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+    DWORD    i, dwDeviceID, dwNeededSize = sizeof(VARSTRING) + sizeof(DWORD);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    for (i = 0; aszDeviceClasses[i]; i++)
+    {
+        if (_stricmp (lpszDeviceClass, aszDeviceClasses[i]) == 0)
+        {
+            break;
+        }
+    }
+
+    if (!aszDeviceClasses[i])
+    {
+        info.lResult = LINEERR_NODEVICE;
+        return (Epilog (&info));
+    }
+
+    if (lpDeviceID->dwTotalSize < dwNeededSize)
+    {
+        lpDeviceID->dwNeededSize = dwNeededSize;
+        lpDeviceID->dwUsedSize = 3 * sizeof(DWORD);
+
+        return (Epilog (&info));
+    }
+
+    if (i == 0)
+    {
+        if (dwSelect == LINECALLSELECT_CALL)
+        {
+            dwDeviceID = pCall->pLine->dwDeviceID;
+        }
+        else
+        {
+            dwDeviceID = pLine->dwDeviceID;
+        }
+    }
+    else
+    {
+        if (gbShowLineGetIDDlg)
+        {
+            char szDlgTitle[64];
+            EVENT_PARAM params[] =
+            {
+                { "dwDeviceID", PT_DWORD, gdwDefLineGetIDID, 0 }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 1, szDlgTitle, XX_REQRESULTPOSTQUIT, params };
+            HWND hwnd;
+
+
+            if (strlen (lpszDeviceClass) > 20)
+            {
+                ((char far *)lpszDeviceClass)[19] = 0;
+            }
+
+            wsprintf(
+                szDlgTitle,
+                "TSPI_lineGetID: select ID for class '%s'",
+                lpszDeviceClass
+                );
+
+            hwnd = CreateDialogParam(
+                hInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) NULL,
+                (DLGPROC) CallDlgProc,
+                (LPARAM) &paramsHeader
+                );
+
+            MsgLoopInTAPIClientContext (hwnd);
+
+            dwDeviceID = params[0].dwValue;
+        }
+        else
+        {
+            dwDeviceID = gdwDefLineGetIDID;
+        }
+    }
+
+    lpDeviceID->dwNeededSize   =
+    lpDeviceID->dwUsedSize     = dwNeededSize;
+    lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+    lpDeviceID->dwStringSize   = sizeof(DWORD);
+    lpDeviceID->dwStringOffset = sizeof(VARSTRING);
+
+    *((LPDWORD)(lpDeviceID + 1)) = dwDeviceID;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE        hdLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "lpLineDevStatus",    lpLineDevStatus }
+    };
+    FUNC_INFO   info = { "lineGetLineDevStatus", SYNC, 2, params };
+    PDRVLINE    pLine = (PDRVLINE) hdLine;
+    DWORD       dwTotalSize, dwNeededSize;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    dwNeededSize = pLine->LineDevStatus.dwNeededSize;
+
+    if ((dwTotalSize = lpLineDevStatus->dwTotalSize) < dwNeededSize)
+    {
+        lpLineDevStatus->dwNeededSize = dwNeededSize;
+        lpLineDevStatus->dwUsedSize   = 3 * sizeof (DWORD);
+    }
+    else
+    {
+        memcpy(
+            lpLineDevStatus,
+            &pLine->LineDevStatus,
+            dwNeededSize
+            );
+
+        lpLineDevStatus->dwTotalSize = dwTotalSize;
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwNumAddressIDs
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine              },
+        { "lpdwNumAddressIDs",  lpdwNumAddressIDs   }
+    };
+    FUNC_INFO info = { "lineGetNumAddressIDs", SYNC, 2, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    *lpdwNumAddressIDs = pLine->LineDevCaps.dwNumAddresses;
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineHold_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        SetCallState(
+            (PDRVCALL) pAsyncReqInfo->dwParam1,
+            LINECALLSTATE_ONHOLD,
+            0
+            );
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info = { "lineHold", ASYNC, 2, params, TSPI_lineHold_postProcess };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineMakeCall_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL   pCall;
+    PDRVLINE   pLine    = (PDRVLINE)   pAsyncReqInfo->dwParam1;
+    HTAPICALL  htCall   = (HTAPICALL)  pAsyncReqInfo->dwParam2;
+    LPHDRVCALL lphdCall = (LPHDRVCALL) pAsyncReqInfo->dwParam3;
+    LPSTR      lpszDestAddress    = (LPSTR) pAsyncReqInfo->dwParam4;
+    LPLINECALLPARAMS lpCallParams = (LPLINECALLPARAMS) pAsyncReqInfo->dwParam5;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall (
+                pLine,
+                htCall,
+                lpCallParams,
+                &pCall
+                )) == 0)
+        {
+            *lphdCall = (HDRVCALL) pCall;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        int i;
+
+
+        //
+        // Loop on user-defined call state progression array
+        //
+
+        for (i = 0; ((i < MAX_OUT_CALL_STATES) && aOutCallStates[i]); i++)
+        {
+            SetCallState (pCall, aOutCallStates[i], aOutCallStateModes[i]);
+        }
+    }
+
+    if (lpszDestAddress)
+    {
+        DrvFree (lpszDestAddress);
+    }
+
+    if (lpCallParams)
+    {
+        DrvFree (lpCallParams);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   },
+        { szlpCallParams,       lpCallParams    }
+    };
+    FUNC_INFO info = { "lineMakeCall", ASYNC, 7, params, TSPI_lineMakeCall_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdLine;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) htCall;
+    info.pAsyncReqInfo->dwParam3 = (DWORD) lphdCall;
+
+    if (lpszDestAddress)
+    {
+        size_t len = strlen (lpszDestAddress) + 1;
+
+
+        info.pAsyncReqInfo->dwParam4 = (DWORD) DrvAlloc (len);
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam4,
+            lpszDestAddress,
+            len
+            );
+    }
+
+    if (lpCallParams)
+    {
+        info.pAsyncReqInfo->dwParam5 = (DWORD) DrvAlloc(
+            (size_t) lpCallParams->dwTotalSize
+            );
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam5,
+            (void far *) lpCallParams,
+            (size_t) lpCallParams->dwTotalSize
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwDigitModes
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwDigitModes",   dwDigitModes,   aDigitModes }
+    };
+    FUNC_INFO info = { "lineMonitorDigits", SYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaModes
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall                      },
+        { "dwMediaModes",   dwMediaModes,   aMediaModes }
+    };
+    FUNC_INFO info = { "lineMonitorMedia", SYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwToneListID",   dwToneListID    },
+        { "lpToneList",     lpToneList      },
+        { "dwNumEntries",   dwNumEntries    }
+    };
+    FUNC_INFO info = { "lineMonitorTones", SYNC, 4, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwLowVersion",   dwLowVersion    },
+        { "dwHighVersion",  dwHighVersion   },
+        { "lpdwExtVersion", lpdwExtVersion  }
+    };
+    FUNC_INFO info = { "lineNegotiateExtVersion", SYNC, 5, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    ShowStr(
+        "TSPI_lineNegoExtVer: setting *lpdwExtVersion = x%lx",
+        dwHighVersion
+        );
+
+    *lpdwExtVersion = dwHighVersion;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+#ifdef WIN32
+
+    if (!ghMsgLoopThread)
+    {
+        DWORD   dwTID;
+
+
+        if (!(ghMsgLoopThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) MsgLoopThread,
+                NULL,
+                0,
+                &dwTID
+                )))
+        {
+            OutputDebugString ("ESP32.TSP: DllMain: CreateThread failed\n\r");
+            return LINEERR_OPERATIONFAILED;
+        }
+    }
+
+#endif
+
+    {
+        FUNC_PARAM params[] =
+        {
+            { szdwDeviceID,         dwDeviceID      },
+            { "dwLowVersion",       dwLowVersion    },
+            { "dwHighVersion",      dwHighVersion   },
+            { "lpdwTSPIVersion",    lpdwTSPIVersion }
+        };
+        FUNC_INFO info = { "lineNegotiateTSPIVersion", SYNC, 4, params };
+
+
+        {
+            // BUGBUG hangs if gbManualResults set, so...
+
+            BOOL bManualResultsSav = gbManualResults;
+
+
+            gbManualResults = FALSE;
+
+            if (!Prolog (&info))
+            {
+                return (Epilog (&info));
+            }
+
+            gbManualResults = bManualResultsSav;
+        }
+
+        *lpdwTSPIVersion = gdwTSPIVersion;
+
+        return (Epilog (&info));
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD       dwDeviceID,
+    HTAPILINE   htLine,
+    LPHDRVLINE  lphdLine,
+    DWORD       dwTSPIVersion,
+    LINEEVENT   lpfnEventProc
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "htLine",         htLine          },
+        { "lphdLine",       lphdLine        },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpfnEventProc",  lpfnEventProc   }
+    };
+    FUNC_INFO info = { "lineOpen", SYNC, 5, params };
+    PDRVLINE pLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    pLine = GetLine (dwDeviceID);
+
+    pLine->htLine        = htLine;
+    pLine->lpfnEventProc = lpfnEventProc;
+
+    *lphdLine = (HDRVLINE) pLine;
+
+    //UpdateWidgetList();
+    PostUpdateWidgetListMsg();
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    DWORD           dwParkMode,
+    LPCSTR          lpszDirAddress,
+    LPVARSTRING     lpNonDirAddress
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "dwParkMode",         dwParkMode      },
+        { "lpszDirAddress",     lpszDirAddress  },
+        { "lpNonDirAddress",    lpNonDirAddress }
+    };
+    FUNC_INFO info = { "linePark", ASYNC, 5, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_linePickup_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL   pCall;
+    PDRVLINE   pLine           = (PDRVLINE)   pAsyncReqInfo->dwParam1;
+    DWORD      dwAddresssID    = pAsyncReqInfo->dwParam2;
+    HTAPICALL  htCall          = (HTAPICALL)  pAsyncReqInfo->dwParam3;
+    LPHDRVCALL lphdCall        = (LPHDRVCALL) pAsyncReqInfo->dwParam4;
+    LPSTR      lpszDestAddress = (LPSTR) pAsyncReqInfo->dwParam5;
+    LPSTR      lpszGroupID     = (LPSTR) pAsyncReqInfo->dwParam6;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall (
+                pLine,
+                htCall,
+                NULL,
+                &pCall
+                )) == 0)
+        {
+            // BUGBUG deal w/ addr id
+
+            *lphdCall = (HDRVCALL) pCall;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState (pCall, LINECALLSTATE_OFFERING, 0);
+    }
+
+    if (lpszDestAddress)
+    {
+        DrvFree (lpszDestAddress);
+    }
+
+    if (lpszGroupID)
+    {
+        DrvFree (lpszGroupID);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCSTR          lpszDestAddress,
+    LPCSTR          lpszGroupID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "lpszGroupID",        lpszGroupID     }
+    };
+    FUNC_INFO info = { "linePickup", ASYNC, 7, params, TSPI_linePickup_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdLine;
+    info.pAsyncReqInfo->dwParam2 = dwAddressID;
+    info.pAsyncReqInfo->dwParam3 = (DWORD) htCall;
+    info.pAsyncReqInfo->dwParam4 = (DWORD) lphdCall;
+
+    if (lpszDestAddress)
+    {
+        size_t len = strlen (lpszDestAddress) + 1;
+
+
+        info.pAsyncReqInfo->dwParam5 = (DWORD) DrvAlloc (len);
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam5,
+            lpszDestAddress,
+            len
+            );
+    }
+
+    if (lpszGroupID)
+    {
+        size_t len = strlen (lpszGroupID) + 1;
+
+
+        info.pAsyncReqInfo->dwParam6 = (DWORD) DrvAlloc (len);
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam6,
+            lpszGroupID,
+            len
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_linePrepareAddToConference_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL    pConsultCall      = (PDRVCALL) NULL;
+    PDRVCALL    pConfCall         = (PDRVCALL) pAsyncReqInfo->dwParam1;
+    HTAPICALL   htConsultCall     = (HTAPICALL) pAsyncReqInfo->dwParam2;
+    LPHDRVCALL  lphdConsultCall   = (LPHDRVCALL) pAsyncReqInfo->dwParam3;
+    LPLINECALLPARAMS lpCallParams = (LPLINECALLPARAMS) pAsyncReqInfo->dwParam4;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall(
+                pConfCall->pLine,
+                htConsultCall,
+                lpCallParams,
+                &pConsultCall
+                )) == 0
+                )
+        {
+            *lphdConsultCall = (HDRVCALL) pConsultCall;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState (pConfCall, LINECALLSTATE_ONHOLDPENDCONF, 0);
+        SetCallState (pConsultCall, LINECALLSTATE_DIALTONE, 0);
+    }
+
+    if (lpCallParams)
+    {
+        DrvFree (lpCallParams);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { "hdConfCall",         hdConfCall          },
+        { "htConsultCall",      htConsultCall       },
+        { "lphdConsultCall",    lphdConsultCall     },
+        { szlpCallParams,       lpCallParams        }
+    };
+    FUNC_INFO info = { "linePrepareAddToConference", ASYNC, 5, params, TSPI_linePrepareAddToConference_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdConfCall;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) htConsultCall;
+    info.pAsyncReqInfo->dwParam3 = (DWORD) lphdConsultCall;
+
+    if (lpCallParams)
+    {
+        info.pAsyncReqInfo->dwParam4 = (DWORD) DrvAlloc(
+            (size_t) lpCallParams->dwTotalSize
+            );
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam4,
+            (void far *) lpCallParams,
+            (size_t) lpCallParams->dwTotalSize
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpszDestAddress",    lpszDestAddress },
+        { "dwCountryCode",      dwCountryCode   }
+    };
+    FUNC_INFO info = { "lineRedirect", ASYNC, 4, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineReleaseUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          }
+    };
+    FUNC_INFO info = { "lineReleaseUserUserInfo", ASYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineRemoveFromConference_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+        PDRVCALL   pCall2 = (PDRVCALL) pCall->pConfParent;
+
+
+        while (pCall2->pNextConfChild != pCall)
+        {
+            pCall2 = pCall2->pNextConfChild;
+        }
+
+        pCall2->pNextConfChild = pCall->pNextConfChild;
+
+        SetCallState (pCall, LINECALLSTATE_CONNECTED, 0);
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info = { "lineRemoveFromConference", ASYNC, 2, params, TSPI_lineRemoveFromConference_postProcess };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      }
+    };
+    FUNC_INFO info = { "lineSecureCall", ASYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE    hdLine,
+    DWORD       dwExtVersion
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine          },
+        { "dwExtVersion",   dwExtVersion    }
+    };
+    FUNC_INFO info = { "lineSelectExtVersion", SYNC, 2, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "lpsUserUserInfo",    lpsUserUserInfo },
+        { szdwSize,             dwSize          }
+    };
+    FUNC_INFO info = { "lineSendUserUserInfo", ASYNC, 4, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL    hdCall,
+    DWORD       dwAppSpecific
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         hdCall          },
+        { "dwAppSpecific",  dwAppSpecific   }
+    };
+    FUNC_INFO info = { "lineSetAppSpecific", SYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID                     },
+        { szhdCall,         hdCall                          },
+        { "dwBearerMode",   dwBearerMode,   aBearerModes    },
+        { "dwMinRate",      dwMinRate                       },
+        { "dwMaxRate",      dwMaxRate                       },
+        { "lpDialParams",   lpDialParams                    }
+    };
+    FUNC_INFO info = { "lineSetCallParams", ASYNC, 6, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCurrentLocation(
+    DWORD   dwLocation
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { "dwLocation", dwLocation }
+    };
+    FUNC_INFO info = { "lineSetCurrentLocation", SYNC, 1, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE    hdLine,
+    DWORD       dwMediaModes
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,         hdLine                      },
+        { "dwMediaModes",   dwMediaModes,   aMediaModes }
+    };
+    FUNC_INFO info = { "lineSetDefaultMediaDetection", SYNC, 2, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpDeviceConfig",     lpDeviceConfig  },
+        { szdwSize,             dwSize          },
+        { "lpszDeviceClass",    lpszDeviceClass }
+    };
+    FUNC_INFO info = { "lineSetDevConfig", SYNC, 4, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,                 hdLine                  },
+        { "dwAddressID",            dwAddressID             },
+        { szhdCall,                 hdCall                  },
+        { "dwSelect",               dwSelect,   aCallSelects    },
+        { "lpDigitList",            lpDigitList             },
+        { "dwDigitNumEntries",      dwDigitNumEntries       },
+        { "lpMediaList",            lpMediaList             },
+        { "dwMediaNumEntries",      dwMediaNumEntries       },
+        { "lpToneList",             lpToneList              },
+        { "dwToneNumEntries",       dwToneNumEntries        },
+        { "lpCallStateList",        lpCallStateList         },
+        { "dwCallStateNumEntries",  dwCallStateNumEntries   }
+    };
+    FUNC_INFO info = { "lineSetMediaControl", SYNC, 12, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaMode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdCall,         szhdCall                  },
+        { "dwMediaMode",    dwMediaMode,  aMediaModes }
+    };
+    FUNC_INFO info = { "lineSetMediaMode", SYNC, 2, params };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE    hdLine,
+    DWORD       dwLineStates,
+    DWORD       dwAddressStates
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdLine,             hdLine          },
+        { "dwLineStates",       dwLineStates,   aLineStates },
+        { "dwAddressStates",    dwAddressStates,    aAddressStates  }
+    };
+    FUNC_INFO info = { "lineSetStatusMessages", SYNC, 3, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    DWORD           dwSelect,
+    DWORD           dwTerminalModes,
+    DWORD           dwTerminalID,
+    DWORD           bEnable
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { szhdCall,             hdCall          },
+        { "dwSelect",           dwSelect,   aCallSelects    },
+        { "dwTerminalModes",    dwTerminalModes,    aTerminalModes  },
+        { "dwTerminalID",       dwTerminalID    },
+        { "bEnable",            bEnable         }
+    };
+    FUNC_INFO info = { "lineSetTerminal", ASYNC, 8, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetupConference_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL    pConfCall         = (PDRVCALL) NULL;
+    PDRVCALL    pConsultCall      = (PDRVCALL) NULL;
+    PDRVCALL    pCall             = (PDRVCALL) pAsyncReqInfo->dwParam1;
+    PDRVLINE    pLine             = (PDRVLINE) pAsyncReqInfo->dwParam2;
+    HTAPICALL   htConfCall        = (HTAPICALL) pAsyncReqInfo->dwParam3;
+    LPHDRVCALL  lphdConfCall      = (LPHDRVCALL) pAsyncReqInfo->dwParam4;
+    HTAPICALL   htConsultCall     = (HTAPICALL) pAsyncReqInfo->dwParam5;
+    LPHDRVCALL  lphdConsultCall   = (LPHDRVCALL) pAsyncReqInfo->dwParam6;
+    LPLINECALLPARAMS lpCallParams = (LPLINECALLPARAMS) pAsyncReqInfo->dwParam7;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall(
+                pLine,
+                htConfCall,
+                lpCallParams,
+                &pConfCall
+                )) == 0
+
+                &&
+
+            (pAsyncReqInfo->lResult = AllocCall(
+                pLine,
+                htConsultCall,
+                lpCallParams,
+                &pConsultCall
+                )) == 0
+                )
+        {
+            *lphdConfCall = (HDRVCALL) pConfCall;
+            *lphdConsultCall = (HDRVCALL) pConsultCall;
+
+            pConfCall->pNextConfChild = (pCall ? pCall : pConsultCall);
+
+            if (pCall)
+            {
+                pCall->pNextConfChild = pConsultCall;
+                pCall->pConfParent = pConfCall;
+            }
+
+            pConsultCall->pConfParent = pConfCall;
+        }
+        else if (pConfCall)
+        {
+            FreeCall (pConfCall);
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if (pCall)
+        {
+            SetCallState (pCall, LINECALLSTATE_CONFERENCED, 0);
+        }
+
+        SetCallState (pConfCall, LINECALLSTATE_ONHOLDPENDCONF, 0);
+        SetCallState (pConsultCall, LINECALLSTATE_DIALTONE, 0);
+    }
+
+    if (lpCallParams)
+    {
+        DrvFree (lpCallParams);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { szhdLine,             hdLine          },
+        { "htConfCall",         htConfCall      },
+        { "lphdConfCall",       lphdConfCall    },
+        { "htConsultCall",      htConsultCall   },
+        { "lphdConsultCall",    lphdConsultCall },
+        { "dwNumParties",       dwNumParties    },
+        { szlpCallParams,       lpCallParams    }
+    };
+    FUNC_INFO info = { "lineSetupConference", ASYNC, 9, params, TSPI_lineSetupConference_postProcess };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) hdLine;
+    info.pAsyncReqInfo->dwParam3 = (DWORD) htConfCall;
+    info.pAsyncReqInfo->dwParam4 = (DWORD) lphdConfCall;
+    info.pAsyncReqInfo->dwParam5 = (DWORD) htConsultCall;
+    info.pAsyncReqInfo->dwParam6 = (DWORD) lphdConsultCall;
+
+    if (lpCallParams)
+    {
+        info.pAsyncReqInfo->dwParam7 = (DWORD) DrvAlloc(
+            (size_t) lpCallParams->dwTotalSize
+            );
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam7,
+            lpCallParams,
+            (size_t) lpCallParams->dwTotalSize
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSetupTransfer_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL    pConsultCall      = (PDRVCALL) NULL;
+    PDRVCALL    pCall             = (PDRVCALL) pAsyncReqInfo->dwParam1;
+    HTAPICALL   htConsultCall     = (HTAPICALL) pAsyncReqInfo->dwParam2;
+    LPHDRVCALL  lphdConsultCall   = (LPHDRVCALL) pAsyncReqInfo->dwParam3;
+    LPLINECALLPARAMS lpCallParams = (LPLINECALLPARAMS) pAsyncReqInfo->dwParam4;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall(
+                pCall->pLine,
+                htConsultCall,
+                lpCallParams,
+                &pConsultCall
+                )) == 0
+                )
+        {
+            *lphdConsultCall = (HDRVCALL) pConsultCall;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState (pCall, LINECALLSTATE_ONHOLD, 0);
+        SetCallState (pConsultCall, LINECALLSTATE_DIALTONE, 0);
+    }
+
+    if (lpCallParams)
+    {
+        DrvFree (lpCallParams);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdCall,             hdCall          },
+        { "htConsultCall",      htConsultCall   },
+        { "lphdConsultCall",    lphdConsultCall },
+        { szlpCallParams,       lpCallParams    }
+    };
+    FUNC_INFO info = { "lineSetupTransfer", ASYNC, 5, params, TSPI_lineSetupTransfer_postProcess };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) htConsultCall;
+    info.pAsyncReqInfo->dwParam3 = (DWORD) lphdConsultCall;
+
+    if (lpCallParams)
+    {
+        info.pAsyncReqInfo->dwParam4 = (DWORD) DrvAlloc(
+            (size_t) lpCallParams->dwTotalSize
+            );
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam4,
+            (void far *) lpCallParams,
+            (size_t) lpCallParams->dwTotalSize
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineSwapHold_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        SetCallState(
+            (PDRVCALL) pAsyncReqInfo->dwParam1,
+            LINECALLSTATE_ONHOLD,
+            0
+            );
+
+        SetCallState(
+            (PDRVCALL) pAsyncReqInfo->dwParam2,
+            LINECALLSTATE_CONNECTED,
+            0
+            );
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdActiveCall,
+    HDRVCALL        hdHeldCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { "hdActiveCall",   hdActiveCall    },
+        { "hdHeldCall",     hdHeldCall      }
+    };
+    FUNC_INFO info = { "lineSwapHold", ASYNC, 3, params, TSPI_lineSwapHold_postProcess };
+    PDRVCALL pActiveCall = (PDRVCALL) hdActiveCall;
+    PDRVCALL pHeldCall = (PDRVCALL) hdHeldCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdActiveCall;
+    info.pAsyncReqInfo->dwParam2 = (DWORD) hdHeldCall;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwCompletionID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdLine,         hdLine          },
+        { "dwCompletionID", dwCompletionID  }
+    };
+    FUNC_INFO info = { "lineUncompleteCall", ASYNC, 3, params };
+    PDRVLINE pLine = (PDRVLINE) hdLine;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineUnhold_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    if ((pAsyncReqInfo->lResult == 0))
+    {
+        PDRVCALL   pCall = (PDRVCALL) pAsyncReqInfo->dwParam1;
+
+
+        if (pCall->dwCallState == LINECALLSTATE_ONHOLD)
+        {
+            SetCallState (pCall, LINECALLSTATE_CONNECTED, 0);
+        }
+        else
+        {
+            pAsyncReqInfo->lResult = LINEERR_INVALCALLSTATE;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdCall,         hdCall      },
+    };
+    FUNC_INFO info = { "lineUnhold", ASYNC, 2, params, TSPI_lineUnhold_postProcess };
+    PDRVCALL pCall = (PDRVCALL) hdCall;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdCall;
+
+    return (Epilog (&info));
+}
+
+
+void
+FAR
+PASCAL
+TSPI_lineUnpark_postProcess(
+    char far           *lpszFuncName,
+    PASYNC_REQUEST_INFO pAsyncReqInfo,
+    BOOL                bSync
+    )
+{
+    PDRVCALL   pCall;
+    PDRVLINE   pLine           = (PDRVLINE) pAsyncReqInfo->dwParam1;
+    DWORD      dwAddressID     = pAsyncReqInfo->dwParam2;
+    HTAPICALL  htCall          = (HTAPICALL)  pAsyncReqInfo->dwParam3;
+    LPHDRVCALL lphdCall        = (LPHDRVCALL) pAsyncReqInfo->dwParam4;
+    LPSTR      lpszDestAddress = (LPSTR) pAsyncReqInfo->dwParam5;
+
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        if ((pAsyncReqInfo->lResult = AllocCall (
+                pLine,
+                htCall,
+                NULL,
+                &pCall
+                )) == 0)
+        {
+            // BUGBUG deal w/ addr id
+
+            *lphdCall = (HDRVCALL) pCall;
+        }
+    }
+
+    DoCompletion(
+        lpszFuncName,
+        pAsyncReqInfo->dwRequestID,
+        pAsyncReqInfo->lResult,
+        bSync
+        );
+
+    if (pAsyncReqInfo->lResult == 0)
+    {
+        SetCallState (pCall, LINECALLSTATE_ONHOLD, 0);
+    }
+
+    if (lpszDestAddress)
+    {
+        DrvFree (lpszDestAddress);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCSTR          lpszDestAddress
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdLine,             hdLine          },
+        { "dwAddressID",        dwAddressID     },
+        { "htCall",             htCall          },
+        { "lphdCall",           lphdCall        },
+        { "lpszDestAddress",    lpszDestAddress }
+    };
+    FUNC_INFO info = { "lineUnpark", ASYNC, 6, params, TSPI_lineUnpark_postProcess };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = (DWORD) hdLine;
+    info.pAsyncReqInfo->dwParam2 = dwAddressID;
+    info.pAsyncReqInfo->dwParam3 = (DWORD) htCall;
+    info.pAsyncReqInfo->dwParam4 = (DWORD) lphdCall;
+
+    if (lpszDestAddress)
+    {
+        size_t len = strlen (lpszDestAddress) + 1;
+
+
+        info.pAsyncReqInfo->dwParam5 = (DWORD) DrvAlloc (len);
+
+        memcpy(
+            (void far *) info.pAsyncReqInfo->dwParam5,
+            lpszDestAddress,
+            len
+            );
+    }
+
+    return (Epilog (&info));
+}
+
+
+
+//
+// -------------------------- TSPI_phoneXxx funcs -----------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE   hdPhone
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,    hdPhone }
+    };
+    FUNC_INFO info = { "phoneClose", SYNC, 1, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    //
+    // This is more of a "command" than a request, in that TAPI.DLL is
+    // going to consider the phone closed whether we like it or not.
+    // Therefore we want to free up the phone even if the user chooses
+    // to return an error.
+    //
+
+    if (!Prolog (&info))
+    {
+        // return (Epilog (&info));
+    }
+
+    pPhone->htPhone = (HTAPIPHONE) NULL;
+
+    //UpdateWidgetList();
+    PostUpdateWidgetListMsg();
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { szhwndOwner,          hwndOwner       },
+        { "lpszDeviceClass",    lpszDeviceClass }
+    };
+    FUNC_INFO info = { "phoneConfigDialog", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    //
+    // Note: MessageBox() implements a get/dispatch msg loop which allows
+    //       other apps (or other windows within the calling app) to gain
+    //       focus.  Once these other windows/apps have focus, it's
+    //       possible that they will call into TAPI, and this service
+    //       provider could be re-entered.
+    //
+
+    MessageBox(
+        hwndOwner,
+        "Config dlg for ESP phone device",
+        "TSPI_phoneConfigDialog",
+        MB_OK
+        );
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdPhone,        hdPhone     },
+        { "lpParams",       lpParams    },
+        { szdwSize,         dwSize      }
+    };
+    FUNC_INFO info =
+    {
+        "phoneDevSpecific",
+        ASYNC,
+        4,
+        params,
+        TSPI_lineDevSpecific_postProcess
+    };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    info.pAsyncReqInfo->dwParam1 = lpParams;
+    info.pAsyncReqInfo->dwParam2 = dwSize;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "lpButtonInfo",   lpButtonInfo    }
+    };
+    FUNC_INFO info = { "phoneGetButtonInfo", SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE   hdPhone,
+    DWORD       dwDataID,
+    LPVOID      lpData,
+    DWORD       dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,    hdPhone     },
+        { "dwDataID",   dwDataID    },
+        { "lpData",     lpData      },
+        { szdwSize,     dwSize      }
+    };
+    FUNC_INFO info = { "phoneGetData", SYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD       dwDeviceID,
+    DWORD       dwTSPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwExtVersion",   dwExtVersion    },
+        { "lpPhoneCaps",    lpPhoneCaps     }
+    };
+    FUNC_INFO info = { "phoneGetDevCaps", SYNC, 4, params };
+    DWORD dwUsedSize;
+    PDRVPHONE pPhone = GetPhone (dwDeviceID);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+
+    //
+    // Figure out how much caps data to copy
+    //
+
+    if (lpPhoneCaps->dwTotalSize >= pPhone->PhoneCaps.dwNeededSize)
+    {
+        dwUsedSize = pPhone->PhoneCaps.dwNeededSize;
+    }
+    else
+    {
+        dwUsedSize = sizeof(PHONECAPS);
+    }
+
+    memcpy(
+        &lpPhoneCaps->dwNeededSize,
+        &pPhone->PhoneCaps.dwNeededSize,
+        (size_t) dwUsedSize - 4  // - 4 since not overwriting dwTotalSize
+        );
+
+    lpPhoneCaps->dwUsedSize = dwUsedSize;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDisplay
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,    hdPhone     },
+        { "lpDisplay",  lpDisplay   }
+    };
+    FUNC_INFO info = { "phoneGetDisplay", SYNC, 2, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpExtensionID",  lpExtensionID   }
+    };
+    FUNC_INFO info = { "phoneGetExtensionID", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    memcpy (lpExtensionID, &gPhoneExtID, sizeof(PHONEEXTENSIONID));
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE   hdPhone,
+    DWORD       dwHookSwitchDev,
+    LPDWORD     lpdwGain
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev },
+        { "lpdwGain",           lpdwGain        }
+    };
+    FUNC_INFO info = { "phoneGetGain", SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE   hdPhone,
+    LPDWORD     lpdwHookSwitchDevs
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone             },
+        { "lpdwHookSwitchDevs", lpdwHookSwitchDevs  }
+    };
+    FUNC_INFO info = { "phoneGetHookSwitch", SYNC, 2, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass },
+        { "lphIcon",            lphIcon         }
+    };
+    FUNC_INFO info = { "phoneGetIcon", SYNC, 3, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    *lphIcon = ghIconPhone;
+
+    return (Epilog (&info));
+}
+
+
+#ifdef WIN32
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+#else
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass
+    )
+#endif
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone         },
+        { "lpDeviceID",         lpDeviceID      },
+        { "lpszDeviceClass",    lpszDeviceClass }
+#ifdef WIN32
+        ,{ "hTargetProcess",     hTargetProcess }
+#endif
+    };
+#ifdef WIN32
+    FUNC_INFO info = { "phoneGetID", SYNC, 4, params };
+#else
+    FUNC_INFO info = { "phoneGetID", SYNC, 3, params };
+#endif
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+    DWORD    i, dwDeviceID, dwNeededSize = sizeof(VARSTRING) + sizeof(DWORD);
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    for (i = 0; aszDeviceClasses[i]; i++)
+    {
+        if (_stricmp (lpszDeviceClass, aszDeviceClasses[i]) == 0)
+        {
+            break;
+        }
+    }
+
+    if (!aszDeviceClasses[i])
+    {
+        info.lResult = PHONEERR_NODEVICE;
+        return (Epilog (&info));
+    }
+
+    if (lpDeviceID->dwTotalSize < dwNeededSize)
+    {
+        lpDeviceID->dwNeededSize = dwNeededSize;
+        lpDeviceID->dwUsedSize = 3 * sizeof(DWORD);
+
+        return (Epilog (&info));
+    }
+
+    if (i == 1)
+    {
+        dwDeviceID = pPhone->dwDeviceID;
+    }
+    else
+    {
+        if (gbShowLineGetIDDlg)
+        {
+            char szDlgTitle[64];
+            EVENT_PARAM params[] =
+            {
+                { "dwDeviceID", PT_DWORD, gdwDefLineGetIDID, 0 }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 1, szDlgTitle, XX_REQRESULTPOSTQUIT, params };
+            HWND hwnd;
+
+
+            if (strlen (lpszDeviceClass) > 20)
+            {
+                ((char far *)lpszDeviceClass)[19] = 0;
+            }
+
+            wsprintf(
+                szDlgTitle,
+                "TSPI_phoneGetID: select ID for class '%s'",
+                lpszDeviceClass
+                );
+
+            hwnd = CreateDialogParam(
+                hInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) NULL,
+                (DLGPROC) CallDlgProc,
+                (LPARAM) &paramsHeader
+                );
+
+            MsgLoopInTAPIClientContext (hwnd);
+
+            dwDeviceID = params[0].dwValue;
+        }
+        else
+        {
+            dwDeviceID = gdwDefLineGetIDID;
+        }
+    }
+
+    lpDeviceID->dwNeededSize   =
+    lpDeviceID->dwUsedSize     = dwNeededSize;
+    lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+    lpDeviceID->dwStringSize   = sizeof(DWORD);
+    lpDeviceID->dwStringOffset = sizeof(VARSTRING);
+
+    *((LPDWORD)(lpDeviceID + 1)) = dwDeviceID;
+
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE   hdPhone,
+    DWORD       dwButtonLampID,
+    LPDWORD     lpdwLampMode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "lpdwLampMode",   lpdwLampMode    }
+    };
+    FUNC_INFO info = { "phoneGetLamp", SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE   hdPhone,
+    LPDWORD     lpdwRingMode,
+    LPDWORD     lpdwVolume
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "lpdwRingMode",   lpdwRingMode    },
+        { "lpdwVolume",     lpdwVolume      }
+    };
+    FUNC_INFO info = { "phoneGetRing", SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE       hdPhone,
+    LPPHONESTATUS   lpPhoneStatus
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "lpPhoneStatus",  lpPhoneStatus   }
+    };
+    FUNC_INFO info = { "phoneGetStatus", SYNC, 2, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    memcpy(
+        &lpPhoneStatus->dwNeededSize,
+        &pPhone->PhoneStatus.dwNeededSize,
+        sizeof(PHONESTATUS) - 4 // - 4 since not overwriting dwTotalSize
+        );
+
+    if (pPhone->PhoneStatus.dwDisplaySize)
+    {
+        lpPhoneStatus->dwNeededSize += pPhone->PhoneStatus.dwDisplaySize;
+
+        if (lpPhoneStatus->dwTotalSize >= lpPhoneStatus->dwNeededSize)
+        {
+            lpPhoneStatus->dwDisplaySize   = pPhone->PhoneStatus.dwDisplaySize;
+            lpPhoneStatus->dwDisplayOffset = (DWORD) sizeof(PHONESTATUS);
+
+            strcpy(
+                ((char far *) lpPhoneStatus) + sizeof(PHONESTATUS),
+                ((char far *) &pPhone->PhoneStatus) +
+                    pPhone->PhoneStatus.dwDisplayOffset
+                );
+
+            lpPhoneStatus->dwUsedSize = lpPhoneStatus->dwNeededSize;
+        }
+    }
+
+
+    //
+    // We're getting the LampModes field from the PhoneCaps
+    //
+
+    if (pPhone->PhoneCaps.dwLampModesSize)
+    {
+        lpPhoneStatus->dwNeededSize += pPhone->PhoneCaps.dwLampModesSize;
+
+        if (lpPhoneStatus->dwTotalSize >= lpPhoneStatus->dwNeededSize)
+        {
+            lpPhoneStatus->dwLampModesSize   =
+                pPhone->PhoneCaps.dwLampModesSize;
+            lpPhoneStatus->dwLampModesOffset = lpPhoneStatus->dwUsedSize;
+
+            strcpy(
+                ((char far *) lpPhoneStatus) +
+                    lpPhoneStatus->dwLampModesOffset,
+                ((char far *) &pPhone->PhoneCaps) +
+                    pPhone->PhoneCaps.dwLampModesOffset
+                );
+
+            lpPhoneStatus->dwUsedSize = lpPhoneStatus->dwNeededSize;
+        }
+    }
+
+
+    //
+    // We're getting the DevSpecific field from the PhoneCaps
+    //
+
+    if (pPhone->PhoneCaps.dwDevSpecificSize)
+    {
+        lpPhoneStatus->dwNeededSize += pPhone->PhoneCaps.dwDevSpecificSize;
+
+        if (lpPhoneStatus->dwTotalSize >= lpPhoneStatus->dwNeededSize)
+        {
+            lpPhoneStatus->dwDevSpecificSize   =
+                pPhone->PhoneCaps.dwDevSpecificSize;
+            lpPhoneStatus->dwDevSpecificOffset = lpPhoneStatus->dwUsedSize;
+
+            strcpy(
+                ((char far *) lpPhoneStatus) +
+                    lpPhoneStatus->dwDevSpecificOffset,
+                ((char far *) &pPhone->PhoneCaps) +
+                    pPhone->PhoneCaps.dwDevSpecificOffset
+                );
+
+            lpPhoneStatus->dwUsedSize = lpPhoneStatus->dwNeededSize;
+        }
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE   hdPhone,
+    DWORD       dwHookSwitchDev,
+    LPDWORD     lpdwVolume
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev,    aHookSwitchDevs },
+        { "lpdwVolume",         lpdwVolume      }
+    };
+    FUNC_INFO info = { "phoneGetVolume", SYNC, 3, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "dwLowVersion",   dwLowVersion    },
+        { "dwHighVersion",  dwHighVersion   },
+        { "lpdwExtVersion", lpdwExtVersion  }
+    };
+    FUNC_INFO info = { "phoneNegotiateExtVersion", SYNC, 5, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    ShowStr(
+        "TSPI_phonNegoExtVer: setting *lpdwExtVersion = x%lx",
+        dwHighVersion
+        );
+
+    *lpdwExtVersion = dwHighVersion;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,         dwDeviceID      },
+        { "dwLowVersion",       dwLowVersion    },
+        { "dwHighVersion",      dwHighVersion   },
+        { "lpdwTSPIVersion",    lpdwTSPIVersion }
+    };
+    FUNC_INFO info = { "phoneNegotiateTSPIVersion", SYNC, 4, params };
+
+
+    {
+        // BUGBUG hangs if gbManualResults set, so...
+
+        BOOL bManualResultsSav = gbManualResults;
+
+
+        gbManualResults = FALSE;
+
+        if (!Prolog (&info))
+        {
+            return (Epilog (&info));
+        }
+
+        gbManualResults = bManualResultsSav;
+    }
+
+    *lpdwTSPIVersion = gdwTSPIVersion;
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneOpen(
+    DWORD       dwDeviceID,
+    HTAPIPHONE  htPhone,
+    LPHDRVPHONE lphdPhone,
+    DWORD       dwTSPIVersion,
+    PHONEEVENT  lpfnEventProc
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwDeviceID,     dwDeviceID      },
+        { "htPhone",        htPhone         },
+        { "lphdPhone",      lphdPhone       },
+        { "dwTSPIVersion",  dwTSPIVersion   },
+        { "lpfnEventProc",  lpfnEventProc   }
+    };
+    FUNC_INFO info = { "phoneOpen", SYNC, 5, params };
+    PDRVPHONE pPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    if (!(pPhone = GetPhone (dwDeviceID)))
+    {
+        // BUGBUG
+    }
+
+    pPhone->htPhone       = htPhone;
+    pPhone->lpfnEventProc = lpfnEventProc;
+
+    *lphdPhone = (HDRVPHONE) pPhone;
+
+    //UpdateWidgetList();
+    PostUpdateWidgetListMsg();
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE   hdPhone,
+    DWORD       dwExtVersion
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwExtVersion",   dwExtVersion    }
+    };
+    FUNC_INFO info = { "phoneSelectExtVersion", SYNC, 2, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "lpButtonInfo",   lpButtonInfo    }
+    };
+    FUNC_INFO info = { "phoneSetButtonInfo", ASYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwDataID,
+    LPVOID          const lpData,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdPhone,        hdPhone         },
+        { "dwDataID",       dwDataID        },
+        { "lpData",         lpData          },
+        { szdwSize,         dwSize          }
+    };
+    FUNC_INFO info = { "phoneSetData", ASYNC, 5, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwRow,
+    DWORD           dwColumn,
+    LPCSTR          lpsDisplay,
+    DWORD           dwSize
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdPhone,        hdPhone     },
+        { "dwRow",          dwRow       },
+        { "dwColumn",       dwColumn    },
+        { "lpsDisplay",     lpsDisplay  },
+        { szdwSize,         dwSize      }
+    };
+    FUNC_INFO info = { "phoneSetDisplay", ASYNC, 6, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDev,
+    DWORD           dwGain
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev,    aHookSwitchDevs },
+        { "dwGain",             dwGain          }
+    };
+    FUNC_INFO info = { "phoneSetGain", ASYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDevs,
+    DWORD           dwHookSwitchMode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID         },
+        { szhdPhone,            hdPhone             },
+        { "dwHookSwitchDevs",   dwHookSwitchDevs,   aHookSwitchDevs },
+        { "dwHookSwitchMode",   dwHookSwitchMode,   aHookSwitchModes    }
+    };
+    FUNC_INFO info = { "phoneSetHookSwitch", ASYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwButtonLampID,
+    DWORD           dwLampMode
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID     },
+        { szhdPhone,        hdPhone         },
+        { "dwButtonLampID", dwButtonLampID  },
+        { "dwLampMode",     dwLampMode, aLampModes   }
+    };
+    FUNC_INFO info = { "phoneSetLamp", ASYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwRingMode,
+    DWORD           dwVolume
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,    dwRequestID },
+        { szhdPhone,        hdPhone     },
+        { "dwRingMode",     dwRingMode  },
+        { "dwVolume",       dwVolume    }
+    };
+    FUNC_INFO info = { "phoneSetRing", ASYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE   hdPhone,
+    DWORD       dwPhoneStates,
+    DWORD       dwButtonModes,
+    DWORD       dwButtonStates
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhdPhone,        hdPhone         },
+        { "dwPhoneStates",  dwPhoneStates,  aPhoneStates    },
+        { "dwButtonModes",  dwButtonModes,  aButtonModes    },
+        { "dwButtonStates", dwButtonStates, aButtonStates   }
+    };
+    FUNC_INFO info = { "phoneSetStatusMessages", SYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDev,
+    DWORD           dwVolume
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwRequestID,        dwRequestID     },
+        { szhdPhone,            hdPhone         },
+        { "dwHookSwitchDev",    dwHookSwitchDev }, // BUGBUG lookup
+        { "dwVolume",           dwVolume        }
+    };
+    FUNC_INFO info = { "phoneSetVolume", ASYNC, 4, params };
+    PDRVPHONE pPhone = (PDRVPHONE) hdPhone;
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    return (Epilog (&info));
+}
+
+
+
+//
+// ------------------------- TSPI_providerXxx funcs ---------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhwndOwner,              hwndOwner               },
+        { szdwPermanentProviderID,  dwPermanentProviderID   }
+    };
+    FUNC_INFO info = { "providerConfig", SYNC, 2, params };
+
+
+    //
+    // Set gbExeStarted to TRUE so we don't get caught in the wait
+    // loop in Prolog, then reset it as appropriate
+    //
+
+    gbExeStarted = TRUE;
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    ESPConfigDialog();
+
+    gbExeStarted = (ghwndMain ? TRUE : FALSE);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreateLineDevice(
+    DWORD   dwTempID,
+    DWORD   dwDeviceID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { "dwTempID",   dwTempID    },
+        { szdwDeviceID, dwDeviceID  }
+    };
+    FUNC_INFO info = { "providerCreateLineDevice", SYNC, 2, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    AllocLine (dwDeviceID);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreatePhoneDevice(
+    DWORD   dwTempID,
+    DWORD   dwDeviceID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { "dwTempID",   dwTempID    },
+        { szdwDeviceID, dwDeviceID  }
+    };
+    FUNC_INFO info = { "providerCreatePhoneDevice", SYNC, 2, params };
+
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    AllocPhone (dwDeviceID);
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD       dwPermanentProviderID,
+    LPDWORD     lpdwNumLines,
+    LPDWORD     lpdwNumPhones,
+    HPROVIDER   hProvider,
+    LINEEVENT   lpfnLineCreateProc,
+    PHONEEVENT  lpfnPhoneCreateProc
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szdwPermanentProviderID,  dwPermanentProviderID   },
+        { "lpdwNumLines",           lpdwNumLines            },
+        { "lpdwNumPhones",          lpdwNumPhones           },
+        { "hProvider",              hProvider               },
+        { "lpfnLineCreateProc",     lpfnLineCreateProc      },
+        { "lpfnPhoneCreateProc",    lpfnPhoneCreateProc     }
+    };
+    FUNC_INFO info = { "providerEnumDevices", SYNC, 6, params };
+
+
+    {
+        // BUGBUG hangs if gbManualResults set, so...
+
+        BOOL bManualResultsSav = gbManualResults;
+
+
+        gbManualResults = FALSE;
+
+        if (!Prolog (&info))
+        {
+            return (Epilog (&info));
+        }
+
+        gbManualResults = bManualResultsSav;
+    }
+
+    *lpdwNumLines  = gdwNumLines;
+    *lpdwNumPhones = gdwNumPhones;
+
+    gpfnLineCreateProc  = lpfnLineCreateProc;
+    gpfnPhoneCreateProc = lpfnPhoneCreateProc;
+
+    ghProvider = hProvider;
+
+    return (Epilog (&info));
+}
+
+#ifdef WIN32
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions
+    )
+#else
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc
+    )
+#endif
+{
+    FUNC_PARAM params[] =
+    {
+        { "dwTSPIVersion",          dwTSPIVersion           },
+        { szdwPermanentProviderID,  dwPermanentProviderID   },
+        { "dwLineDeviceIDBase",     dwLineDeviceIDBase      },
+        { "dwPhoneDeviceIDBase",    dwPhoneDeviceIDBase     },
+        { "dwNumLines",             dwNumLines              },
+        { "dwNumPhones",            dwNumPhones             },
+        { "lpfnCompletionProc",     lpfnCompletionProc      }
+    };
+    FUNC_INFO info = { "providerInit", SYNC, 7, params };
+    DWORD i;
+    LONG  lResult;
+
+
+#ifdef WIN32
+
+    *lpdwTSPIOptions = LINETSPIOPTION_NONREENTRANT;
+
+#endif
+
+    {
+        // BUGBUG hangs if gbManualResults set, so...
+
+        BOOL bManualResultsSav = gbManualResults;
+
+
+        gbManualResults = FALSE;
+
+        if (!Prolog (&info))
+        {
+            return (Epilog (&info));
+        }
+
+        gbManualResults = bManualResultsSav;
+    }
+
+    gdwLineDeviceIDBase = dwLineDeviceIDBase;
+    gdwPermanentProviderID = dwPermanentProviderID;
+    gpfnCompletionProc = lpfnCompletionProc;
+
+    if (info.lResult == 0)
+    {
+        gdwNumInits++;
+    }
+
+    for (i = dwLineDeviceIDBase; i < (dwLineDeviceIDBase + dwNumLines); i++)
+    {
+        AllocLine (i);
+    }
+
+    for (i = dwPhoneDeviceIDBase; i < (dwPhoneDeviceIDBase + dwNumPhones); i++)
+    {
+        AllocPhone (i);
+    }
+
+    ghIconLine  = LoadIcon (hInst, (LPCSTR)MAKEINTRESOURCE(IDI_ICON3));
+    ghIconPhone = LoadIcon (hInst, (LPCSTR)MAKEINTRESOURCE(IDI_ICON2));
+
+    if ((lResult = Epilog (&info)) == 0)
+    {
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON1), TRUE);
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON2), TRUE);
+        EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON3), TRUE);
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhwndOwner,              hwndOwner               },
+        { szdwPermanentProviderID,  dwPermanentProviderID   }
+    };
+    FUNC_INFO info = { "providerInstall", SYNC, 2, params };
+
+
+    //
+    // Set gbExeStarted to TRUE so we don't get caught in the wait
+    // loop in Prolog, then reset it as appropriate
+    //
+
+    gbExeStarted = TRUE;
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    gbExeStarted = (ghwndMain ? TRUE : FALSE);
+
+
+    //
+    // Check to see if we're already installed
+    //
+
+    if (IsESPInstalled (hwndOwner))
+    {
+        info.lResult = LINEERR_OPERATIONFAILED;
+    }
+    else
+    {
+        UpdateTelephonIni (dwPermanentProviderID);
+    }
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { szhwndOwner,              hwndOwner               },
+        { szdwPermanentProviderID,  dwPermanentProviderID   }
+    };
+    FUNC_INFO info = { "providerRemove", SYNC, 2, params };
+    char szProviderN[16];
+
+
+    //
+    // Set gbExeStarted to TRUE so we don't get caught in the wait
+    // loop in Prolog, then reset it as appropriate
+    //
+
+    gbExeStarted = TRUE;
+
+    if (!Prolog (&info))
+    {
+        return (Epilog (&info));
+    }
+
+    gbExeStarted = (ghwndMain ? TRUE : FALSE);
+
+
+    //
+    // Clean up the [ProviderN] section in telephon.ini
+    //
+
+    wsprintf (szProviderN, "%s%ld", szProvider, dwPermanentProviderID);
+
+    WritePrivateProfileString(
+        szProviderN,
+        (LPCSTR) NULL,
+        (LPCSTR) NULL,
+        szTelephonIni
+        );
+
+    return (Epilog (&info));
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD   dwTSPIVersion
+    )
+{
+    FUNC_PARAM params[] =
+    {
+        { "dwTSPIVersion",  dwTSPIVersion }
+    };
+    FUNC_INFO info = { "providerShutdown", SYNC, 1, params };
+    LONG lResult;
+
+
+    {
+        // BUGBUG hangs if gbManualResults set, so...
+
+        BOOL bManualResultsSav = gbManualResults;
+
+
+        gbManualResults = FALSE;
+
+        if (!Prolog (&info))
+        {
+            return (Epilog (&info));
+        }
+
+        gbManualResults = bManualResultsSav;
+    }
+
+    if (info.lResult == 0)
+    {
+        gdwNumInits--;
+    }
+
+
+    //
+    // Since we're shutting down just tear everything down by hand
+    // (& save having to do all the MostMessage's, etc)
+    //
+
+    while (gaWidgets)
+    {
+        PDRVWIDGET pNextWidget = gaWidgets->pNext;
+
+
+        DrvFree (gaWidgets);
+        gaWidgets = pNextWidget;
+    }
+
+    SendMessage (ghwndList1, LB_RESETCONTENT, 0, 0);
+
+    if (gbAutoClose)
+    {
+        PostMessage (ghwndMain, WM_CLOSE, 0, 0);
+    }
+
+    DestroyIcon (ghIconLine);
+    DestroyIcon (ghIconPhone);
+
+    ghProvider = NULL;
+
+#ifdef WIN32
+
+    SaveIniSettings();
+
+#endif
+
+    lResult = Epilog (&info);
+
+#ifdef WIN32
+
+    PostMessage (ghwndMain, WM_CLOSE, 0, 0);
+
+    WaitForSingleObject (ghMsgLoopThread, INFINITE);
+
+    CloseHandle (ghMsgLoopThread);
+
+    ghMsgLoopThread = NULL;
+
+#endif
+
+    //
+    // Disable the buttons so the user doesn't press one & cause a GPF
+    //
+
+    EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON1), FALSE);
+    EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON2), FALSE);
+    EnableWindow (GetDlgItem (ghwndMain, IDC_BUTTON3), FALSE);
+
+    return lResult;
+}
+
+
+#pragma warning (default:4047)
+
+//
+// ------------------------ Private support routines --------------------------
+//
+
+
+VOID
+ShowStr(
+    char *format,
+    ...
+    )
+{
+    static char buf[256], bigBuf[2048] = "";
+    static int iTextLen = 1;
+    int len;
+    va_list ap;
+
+
+    if (gbDisableUI)
+    {
+        return;
+    }
+
+    va_start(ap, format);
+
+    // BUGBUG what if !ghwndMain
+
+    wvsprintf (buf, format, ap);
+
+    strcat (buf, "\r\n");
+
+    len = (int) strlen (buf);
+
+    if ((iTextLen + len) <= 2048)
+    {
+        iTextLen += len;
+
+
+        //
+        // Cat the new buf to the global buf that contains all the text
+        // that'll get added to the edit control the next time a
+        // WM_ADDTEXT msg is processed
+        //
+
+#ifdef WIN32
+        WaitForSingleObject (ghShowStrBufMutex, INFINITE);
+#endif
+        if (bigBuf[0] == 0)
+        {
+            //
+            // The handler for WM_ADDTEXT zeroes out the first byte in the
+            // buffer when it has added the text to the edit control, so if
+            // here we know we need to post another msg to alert that more
+            // text needs to be added
+            //
+
+            PostMessage(
+                ghwndMain,
+                WM_ADDTEXT,
+                ESP_MSG_KEY,
+                (LPARAM) bigBuf
+                );
+
+            iTextLen = 1; // to acct for null terminator
+        }
+
+        strcat (bigBuf, buf);
+
+#ifdef WIN32
+        ReleaseMutex (ghShowStrBufMutex);
+#endif
+
+    }
+    else
+    {
+        OutputDebugString ("ESP.TSP: buf overflow:\t");
+        OutputDebugString (buf);
+    }
+
+    va_end(ap);
+}
+
+
+BOOL
+ScanForDWORD(
+   char far *pBuf,
+   LPDWORD  lpdw
+   )
+{
+    char  c;
+    BOOL  bValid = FALSE;
+    DWORD d = 0;
+
+    while ((c = *pBuf))
+    {
+        if ((c >= '0') && (c <= '9'))
+        {
+            c -= '0';
+        }
+        else if ((c >= 'a') && (c <= 'f'))
+        {
+            c -= ('a' - 10);
+        }
+        else if ((c >= 'A') && (c <= 'F'))
+        {
+            c -= ('A' - 10);
+        }
+        else
+        {
+            break;
+        }
+
+        bValid = TRUE;
+
+        d *= 16;
+
+        d += (DWORD) c;
+
+        pBuf++;
+    }
+
+    if (bValid)
+    {
+        *lpdw = d;
+    }
+
+    return bValid;
+}
+
+
+void
+UpdateTelephonIni(
+    DWORD dwPermanentProviderID
+    )
+{
+    //
+    // 1.3 Support: write out the num lines & phones we support to
+    // [ProviderN] section in telephon.ini
+    //
+
+    char buf[16], szProviderN[16];
+
+
+    wsprintf (szProviderN, "%s%ld", szProvider, dwPermanentProviderID);
+
+    wsprintf (buf, "%ld", gdwNumLines);
+
+    WritePrivateProfileString(
+        szProviderN,
+        "NumLines",
+        buf,
+        szTelephonIni
+        );
+
+    wsprintf (buf, "%ld", gdwNumPhones);
+
+    WritePrivateProfileString(
+        szProviderN,
+        "NumPhones",
+        buf,
+        szTelephonIni
+        );
+}
+
+
+char far *
+GetFlags(
+    DWORD    dwFlags,
+    PLOOKUP  pLookup
+    )
+{
+    int i;
+    static char buf[256];
+    char far *p = (char far *) NULL;
+
+
+    buf[0] = 0;
+
+    for (i = 0; (dwFlags && (pLookup[i].dwVal != 0xffffffff)); i++)
+    {
+        if (dwFlags & pLookup[i].dwVal)
+        {
+            strcat (buf, pLookup[i].lpszVal);
+            strcat (buf, " ");
+
+            dwFlags = dwFlags & (~pLookup[i].dwVal);
+        }
+    }
+
+    if (buf[0])
+    {
+        if ((p = (char far *) DrvAlloc (strlen (buf) + 1)))
+        {
+            strcpy (p, buf);
+        }
+    }
+
+    return p;
+}
+
+
+void
+ShowLineEvent(
+    HTAPILINE   htLine,
+    HTAPICALL   htCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    if (gbShowEvents)
+    {
+        static DWORD adwLineMsgs[] =
+        {
+            LINE_ADDRESSSTATE,
+            LINE_CALLINFO,
+            LINE_CALLSTATE,
+            LINE_CLOSE,
+            LINE_DEVSPECIFIC,
+            LINE_DEVSPECIFICFEATURE,
+            LINE_GATHERDIGITS,
+            LINE_GENERATE,
+            LINE_LINEDEVSTATE,
+            LINE_MONITORDIGITS,
+            LINE_MONITORMEDIA,
+            LINE_MONITORTONE,
+
+            LINE_CREATE,
+
+            LINE_NEWCALL,
+            LINE_CALLDEVSPECIFIC,
+            LINE_CALLDEVSPECIFICFEATURE,
+
+            0xffffffff
+        };
+
+        static char *aszLineMsgs[] =
+        {
+            "LINE_ADDRESSSTATE",
+            "LINE_CALLINFO",
+            "LINE_CALLSTATE",
+            "LINE_CLOSE",
+            "LINE_DEVSPECIFIC",
+            "LINE_DEVSPECIFICFEATURE",
+            "LINE_GATHERDIGITS",
+            "LINE_GENERATE",
+            "LINE_LINEDEVSTATE",
+            "LINE_MONITORDIGITS",
+            "LINE_MONITORMEDIA",
+            "LINE_MONITORTONE",
+
+            "LINE_CREATE",
+
+            "LINE_NEWCALL",
+            "LINE_CALLDEVSPECIFIC",
+            "LINE_CALLDEVSPECIFICFEATURE"
+        };
+
+        int       i;
+        char far *lpszParam1 = (char far *) NULL;
+        char far *lpszParam2 = (char far *) NULL;
+        char far *lpszParam3 = (char far *) NULL;
+
+
+        for (i = 0; adwLineMsgs[i] != 0xffffffff; i++)
+        {
+            if (dwMsg == adwLineMsgs[i])
+            {
+                ShowStr(
+                    "%ssent %s : htLine=x%lx, htCall=x%lx",
+                    szCallUp,
+                    aszLineMsgs[i],
+                    htLine,
+                    htCall
+                    );
+
+                break;
+            }
+        }
+
+        if (adwLineMsgs[i] == 0xffffffff)
+        {
+            ShowStr(
+                "%ssent <unknown msg id, x%lx> : htLine=x%lx, htCall=x%lx",
+                szCallUp,
+                dwMsg,
+                htLine,
+                htCall
+                );
+        }
+
+        switch (dwMsg)
+        {
+        case LINE_ADDRESSSTATE:
+
+            lpszParam2 = GetFlags (dwParam2, aAddressStates);
+            break;
+
+        case LINE_CALLINFO:
+
+            lpszParam1 = GetFlags (dwParam1, aCallInfoStates);
+            break;
+
+        case LINE_CALLSTATE:
+
+            lpszParam1 = GetFlags (dwParam1, aCallStates);
+            break;
+
+        case LINE_LINEDEVSTATE:
+
+            lpszParam1 = GetFlags (dwParam1, aLineStates);
+            break;
+
+        } // switch
+
+        ShowStr(
+            "%s%sdwParam1=x%lx, %s",
+            szCallUp,
+            szTab,
+            dwParam1,
+            (lpszParam1 ? lpszParam1 : "")
+            );
+
+        ShowStr(
+            "%s%sdwParam2=x%lx, %s",
+            szCallUp,
+            szTab,
+            dwParam2,
+            (lpszParam2 ? lpszParam2 : "")
+            );
+
+        ShowStr(
+            "%s%sdwParam3=x%lx, %s",
+            szCallUp,
+            szTab,
+            dwParam3,
+            (lpszParam3 ? lpszParam3 : "")
+            );
+
+        if (lpszParam1)
+        {
+            DrvFree (lpszParam1);
+        }
+
+        if (lpszParam2)
+        {
+            DrvFree (lpszParam2);
+        }
+
+        if (lpszParam3)
+        {
+            DrvFree (lpszParam3);
+        }
+    }
+}
+
+
+void
+ShowPhoneEvent(
+    HTAPIPHONE  htPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    if (gbShowEvents)
+    {
+        static char *aszPhoneMsgs[] =
+        {
+            "PHONE_BUTTON",
+            "PHONE_CLOSE",
+            "PHONE_DEVSPECIFIC",
+            "PHONE_REPLY",
+            "PHONE_STATE",
+
+            "PHONE_CREATE"
+        };
+        char far *lpszParam1 = (char far *) NULL;
+        char far *lpszParam2 = (char far *) NULL;
+        char far *lpszParam3 = (char far *) NULL;
+
+
+        if ((dwMsg < PHONE_BUTTON) ||
+            ((dwMsg > PHONE_STATE) && (dwMsg != PHONE_CREATE)))
+        {
+            ShowStr(
+                "%ssent <unknown msg id, x%lx> : htPhone=x%lx",
+                szCallUp,
+                dwMsg,
+                htPhone
+                );
+        }
+        else
+        {
+            //
+            // Munge dwMsg so that we get the right index into aszLineMsgs
+            //
+
+            if (dwMsg == PHONE_CREATE)
+            {
+                dwMsg = 5;
+            }
+            else
+            {
+                dwMsg -= PHONE_BUTTON;
+            }
+
+            ShowStr(
+                "%ssent %s : htPhone=x%lx",
+                szCallUp,
+                aszPhoneMsgs[dwMsg],
+                htPhone
+                );
+        }
+
+        switch (dwMsg)
+        {
+        case PHONE_BUTTON:
+
+            lpszParam2 = GetFlags (dwParam2, aButtonModes);
+            lpszParam3 = GetFlags (dwParam3, aButtonStates);
+            break;
+
+        case PHONE_STATE:
+
+            lpszParam1 = GetFlags (dwParam1, aPhoneStates);
+            break;
+
+        } // switch
+
+        ShowStr(
+            "%s%sdwParam1=x%lx, %s",
+            szCallUp,
+            szTab,
+            dwParam1,
+            (lpszParam1 ? lpszParam1 : "")
+            );
+
+        ShowStr(
+            "%s%sdwParam2=x%lx, %s",
+            szCallUp,
+            szTab,
+            dwParam2,
+            (lpszParam2 ? lpszParam2 : "")
+            );
+
+        ShowStr(
+            "%s%sdwParam3=x%lx, %s",
+            szCallUp,
+            szTab,
+            dwParam3,
+            (lpszParam3 ? lpszParam3 : "")
+            );
+
+        if (lpszParam1)
+        {
+            DrvFree (lpszParam1);
+        }
+
+        if (lpszParam2)
+        {
+            DrvFree (lpszParam2);
+        }
+
+        if (lpszParam3)
+        {
+            DrvFree (lpszParam3);
+        }
+    }
+}
+
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        break;
+
+#ifdef WIN32
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_STATIC)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+__loadds
+CALLBACK
+CallDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    DWORD  i;
+
+    typedef struct _DLG_INST_DATA
+    {
+        PEVENT_PARAM_HEADER pParamsHeader;
+
+        LONG lLastSel;
+
+        char szComboText[MAX_STRING_PARAM_SIZE];
+
+        HGLOBAL hComboDS;
+
+        LPVOID  pComboSeg;
+
+        HWND    hwndCombo;
+
+    } DLG_INST_DATA, *PDLG_INST_DATA;
+
+    PDLG_INST_DATA pDlgInstData = (PDLG_INST_DATA)
+        GetWindowLong (hwnd, DWL_USER);
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        //
+        // Alloc a dlg instance data struct, init it, & save a ptr to it
+        //
+
+        pDlgInstData = (PDLG_INST_DATA) DrvAlloc (sizeof(DLG_INST_DATA));
+
+        // BUGBUG if (!pDlgInstData)
+
+        pDlgInstData->pParamsHeader = (PEVENT_PARAM_HEADER) lParam;
+        pDlgInstData->lLastSel = -1;
+
+        SetWindowLong (hwnd, DWL_USER, (LONG) pDlgInstData);
+
+
+#ifndef WIN32
+        {
+            //
+            // Go thru the hassle of creating combobox on the fly because
+            // otherwise we'll blow up when the combo tries to use our DS
+            // for it's heap.
+            //
+
+            RECT rect = { 116, 16, 80, 47 };
+
+
+            pDlgInstData->hComboDS = GlobalAlloc(
+                GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT,
+                2048
+                );
+
+            pDlgInstData->pComboSeg = GlobalLock (pDlgInstData->hComboDS);
+
+            LocalInit(
+                HIWORD(pDlgInstData->pComboSeg),
+                0,
+                (UINT) (GlobalSize (pDlgInstData->hComboDS) - 16)
+                );
+
+            UnlockSegment ((UINT)HIWORD(pDlgInstData->pComboSeg));
+
+            MapDialogRect (hwnd, &rect);
+
+            pDlgInstData->hwndCombo = CreateWindow(
+                "combobox",
+                NULL,
+                WS_CHILD | WS_VISIBLE | CBS_SIMPLE | CBS_NOINTEGRALHEIGHT |
+                    CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP,
+                rect.left,
+                rect.top,
+                rect.right,
+                rect.bottom,
+                hwnd,
+                (HMENU) IDC_COMBO1,
+                (HINSTANCE) HIWORD(pDlgInstData->pComboSeg),
+                NULL
+                );
+        }
+#endif
+
+        //
+        // Limit the max text length for the combobox's edit field
+        // (NOTE: A combobox ctrl actually has two child windows: a
+        // edit ctrl & a listbox.  We need to get the hwnd of the
+        // child edit ctrl & send it the LIMITTEXT msg.)
+        //
+
+        {
+            HWND hwndChild = GetWindow (pDlgInstData->hwndCombo, GW_CHILD);
+
+
+            while (hwndChild)
+            {
+                char buf[8];
+
+
+                GetClassName (hwndChild, buf, 7);
+
+                if (_stricmp (buf, "edit") == 0)
+                {
+                    break;
+                }
+
+                hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+            }
+
+            SendMessage(
+                hwndChild,
+                EM_LIMITTEXT,
+                (WPARAM) MAX_STRING_PARAM_SIZE - 1,
+                0
+                );
+        }
+
+
+        //
+        // Misc other init
+        //
+
+        pDlgInstData->pParamsHeader = (PEVENT_PARAM_HEADER) lParam;
+
+        SetWindowText (hwnd, pDlgInstData->pParamsHeader->pszDlgTitle);
+
+        for (i = 0; i < pDlgInstData->pParamsHeader->dwNumParams; i++)
+        {
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST1,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) pDlgInstData->pParamsHeader->aParams[i].szName
+                );
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        LONG      lLastSel      = pDlgInstData->lLastSel;
+        char far *lpszComboText = pDlgInstData->szComboText;
+        PEVENT_PARAM_HEADER pParamsHeader = pDlgInstData->pParamsHeader;
+
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            if (lLastSel != -1)
+            {
+                char buf[MAX_STRING_PARAM_SIZE];
+
+
+                //
+                // Save val of currently selected param
+                //
+
+                i = GetDlgItemText (hwnd, IDC_COMBO1, buf, MAX_STRING_PARAM_SIZE-1);
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    LONG lComboSel;
+
+
+                    lComboSel = SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_GETCURSEL,
+                        0,
+                        0
+                        );
+
+                    if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                    {
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD) 0;
+                    }
+                    else // "Valid string"
+                    {
+                        strncpy(
+                            pParamsHeader->aParams[lLastSel].u.buf,
+                            buf,
+                            MAX_STRING_PARAM_SIZE - 1
+                            );
+
+                        pParamsHeader->aParams[lLastSel].u.buf[MAX_STRING_PARAM_SIZE-1] = 0;
+
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                            pParamsHeader->aParams[lLastSel].u.buf;
+                    }
+
+                    break;
+                }
+                case PT_DWORD:
+                case PT_FLAGS:
+                case PT_ORDINAL:
+                {
+                    if (!ScanForDWORD(
+                            buf,
+                            &pParamsHeader->aParams[lLastSel].dwValue
+                            ))
+                    {
+                        //
+                        // Default to 0
+                        //
+
+                        pParamsHeader->aParams[lLastSel].dwValue = 0;
+                    }
+
+                    break;
+                }
+                } // switch
+            }
+
+            // Drop thru to IDCANCEL cleanup code
+
+        case IDCANCEL:
+
+#ifndef WIN32
+            DestroyWindow (pDlgInstData->hwndCombo);
+            GlobalFree (pDlgInstData->hComboDS);
+#endif
+            DrvFree (pDlgInstData);
+            EndDialog (hwnd, (int)LOWORD(wParam));
+
+            if (pParamsHeader->dwEventType == XX_REQRESULTPOSTQUIT)
+            {
+                PostQuitMessage(0);
+            }
+            break;
+
+        case IDC_LIST1:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+#else
+            if (HIWORD(lParam) == LBN_SELCHANGE)
+#endif
+            {
+                char buf[MAX_STRING_PARAM_SIZE] = "";
+                LPCSTR lpstr = buf;
+                LONG lSel =
+                    SendDlgItemMessage (hwnd, IDC_LIST1, LB_GETCURSEL, 0, 0);
+
+
+                if (lLastSel != -1)
+                {
+                    //
+                    // Save the old param value
+                    //
+
+                    i = GetDlgItemText(
+                        hwnd,
+                        IDC_COMBO1,
+                        buf,
+                        MAX_STRING_PARAM_SIZE - 1
+                        );
+
+                    switch (pParamsHeader->aParams[lLastSel].dwType)
+                    {
+                    case PT_STRING:
+                    {
+                        LONG lComboSel;
+
+
+                        lComboSel = SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_GETCURSEL,
+                            0,
+                            0
+                            );
+
+                        if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                        {
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)0;
+                        }
+                        else // "Valid string" or no sel
+                        {
+                            strncpy(
+                                pParamsHeader->aParams[lLastSel].u.buf,
+                                buf,
+                                MAX_STRING_PARAM_SIZE - 1
+                                );
+
+                            pParamsHeader->aParams[lLastSel].u.buf[MAX_STRING_PARAM_SIZE - 1] = 0;
+
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                                pParamsHeader->aParams[lLastSel].u.buf;
+                        }
+
+                        break;
+                    }
+                    case PT_DWORD:
+                    case PT_FLAGS:
+                    case PT_ORDINAL:
+                    {
+                        if (!ScanForDWORD(
+                                buf,
+                                &pParamsHeader->aParams[lLastSel].dwValue
+                                ))
+                        {
+                            //
+                            // Default to 0
+                            //
+
+                            pParamsHeader->aParams[lLastSel].dwValue = 0;
+                        }
+
+                        break;
+                    }
+                    } // switch
+                }
+
+
+                SendDlgItemMessage (hwnd, IDC_LIST2, LB_RESETCONTENT, 0, 0);
+                SendDlgItemMessage (hwnd, IDC_COMBO1, CB_RESETCONTENT, 0, 0);
+
+                switch (pParamsHeader->aParams[lSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    char * aszOptions[] =
+                    {
+                        "NUL (dwXxxSize=0)",
+                        "Valid string"
+                    };
+
+
+                    for (i = 0; i < 2; i++)
+                    {
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) aszOptions[i]
+                            );
+                    }
+
+                    if (pParamsHeader->aParams[lSel].dwValue == 0)
+                    {
+                        i = 0;
+                        buf[0] = 0;
+                    }
+                    else
+                    {
+                        i = 1;
+                        lpstr = (LPCSTR) pParamsHeader->aParams[lSel].dwValue;
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_SETCURSEL,
+                        (WPARAM) i,
+                        0
+                        );
+
+                    break;
+                }
+                case PT_DWORD:
+                {
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "0000000"
+                        );
+
+                    if (pParamsHeader->aParams[lSel].u.dwDefValue)
+                    {
+                        //
+                        // Add the default val string to the combo
+                        //
+
+                        wsprintf(
+                            buf,
+                            "%08lx",
+                            pParamsHeader->aParams[lSel].u.dwDefValue
+                            );
+
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) buf
+                            );
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "ffffffff"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_ORDINAL:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].u.pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue ==
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_FLAGS:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].u.pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue &
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select all"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                } //switch
+
+                SetDlgItemText (hwnd, IDC_COMBO1, lpstr);
+
+                pDlgInstData->lLastSel = lSel;
+            }
+            break;
+
+        case IDC_LIST2:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+#else
+            if (HIWORD(lParam) == LBN_SELCHANGE)
+#endif
+            {
+                //
+                // BUGBUG in the PT_ORDINAL case we should compare the
+                // currently selected item(s) against the previous DWORD
+                // val and figure out which item we need to deselect,
+                // if any, in order to maintain a mutex of values
+                //
+
+                PLOOKUP pLookup = (PLOOKUP)
+                    pParamsHeader->aParams[lLastSel].u.pLookup;
+                char buf[16];
+                DWORD dwValue = 0;
+                int far *ai;
+                LONG i, lSelCount =
+                    SendDlgItemMessage (hwnd, IDC_LIST2, LB_GETSELCOUNT, 0, 0);
+
+
+                ai = (int far *) DrvAlloc ((size_t)lSelCount * sizeof(int));
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_GETSELITEMS,
+                    (WPARAM) lSelCount,
+                    (LPARAM) ai
+                    );
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_FLAGS)
+                {
+                    for (i = 0; i < lSelCount; i++)
+                    {
+                        dwValue |= pLookup[ai[i]].dwVal;
+                    }
+                }
+                else // if (.dwType == PT_ORDINAL)
+                {
+                    if (lSelCount == 1)
+                    {
+                        dwValue = pLookup[ai[0]].dwVal;
+                    }
+                    else if (lSelCount == 2)
+                    {
+                        //
+                        // Figure out which item we need to de-select, since
+                        // we're doing ordinals & only want 1 item selected
+                        // at a time
+                        //
+
+                        GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                        if (ScanForDWORD (buf, &dwValue))
+                        {
+                            if (pLookup[ai[0]].dwVal == dwValue)
+                            {
+                                SendDlgItemMessage(
+                                    hwnd,
+                                    IDC_LIST2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[0]
+                                    );
+
+                                dwValue = pLookup[ai[1]].dwVal;
+                            }
+                            else
+                            {
+                                SendDlgItemMessage(
+                                    hwnd,
+                                    IDC_LIST2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[1]
+                                    );
+
+                                dwValue = pLookup[ai[0]].dwVal;
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                    else if (lSelCount > 2)
+                    {
+                        //
+                        // Determine previous selection & de-select all the
+                        // latest selections
+                        //
+
+                        GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                        if (ScanForDWORD (buf, &dwValue))
+                        {
+                            for (i = 0; i < lSelCount; i++)
+                            {
+                                if (pLookup[ai[i]].dwVal != dwValue)
+                                {
+                                    SendDlgItemMessage(
+                                        hwnd,
+                                        IDC_LIST2,
+                                        LB_SETSEL,
+                                        0,
+                                        (LPARAM) ai[i]
+                                        );
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                }
+
+                DrvFree (ai);
+                wsprintf (buf, "%08lx", dwValue);
+                SetDlgItemText (hwnd, IDC_COMBO1, buf);
+            }
+            break;
+
+        case IDC_COMBO1:
+
+#ifdef WIN32
+            switch (HIWORD(wParam))
+#else
+            switch (HIWORD(lParam))
+#endif
+            {
+            case CBN_SELCHANGE:
+            {
+                LONG lSel =
+                    SendDlgItemMessage (hwnd, IDC_COMBO1, CB_GETCURSEL, 0, 0);
+
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_ORDINAL:
+
+                    //
+                    // The only option here is "select none"
+                    //
+
+                    strcpy (lpszComboText, "00000000");
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+                    break;
+
+                case PT_FLAGS:
+                {
+                    BOOL bSelect = (lSel ? TRUE : FALSE);
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_LIST2,
+                        LB_SETSEL,
+                        (WPARAM) bSelect,
+                        (LPARAM) -1
+                        );
+
+                    if (bSelect)
+                    {
+                        PLOOKUP pLookup = (PLOOKUP)
+                            pParamsHeader->aParams[lLastSel].u.pLookup;
+                        DWORD dwValue = 0;
+                        int far *ai;
+                        LONG i, lSelCount =
+                            SendDlgItemMessage (hwnd, IDC_LIST2, LB_GETSELCOUNT, 0, 0);
+
+
+                        ai = (int far *) DrvAlloc(
+                            (size_t)lSelCount * sizeof(int)
+                            );
+
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_LIST2,
+                            LB_GETSELITEMS,
+                            (WPARAM) lSelCount,
+                            (LPARAM) ai
+                            );
+
+                        for (i = 0; i < lSelCount; i++)
+                        {
+                            dwValue |= pLookup[ai[i]].dwVal;
+                        }
+
+                        DrvFree (ai);
+                        wsprintf (lpszComboText, "%08lx", dwValue);
+
+                    }
+                    else
+                    {
+                        strcpy (lpszComboText, "00000000");
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+                }
+                case PT_STRING:
+
+                    if (lSel == 1)
+                    {
+                        strncpy(
+                            lpszComboText,
+                            pParamsHeader->aParams[lLastSel].u.buf,
+                            MAX_STRING_PARAM_SIZE
+                            );
+
+                        lpszComboText[MAX_STRING_PARAM_SIZE-1] = 0;
+                    }
+                    else
+                    {
+                        lpszComboText[0] = 0;
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+
+                case PT_DWORD:
+
+                    break;
+
+                } // switch
+                break;
+            }
+            case CBN_EDITCHANGE:
+            {
+                //
+                // If user entered text in the edit field then copy the
+                // text to our buffer
+                //
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_STRING)
+                {
+                    char buf[MAX_STRING_PARAM_SIZE];
+
+
+                    GetDlgItemText(
+                        hwnd,
+                        IDC_COMBO1,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    strncpy(
+                        pParamsHeader->aParams[lLastSel].u.buf,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    pParamsHeader->aParams[lLastSel].u.buf
+                        [MAX_STRING_PARAM_SIZE-1] = 0;
+                }
+                break;
+            }
+            } // switch
+
+        } // switch
+
+        break;
+    }
+    case WM_USER+55:
+
+        SetDlgItemText (hwnd, IDC_COMBO1, pDlgInstData->szComboText);
+        break;
+
+#ifdef WIN32
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_STATIC)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+void
+MsgLoopInTAPIClientContext(
+    HWND hwnd
+    )
+{
+
+    //
+    // -> See NOTE #2 in header above for info on the following
+    //
+    // We're filtering msgs here, only letting thru those which are
+    // destined for the dlg or it's children- we don't want to run
+    // into a situation where we're re-entering an app that's not
+    // expecting to be re-entered.
+    //
+    // Also, there's a special case in the dlg proc in which a quit
+    // msg will get posted when the dlg is dismissed so we'll drop
+    // out of this msg loop
+    //
+
+    MSG msg;
+
+    while (1)
+    {
+        if (PeekMessage (&msg, hwnd, 0, 0, PM_NOYIELD | PM_REMOVE))
+        {
+            if (msg.message == WM_QUIT)
+            {
+                break;
+            }
+
+            TranslateMessage (&msg);
+            DispatchMessage  (&msg);
+        }
+    }
+
+    DestroyWindow (hwnd);
+}
+
+
+BOOL
+Prolog(
+    PFUNC_INFO pInfo
+    )
+{
+    BOOL  bLineFunc = (pInfo->lpszFuncName[1] != 'h');
+    DWORD i, j;
+
+
+
+#ifdef WIN32
+
+    // BUGBUG move this to the first func called (TSPI nego?)
+
+    while (!gbExeStarted)
+    {
+        Sleep (0);
+    }
+
+#else
+
+    if (!gbExeStarted)
+    {
+        UINT uiResult = WinExec ("espexe.exe", SW_SHOW);
+
+
+        if (uiResult < 32)
+        {
+            char buf[64];
+
+            wsprintf (buf, "WinExec('espexe.exe') failed, err=x%x", uiResult);
+            MessageBox ((HWND) NULL, buf, "Error: esp.tsp", MB_SYSTEMMODAL);
+            pInfo->lResult = LINEERR_OPERATIONFAILED;
+            return FALSE;
+        }
+
+        while (!gbExeStarted)
+        {
+            Yield();
+        }
+    }
+
+#endif
+
+    if (gbShowFuncEntry)
+    {
+        ShowStr ("TSPI_%s: enter", pInfo->lpszFuncName);
+    }
+
+    if (gbShowFuncParams)
+    {
+        for (i = 0; i < pInfo->dwNumParams; i++)
+        {
+            if (pInfo->aParams[i].dwVal &&
+                (strncmp (pInfo->aParams[i].lpszVal, "lpsz", 4) == 0))
+            {
+                ShowStr(
+                    "%s%s=x%lx, '%s'",
+                    szTab,
+                    pInfo->aParams[i].lpszVal,
+                    pInfo->aParams[i].dwVal,
+                    pInfo->aParams[i].dwVal
+                    );
+            }
+            else if (pInfo->aParams[i].pLookup)
+            {
+                char buf[90];
+                PLOOKUP pLookup = pInfo->aParams[i].pLookup;
+
+
+                wsprintf(
+                    buf,
+                    "%s%s=x%lx, ",
+                    szTab,
+                    pInfo->aParams[i].lpszVal,
+                    pInfo->aParams[i].dwVal
+                    );
+
+                for (j = 0; pLookup[j].dwVal != 0xffffffff; j++)
+                {
+                    if (pInfo->aParams[i].dwVal & pLookup[j].dwVal)
+                    {
+                        strcat (buf, pLookup[j].lpszVal);
+                        strcat (buf, " ");
+
+                        if (strlen (buf) > 60)
+                        {
+                            ShowStr (buf);
+                            wsprintf (buf, "%s%s", szTab, szTab);
+                        }
+                    }
+                }
+
+                ShowStr (buf);
+            }
+            else
+            {
+                ShowStr(
+                    "%s%s=x%lx",
+                    szTab,
+                    pInfo->aParams[i].lpszVal,
+                    pInfo->aParams[i].dwVal
+                    );
+            }
+        }
+    }
+
+    if (gbManualResults)
+    {
+        char szDlgTitle[64];
+        EVENT_PARAM params[] =
+        {
+            { "lResult", PT_ORDINAL, 0, (bLineFunc ? aLineErrs : aPhoneErrs) }
+        };
+        EVENT_PARAM_HEADER paramsHeader =
+            { 1, szDlgTitle, XX_REQRESULTPOSTQUIT, params };
+        HWND hwnd;
+
+
+        wsprintf (szDlgTitle, "TSPI_%s request result", pInfo->lpszFuncName);
+
+        hwnd = CreateDialogParam(
+            hInst,
+            (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+            (HWND) NULL,
+            (DLGPROC) CallDlgProc,
+            (LPARAM) &paramsHeader
+            );
+
+        MsgLoopInTAPIClientContext (hwnd);
+
+
+        //
+        // If user selected to synchronously return an error we'll save
+        // the error & return FALSE to indicate to caller that it should
+        // return immediately.
+        //
+
+        if (params[0].dwValue)
+        {
+            pInfo->lResult = (LONG) params[0].dwValue;
+
+            return FALSE;
+        }
+    }
+
+    if (pInfo->bAsync)
+    {
+        //
+        // Alloc & init an async request info structure
+        //
+
+        PASYNC_REQUEST_INFO pAsyncReqInfo = (PASYNC_REQUEST_INFO)
+            DrvAlloc (sizeof(ASYNC_REQUEST_INFO));
+
+
+        if (pAsyncReqInfo)
+        {
+            memset (pAsyncReqInfo, 0, sizeof(ASYNC_REQUEST_INFO));
+
+            pAsyncReqInfo->pfnPostProcessProc = (FARPROC)
+                pInfo->pfnPostProcessProc;
+            pAsyncReqInfo->dwRequestID        = pInfo->aParams[0].dwVal;
+
+            pInfo->pAsyncReqInfo = pAsyncReqInfo;
+
+            strcpy (pAsyncReqInfo->szFuncName, pInfo->lpszFuncName);
+        }
+        else
+        {
+            pInfo->lResult = (bLineFunc ?
+                LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+
+            return FALSE;
+        }
+    }
+
+    if (gbBreakOnFuncEntry)
+    {
+        DebugBreak();
+    }
+
+    return TRUE;
+}
+
+
+LONG
+Epilog(
+    PFUNC_INFO pInfo
+    )
+{
+    if (pInfo->bAsync)
+    {
+        if (pInfo->lResult == 0)
+        {
+            if (gbManualCompl || gbAsyncCompl)
+            {
+                PostMessage(
+                    ghwndMain,
+                    (gbManualCompl ? WM_MANUALCOMPL : WM_ASYNCCOMPL),
+                    ESP_MSG_KEY,
+                    (LPARAM) pInfo->pAsyncReqInfo
+                    );
+            }
+            else
+            {
+                //
+                // We're completing this async request synchronously, so call
+                // the post processing proc (if there is one) or call the
+                // completion routine directly
+                //
+
+                if (pInfo->pAsyncReqInfo->pfnPostProcessProc)
+                {
+                    (*((POSTPROCESSPROC)pInfo->pAsyncReqInfo->pfnPostProcessProc))(
+                        pInfo->lpszFuncName,
+                        pInfo->pAsyncReqInfo,
+                        TRUE
+                        );
+                }
+                else
+                {
+                    DoCompletion(
+                        pInfo->lpszFuncName,
+                        pInfo->aParams[0].dwVal,
+                        pInfo->lResult,
+                        TRUE
+                        );
+                }
+
+                DrvFree (pInfo->pAsyncReqInfo);
+            }
+
+
+            //
+            // Finally, for success cases want to return the request ID per spec
+            //
+
+            pInfo->lResult = pInfo->aParams[0].dwVal;
+        }
+        else
+        {
+            if (pInfo->pAsyncReqInfo)
+            {
+                DrvFree (pInfo->pAsyncReqInfo);
+            }
+        }
+    }
+
+    if (gbShowFuncExit)
+    {
+        ShowStr(
+            "TSPI_%s: exit, returning x%lx",
+            pInfo->lpszFuncName,
+            pInfo->lResult
+            );
+    }
+
+    return (pInfo->lResult);
+}
+
+
+PDRVWIDGET
+GetSelectedWidget(
+    void
+    )
+{
+    PDRVWIDGET pWidget = NULL;
+    LONG lSel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0), i;
+
+
+    if (lSel != LB_ERR)
+    {
+        pWidget = gaWidgets;
+
+        for (i = 0; i < lSel; i++)
+        {
+            if (!pWidget)
+            {
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+    }
+
+    return pWidget;
+}
+
+
+void
+ESPConfigDialog(
+    void
+    )
+{
+    EVENT_PARAM params[] =
+    {
+        { "TSPI Version",      PT_DWORD,   gdwTSPIVersion, NULL },
+        { "Num Lines",         PT_DWORD,   gdwNumLines, NULL },
+        { "Num Addrs/Line",    PT_DWORD,   gdwNumAddrsPerLine, NULL },
+        { "Num Phones",        PT_DWORD,   gdwNumPhones, NULL },
+        { "ShowLineGetIDDlg",  PT_DWORD,   gbShowLineGetIDDlg, NULL },
+        { "DefLineGetIDID",    PT_DWORD,   gdwDefLineGetIDID, NULL },
+        { "LineExtID0",        PT_DWORD,   gLineExtID.dwExtensionID0, NULL },
+        { "LineExtID1",        PT_DWORD,   gLineExtID.dwExtensionID1, NULL },
+        { "LineExtID2",        PT_DWORD,   gLineExtID.dwExtensionID2, NULL },
+        { "LineExtID3",        PT_DWORD,   gLineExtID.dwExtensionID3, NULL },
+        { "PhoneExtID0",       PT_DWORD,   gPhoneExtID.dwExtensionID0, NULL },
+        { "PhoneExtID1",       PT_DWORD,   gPhoneExtID.dwExtensionID1, NULL },
+        { "PhoneExtID2",       PT_DWORD,   gPhoneExtID.dwExtensionID2, NULL },
+        { "PhoneExtID3",       PT_DWORD,   gPhoneExtID.dwExtensionID3, NULL }
+    };
+    EVENT_PARAM_HEADER paramsHeader =
+        { 12, "Default Provider Values", XX_DEFAULTS, params };
+
+
+    if (DialogBoxParam(
+            hInst,
+            (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+            (HWND) ghwndMain,
+            (DLGPROC) CallDlgProc,
+            (LPARAM) &paramsHeader
+            ) == IDOK)
+    {
+        if (!gdwNumInits)
+        {
+            gdwTSPIVersion     = params[0].dwValue;
+            gdwNumAddrsPerLine = params[2].dwValue;
+
+
+            //
+            // v1.0 support (since 1.0 doesn't call providerEnumDevices). Find
+            // [ProviderN] section for ESP & updates NumLines & NumPhones.
+            //
+
+            if ((gdwNumLines != params[1].dwValue) ||
+                (gdwNumPhones != params[3].dwValue))
+            {
+                int  iNumProviders, i;
+                char szProviderN[32];
+
+
+                gdwNumLines  = params[1].dwValue;
+                gdwNumPhones = params[3].dwValue;
+
+                iNumProviders = GetPrivateProfileInt(
+                    szProviders,
+                    szNumProviders,
+                    0,
+                    szTelephonIni
+                    );
+
+                for (i = 0; i < iNumProviders; i++)
+                {
+                    char szProviderName[16];
+
+
+                    wsprintf (szProviderN, "%s%d", szProviderFilename, i);
+
+                    GetPrivateProfileString(
+                        szProviders,
+                        szProviderN,
+                        "",
+                        szProviderName,
+                        16,
+                        szTelephonIni
+                        );
+
+                    if (_stricmp (szProviderName, szEspTsp) == 0)
+                    {
+                        wsprintf (szProviderN, "%s%d", szProviderID, i);
+
+                        i = GetPrivateProfileInt(
+                            szProviders,
+                            szProviderN,
+                            30000,
+                            szTelephonIni
+                            );
+
+                        // BUGBUG chk if err
+
+                        break;
+                    }
+                }
+
+                UpdateTelephonIni ((DWORD) i);
+            }
+        }
+        else if ((gdwTSPIVersion     != params[0].dwValue) ||
+                 (gdwNumLines        != params[1].dwValue) ||
+                 (gdwNumAddrsPerLine != params[2].dwValue) ||
+                 (gdwNumPhones       != params[3].dwValue))
+        {
+            MessageBox(
+                ghwndMain,
+                "You must shut down all active TAPI applications in order " \
+                    "for changes to TSPI Version, Num Lines, NumAddrs/Line," \
+                    " or Num Phones to take effect",
+                "Note",
+                MB_OK
+                );
+        }
+
+        gdwTSPIVersion     = params[0].dwValue;
+        gdwNumLines        = params[1].dwValue;
+        gdwNumAddrsPerLine = params[2].dwValue;
+        gdwNumPhones       = params[3].dwValue;
+
+        gbShowLineGetIDDlg = (BOOL) params[4].dwValue;
+        gdwDefLineGetIDID  = params[5].dwValue;
+
+        gLineExtID.dwExtensionID0 = params[4].dwValue;
+        gLineExtID.dwExtensionID1 = params[5].dwValue;
+        gLineExtID.dwExtensionID2 = params[6].dwValue;
+        gLineExtID.dwExtensionID3 = params[7].dwValue;
+
+        gPhoneExtID.dwExtensionID0 = params[8].dwValue;
+        gPhoneExtID.dwExtensionID1 = params[9].dwValue;
+        gPhoneExtID.dwExtensionID2 = params[10].dwValue;
+        gPhoneExtID.dwExtensionID3 = params[11].dwValue;
+    }
+}
+
+
+void
+WidgetPropertiesDialog(
+    PDRVWIDGET  pWidget,
+    BOOL        bIncomingCall
+    )
+{
+    static char aszVarFields[17][MAX_STRING_PARAM_SIZE];
+    DWORD i;
+
+
+    switch (pWidget->dwType)
+    {
+    case WT_DRVCALL:
+    {
+        //
+        // We use the bIncomingCall flag here automatically cause a chg in
+        // the call state (from IDLE to OFFERING) on incoming calls, otherwise
+        // if the user forgets to chg it (from IDLE) any chgs they make will
+        // just be ignored by TAPI.DLL
+        //
+
+        PDRVCALL pCall = (PDRVCALL) pWidget;
+        LPLINECALLINFO lpCallInfo = &pCall->LineCallInfo;
+        char far *lpVarFields = (char far *) lpCallInfo + sizeof(LINECALLINFO);
+        EVENT_PARAM params[] =
+        {
+            { "Status.dwCallState",         PT_FLAGS, (bIncomingCall ? LINECALLSTATE_OFFERING : pCall->dwCallState), aCallStates },
+            { "Status.dwCallStateMode",     PT_DWORD, pCall->dwCallStateMode, NULL },
+            { "Status.dwCallFeatures",      PT_FLAGS, pCall->dwCallFeatures, aCallFeatures },
+
+            { "Info.dwBearerMode",          PT_FLAGS, lpCallInfo->dwBearerMode, aBearerModes },
+            { "Info.dwRate",                PT_DWORD, lpCallInfo->dwRate, NULL },
+            { "Info.dwMediaMode",           PT_FLAGS, lpCallInfo->dwMediaMode, aMediaModes },
+            { "Info.dwAppSpecific",         PT_DWORD, lpCallInfo->dwAppSpecific, 0 },
+            { "Info.dwCallID",              PT_DWORD, lpCallInfo->dwCallID, 0 },
+            { "Info.dwRelatedCallID",       PT_DWORD, lpCallInfo->dwRelatedCallID, 0 },
+            { "Info.dwCallParamFlags",      PT_FLAGS, lpCallInfo->dwCallParamFlags, aCallParamFlags },
+            { "Info.dwCallStates",          PT_FLAGS, lpCallInfo->dwCallStates, aCallStates },
+            { "Info.DialParams.dwDialPause",        PT_DWORD, lpCallInfo->DialParams.dwDialPause, 0 },
+            { "Info.DialParams.dwDialSpeed",        PT_DWORD, lpCallInfo->DialParams.dwDialSpeed, 0 },
+            { "Info.DialParams.dwDigitDuration",    PT_DWORD, lpCallInfo->DialParams.dwDigitDuration, 0 },
+            { "Info.DialParams.dwWaitForDialtone",  PT_DWORD, lpCallInfo->DialParams.dwWaitForDialtone, 0 },
+            { "Info.dwOrigin",              PT_FLAGS, lpCallInfo->dwOrigin, aCallOrigins },
+            { "Info.dwReason",              PT_FLAGS, lpCallInfo->dwReason, aCallReasons },
+            { "Info.dwCompletionID",        PT_DWORD, lpCallInfo->dwCompletionID, 0 },
+            { "Info.dwCountryCode",         PT_DWORD, lpCallInfo->dwCountryCode, 0 },
+            { "Info.dwTrunk",               PT_DWORD, lpCallInfo->dwTrunk, 0 },
+            { "Info.dwCallerIDFlags",       PT_FLAGS,  lpCallInfo->dwCallerIDFlags, aCallerIDFlags },
+            { "Info.szCallerID",            PT_STRING, (DWORD) (lpCallInfo->dwCallerIDSize ? aszVarFields[0] : 0), (LPVOID) aszVarFields[0] },
+            { "Info.szCallerIDName",        PT_STRING, (DWORD) (lpCallInfo->dwCallerIDNameSize ? aszVarFields[1] : 0), (LPVOID) aszVarFields[1] },
+            { "Info.dwCalledIDFlags",       PT_FLAGS,  lpCallInfo->dwCalledIDFlags, aCallerIDFlags },
+            { "Info.szCalledID",            PT_STRING, (DWORD) (lpCallInfo->dwCalledIDSize ? aszVarFields[2] : 0), (LPVOID) aszVarFields[2] },
+            { "Info.szCalledIDName",        PT_STRING, (DWORD) (lpCallInfo->dwCalledIDNameSize ? aszVarFields[3] : 0), (LPVOID) aszVarFields[3] },
+            { "Info.dwConnectedIDFlags",    PT_FLAGS,  lpCallInfo->dwConnectedIDFlags, aCallerIDFlags },
+            { "Info.szConnectedID",         PT_STRING, (DWORD) (lpCallInfo->dwConnectedIDSize ? aszVarFields[4] : 0), (LPVOID) aszVarFields[4] },
+            { "Info.szConnectedIDName",     PT_STRING, (DWORD) (lpCallInfo->dwConnectedIDNameSize ? aszVarFields[5] : 0), (LPVOID) aszVarFields[5] },
+            { "Info.dwRedirectionIDFlags",  PT_FLAGS,  lpCallInfo->dwRedirectionIDFlags, aCallerIDFlags },
+            { "Info.szRedirectionID",       PT_STRING, (DWORD) (lpCallInfo->dwRedirectionIDSize ? aszVarFields[6] : 0), (LPVOID) aszVarFields[6] },
+            { "Info.szRedirectionIDName",   PT_STRING, (DWORD) (lpCallInfo->dwRedirectionIDNameSize ? aszVarFields[7] : 0), (LPVOID) aszVarFields[7] },
+            { "Info.dwRedirectingIDFlags",  PT_FLAGS,  lpCallInfo->dwRedirectingIDFlags, aCallerIDFlags },
+            { "Info.szRedirectingID",       PT_STRING, (DWORD) (lpCallInfo->dwRedirectingIDSize ? aszVarFields[8] : 0), (LPVOID) aszVarFields[8] },
+            { "Info.szRedirectingIDName",   PT_STRING, (DWORD) (lpCallInfo->dwRedirectingIDNameSize ? aszVarFields[9] : 0), (LPVOID) aszVarFields[9] },
+            { "Info.szDisplay",             PT_STRING, (DWORD) (lpCallInfo->dwDisplaySize ? aszVarFields[10] : 0), (LPVOID) aszVarFields[10] },
+            { "Info.szUserUserInfo",        PT_STRING, (DWORD) (lpCallInfo->dwUserUserInfoSize ? aszVarFields[11] : 0), (LPVOID) aszVarFields[11] },
+            { "Info.szHighLevelComp",       PT_STRING, (DWORD) (lpCallInfo->dwHighLevelCompSize ? aszVarFields[12] : 0), (LPVOID) aszVarFields[12] },
+            { "Info.szLowLevelComp",        PT_STRING, (DWORD) (lpCallInfo->dwLowLevelCompSize ? aszVarFields[13] : 0), (LPVOID) aszVarFields[13] },
+            { "Info.szChargingInfo",        PT_STRING, (DWORD) (lpCallInfo->dwChargingInfoSize ? aszVarFields[14] : 0), (LPVOID) aszVarFields[14] },
+            { "Info.szTerminalModes",       PT_STRING, (DWORD) (lpCallInfo->dwTerminalModesSize ? aszVarFields[15] : 0), (LPVOID) aszVarFields[15] },
+            { "Info.szDevSpecific",         PT_STRING, (DWORD) (lpCallInfo->dwDevSpecificSize ? aszVarFields[16] : 0), (LPVOID) aszVarFields[16] }
+        };
+        EVENT_PARAM_HEADER paramsHeader =
+            { 42, "Call status/info", XX_CALL, params };
+
+
+        for (i = 0; i < 17; i++)
+        {
+            strcpy (aszVarFields[i], lpVarFields + i*MAX_STRING_PARAM_SIZE);
+        }
+
+        if (DialogBoxParam(
+                hInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) ghwndMain,
+                (DLGPROC) CallDlgProc,
+                (LPARAM) &paramsHeader
+                ) == IDOK)
+        {
+            LPDWORD alpdwXxxSize[17] =
+            {
+                &lpCallInfo->dwCallerIDSize,
+                &lpCallInfo->dwCallerIDNameSize,
+                &lpCallInfo->dwCalledIDSize,
+                &lpCallInfo->dwCalledIDNameSize,
+                &lpCallInfo->dwConnectedIDSize,
+                &lpCallInfo->dwConnectedIDNameSize,
+                &lpCallInfo->dwRedirectionIDSize,
+                &lpCallInfo->dwRedirectionIDNameSize,
+                &lpCallInfo->dwRedirectingIDSize,
+                &lpCallInfo->dwRedirectingIDNameSize,
+                &lpCallInfo->dwDisplaySize,
+                &lpCallInfo->dwUserUserInfoSize,
+                &lpCallInfo->dwHighLevelCompSize,
+                &lpCallInfo->dwLowLevelCompSize,
+                &lpCallInfo->dwChargingInfoSize,
+                &lpCallInfo->dwTerminalModesSize,
+                &lpCallInfo->dwDevSpecificSize
+            };
+            LPDWORD alpdwXxx[22] =
+            {
+                &lpCallInfo->dwBearerMode,
+                &lpCallInfo->dwRate,
+                &lpCallInfo->dwMediaMode,
+                &lpCallInfo->dwAppSpecific,
+                &lpCallInfo->dwCallID,
+                &lpCallInfo->dwRelatedCallID,
+                &lpCallInfo->dwCallParamFlags,
+                &lpCallInfo->dwCallStates,
+                &lpCallInfo->DialParams.dwDialPause,
+                &lpCallInfo->DialParams.dwDialSpeed,
+                &lpCallInfo->DialParams.dwDigitDuration,
+                &lpCallInfo->DialParams.dwWaitForDialtone,
+                &lpCallInfo->dwOrigin,
+                &lpCallInfo->dwReason,
+                &lpCallInfo->dwCompletionID,
+                &lpCallInfo->dwCountryCode,
+                &lpCallInfo->dwTrunk,
+                &lpCallInfo->dwCallerIDFlags,
+                &lpCallInfo->dwCalledIDFlags,
+                &lpCallInfo->dwConnectedIDFlags,
+                &lpCallInfo->dwRedirectionIDFlags,
+                &lpCallInfo->dwRedirectingIDFlags
+            };
+            DWORD dwCallInfoChangedFlags, i;
+            static DWORD adwVarFieldFlags[17] =
+            {
+                LINECALLINFOSTATE_CALLERID,
+                LINECALLINFOSTATE_CALLERID,
+                LINECALLINFOSTATE_CALLEDID,
+                LINECALLINFOSTATE_CALLEDID,
+                LINECALLINFOSTATE_CONNECTEDID,
+                LINECALLINFOSTATE_CONNECTEDID,
+                LINECALLINFOSTATE_REDIRECTIONID,
+                LINECALLINFOSTATE_REDIRECTIONID,
+                LINECALLINFOSTATE_REDIRECTINGID,
+                LINECALLINFOSTATE_REDIRECTINGID,
+                LINECALLINFOSTATE_DISPLAY,
+                LINECALLINFOSTATE_USERUSERINFO,
+                LINECALLINFOSTATE_HIGHLEVELCOMP,
+                LINECALLINFOSTATE_LOWLEVELCOMP,
+                LINECALLINFOSTATE_CHARGINGINFO,
+                LINECALLINFOSTATE_TERMINAL,
+                LINECALLINFOSTATE_DEVSPECIFIC
+            };
+            static DWORD adwDWORDFieldFlags[22] =
+            {
+                LINECALLINFOSTATE_BEARERMODE,
+                LINECALLINFOSTATE_RATE,
+                LINECALLINFOSTATE_MEDIAMODE,
+                LINECALLINFOSTATE_APPSPECIFIC,
+                LINECALLINFOSTATE_CALLID,
+                LINECALLINFOSTATE_RELATEDCALLID,
+                LINECALLINFOSTATE_OTHER,
+                LINECALLINFOSTATE_OTHER,
+                LINECALLINFOSTATE_DIALPARAMS,
+                LINECALLINFOSTATE_DIALPARAMS,
+                LINECALLINFOSTATE_DIALPARAMS,
+                LINECALLINFOSTATE_DIALPARAMS,
+                LINECALLINFOSTATE_ORIGIN,
+                LINECALLINFOSTATE_REASON,
+                LINECALLINFOSTATE_COMPLETIONID,
+                LINECALLINFOSTATE_OTHER,
+                LINECALLINFOSTATE_TRUNK,
+                LINECALLINFOSTATE_CALLERID,
+                LINECALLINFOSTATE_CALLEDID,
+                LINECALLINFOSTATE_CONNECTEDID,
+                LINECALLINFOSTATE_REDIRECTIONID,
+                LINECALLINFOSTATE_REDIRECTINGID
+            };
+            static int aiVarFieldIndices[17] =
+            {
+                21, 22, 24, 25, 27, 28, 30, 31, 33, 34, 35, 36, 37,
+                38, 39, 40, 41
+            };
+            static int aiDWORDFieldIndices[22] =
+            {
+                3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+                18, 19, 20, 23, 26, 29, 32
+            };
+
+
+            //
+            // If the state info chgd then save it & send a call state msg
+            //
+
+            if ((params[0].dwValue != pCall->dwCallState) ||
+                (params[1].dwValue != pCall->dwCallStateMode) ||
+                (params[2].dwValue != pCall->dwCallFeatures))
+            {
+                //
+                // We want to make sure that the media mode is up to date
+                // when we send the CALLSTATE msg
+                //
+
+                DWORD   dwMediaModeOrig = lpCallInfo->dwMediaMode;
+
+
+                lpCallInfo->dwMediaMode = params[5].dwValue;
+
+
+                //
+                // We need to zero the state in order to force a msg (even
+                // if state didn't chg)
+                //
+
+                pCall->dwCallState = 0xdeadbeef;
+
+                SetCallState (pCall, params[0].dwValue, params[1].dwValue);
+
+                pCall->dwCallFeatures = params[2].dwValue;
+
+
+                //
+                // Restore the media mode so we can catch the chg down below
+                //
+
+                lpCallInfo->dwMediaMode = dwMediaModeOrig;
+            }
+
+
+            //
+            // If the info chgd then save it & send a call info msg
+            //
+
+            dwCallInfoChangedFlags = 0;
+
+            for (i = 0; i < 22; i++)
+            {
+                if (params[aiDWORDFieldIndices[i]].dwValue != *(alpdwXxx[i]))
+                {
+                    *(alpdwXxx[i]) = params[aiDWORDFieldIndices[i]].dwValue;
+                    dwCallInfoChangedFlags |= adwDWORDFieldFlags[i];
+                }
+            }
+
+            for (i = 0; i < 17; i++)
+            {
+                if (params[aiVarFieldIndices[i]].dwValue == 0)
+                {
+                    if (*(alpdwXxxSize[i]) != 0)
+                    {
+                        *(alpdwXxxSize[i]) = *(alpdwXxxSize[i] + 1) = 0;
+                        lpVarFields[i*MAX_STRING_PARAM_SIZE] = 0;
+                        dwCallInfoChangedFlags |= adwVarFieldFlags[i];
+                    }
+                }
+                else if (strcmp(
+                            aszVarFields[i],
+                            lpVarFields + i*MAX_STRING_PARAM_SIZE
+                            ) ||
+                         (*(alpdwXxxSize[i]) == 0))
+                {
+                    strcpy(
+                        lpVarFields + i*MAX_STRING_PARAM_SIZE,
+                        aszVarFields[i]
+                        );
+
+                    *(alpdwXxxSize[i]) = strlen (aszVarFields[i]) + 1;
+                    *(alpdwXxxSize[i] + 1) = sizeof(LINECALLINFO) +
+                        i*MAX_STRING_PARAM_SIZE;
+                    dwCallInfoChangedFlags |= adwVarFieldFlags[i];
+                }
+            }
+
+            if (dwCallInfoChangedFlags)
+            {
+                SendLineEvent(
+                    pCall->pLine,
+                    pCall,
+                    LINE_CALLINFO,
+                    dwCallInfoChangedFlags,
+                    0,
+                    0
+                    );
+            }
+        }
+
+        break;
+    }
+    case WT_DRVLINE:
+    {
+        PDRVLINE pLine = (PDRVLINE) pWidget;
+        EVENT_PARAM params[] =
+        {
+            { "<under contruction>", PT_DWORD, 0, NULL }
+//            { "Caps.dwBearerModes",  PT_FLAGS, pLine->LineDevCaps.dwBearerModes, aBearerModes },
+//            { "Caps.dwMediaModes",   PT_FLAGS, pLine->LineDevCaps.dwMediaModes, aMediaModes }
+        };
+        EVENT_PARAM_HEADER paramsHeader =
+            { 1, "Line caps/status", XX_LINE, params };
+
+
+        if (DialogBoxParam(
+                hInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) ghwndMain,
+                (DLGPROC) CallDlgProc,
+                (LPARAM) &paramsHeader
+                ) == IDOK)
+        {
+        }
+
+        break;
+    }
+    case WT_DRVPHONE:
+    {
+        PDRVPHONE pPhone = (PDRVPHONE) pWidget;
+        LPPHONECAPS lpPhoneCaps = &pPhone->PhoneCaps;
+        char far *lpCapsVarFields = (char far *) lpPhoneCaps + sizeof(PHONECAPS);
+        LPPHONESTATUS lpPhoneStatus = &pPhone->PhoneStatus;
+        char far *lpStatusVarFields = (char far *) lpPhoneStatus + sizeof(PHONESTATUS);
+        EVENT_PARAM params[] =
+        {
+            { "Caps.szProviderInfo",            PT_STRING, (DWORD) (lpPhoneCaps->dwProviderInfoSize ? aszVarFields[0] : 0) , (LPVOID) aszVarFields[0] },
+            { "Caps.szPhoneInfo",               PT_STRING, (DWORD) (lpPhoneCaps->dwPhoneInfoSize ? aszVarFields[1] : 0) , (LPVOID) aszVarFields[1] },
+            { "Caps.szPhoneName",               PT_STRING, (DWORD) (lpPhoneCaps->dwPhoneNameSize ? aszVarFields[2] : 0) , (LPVOID) aszVarFields[2] },
+            { "Caps.dwPhoneStates",             PT_FLAGS,  lpPhoneCaps->dwPhoneStates, aPhoneStates },
+            { "Caps.dwHookSwitchDevs",          PT_FLAGS,  lpPhoneCaps->dwHookSwitchDevs, aHookSwitchDevs },
+            { "Caps.dwHandsetHookSwitchModes",  PT_FLAGS,  lpPhoneCaps->dwHandsetHookSwitchModes, aHookSwitchModes },
+            { "Caps.dwSpeakerHookSwitchModes",  PT_FLAGS,  lpPhoneCaps->dwSpeakerHookSwitchModes, aHookSwitchModes },
+            { "Caps.dwHeadsetHookSwitchModes",  PT_FLAGS,  lpPhoneCaps->dwHeadsetHookSwitchModes, aHookSwitchModes },
+            { "Caps.dwVolumeFlags",             PT_FLAGS,  lpPhoneCaps->dwVolumeFlags, aHookSwitchDevs },
+            { "Caps.dwGainFlags",               PT_FLAGS,  lpPhoneCaps->dwGainFlags, aHookSwitchDevs },
+            { "Caps.dwDisplayNumRows",          PT_DWORD,  lpPhoneCaps->dwDisplayNumRows, 0 },
+            { "Caps.dwDisplayNumColumns",       PT_DWORD,  lpPhoneCaps->dwDisplayNumColumns, 0 },
+            { "Caps.dwNumRingModes",            PT_DWORD,  lpPhoneCaps->dwNumRingModes, 0 },
+            { "Caps.dwNumButtonLamps",          PT_DWORD,  lpPhoneCaps->dwNumButtonLamps, 0 },
+            { "Caps.szButtonModes",             PT_STRING, (DWORD) (lpPhoneCaps->dwButtonModesSize ? aszVarFields[3] : 0) , (LPVOID) aszVarFields[3] },
+            { "Caps.szButtonFunctions",         PT_STRING, (DWORD) (lpPhoneCaps->dwButtonFunctionsSize ? aszVarFields[4] : 0) , (LPVOID) aszVarFields[4] },
+            { "Caps.szLampModes",               PT_STRING, (DWORD) (lpPhoneCaps->dwLampModesSize ? aszVarFields[5] : 0) , (LPVOID) aszVarFields[5] },
+            { "Caps.dwNumSetData",              PT_DWORD,  lpPhoneCaps->dwNumSetData, 0 },
+            { "Caps.szSetData",                 PT_STRING, (DWORD) (lpPhoneCaps->dwSetDataSize ? aszVarFields[6] : 0) , (LPVOID) aszVarFields[6] },
+            { "Caps.dwNumGetData",              PT_DWORD,  lpPhoneCaps->dwNumGetData, 0 },
+            { "Caps.szGetData",                 PT_STRING, (DWORD) (lpPhoneCaps->dwGetDataSize ? aszVarFields[7] : 0) , (LPVOID) aszVarFields[7] },
+            { "Caps.szDevSpecific",             PT_STRING, (DWORD) (lpPhoneCaps->dwDevSpecificSize ? aszVarFields[8] : 0) , (LPVOID) aszVarFields[8] },
+
+            { "Status.dwStatusFlags",           PT_FLAGS,  lpPhoneStatus->dwStatusFlags, aPhoneStatusFlags },
+            { "Status.dwRingMode",              PT_DWORD,  lpPhoneStatus->dwRingMode, 0 },
+            { "Status.dwRingVolume",            PT_DWORD,  lpPhoneStatus->dwRingVolume, 0 },
+            { "Status.dwHandsetHookSwitchMode", PT_FLAGS,  lpPhoneStatus->dwHandsetHookSwitchMode, aHookSwitchModes },
+            { "Status.dwHandsetVolume",         PT_DWORD,  lpPhoneStatus->dwHandsetVolume, 0 },
+            { "Status.dwHandsetGain",           PT_DWORD,  lpPhoneStatus->dwHandsetGain, 0 },
+            { "Status.dwSpeakerHookSwitchMode", PT_FLAGS,  lpPhoneStatus->dwSpeakerHookSwitchMode, aHookSwitchModes },
+            { "Status.dwSpeakerVolume",         PT_DWORD,  lpPhoneStatus->dwSpeakerVolume, 0 },
+            { "Status.dwSpeakerGain",           PT_DWORD,  lpPhoneStatus->dwSpeakerGain, 0 },
+            { "Status.dwHeadsetHookSwitchMode", PT_FLAGS,  lpPhoneStatus->dwHeadsetHookSwitchMode, aHookSwitchModes },
+            { "Status.dwHeadsetVolume",         PT_DWORD,  lpPhoneStatus->dwHeadsetVolume, 0 },
+            { "Status.dwHeadsetGain",           PT_DWORD,  lpPhoneStatus->dwHeadsetGain, 0 },
+            { "Status.szDisplay",               PT_STRING, (DWORD) (lpPhoneStatus->dwDisplaySize ? aszVarFields[10] : 0) , (LPVOID) aszVarFields[10] }
+        };
+        EVENT_PARAM_HEADER paramsHeader =
+            { 35, "Phone caps/status", XX_PHONE, params };
+
+
+        for (i = 0; i < 9; i++)
+        {
+            strcpy (aszVarFields[i], lpCapsVarFields + i*MAX_STRING_PARAM_SIZE);
+        }
+
+        strcpy (aszVarFields[9], lpStatusVarFields);
+
+        if (DialogBoxParam(
+                hInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                (HWND) ghwndMain,
+                (DLGPROC) CallDlgProc,
+                (LPARAM) &paramsHeader
+                ) == IDOK)
+        {
+            LPDWORD alpdwXxxSize[10] =
+            {
+                &lpPhoneCaps->dwProviderInfoSize,
+                &lpPhoneCaps->dwPhoneInfoSize,
+                &lpPhoneCaps->dwPhoneNameSize,
+                &lpPhoneCaps->dwButtonModesSize,
+                &lpPhoneCaps->dwButtonFunctionsSize,
+                &lpPhoneCaps->dwLampModesSize,
+                &lpPhoneCaps->dwSetDataSize,
+                &lpPhoneCaps->dwGetDataSize,
+                &lpPhoneCaps->dwDevSpecificSize,
+
+                &lpPhoneStatus->dwDisplaySize
+            };
+            LPDWORD alpdwXxx[25] =
+            {
+                &lpPhoneCaps->dwPhoneStates,
+                &lpPhoneCaps->dwHookSwitchDevs,
+                &lpPhoneCaps->dwHandsetHookSwitchModes,
+                &lpPhoneCaps->dwSpeakerHookSwitchModes,
+                &lpPhoneCaps->dwHeadsetHookSwitchModes,
+                &lpPhoneCaps->dwVolumeFlags,
+                &lpPhoneCaps->dwGainFlags,
+                &lpPhoneCaps->dwDisplayNumRows,
+                &lpPhoneCaps->dwDisplayNumColumns,
+                &lpPhoneCaps->dwNumRingModes,
+                &lpPhoneCaps->dwNumButtonLamps,
+                &lpPhoneCaps->dwNumSetData,
+                &lpPhoneCaps->dwNumGetData,
+
+                &lpPhoneStatus->dwStatusFlags,
+                &lpPhoneStatus->dwRingMode,
+                &lpPhoneStatus->dwRingVolume,
+                &lpPhoneStatus->dwHandsetHookSwitchMode,
+                &lpPhoneStatus->dwHandsetVolume,
+                &lpPhoneStatus->dwHandsetGain,
+                &lpPhoneStatus->dwSpeakerHookSwitchMode,
+                &lpPhoneStatus->dwSpeakerVolume,
+                &lpPhoneStatus->dwSpeakerGain,
+                &lpPhoneStatus->dwHeadsetHookSwitchMode,
+                &lpPhoneStatus->dwHeadsetVolume,
+                &lpPhoneStatus->dwHeadsetGain
+            };
+            DWORD dwStatusChangedFlags, i;
+            static DWORD adwVarFieldFlags[10] =
+            {
+                0,
+                0,
+                0,
+                0,
+                0,
+                PHONESTATE_LAMP,
+                0,
+                0,
+                PHONESTATE_DEVSPECIFIC,
+                PHONESTATE_DISPLAY,
+            };
+            static DWORD adwDWORDFieldFlags[12] =
+            {
+                PHONESTATE_OTHER,
+                PHONESTATE_RINGMODE,
+                PHONESTATE_RINGVOLUME,
+                PHONESTATE_HANDSETHOOKSWITCH,
+                PHONESTATE_HANDSETVOLUME,
+                PHONESTATE_HANDSETGAIN,
+                PHONESTATE_SPEAKERHOOKSWITCH,
+                PHONESTATE_SPEAKERVOLUME,
+                PHONESTATE_SPEAKERGAIN,
+                PHONESTATE_HEADSETHOOKSWITCH,
+                PHONESTATE_HEADSETVOLUME,
+                PHONESTATE_HEADSETGAIN
+            };
+            static int aiVarFieldIndices[10] =
+            {
+                0, 1, 2, 14, 15, 16, 18, 20, 21, 34
+            };
+            static int aiDWORDFieldIndices[25] =
+            {
+                3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 17, 19, 22, 23,
+                24, 25, 25, 27, 28, 29, 30, 31, 32, 33
+            };
+
+
+            //
+            // If the caps/status chgd then save it & send a state msg
+            //
+
+            dwStatusChangedFlags = 0;
+
+            for (i = 0; i < 25; i++)
+            {
+                if (params[aiDWORDFieldIndices[i]].dwValue != *(alpdwXxx[i]))
+                {
+                    *(alpdwXxx[i]) = params[aiDWORDFieldIndices[i]].dwValue;
+
+                    if (i >= 13)
+                    {
+                        dwStatusChangedFlags |= adwDWORDFieldFlags[i-13];
+                    }
+                }
+            }
+
+            for (i = 0; i < 10; i++)
+            {
+                if (params[aiVarFieldIndices[i]].dwValue == 0)
+                {
+                    if (*(alpdwXxxSize[i]) != 0)
+                    {
+                        *(alpdwXxxSize[i]) = *(alpdwXxxSize[i] + 1) = 0;
+                        if (i < 9)
+                        {
+                            lpCapsVarFields[i*MAX_STRING_PARAM_SIZE] = 0;
+                        }
+                        else
+                        {
+                            lpStatusVarFields[0] = 0;
+                        }
+                        dwStatusChangedFlags |= adwVarFieldFlags[i];
+                    }
+                }
+                else if (strcmp(
+                            aszVarFields[i],
+                            (i < 9 ?
+                                lpCapsVarFields + i*MAX_STRING_PARAM_SIZE :
+                                lpStatusVarFields)
+                            ) ||
+                         (*(alpdwXxxSize[i]) == 0))
+                {
+                    if (i < 9)
+                    {
+                        strcpy(
+                            lpCapsVarFields + i*MAX_STRING_PARAM_SIZE,
+                            aszVarFields[i]
+                            );
+
+                        *(alpdwXxxSize[i] + 1) = sizeof(PHONECAPS) +
+                            i*MAX_STRING_PARAM_SIZE;
+                    }
+                    else
+                    {
+                        strcpy (lpStatusVarFields, aszVarFields[i]);
+
+                        *(alpdwXxxSize[i] + 1) = sizeof(PHONESTATUS);
+                    }
+
+                    *(alpdwXxxSize[i]) = strlen (aszVarFields[i]) + 1;
+                    dwStatusChangedFlags |= adwVarFieldFlags[i];
+                }
+            }
+
+            if (dwStatusChangedFlags)
+            {
+                SendPhoneEvent(
+                    pPhone,
+                    PHONE_STATE,
+                    dwStatusChangedFlags,
+                    0,
+                    0
+                    );
+            }
+        }
+
+        break;
+    }
+    } // switch
+}
+
+
+BOOL
+__loadds
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static HICON  hIcon;
+    static int    icyButton, icyBorder;
+
+    static BOOL bCaptured = FALSE;
+    static LONG xCapture, cxVScroll;
+    static int  cyWnd;
+    static HFONT  hFont;
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        char buf[64];
+        RECT rect;
+
+
+        //
+        // Init some globals
+        //
+
+        hIcon = LoadIcon (hInst, MAKEINTRESOURCE(IDI_ICON1));
+
+        ghwndMain  = hwnd;
+        ghwndList1 = GetDlgItem (hwnd, IDC_LIST1);
+        ghwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+        ghwndEdit  = GetDlgItem (hwnd, IDC_EDIT1);
+        ghMenu     = GetMenu (hwnd);
+
+        icyBorder = GetSystemMetrics (SM_CYFRAME);
+        GetWindowRect (GetDlgItem (hwnd, IDC_BUTTON1), &rect);
+        icyButton = (rect.bottom - rect.top) + icyBorder + 3;
+        cxVScroll = 2*GetSystemMetrics (SM_CXVSCROLL);
+
+
+        //
+        //
+        //
+
+        {
+            #define MYBOOL  1
+            #define MYDWORD 2
+
+            typedef struct _INIT_VALUE
+            {
+                char   *lpszValue;
+
+                LPVOID lpValue;
+
+                int    iType;
+
+                union
+                {
+                    DWORD  dwMenuItem;
+
+                    char   *lpszDefValueAscii;
+
+                } u;
+
+            } INIT_VALUE, *PINIT_VALUE;
+
+            int i;
+            INIT_VALUE aValues[] =
+            {
+                { "TSPIVersion",         &gdwTSPIVersion,             MYDWORD, (DWORD) ((char far *)"10003") },
+                { "NumLines",            &gdwNumLines,                MYDWORD, (DWORD) ((char far *)"3") },
+                { "NumAddrsPerLine",     &gdwNumAddrsPerLine,         MYDWORD, (DWORD) ((char far *)"2") },
+                { "NumPhones",           &gdwNumPhones,               MYDWORD, (DWORD) ((char far *)"2") },
+                { "ShowFuncEntry",       &gbShowFuncEntry,            MYBOOL,  (DWORD) IDM_SHOWFUNCENTRY   },
+                { "ShowFuncExit",        &gbShowFuncExit,             MYBOOL,  (DWORD) IDM_SHOWFUNCEXIT    },
+                { "ShowFuncParams",      &gbShowFuncParams,           MYBOOL,  (DWORD) IDM_SHOWFUNCPARAMS  },
+                { "ShowEvents",          &gbShowEvents,               MYBOOL,  (DWORD) IDM_SHOWEVENTS      },
+                { "ShowCompletions",     &gbShowCompletions,          MYBOOL,  (DWORD) IDM_SHOWCOMPLETIONS },
+                { "BreakOnFuncEntry",    &gbBreakOnFuncEntry,         MYBOOL,  (DWORD) IDM_DEBUGBREAK },
+                { "AutoClose",           &gbAutoClose,                MYBOOL,  (DWORD) IDM_AUTOCLOSE },
+                { "SyncCompl",           &gbSyncCompl,                MYBOOL,  (DWORD) IDM_SYNCCOMPL      },
+                { "AsyncCompl",          &gbAsyncCompl,               MYBOOL,  (DWORD) IDM_ASYNCCOMPL     },
+                { "ManualCompl",         &gbManualCompl,              MYBOOL,  (DWORD) IDM_MANUALCOMPL    },
+                { "ManualResults",       &gbManualResults,            MYBOOL,  (DWORD) IDM_MANUALRESULTS  },
+                { "DisableUI",           &gbDisableUI,                MYBOOL,  (DWORD) IDM_DISABLEUI      },
+                { "ShowLineGetIDDlg",    &gbShowLineGetIDDlg,         MYBOOL,  (DWORD) 0      },
+                { "DefLineGetIDID",      &gdwDefLineGetIDID,          MYDWORD, (DWORD) ((char far *)"ffffffff") },
+                { "LineExtID0",          &gLineExtID.dwExtensionID0,  MYDWORD, (DWORD) ((char far *)"6f79f180") },
+                { "LineExtID1",          &gLineExtID.dwExtensionID1,  MYDWORD, (DWORD) ((char far *)"101b0bb0") },
+                { "LineExtID2",          &gLineExtID.dwExtensionID2,  MYDWORD, (DWORD) ((char far *)"00089e96") },
+                { "LineExtID3",          &gLineExtID.dwExtensionID3,  MYDWORD, (DWORD) ((char far *)"8a2e312b") },
+                { "PhoneExtID0",         &gPhoneExtID.dwExtensionID0, MYDWORD, (DWORD) ((char far *)"0") },
+                { "PhoneExtID1",         &gPhoneExtID.dwExtensionID1, MYDWORD, (DWORD) ((char far *)"0") },
+                { "PhoneExtID2",         &gPhoneExtID.dwExtensionID2, MYDWORD, (DWORD) ((char far *)"0") },
+                { "PhoneExtID3",         &gPhoneExtID.dwExtensionID3, MYDWORD, (DWORD) ((char far *)"0") },
+                { "OutCallState1",       &aOutCallStates[0],          MYDWORD, (DWORD) ((char far *)"10") }, // DIALING
+                { "OutCallStateMode1",   &aOutCallStateModes[0],      MYDWORD, (DWORD) ((char far *)"0") },
+                { "OutCallState2",       &aOutCallStates[1],          MYDWORD, (DWORD) ((char far *)"200") }, // PROCEEDING
+                { "OutCallStateMode2",   &aOutCallStateModes[1],      MYDWORD, (DWORD) ((char far *)"0") },
+                { "OutCallState3",       &aOutCallStates[2],          MYDWORD, (DWORD) ((char far *)"0") },
+                { "OutCallStateMode3",   &aOutCallStateModes[2],      MYDWORD, (DWORD) ((char far *)"0") },
+                { "OutCallState4",       &aOutCallStates[3],          MYDWORD, (DWORD) ((char far *)"0") },
+                { "OutCallStateMode4",   &aOutCallStateModes[3],      MYDWORD, (DWORD) ((char far *)"0") },
+                { NULL,                  NULL, 0, 0 }
+            };
+
+
+            for (i = 0; aValues[i].lpszValue; i++)
+            {
+                switch (aValues[i].iType)
+                {
+                case MYBOOL:
+
+                    *((BOOL *) aValues[i].lpValue) = (BOOL)
+                        GetProfileInt(
+                            szMySection,
+                            aValues[i].lpszValue,
+                            ((i == 4) || (i == 12) ? 1 : 0)
+                            );
+
+                    if (*((BOOL *)aValues[i].lpValue) &&
+                        aValues[i].u.dwMenuItem)
+                    {
+                        CheckMenuItem(
+                            ghMenu,
+                            (UINT) aValues[i].u.dwMenuItem,
+                            MF_BYCOMMAND | MF_CHECKED
+                            );
+                    }
+
+                    break;
+
+                case MYDWORD:
+                {
+                    char buf[16];
+
+
+                    GetProfileString(
+                        szMySection,
+                        aValues[i].lpszValue,
+                        aValues[i].u.lpszDefValueAscii,
+                        buf,
+                        15
+                        );
+
+                    ScanForDWORD (buf, (LPDWORD) aValues[i].lpValue);
+
+                    break;
+                }
+                } // switch
+            }
+        }
+
+
+        //
+        // Set control fonts
+        //
+
+        {
+            HWND hwndCtrl = GetDlgItem (hwnd, IDC_BUTTON1);
+            hFont = CreateFont(
+                13, 5, 0, 0, 400, 0, 0, 0, 0, 1, 2, 1, 34, "MS Sans Serif"
+                );
+
+            do
+            {
+                SendMessage(
+                    hwndCtrl,
+                    WM_SETFONT,
+                    (WPARAM) hFont,
+                    0
+                    );
+
+            } while ((hwndCtrl = GetNextWindow (hwndCtrl, GW_HWNDNEXT)));
+        }
+
+
+        //
+        // Read in control size ratios
+        //
+
+        cxWnd   = GetProfileInt (szMySection, "cxWnd",   100);
+        cxList1 = GetProfileInt (szMySection, "cxList1", 25);
+
+
+        //
+        // Send self WM_SIZE to position child controls correctly
+        //
+
+        GetProfileString(
+            szMySection,
+            "Left",
+            "0",
+            buf,
+            63
+            );
+
+        if (strcmp (buf, "max") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMAXIMIZED);
+        }
+        else if (strcmp (buf, "min") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMINIMIZED);
+        }
+        else
+        {
+            int left, top, right, bottom;
+            int cxScreen = GetSystemMetrics (SM_CXSCREEN);
+            int cyScreen = GetSystemMetrics (SM_CYSCREEN);
+
+
+            left   = GetProfileInt (szMySection, "Left",   0);
+            top    = GetProfileInt (szMySection, "Top",    3*cyScreen/4);
+            right  = GetProfileInt (szMySection, "Right",  cxScreen);
+            bottom = GetProfileInt (szMySection, "Bottom", cyScreen);
+
+            SetWindowPos(
+                hwnd,
+                HWND_TOP,
+                left,
+                top,
+                right - left,
+                bottom - top,
+                SWP_SHOWWINDOW
+                );
+
+            GetClientRect (hwnd, &rect);
+
+            SendMessage(
+                hwnd,
+                WM_SIZE,
+                0,
+                MAKELONG((rect.right-rect.left),(rect.bottom-rect.top))
+                );
+
+            ShowWindow (hwnd, SW_SHOW);
+        }
+
+        gbExeStarted = TRUE;
+
+        break;
+    }
+    case WM_ADDTEXT:
+    {
+        if (wParam == ESP_MSG_KEY)
+        {
+#ifdef WIN32
+            SendMessage(
+                ghwndEdit,
+                EM_SETSEL,
+                (WPARAM)0xfffffffd,
+                (LPARAM)0xfffffffe
+                );
+
+            WaitForSingleObject (ghShowStrBufMutex, INFINITE);
+#else
+            SendMessage(
+                ghwndEdit,
+                EM_SETSEL,
+                (WPARAM)0,
+                (LPARAM) MAKELONG(0xfffd,0xfffe)
+                );
+#endif
+
+            SendMessage (ghwndEdit, EM_REPLACESEL, 0, lParam);
+
+#ifdef WIN32
+            SendMessage (ghwndEdit, EM_SCROLLCARET, 0, 0);
+#endif
+            memset ((char *) lParam, 0, 16);
+#ifdef WIN32
+            ReleaseMutex (ghShowStrBufMutex);
+#endif
+        }
+
+        break;
+    }
+    case WM_UPDATEWIDGETLIST:
+
+        if (wParam == ESP_MSG_KEY)
+        {
+            UpdateWidgetList();
+        }
+
+        break;
+
+    case WM_ASYNCCOMPL:
+    {
+        PASYNC_REQUEST_INFO pAsyncReqInfo = (PASYNC_REQUEST_INFO) lParam;
+        char buf[64];
+
+
+        if (gbManualResults)
+        {
+            EVENT_PARAM params[] =
+            {
+                { "lResult", PT_ORDINAL, 0, aLineErrs }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 1, buf, XX_REQRESULT, params };
+
+
+            if (strstr (pAsyncReqInfo->szFuncName, "pho"))
+            {
+                params[0].u.pLookup = aPhoneErrs;
+            }
+
+            wsprintf(
+                buf,
+                "Completing ReqID=x%lx, TSPI_%s",
+                pAsyncReqInfo->dwRequestID,
+                pAsyncReqInfo->szFuncName
+                );
+
+            if (DialogBoxParam(
+                    hInst,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    (HWND) hwnd,
+                    (DLGPROC) CallDlgProc,
+                    (LPARAM) &paramsHeader
+                    ) == IDOK)
+            {
+                pAsyncReqInfo->lResult = (LONG) params[0].dwValue;
+            }
+            else
+            {
+                // BUGBUG? for now just return opfailed err if user cancels
+
+                if (params[0].u.pLookup == aLineErrs)
+                {
+                    pAsyncReqInfo->lResult = LINEERR_OPERATIONFAILED;
+                }
+                else
+                {
+                    pAsyncReqInfo->lResult = PHONEERR_OPERATIONFAILED;
+                }
+            }
+        }
+
+        wsprintf (buf, "TSPI_%s", pAsyncReqInfo->szFuncName);
+
+        if (pAsyncReqInfo->pfnPostProcessProc)
+        {
+            (*((POSTPROCESSPROC)pAsyncReqInfo->pfnPostProcessProc))(
+                buf,
+                pAsyncReqInfo,
+                FALSE
+                );
+        }
+        else
+        {
+            DoCompletion(
+                buf,
+                pAsyncReqInfo->dwRequestID,
+                pAsyncReqInfo->lResult,
+                FALSE
+                );
+        }
+
+        DrvFree (pAsyncReqInfo);
+
+        break;
+    }
+    case WM_MANUALCOMPL:
+    {
+        PASYNC_REQUEST_INFO pAsyncReqInfo = (PASYNC_REQUEST_INFO) lParam;
+        char buf[64];
+        int iIndex;
+
+
+        wsprintf(
+            buf,
+            "ReqID=x%lx, TSPI_%s",
+            pAsyncReqInfo->dwRequestID,
+            pAsyncReqInfo->szFuncName
+            );
+
+        SendMessage(
+            ghwndList2,
+            LB_INSERTSTRING,
+            (WPARAM) -1,
+            (LPARAM) buf
+            );
+
+        iIndex = (int) (SendMessage (ghwndList2, LB_GETCOUNT, 0, 0) - 1);
+
+        SendMessage(
+            ghwndList2,
+            LB_SETITEMDATA,
+            (WPARAM) iIndex,
+            (LPARAM) pAsyncReqInfo
+            );
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        switch (LOWORD((DWORD)wParam))
+        {
+        case IDC_EDIT1:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == EN_CHANGE)
+#else
+            if (HIWORD(lParam) == EN_CHANGE)
+#endif
+            {
+                //
+                // Watch to see if the edit control is full, & if so
+                // purge the top half of the text to make room for more
+                //
+
+                int length = GetWindowTextLength (ghwndEdit);
+
+
+                if (length > 20000)
+                {
+#ifdef WIN32
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)0 ,
+                        (LPARAM) 10000
+                        );
+#else
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)1,
+                        (LPARAM) MAKELONG (0, 10000)
+                        );
+#endif
+
+                    SendMessage(
+                        ghwndEdit,
+                        EM_REPLACESEL,
+                        0,
+                        (LPARAM) (char far *) ""
+                        );
+
+#ifdef WIN32
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)0xfffffffd,
+                        (LPARAM)0xfffffffe
+                        );
+#else
+                    SendMessage(
+                        ghwndEdit,
+                        EM_SETSEL,
+                        (WPARAM)1,
+                        (LPARAM) MAKELONG (0xfffd, 0xfffe)
+                        );
+#endif
+                }
+            }
+            break;
+
+        case IDM_INSTALL:
+        {
+            int  iNumProviders, iNextProviderID;
+            char szProviderXxxN[32];
+            char buf[32];
+
+
+            //
+            // First, see if ESP is already installed
+            //
+
+            if (IsESPInstalled (hwnd))
+            {
+                return FALSE;
+            }
+
+            //
+            // If here need to add the provider entries to telephon.ini
+            //
+            // BUGBUG ought to call lineAddProvider instead
+            //
+
+            MessageBox(
+                hwnd,
+                "Please close all active TAPI applications, then press OK.",
+                "Installing ESP",
+                MB_OK
+                );
+
+            iNumProviders = GetPrivateProfileInt(
+                    szProviders,
+                    szNumProviders,
+                    0,
+                    szTelephonIni
+                    );
+
+            wsprintf (buf, "%d", 1 + iNumProviders);
+
+            WritePrivateProfileString(
+                szProviders,
+                szNumProviders,
+                buf,
+                szTelephonIni
+                );
+
+            iNextProviderID = GetPrivateProfileInt(
+                    szProviders,
+                    szNextProviderID,
+                    0,
+                    szTelephonIni
+                    );
+
+            wsprintf (buf, "%d", 1 + iNextProviderID);
+
+            WritePrivateProfileString(
+                szProviders,
+                szNextProviderID,
+                buf,
+                szTelephonIni
+                );
+
+            wsprintf (buf, "%d", iNextProviderID);
+            wsprintf (szProviderXxxN, "ProviderID%d", iNumProviders);
+
+            WritePrivateProfileString(
+                szProviders,
+                szProviderXxxN,
+                buf,
+                szTelephonIni
+                );
+
+            wsprintf(
+                szProviderXxxN,
+                "%s%d",
+                szProviderFilename,
+                iNumProviders
+                );
+
+            WritePrivateProfileString(
+                szProviders,
+                szProviderXxxN,
+                szEspTsp,
+                szTelephonIni
+                );
+
+            UpdateTelephonIni ((DWORD) iNextProviderID);
+
+            MessageBox(
+                hwnd,
+                "ESP has been successfully installed.  "           \
+                    "You can now restart your TAPI applications.  "       \
+                    "(If TAPI fails to successfully initialize ESP "      \
+                    "then try manually copying the files ESP.TSP "        \
+                    "and ESPEXE.EXE to your <windows>/system directory.)",
+                "Installing ESP",
+                MB_OK
+                );
+
+            break;
+        }
+        case IDM_UNINSTALL:
+        {
+            int  iNumProviders, i;
+            char szProviderN[32], buf[128];
+
+
+            //
+            // First, see if ESP is already installed
+            //
+
+            iNumProviders = GetPrivateProfileInt(
+                szProviders,
+                szNumProviders,
+                0,
+                szTelephonIni
+                );
+
+            for (i = 0; i < iNumProviders; i++)
+            {
+                char szProviderName[8];
+
+
+                wsprintf (szProviderN, "%s%d", szProviderFilename, i);
+
+                GetPrivateProfileString(
+                    szProviders,
+                    szProviderN,
+                    "",
+                    szProviderName,
+                    8,
+                    szTelephonIni
+                    );
+
+                if (_stricmp (szProviderName, szEspTsp) == 0)
+                {
+                    break;
+                }
+            }
+
+            if (i == iNumProviders)
+            {
+                MessageBox(
+                    hwnd,
+                    "ESP is not installed.",
+                    "Uninstalling ESP",
+                    MB_OK
+                    );
+
+                break;
+            }
+
+
+            //
+            // If here need to remove the provider entries to telephon.ini
+            //
+
+            wsprintf (buf, "%d", iNumProviders - 1);
+
+            WritePrivateProfileString(
+                szProviders,
+                szNumProviders,
+                buf,
+                szTelephonIni
+                );
+
+
+            //
+            // Nuke the [ProviderN] section
+            //
+
+            {
+                int iProviderID;
+
+
+                wsprintf (szProviderN, "%s%d", szProviderID, i);
+
+                iProviderID = GetPrivateProfileInt(
+                    szProviders,
+                    szProviderN,
+                    0,
+                    szTelephonIni
+                    );
+
+                wsprintf (szProviderN, "%s%d", szProvider, iProviderID);
+
+                WritePrivateProfileString(
+                    szProviderN,
+                    (LPCSTR) NULL,
+                    (LPCSTR) NULL,
+                    szTelephonIni
+                    );
+            }
+
+
+            //
+            // Shuffle the ProviderID[i+1] & ProviderFilename[i+1] down
+            // to ProviderID[i] & ProviderFilename[i]
+            //
+
+            for (; i < (iNumProviders - 1); i++)
+            {
+                wsprintf (szProviderN, "%s%d", szProviderID, i + 1);
+
+                GetPrivateProfileString(
+                    szProviders,
+                    szProviderN,
+                    "",
+                    buf,
+                    128,
+                    szTelephonIni
+                    );
+
+                wsprintf (szProviderN, "%s%d", szProviderID, i);
+
+                WritePrivateProfileString(
+                    szProviders,
+                    szProviderN,
+                    buf,
+                    szTelephonIni
+                    );
+
+
+                wsprintf (szProviderN, "%s%d", szProviderFilename, i + 1);
+
+                GetPrivateProfileString(
+                    szProviders,
+                    szProviderN,
+                    "",
+                    buf,
+                    128,
+                    szTelephonIni
+                    );
+
+                wsprintf (szProviderN, "%s%d", szProviderFilename, i);
+
+                WritePrivateProfileString(
+                    szProviders,
+                    szProviderN,
+                    buf,
+                    szTelephonIni
+                    );
+            }
+
+
+            //
+            // Nuke the last ProviderIDN & ProviderFilenameN entries
+            //
+
+            wsprintf (szProviderN, "%s%d", szProviderID, i);
+
+            WritePrivateProfileString(
+                szProviders,
+                szProviderN,
+                (LPCSTR) NULL,
+                szTelephonIni
+                );
+
+            wsprintf (szProviderN, "%s%d", szProviderFilename, i);
+
+            WritePrivateProfileString(
+                szProviders,
+                szProviderN,
+                (LPCSTR) NULL,
+                szTelephonIni
+                );
+
+
+            //
+            // Alert user of success
+            //
+
+            MessageBox(
+                hwnd,
+                "ESP has been successfully uninstalled.",
+                "Uninstalling ESP",
+                MB_OK
+                );
+
+            break;
+        }
+        case IDM_DUMPGLOBALS:
+        {
+            typedef struct _MYGLOBAL
+            {
+                char far *lpszGlobal;
+
+                LPDWORD   lpdwGlobal;
+
+            } MYGLOBAL, far *PMYGLOBAL;
+
+            static MYGLOBAL aGlobals[] =
+            {
+                //
+                // When making chgs here make sure to chg init of iNumGlobals
+                // down below
+                //
+
+                { "PermanentProviderID", (LPDWORD) &gdwPermanentProviderID },
+
+
+                //
+                // Globals past here are 1.4 only
+                //
+
+                { "hProvider",           (LPDWORD) &ghProvider }
+            };
+
+
+            ShowStr ("ESP globals:");
+
+            if (gdwNumInits)
+            {
+                int i, iNumGlobals = (gdwTSPIVersion == 0x10003 ? 1 : 2);
+
+                for (i = 0; i < iNumGlobals; i++)
+                {
+                    ShowStr(
+                        "%s%s=x%lx",
+                        szTab,
+                        aGlobals[i].lpszGlobal,
+                        *(aGlobals[i].lpdwGlobal)
+                        );
+                }
+            }
+            else
+            {
+                ShowStr(
+                    "%s<Provider not initialized>",
+                    szTab
+                    );
+            }
+
+            break;
+        }
+        case IDM_EXIT:
+
+            PostMessage (hwnd, WM_CLOSE, 0, 0);
+            break;
+
+        case IDM_OUTCALLSTATEPROG:
+        {
+            EVENT_PARAM params[] =
+            {
+                { "State 1",        PT_ORDINAL, aOutCallStates[0], aCallStates },
+                { "State 1 mode",   PT_DWORD,   aOutCallStateModes[0],  NULL },
+                { "State 2",        PT_ORDINAL, aOutCallStates[1], aCallStates },
+                { "State 2 mode",   PT_DWORD,   aOutCallStateModes[1],  NULL },
+                { "State 3",        PT_ORDINAL, aOutCallStates[2], aCallStates },
+                { "State 3 mode",   PT_DWORD,   aOutCallStateModes[2],  NULL },
+                { "State 4",        PT_ORDINAL, aOutCallStates[3], aCallStates },
+                { "State 4 mode",   PT_DWORD,   aOutCallStateModes[3],  NULL }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 2*MAX_OUT_CALL_STATES, "Outgoing call state progress", XX_OUTCALLSTATEPROG, params };
+            int i;
+
+
+            if (DialogBoxParam(
+                    hInst,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    (HWND) hwnd,
+                    (DLGPROC) CallDlgProc,
+                    (LPARAM) &paramsHeader
+                    ) == IDOK)
+            {
+                memset(
+                    aOutCallStates,
+                    0,
+                    sizeof(DWORD) * MAX_OUT_CALL_STATES
+                    );
+
+                memset(
+                    aOutCallStateModes,
+                    0,
+                    sizeof(DWORD) * MAX_OUT_CALL_STATES
+                    );
+
+                for (i = 0; i < MAX_OUT_CALL_STATES; i++)
+                {
+                    if (params[2*i].dwValue == 0)
+                    {
+                        break;
+                    }
+
+                    aOutCallStates[i]     = params[2*i].dwValue;
+                    aOutCallStateModes[i] = params[(2*i)+1].dwValue;
+                }
+            }
+
+            break;
+        }
+        case IDM_ABOUT:
+
+            DialogBox(
+                hInst,
+                (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG2),
+                (HWND) hwnd,
+                (DLGPROC) AboutDlgProc
+                );
+
+            break;
+
+        case IDM_USAGE:
+        {
+            static char szDlgText[] =
+
+                "ABSTRACT:\n\r"                                               \
+                "    ESP is a TAPI Service Provider that supports "           \
+                "multiple virtual line and phone devices. It is "             \
+                "configurable, requires no special hardware, "                \
+                "and implements the entire Telephony Service Provider "       \
+                "Interface (including Win95 TAPI extensions). ESP "           \
+                "will work in both Windows 3.1/TAPI 1.0 and "                 \
+                "Windows95/TAPI 1.1 systems.\n\r"                             \
+
+                "\n\rGETTING STARTED:\n\r"                                    \
+                "    1. Choose 'File/Install' to install ESP.\n\r"            \
+                "    2. Start a TAPI application and try to make a call "     \
+                "on one of ESP's line devices (watch for messages appearing " \
+                "in the ESP window).\n\r"                                     \
+                "    *. Choose 'File/Uninstall' to uninstall ESP.\n\r"        \
+
+                "\n\rMORE INFO:\n\r"                                          \
+                "    *  Double-click on a line, call, or phone widget (in "   \
+                "upper-left listbox) to view/modify properties. The 'hd' "    \
+                "widget field is the driver handle; the 'ht' field is the "   \
+                "TAPI handle.\n\r"                                            \
+                "    *  Press the 'LEvt' or 'PEvt' button to indicate a "     \
+                "line or phone event to TAPI.DLL. Press the 'Call+' button "  \
+                "to indicate an incoming call.\n\r"                           \
+                "    *  Choose 'Options/Default values...' to modify "        \
+                "provider paramters (SPI version, # lines, etc).\n\r"         \
+                "    *  All parameter values displayed in hexadecimal "       \
+                "unless specified otherwise (strings displayed by contents)." \
+                "\n\r"                                                        \
+                "    *  Choose 'Options/Complete async requests/Xxx' to "     \
+                "specify async requests completion behavior. Manually-"       \
+                "completed requests appear in lower-left listbox.";
+
+            MessageBox (hwnd, szDlgText, "Using ESP", MB_OK);
+
+            break;
+        }
+        case IDM_SHOWFUNCENTRY:
+
+            gbShowFuncEntry = (gbShowFuncEntry ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SHOWFUNCENTRY,
+                MF_BYCOMMAND | (gbShowFuncEntry ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_SHOWFUNCEXIT:
+
+            gbShowFuncExit = (gbShowFuncExit ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SHOWFUNCEXIT,
+                MF_BYCOMMAND | (gbShowFuncExit ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_SHOWFUNCPARAMS:
+
+            gbShowFuncParams = (gbShowFuncParams ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SHOWFUNCPARAMS,
+                MF_BYCOMMAND | (gbShowFuncParams ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_SHOWEVENTS:
+
+            gbShowEvents = (gbShowEvents ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SHOWEVENTS,
+                MF_BYCOMMAND | (gbShowEvents ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_SHOWCOMPLETIONS:
+
+            gbShowCompletions = (gbShowCompletions ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SHOWCOMPLETIONS,
+                MF_BYCOMMAND | (gbShowCompletions ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_DEBUGBREAK:
+
+            gbBreakOnFuncEntry = (gbBreakOnFuncEntry ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_DEBUGBREAK,
+                MF_BYCOMMAND | (gbBreakOnFuncEntry ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_SYNCCOMPL:
+
+            gbSyncCompl = TRUE;
+            gbAsyncCompl = gbManualCompl = FALSE;
+            goto Do_compl_menuitems;
+
+        case IDM_ASYNCCOMPL:
+
+            gbAsyncCompl = TRUE;
+            gbSyncCompl = gbManualCompl = FALSE;
+            goto Do_compl_menuitems;
+
+        case IDM_MANUALCOMPL:
+
+            gbManualCompl = TRUE;
+            gbSyncCompl = gbAsyncCompl = FALSE;
+            goto Do_compl_menuitems;
+
+Do_compl_menuitems:
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SYNCCOMPL,
+                MF_BYCOMMAND | (gbSyncCompl ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_ASYNCCOMPL,
+                MF_BYCOMMAND | (gbAsyncCompl ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_MANUALCOMPL,
+                MF_BYCOMMAND | (gbManualCompl ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_MANUALRESULTS:
+
+            gbManualResults = (gbManualResults ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_MANUALRESULTS,
+                MF_BYCOMMAND | (gbManualResults ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_DISABLEUI:
+
+            if ((gbDisableUI = (gbDisableUI ? FALSE : TRUE)) == FALSE)
+            {
+                PostUpdateWidgetListMsg();
+            }
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_DISABLEUI,
+                MF_BYCOMMAND | (gbDisableUI ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_AUTOCLOSE:
+
+            gbAutoClose = (gbAutoClose ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_AUTOCLOSE,
+                MF_BYCOMMAND | (gbAutoClose ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_SHOWALL:
+        {
+            static UINT ai[5] =
+                { IDM_SHOWFUNCENTRY, IDM_SHOWFUNCEXIT, IDM_SHOWFUNCPARAMS,
+                  IDM_SHOWEVENTS, IDM_SHOWCOMPLETIONS };
+            int i;
+
+
+            gbShowFuncEntry   =
+            gbShowFuncExit    =
+            gbShowFuncParams  =
+            gbShowEvents      =
+            gbShowCompletions = TRUE;
+
+            for (i = 0; i < 5; i++)
+            {
+                CheckMenuItem (ghMenu, ai[i], MF_BYCOMMAND | MF_CHECKED);
+            }
+
+            break;
+        }
+        case IDM_SHOWNONE:
+        {
+            static UINT ai[5] =
+                { IDM_SHOWFUNCENTRY, IDM_SHOWFUNCEXIT, IDM_SHOWFUNCPARAMS,
+                  IDM_SHOWEVENTS, IDM_SHOWCOMPLETIONS };
+            int i;
+
+
+            gbShowFuncEntry   =
+            gbShowFuncExit    =
+            gbShowFuncParams  =
+            gbShowEvents      =
+            gbShowCompletions = FALSE;
+
+            for (i = 0; i < 5; i++)
+            {
+                CheckMenuItem (ghMenu, ai[i], MF_BYCOMMAND | MF_UNCHECKED);
+            }
+
+            break;
+        }
+        case IDM_DEFAULTS:
+
+            ESPConfigDialog();
+
+            break;
+
+        case IDC_PREVCTRL:
+        {
+            HWND hwndPrev = GetNextWindow (GetFocus (), GW_HWNDPREV);
+
+            if (!hwndPrev)
+            {
+                hwndPrev = GetDlgItem (hwnd, IDC_LIST2);
+            }
+
+            SetFocus (hwndPrev);
+            break;
+        }
+        case IDC_NEXTCTRL:
+        {
+            HWND hwndNext = GetNextWindow (GetFocus (), GW_HWNDNEXT);
+
+            if (!hwndNext)
+            {
+                hwndNext = GetDlgItem (hwnd, IDC_BUTTON1);
+            }
+
+            SetFocus (hwndNext);
+            break;
+        }
+        case IDC_ENTER:
+        {
+            HWND hwndFocus = GetFocus();
+
+            if (hwndFocus == ghwndList1)
+            {
+                PDRVWIDGET pWidget = GetSelectedWidget();
+
+
+                if (!pWidget)
+                {
+                    break;
+                }
+
+                WidgetPropertiesDialog (pWidget, FALSE);
+            }
+            else if ((hwndFocus == ghwndList2) &&
+                     (SendMessage (ghwndList2, LB_GETCURSEL, 0, 0) != LB_ERR))
+            {
+#ifdef WIN32
+                wParam = MAKEWPARAM (0, LBN_DBLCLK);
+#else
+                lParam = MAKELPARAM (0, LBN_DBLCLK);
+#endif
+                goto CompleteAsyncRequest;
+            }
+
+            break;
+        }
+        case IDC_BUTTON1:
+        {
+            EVENT_PARAM params[] =
+            {
+                { "htLine",   PT_DWORD,   0, NULL },
+                { "htCall",   PT_DWORD,   0, NULL },
+                { "dwMsg",    PT_ORDINAL, 0, aLineMsgs },
+                { "dwParam1", PT_DWORD,   0, NULL },
+                { "dwParam2", PT_DWORD,   0, NULL },
+                { "dwParam3", PT_DWORD,   0, NULL }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 6, "Line event", XX_LINEEVENT, params };
+            PDRVWIDGET pWidget = GetSelectedWidget();
+
+
+            //
+            // If the selected widget is a line
+            // or call then reset the defaults
+            //
+
+            if (pWidget)
+            {
+                if (pWidget->dwType == WT_DRVCALL)
+                {
+                    params[0].dwValue = (DWORD)
+                        (((PDRVCALL)pWidget)->pLine->htLine);
+                    params[1].dwValue = (DWORD)
+                        (((PDRVCALL)pWidget)->htCall);
+                }
+                else if (pWidget->dwType == WT_DRVLINE)
+                {
+                    params[0].dwValue = (DWORD)
+                        (((PDRVLINE)pWidget)->htLine);
+                }
+            }
+
+            if (DialogBoxParam(
+                    hInst,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    (HWND) hwnd,
+                    (DLGPROC) CallDlgProc,
+                    (LPARAM) &paramsHeader
+                    ) == IDOK)
+            {
+                //
+                // BUGBUG Currently the pfnLineCreateProc == pfnLineEventProc
+                //
+
+                (*gpfnLineCreateProc)(
+                    (HTAPILINE) params[0].dwValue,
+                    (HTAPICALL) params[1].dwValue,
+                    params[2].dwValue,
+                    params[3].dwValue,
+                    params[4].dwValue,
+                    params[5].dwValue
+                    );
+
+                ShowLineEvent(
+                    (HTAPILINE) params[0].dwValue,
+                    (HTAPICALL) params[1].dwValue,
+                    params[2].dwValue,
+                    params[3].dwValue,
+                    params[4].dwValue,
+                    params[5].dwValue
+                    );
+
+
+                //
+                // BUGBUG
+                //
+                // Currently (12/28/94) TAPI.DLL is calling back into the
+                // SP to clean up calls & lines even after the CLOSE msg
+                // is sent.
+                //
+
+                if (params[2].dwValue == LINE_CLOSE)
+                {
+                    //
+                    // See if we can match the htLine specified by the user
+                    // against those in the widgets list, and if so nuke
+                    // the line & all calls on that line
+                    //
+
+                    pWidget = gaWidgets;
+
+                    while (pWidget)
+                    {
+                        if ((pWidget->dwType == WT_DRVLINE) &&
+                            ( (DWORD) (((PDRVLINE)pWidget)->htLine) ==
+                                params[0].dwValue))
+                        {
+                            // BUGBUG must clean up all pending reqs
+
+                            ShowStr ("Forcibly closing line, any pending reqs NOT completed");
+
+                            ((PDRVLINE)pWidget)->htLine = (HTAPILINE) NULL;
+
+                            pWidget = pWidget->pNext;
+
+                            while (pWidget->dwType == WT_DRVCALL)
+                            {
+                                PDRVWIDGET pWidgetNext = pWidget->pNext;
+
+                                FreeCall ((PDRVCALL) pWidget);
+
+                                pWidget = pWidgetNext;
+                            }
+
+                            UpdateWidgetList();
+
+                            break;
+                        }
+
+                        pWidget = pWidget->pNext;
+                    }
+                }
+            }
+
+            break;
+        }
+        case IDC_BUTTON2:
+        {
+            EVENT_PARAM params[] =
+            {
+                { "htPhone",  PT_DWORD,   0, NULL },
+                { "dwMsg",    PT_ORDINAL, 0, aPhoneMsgs },
+                { "dwParam1", PT_DWORD,   0, NULL },
+                { "dwParam2", PT_DWORD,   0, NULL },
+                { "dwParam3", PT_DWORD,   0, NULL }
+            };
+            EVENT_PARAM_HEADER paramsHeader =
+                { 5, "Phone event", XX_PHONEEVENT, params };
+            PDRVWIDGET pWidget = GetSelectedWidget();
+
+
+            //
+            // If the selected widget is a phone then reset the default
+            //
+
+            if (pWidget)
+            {
+                if (pWidget->dwType == WT_DRVPHONE)
+                {
+                    params[0].dwValue = (DWORD)
+                        (((PDRVPHONE)pWidget)->htPhone);
+                }
+            }
+
+            if (DialogBoxParam(
+                    hInst,
+                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                    (HWND) hwnd,
+                    (DLGPROC) CallDlgProc,
+                    (LPARAM) &paramsHeader
+                    ) == IDOK)
+            {
+                //
+                // BUGBUG Currently the pfnPhoneCreateProc == pfnPhoneEventProc
+                //
+
+                (*gpfnPhoneCreateProc)(
+                    (HTAPIPHONE) params[0].dwValue,
+                    params[1].dwValue,
+                    params[2].dwValue,
+                    params[3].dwValue,
+                    params[4].dwValue
+                    );
+
+                ShowPhoneEvent(
+                    (HTAPIPHONE) params[0].dwValue,
+                    params[1].dwValue,
+                    params[2].dwValue,
+                    params[3].dwValue,
+                    params[4].dwValue
+                    );
+
+                if (params[1].dwValue == PHONE_CLOSE)
+                {
+                    //
+                    // See if we can match the htPhone specified by the
+                    // user against those in the widgets list, and if so
+                    // nuke the phone
+                    //
+
+                    pWidget = gaWidgets;
+
+                    while (pWidget)
+                    {
+                        if ((pWidget->dwType == WT_DRVPHONE) &&
+                            ( (DWORD) (((PDRVPHONE)pWidget)->htPhone) ==
+                                params[0].dwValue))
+                        {
+                            // BUGBUG must clean up all pending reqs
+
+                            ShowStr ("Forcibly closing phone, any pending reqs NOT completed");
+
+                            ((PDRVPHONE)pWidget)->htPhone = (HTAPIPHONE) NULL;
+
+                            UpdateWidgetList();
+
+                            break;
+                        }
+
+                        pWidget = pWidget->pNext;
+                    }
+                }
+            }
+
+            break;
+        }
+        case IDC_BUTTON3:
+        {
+            PDRVWIDGET pWidget = GetSelectedWidget();
+            PDRVCALL pCall;
+
+
+            if (!pWidget ||
+                (pWidget->dwType != WT_DRVLINE) ||
+                !((PDRVLINE)pWidget)->htLine)
+            {
+                MessageBox(
+                    hwnd,
+                    "You must select an open provider line",
+                    "Creating an incoming call",
+                    MB_OK
+                    );
+
+                break;
+            }
+
+            AllocCall(
+                (PDRVLINE) pWidget,
+                (HTAPICALL) NULL,
+                (LPLINECALLPARAMS) NULL,
+                &pCall
+                );
+
+            SendLineEvent(
+                (PDRVLINE) pWidget,
+                NULL, //pCall,
+                LINE_NEWCALL,
+                (DWORD) pCall,
+                (DWORD) &pCall->htCall,
+                0
+                );
+
+            if (!pCall->htCall)
+            {
+                 // BUGBUG try again
+
+                 break;
+            }
+            else
+            {
+                //
+                // Make sure htCall gets shown
+                //
+
+                UpdateWidgetList();
+            }
+
+            SendMessage(
+                ghwndList1,
+                LB_SETCURSEL,
+                (WPARAM) (GetWidgetIndex ((PDRVWIDGET) pCall)),
+                0
+                );
+
+
+            //
+            // Bring up the props dlg for the call automatically so user
+            // can select call state
+            //
+
+            WidgetPropertiesDialog ((PDRVWIDGET) pCall, TRUE);
+
+            break;
+        }
+        case IDC_BUTTON4:
+
+            SetDlgItemText (hwnd, IDC_EDIT1, "");
+
+            break;
+
+        case IDC_LIST1:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_DBLCLK)
+#else
+            if (HIWORD(lParam) == LBN_DBLCLK)
+#endif
+            {
+                PDRVWIDGET pWidget = GetSelectedWidget();
+
+
+                if (!pWidget)
+                {
+                    return FALSE;
+                }
+
+                WidgetPropertiesDialog (pWidget, FALSE);
+            }
+
+            break;
+
+        case IDC_LIST2:
+
+CompleteAsyncRequest:
+
+#ifdef WIN32
+            if (HIWORD(wParam) == LBN_DBLCLK)
+#else
+            if (HIWORD(lParam) == LBN_DBLCLK)
+#endif
+            {
+                int iSelIndex = (int) SendMessage(ghwndList2,LB_GETCURSEL,0,0);
+                char buf[64] = "Completing ";
+                char far *lpszFuncName;
+                PASYNC_REQUEST_INFO pAsyncReqInfo = (PASYNC_REQUEST_INFO)
+                    SendMessage(
+                        ghwndList2,
+                        LB_GETITEMDATA,
+                        (WPARAM) iSelIndex,
+                        0
+                        );
+
+
+                SendMessage(
+                    ghwndList2,
+                    LB_GETTEXT,
+                    (WPARAM) iSelIndex,
+                    (LPARAM) &buf[11]
+                    );
+
+                lpszFuncName = strstr (buf, "TSP") + 5;
+
+                if (gbManualResults)
+                {
+                    EVENT_PARAM params[] =
+                    {
+                        { "lResult", PT_ORDINAL, 0, aLineErrs }
+                    };
+                    EVENT_PARAM_HEADER paramsHeader =
+                        { 1, buf, XX_REQRESULT, params };
+
+
+                    if (strstr (buf, "pho"))
+                    {
+                        params[0].u.pLookup = aPhoneErrs;
+                    }
+
+                    if (DialogBoxParam(
+                            hInst,
+                            (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                            (HWND) hwnd,
+                            (DLGPROC) CallDlgProc,
+                            (LPARAM) &paramsHeader
+                            ) == IDCANCEL)
+                    {
+                        break;
+                    }
+
+                    pAsyncReqInfo->lResult = (LONG) params[0].dwValue;
+                }
+
+
+                if (pAsyncReqInfo->pfnPostProcessProc)
+                {
+
+                    (*((POSTPROCESSPROC)pAsyncReqInfo->pfnPostProcessProc))(
+                        lpszFuncName,
+                        pAsyncReqInfo,
+                        FALSE
+                        );
+                }
+                else
+                {
+                    DoCompletion(
+                        lpszFuncName,
+                        pAsyncReqInfo->dwRequestID,
+                        pAsyncReqInfo->lResult,
+                        FALSE
+                        );
+                }
+
+                DrvFree (pAsyncReqInfo);
+
+                SendMessage(
+                    ghwndList2,
+                    LB_DELETESTRING,
+                    (WPARAM) iSelIndex,
+                    0
+                    );
+            }
+
+            break;
+
+        } //switch
+
+        break;
+    }
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+
+        BeginPaint (hwnd, &ps);
+
+        if (IsIconic (hwnd))
+        {
+            DrawIcon (ps.hdc, 0, 0, hIcon);
+        }
+        else
+        {
+            FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+#ifdef WIN32
+            MoveToEx (ps.hdc, 0, 0, NULL);
+#else
+            MoveTo (ps.hdc, 0, 0);
+#endif
+            LineTo (ps.hdc, 5000, 0);
+
+#ifdef WIN32
+            MoveToEx (ps.hdc, 0, icyButton - 4, NULL);
+#else
+            MoveTo (ps.hdc, 0, icyButton - 4);
+#endif
+            LineTo (ps.hdc, 5000, icyButton - 4);
+        }
+
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    case WM_SIZE:
+    {
+        LONG width = (LONG)LOWORD(lParam);
+
+
+        //
+        // Adjust globals based on new size
+        //
+
+        cxList1 = (cxList1 * width) / cxWnd;
+        cxWnd = width;
+        cyWnd = ((int)HIWORD(lParam)) - icyButton;
+
+
+        //
+        // Now reposition the child windows
+        //
+
+        SetWindowPos(
+            ghwndList1,
+            GetNextWindow (ghwndList1, GW_HWNDPREV),
+            0,
+            icyButton,
+            (int) cxList1,
+            2*cyWnd/3,
+            SWP_SHOWWINDOW
+            );
+
+        SetWindowPos(
+            ghwndList2,
+            GetNextWindow (ghwndList2, GW_HWNDPREV),
+            0,
+            icyButton + 2*cyWnd/3 + icyBorder,
+            (int) cxList1,
+            cyWnd/3 - icyBorder,
+            SWP_SHOWWINDOW
+            );
+
+        SetWindowPos(
+            ghwndEdit,
+            GetNextWindow (ghwndEdit, GW_HWNDPREV),
+            (int) cxList1 + icyBorder,
+            icyButton,
+            (int)width - ((int)cxList1 + icyBorder),
+            cyWnd,
+            SWP_SHOWWINDOW
+            );
+
+        InvalidateRect (hwnd, NULL, TRUE);
+
+        break;
+    }
+    case WM_MOUSEMOVE:
+    {
+        LONG x = (LONG)((short)LOWORD(lParam));
+        int y = (int)((short)HIWORD(lParam));
+        int cxList1New;
+
+
+        if (((y > icyButton) && (x > cxList1)) || bCaptured)
+        {
+            SetCursor(
+                LoadCursor ((HINSTANCE) NULL, MAKEINTRESOURCE(IDC_SIZEWE))
+                );
+        }
+
+        if (bCaptured)
+        {
+            x = (x < cxVScroll ?  cxVScroll : x);
+            x = (x > (cxWnd - cxVScroll) ?  (cxWnd - cxVScroll) : x);
+
+            cxList1New = (int) (cxList1 + x - xCapture);
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                0,
+                icyButton,
+                cxList1New,
+                2*cyWnd/3,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndList2,
+                GetNextWindow (ghwndList2, GW_HWNDPREV),
+                0,
+                icyButton + 2*cyWnd/3 + icyBorder,
+                cxList1New,
+                cyWnd/3 - icyBorder,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndEdit,
+                GetNextWindow (ghwndEdit, GW_HWNDPREV),
+                (int) cxList1New + icyBorder,
+                icyButton,
+                (int)cxWnd - (cxList1New + icyBorder),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+        }
+
+        break;
+    }
+    case WM_LBUTTONDOWN:
+    {
+        if (((int)((short)HIWORD(lParam)) > icyButton) &&
+             ((int)((short)LOWORD(lParam)) > cxList1))
+        {
+            xCapture = (LONG)LOWORD(lParam);
+
+            SetCapture (hwnd);
+
+            bCaptured = TRUE;
+        }
+
+        break;
+    }
+    case WM_LBUTTONUP:
+    {
+        if (bCaptured)
+        {
+            POINT p;
+            LONG  x;
+
+            GetCursorPos (&p);
+            MapWindowPoints (HWND_DESKTOP, hwnd, &p, 1);
+            x = (LONG) p.x;
+
+            ReleaseCapture();
+
+            x = (x < cxVScroll ? cxVScroll : x);
+            x = (x > (cxWnd - cxVScroll) ? (cxWnd - cxVScroll) : x);
+
+            cxList1 = cxList1 + (x - xCapture);
+
+            bCaptured = FALSE;
+
+            InvalidateRect (hwnd, NULL, TRUE);
+        }
+
+        break;
+    }
+    case WM_CLOSE:
+
+        SaveIniSettings();
+        ghwndEdit = ghwndList1 = (HWND) NULL;
+        DestroyIcon (hIcon);
+        DeleteObject (hFont);
+        gbExeStarted = FALSE;
+        PostQuitMessage (0);
+        break;
+
+    } // switch
+
+    return FALSE;
+}
+
+
+void
+TSPIAPI
+DllMsgLoop(
+    void
+    )
+{
+    MSG msg;
+    HACCEL  hAccel;
+
+
+    OutputDebugString ("ESP: DllMsgLoop: enter\n\r");
+
+    ghwndMain = CreateDialog(
+        hInst,
+        (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG1),
+        (HWND)NULL,
+        (DLGPROC) MainWndProc
+        );
+
+    if (!ghwndMain)
+    {
+        OutputDebugString ("ESP.TSP: DllMsgLoop: CreateDlg failed\n\r");
+    }
+
+    hAccel = LoadAccelerators(
+        hInst,
+        (LPCSTR)MAKEINTRESOURCE(IDR_ACCELERATOR1)
+        );
+
+    while (GetMessage (&msg, (HWND) NULL, 0, 0))
+    {
+        if (!TranslateAccelerator (ghwndMain, hAccel, &msg))
+        {
+            TranslateMessage (&msg);
+            DispatchMessage (&msg);
+        }
+    }
+
+#ifdef WIN32
+
+    DestroyWindow (ghwndMain);
+
+    DestroyAcceleratorTable (hAccel);
+
+#endif
+
+    ghwndMain = (HWND) NULL;
+}
+
+
+void
+PASCAL
+SendLineEvent(
+    PDRVLINE    pLine,
+    PDRVCALL    pCall,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    //
+    //
+    //
+
+    (*(pLine->lpfnEventProc))(
+        pLine->htLine,
+        (pCall ? pCall->htCall : (HTAPICALL) NULL),
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+
+    if (dwMsg == LINE_CALLSTATE)
+    {
+        PostUpdateWidgetListMsg();
+    }
+
+    ShowLineEvent(
+        pLine->htLine,
+        (pCall ? pCall->htCall : (HTAPICALL) NULL),
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+}
+
+
+void
+PASCAL
+SendPhoneEvent(
+    PDRVPHONE   pPhone,
+    DWORD       dwMsg,
+    DWORD       dwParam1,
+    DWORD       dwParam2,
+    DWORD       dwParam3
+    )
+{
+    //
+    //
+    //
+
+    (*(pPhone->lpfnEventProc))(
+        pPhone->htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+
+    ShowPhoneEvent(
+        pPhone->htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+}
+
+
+void
+PASCAL
+DoCompletion(
+    char far *lpszFuncName,
+    DWORD     dwRequestID,
+    LONG      lResult,
+    BOOL      bSync
+    )
+{
+    (*gpfnCompletionProc)(dwRequestID, lResult);
+
+    if (gbShowCompletions)
+    {
+        ShowStr(
+            "%sTSPI_%s: calling compl proc (%ssync), dwReqID=x%lx, lResult = x%lx",
+            szCallUp,
+            lpszFuncName,
+            (bSync ? "" : "a"),
+            dwRequestID,
+            lResult
+            );
+    }
+}
+
+
+void
+PASCAL
+SetCallState(
+    PDRVCALL pCall,
+    DWORD    dwCallState,
+    DWORD    dwCallStateMode
+    )
+{
+    //
+    // First, check the current call state. Never send another call state
+    // msg on a call once you've sent a LINECALLSTATE_IDLE msg (because
+    // it'll hose apps, and calls instances aren't supposed to be reused).
+    //
+
+    if (pCall->dwCallState == LINECALLSTATE_IDLE)
+    {
+        ShowStr(
+            "SetCallState: call x%lx is IDLE, not changing call state",
+            pCall
+            );
+
+        return;
+    }
+
+
+    //
+    // Next, check to see if the new state matches the current state, and
+    // if so just return.
+    //
+
+    if (dwCallState == pCall->dwCallState)
+    {
+        ShowStr(
+            "SetCallState: not sending call x%lx state msg " \
+                "(new state = current state)",
+            pCall
+            );
+
+        return;
+    }
+
+
+    //
+    // Change the call state & notify TAPI
+    //
+
+    pCall->dwCallState     = dwCallState;
+    pCall->dwCallStateMode = dwCallStateMode;
+
+    SendLineEvent(
+        pCall->pLine,
+        pCall,
+        LINE_CALLSTATE,
+        dwCallState,
+        dwCallStateMode,
+        pCall->LineCallInfo.dwMediaMode
+        );
+}
+
+
+LPVOID
+DrvAlloc(
+    size_t numBytes
+    )
+{
+    LPVOID p = (LPVOID) malloc (numBytes);
+
+
+    if (!p)
+    {
+        ShowStr ("Error: DrvAlloc (x%lx) failed", (DWORD) numBytes);
+    }
+
+    return p;
+}
+
+
+void
+DrvFree(
+    LPVOID lp
+    )
+{
+    free (lp);
+}
+
+
+void
+SaveIniSettings(
+    void
+    )
+{
+    char buf[32];
+    RECT rect;
+
+
+    GetWindowRect (ghwndMain, &rect);
+
+    {
+        typedef struct _SAVE_VALUE
+        {
+            char    *lpszVal;
+
+            DWORD   dwValue;
+
+        } SAVE_VALUE, *PSAVE_VALUE;
+
+        SAVE_VALUE aValues[] =
+        {
+            { "Left",                (DWORD) rect.left             },
+            { "Top",                 (DWORD) rect.top              },
+            { "Right",               (DWORD) rect.right            },
+            { "Bottom",              (DWORD) rect.bottom           },
+            { "cxWnd",               (DWORD) cxWnd                 },
+            { "cxList1",             (DWORD) cxList1               },
+            { "ShowFuncEntry",       (DWORD) gbShowFuncEntry       },
+            { "ShowFuncExit",        (DWORD) gbShowFuncExit        },
+            { "ShowFuncParams",      (DWORD) gbShowFuncParams      },
+            { "ShowEvents",          (DWORD) gbShowEvents          },
+            { "ShowCompletions",     (DWORD) gbShowCompletions     },
+            { "AutoClose",           (DWORD) gbAutoClose           },
+            { "SyncCompl",           (DWORD) gbSyncCompl           },
+            { "AsyncCompl",          (DWORD) gbAsyncCompl          },
+            { "ManualCompl",         (DWORD) gbManualCompl         },
+            { "ManualResults",       (DWORD) gbManualResults       },
+            { "ShowLineGetIDDlg",    (DWORD) gbShowLineGetIDDlg    },
+            { "DisableUI",           (DWORD) gbDisableUI           },
+            { NULL,                  0 },
+            { "TSPIVersion",         gdwTSPIVersion                },
+            { "NumLines",            gdwNumLines                   },
+            { "NumAddrsPerLine",     gdwNumAddrsPerLine            },
+            { "NumPhones",           gdwNumPhones                  },
+            { "LineExtID0",          gLineExtID.dwExtensionID0     },
+            { "LineExtID1",          gLineExtID.dwExtensionID1     },
+            { "LineExtID2",          gLineExtID.dwExtensionID2     },
+            { "LineExtID3",          gLineExtID.dwExtensionID3     },
+            { "PhoneExtID0",         gPhoneExtID.dwExtensionID0    },
+            { "PhoneExtID1",         gPhoneExtID.dwExtensionID1    },
+            { "PhoneExtID2",         gPhoneExtID.dwExtensionID2    },
+            { "PhoneExtID3",         gPhoneExtID.dwExtensionID3    },
+            { "OutCallState1",       aOutCallStates[0]             },
+            { "OutCallStateMode1",   aOutCallStateModes[0]         },
+            { "OutCallState2",       aOutCallStates[1]             },
+            { "OutCallStateMode2",   aOutCallStateModes[1]         },
+            { "OutCallState3",       aOutCallStates[2]             },
+            { "OutCallStateMode3",   aOutCallStateModes[2]         },
+            { "OutCallState4",       aOutCallStates[3]             },
+            { "OutCallStateMode4",   aOutCallStateModes[3]         },
+            { "DefLineGetIDID",      gdwDefLineGetIDID             },
+            { NULL,                  0 }
+        };
+        int i;
+
+
+        for (i = 0; aValues[i].lpszVal; i++)
+        {
+            wsprintf (buf, "%ld", aValues[i].dwValue); // decimal
+
+            WriteProfileString(
+               szMySection,
+               aValues[i].lpszVal,
+               (LPCSTR) buf
+               );
+        }
+
+        for (++i; aValues[i].lpszVal; i++)
+        {
+            wsprintf (buf, "%lx", aValues[i].dwValue); // hex for DWORDs
+
+            WriteProfileString(
+               szMySection,
+               aValues[i].lpszVal,
+               (LPCSTR) buf
+               );
+        }
+
+        if (IsIconic (ghwndMain))
+        {
+            WriteProfileString(
+                szMySection,
+                "Left",
+                "min"
+                );
+        }
+        else if (IsZoomed (ghwndMain))
+        {
+            WriteProfileString(
+                szMySection,
+                "Left",
+                "max"
+                );
+        }
+    }
+}
+
+
+BOOL
+IsESPInstalled(
+    HWND    hwnd
+    )
+{
+    int     i, iNumProviders;
+    BOOL    bResult = FALSE;
+
+
+    iNumProviders = GetPrivateProfileInt(
+        szProviders,
+        szNumProviders,
+        0,
+        szTelephonIni
+        );
+
+    for (i = 0; i < iNumProviders; i++)
+    {
+        char szProviderFilenameN[32], szProviderName[32];
+
+
+        wsprintf (szProviderFilenameN, "%s%d", szProviderFilename, i);
+
+        GetPrivateProfileString(
+            szProviders,
+            szProviderFilenameN,
+            "",
+            szProviderName,
+            31,
+            szTelephonIni
+            );
+
+        if (_stricmp (szProviderName, szEspTsp) == 0)
+        {
+            MessageBox(
+                hwnd,
+                "ESP is already installed.",
+                "Installing ESP",
+                MB_OK
+                );
+
+            bResult =  TRUE;
+            break;
+        }
+    }
+
+    return bResult;
+}
diff --git a/private/tapi/dev/sp/esp/esp.def b/private/tapi/dev/sp/esp/esp.def
new file mode 100644
index 000000000..3c53f1b75
--- /dev/null
+++ b/private/tapi/dev/sp/esp/esp.def
@@ -0,0 +1,117 @@
+LIBRARY     ESP
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept                         @500
+        TSPI_lineAddToConference                @501
+        TSPI_lineAnswer                         @502
+        TSPI_lineBlindTransfer                  @503
+        TSPI_lineClose                          @504
+        TSPI_lineCloseCall                      @505
+        TSPI_lineCompleteCall                   @506
+        TSPI_lineCompleteTransfer               @507
+        TSPI_lineConditionalMediaDetection      @508
+        TSPI_lineConfigDialog                   @509
+        TSPI_lineDevSpecific                    @510
+        TSPI_lineDevSpecificFeature             @511
+        TSPI_lineDial                           @512
+        TSPI_lineDrop                           @513
+        TSPI_lineForward                        @514
+        TSPI_lineGatherDigits                   @515
+        TSPI_lineGenerateDigits                 @516
+        TSPI_lineGenerateTone                   @517
+        TSPI_lineGetAddressCaps                 @518
+        TSPI_lineGetAddressID                   @519
+        TSPI_lineGetAddressStatus               @520
+        TSPI_lineGetCallAddressID               @521
+        TSPI_lineGetCallInfo                    @522
+        TSPI_lineGetCallStatus                  @523
+        TSPI_lineGetDevCaps                     @524
+        TSPI_lineGetDevConfig                   @525
+        TSPI_lineGetExtensionID                 @526
+        TSPI_lineGetIcon                        @527
+        TSPI_lineGetID                          @528
+        TSPI_lineGetLineDevStatus               @529
+        TSPI_lineGetNumAddressIDs               @530
+        TSPI_lineHold                           @531
+        TSPI_lineMakeCall                       @532
+        TSPI_lineMonitorDigits                  @533
+        TSPI_lineMonitorMedia                   @534
+        TSPI_lineMonitorTones                   @535
+        TSPI_lineNegotiateExtVersion            @536
+        TSPI_lineNegotiateTSPIVersion           @537
+        TSPI_lineOpen                           @538
+        TSPI_linePark                           @539
+        TSPI_linePickup                         @540
+        TSPI_linePrepareAddToConference         @541
+        TSPI_lineRedirect                       @542
+        TSPI_lineRemoveFromConference           @543
+        TSPI_lineSecureCall                     @544
+        TSPI_lineSelectExtVersion               @545
+        TSPI_lineSendUserUserInfo               @546
+        TSPI_lineSetAppSpecific                 @547
+        TSPI_lineSetCallParams                  @548
+        TSPI_lineSetDefaultMediaDetection       @549
+        TSPI_lineSetDevConfig                   @550
+        TSPI_lineSetMediaControl                @551
+        TSPI_lineSetMediaMode                   @552
+        TSPI_lineSetStatusMessages              @553
+        TSPI_lineSetTerminal                    @554
+        TSPI_lineSetupConference                @555
+        TSPI_lineSetupTransfer                  @556
+        TSPI_lineSwapHold                       @557
+        TSPI_lineUncompleteCall                 @558
+        TSPI_lineUnhold                         @559
+        TSPI_lineUnpark                         @560
+
+        TSPI_phoneClose                         @561
+        TSPI_phoneConfigDialog                  @562
+        TSPI_phoneDevSpecific                   @563
+        TSPI_phoneGetButtonInfo                 @564
+        TSPI_phoneGetData                       @565
+        TSPI_phoneGetDevCaps                    @566
+        TSPI_phoneGetDisplay                    @567
+        TSPI_phoneGetExtensionID                @568
+        TSPI_phoneGetGain                       @569
+        TSPI_phoneGetHookSwitch                 @570
+        TSPI_phoneGetIcon                       @571
+        TSPI_phoneGetID                         @572
+        TSPI_phoneGetLamp                       @573
+        TSPI_phoneGetRing                       @574
+        TSPI_phoneGetStatus                     @575
+        TSPI_phoneGetVolume                     @576
+        TSPI_phoneNegotiateExtVersion           @577
+        TSPI_phoneNegotiateTSPIVersion          @578
+        TSPI_phoneOpen                          @579
+        TSPI_phoneSelectExtVersion              @580
+        TSPI_phoneSetButtonInfo                 @581
+        TSPI_phoneSetData                       @582
+        TSPI_phoneSetDisplay                    @583
+        TSPI_phoneSetGain                       @584
+        TSPI_phoneSetHookSwitch                 @585
+        TSPI_phoneSetLamp                       @586
+        TSPI_phoneSetRing                       @587
+        TSPI_phoneSetStatusMessages             @588
+        TSPI_phoneSetVolume                     @589
+
+        TSPI_providerConfig                     @590
+        TSPI_providerInit                       @591
+        TSPI_providerInstall                    @592
+        TSPI_providerRemove                     @593
+        TSPI_providerShutdown                   @594
+
+        TSPI_providerEnumDevices                @595
+        TSPI_lineDropOnClose                    @596
+        TSPI_lineDropNoOwner                    @597
+        TSPI_providerCreateLineDevice           @598
+        TSPI_providerCreatePhoneDevice          @599
+        TSPI_lineSetCurrentLocation             @600
+        TSPI_lineConfigDialogEdit               @601
+        TSPI_lineReleaseUserUserInfo            @602
+
+        DllMsgLoop
+        MainWndProc
+        AboutDlgProc
+        CallDlgProc
diff --git a/private/tapi/dev/sp/esp/esp.h b/private/tapi/dev/sp/esp/esp.h
new file mode 100644
index 000000000..71d07ed1a
--- /dev/null
+++ b/private/tapi/dev/sp/esp/esp.h
@@ -0,0 +1,631 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    esp.h
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+#include <windows.h>
+#include <stddef.h>
+
+#ifdef WIN32
+#define __loadds
+#endif
+
+#include <tapi.h>
+#include <tspi.h>
+
+#include "resource.h"
+
+
+#define TEXT_BUF_SIZE           4096
+
+#define WM_ADDTEXT              (WM_USER+0x55)
+#define WM_UPDATEWIDGETLIST     (WM_USER+0x56)
+#define WM_ASYNCCOMPL           (WM_USER+0x57)
+#define WM_MANUALCOMPL          (WM_USER+0x58)
+#define ESP_MSG_KEY             0x1234
+
+#define XX_LINEEVENT            1
+#define XX_PHONEEVENT           2
+#define XX_DEFAULTS             3
+#define XX_CALL                 4
+#define XX_OUTCALLSTATEPROG     5
+#define XX_REQRESULTPOSTQUIT    6
+#define XX_REQRESULT            7
+#define XX_LINE                 8
+#define XX_PHONE                9
+
+#define SYNC                    0
+#define ASYNC                   1
+
+#define WT_DRVLINE              1
+#define WT_DRVCALL              2
+#define WT_DRVPHONE             3
+
+#define PT_DWORD                1
+#define PT_FLAGS                2
+//#define PT_POINTER              3
+#define PT_STRING               4
+#define PT_ORDINAL              5
+
+#define MAX_STRING_PARAM_SIZE   32
+
+#define MAX_OUT_CALL_STATES     4
+
+#define ALL_ADDRESS_FEATURES       (LINEADDRFEATURE_FORWARD          | \
+                                    LINEADDRFEATURE_MAKECALL         | \
+                                    LINEADDRFEATURE_PICKUP           | \
+                                    LINEADDRFEATURE_SETMEDIACONTROL  | \
+                                    LINEADDRFEATURE_SETTERMINAL      | \
+                                    LINEADDRFEATURE_SETUPCONF        | \
+                                    LINEADDRFEATURE_UNCOMPLETECALL   | \
+                                    LINEADDRFEATURE_UNPARK)
+#define ALL_ADDRESS_MODES          (LINEADDRESSMODE_ADDRESSID        | \
+                                    LINEADDRESSMODE_DIALABLEADDR)
+#define ALL_ADDRESS_STATES         (LINEADDRESSSTATE_OTHER           | \
+                                    LINEADDRESSSTATE_DEVSPECIFIC     | \
+                                    LINEADDRESSSTATE_INUSEZERO       | \
+                                    LINEADDRESSSTATE_INUSEONE        | \
+                                    LINEADDRESSSTATE_INUSEMANY       | \
+                                    LINEADDRESSSTATE_NUMCALLS        | \
+                                    LINEADDRESSSTATE_FORWARD         | \
+                                    LINEADDRESSSTATE_TERMINALS       | \
+                                    LINEADDRESSSTATE_CAPSCHANGE)
+#define ALL_BEARER_MODES           (LINEBEARERMODE_VOICE             | \
+                                    LINEBEARERMODE_SPEECH            | \
+                                    LINEBEARERMODE_MULTIUSE          | \
+                                    LINEBEARERMODE_DATA              | \
+                                    LINEBEARERMODE_ALTSPEECHDATA     | \
+                                    LINEBEARERMODE_NONCALLSIGNALING  | \
+                                    LINEBEARERMODE_PASSTHROUGH)
+#define ALL_BUSY_MODES             (LINEBUSYMODE_STATION             | \
+                                    LINEBUSYMODE_TRUNK               | \
+                                    LINEBUSYMODE_UNKNOWN             | \
+                                    LINEBUSYMODE_UNAVAIL)
+#define ALL_CALL_FEATURES          (LINECALLFEATURE_ACCEPT           | \
+                                    LINECALLFEATURE_ADDTOCONF        | \
+                                    LINECALLFEATURE_ANSWER           | \
+                                    LINECALLFEATURE_BLINDTRANSFER    | \
+                                    LINECALLFEATURE_COMPLETECALL     | \
+                                    LINECALLFEATURE_COMPLETETRANSF   | \
+                                    LINECALLFEATURE_DIAL             | \
+                                    LINECALLFEATURE_DROP             | \
+                                    LINECALLFEATURE_GATHERDIGITS     | \
+                                    LINECALLFEATURE_GENERATEDIGITS   | \
+                                    LINECALLFEATURE_GENERATETONE     | \
+                                    LINECALLFEATURE_HOLD             | \
+                                    LINECALLFEATURE_MONITORDIGITS    | \
+                                    LINECALLFEATURE_MONITORMEDIA     | \
+                                    LINECALLFEATURE_MONITORTONES     | \
+                                    LINECALLFEATURE_PARK             | \
+                                    LINECALLFEATURE_PREPAREADDCONF   | \
+                                    LINECALLFEATURE_REDIRECT         | \
+                                    LINECALLFEATURE_REMOVEFROMCONF   | \
+                                    LINECALLFEATURE_SECURECALL       | \
+                                    LINECALLFEATURE_SENDUSERUSER     | \
+                                    LINECALLFEATURE_SETCALLPARAMS    | \
+                                    LINECALLFEATURE_SETMEDIACONTROL  | \
+                                    LINECALLFEATURE_SETTERMINAL      | \
+                                    LINECALLFEATURE_SETUPCONF        | \
+                                    LINECALLFEATURE_SETUPTRANSFER    | \
+                                    LINECALLFEATURE_SWAPHOLD         | \
+                                    LINECALLFEATURE_UNHOLD           | \
+                                    LINECALLFEATURE_RELEASEUSERUSERINFO)
+#define ALL_CALL_INFO_STATES       (LINECALLINFOSTATE_OTHER          | \
+                                    LINECALLINFOSTATE_DEVSPECIFIC    | \
+                                    LINECALLINFOSTATE_BEARERMODE     | \
+                                    LINECALLINFOSTATE_RATE           | \
+                                    LINECALLINFOSTATE_MEDIAMODE      | \
+                                    LINECALLINFOSTATE_APPSPECIFIC    | \
+                                    LINECALLINFOSTATE_CALLID         | \
+                                    LINECALLINFOSTATE_RELATEDCALLID  | \
+                                    LINECALLINFOSTATE_ORIGIN         | \
+                                    LINECALLINFOSTATE_REASON         | \
+                                    LINECALLINFOSTATE_COMPLETIONID   | \
+                                    LINECALLINFOSTATE_TRUNK          | \
+                                    LINECALLINFOSTATE_CALLERID       | \
+                                    LINECALLINFOSTATE_CALLEDID       | \
+                                    LINECALLINFOSTATE_CONNECTEDID    | \
+                                    LINECALLINFOSTATE_REDIRECTIONID  | \
+                                    LINECALLINFOSTATE_REDIRECTINGID  | \
+                                    LINECALLINFOSTATE_DISPLAY        | \
+                                    LINECALLINFOSTATE_USERUSERINFO   | \
+                                    LINECALLINFOSTATE_HIGHLEVELCOMP  | \
+                                    LINECALLINFOSTATE_LOWLEVELCOMP   | \
+                                    LINECALLINFOSTATE_CHARGINGINFO   | \
+                                    LINECALLINFOSTATE_TERMINAL       | \
+                                    LINECALLINFOSTATE_DIALPARAMS     | \
+                                    LINECALLINFOSTATE_MONITORMODES)
+                                    //LINECALLINFOSTATE_NUMMONITORS not SP flag
+                                    //LINECALLINFOSTATE_NUMOWNERINCR not SP flag
+                                    //LINECALLINFOSTATE_NUMOWNERDECR not SP flag
+#define ALL_CALL_PARTY_ID_FLAGS    (LINECALLPARTYID_BLOCKED          | \
+                                    LINECALLPARTYID_OUTOFAREA        | \
+                                    LINECALLPARTYID_NAME             | \
+                                    LINECALLPARTYID_ADDRESS          | \
+                                    LINECALLPARTYID_PARTIAL          | \
+                                    LINECALLPARTYID_UNKNOWN          | \
+                                    LINECALLPARTYID_UNAVAIL)
+#define ALL_CALL_STATES            (LINECALLSTATE_IDLE               | \
+                                    LINECALLSTATE_OFFERING           | \
+                                    LINECALLSTATE_ACCEPTED           | \
+                                    LINECALLSTATE_DIALTONE           | \
+                                    LINECALLSTATE_DIALING            | \
+                                    LINECALLSTATE_RINGBACK           | \
+                                    LINECALLSTATE_BUSY               | \
+                                    LINECALLSTATE_SPECIALINFO        | \
+                                    LINECALLSTATE_CONNECTED          | \
+                                    LINECALLSTATE_PROCEEDING         | \
+                                    LINECALLSTATE_ONHOLD             | \
+                                    LINECALLSTATE_CONFERENCED        | \
+                                    LINECALLSTATE_ONHOLDPENDCONF     | \
+                                    LINECALLSTATE_ONHOLDPENDTRANSFER | \
+                                    LINECALLSTATE_DISCONNECTED       | \
+                                    LINECALLSTATE_UNKNOWN)
+#define ALL_DIAL_TONE_MODES        (LINEDIALTONEMODE_NORMAL          | \
+                                    LINEDIALTONEMODE_SPECIAL         | \
+                                    LINEDIALTONEMODE_INTERNAL        | \
+                                    LINEDIALTONEMODE_EXTERNAL        | \
+                                    LINEDIALTONEMODE_UNKNOWN         | \
+                                    LINEDIALTONEMODE_UNAVAIL)
+#define ALL_DISCONNECT_MODES       (LINEDISCONNECTMODE_NORMAL        | \
+                                    LINEDISCONNECTMODE_UNKNOWN       | \
+                                    LINEDISCONNECTMODE_REJECT        | \
+                                    LINEDISCONNECTMODE_PICKUP        | \
+                                    LINEDISCONNECTMODE_FORWARDED     | \
+                                    LINEDISCONNECTMODE_BUSY          | \
+                                    LINEDISCONNECTMODE_NOANSWER      | \
+                                    LINEDISCONNECTMODE_BADADDRESS    | \
+                                    LINEDISCONNECTMODE_UNREACHABLE   | \
+                                    LINEDISCONNECTMODE_CONGESTION    | \
+                                    LINEDISCONNECTMODE_INCOMPATIBLE  | \
+                                    LINEDISCONNECTMODE_UNAVAIL       | \
+                                    LINEDISCONNECTMODE_NODIALTONE)
+#define ALL_MEDIA_MODES            (LINEMEDIAMODE_UNKNOWN            | \
+                                    LINEMEDIAMODE_INTERACTIVEVOICE   | \
+                                    LINEMEDIAMODE_AUTOMATEDVOICE     | \
+                                    LINEMEDIAMODE_DATAMODEM          | \
+                                    LINEMEDIAMODE_G3FAX              | \
+                                    LINEMEDIAMODE_TDD                | \
+                                    LINEMEDIAMODE_G4FAX              | \
+                                    LINEMEDIAMODE_DIGITALDATA        | \
+                                    LINEMEDIAMODE_TELETEX            | \
+                                    LINEMEDIAMODE_VIDEOTEX           | \
+                                    LINEMEDIAMODE_TELEX              | \
+                                    LINEMEDIAMODE_MIXED              | \
+                                    LINEMEDIAMODE_ADSI               | \
+                                    LINEMEDIAMODE_VOICEVIEW)
+#define ALL_LINE_DEV_CAP_FLAGS     (LINEDEVCAPFLAGS_CROSSADDRCONF    | \
+                                    LINEDEVCAPFLAGS_HIGHLEVCOMP      | \
+                                    LINEDEVCAPFLAGS_LOWLEVCOMP       | \
+                                    LINEDEVCAPFLAGS_MEDIACONTROL     | \
+                                    LINEDEVCAPFLAGS_MULTIPLEADDR     | \
+                                    LINEDEVCAPFLAGS_CLOSEDROP        | \
+                                    LINEDEVCAPFLAGS_DIALBILLING      | \
+                                    LINEDEVCAPFLAGS_DIALQUIET        | \
+                                    LINEDEVCAPFLAGS_DIALDIALTONE)
+#define ALL_LINE_STATES            (LINEDEVSTATE_OTHER               | \
+                                    LINEDEVSTATE_RINGING             | \
+                                    LINEDEVSTATE_CONNECTED           | \
+                                    LINEDEVSTATE_DISCONNECTED        | \
+                                    LINEDEVSTATE_MSGWAITON           | \
+                                    LINEDEVSTATE_MSGWAITOFF          | \
+                                    LINEDEVSTATE_INSERVICE           | \
+                                    LINEDEVSTATE_OUTOFSERVICE        | \
+                                    LINEDEVSTATE_MAINTENANCE         | \
+                                    LINEDEVSTATE_OPEN                | \
+                                    LINEDEVSTATE_CLOSE               | \
+                                    LINEDEVSTATE_NUMCALLS            | \
+                                    LINEDEVSTATE_NUMCOMPLETIONS      | \
+                                    LINEDEVSTATE_TERMINALS           | \
+                                    LINEDEVSTATE_ROAMMODE            | \
+                                    LINEDEVSTATE_BATTERY             | \
+                                    LINEDEVSTATE_SIGNAL              | \
+                                    LINEDEVSTATE_DEVSPECIFIC         | \
+                                    LINEDEVSTATE_REINIT              | \
+                                    LINEDEVSTATE_LOCK                | \
+                                    LINEDEVSTATE_CAPSCHANGE          | \
+                                    LINEDEVSTATE_CONFIGCHANGE        | \
+                                    LINEDEVSTATE_TRANSLATECHANGE     | \
+                                    LINEDEVSTATE_COMPLCANCEL         | \
+                                    LINEDEVSTATE_REMOVED)
+#define ALL_LINE_FEATURES          (LINEFEATURE_DEVSPECIFIC          | \
+                                    LINEFEATURE_DEVSPECIFICFEAT      | \
+                                    LINEFEATURE_FORWARD              | \
+                                    LINEFEATURE_MAKECALL             | \
+                                    LINEFEATURE_SETMEDIACONTROL      | \
+                                    LINEFEATURE_SETTERMINAL)
+#define ALL_SPECIAL_INFO           (LINESPECIALINFO_NOCIRCUIT        | \
+                                    LINESPECIALINFO_CUSTIRREG        | \
+                                    LINESPECIALINFO_REORDER          | \
+                                    LINESPECIALINFO_UNKNOWN          | \
+                                    LINESPECIALINFO_UNAVAIL)
+#define ALL_ADDRESS_CAP_FLAGS      (LINEADDRCAPFLAGS_FWDNUMRINGS     | \
+                                    LINEADDRCAPFLAGS_PICKUPGROUPID   | \
+                                    LINEADDRCAPFLAGS_SECURE          | \
+                                    LINEADDRCAPFLAGS_BLOCKIDDEFAULT  | \
+                                    LINEADDRCAPFLAGS_BLOCKIDOVERRIDE | \
+                                    LINEADDRCAPFLAGS_DIALED          | \
+                                    LINEADDRCAPFLAGS_ORIGOFFHOOK     | \
+                                    LINEADDRCAPFLAGS_DESTOFFHOOK     | \
+                                    LINEADDRCAPFLAGS_FWDCONSULT      | \
+                                    LINEADDRCAPFLAGS_SETUPCONFNULL   | \
+                                    LINEADDRCAPFLAGS_AUTORECONNECT   | \
+                                    LINEADDRCAPFLAGS_COMPLETIONID    | \
+                                    LINEADDRCAPFLAGS_TRANSFERHELD    | \
+                                    LINEADDRCAPFLAGS_TRANSFERMAKE    | \
+                                    LINEADDRCAPFLAGS_CONFERENCEHELD  | \
+                                    LINEADDRCAPFLAGS_CONFERENCEMAKE  | \
+                                    LINEADDRCAPFLAGS_PARTIALDIAL     | \
+                                    LINEADDRCAPFLAGS_FWDSTATUSVALID  | \
+                                    LINEADDRCAPFLAGS_FWDINTEXTADDR   | \
+                                    LINEADDRCAPFLAGS_FWDBUSYNAADDR   | \
+                                    LINEADDRCAPFLAGS_ACCEPTTOALERT   | \
+                                    LINEADDRCAPFLAGS_CONFDROP        | \
+                                    LINEADDRCAPFLAGS_PICKUPCALLWAIT)
+
+//
+// Note: Some fields in the following structures are dups, & so we just
+//       ignore them & copy them on the fly when necessary
+//
+//     PHONESTATUS: LampModes(Size\Offset) & DevSpecific(Size\Offset)
+//                  copied from PHONECAPS. OwnerName(Size\Offset) filled
+//                  in by TAPI.DLL
+//
+
+#define LINE_DEV_CAPS_VAR_DATA_SIZE     (6*MAX_STRING_PARAM_SIZE)
+#define LINE_DEV_STATUS_VAR_DATA_SIZE   (2*MAX_STRING_PARAM_SIZE)
+#define LINE_ADDR_CAPS_VAR_DATA_SIZE    (3*MAX_STRING_PARAM_SIZE)
+#define LINE_ADDR_STATUS_VAR_DATA_SIZE  (2*MAX_STRING_PARAM_SIZE)
+#define LINE_CALL_INFO_VAR_DATA_SIZE    (17*MAX_STRING_PARAM_SIZE)
+#define PHONE_CAPS_VAR_DATA_SIZE        (9*MAX_STRING_PARAM_SIZE)
+#define PHONE_STATUS_VAR_DATA_SIZE      (1*MAX_STRING_PARAM_SIZE)
+
+
+typedef struct _ASYNC_REQUEST_INFO
+{
+    FARPROC     pfnPostProcessProc;
+
+    DWORD       dwRequestID;
+
+    LONG        lResult;
+
+    DWORD       dwParam1;
+
+    DWORD       dwParam2;
+
+    DWORD       dwParam3;
+
+    DWORD       dwParam4;
+
+    DWORD       dwParam5;
+
+    DWORD       dwParam6;
+
+    DWORD       dwParam7;
+
+    DWORD       dwParam8;
+
+    char        szFuncName[32];
+
+} ASYNC_REQUEST_INFO, far *PASYNC_REQUEST_INFO;
+
+
+typedef void (FAR PASCAL *POSTPROCESSPROC)(char far *, PASYNC_REQUEST_INFO, BOOL);
+
+
+typedef struct _LOOKUP
+{
+    DWORD       dwVal;
+
+    char far   *lpszVal;
+
+} LOOKUP, *PLOOKUP;
+
+
+typedef struct _EVENT_PARAM
+{
+    char far    *szName;
+
+    DWORD       dwType;
+
+    DWORD       dwValue;
+
+    union
+    {
+        PLOOKUP     pLookup;
+
+        char far    *buf;
+
+        LPVOID      ptr;
+
+        DWORD       dwDefValue;
+
+    } u;
+
+} EVENT_PARAM, far *PEVENT_PARAM;
+
+
+typedef struct _EVENT_PARAM_HEADER
+{
+    DWORD       dwNumParams;
+
+    LPSTR       pszDlgTitle;
+
+    DWORD       dwEventType;
+
+    PEVENT_PARAM    aParams;
+
+} EVENT_PARAM_HEADER, far *PEVENT_PARAM_HEADER;
+
+
+typedef struct _FUNC_PARAM
+{
+    char        *lpszVal;
+
+    DWORD       dwVal;
+
+    PLOOKUP     pLookup;
+
+} FUNC_PARAM, *PFUNC_PARAM;
+
+
+typedef struct _FUNC_INFO
+{
+    char        *lpszFuncName;
+
+    DWORD       bAsync;
+
+    DWORD       dwNumParams;
+
+    PFUNC_PARAM aParams;
+
+    POSTPROCESSPROC pfnPostProcessProc;
+
+    PASYNC_REQUEST_INFO pAsyncReqInfo;
+
+    LONG        lResult;
+
+} FUNC_INFO, *PFUNC_INFO;
+
+
+typedef struct _ASYNC_REQUEST
+{
+    DWORD       dwRequestID;
+
+    LONG        lResult;
+
+} ASYNC_REQUEST, *PASYNC_REQUEST;
+
+
+typedef struct _DRVWIDGET
+{
+    DWORD       dwType;
+
+    struct _DRVWIDGET   *pNext;
+
+} DRVWIDGET, *PDRVWIDGET;
+
+
+typedef struct _DRVLINE
+{
+    DRVWIDGET   Widget;
+
+    HTAPILINE   htLine;
+
+    LINEEVENT   lpfnEventProc;
+
+    DWORD       dwDeviceID;
+
+    DWORD       dwDetectedMediaModes;
+
+    LINEDEVCAPS LineDevCaps;
+
+    char        LineDevCapsVarData[LINE_DEV_CAPS_VAR_DATA_SIZE];
+
+    LINEDEVSTATUS   LineDevStatus;
+
+    char        LineDevStatusVarData[LINE_DEV_STATUS_VAR_DATA_SIZE];
+
+    LINEADDRESSCAPS LineAddrCaps;
+
+    char        LineAddrCapsVarData[LINE_ADDR_CAPS_VAR_DATA_SIZE];
+
+    LINEADDRESSSTATUS   LineAddrStatus;
+
+    char        LineAddrStatusVarData[LINE_ADDR_STATUS_VAR_DATA_SIZE];
+
+} DRVLINE, FAR *PDRVLINE;
+
+
+typedef struct _DRVCALL
+{
+    DRVWIDGET   Widget;
+
+    PDRVLINE    pLine;
+
+    HTAPICALL   htCall;
+
+    DWORD       dwCallState;
+
+    DWORD       dwCallStateMode;
+
+    DWORD       dwCallFeatures;
+
+    struct _DRVCALL far *pConfParent;
+
+    struct _DRVCALL far *pNextConfChild;
+
+    LINECALLINFO    LineCallInfo;
+
+    char        LineAddressStatusVarData[LINE_CALL_INFO_VAR_DATA_SIZE];
+
+} DRVCALL, FAR *PDRVCALL;
+
+
+typedef struct _DRVPHONE
+{
+    DRVWIDGET   Widget;
+
+    HTAPIPHONE  htPhone;
+
+    PHONEEVENT  lpfnEventProc;
+
+    DWORD       dwDeviceID;
+
+    PHONECAPS   PhoneCaps;
+
+    char        PhoneCapsVarData[PHONE_CAPS_VAR_DATA_SIZE];
+
+    PHONESTATUS PhoneStatus;
+
+    char        PhoneStatusVarData[PHONE_STATUS_VAR_DATA_SIZE];
+
+} DRVPHONE, FAR *PDRVPHONE;
+
+
+typedef struct _LINE_EVENT_RECORD
+{
+    PDRVLINE    pLine;
+
+    HTAPICALL   htCall;
+
+    DWORD       dwMsg;
+
+    DWORD       dwParam1;
+
+    DWORD       dwParam2;
+
+    DWORD       dwParam3;
+
+} LINE_EVENT_RECORD, FAR *PLINE_EVENT_RECORD;
+
+
+BOOL
+InitGlobals(
+    );
+
+VOID
+ShowStr(
+    char *lpszFormat,
+    ...
+    );
+
+BOOL
+Prolog(
+    PFUNC_INFO pInfo
+    );
+
+LONG
+Epilog(
+    PFUNC_INFO pInfo
+    );
+
+void
+TSPIAPI
+ExeAttach(
+    void
+    );
+
+void
+TSPIAPI
+ExeDetach(
+    void
+    );
+
+LPVOID
+DrvAlloc(
+    size_t numBytes
+    );
+
+void
+DrvFree(
+    LPVOID lp
+    );
+
+void
+ESPConfigDialog(
+    void
+    );
+
+void
+TSPIAPI
+DllMsgLoop(
+    void
+    );
+
+//
+// Exports from WIDGET.C
+//
+
+PDRVLINE
+AllocLine(
+    DWORD       dwDeviceID
+    );
+
+VOID
+FreeLine(
+    PDRVLINE    pLine
+    );
+
+LONG
+AllocCall(
+    PDRVLINE    pLine,
+    HTAPICALL   htCall,
+    LPLINECALLPARAMS    lpCallParams,
+    PDRVCALL    *ppCall
+    );
+
+VOID
+FreeCall(
+    PDRVCALL    pCall
+    );
+
+PDRVPHONE
+AllocPhone(
+    DWORD       dwDeviceID
+    );
+
+VOID
+FreePhone(
+    PDRVPHONE   pPhone
+    );
+
+int
+GetWidgetIndex(
+    PDRVWIDGET  pWidget
+    );
+
+void
+UpdateWidgetList(
+    void
+    );
+
+PDRVLINE
+GetLine(
+    DWORD dwDeviceID
+    );
+
+PDRVPHONE
+GetPhone(
+    DWORD dwDeviceID
+    );
+
+void
+PostUpdateWidgetListMsg(
+    void
+    );
diff --git a/private/tapi/dev/sp/esp/esp.ico b/private/tapi/dev/sp/esp/esp.ico
new file mode 100644
index 000000000..516eb3f84
--- /dev/null
+++ b/private/tapi/dev/sp/esp/esp.ico
diff --git a/private/tapi/dev/sp/esp/esp.rc b/private/tapi/dev/sp/esp/esp.rc
new file mode 100644
index 000000000..d8a6a58fd
--- /dev/null
+++ b/private/tapi/dev/sp/esp/esp.rc
@@ -0,0 +1,224 @@
+//Microsoft App Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#ifdef WIN32
+#include "windows.h"
+#else
+#include "afxres.h"
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+#ifdef APSTUDIO_INVOKED
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 292, 217
+STYLE WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU | 
+    WS_THICKFRAME
+CAPTION "ESP: The Economical Service Provider"
+MENU IDR_MENU2
+FONT 6, "Courier"
+BEGIN
+    PUSHBUTTON      "LEvt",IDC_BUTTON1,1,1,16,16,WS_DISABLED
+    PUSHBUTTON      "PEvt",IDC_BUTTON2,19,1,16,16,WS_DISABLED
+    PUSHBUTTON      "Call+",IDC_BUTTON3,37,1,16,16,WS_DISABLED
+    PUSHBUTTON      "Clear",IDC_BUTTON4,55,1,16,16
+    EDITTEXT        IDC_EDIT1,129,19,117,195,ES_MULTILINE | ES_AUTOVSCROLL | 
+                    ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL | 0x1000
+    LISTBOX         IDC_LIST1,62,17,65,197,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LISTBOX         IDC_LIST2,0,0,0,0,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+END
+
+IDD_DIALOG2 DIALOG DISCARDABLE  0, 0, 185, 69
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "About ESPExe"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,69,50,50,14
+    LTEXT           "ESP v1.0",38,88,12,70,7
+    LTEXT           "Copyright (c) 1995 Microsoft Corporation",70,24,30,160,
+                    12
+    ICON            IDI_ICON1,IDC_STATIC1,60,5,18,20
+END
+
+IDD_DIALOG3 DIALOG DISCARDABLE  0, 0, 205, 192
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+FONT 8, "MS Sans Serif"
+BEGIN
+    LTEXT           "Parameters:",55,4,6,42,7
+    LISTBOX         IDC_LIST1,4,16,100,148,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Value:",56,116,6,30,7
+#ifdef WIN32
+    COMBOBOX        IDC_COMBO1,116,16,80,47,CBS_SIMPLE | CBS_AUTOHSCROLL |
+                    CBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+#endif
+    LTEXT           "Bit flags:",57,116,66,40,9
+    LISTBOX         IDC_LIST2,116,75,80,89,LBS_MULTIPLESEL | 
+                    LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,116,171,36,14
+    PUSHBUTTON      "Cancel",IDCANCEL,160,171,37,14
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MENU2 MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Install",                            IDM_INSTALL
+        MENUITEM "&Uninstall",                          IDM_UNINSTALL
+        MENUITEM SEPARATOR
+        MENUITEM "&Dump globals",                       IDM_DUMPGLOBALS
+#ifndef WIN32
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                               IDM_EXIT
+#endif
+    END
+    POPUP "&Options"
+    BEGIN
+        MENUITEM "&Default values...",                  IDM_DEFAULTS
+        MENUITEM SEPARATOR
+        MENUITEM "&Outgoing call state progress...",    IDM_OUTCALLSTATEPROG
+        MENUITEM SEPARATOR
+        POPUP "D&ebug Output"
+        BEGIN
+            MENUITEM "Show function &entry",            IDM_SHOWFUNCENTRY
+            MENUITEM "Show &parameters",                IDM_SHOWFUNCPARAMS
+            MENUITEM "Show function e&xit",             IDM_SHOWFUNCEXIT
+            MENUITEM "Show event &notifications",       IDM_SHOWEVENTS
+            MENUITEM "Show &completion notifications",  IDM_SHOWCOMPLETIONS
+            MENUITEM SEPARATOR
+            MENUITEM "Show &all",                       IDM_SHOWALL
+            MENUITEM "Show n&one",                      IDM_SHOWNONE
+        END
+        MENUITEM "Debug&Break() on function entry",     IDM_DEBUGBREAK
+        MENUITEM SEPARATOR
+
+        POPUP "Complete async requests"
+        BEGIN
+            MENUITEM "Synchronously",                   IDM_SYNCCOMPL
+            MENUITEM "Asynchronously",                  IDM_ASYNCCOMPL
+            MENUITEM "Manually",                        IDM_MANUALCOMPL
+        END
+        MENUITEM "User-specified request results",      IDM_MANUALRESULTS
+        MENUITEM SEPARATOR
+        MENUITEM "Disable UI (for faster auto-testing)",IDM_DISABLEUI
+#ifndef WIN32
+        MENUITEM SEPARATOR
+        MENUITEM "Close &window on shutdown",           IDM_AUTOCLOSE
+#endif
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Using ESP...",                       IDM_USAGE
+        MENUITEM SEPARATOR
+        MENUITEM "&About...",                           IDM_ABOUT
+    END
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+#if TAPI_NT
+IDI_ICON1               ICON    DISCARDABLE     "ESP.ICO"
+IDI_ICON2               ICON    DISCARDABLE     "PHONE.ICO"
+IDI_ICON3               ICON    DISCARDABLE     "LINE.ICO"
+#else
+IDI_ICON1               ICON    DISCARDABLE     "..\\ESP.ICO"
+IDI_ICON2               ICON    DISCARDABLE     "..\\PHONE.ICO"
+IDI_ICON3               ICON    DISCARDABLE     "..\\LINE.ICO"
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDR_ACCELERATOR1 ACCELERATORS DISCARDABLE
+BEGIN
+    VK_F1,     IDC_F1HELP,   VIRTKEY
+    VK_TAB,    IDC_PREVCTRL, VIRTKEY, SHIFT
+    VK_TAB,    IDC_NEXTCTRL, VIRTKEY
+    VK_RETURN, IDC_ENTER,    VIRTKEY
+END
+
+
+#ifndef APSTUDIO_INVOKED
+////////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Economical Service Provider"
+#define VER_INTERNALNAME_STR        "esp"
+#define VER_ORIGINALFILENAME_STR    "ESP.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
diff --git a/private/tapi/dev/sp/esp/esp32.def b/private/tapi/dev/sp/esp/esp32.def
new file mode 100644
index 000000000..1a3210653
--- /dev/null
+++ b/private/tapi/dev/sp/esp/esp32.def
@@ -0,0 +1,117 @@
+LIBRARY     ESP
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept                        @500
+        TSPI_lineAddToConference               @501
+        TSPI_lineAnswer                        @502
+        TSPI_lineBlindTransfer                 @503
+        TSPI_lineClose                         @504
+        TSPI_lineCloseCall                     @505
+        TSPI_lineCompleteCall                  @506
+        TSPI_lineCompleteTransfer              @507
+        TSPI_lineConditionalMediaDetection     @508
+        TSPI_lineConfigDialog                  @509
+        TSPI_lineDevSpecific                   @510
+        TSPI_lineDevSpecificFeature            @511
+        TSPI_lineDial                          @512
+        TSPI_lineDrop                          @513
+        TSPI_lineForward                       @514
+        TSPI_lineGatherDigits                  @515
+        TSPI_lineGenerateDigits                @516
+        TSPI_lineGenerateTone                  @517
+        TSPI_lineGetAddressCaps                @518
+        TSPI_lineGetAddressID                  @519
+        TSPI_lineGetAddressStatus              @520
+        TSPI_lineGetCallAddressID              @521
+        TSPI_lineGetCallInfo                   @522
+        TSPI_lineGetCallStatus                 @523
+        TSPI_lineGetDevCaps                    @524
+        TSPI_lineGetDevConfig                  @525
+        TSPI_lineGetExtensionID                @526
+        TSPI_lineGetIcon                       @527
+        TSPI_lineGetID                         @528
+        TSPI_lineGetLineDevStatus              @529
+        TSPI_lineGetNumAddressIDs              @530
+        TSPI_lineHold                          @531
+        TSPI_lineMakeCall                      @532
+        TSPI_lineMonitorDigits                 @533
+        TSPI_lineMonitorMedia                  @534
+        TSPI_lineMonitorTones                  @535
+        TSPI_lineNegotiateExtVersion           @536
+        TSPI_lineNegotiateTSPIVersion          @537
+        TSPI_lineOpen                          @538
+        TSPI_linePark                          @539
+        TSPI_linePickup                        @540
+        TSPI_linePrepareAddToConference        @541
+        TSPI_lineRedirect                      @542
+        TSPI_lineRemoveFromConference          @543
+        TSPI_lineSecureCall                    @544
+        TSPI_lineSelectExtVersion              @545
+        TSPI_lineSendUserUserInfo              @546
+        TSPI_lineSetAppSpecific                @547
+        TSPI_lineSetCallParams                 @548
+        TSPI_lineSetDefaultMediaDetection      @549
+        TSPI_lineSetDevConfig                  @550
+        TSPI_lineSetMediaControl               @551
+        TSPI_lineSetMediaMode                  @552
+        TSPI_lineSetStatusMessages             @553
+        TSPI_lineSetTerminal                   @554
+        TSPI_lineSetupConference               @555
+        TSPI_lineSetupTransfer                 @556
+        TSPI_lineSwapHold                      @557
+        TSPI_lineUncompleteCall                @558
+        TSPI_lineUnhold                        @559
+        TSPI_lineUnpark                        @560
+
+        TSPI_phoneClose                        @561
+        TSPI_phoneConfigDialog                 @562
+        TSPI_phoneDevSpecific                  @563
+        TSPI_phoneGetButtonInfo                @564
+        TSPI_phoneGetData                      @565
+        TSPI_phoneGetDevCaps                   @566
+        TSPI_phoneGetDisplay                   @567
+        TSPI_phoneGetExtensionID               @568
+        TSPI_phoneGetGain                      @569
+        TSPI_phoneGetHookSwitch                @570
+        TSPI_phoneGetIcon                      @571
+        TSPI_phoneGetID                        @572
+        TSPI_phoneGetLamp                      @573
+        TSPI_phoneGetRing                      @574
+        TSPI_phoneGetStatus                    @575
+        TSPI_phoneGetVolume                    @576
+        TSPI_phoneNegotiateExtVersion          @577
+        TSPI_phoneNegotiateTSPIVersion         @578
+        TSPI_phoneOpen                         @579
+        TSPI_phoneSelectExtVersion             @580
+        TSPI_phoneSetButtonInfo                @581
+        TSPI_phoneSetData                      @582
+        TSPI_phoneSetDisplay                   @583
+        TSPI_phoneSetGain                      @584
+        TSPI_phoneSetHookSwitch                @585
+        TSPI_phoneSetLamp                      @586
+        TSPI_phoneSetRing                      @587
+        TSPI_phoneSetStatusMessages            @588
+        TSPI_phoneSetVolume                    @589
+
+        TSPI_providerConfig                    @590
+        TSPI_providerInit                      @591
+        TSPI_providerInstall                   @592
+        TSPI_providerRemove                    @593
+        TSPI_providerShutdown                  @594
+
+        TSPI_providerEnumDevices               @595
+        TSPI_lineDropOnClose                   @596
+        TSPI_lineDropNoOwner                   @597
+        TSPI_providerCreateLineDevice          @598
+        TSPI_providerCreatePhoneDevice         @599
+        TSPI_lineSetCurrentLocation            @600
+        TSPI_lineConfigDialogEdit              @601
+        TSPI_lineReleaseUserUserInfo           @602
+
+        DllMsgLoop
+        MainWndProc
+        AboutDlgProc
+        CallDlgProc
diff --git a/private/tapi/dev/sp/esp/espexe.c b/private/tapi/dev/sp/esp/espexe.c
new file mode 100644
index 000000000..565c7672e
--- /dev/null
+++ b/private/tapi/dev/sp/esp/espexe.c
@@ -0,0 +1,67 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    espexe.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#include "esp.h"
+
+
+
+typedef void (TSPIAPI *MYFUNC)(void);
+
+
+int
+WINAPI
+WinMain(
+    HANDLE  hInstance,
+    HANDLE  hPrevInstance,
+    LPSTR   lpCmdLine,
+    int     nCmdShow
+    )
+{
+    HINSTANCE hLib = LoadLibrary ("esp.tsp");
+    MYFUNC pfnDllMsgLoop;
+
+
+    if (hLib < HINSTANCE_ERROR)
+    {
+        char buf[32];
+
+
+        wsprintf (buf, "WinExec returned %d", hLib);
+
+        MessageBox(
+            (HWND) NULL,
+            buf,
+            "ESPEXE.EXE: Error loading ESP.TSP",
+            MB_OK
+            );
+
+        return 0;
+    }
+
+    if ((pfnDllMsgLoop = (MYFUNC) GetProcAddress (hLib, "DLLMSGLOOP")))
+    {
+        (*pfnDllMsgLoop)();
+    }
+
+    FreeLibrary (hLib);
+
+    return 0;
+}
diff --git a/private/tapi/dev/sp/esp/espexe.def b/private/tapi/dev/sp/esp/espexe.def
new file mode 100644
index 000000000..4a7235c37
--- /dev/null
+++ b/private/tapi/dev/sp/esp/espexe.def
@@ -0,0 +1,6 @@
+NAME         ESPEXE
+STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+HEAPSIZE     4096
+STACKSIZE    16384
diff --git a/private/tapi/dev/sp/esp/espexe.rc b/private/tapi/dev/sp/esp/espexe.rc
new file mode 100644
index 000000000..b5fa5dee7
--- /dev/null
+++ b/private/tapi/dev/sp/esp/espexe.rc
@@ -0,0 +1,57 @@
+//Microsoft App Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+#ifdef APSTUDIO_INVOKED
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+IDI_ICON1               ICON    DISCARDABLE     "ESP.ICO"
+
+#ifndef APSTUDIO_INVOKED
+////////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
diff --git a/private/tapi/dev/sp/esp/line.ico b/private/tapi/dev/sp/esp/line.ico
new file mode 100644
index 000000000..6c2186e09
--- /dev/null
+++ b/private/tapi/dev/sp/esp/line.ico
diff --git a/private/tapi/dev/sp/esp/makefile b/private/tapi/dev/sp/esp/makefile
new file mode 100644
index 000000000..b0bb9d98e
--- /dev/null
+++ b/private/tapi/dev/sp/esp/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   esp Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/esp/makefile.def b/private/tapi/dev/sp/esp/makefile.def
new file mode 100644
index 000000000..8524448df
--- /dev/null
+++ b/private/tapi/dev/sp/esp/makefile.def
@@ -0,0 +1,46 @@
+ROOT=..\..\..\..\..\..
+
+IS_OEM=1
+IS_32 = TRUE
+WIN32=1
+WANT_C932=1
+
+DLLENTRY=DllMain
+BUILDDLL=1
+
+CLEANLIST=*.tsp
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=esp
+TARGETS=esp32.tsp
+
+SRCDIR=..
+
+
+L32EXE=esp32.tsp		# Name of exe.
+L32DEF=..\esp.def              # Our def file.
+L32MAP=esp.map		# Our map file.
+L32SYM=esp.sym		# Our sym file.
+L32RES=esp.res	# Resource file.
+L32OBJS = esp.obj vars.obj widget.obj
+L32LIBS= \
+    $(DEVROOT)\tools\c932\lib\crtdll.lib \
+    $(DEVROOT)\lib\user32.lib            \
+    $(DEVROOT)\lib\gdi32.lib            \
+    $(DEVROOT)\lib\kernel32.lib
+
+
+!include $(ROOT)\dev\master.mk
+
+
+INCLUDE=$(ROOT)\win\thunk;$(ROOT)\win\core\inc;$(INCLUDE)
+
+RCFLAGS=$(RCFLAGS) -DWIN32
+
+CFLAGS=$(CFLAGS) -DWIN32=100
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/esp/phone.ico b/private/tapi/dev/sp/esp/phone.ico
new file mode 100644
index 000000000..ee34203e3
--- /dev/null
+++ b/private/tapi/dev/sp/esp/phone.ico
diff --git a/private/tapi/dev/sp/esp/resource.h b/private/tapi/dev/sp/esp/resource.h
new file mode 100644
index 000000000..83a7de59d
--- /dev/null
+++ b/private/tapi/dev/sp/esp/resource.h
@@ -0,0 +1,60 @@
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by ESP.RC
+//
+#define IDR_MENU1                       101
+#define IDD_DIALOG1                     102
+#define IDD_DIALOG2                     103
+#define IDI_ICON1                       104
+#define IDD_DIALOG3                     105
+#define IDI_ICON2                       105
+#define IDI_ICON3                       106
+#define IDR_ACCELERATOR1                107
+#define IDC_LIST1                       1000
+#define IDC_LIST2                       1001
+#define IDC_LIST3                       1002
+#define IDC_EDIT1                       1003
+#define IDC_STATIC1                     1004
+#define IDC_BUTTON1                     1005
+#define IDC_BUTTON2                     1006
+#define IDC_BUTTON3                     1007
+#define IDC_BUTTON4                     1009
+#define IDC_COMBO1                      1010
+#define IDC_F1HELP                      1011
+#define IDC_PREVCTRL                    1012
+#define IDC_NEXTCTRL                    1013
+#define IDC_ENTER                       1014
+#define IDM_ABOUT                       40000
+#define IDM_EXIT                        40001
+#define IDM_SHOWFUNCENTRY               40002
+#define IDM_SHOWFUNCPARAMS              40003
+#define IDM_SHOWFUNCEXIT                40004
+#define IDM_SHOWEVENTS                  40005
+#define IDM_SHOWCOMPLETIONS             40006
+#define IDM_DEBUGBREAK                  40007
+#define IDM_SHOWALL                     40008
+#define IDM_SHOWNONE                    40009
+#define IDM_DEFAULTS                    40010
+#define IDM_OUTCALLSTATEPROG            40011
+#define IDM_AUTOCLOSE                   40012
+#define IDM_INSTALL                     40013
+#define IDM_UNINSTALL                   40014
+#define IDM_USAGE                       40015
+#define IDM_DUMPGLOBALS                 40016
+#define IDM_SYNCCOMPL                   40017
+#define IDM_ASYNCCOMPL                  40018
+#define IDM_MANUALCOMPL                 40019
+#define IDM_MANUALRESULTS               40020
+#define IDM_DISABLEUI                   40021
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        108
+#define _APS_NEXT_COMMAND_VALUE         40021
+#define _APS_NEXT_CONTROL_VALUE         1015
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/sp/esp/sources b/private/tapi/dev/sp/esp/sources
new file mode 100644
index 000000000..2cda20238
--- /dev/null
+++ b/private/tapi/dev/sp/esp/sources
@@ -0,0 +1,58 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=esp32
+TARGETPATH=.
+TARGETTYPE=DYNLINK
+TARGETEXT=tsp
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\gdi32.lib
+
+C_DEFINES=-DTAPI_NT=1
+
+DLLBASE=0x60000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=esp.c  \
+        vars.c \
+        widget.c \
+        esp.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/esp/vars.c b/private/tapi/dev/sp/esp/vars.c
new file mode 100644
index 000000000..4698da789
--- /dev/null
+++ b/private/tapi/dev/sp/esp/vars.c
@@ -0,0 +1,605 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    vars.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#include "esp.h"
+
+#ifdef WIN32
+#define my_far
+#else
+#define my_far _far
+#endif
+
+
+HWND        ghwndMain  = (HWND) NULL;
+HWND        ghwndEdit  = (HWND) NULL;
+HWND        ghwndList1 = (HWND) NULL;
+HWND        ghwndList2 = (HWND) NULL;
+BOOL        gbExeStarted = FALSE;
+BOOL        gbAutoClose;
+BOOL        gbShowFuncEntry;
+BOOL        gbShowFuncExit;
+BOOL        gbShowFuncParams;
+BOOL        gbShowEvents;
+BOOL        gbShowCompletions;
+BOOL        gbBreakOnFuncEntry;
+BOOL        gbDisableUI;
+BOOL        gbSyncCompl;
+BOOL        gbAsyncCompl;
+BOOL        gbManualCompl;
+BOOL        gbManualResults;
+BOOL        gbShowLineGetIDDlg;
+HICON       ghIconLine;
+HICON       ghIconPhone;
+HMENU       ghMenu = (HMENU) NULL;
+DWORD       gdwTSPIVersion;
+DWORD       gdwNumLines;
+DWORD       gdwNumAddrsPerLine;
+DWORD       gdwNumPhones;
+DWORD       gdwNumInits = 0;
+DWORD       gdwDefLineGetIDID;
+DWORD       gdwLineDeviceIDBase;
+DWORD       gdwPermanentProviderID;
+DWORD       aOutCallStates[MAX_OUT_CALL_STATES];
+DWORD       aOutCallStateModes[MAX_OUT_CALL_STATES];
+HPROVIDER   ghProvider = (HPROVIDER) NULL;
+LINEEVENT   gpfnLineCreateProc;
+PHONEEVENT  gpfnPhoneCreateProc;
+PDRVWIDGET  gaWidgets = (PDRVWIDGET) NULL;
+LINEEXTENSIONID  gLineExtID;
+PHONEEXTENSIONID gPhoneExtID;
+ASYNC_COMPLETION gpfnCompletionProc;
+LPLINEADDRESSCAPS    gpDefLineAddrCaps = (LPLINEADDRESSCAPS) NULL;
+
+
+LOOKUP my_far aPhoneStatusFlags[] =
+{
+    { PHONESTATUSFLAGS_CONNECTED       ,"CONNECTED"          },
+    { PHONESTATUSFLAGS_SUSPENDED       ,"SUSPENDED"          },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aCallParamFlags[] =
+{
+    { LINECALLPARAMFLAGS_SECURE        ,"SECURE"             },
+    { LINECALLPARAMFLAGS_IDLE          ,"IDLE"               },
+    { LINECALLPARAMFLAGS_BLOCKID       ,"BLOCKID"            },
+    { LINECALLPARAMFLAGS_ORIGOFFHOOK   ,"ORIGOFFHOOK"        },
+    { LINECALLPARAMFLAGS_DESTOFFHOOK   ,"DESTOFFHOOK"        },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aCallOrigins[] =
+{
+    { LINECALLORIGIN_OUTBOUND          ,"OUTBOUND"           },
+    { LINECALLORIGIN_INTERNAL          ,"INTERNAL"           },
+    { LINECALLORIGIN_EXTERNAL          ,"EXTERNAL"           },
+    { LINECALLORIGIN_UNKNOWN           ,"UNKNOWN"            },
+    { LINECALLORIGIN_UNAVAIL           ,"UNAVAIL"            },
+    { LINECALLORIGIN_CONFERENCE        ,"CONFERENCE"         },
+#ifdef TAPI_1_1
+    { LINECALLORIGIN_INBOUND           ,"INBOUND"            },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aCallReasons[] =
+{
+    { LINECALLREASON_DIRECT            ,"DIRECT"             },
+    { LINECALLREASON_FWDBUSY           ,"FWDBUSY"            },
+    { LINECALLREASON_FWDNOANSWER       ,"FWDNOANSWER"        },
+    { LINECALLREASON_FWDUNCOND         ,"FWDUNCOND"          },
+    { LINECALLREASON_PICKUP            ,"PICKUP"             },
+    { LINECALLREASON_UNPARK            ,"UNPARK"             },
+    { LINECALLREASON_REDIRECT          ,"REDIRECT"           },
+    { LINECALLREASON_CALLCOMPLETION    ,"CALLCOMPLETION"     },
+    { LINECALLREASON_TRANSFER          ,"TRANSFER"           },
+    { LINECALLREASON_REMINDER          ,"REMINDER"           },
+    { LINECALLREASON_UNKNOWN           ,"UNKNOWN"            },
+    { LINECALLREASON_UNAVAIL           ,"UNAVAIL"            },
+#ifdef TAPI_1_
+    { LINECALLREASON_INTRUDE           ,"INTRUDE"            },
+    { LINECALLREASON_PARKED            ,"PARKED"             },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aLineMsgs[] =
+{
+//    { LINE_ADDRESSSTATE,            "ADDRESSSTATE" },
+    { LINE_CALLDEVSPECIFIC,         "CALLDEVSPECIFIC" },
+    { LINE_CALLDEVSPECIFICFEATURE,  "CALLDEVSPECIFICFEATURE" },
+//    { LINE_CALLINFO,                "CALLINFO" },
+//    { LINE_CALLSTATE,               "CALLSTATE" },
+    { LINE_CLOSE,                   "CLOSE" },
+    { LINE_CREATE,                  "CREATE" },
+    { LINE_DEVSPECIFIC,             "DEVSPECIFIC" },
+    { LINE_DEVSPECIFICFEATURE,      "DEVSPECIFICFEATURE" },
+    { LINE_GATHERDIGITS,            "GATHERDIGITS" },
+    { LINE_GENERATE,                "GENERATE" },
+    { LINE_LINEDEVSTATE,            "LINEDEVSTATE" },
+    { LINE_MONITORDIGITS,           "MONITORDIGITS" },
+    { LINE_MONITORMEDIA,            "MONITORMEDIA" },
+    { LINE_MONITORTONE,             "MONITORTONE" },
+//    { LINE_NEWCALL,                 "NEWCALL" },
+    { 0xffffffff,                    "" }
+};
+
+
+LOOKUP my_far aPhoneMsgs[] =
+{
+    { PHONE_BUTTON,                 "BUTTON" },
+    { PHONE_CLOSE,                  "CLOSE" },
+    { PHONE_CREATE,                 "CREATE" },
+    { PHONE_DEVSPECIFIC,            "DEVSPECIFIC" },
+    { PHONE_STATE,                  "STATE" },
+    { 0xffffffff,                   "" }
+};
+
+
+LOOKUP my_far aCallerIDFlags[] =
+{
+    { LINECALLPARTYID_BLOCKED          ,"BLOCKED"            },
+    { LINECALLPARTYID_OUTOFAREA        ,"OUTOFAREA"          },
+    { LINECALLPARTYID_NAME             ,"NAME"               },
+    { LINECALLPARTYID_ADDRESS          ,"ADDRESS"            },
+    { LINECALLPARTYID_PARTIAL          ,"PARTIAL"            },
+    { LINECALLPARTYID_UNKNOWN          ,"UNKNOWN"            },
+    { LINECALLPARTYID_UNAVAIL          ,"UNAVAIL"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aCallStates[] =
+{
+    { LINECALLSTATE_IDLE               ,"IDLE"               },
+    { LINECALLSTATE_OFFERING           ,"OFFERING"           },
+    { LINECALLSTATE_ACCEPTED           ,"ACCEPTED"           },
+    { LINECALLSTATE_DIALTONE           ,"DIALTONE"           },
+    { LINECALLSTATE_DIALING            ,"DIALING"            },
+    { LINECALLSTATE_RINGBACK           ,"RINGBACK"           },
+    { LINECALLSTATE_BUSY               ,"BUSY"               },
+    { LINECALLSTATE_SPECIALINFO        ,"SPECIALINFO"        },
+    { LINECALLSTATE_CONNECTED          ,"CONNECTED"          },
+    { LINECALLSTATE_PROCEEDING         ,"PROCEEDING"         },
+    { LINECALLSTATE_ONHOLD             ,"ONHOLD"             },
+    { LINECALLSTATE_CONFERENCED        ,"CONFERENCED"        },
+    { LINECALLSTATE_ONHOLDPENDCONF     ,"ONHOLDPENDCONF"     },
+    { LINECALLSTATE_ONHOLDPENDTRANSFER ,"ONHOLDPENDTRANSFER" },
+    { LINECALLSTATE_DISCONNECTED       ,"DISCONNECTED"       },
+    { LINECALLSTATE_UNKNOWN            ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aCallInfoStates[] =
+{
+    { LINECALLINFOSTATE_OTHER          ,"OTHER"              },
+    { LINECALLINFOSTATE_DEVSPECIFIC    ,"DEVSPECIFIC"        },
+    { LINECALLINFOSTATE_BEARERMODE     ,"BEARERMODE"         },
+    { LINECALLINFOSTATE_RATE           ,"RATE"               },
+    { LINECALLINFOSTATE_MEDIAMODE      ,"MEDIAMODE"          },
+    { LINECALLINFOSTATE_APPSPECIFIC    ,"APPSPECIFIC"        },
+    { LINECALLINFOSTATE_CALLID         ,"CALLID"             },
+    { LINECALLINFOSTATE_RELATEDCALLID  ,"RELATEDCALLID"      },
+    { LINECALLINFOSTATE_ORIGIN         ,"ORIGIN"             },
+    { LINECALLINFOSTATE_REASON         ,"REASON"             },
+    { LINECALLINFOSTATE_COMPLETIONID   ,"COMPLETIONID"       },
+    { LINECALLINFOSTATE_NUMOWNERINCR   ,"NUMOWNERINCR"       },
+    { LINECALLINFOSTATE_NUMOWNERDECR   ,"NUMOWNERDECR"       },
+    { LINECALLINFOSTATE_NUMMONITORS    ,"NUMMONITORS"        },
+    { LINECALLINFOSTATE_TRUNK          ,"TRUNK"              },
+    { LINECALLINFOSTATE_CALLERID       ,"CALLERID"           },
+    { LINECALLINFOSTATE_CALLEDID       ,"CALLEDID"           },
+    { LINECALLINFOSTATE_CONNECTEDID    ,"CONNECTEDID"        },
+    { LINECALLINFOSTATE_REDIRECTIONID  ,"REDIRECTIONID"      },
+    { LINECALLINFOSTATE_REDIRECTINGID  ,"REDIRECTINGID"      },
+    { LINECALLINFOSTATE_DISPLAY        ,"DISPLAY"            },
+    { LINECALLINFOSTATE_USERUSERINFO   ,"USERUSERINFO"       },
+    { LINECALLINFOSTATE_HIGHLEVELCOMP  ,"HIGHLEVELCOMP"      },
+    { LINECALLINFOSTATE_LOWLEVELCOMP   ,"LOWLEVELCOMP"       },
+    { LINECALLINFOSTATE_CHARGINGINFO   ,"CHARGINGINFO"       },
+    { LINECALLINFOSTATE_TERMINAL       ,"TERMINAL"           },
+    { LINECALLINFOSTATE_DIALPARAMS     ,"DIALPARAMS"         },
+    { LINECALLINFOSTATE_MONITORMODES   ,"MONITORMODES"       },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aCallFeatures[] =
+{
+    { LINECALLFEATURE_ACCEPT           ,"ACCEPT"             },
+    { LINECALLFEATURE_ADDTOCONF        ,"ADDTOCONF"          },
+    { LINECALLFEATURE_ANSWER           ,"ANSWER"             },
+    { LINECALLFEATURE_BLINDTRANSFER    ,"BLINDTRANSFER"      },
+    { LINECALLFEATURE_COMPLETECALL     ,"COMPLETECALL"       },
+    { LINECALLFEATURE_COMPLETETRANSF   ,"COMPLETETRANSF"     },
+    { LINECALLFEATURE_DIAL             ,"DIAL"               },
+    { LINECALLFEATURE_DROP             ,"DROP"               },
+    { LINECALLFEATURE_GATHERDIGITS     ,"GATHERDIGITS"       },
+    { LINECALLFEATURE_GENERATEDIGITS   ,"GENERATEDIGITS"     },
+    { LINECALLFEATURE_GENERATETONE     ,"GENERATETONE"       },
+    { LINECALLFEATURE_HOLD             ,"HOLD"               },
+    { LINECALLFEATURE_MONITORDIGITS    ,"MONITORDIGITS"      },
+    { LINECALLFEATURE_MONITORMEDIA     ,"MONITORMEDIA"       },
+    { LINECALLFEATURE_MONITORTONES     ,"MONITORTONES"       },
+    { LINECALLFEATURE_PARK             ,"PARK"               },
+    { LINECALLFEATURE_PREPAREADDCONF   ,"PREPAREADDCONF"     },
+    { LINECALLFEATURE_REDIRECT         ,"REDIRECT"           },
+    { LINECALLFEATURE_REMOVEFROMCONF   ,"REMOVEFROMCONF"     },
+    { LINECALLFEATURE_SECURECALL       ,"SECURECALL"         },
+    { LINECALLFEATURE_SENDUSERUSER     ,"SENDUSERUSER"       },
+    { LINECALLFEATURE_SETCALLPARAMS    ,"SETCALLPARAMS"      },
+    { LINECALLFEATURE_SETMEDIACONTROL  ,"SETMEDIACONTROL"    },
+    { LINECALLFEATURE_SETTERMINAL      ,"SETTERMINAL"        },
+    { LINECALLFEATURE_SETUPCONF        ,"SETUPCONF"          },
+    { LINECALLFEATURE_SETUPTRANSFER    ,"SETUPTRANSFER"      },
+    { LINECALLFEATURE_SWAPHOLD         ,"SWAPHOLD"           },
+    { LINECALLFEATURE_UNHOLD           ,"UNHOLD"             },
+#ifdef TAPI_1_1
+    { LINECALLFEATURE_RELEASEUSERUSERINFO  ,"RELEASEUSERUSERINFO" },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aMediaModes[] =
+{
+    { LINEMEDIAMODE_UNKNOWN            ,"UNKNOWN"            },
+    { LINEMEDIAMODE_INTERACTIVEVOICE   ,"INTERACTIVEVOICE"   },
+    { LINEMEDIAMODE_AUTOMATEDVOICE     ,"AUTOMATEDVOICE"     },
+    { LINEMEDIAMODE_DATAMODEM          ,"DATAMODEM"          },
+    { LINEMEDIAMODE_G3FAX              ,"G3FAX"              },
+    { LINEMEDIAMODE_TDD                ,"TDD"                },
+    { LINEMEDIAMODE_G4FAX              ,"G4FAX"              },
+    { LINEMEDIAMODE_DIGITALDATA        ,"DIGITALDATA"        },
+    { LINEMEDIAMODE_TELETEX            ,"TELETEX"            },
+    { LINEMEDIAMODE_VIDEOTEX           ,"VIDEOTEX"           },
+    { LINEMEDIAMODE_TELEX              ,"TELEX"              },
+    { LINEMEDIAMODE_MIXED              ,"MIXED"              },
+    { LINEMEDIAMODE_ADSI               ,"ADSI"               },
+#ifdef TAPI_1_1
+    { LINEMEDIAMODE_VOICEVIEW          ,"VOICEVIEW"          },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP my_far aButtonModes[] =
+{
+    { PHONEBUTTONMODE_DUMMY            ,"DUMMY"              },
+    { PHONEBUTTONMODE_CALL             ,"CALL"               },
+    { PHONEBUTTONMODE_FEATURE          ,"FEATURE"            },
+    { PHONEBUTTONMODE_KEYPAD           ,"KEYPAD"             },
+    { PHONEBUTTONMODE_LOCAL            ,"LOCAL"              },
+    { PHONEBUTTONMODE_DISPLAY          ,"DISPLAY"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aButtonStates[] =
+{
+    { PHONEBUTTONSTATE_UP              ,"UP"                 },
+    { PHONEBUTTONSTATE_DOWN            ,"DOWN"               },
+#ifdef TAPI_1_1
+    { PHONEBUTTONSTATE_UNKNOWN         ,"UNKNOWN"            },
+    { PHONEBUTTONSTATE_UNAVAIL         ,"UNAVAIL"            },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP my_far aHookSwitchDevs[] =
+{
+    { PHONEHOOKSWITCHDEV_HANDSET       ,"HANDSET"            },
+    { PHONEHOOKSWITCHDEV_SPEAKER       ,"SPEAKER"            },
+    { PHONEHOOKSWITCHDEV_HEADSET       ,"HEADSET"            },
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP my_far aCallSelects[] =
+{
+    { LINECALLSELECT_LINE              ,"LINE"               },
+    { LINECALLSELECT_ADDRESS           ,"ADDRESS"            },
+    { LINECALLSELECT_CALL              ,"CALL"               },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aTransferModes[] =
+{
+    { LINETRANSFERMODE_TRANSFER        ,"TRANSFER"           },
+    { LINETRANSFERMODE_CONFERENCE      ,"CONFERENCE"         },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aDigitModes[] =
+{
+    { LINEDIGITMODE_PULSE              ,"PULSE"              },
+    { LINEDIGITMODE_DTMF               ,"DTMF"               },
+    { LINEDIGITMODE_DTMFEND            ,"DTMFEND"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aToneModes[] =
+{
+    { LINETONEMODE_CUSTOM              ,"CUSTOM"             },
+    { LINETONEMODE_RINGBACK            ,"RINGBACK"           },
+    { LINETONEMODE_BUSY                ,"BUSY"               },
+    { LINETONEMODE_BEEP                ,"BEEP"               },
+    { LINETONEMODE_BILLING             ,"BILLING"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aBearerModes[] =
+{
+    { LINEBEARERMODE_VOICE             ,"VOICE"              },
+    { LINEBEARERMODE_SPEECH            ,"SPEECH"             },
+    { LINEBEARERMODE_MULTIUSE          ,"MULTIUSE"           },
+    { LINEBEARERMODE_DATA              ,"DATA"               },
+    { LINEBEARERMODE_ALTSPEECHDATA     ,"ALTSPEECHDATA"      },
+    { LINEBEARERMODE_NONCALLSIGNALING  ,"NONCALLSIGNALING"   },
+#ifdef TAPI_1_1
+    { LINEBEARERMODE_PASSTHROUGH       ,"PASSTHROUGH"        },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aLineStates[] =
+{
+    { LINEDEVSTATE_OTHER               ,"OTHER"              },
+    { LINEDEVSTATE_RINGING             ,"RINGING"            },
+    { LINEDEVSTATE_CONNECTED           ,"CONNECTED"          },
+    { LINEDEVSTATE_DISCONNECTED        ,"DISCONNECTED"       },
+    { LINEDEVSTATE_MSGWAITON           ,"MSGWAITON"          },
+    { LINEDEVSTATE_MSGWAITOFF          ,"MSGWAITOFF"         },
+    { LINEDEVSTATE_INSERVICE           ,"INSERVICE"          },
+    { LINEDEVSTATE_OUTOFSERVICE        ,"OUTOFSERVICE"       },
+    { LINEDEVSTATE_MAINTENANCE         ,"MAINTENANCE"        },
+    { LINEDEVSTATE_OPEN                ,"OPEN"               },
+    { LINEDEVSTATE_CLOSE               ,"CLOSE"              },
+    { LINEDEVSTATE_NUMCALLS            ,"NUMCALLS"           },
+    { LINEDEVSTATE_NUMCOMPLETIONS      ,"NUMCOMPLETIONS"     },
+    { LINEDEVSTATE_TERMINALS           ,"TERMINALS"          },
+    { LINEDEVSTATE_ROAMMODE            ,"ROAMMODE"           },
+    { LINEDEVSTATE_BATTERY             ,"BATTERY"            },
+    { LINEDEVSTATE_SIGNAL              ,"SIGNAL"             },
+    { LINEDEVSTATE_DEVSPECIFIC         ,"DEVSPECIFIC"        },
+    { LINEDEVSTATE_REINIT              ,"REINIT"             },
+    { LINEDEVSTATE_LOCK                ,"LOCK"               },
+#ifdef TAPI_1_1
+    { LINEDEVSTATE_CAPSCHANGE          ,"CAPSCHANGE"         },
+    { LINEDEVSTATE_CONFIGCHANGE        ,"CONFIGCHANGE"       },
+    { LINEDEVSTATE_TRANSLATECHANGE     ,"TRANSLATECHANGE"    },
+    { LINEDEVSTATE_COMPLCANCEL         ,"COMPLCANCEL"        },
+    { LINEDEVSTATE_REMOVED             ,"REMOVED"            },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aAddressStates[] =
+{
+    { LINEADDRESSSTATE_OTHER           ,"OTHER"              },
+    { LINEADDRESSSTATE_DEVSPECIFIC     ,"DEVSPECIFIC"        },
+    { LINEADDRESSSTATE_INUSEZERO       ,"INUSEZERO"          },
+    { LINEADDRESSSTATE_INUSEONE        ,"INUSEONE"           },
+    { LINEADDRESSSTATE_INUSEMANY       ,"INUSEMANY"          },
+    { LINEADDRESSSTATE_NUMCALLS        ,"NUMCALLS"           },
+    { LINEADDRESSSTATE_FORWARD         ,"FORWARD"            },
+    { LINEADDRESSSTATE_TERMINALS       ,"TERMINALS"          },
+#ifdef TAPI_1_1
+    { LINEADDRESSSTATE_CAPSCHANGE      ,"CAPSCHANGE"         },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aTerminalModes[] =
+{
+    { LINETERMMODE_BUTTONS             ,"BUTTONS"            },
+    { LINETERMMODE_LAMPS               ,"LAMPS"              },
+    { LINETERMMODE_DISPLAY             ,"DISPLAY"            },
+    { LINETERMMODE_RINGER              ,"RINGER"             },
+    { LINETERMMODE_HOOKSWITCH          ,"HOOKSWITCH"         },
+    { LINETERMMODE_MEDIATOLINE         ,"MEDIATOLINE"        },
+    { LINETERMMODE_MEDIAFROMLINE       ,"MEDIAFROMLINE"      },
+    { LINETERMMODE_MEDIABIDIRECT       ,"MEDIABIDIRECT"      },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aHookSwitchModes[] =
+{
+    { PHONEHOOKSWITCHMODE_ONHOOK       ,"ONHOOK"             },
+    { PHONEHOOKSWITCHMODE_MIC          ,"MIC"                },
+    { PHONEHOOKSWITCHMODE_SPEAKER      ,"SPEAKER"            },
+    { PHONEHOOKSWITCHMODE_MICSPEAKER   ,"MICSPEAKER"         },
+    { PHONEHOOKSWITCHMODE_UNKNOWN      ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aLampModes[] =
+{
+    { PHONELAMPMODE_DUMMY              ,"DUMMY"              },
+    { PHONELAMPMODE_OFF                ,"OFF"                },
+    { PHONELAMPMODE_STEADY             ,"STEADY"             },
+    { PHONELAMPMODE_WINK               ,"WINK"               },
+    { PHONELAMPMODE_FLASH              ,"FLASH"              },
+    { PHONELAMPMODE_FLUTTER            ,"FLUTTER"            },
+    { PHONELAMPMODE_BROKENFLUTTER      ,"BROKENFLUTTER"      },
+    { PHONELAMPMODE_UNKNOWN            ,"UNKNOWN"            },
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP my_far aPhoneStates[] =
+{
+    { PHONESTATE_OTHER                 ,"OTHER"              },
+    { PHONESTATE_CONNECTED             ,"CONNECTED"          },
+    { PHONESTATE_DISCONNECTED          ,"DISCONNECTED"       },
+    { PHONESTATE_OWNER                 ,"OWNER"              },
+    { PHONESTATE_MONITORS              ,"MONITORS"           },
+    { PHONESTATE_DISPLAY               ,"DISPLAY"            },
+    { PHONESTATE_LAMP                  ,"LAMP"               },
+    { PHONESTATE_RINGMODE              ,"RINGMODE"           },
+    { PHONESTATE_RINGVOLUME            ,"RINGVOLUME"         },
+    { PHONESTATE_HANDSETHOOKSWITCH     ,"HANDSETHOOKSWITCH"  },
+    { PHONESTATE_HANDSETVOLUME         ,"HANDSETVOLUME"      },
+    { PHONESTATE_HANDSETGAIN           ,"HANDSETGAIN"        },
+    { PHONESTATE_SPEAKERHOOKSWITCH     ,"SPEAKERHOOKSWITCH"  },
+    { PHONESTATE_SPEAKERVOLUME         ,"SPEAKERVOLUME"      },
+    { PHONESTATE_SPEAKERGAIN           ,"SPEAKERGAIN"        },
+    { PHONESTATE_HEADSETHOOKSWITCH     ,"HEADSETHOOKSWITCH"  },
+    { PHONESTATE_HEADSETVOLUME         ,"HEADSETVOLUME"      },
+    { PHONESTATE_HEADSETGAIN           ,"HEADSETGAIN"        },
+    { PHONESTATE_SUSPEND               ,"SUSPEND"            },
+    { PHONESTATE_RESUME                ,"RESUME"             },
+    { PHONESTATE_DEVSPECIFIC           ,"DEVSPECIFIC"        },
+    { PHONESTATE_REINIT                ,"REINIT"             },
+#ifdef TAPI_1_1
+    { PHONESTATE_CAPSCHANGE            ,"CAPSCHANGE"         },
+    { PHONESTATE_REMOVED               ,"REMOVED"            },
+#endif
+    { 0xffffffff                       ,""                   }
+};
+
+
+LOOKUP my_far aLineErrs[] =
+{
+    { 0                                ,"<SUCCESS>"              },
+    { LINEERR_ALLOCATED                ,"ALLOCATED"              },
+    { LINEERR_BADDEVICEID              ,"BADDEVICEID"            },
+    { LINEERR_BEARERMODEUNAVAIL        ,"BEARERMODEUNAVAIL"      },
+    { LINEERR_CALLUNAVAIL              ,"CALLUNAVAIL"            },
+    { LINEERR_COMPLETIONOVERRUN        ,"COMPLETIONOVERRUN"      },
+    { LINEERR_CONFERENCEFULL           ,"CONFERENCEFULL"         },
+    { LINEERR_DIALBILLING              ,"DIALBILLING"            },
+    { LINEERR_DIALDIALTONE             ,"DIALDIALTONE"           },
+    { LINEERR_DIALPROMPT               ,"DIALPROMPT"             },
+    { LINEERR_DIALQUIET                ,"DIALQUIET"              },
+    { LINEERR_INCOMPATIBLEAPIVERSION   ,"INCOMPATIBLEAPIVERSION" },
+    { LINEERR_INCOMPATIBLEEXTVERSION   ,"INCOMPATIBLEEXTVERSION" },
+    { LINEERR_INIFILECORRUPT           ,"INIFILECORRUPT"         },
+    { LINEERR_INUSE                    ,"INUSE"                  },
+    { LINEERR_INVALADDRESS             ,"INVALADDRESS"           },
+    { LINEERR_INVALADDRESSID           ,"INVALADDRESSID"         },
+    { LINEERR_INVALADDRESSMODE         ,"INVALADDRESSMODE"       },
+    { LINEERR_INVALADDRESSSTATE        ,"INVALADDRESSSTATE"      },
+    { LINEERR_INVALAPPHANDLE           ,"INVALAPPHANDLE"         },
+    { LINEERR_INVALAPPNAME             ,"INVALAPPNAME"           },
+    { LINEERR_INVALBEARERMODE          ,"INVALBEARERMODE"        },
+    { LINEERR_INVALCALLCOMPLMODE       ,"INVALCALLCOMPLMODE"     },
+    { LINEERR_INVALCALLHANDLE          ,"INVALCALLHANDLE"        },
+    { LINEERR_INVALCALLPARAMS          ,"INVALCALLPARAMS"        },
+    { LINEERR_INVALCALLPRIVILEGE       ,"INVALCALLPRIVILEGE"     },
+    { LINEERR_INVALCALLSELECT          ,"INVALCALLSELECT"        },
+    { LINEERR_INVALCALLSTATE           ,"INVALCALLSTATE"         },
+    { LINEERR_INVALCALLSTATELIST       ,"INVALCALLSTATELIST"     },
+    { LINEERR_INVALCARD                ,"INVALCARD"              },
+    { LINEERR_INVALCOMPLETIONID        ,"INVALCOMPLETIONID"      },
+    { LINEERR_INVALCONFCALLHANDLE      ,"INVALCONFCALLHANDLE"    },
+    { LINEERR_INVALCONSULTCALLHANDLE   ,"INVALCONSULTCALLHANDLE" },
+    { LINEERR_INVALCOUNTRYCODE         ,"INVALCOUNTRYCODE"       },
+    { LINEERR_INVALDEVICECLASS         ,"INVALDEVICECLASS"       },
+    { LINEERR_INVALDEVICEHANDLE        ,"INVALDEVICEHANDLE"      },
+    { LINEERR_INVALDIALPARAMS          ,"INVALDIALPARAMS"        },
+    { LINEERR_INVALDIGITLIST           ,"INVALDIGITLIST"         },
+    { LINEERR_INVALDIGITMODE           ,"INVALDIGITMODE"         },
+    { LINEERR_INVALDIGITS              ,"INVALDIGITS"            },
+    { LINEERR_INVALEXTVERSION          ,"INVALEXTVERSION"        },
+    { LINEERR_INVALGROUPID             ,"INVALGROUPID"           },
+    { LINEERR_INVALLINEHANDLE          ,"INVALLINEHANDLE"        },
+    { LINEERR_INVALLINESTATE           ,"INVALLINESTATE"         },
+    { LINEERR_INVALLOCATION            ,"INVALLOCATION"          },
+    { LINEERR_INVALMEDIALIST           ,"INVALMEDIALIST"         },
+    { LINEERR_INVALMEDIAMODE           ,"INVALMEDIAMODE"         },
+    { LINEERR_INVALMESSAGEID           ,"INVALMESSAGEID"         },
+    { LINEERR_INVALPARAM               ,"INVALPARAM"             },
+    { LINEERR_INVALPARKID              ,"INVALPARKID"            },
+    { LINEERR_INVALPARKMODE            ,"INVALPARKMODE"          },
+    { LINEERR_INVALPOINTER             ,"INVALPOINTER"           },
+    { LINEERR_INVALPRIVSELECT          ,"INVALPRIVSELECT"        },
+    { LINEERR_INVALRATE                ,"INVALRATE"              },
+    { LINEERR_INVALREQUESTMODE         ,"INVALREQUESTMODE"       },
+    { LINEERR_INVALTERMINALID          ,"INVALTERMINALID"        },
+    { LINEERR_INVALTERMINALMODE        ,"INVALTERMINALMODE"      },
+    { LINEERR_INVALTIMEOUT             ,"INVALTIMEOUT"           },
+    { LINEERR_INVALTONE                ,"INVALTONE"              },
+    { LINEERR_INVALTONELIST            ,"INVALTONELIST"          },
+    { LINEERR_INVALTONEMODE            ,"INVALTONEMODE"          },
+    { LINEERR_INVALTRANSFERMODE        ,"INVALTRANSFERMODE"      },
+    { LINEERR_LINEMAPPERFAILED         ,"LINEMAPPERFAILED"       },
+    { LINEERR_NOCONFERENCE             ,"NOCONFERENCE"           },
+    { LINEERR_NODEVICE                 ,"NODEVICE"               },
+    { LINEERR_NODRIVER                 ,"NODRIVER"               },
+    { LINEERR_NOMEM                    ,"NOMEM"                  },
+    { LINEERR_NOREQUEST                ,"NOREQUEST"              },
+    { LINEERR_NOTOWNER                 ,"NOTOWNER"               },
+    { LINEERR_NOTREGISTERED            ,"NOTREGISTERED"          },
+    { LINEERR_OPERATIONFAILED          ,"OPERATIONFAILED"        },
+    { LINEERR_OPERATIONUNAVAIL         ,"OPERATIONUNAVAIL"       },
+    { LINEERR_RATEUNAVAIL              ,"RATEUNAVAIL"            },
+    { LINEERR_RESOURCEUNAVAIL          ,"RESOURCEUNAVAIL"        },
+    { LINEERR_REQUESTOVERRUN           ,"REQUESTOVERRUN"         },
+    { LINEERR_STRUCTURETOOSMALL        ,"STRUCTURETOOSMALL"      },
+    { LINEERR_TARGETNOTFOUND           ,"TARGETNOTFOUND"         },
+    { LINEERR_TARGETSELF               ,"TARGETSELF"             },
+    { LINEERR_UNINITIALIZED            ,"UNINITIALIZED"          },
+    { LINEERR_USERUSERINFOTOOBIG       ,"USERUSERINFOTOOBIG"     },
+    { LINEERR_REINIT                   ,"REINIT"                 },
+    { LINEERR_ADDRESSBLOCKED           ,"ADDRESSBLOCKED"         },
+    { LINEERR_BILLINGREJECTED          ,"BILLINGREJECTED"        },
+    { LINEERR_INVALFEATURE             ,"INVALFEATURE"           },
+    { LINEERR_NOMULTIPLEINSTANCE       ,"NOMULTIPLEINSTANCE"     },
+    { 0xffffffff                       ,""                   }
+};
+
+LOOKUP my_far aPhoneErrs[] =
+{
+    { 0                                ,"<SUCCESS>"              },
+    { PHONEERR_ALLOCATED               ,"ALLOCATED"              },
+    { PHONEERR_BADDEVICEID             ,"BADDEVICEID"            },
+    { PHONEERR_INCOMPATIBLEAPIVERSION  ,"INCOMPATIBLEAPIVERSION" },
+    { PHONEERR_INCOMPATIBLEEXTVERSION  ,"INCOMPATIBLEEXTVERSION" },
+    { PHONEERR_INIFILECORRUPT          ,"INIFILECORRUPT"         },
+    { PHONEERR_INUSE                   ,"INUSE"                  },
+    { PHONEERR_INVALAPPHANDLE          ,"INVALAPPHANDLE"         },
+    { PHONEERR_INVALAPPNAME            ,"INVALAPPNAME"           },
+    { PHONEERR_INVALBUTTONLAMPID       ,"INVALBUTTONLAMPID"      },
+    { PHONEERR_INVALBUTTONMODE         ,"INVALBUTTONMODE"        },
+    { PHONEERR_INVALBUTTONSTATE        ,"INVALBUTTONSTATE"       },
+    { PHONEERR_INVALDATAID             ,"INVALDATAID"            },
+    { PHONEERR_INVALDEVICECLASS        ,"INVALDEVICECLASS"       },
+    { PHONEERR_INVALEXTVERSION         ,"INVALEXTVERSION"        },
+    { PHONEERR_INVALHOOKSWITCHDEV      ,"INVALHOOKSWITCHDEV"     },
+    { PHONEERR_INVALHOOKSWITCHMODE     ,"INVALHOOKSWITCHMODE"    },
+    { PHONEERR_INVALLAMPMODE           ,"INVALLAMPMODE"          },
+    { PHONEERR_INVALPARAM              ,"INVALPARAM"             },
+    { PHONEERR_INVALPHONEHANDLE        ,"INVALPHONEHANDLE"       },
+    { PHONEERR_INVALPHONESTATE         ,"INVALPHONESTATE"        },
+    { PHONEERR_INVALPOINTER            ,"INVALPOINTER"           },
+    { PHONEERR_INVALPRIVILEGE          ,"INVALPRIVILEGE"         },
+    { PHONEERR_INVALRINGMODE           ,"INVALRINGMODE"          },
+    { PHONEERR_NODEVICE                ,"NODEVICE"               },
+    { PHONEERR_NODRIVER                ,"NODRIVER"               },
+    { PHONEERR_NOMEM                   ,"NOMEM"                  },
+    { PHONEERR_NOTOWNER                ,"NOTOWNER"               },
+    { PHONEERR_OPERATIONFAILED         ,"OPERATIONFAILED"        },
+    { PHONEERR_OPERATIONUNAVAIL        ,"OPERATIONUNAVAIL"       },
+    { PHONEERR_RESOURCEUNAVAIL         ,"RESOURCEUNAVAIL"        },
+    { PHONEERR_REQUESTOVERRUN          ,"REQUESTOVERRUN"         },
+    { PHONEERR_STRUCTURETOOSMALL       ,"STRUCTURETOOSMALL"      },
+    { PHONEERR_UNINITIALIZED           ,"UNINITIALIZED"          },
+    { PHONEERR_REINIT                  ,"REINIT"                 },
+    { 0xffffffff                       ,""                   }
+};
diff --git a/private/tapi/dev/sp/esp/vars.h b/private/tapi/dev/sp/esp/vars.h
new file mode 100644
index 000000000..dc87e6439
--- /dev/null
+++ b/private/tapi/dev/sp/esp/vars.h
@@ -0,0 +1,95 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    vars.h
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#ifdef WIN32
+#define my_far
+#else
+#define my_far _far
+#endif
+
+
+extern HWND        ghwndMain;
+extern HWND        ghwndEdit;
+extern HWND        ghwndList1;
+extern HWND        ghwndList2;
+extern BOOL        gbAutoClose;
+extern BOOL        gbExeStarted;
+extern BOOL        gbShowFuncEntry;
+extern BOOL        gbShowFuncExit;
+extern BOOL        gbShowFuncParams;
+extern BOOL        gbShowEvents;
+extern BOOL        gbShowCompletions;
+extern BOOL        gbBreakOnFuncEntry;
+extern BOOL        gbDisableUI;
+extern BOOL        gbSyncCompl;
+extern BOOL        gbAsyncCompl;
+extern BOOL        gbManualCompl;
+extern BOOL        gbManualResults;
+extern BOOL        gbShowLineGetIDDlg;
+extern HICON       ghIconLine;
+extern HICON       ghIconPhone;
+extern HMENU       ghMenu;
+extern DWORD       gdwTSPIVersion;
+extern DWORD       gdwNumLines;
+extern DWORD       gdwNumAddrsPerLine;
+extern DWORD       gdwNumPhones;
+extern DWORD       gdwNumInits;
+extern DWORD       gdwDefLineGetIDID;
+extern DWORD       gdwLineDeviceIDBase;
+extern DWORD       gdwPermanentProviderID;
+extern DWORD       aOutCallStates[MAX_OUT_CALL_STATES];
+extern DWORD       aOutCallStateModes[MAX_OUT_CALL_STATES];
+extern HPROVIDER   ghProvider;
+extern LINEEVENT   gpfnLineCreateProc;
+extern PHONEEVENT  gpfnPhoneCreateProc;
+extern PDRVWIDGET  gaWidgets;
+extern LINEEXTENSIONID  gLineExtID;
+extern PHONEEXTENSIONID gPhoneExtID;
+extern ASYNC_COMPLETION gpfnCompletionProc;
+extern LPLINEADDRESSCAPS    gpDefLineAddrCaps;
+
+extern LOOKUP my_far aPhoneStatusFlags[];
+extern LOOKUP my_far aCallParamFlags[];
+extern LOOKUP my_far aCallOrigins[];
+extern LOOKUP my_far aCallReasons[];
+extern LOOKUP my_far aLineMsgs[];
+extern LOOKUP my_far aPhoneMsgs[];
+extern LOOKUP my_far aCallerIDFlags[];
+extern LOOKUP my_far aCallStates[];
+extern LOOKUP my_far aCallInfoStates[];
+extern LOOKUP my_far aCallFeatures[];
+extern LOOKUP my_far aMediaModes[];
+extern LOOKUP my_far aButtonModes[];
+extern LOOKUP my_far aButtonStates[];
+extern LOOKUP my_far aHookSwitchDevs[];
+extern LOOKUP my_far aCallSelects[];
+extern LOOKUP my_far aTransferModes[];
+extern LOOKUP my_far aDigitModes[];
+extern LOOKUP my_far aToneModes[];
+extern LOOKUP my_far aBearerModes[];
+extern LOOKUP my_far aLineStates[];
+extern LOOKUP my_far aAddressStates[];
+extern LOOKUP my_far aTerminalModes[];
+extern LOOKUP my_far aHookSwitchModes[];
+extern LOOKUP my_far aLampModes[];
+extern LOOKUP my_far aPhoneStates[];
+extern LOOKUP my_far aLineErrs[];
+extern LOOKUP my_far aPhoneErrs[];
diff --git a/private/tapi/dev/sp/esp/widget.c b/private/tapi/dev/sp/esp/widget.c
new file mode 100644
index 000000000..7152a412a
--- /dev/null
+++ b/private/tapi/dev/sp/esp/widget.c
@@ -0,0 +1,885 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    widget.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <malloc.h>
+#include "esp.h"
+#include "vars.h"
+
+
+char szProviderInfo[] = "ESP v1.0";
+
+void
+UpdateWidgetList(
+    void
+    )
+{
+    PDRVWIDGET pWidget = gaWidgets;
+
+
+    if (gbDisableUI)
+    {
+        return;
+    }
+
+    SendMessage (ghwndList1, LB_RESETCONTENT, 0, 0);
+
+#ifdef WIN32
+    try
+    {
+#endif
+        while (pWidget)
+        {
+            char buf[128];
+
+
+            switch (pWidget->dwType)
+            {
+            case WT_DRVLINE:
+
+                wsprintf(
+                    buf,
+                    "Line%ld, hd=x%lx (ht=x%lx, %s)",
+                    ((PDRVLINE)pWidget)->dwDeviceID,
+                    pWidget,
+                    ((PDRVLINE)pWidget)->htLine,
+                    (((PDRVLINE)pWidget)->htLine ? "open" : "closed")
+                    );
+
+                break;
+
+            case WT_DRVCALL:
+            {
+                int       i;
+                char far *lpszCallState = "";
+
+
+                for (i = 0; aCallStates[i].dwVal != 0xffffffff; i++)
+                {
+                    if (((PDRVCALL)pWidget)->dwCallState == aCallStates[i].dwVal)
+                    {
+                        lpszCallState = aCallStates[i].lpszVal;
+                        break;
+                    }
+                }
+
+                wsprintf(
+                    buf,
+                    "  Addr%ld, hdCall=x%lx %s (htCall=x%lx)",
+                    ((PDRVCALL)pWidget)->LineCallInfo.dwAddressID,
+                    pWidget,
+                    lpszCallState,
+                    ((PDRVCALL)pWidget)->htCall
+                    );
+
+                break;
+            }
+            case WT_DRVPHONE:
+
+                wsprintf(
+                    buf,
+                    "Phone%ld, hd=x%lx (ht=x%lx, %s)",
+                    ((PDRVPHONE)pWidget)->dwDeviceID,
+                    pWidget,
+                    ((PDRVPHONE)pWidget)->htPhone,
+                    (((PDRVPHONE)pWidget)->htPhone ? "open" : "closed")
+                    );
+
+                break;
+            }
+
+            SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)buf);
+
+            pWidget = pWidget->pNext;
+        }
+#ifdef WIN32
+    }
+    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+        PostUpdateWidgetListMsg();
+    }
+#endif
+}
+
+
+void
+PostUpdateWidgetListMsg(
+    void
+    )
+{
+    PostMessage (ghwndMain, WM_UPDATEWIDGETLIST, ESP_MSG_KEY, 0);
+}
+
+
+void
+InsertWidgetInList(
+    PDRVWIDGET pNewWidget,
+    PDRVWIDGET pWidgetInsertBefore
+    )
+{
+    pNewWidget->pNext = pWidgetInsertBefore;
+
+    if ((gaWidgets == NULL) || (pWidgetInsertBefore == gaWidgets))
+    {
+        gaWidgets = pNewWidget;
+    }
+    else
+    {
+        PDRVWIDGET pPrevWidget = gaWidgets;
+
+
+        while (pPrevWidget->pNext &&
+               (pPrevWidget->pNext != pWidgetInsertBefore))
+        {
+            pPrevWidget = pPrevWidget->pNext;
+        }
+
+        pPrevWidget->pNext = pNewWidget;
+    }
+
+    //UpdateWidgetList();
+    PostUpdateWidgetListMsg();
+}
+
+
+BOOL
+RemoveWidgetFromList(
+    PDRVWIDGET pWidgetToRemove
+    )
+{
+    if (gaWidgets == NULL)
+    {
+        goto RemoveWidgetFromList_error;
+    }
+
+    if (pWidgetToRemove == gaWidgets)
+    {
+        gaWidgets = pWidgetToRemove->pNext;
+    }
+    else
+    {
+        PDRVWIDGET pPrevWidget = gaWidgets;
+
+
+        while (pPrevWidget->pNext && (pPrevWidget->pNext != pWidgetToRemove))
+        {
+            pPrevWidget = pPrevWidget->pNext;
+        }
+
+        if (pPrevWidget->pNext == NULL)
+        {
+            goto RemoveWidgetFromList_error;
+        }
+
+        pPrevWidget->pNext = pWidgetToRemove->pNext;
+    }
+
+    DrvFree (pWidgetToRemove);
+
+    //UpdateWidgetList();
+    PostUpdateWidgetListMsg();
+
+    return TRUE;
+
+RemoveWidgetFromList_error:
+
+    ShowStr(
+        "error: RemoveWidgetFromList: widget x%lx not in list",
+        pWidgetToRemove
+        );
+
+    return FALSE;
+}
+
+
+PDRVLINE
+AllocLine(
+    DWORD       dwDeviceID
+    )
+{
+    PDRVLINE pNewLine = (PDRVLINE) DrvAlloc (sizeof(DRVLINE));
+
+
+    if (pNewLine)
+    {
+        char far *p;
+        PDRVWIDGET pWidget = gaWidgets;
+
+
+        //
+        // Init the data structure
+        //
+
+        memset (pNewLine, 0, sizeof(DRVLINE));
+        pNewLine->Widget.dwType = WT_DRVLINE;
+        pNewLine->dwDeviceID    = dwDeviceID;
+
+
+        //
+        // Dev caps
+        //
+
+        pNewLine->LineDevCaps.dwNeededSize      =
+        pNewLine->LineDevCaps.dwUsedSize        = sizeof(LINEDEVCAPS) +
+            LINE_DEV_CAPS_VAR_DATA_SIZE;
+
+        pNewLine->LineDevCaps.dwProviderInfoSize = strlen (szProviderInfo) + 1;
+        pNewLine->LineDevCaps.dwProviderInfoOffset = sizeof(LINEDEVCAPS);
+
+        p = ((char far *) &pNewLine->LineDevCaps) +
+                pNewLine->LineDevCaps.dwProviderInfoOffset;
+
+        strcpy (p, szProviderInfo);
+
+        //pNewLine->LineDevCaps.dwSwitchInfoSize;
+        //pNewLine->LineDevCaps.dwSwitchInfoOffset =
+
+        pNewLine->LineDevCaps.dwPermanentLineID =
+            (0x0000ffff & dwDeviceID) |
+                ((0x0000ffff & gdwPermanentProviderID) << 16);
+
+        pNewLine->LineDevCaps.dwLineNameOffset =
+            sizeof(LINEDEVCAPS) + 2*MAX_STRING_PARAM_SIZE;
+
+        p = ((char far *) &pNewLine->LineDevCaps) +
+                pNewLine->LineDevCaps.dwLineNameOffset;
+
+        sprintf (p, "Line%ld (ESP)", dwDeviceID);
+
+        pNewLine->LineDevCaps.dwLineNameSize = (DWORD) strlen (p) + 1;
+        pNewLine->LineDevCaps.dwStringFormat = STRINGFORMAT_ASCII;
+
+        pNewLine->LineDevCaps.dwAddressModes = ALL_ADDRESS_MODES;
+        pNewLine->LineDevCaps.dwNumAddresses = gdwNumAddrsPerLine;
+        pNewLine->LineDevCaps.dwBearerModes  = ALL_BEARER_MODES;
+        pNewLine->LineDevCaps.dwMaxRate      = 0x100000; //BUGBUG
+        pNewLine->LineDevCaps.dwMediaModes   = ALL_MEDIA_MODES;
+
+        //pNewLine->LineDevCaps.dwGenerateToneModes;
+        //pNewLine->LineDevCaps.dwGenerateToneMaxNumFreq;
+        //pNewLine->LineDevCaps.dwGenerateDigitModes;
+        //pNewLine->LineDevCaps.dwMonitorToneMaxNumFreq;
+        //pNewLine->LineDevCaps.dwMonitorToneMaxNumEntries;
+        //pNewLine->LineDevCaps.dwMonitorDigitModes;
+        //pNewLine->LineDevCaps.dwGatherDigitsMinTimeout;
+        //pNewLine->LineDevCaps.dwGatherDigitsMaxTimeout;
+
+        //pNewLine->LineDevCaps.dwMedCtlDigitMaxListSize;
+        //pNewLine->LineDevCaps.dwMedCtlMediaMaxListSize;
+        //pNewLine->LineDevCaps.dwMedCtlToneMaxListSize;
+        //pNewLine->LineDevCaps.dwMedCtlCallStateMaxListSize;
+
+        pNewLine->LineDevCaps.dwDevCapFlags       = ALL_LINE_DEV_CAP_FLAGS;
+        pNewLine->LineDevCaps.dwMaxNumActiveCalls = 1024; // BUGBUG
+        pNewLine->LineDevCaps.dwAnswerMode        = LINEANSWERMODE_NONE; // BUGBUG???
+        pNewLine->LineDevCaps.dwRingModes         = 1;
+        pNewLine->LineDevCaps.dwLineStates        = ALL_LINE_STATES;
+
+        //pNewLine->LineDevCaps.dwUUIAcceptSize;
+        //pNewLine->LineDevCaps.dwUUIAnswerSize;
+        //pNewLine->LineDevCaps.dwUUIMakeCallSize;
+        //pNewLine->LineDevCaps.dwUUIDropSize;
+        //pNewLine->LineDevCaps.dwUUISendUserUserInfoSize;
+        //pNewLine->LineDevCaps.dwUUICallInfoSize;
+
+        //pNewLine->LineDevCaps.MinDialParams;
+        //pNewLine->LineDevCaps.MaxDialParams;
+        //pNewLine->LineDevCaps.DefaultDialParams;
+
+        //pNewLine->LineDevCaps.dwNumTerminals;
+        //pNewLine->LineDevCaps.dwTerminalCapsSize;
+        //pNewLine->LineDevCaps.dwTerminalCapsOffset
+        //pNewLine->LineDevCaps.dwTerminalTextEntrySize;
+        //pNewLine->LineDevCaps.dwTerminalTextSize;
+        //pNewLine->LineDevCaps.dwTerminalTextOffset
+
+        //pNewLine->LineDevCaps.dwDevSpecificSize;
+        //pNewLine->LineDevCaps.dwDevSpecificOffset
+        pNewLine->LineDevCaps.dwLineFeatures = ALL_LINE_FEATURES;
+
+
+        //
+        // Dev status
+        //
+
+        pNewLine->LineDevStatus.dwNeededSize =
+        pNewLine->LineDevStatus.dwUsedSize   = sizeof (LINEDEVSTATUS) +
+            LINE_DEV_STATUS_VAR_DATA_SIZE;
+
+        //pNewLine->LineDevStatus.dwNumOpens        // TAPI.DLL fills in
+        //pNewLine->LineDevStatus.dwOpenMediaModes  // TAPI.DLL fills in
+
+        //pNewLine->LineDevStatus.dwNumActiveCalls
+        //pNewLine->LineDevStatus.dwNumOnHoldCalls
+        //pNewLine->LineDevStatus.dwNumOnHoldPendCalls
+        pNewLine->LineDevStatus.dwLineFeatures        = ALL_LINE_FEATURES;
+        //pNewLine->LineDevStatus.dwNumCallCompletions
+        //pNewLine->LineDevStatus.dwRingMode
+        //pNewLine->LineDevStatus.dwSignalLevel
+        //pNewLine->LineDevStatus.dwBatteryLevel
+        //pNewLine->LineDevStatus.dwRoamMode
+
+        pNewLine->LineDevStatus.dwDevStatusFlags      =
+            LINEDEVSTATUSFLAGS_CONNECTED | LINEDEVSTATUSFLAGS_INSERVICE;
+
+        //pNewLine->LineDevStatus.dwTerminalModesSize;
+        //pNewLine->LineDevStatus.dwTerminalModesOffset
+
+        //pNewLine->LineDevStatus.dwDevSpecificSize
+        //pNewLine->LineDevStatus.dwDevSpecificOffset
+
+
+        //
+        // Addr caps
+        //
+
+        pNewLine->LineAddrCaps.dwNeededSize         =
+        pNewLine->LineAddrCaps.dwUsedSize           = sizeof(LINEADDRESSCAPS) +
+            LINE_ADDR_CAPS_VAR_DATA_SIZE;
+
+        pNewLine->LineAddrCaps.dwLineDeviceID       = dwDeviceID;
+
+        //pNewLine->LineAddrCaps.dwAddressSize
+        pNewLine->LineAddrCaps.dwAddressOffset      = sizeof(LINEADDRESSCAPS);
+
+        //pNewLine->LineAddrCaps.dwDevSpecificSize
+        //pNewLine->LineAddrCaps.dwDevSpecificOffset
+
+        pNewLine->LineAddrCaps.dwAddressSharing     = LINEADDRESSSHARING_PRIVATE;
+        pNewLine->LineAddrCaps.dwAddressStates      = ALL_ADDRESS_STATES;
+        pNewLine->LineAddrCaps.dwCallInfoStates     = ALL_CALL_INFO_STATES;
+        pNewLine->LineAddrCaps.dwCallerIDFlags      =
+        pNewLine->LineAddrCaps.dwCalledIDFlags      =
+        pNewLine->LineAddrCaps.dwConnectedIDFlags   =
+        pNewLine->LineAddrCaps.dwRedirectionIDFlags =
+        pNewLine->LineAddrCaps.dwRedirectingIDFlags = ALL_CALL_PARTY_ID_FLAGS;
+        pNewLine->LineAddrCaps.dwCallStates         = ALL_CALL_STATES;
+        pNewLine->LineAddrCaps.dwDialToneModes      = ALL_DIAL_TONE_MODES;
+        pNewLine->LineAddrCaps.dwBusyModes          = ALL_BUSY_MODES;
+        pNewLine->LineAddrCaps.dwSpecialInfo        = ALL_SPECIAL_INFO;
+        pNewLine->LineAddrCaps.dwDisconnectModes    = ALL_DISCONNECT_MODES;
+
+        pNewLine->LineAddrCaps.dwMaxNumActiveCalls  =
+        pNewLine->LineAddrCaps.dwMaxNumOnHoldCalls  =
+        pNewLine->LineAddrCaps.dwMaxNumOnHoldPendingCalls =
+        pNewLine->LineAddrCaps.dwMaxNumConference   =
+        pNewLine->LineAddrCaps.dwMaxNumTransConf    = 64; // BUGBUG
+
+        pNewLine->LineAddrCaps.dwAddrCapFlags       = ALL_ADDRESS_CAP_FLAGS;
+        pNewLine->LineAddrCaps.dwCallFeatures       = ALL_CALL_FEATURES;
+        //pNewLine->LineAddrCaps.dwRemoveFromConfCaps
+        //pNewLine->LineAddrCaps.dwRemoveFromConfState
+        //pNewLine->LineAddrCaps.dwTransferModes
+        //pNewLine->LineAddrCaps.dwParkModes
+
+        //pNewLine->LineAddrCaps.dwForwardModes
+        //pNewLine->LineAddrCaps.dwMaxForwardEntries
+        //pNewLine->LineAddrCaps.dwMaxSpecificEntries
+        //pNewLine->LineAddrCaps.dwMinFwdNumRings
+        //pNewLine->LineAddrCaps.dwMaxFwdNumRings
+
+        //pNewLine->LineAddrCaps.dwMaxCallCompletions
+        //pNewLine->LineAddrCaps.dwCallCompletionConds
+        //pNewLine->LineAddrCaps.dwCallCompletionModes
+        //pNewLine->LineAddrCaps.dwNumCompletionMessages
+        //pNewLine->LineAddrCaps.dwCompletionMsgTextEntrySize
+        //pNewLine->LineAddrCaps.dwCompletionMsgTextSize
+        //pNewLine->LineAddrCaps.dwCompletionMsgTextOffset
+        pNewLine->LineAddrCaps.dwAddressFeatures = ALL_ADDRESS_FEATURES;
+
+
+        //
+        // Addr status
+        //
+
+        pNewLine->LineAddrStatus.dwNeededSize =
+        pNewLine->LineAddrStatus.dwUsedSize   =
+            sizeof (LINEADDRESSSTATUS) + LINE_ADDR_STATUS_VAR_DATA_SIZE;
+
+        //pNewLine->LineAddrStatus.dwNumInUse
+        //pNewLine->LineAddrStatus.dwNumActiveCalls
+        //pNewLine->LineAddrStatus.dwNumOnHoldCalls
+        //pNewLine->LineAddrStatus.dwNumOnHoldPendCalls
+        pNewLine->LineAddrStatus.dwAddressFeatures = ALL_ADDRESS_FEATURES;
+
+        //pNewLine->LineAddrStatus.dwNumRingsNoAnswer
+        //pNewLine->LineAddrStatus.dwForwardNumEntries
+        //pNewLine->LineAddrStatus.dwForwardSize
+        //pNewLine->LineAddrStatus.dwForwardOffset
+
+        //pNewLine->LineAddrStatus.dwTerminalModesSize
+        //pNewLine->LineAddrStatus.dwTerminalModesOffset
+
+        //pNewLine->LineAddrStatus.dwDevSpecificSize
+        //pNewLine->LineAddrStatus.dwDevSpecificOffset
+
+
+        //
+        // Insert new line...
+        //
+
+        while (pWidget && (pWidget->dwType != WT_DRVPHONE))
+        {
+            PDRVLINE pLine = (PDRVLINE) pWidget;
+
+
+            if ((pWidget->dwType == WT_DRVLINE) &&
+                (pLine->dwDeviceID > dwDeviceID))
+            {
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+
+        InsertWidgetInList ((PDRVWIDGET) pNewLine, pWidget);
+    }
+
+    return pNewLine;
+}
+
+
+PDRVLINE
+GetLine(
+    DWORD dwDeviceID
+    )
+{
+    PDRVWIDGET pWidget = gaWidgets;
+
+
+    while (pWidget)
+    {
+        if ((pWidget->dwType == WT_DRVLINE) &&
+            (((PDRVLINE) pWidget)->dwDeviceID == dwDeviceID))
+        {
+            return ((PDRVLINE) pWidget);
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PDRVLINE) NULL);
+}
+
+
+VOID
+FreeLine(
+    PDRVLINE    pLine
+    )
+{
+    PDRVWIDGET pWidget = pLine->Widget.pNext;
+
+
+    if (RemoveWidgetFromList ((PDRVWIDGET) pLine))
+    {
+        // BUGBUG need to complete all pending reqs
+
+        while (pWidget && (pWidget->dwType == WT_DRVCALL))
+        {
+            PDRVWIDGET pWidget2 = pWidget->pNext;
+
+
+            RemoveWidgetFromList (pWidget);
+            pWidget = pWidget2;
+        }
+    }
+}
+
+
+LONG
+AllocCall(
+    PDRVLINE    pLine,
+    HTAPICALL   htCall,
+    LPLINECALLPARAMS    lpCallParams,
+    PDRVCALL    *ppCall
+    )
+{
+    LONG       lResult = 0;
+    DWORD      dwAddressID = 0;
+    PDRVCALL   pNewCall = (PDRVCALL) DrvAlloc (sizeof(DRVCALL));
+    PDRVWIDGET pWidget = (PDRVWIDGET) pLine->Widget.pNext;
+
+
+    //
+    // Validate call params
+    //
+
+    if (lpCallParams)
+    {
+        if (lpCallParams->dwAddressMode == LINEADDRESSMODE_ADDRESSID)
+        {
+            if (lpCallParams->dwAddressID >= gdwNumAddrsPerLine)
+            {
+                lResult = LINEERR_INVALCALLPARAMS;
+                goto AllocCall_exit;
+            }
+            else
+            {
+                dwAddressID = lpCallParams->dwAddressID;
+            }
+        }
+
+        // BUGBUG chk against currently supported bearer/media modes on line
+    }
+
+
+    //
+    // Alloc a new call struct
+    //
+
+    if (!pNewCall)
+    {
+        lResult = LINEERR_NOMEM;
+        goto AllocCall_exit;
+    }
+
+
+    //
+    // Initialize the new call fields
+    //
+
+    memset (pNewCall, 0, sizeof(DRVCALL));
+
+    pNewCall->Widget.dwType  = WT_DRVCALL;
+    pNewCall->pLine          = pLine;
+    pNewCall->htCall         = htCall;
+    pNewCall->dwCallState    = LINECALLSTATE_UNKNOWN;
+    pNewCall->dwCallFeatures = ALL_CALL_FEATURES;
+
+    pNewCall->LineCallInfo.dwNeededSize =
+    pNewCall->LineCallInfo.dwUsedSize = sizeof (LINECALLINFO) +
+            LINE_CALL_INFO_VAR_DATA_SIZE;
+
+    pNewCall->LineCallInfo.dwLineDeviceID = pLine->dwDeviceID;
+    pNewCall->LineCallInfo.dwAddressID    = dwAddressID;
+
+    pNewCall->LineCallInfo.dwBearerMode =
+        (lpCallParams ? lpCallParams->dwBearerMode : LINEBEARERMODE_VOICE);
+    pNewCall->LineCallInfo.dwRate       =
+        (lpCallParams ? lpCallParams->dwMaxRate : 65536);
+    pNewCall->LineCallInfo.dwMediaMode  =
+        (lpCallParams ? lpCallParams->dwMediaMode :
+            LINEMEDIAMODE_INTERACTIVEVOICE);
+
+    //pNewCall->LineCallInfo.dwAppSpecific
+    //pNewCall->LineCallInfo.dwCallID
+    //pNewCall->LineCallInfo.dwRelatedCallID
+    //pNewCall->LineCallInfo.dwCallParamFlags
+    pNewCall->LineCallInfo.dwCallStates = ALL_CALL_STATES;
+
+    //pNewCall->LineCallInfo.dwMonitorDigitModes    FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwMonitorMediaModes    FILLED IN BY TAPI
+
+    if (lpCallParams)
+    {
+        memcpy(
+            &pNewCall->LineCallInfo.DialParams,
+            &lpCallParams->DialParams,
+            sizeof(LINEDIALPARAMS)
+            );
+    }
+
+    //pNewCall->LineCallInfo.dwOrigin
+    //pNewCall->LineCallInfo.dwReason
+    //pNewCall->LineCallInfo.dwCompletionID
+
+    //pNewCall->LineCallInfo.dwNumOwners    FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwNumMonitors  FILLED IN BY TAPI
+
+    //pNewCall->LineCallInfo.dwCountryCode
+    //pNewCall->LineCallInfo.dwTrunk
+
+    //pNewCall->LineCallInfo.dwCallerIDFlags
+    //pNewCall->LineCallInfo.dwCallerIDSize
+    //pNewCall->LineCallInfo.dwCallerIDOffset
+
+    //pNewCall->LineCallInfo.dwCallerIDNameSize
+    //pNewCall->LineCallInfo.dwCallerIDNameOffset
+
+    //pNewCall->LineCallInfo.dwCalledIDFlags
+    //pNewCall->LineCallInfo.dwCalledIDSize
+    //pNewCall->LineCallInfo.dwCalledIDOffset
+
+    //pNewCall->LineCallInfo.dwCalledIDNameSize
+    //pNewCall->LineCallInfo.dwCalledIDNameOffset
+
+    //pNewCall->LineCallInfo.dwConnectedIDFlags
+    //pNewCall->LineCallInfo.dwConnectedIDSize
+    //pNewCall->LineCallInfo.dwConnectedIDOffset
+
+    //pNewCall->LineCallInfo.dwConnectedIDNameSize
+    //pNewCall->LineCallInfo.dwConnectedIDNameOffset
+
+    //pNewCall->LineCallInfo.dwRedirectionIDFlags
+    //pNewCall->LineCallInfo.dwRedirectionIDSize
+    //pNewCall->LineCallInfo.dwRedirectionIDOffset
+
+    //pNewCall->LineCallInfo.dwRedirectionIDNameSize
+    //pNewCall->LineCallInfo.dwRedirectionIDNameOffset
+
+    //pNewCall->LineCallInfo.dwRedirectingIDFlags
+    //pNewCall->LineCallInfo.dwRedirectingIDSize
+    //pNewCall->LineCallInfo.dwRedirectingIDOffset
+
+    //pNewCall->LineCallInfo.dwRedirectingIDNameSize
+    //pNewCall->LineCallInfo.dwRedirectingIDNameOffset
+
+    //pNewCall->LineCallInfo.dwAppNameSize               FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwAppNameOffset             FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwDisplayableAddressSize    FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwDisplayableAddressOffset  FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwCalledPartySize           FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwCalledPartyOffset         FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwCommentSize               FILLED IN BY TAPI
+    //pNewCall->LineCallInfo.dwCommentOffset             FILLED IN BY TAPI
+
+    //pNewCall->LineCallInfo.dwDisplaySize
+    //pNewCall->LineCallInfo.dwDisplayOffset
+
+    //pNewCall->LineCallInfo.dwUserUserInfoSize
+    //pNewCall->LineCallInfo.dwUserUserInfoOffset
+
+    //pNewCall->LineCallInfo.dwHighLevelCompSize
+    //pNewCall->LineCallInfo.dwHighLevelCompOffset
+
+    //pNewCall->LineCallInfo.dwLowLevelCompSize
+    //pNewCall->LineCallInfo.dwLowLevelCompOffset
+
+    //pNewCall->LineCallInfo.dwChargingInfoSize
+    //pNewCall->LineCallInfo.dwChargingInfoOffset
+
+    //pNewCall->LineCallInfo.dwTerminalModesSize
+    //pNewCall->LineCallInfo.dwTerminalModesOffset
+
+    //pNewCall->LineCallInfo.dwDevSpecificSize
+    //pNewCall->LineCallInfo.dwDevSpecificOffset
+
+
+    //
+    // Insert new call...
+    //
+
+    while (pWidget &&
+           (pWidget->dwType == WT_DRVCALL) &&
+           (((PDRVCALL)pWidget)->LineCallInfo.dwAddressID <= dwAddressID))
+    {
+        pWidget = pWidget->pNext;
+    }
+
+    InsertWidgetInList ((PDRVWIDGET) pNewCall, pWidget);
+
+
+    //
+    // Fill in the blanks
+    //
+
+    *ppCall = pNewCall;
+
+AllocCall_exit:
+
+    return lResult;
+}
+
+
+VOID
+FreeCall(
+    PDRVCALL    pCall
+    )
+{
+    // BUGBUG need to complete all pending reqs
+
+    RemoveWidgetFromList ((PDRVWIDGET) pCall);
+}
+
+
+PDRVPHONE
+AllocPhone(
+    DWORD       dwDeviceID
+    )
+{
+    PDRVPHONE pNewPhone = (PDRVPHONE) DrvAlloc (sizeof(DRVPHONE));
+
+
+    if (pNewPhone)
+    {
+        PDRVWIDGET pWidget = gaWidgets;
+        char far *p;
+
+
+        memset (pNewPhone, 0, sizeof(DRVPHONE));
+
+        pNewPhone->Widget.dwType = WT_DRVPHONE;
+        pNewPhone->dwDeviceID    = dwDeviceID;
+
+
+        //
+        // Caps
+        //
+
+        pNewPhone->PhoneCaps.dwNeededSize =
+        pNewPhone->PhoneCaps.dwUsedSize   =
+            sizeof(PHONECAPS) + PHONE_CAPS_VAR_DATA_SIZE;
+
+        pNewPhone->PhoneCaps.dwProviderInfoSize = strlen (szProviderInfo) + 1;
+        pNewPhone->PhoneCaps.dwProviderInfoOffset = sizeof(PHONECAPS);
+
+        p = ((char far *) &pNewPhone->PhoneCaps) +
+                pNewPhone->PhoneCaps.dwProviderInfoOffset;
+
+        strcpy (p, szProviderInfo);
+
+        //pNewPhone->PhoneCaps.dwPhoneInfoSize
+        //pNewPhone->PhoneCaps.dwPhoneInfoOffset
+
+        pNewPhone->PhoneCaps.dwPermanentPhoneID;
+            (0x0000ffff & dwDeviceID) |
+                ((0x0000ffff & gdwPermanentProviderID) << 16);
+
+        pNewPhone->PhoneCaps.dwPhoneNameOffset =
+            sizeof(PHONECAPS) + 2*MAX_STRING_PARAM_SIZE;
+
+        p = ((char far *) &pNewPhone->PhoneCaps) +
+                pNewPhone->PhoneCaps.dwPhoneNameOffset;
+
+        sprintf (p, "Phone%ld (ESP)", dwDeviceID);
+
+        pNewPhone->PhoneCaps.dwPhoneNameSize = (DWORD) strlen (p) + 1;
+
+        pNewPhone->PhoneCaps.dwStringFormat = STRINGFORMAT_ASCII;
+
+        //pNewPhone->PhoneCaps.dwPhoneStates
+        //pNewPhone->PhoneCaps.dwHookSwitchDevs
+        //pNewPhone->PhoneCaps.dwHandsetHookSwitchModes
+        //pNewPhone->PhoneCaps.dwSpeakerHookSwitchModes
+        //pNewPhone->PhoneCaps.dwHeadsetHookSwitchModes
+
+        //pNewPhone->PhoneCaps.dwVolumeFlags
+        //pNewPhone->PhoneCaps.dwGainFlags
+        //pNewPhone->PhoneCaps.dwDisplayNumRows
+        //pNewPhone->PhoneCaps.dwDisplayNumColumns
+        //pNewPhone->PhoneCaps.dwNumRingModes
+        //pNewPhone->PhoneCaps.dwNumButtonLamps
+
+        //pNewPhone->PhoneCaps.dwButtonModesSize
+        //pNewPhone->PhoneCaps.dwButtonModesOffset
+
+        //pNewPhone->PhoneCaps.dwButtonFunctionsSize
+        //pNewPhone->PhoneCaps.dwButtonFunctionsOffset
+
+        //pNewPhone->PhoneCaps.dwLampModesSize
+        //pNewPhone->PhoneCaps.dwLampModesOffset
+
+        //pNewPhone->PhoneCaps.dwNumSetData
+        //pNewPhone->PhoneCaps.dwSetDataSize
+        //pNewPhone->PhoneCaps.dwSetDataOffset
+
+        //pNewPhone->PhoneCaps.dwNumGetData
+        //pNewPhone->PhoneCaps.dwGetDataSize
+        //pNewPhone->PhoneCaps.dwGetDataOffset
+
+        //pNewPhone->PhoneCaps.dwDevSpecificSize
+        //pNewPhone->PhoneCaps.dwDevSpecificOffset
+
+
+        //
+        // Status
+        //
+
+        pNewPhone->PhoneStatus.dwUsedSize =
+        pNewPhone->PhoneStatus.dwNeededSize = sizeof(PHONESTATUS);
+
+
+        //
+        // Insert new phone...
+        //
+
+        while (pWidget)
+        {
+            if ((pWidget->dwType == WT_DRVPHONE) &&
+                (((PDRVPHONE)pWidget)->dwDeviceID > dwDeviceID))
+            {
+                break;
+            }
+
+            pWidget = pWidget->pNext;
+        }
+
+        InsertWidgetInList ((PDRVWIDGET) pNewPhone, pWidget);
+    }
+
+    return pNewPhone;
+}
+
+
+PDRVPHONE
+GetPhone(
+    DWORD dwDeviceID
+    )
+{
+    PDRVWIDGET pWidget = gaWidgets;
+
+
+    while (pWidget)
+    {
+        if ((pWidget->dwType == WT_DRVPHONE) &&
+            (((PDRVPHONE) pWidget)->dwDeviceID == dwDeviceID))
+        {
+            return ((PDRVPHONE) pWidget);
+        }
+
+        pWidget = pWidget->pNext;
+    }
+
+    return ((PDRVPHONE) NULL);
+}
+
+
+VOID
+FreePhone(
+    PDRVPHONE   pPhone
+    )
+{
+    // BUGBUG need to complete all pending reqs
+
+    RemoveWidgetFromList ((PDRVWIDGET) pPhone);
+}
+
+
+int
+GetWidgetIndex(
+    PDRVWIDGET  pWidget
+    )
+{
+    int i;
+    PDRVWIDGET pWidget2 = gaWidgets;
+
+
+    for (i = 0; pWidget != pWidget2; i++)
+    {
+        pWidget2 = pWidget2->pNext;
+    }
+
+    return i;
+}
diff --git a/private/tapi/dev/sp/esp/win31.mak b/private/tapi/dev/sp/esp/win31.mak
new file mode 100644
index 000000000..05b19002e
--- /dev/null
+++ b/private/tapi/dev/sp/esp/win31.mak
@@ -0,0 +1,60 @@
+!include \telephon\tapi\tapi.mak
+
+!ifndef  TAPI_1_1
+TAPI_1_1 = 1
+!endif
+
+!if $(TAPI_1_1)
+TAPI_VER_FLAGS = -DTAPI_1_1
+!else
+TAPI_VER_FLAGS =
+!endif
+
+
+DLLOBJ = esp.obj widget.obj vars.obj
+APPOBJ = espexe.obj
+
+release: esp.tsp espexe.exe
+
+esp.obj:
+  cl $(CFLAGS) $(TAPI_VER_FLAGS)  /c esp.c
+
+widget.obj:
+  cl $(CFLAGS) $(TAPI_VER_FLAGS)  /c widget.c
+
+vars.obj:
+  cl $(CFLAGS) $(TAPI_VER_FLAGS)  /c vars.c
+
+esp.tsp:: $(DLLOBJ) $(@B).def $(@B).rc
+        echo >NUL @<<$(@B).CRF
+$(DLLOBJ)
+$@
+$(@B).map
+c:\msvc\lib\+
+$(LIBS)
+$(@B).def;
+<<
+        link $(LFLAGS) /NOPACKC @$(@B).CRF
+        $(RC) $(RESFLAGS) $(@B).rc $@
+        implib /nologo /nowep $(@B).LIB $@
+        mapsym $(@B)
+        copy esp.tsp ..\..\lib\i386
+
+
+
+espexe.obj:
+  cl $(APPCFLAGS) /c espexe.c
+
+espexe.exe:: $(APPOBJ) $(@B).def $(@B).rc
+        echo >NUL @<<$(@B).CRF
+$(APPOBJ)
+$@
+$(@B).MAP
+c:\msvc\lib\+
+libw llibcew esp
+$(@B).def;
+<<
+        link $(LFLAGS) @$(@B).CRF
+        $(RC) $(RESFLAGS) $(@B).rc $@
+        mapsym $(@B)
+        copy espexe.exe ..\..\lib\i386
diff --git a/private/tapi/dev/sp/hmtsp/depend.mk b/private/tapi/dev/sp/hmtsp/depend.mk
new file mode 100644
index 000000000..e7ec80539
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/depend.mk
@@ -0,0 +1,3 @@
+.\hmtsp.obj: ..\hmtsp.c ..\hmtsp.h
+
+.\hmtsp.res: ..\hmtsp.rc ..\hmtsprc.h
diff --git a/private/tapi/dev/sp/hmtsp/hmtsp.c b/private/tapi/dev/sp/hmtsp/hmtsp.c
new file mode 100644
index 000000000..5aafed5b5
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/hmtsp.c
@@ -0,0 +1,1160 @@
+// Happy Modem Testing Service Provider
+// derived from PDISP
+
+#ifndef TESTING
+#define TESTING
+#endif
+
+#define USECOMM                 /* for chicago windows.h */
+#include <windows.h>
+#include <memory.h>    
+#include <stdlib.h>   
+#include <string.h>
+#include <assert.h>
+#include "hmtsp.h"
+
+#ifdef TESTING
+void FAR PASCAL LogDestAddress(LPCSTR szDestAddress);
+#endif
+
+BOOL CALLBACK ConfigDlgProc(HWND, UINT, WPARAM, LPARAM);
+
+int   SerialOpenComms (LPSTR, LPSTR);
+void    LoadIniStrings (DWORD);
+long    appCall (int, char *, long);
+
+
+#define msgMakeCall                     1
+#define msgDrop                         2
+
+
+// The number of entries in the devices and speed array.
+
+#define NUMPORTS 4
+
+char *lpszCommDevArray[NUMPORTS] = 
+{ "COM1", "COM2", "COM3", "COM4" };
+
+
+// Various tags in the ini file.
+
+char s_telephon_ini[] = "telephon.ini";
+
+char s_one[]                    = "1";
+char s_zero[]                   = "0";
+char s_numlines[]               = "NumLines";
+char s_numphones[]      = "NumPhones";
+char s_providerx[]      = "Provider%d";
+
+char s_port[]                   = "Port";
+char s_linename[]               = "LineName";
+char s_lineaddr[]               = "LineAddress";
+
+// The global module handle
+
+HANDLE  hInst                   = NULL;
+
+// Line object.
+ATSPLineData line;
+
+// Provider description string
+char gszProviderInfo[255];
+
+
+///////////////////////////////////////////////////////////
+// The required DLL functions
+///////////////////////////////////////////////////////////
+
+int FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSegment,
+			       WORD wHeapSize, LPSTR lpszCmdLine)
+{                      
+	if (hInst != NULL)
+		return FALSE;
+
+	hInst = hInstance;
+
+	return TRUE;
+}
+
+VOID FAR PASCAL  WEP (int bSystemExit)
+{ 
+	hInst = NULL;
+}
+
+
+///////////////////////////////////////////////////////////
+// The Service Provider Basic Configuration Routines
+///////////////////////////////////////////////////////////
+
+static BOOL initialised = FALSE;
+
+LONG TSPIAPI TSPI_lineNegotiateTSPIVersion (
+DWORD           dwDeviceID,
+DWORD           dwLowVersion,
+DWORD           dwHighVersion,
+LPDWORD lpdwTSPIVersion)
+{
+	DebugMsg (("Entering TSPI_lineNegotiateTSPIVersion"));
+
+	// line.lineID will contain garbage before provider_init has
+	// been called (ie. first time through). However, we can guarantee
+	// that the first call will be with INITIALIZE_NEGOTIATION and that
+	// is followed immediately by provider_init. This would be a problem
+	// if the line data structure was dynamically allocated !
+
+	if (dwDeviceID == INITIALIZE_NEGOTIATION ||
+		 dwDeviceID == line.lineID)                     // we support only one line
+	{
+		*lpdwTSPIVersion = ATSP_VERSION;
+		
+		if (dwLowVersion  > ATSP_VERSION ||     // the app is too new for us
+			 dwHighVersion < ATSP_VERSION)  // we are too new for the app
+			return LINEERR_INCOMPATIBLEAPIVERSION;
+		else
+			return 0;
+	}
+
+	return LINEERR_BADDEVICEID;             // The requested device doesn't exist
+}
+
+
+LONG TSPIAPI TSPI_providerInit (
+DWORD             dwTSPIVersion,
+DWORD             dwPermanentProviderID,
+DWORD             dwLineDeviceIDBase,
+DWORD             dwPhoneDeviceIDBase,
+DWORD             dwNumLines,
+DWORD             dwNumPhones,
+ASYNC_COMPLETION  lpfnCompletionProc,
+LPDWORD           lpdwOptions
+)
+{
+	DebugMsg (("Entering TSPI_providerInit"));
+
+	assert (dwTSPIVersion == ATSP_VERSION);
+	assert (dwNumLines    == 1);
+	assert (dwNumPhones   == 0);
+
+	if (initialised)
+		return LINEERR_NOMULTIPLEINSTANCE;
+	
+	// initialise our internal structures
+
+	ZeroMemory (&line, sizeof (ATSPLineData));
+  
+	line.lpfnCompletion     = lpfnCompletionProc;
+	line.lineID                             = dwLineDeviceIDBase;
+	line.dwMediaMode                = LINEMEDIAMODE_INTERACTIVEVOICE;
+	line.hcd                                        = -1;
+	LoadIniStrings (dwPermanentProviderID);
+
+	initialised = TRUE;
+
+	return 0;
+}
+
+
+LONG TSPIAPI TSPI_providerShutdown (DWORD dwTSPIVersion)
+{                                                                                          
+	DebugMsg (("Entering TSPI_providerShutdown"));
+
+	initialised = FALSE;
+
+	return 0;
+}
+
+
+///////////////////////////////////////////////////////////
+// The Line Specific Calls
+///////////////////////////////////////////////////////////
+
+LONG TSPIAPI TSPI_lineConfigDialog (
+DWORD    dwDeviceID, 
+HWND     hwndOwner,
+LPCSTR lpszDeviceClass)
+{
+	DebugMsg (("Entering TSPI_lineConfigDialog"));
+	
+	if (dwDeviceID != line.lineID)
+		return LINEERR_BADDEVICEID;
+
+#ifndef TESTING
+	DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG),
+							hwndOwner, ConfigDlgProc);
+#endif
+
+	return 0;
+}
+
+
+long lineDropCore (ATSPLineData *theLine, DWORD dwRequestID)
+{
+	// if the call is not idle, transition to idle and close the comms port
+	
+	return appCall (msgDrop, 0, dwRequestID);
+}
+
+
+LONG TSPIAPI TSPI_lineClose (HDRVLINE hdLine)
+{
+	DebugMsg (("Entering TSPI_lineClose"));
+  
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	// call drop in case there is still an active call on the line
+	lineDropCore (&line, 0);
+
+	return 0;
+}
+
+
+LONG TSPIAPI TSPI_lineCloseCall (HDRVCALL hdCall)
+{
+	DebugMsg (("Entering TSPI_lineCloseCall"));
+  
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+	
+	// call drop in case there is still an active call on the line
+	lineDropCore (&line, 0);
+
+	line.callState = 0;
+	return 0;
+}
+
+
+LONG TSPIAPI TSPI_lineDrop (
+DRV_REQUESTID   dwRequestID, 
+HDRVCALL                        hdCall,
+LPCSTR                  lpsUserUserInfo, 
+DWORD                           dwSize)
+{
+	// Transition a call to the IDLE state.
+  
+	DebugMsg (("Entering TSPI_lineDrop"));
+  
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+	
+	return lineDropCore (&line, dwRequestID);       // it was our active call
+}
+
+LONG TSPIAPI TSPI_lineGetAddressCaps (
+DWORD                                   dwDeviceID,
+DWORD                                   dwAddressID,
+DWORD                                   dwTSPIVersion,
+DWORD                                   dwExtVersion,
+LPLINEADDRESSCAPS lpAddressCaps)
+
+{
+	int cbLineAddr;
+
+	DebugMsg (("Entering TSPI_lineGetAddressCaps"));
+
+	// We support only one line and one address.
+  
+	if (dwDeviceID != line.lineID)
+		return LINEERR_BADDEVICEID;
+
+	if (dwAddressID != 0)
+		return LINEERR_INVALADDRESSID;
+  
+	cbLineAddr = lstrlen (line.lineaddr) + 1;
+
+	lpAddressCaps->dwNeededSize = sizeof (LINEADDRESSCAPS) + cbLineAddr;
+
+	if (lpAddressCaps->dwTotalSize < lpAddressCaps->dwNeededSize)
+		lpAddressCaps->dwUsedSize = sizeof (LINEADDRESSCAPS);
+	else
+	{
+		MoveMemory((char *) lpAddressCaps + sizeof (LINEADDRESSCAPS), 
+					line.lineaddr, cbLineAddr);
+
+		lpAddressCaps->dwAddressSize     = cbLineAddr;
+		lpAddressCaps->dwAddressOffset = sizeof (LINEADDRESSCAPS);
+		lpAddressCaps->dwUsedSize                = lpAddressCaps->dwNeededSize;
+	}
+  
+	lpAddressCaps->dwLineDeviceID                   =       line.lineID;
+
+	lpAddressCaps->dwAddressSharing         =       LINEADDRESSSHARING_PRIVATE;
+	lpAddressCaps->dwAddressStates          =       LINEADDRESSSTATE_OTHER |
+														LINEADDRESSSTATE_INUSEZERO |
+														LINEADDRESSSTATE_INUSEONE |
+														LINEADDRESSSTATE_NUMCALLS;
+	lpAddressCaps->dwCallInfoStates         =       LINECALLINFOSTATE_OTHER |
+														LINECALLINFOSTATE_APPSPECIFIC |
+														LINECALLINFOSTATE_NUMOWNERINCR |
+														LINECALLINFOSTATE_NUMOWNERDECR |
+														LINECALLINFOSTATE_NUMMONITORS |
+														LINECALLINFOSTATE_DIALPARAMS;
+	lpAddressCaps->dwCallerIDFlags          =       LINECALLPARTYID_UNAVAIL;
+	lpAddressCaps->dwCalledIDFlags          =       LINECALLPARTYID_UNAVAIL;
+	lpAddressCaps->dwConnectedIDFlags       =       LINECALLPARTYID_UNAVAIL;
+	lpAddressCaps->dwRedirectionIDFlags     =       LINECALLPARTYID_UNAVAIL;
+	lpAddressCaps->dwRedirectingIDFlags     =       LINECALLPARTYID_UNAVAIL;
+	lpAddressCaps->dwCallStates                     =       LINECALLSTATE_IDLE |
+														LINECALLSTATE_DIALTONE |
+														LINECALLSTATE_DIALING |
+														LINECALLSTATE_BUSY |
+														LINECALLSTATE_CONNECTED |
+														LINECALLSTATE_PROCEEDING |
+														LINECALLSTATE_UNKNOWN;
+	lpAddressCaps->dwDialToneModes          =       LINEDIALTONEMODE_UNAVAIL;
+	lpAddressCaps->dwBusyModes                              =       LINEBUSYMODE_UNAVAIL;
+	lpAddressCaps->dwSpecialInfo                    =       LINESPECIALINFO_UNAVAIL;
+	lpAddressCaps->dwDisconnectModes                =       LINEDISCONNECTMODE_UNKNOWN;
+	lpAddressCaps->dwMaxNumActiveCalls      =       1;
+	lpAddressCaps->dwAddrCapFlags                   =       LINEADDRCAPFLAGS_BLOCKIDDEFAULT |
+														LINEADDRCAPFLAGS_DIALED |
+														LINEADDRCAPFLAGS_PARTIALDIAL;
+	lpAddressCaps->dwCallFeatures                   =       LINECALLFEATURE_DIAL |
+														LINECALLFEATURE_DROP;
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetAddressID (
+HDRVLINE                 hdLine, 
+LPDWORD          lpdwAddressID, 
+DWORD                    dwAddressMode,
+LPCSTR           lpsAddress, 
+DWORD                    dwSize)
+{
+	DebugMsg (("Entering TSPI_lineGetAddressID"));
+
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	assert (dwAddressMode == LINEADDRESSMODE_DIALABLEADDR);
+
+	if (lstrcmp (line.lineaddr, lpsAddress))
+		return LINEERR_INVALADDRESS;
+	else
+	{ 
+		*lpdwAddressID = 0;     // we support only 1 line
+		return 0;
+	}
+}
+
+LONG TSPIAPI TSPI_lineGetAddressStatus (
+HDRVLINE                                        hdLine,
+DWORD                                           dwAddressID,
+LPLINEADDRESSSTATUS     lpAddressStatus)
+{
+	DebugMsg (("Entering TSPI_lineGetAddressStatus"));
+
+	if (dwAddressID)
+		return LINEERR_INVALADDRESSID;
+
+	lpAddressStatus->dwUsedSize     = 
+	lpAddressStatus->dwNeededSize   = sizeof (LINEADDRESSSTATUS);
+  
+	// if we are idle a call can be made
+
+	if (line.callState == 0)                // our internal flag that line is not in use
+		lpAddressStatus->dwAddressFeatures = LINEADDRFEATURE_MAKECALL;
+	else
+	{
+		lpAddressStatus->dwNumInUse              = 1;
+		lpAddressStatus->dwNumActiveCalls = 1;
+	}
+
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetCallAddressID (
+HDRVCALL        hdCall,
+LPDWORD lpdwAddressID)
+{
+	DebugMsg (("Entering TSPI_lineGetCallAddressID"));
+
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+
+	// There is but a single address where a call may exist.
+	*lpdwAddressID = 0;
+  
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetCallInfo (
+HDRVCALL                        hdCall,
+LPLINECALLINFO  lpCallInfo)
+{
+	int cbDestAddr = lstrlen (line.DestAddress) + 1;
+	
+	DebugMsg (("Entering TSPI_lineGetCallInfo"));
+
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+
+
+	lpCallInfo->dwUsedSize   = sizeof (LINECALLINFO);
+	lpCallInfo->dwNeededSize = sizeof (LINECALLINFO) + cbDestAddr;
+
+	if (lpCallInfo->dwTotalSize >= lpCallInfo->dwNeededSize)
+	{
+		CopyMemory((char *) lpCallInfo + sizeof (LINECALLINFO), 
+					line.DestAddress, cbDestAddr);
+
+		lpCallInfo->dwDisplayableAddressSize    = cbDestAddr;
+		lpCallInfo->dwDisplayableAddressOffset  = sizeof (LINECALLINFO);
+		lpCallInfo->dwUsedSize                                          = lpCallInfo->dwNeededSize;
+	}
+
+	lpCallInfo->dwLineDeviceID                                      =       line.lineID;
+	lpCallInfo->dwBearerMode                                        =       LINEBEARERMODE_VOICE;
+	lpCallInfo->dwMediaMode                                         =       line.dwMediaMode;
+	lpCallInfo->dwAppSpecific                                       =       line.dwAppSpecific;
+	lpCallInfo->dwCallParamFlags                            =       LINECALLPARAMFLAGS_IDLE |
+															LINECALLPARAMFLAGS_BLOCKID;
+	lpCallInfo->dwCallStates                                        =       LINECALLSTATE_IDLE |
+															LINECALLSTATE_CONNECTED;
+	lpCallInfo->dwOrigin                                                    =       LINECALLORIGIN_OUTBOUND;
+	lpCallInfo->dwReason                                                    =       LINECALLREASON_UNAVAIL;
+	lpCallInfo->dwCallerIDFlags                             =       LINECALLPARTYID_UNAVAIL;
+	lpCallInfo->dwCalledIDFlags                             =       LINECALLPARTYID_UNAVAIL;
+	lpCallInfo->dwConnectedIDFlags                  =       LINECALLPARTYID_UNAVAIL;
+	lpCallInfo->dwRedirectionIDFlags                        =       LINECALLPARTYID_UNAVAIL;
+	lpCallInfo->dwRedirectingIDFlags                        =       LINECALLPARTYID_UNAVAIL;
+
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetCallStatus (
+HDRVCALL                          hdCall,
+LPLINECALLSTATUS lpCallStatus)
+{
+	DebugMsg (("Entering TSPI_lineGetCallStatus"));
+
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+	
+	lpCallStatus->dwCallState = line.callState;
+	
+	if (line.callState == LINECALLSTATE_CONNECTED)
+		lpCallStatus->dwCallFeatures = LINECALLFEATURE_DROP;
+
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetDevCaps (
+DWORD dwDeviceID,
+DWORD dwTSPIVersion, 
+DWORD dwExtVersion,
+LPLINEDEVCAPS lpLineDevCaps)
+{
+	int cbname = lstrlen (line.linename)   + 1;
+	int cbinfo = lstrlen (gszProviderInfo) + 1;
+
+	DebugMsg (("Entering TSPI_lineGetDevCaps"));
+
+	if (dwDeviceID != line.lineID)
+		return LINEERR_BADDEVICEID;
+
+
+	lpLineDevCaps->dwUsedSize   = sizeof (LINEDEVCAPS);
+	lpLineDevCaps->dwNeededSize = sizeof (LINEDEVCAPS) + cbinfo + cbname;
+
+  
+	if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwUsedSize + cbinfo)
+	{
+		// Copy in the provider info
+
+		CopyMemory ((char *)lpLineDevCaps + lpLineDevCaps->dwUsedSize, 
+												gszProviderInfo, cbinfo);
+
+		lpLineDevCaps->dwProviderInfoSize       = cbinfo;
+		lpLineDevCaps->dwProviderInfoOffset     = lpLineDevCaps->dwUsedSize;
+		lpLineDevCaps->dwUsedSize                         += cbinfo;
+	}
+  
+	if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwUsedSize + cbname)
+	{
+		// Copy in the line name
+
+		CopyMemory((char *) lpLineDevCaps + lpLineDevCaps->dwUsedSize,
+												line.linename, cbname);
+   
+		lpLineDevCaps->dwLineNameSize           = cbname;
+		lpLineDevCaps->dwLineNameOffset = lpLineDevCaps->dwUsedSize;
+		lpLineDevCaps->dwUsedSize                 += cbname;
+	}
+  
+
+	lpLineDevCaps->dwPermanentLineID                = (line.dwppID << 16) + 0;
+  
+	// TAPI.DLL fills in APIVersion and ExtVersion.
+
+	lpLineDevCaps->dwNumAddresses                   =       1;
+	lpLineDevCaps->dwMaxNumActiveCalls      =       1;
+	lpLineDevCaps->dwStringFormat                   =       STRINGFORMAT_ASCII;
+	lpLineDevCaps->dwBearerModes                    =       LINEBEARERMODE_VOICE;
+	lpLineDevCaps->dwMediaModes                     =       LINEMEDIAMODE_INTERACTIVEVOICE;
+
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetID (
+HDRVLINE                        hdLine,
+DWORD                           dwAddressID,
+HDRVCALL                        hdCall,
+DWORD                           dwSelect,
+LPVARSTRING             lpDeviceID,
+LPCSTR                  lpszDeviceClass,
+HANDLE                  hHandle)
+{
+	DebugMsg (("Entering TSPI_lineGetID"));
+
+	// Since we have only one device, we don't have to
+	// check the location of the line, address, or call.
+
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	if (lstrcmp (lpszDeviceClass, "tapi/line") == 0)
+	{
+		lpDeviceID->dwNeededSize = sizeof (VARSTRING) + sizeof (DWORD);
+
+		if (lpDeviceID->dwTotalSize >= lpDeviceID->dwNeededSize)
+		{
+			lpDeviceID->dwUsedSize          = lpDeviceID->dwNeededSize;
+	lpDeviceID->dwStringFormat      = STRINGFORMAT_BINARY;
+	lpDeviceID->dwStringSize        = sizeof (DWORD);
+	lpDeviceID->dwStringOffset      = sizeof (VARSTRING);
+		
+	*((DWORD *) ((char *) lpDeviceID + sizeof (VARSTRING))) = 
+																				line.lineID;
+		}
+
+		return 0;
+	}
+
+#ifdef COMMSUPPORT  
+	if (lstrcmp (lpszDeviceClass, "comm") == 0)
+	{
+      int cbport = lstrlen (line.port) + 1;
+
+      lpDeviceID->dwNeededSize = sizeof (VARSTRING) + cbport;
+
+		if (lpDeviceID->dwTotalSize >= lpDeviceID->dwNeededSize)
+		{
+			lpDeviceID->dwUsedSize          = lpDeviceID->dwNeededSize;
+			lpDeviceID->dwStringFormat = STRINGFORMAT_ASCII;
+			lpDeviceID->dwStringSize        = cbport;
+			lpDeviceID->dwStringOffset = sizeof (VARSTRING);
+
+			CopyMemory ((char *) lpDeviceID + sizeof (VARSTRING), 
+																	line.port, cbport);
+		}
+
+		return 0;
+	}
+#endif
+  
+	return LINEERR_NODEVICE;
+}
+
+LONG TSPIAPI TSPI_lineGetLineDevStatus (
+HDRVLINE                         hdLine,
+LPLINEDEVSTATUS lpLineDevStatus)
+{
+	DebugMsg (("Entering TSPI_lineGetLineDevStatus"));
+  
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	lpLineDevStatus->dwUsedSize              =
+	lpLineDevStatus->dwNeededSize            = sizeof (LINEDEVSTATUS);
+
+	lpLineDevStatus->dwOpenMediaModes = line.dwLineMediaModes;
+	lpLineDevStatus->dwRoamMode              = LINEROAMMODE_UNAVAIL;
+
+	if (line.callState == 0)
+	{
+		lpLineDevStatus->dwNumActiveCalls = 0;
+		lpLineDevStatus->dwLineFeatures  = LINEFEATURE_MAKECALL;
+	}
+	else
+	{
+		lpLineDevStatus->dwNumActiveCalls = 1;
+		lpLineDevStatus->dwDevStatusFlags = LINEDEVSTATUSFLAGS_CONNECTED |
+														LINEDEVSTATUSFLAGS_INSERVICE;
+	}
+
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineGetNumAddressIDs (
+HDRVLINE        hdLine,
+LPDWORD lpNumAddressIDs)
+{
+	DebugMsg (("Entering TSPI_lineGetNumAddressIDs"));
+  
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	*lpNumAddressIDs = 1;   // We only support one address
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineMakeCall (
+DRV_REQUESTID                           dwRequestID,
+HDRVLINE                                                hdLine,
+HTAPICALL                                       htCall,
+LPHDRVCALL                                      lphdCall,
+LPCSTR                                          lpszDestAddress,
+DWORD                                                   dwCountryCode,
+LPLINECALLPARAMS const  lpCallParams)
+{
+	DebugMsg (("Entering TSPI_lineMakeCall"));
+
+#ifdef TESTING
+	LogDestAddress(lpszDestAddress);
+#endif  
+
+	if (lpszDestAddress && 
+		lstrlen (lpszDestAddress) > TAPIMAXDESTADDRESSSIZE)
+		return LINEERR_INVALPOINTER;
+
+	if (line.callState != 0)
+		return LINEERR_RESOURCEUNAVAIL;
+  
+	if (lpCallParams)
+	{
+		if (lpCallParams->dwCallParamFlags & 
+			 ~(LINECALLPARAMFLAGS_IDLE | LINECALLPARAMFLAGS_BLOCKID))
+			return LINEERR_INVALCALLPARAMS;
+	}
+
+	// fill in fields of the call record
+
+	line.htCall = htCall;                   // we have no hdcall of our own
+	*lphdCall = (HDRVCALL) htCall;
+
+	if (lpszDestAddress)
+		lstrcpy (line.DestAddress, lpszDestAddress);
+	else 
+		line.DestAddress[0] = 0;                        
+
+	return appCall (msgMakeCall, line.DestAddress, dwRequestID);
+}
+
+long appCall (int msg, char *str, long dwRequestID)
+{
+#ifndef TESTING
+	long wait;
+#endif
+
+	if (msg == msgMakeCall)
+	{
+#ifdef TESTING
+                line.hcd = 1;  
+#else
+		line.hcd = SerialOpenComms (line.port, "9600");
+#endif         
+		if (line.hcd < 0)
+			return LINEERR_RESOURCEUNAVAIL;
+		else
+		{
+			char dial[255];
+			wsprintf (dial, "ATMH9D%s;\r", str);
+#ifdef TESTING
+                        DebugMsg (("Sent: %s", dial));
+                        PostMessage(HWND_BROADCAST, WM_USER + 945, 0, 0);
+
+                        line.callState = LINECALLSTATE_CONNECTED;
+                        line.lpfnCompletion (dwRequestID, 0);
+                        line.lpfnEventProc  (line.htLine, line.htCall, LINE_CALLSTATE,
+										   LINECALLSTATE_CONNECTED, 0, 0);
+#else
+			if (WriteComm (line.hcd, dial, lstrlen (dial)) > 0)
+			{
+				DebugMsg (("Sent: %s", dial));
+
+				line.callState = LINECALLSTATE_CONNECTED;
+				line.lpfnCompletion (dwRequestID, 0);
+				line.lpfnEventProc  (line.htLine, line.htCall, LINE_CALLSTATE,
+										   LINECALLSTATE_CONNECTED, 0, 0);
+			}
+			else
+			{
+				DebugMsg (("failed to write string"));  
+				return GetCommError (line.hcd, NULL);
+                        }
+#endif /* TESTING */
+
+		}
+	}
+	else    // must be linedrop
+	{
+		if (line.hcd < 0)
+			DebugMsg (("idle"));
+		else
+		{
+#ifndef TESTING
+			wait = GetTickCount();
+			WriteComm (line.hcd, "\r", 1);
+			while (GetTickCount() - wait < 250);
+
+			if (WriteComm (line.hcd, "ATH8\r", 6) > 0)
+				DebugMsg (("Sent: %s", str));
+			else
+				DebugMsg (("failed to hang up"));  
+
+			wait = GetTickCount();
+			while (GetTickCount() - wait < 250);
+
+			EscapeCommFunction (line.hcd, CLRDTR);  // drop DTR
+	
+			if (CloseComm (line.hcd))
+				DebugMsg (("Couldn't close the serial port"));
+#endif /* TESTING */    
+			line.hcd = -1;
+			line.callState = LINECALLSTATE_IDLE;
+			line.lpfnEventProc (line.htLine, line.htCall, LINE_CALLSTATE,
+									  LINECALLSTATE_IDLE, 0, 0);
+		}
+
+		if (dwRequestID)
+			line.lpfnCompletion (dwRequestID, 0);
+	}
+
+	return dwRequestID;
+}
+
+
+LONG TSPIAPI TSPI_lineOpen (
+DWORD                   dwDeviceID,
+HTAPILINE       htLine,
+LPHDRVLINE      lphdLine,
+DWORD                   dwTSPIVersion,
+LINEEVENT       lpfnEventProc)
+{
+	DebugMsg (("Entering TSPI_lineOpen"));
+  
+	if (dwDeviceID != line.lineID)
+		return LINEERR_BADDEVICEID;
+
+	// Since we only support outgoing calls, we
+	// don't open the serial port until we need to make a call
+  
+	line.lpfnEventProc = lpfnEventProc;
+	line.htLine                      = htLine;
+	*lphdLine                        = (HDRVLINE) &line;
+  
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineSetAppSpecific (
+HDRVCALL        hdCall,
+DWORD           dwAppSpecific)
+{
+	DebugMsg (("Entering TSPI_lineSetAppSpecific"));
+
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+
+	line.dwAppSpecific = dwAppSpecific;
+
+	line.lpfnEventProc (line.htLine, line.htCall, LINE_CALLINFO, 
+							  LINECALLINFOSTATE_APPSPECIFIC, 0, 0);
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineConditionalMediaDetection ( 
+HDRVLINE          hdLine,
+DWORD             dwMediaModes,
+LPLINECALLPARAMS  const lpCallParams)
+{
+	DebugMsg (("Entering TSPI_lineConditionalMediaDetection"));
+
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	if (dwMediaModes != LINEMEDIAMODE_INTERACTIVEVOICE)
+		return LINEERR_INVALMEDIAMODE;
+
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineSetDefaultMediaDetection (
+HDRVLINE        hdLine,
+DWORD           dwMediaModes)
+{
+	DebugMsg (("Entering TSPI_lineSetDefaultMediaDetection"));
+
+	if (hdLine != (HDRVLINE) &line)
+		return LINEERR_INVALLINEHANDLE;
+
+	if (dwMediaModes && dwMediaModes != LINEMEDIAMODE_INTERACTIVEVOICE)
+		return LINEERR_INVALMEDIAMODE;
+
+	line.dwLineMediaModes = dwMediaModes;
+	
+	return 0;
+}
+
+LONG TSPIAPI TSPI_lineSetMediaMode (
+HDRVCALL        hdCall,
+DWORD           dwMediaMode)
+{ 
+	DebugMsg (("Entering TSPI_lineSetMediaMode"));
+  
+	if (hdCall != (HDRVCALL) line.htCall)
+		return LINEERR_INVALCALLHANDLE;
+		
+	if (dwMediaMode != LINEMEDIAMODE_INTERACTIVEVOICE)
+		return LINEERR_INVALMEDIAMODE;
+  
+	line.dwMediaMode = dwMediaMode;
+	
+	return 0;
+}
+
+
+///////////////////////////////////////////////////////////
+// The configuration trio
+///////////////////////////////////////////////////////////
+
+// These routines are called from the control panel applet
+// TAPI may not be running at this point, so one cannot assume
+// we have been initialised
+
+LONG TSPIAPI TSPI_providerConfig (HWND hwnd, DWORD dwPermanentProviderId)
+{
+	DebugMsg (("Entering TSPI_providerConfig"));
+
+	if (!initialised)
+		LoadIniStrings (dwPermanentProviderId);
+	else if (dwPermanentProviderId != line.dwppID)
+		return LINEERR_NOMULTIPLEINSTANCE;
+
+#ifndef TESTING
+	DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), hwnd, ConfigDlgProc);
+#endif
+
+	return 0;
+}
+
+
+LONG TSPIAPI TSPI_providerInstall (HWND hwnd, DWORD dwPermanentProviderId)
+{
+	int res;
+	char szProvider[sizeof (s_providerx) + 5];              // room for 65535
+
+	DebugMsg (("Entering TSPI_providerInstall"));
+
+	if (!initialised)
+		LoadIniStrings (dwPermanentProviderId);
+	else if (dwPermanentProviderId != line.dwppID)
+	{
+		res = ID_MULTIPLE_INST;
+		goto error;
+	}
+
+	wsprintf (szProvider, s_providerx, (int) dwPermanentProviderId);
+	
+	// we support 1 line and 0 phones
+
+	WritePrivateProfileString (szProvider, s_numlines,  s_one,  s_telephon_ini);
+	WritePrivateProfileString (szProvider, s_numphones, s_zero, s_telephon_ini);
+
+	// Flush the ini file cache.
+	WritePrivateProfileString (0, 0, 0, s_telephon_ini);
+
+#ifndef TESTING
+	// display the config screen
+	if (DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), 
+											hwnd, ConfigDlgProc) == 0)
+		return 0;
+	else
+		return LINEERR_OPERATIONFAILED;
+
+#else
+        return 0;
+#endif
+
+error:
+	{
+		char szerr[255];
+		char title[255];
+
+		LoadString (hInst, res, szerr, sizeof (szerr));
+		LoadString (hInst, ID_ATSP_ERROR, title, sizeof (title));
+
+		MessageBox (hwnd, szerr, title, MB_APPLMODAL | MB_ICONEXCLAMATION);
+
+		return LINEERR_OPERATIONFAILED;
+	}
+}
+
+
+LONG TSPIAPI TSPI_providerRemove (HWND hwnd, DWORD dwPermanentProviderId)
+{
+	DebugMsg (("Entering TSPI_providerRemove"));
+
+	// The control panel removes all of our junk for us
+	// (and then some) when the provider is removed.
+	
+	return 0;
+}
+
+
+
+///////////////////////////////////////////////////////////
+// Internal support routines
+///////////////////////////////////////////////////////////
+
+
+void LoadIniStrings (DWORD ppID)
+{
+	char section[sizeof (s_providerx) + 5];         // room for 65535
+
+	wsprintf (section, s_providerx, (int) ppID);
+	line.dwppID = ppID;
+#ifdef TESTING
+        lstrcpy(line.port, "COM1");
+        lstrcpy(line.linename, "Testing SP");
+        lstrcpy(line.lineaddr, "");
+#else
+	// user preferences come from the telephon.ini file
+
+	GetPrivateProfileString (section, s_port, "COM1", line.port,
+											sizeof (line.port), s_telephon_ini);
+	GetPrivateProfileString (section, s_linename, "", line.linename, 
+											sizeof (line.linename), s_telephon_ini);
+	GetPrivateProfileString (section, s_lineaddr, "", line.lineaddr, 
+                                                                     sizeof (line.lineaddr), s_telephon_ini);
+#endif /* TESTING */
+
+	// the provider info string comes from the resource file
+
+	gszProviderInfo[0] = 0;         // in case loadstring fails
+
+	LoadString (hInst, ID_PROVIDER_INFO, gszProviderInfo, sizeof (gszProviderInfo));
+  
+	return;
+}
+
+
+BOOL CALLBACK 
+ConfigDlgProc (HWND hDlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
+{
+  int CurrSel;
+
+  switch (uiMsg) 
+  {
+	case WM_INITDIALOG:
+   {
+		for (CurrSel = 0; CurrSel < NUMPORTS; CurrSel++)
+		{
+			// List the port in the combo box.
+			SendDlgItemMessage (hDlg, ID_PORT, CB_ADDSTRING,
+									0, (LPARAM) ((LPSTR) lpszCommDevArray[CurrSel]));
+		}
+								
+		CurrSel = (int) SendDlgItemMessage (hDlg, ID_PORT,  CB_FINDSTRING, 
+															0, (LPARAM) (LPSTR) line.port);
+		SendDlgItemMessage (hDlg, ID_PORT,              CB_SETCURSEL, CurrSel, 0);
+
+		SendDlgItemMessage (hDlg, ID_LINENAME, WM_SETTEXT, 0, 
+															(LPARAM) (LPSTR) line.linename);
+		SendDlgItemMessage (hDlg, ID_LINEADDR, WM_SETTEXT, 0, 
+															(LPARAM) (LPSTR) line.lineaddr);
+	}
+	break;
+
+	case WM_COMMAND:
+	{
+	  switch (wParam) 
+	  {
+		case IDOK:
+		{
+			char szp[sizeof (s_providerx) + 5];             // room for 65535
+			wsprintf (szp, s_providerx, (int) line.dwppID);
+
+			// Port
+
+			CurrSel = (int) SendDlgItemMessage (hDlg, ID_PORT, 
+																CB_GETCURSEL, 0, 0);
+			SendDlgItemMessage (hDlg, ID_PORT, CB_GETLBTEXT, CurrSel, 
+																(LPARAM) (LPSTR) line.port);
+			WritePrivateProfileString (szp, s_port, line.port, s_telephon_ini);
+	  
+			// Line Name
+
+			SendDlgItemMessage (hDlg, ID_LINENAME, WM_GETTEXT,
+							sizeof (line.linename), (LPARAM) (LPSTR) line.linename);
+			WritePrivateProfileString (szp, s_linename, line.linename, 
+																				s_telephon_ini);
+
+			// Line Address
+
+			SendDlgItemMessage (hDlg, ID_LINEADDR, WM_GETTEXT,
+							sizeof (line.lineaddr), (LPARAM) (LPSTR) line.lineaddr);
+			WritePrivateProfileString (szp, s_lineaddr, line.lineaddr, 
+																				s_telephon_ini);
+
+			// Flush the ini file cache
+
+			WritePrivateProfileString (0, 0, 0, s_telephon_ini);
+			EndDialog (hDlg, 0);
+		}
+		break;
+	 
+		case IDCANCEL:
+			EndDialog (hDlg, -1);
+			break;
+	  }
+	}
+	break;
+
+	default:
+		return FALSE;
+  }
+
+  return TRUE;
+}
+
+
+#ifdef DEBUG
+void CDECL SPTrace(LPCSTR pszFormat, ...)
+{
+	static char szBuffer[512];
+	static char fmtBuffer[1024];
+	static char szModuleBuffer[_MAX_PATH];
+	static char szTemp[_MAX_PATH];
+	static char szFName[_MAX_FNAME];
+	const char* pszLocalFormat;
+	
+	int nBuf, count, localCount;
+	va_list args;
+  
+	pszLocalFormat = pszFormat;
+  
+	va_start (args, pszFormat);
+  
+	nBuf = wvsprintf (szBuffer, pszLocalFormat, args);
+  
+	// Convert formatting to readable format.
+	for (count = 0, localCount = 0; count < nBuf; count++, localCount++)
+	{
+		if (szBuffer[count] == '\r')
+		{
+			fmtBuffer[localCount++] = '\\';
+			fmtBuffer[localCount] = 'r';
+		}
+		else if (szBuffer[count] == '\n')
+		{
+			fmtBuffer[localCount++] = '\\';
+			fmtBuffer[localCount] = 'n';
+		}
+		else
+			fmtBuffer[localCount] = szBuffer[count];
+	}
+
+	fmtBuffer[localCount] = '\0';
+
+	GetModuleFileName (hInst, szModuleBuffer, sizeof (szModuleBuffer));
+	_splitpath (szModuleBuffer, szTemp, szTemp, szFName, szTemp);
+	wsprintf (szBuffer, "%s: %s\n\r", (LPSTR) szFName, (LPSTR) fmtBuffer);
+  
+	OutputDebugString (szBuffer);
+}
+#endif
+
+
+
+UINT myatoi (LPSTR speed)
+{
+	UINT i;
+
+	for (i = 0; *speed; speed++)
+		i = i * 10 + (*speed - '0');
+	
+	return i;
+}
+
+#define TXQUEUE 512
+#define RXQUEUE 512
+
+int SerialOpenComms (LPSTR port, LPSTR speed)
+{
+
+
+#if 0
+BJM-09/06/95
+BJM-09/06/95
+BJM-09/06/95
+	int hcd = OpenComm (port, RXQUEUE, TXQUEUE);
+
+	if (hcd >= 0)
+	{
+		DCB dcb;
+
+		if (GetCommState (hcd, &dcb) == 0)
+		{
+			ZeroMemory (&dcb.BaudRate, sizeof (DCB) - sizeof (dcb.Id));
+
+			dcb.BaudRate = myatoi (speed);
+			dcb.ByteSize = 8;
+			dcb.fBinary  = TRUE;
+//                      dcb.fChEvt   = TRUE;
+			dcb.XonChar  = 17;
+			dcb.XoffChar = 19;
+//                      dcb.EvtChar  = '\n';
+
+			if (SetCommState (&dcb) == 0)
+			{
+				DebugMsg (("Opened: %s:%s", port, speed));
+				return hcd;
+			}
+		}
+
+		CloseComm (hcd);
+	}
+
+	DebugMsg (("***Comm port failed to open"));
+	return -1;
+BJM-09/06/95
+BJM-09/06/95
+#endif
+}
+
+
+#ifdef TESTING
+//
+// report last dialable address sent in to SP 
+//
+
+static char gszLastDestAddress[256];
+static BOOL gbLastAddressValid = 0;
+
+void FAR PASCAL LogDestAddress(LPCSTR szDestAddress)
+{
+	if (gbLastAddressValid == 0)
+	{
+		strncpy(gszLastDestAddress, szDestAddress, sizeof(gszLastDestAddress)-1);
+		gszLastDestAddress[sizeof(gszLastDestAddress)-1] = 0;
+		gbLastAddressValid = 1;
+	}
+}       
+
+void FAR PASCAL  GetLastDestAddress (LPSTR szLastAddrBuffer, int cb)
+{
+	if ((szLastAddrBuffer != NULL) && (cb > 0))
+	{
+		strncpy(szLastAddrBuffer, gszLastDestAddress, cb-1);
+		szLastAddrBuffer[cb-1] = 0;
+		gbLastAddressValid = 0;
+	}
+}
+
+void FAR PASCAL ClearLastDestAddressBuffer()
+{
+	gbLastAddressValid = 0;
+	gszLastDestAddress[0] = 0;
+}
+#endif /* TESTING */
diff --git a/private/tapi/dev/sp/hmtsp/hmtsp.def b/private/tapi/dev/sp/hmtsp/hmtsp.def
new file mode 100644
index 000000000..b77e8f8ad
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/hmtsp.def
@@ -0,0 +1,36 @@
+LIBRARY         HMTSP32
+CODE            MOVEABLE DISCARDABLE 
+DATA            PRELOAD MOVEABLE 
+    
+SEGMENTS    
+            "_TEXT" PRELOAD
+
+EXPORTS 
+	WEP
+
+	TSPI_providerInstall                    @592
+	TSPI_providerRemove                	@593
+	TSPI_providerConfig                	@590
+	TSPI_lineNegotiateTSPIVersion      	@537
+	TSPI_providerInit			@591
+	TSPI_providerShutdown			@594
+	TSPI_lineClose                     	@504
+	TSPI_lineCloseCall                 	@505
+	TSPI_lineConditionalMediaDetection      @508
+	TSPI_lineConfigDialog              	@509
+	TSPI_lineDrop                      	@513
+	TSPI_lineGetAddressCaps            	@518
+	TSPI_lineGetAddressID              	@519
+	TSPI_lineGetAddressStatus          	@520
+	TSPI_lineGetCallAddressID       	@521
+	TSPI_lineGetCallInfo               	@522
+	TSPI_lineGetCallStatus             	@523
+	TSPI_lineGetDevCaps                	@524
+	TSPI_lineGetID                     	@528
+	TSPI_lineGetLineDevStatus          	@529
+	TSPI_lineGetNumAddressIDs          	@530
+	TSPI_lineMakeCall                  	@532
+	TSPI_lineOpen                      	@538
+	TSPI_lineSetAppSpecific            	@547
+	TSPI_lineSetDefaultMediaDetection  	@549
+	TSPI_lineSetMediaMode              	@552
diff --git a/private/tapi/dev/sp/hmtsp/hmtsp.h b/private/tapi/dev/sp/hmtsp/hmtsp.h
new file mode 100644
index 000000000..94874e0f0
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/hmtsp.h
@@ -0,0 +1,50 @@
+#include <windows.h>
+#include "TSPI.H"
+#include "hmtsprc.h"
+             
+#define ATSP_VERSION 0x00010004
+
+#define SMALLBUFFER 40
+
+typedef struct lineInfo
+{
+	// We have only a single call on a single address on a single line
+	// This structure is constructed in TSPI_Initialize
+  
+	LINEEVENT			lpfnEventProc;				// TAPI event callback function
+	ASYNC_COMPLETION	lpfnCompletion;			// TAPI Completion callback
+
+	DWORD					lineID;						// the tapi ID of our line
+	DWORD					dwLineMediaModes;
+	DWORD					dwppID;						// Our permanent provider ID
+	HTAPILINE			htLine;						// TAPI opaque line handle
+	HTAPICALL			htCall;						// TAPI opaque call handle
+
+	DWORD					callState;					// The state of this call
+//	DWORD					dwRequestID;				// for async requests
+	DWORD					dwMediaMode;
+	DWORD					dwAppSpecific;
+
+	int					hcd;							// the associated COM device
+	char					port[SMALLBUFFER];		// "COM1"
+	char					linename[SMALLBUFFER];	// "My Phone"
+	char					lineaddr[SMALLBUFFER];	// "555-1212"
+
+	char					DestAddress[TAPIMAXDESTADDRESSSIZE];
+
+} ATSPLineData;
+
+
+// Debug Message Macro
+
+#ifdef DEBUG
+#include <stdarg.h>
+#include <stdio.h> 
+void CDECL SPTrace(LPCSTR pszFormat, ...);
+#define DebugMsg(_x_)  SPTrace _x_
+#else
+#define DebugMsg(_x_)
+#endif
+
+
+
diff --git a/private/tapi/dev/sp/hmtsp/hmtsp.rc b/private/tapi/dev/sp/hmtsp/hmtsp.rc
new file mode 100644
index 000000000..860df28b4
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/hmtsp.rc
@@ -0,0 +1,47 @@
+#include <windows.h>
+#include "hmtsprc.h"
+
+IDD_CFGDLG DIALOG DISCARDABLE  20, 15, 177, 95
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "PDI Configuration"
+FONT 8, "MS Sans Serif"
+BEGIN
+    LTEXT           "&Communications Port",ID_STATIC,9,7,70,9,NOT WS_GROUP
+    COMBOBOX        ID_PORT,9,18,90,52,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "&Line Name",ID_STATIC,8,36,100,8
+    EDITTEXT        ID_LINENAME,9,46,90,12,ES_AUTOHSCROLL
+    LTEXT           "Phone &Number",ID_STATIC,8,64,94,9
+    EDITTEXT        ID_LINEADDR,9,73,90,12,ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "OK",IDOK,111,16,56,14
+    PUSHBUTTON      "Cancel",IDCANCEL,111,36,56,14
+END
+
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_PROVIDER_INFO "Microsoft Internal Use Happy Modem Testing Service Provider"
+    ID_MULTIPLE_INST "The selected service provider is already installed in the system and cannot support multiple instances."
+    ID_ATSP_ERROR    "Happy Modem Testing Service Provider Error"
+END
+
+
+/* Version Numbering stuff */
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#define VER_FILEDESCRIPTION_STR     "Happy Modem Testing SP (HMSP)"
+#define VER_INTERNALNAME_STR        "hmtsp"
+#define VER_ORIGINALFILENAME_STR    "HMTSP.TSP"
+#define VER_TYPE                    VFT_DLL
+#define DLL
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/hmtsp/hmtsprc.h b/private/tapi/dev/sp/hmtsp/hmtsprc.h
new file mode 100644
index 000000000..888328e6f
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/hmtsprc.h
@@ -0,0 +1,18 @@
+// dialog IDs
+
+#define ID_PROVIDER_INFO		2
+#define ID_MULTIPLE_INST		3
+#define ID_NO_DRIVER				4
+#define ID_ATSP_ERROR			5
+
+#define IDI_MODEM					10
+
+#define IDD_CFGDLG				101
+
+#define ID_PORT					1000
+#define ID_LINENAME				1002
+#define ID_LINEADDR				1003
+
+#define ID_STATIC					-1
+
+
diff --git a/private/tapi/dev/sp/hmtsp/makefile b/private/tapi/dev/sp/hmtsp/makefile
new file mode 100644
index 000000000..9f6b20824
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/hmtsp/makefile.def b/private/tapi/dev/sp/hmtsp/makefile.def
new file mode 100644
index 000000000..01eb7c309
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/makefile.def
@@ -0,0 +1,64 @@
+##############################################################################
+#
+#   HMTSP Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+DEFENTRY=main
+
+BUILDDLL=1
+DLLENTRY=DllMain
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=hmtsp32
+TARGETS=hmtsp32.TSP
+
+CLEANLIST=*.tsp
+
+SRCDIR=..
+
+L32EXE=hmtsp32.tsp		# Name of exe.
+L32DEF=..\hmtsp.def              # Our def file.
+#L32MAP=hmtsp.map		# Our map file.
+L32LIBS=$(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\comctl32.lib                \
+        $(W32LIBID)\advapi32.lib                \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib
+#        $(ROOT)\dev\tools\c932\lib\rpcndr.lib   \
+#        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib
+#        $(ROOT)\dev\tools\c932\lib\msvcrt.lib
+#        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+
+L32RES=hmtsp.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = hmtsp.obj
+
+
+L32FLAGS=$(L32FLAGS) /PDB:hmtsp.pdb
+
+
+!include $(ROOT)\dev\master.mk
+
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/hmtsp/makefile.old b/private/tapi/dev/sp/hmtsp/makefile.old
new file mode 100644
index 000000000..8baebcc3e
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/makefile.old
@@ -0,0 +1,96 @@
+# Project makefile for ATSP chicago build from 
+# unified code base.
+
+# release build makefile for chicago release
+
+!ifndef TAPIROOT
+TAPIROOT=\telephon\tapi
+!endif
+
+!ifndef TARGETDIR
+TARGETDIR =$(TAPIROOT)
+!endif
+
+!ifdef CHICAGO
+CC      = cl
+RC      = $(TAPIROOT)\bin\rc.exe
+MAKE    = nmake
+FLAGS	= $(FLAGS) /DCHICAGO
+TINC	= /I $(TAPIROOT)\inc /I $(TAPIROOT)\chicoinc
+!else
+CC      = cl
+RC      = rc
+MAKE    = nmake
+TINC	= /I $(TAPIROOT)\inc
+!endif
+
+
+!ifdef DEBUG
+FLAGS   = $(FLAGS) /DDEBUG
+!ifdef DIAGNOSTIC
+FLAGS = $(FLAGS) /DDIAGNOSTIC
+!endif
+!ifdef MSDEBUG
+FLAGS = $(FLAGS) /DMSDEBUG
+!endif
+CFLAGS = /nologo /G2 /W3 /Zi /ALw /Od $(FLAGS) /FR /GD $(TINC)
+APPCFLAGS = /nologo /G2 /W3 /Zi /Zp1 /AL /Od $(FLAGS) /GA $(TINC)
+LFLAGS = /nologo /ONERROR:NOEXE /NOD /CO /NOE /ALIGN:4 /MAP:FULL
+RESFLAGS = /K $(TINC) $(FLAGS)
+!else
+FLAGS   = $(FLAGS) /DNDEBUG
+CFLAGS = /nologo /G3 /W3 /Zp1 /ALw /O1 /Ox $(FLAGS) /GD $(TINC)
+APPCFLAGS = /nologo /G3 /W3 /Zp1 /AL /O1 /Ox $(FLAGS) /GA $(TINC) 
+LFLAGS = /nologo /ONERROR:NOEXE /NOD /NOE /ALIGN:4 /NONULLS /PACKD /PACKF /MAP:FULL
+RESFLAGS = /K $(TINC)
+!endif
+
+!ifdef CHICAGO
+RESFLAGS= $(RESFLAGS) /DCHICAGO
+!endif
+
+LIBS = libw ldllcew toolhelp ver commdlg
+APPLIBS = libw llibcew $(TARGETDIR)\tapi
+
+
+all:    clean release 
+
+clean:  
+	del *.obj 
+	del *.dll 
+	del *.map 
+	del *.sym 
+	del *.cpl
+	del *.res
+	del *.exe
+	del *.lib
+	del *.sbr
+	del *.bsc
+	del *.hlp
+	del *.tsp
+	del *.asm
+	del *.pdb
+	del *.aps
+
+
+release: hmtsp.tsp
+
+
+hmtsp.tsp:: $(@B).obj $(@B).def $(@B).rc
+	echo >NUL @<<$(@B).CRF
+$(@B).obj
+$@
+$(@B).map
+c:\msvc\lib\+
+$(LIBS)
+$(@B).def;
+<<
+	link $(LFLAGS) /NOPACKC @$(@B).CRF
+        $(RC) /D$(MYFLAGS) $(RESFLAGS) $(@B).rc $@
+	implib /nologo /nowep $(@B).LIB $@
+	mapsym $(@B)
+	copy $(@B).tsp $(TARGETDIR)
+	copy $(@B).sym $(TARGETDIR)
+
+
+
\ No newline at end of file
diff --git a/private/tapi/dev/sp/hmtsp/sources b/private/tapi/dev/sp/hmtsp/sources
new file mode 100644
index 000000000..1266682a0
--- /dev/null
+++ b/private/tapi/dev/sp/hmtsp/sources
@@ -0,0 +1,58 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=hmtsp32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=tsp
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\gdi32.lib
+
+C_DEFINES=-DTAPI_NT=1
+
+DLLBASE=0x60000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+DLLDEF=hmtsp.def
+
+USE_CRTDLL=1
+
+SOURCES=hmtsp.c \
+        hmtsp.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/kmddsp/kmddsp.c b/private/tapi/dev/sp/kmddsp/kmddsp.c
new file mode 100644
index 000000000..9eb6d688c
--- /dev/null
+++ b/private/tapi/dev/sp/kmddsp/kmddsp.c
@@ -0,0 +1,4792 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995-1996  Microsoft Corporation
+
+Module Name:
+
+    kmddsp.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    11-Apr-1995
+
+Revision History:
+
+
+
+Notes:
+
+    1. NdisTapi.sys needs to be modified to support IOCTL_DISCONNECT so we
+       don't have to close all the driver handles etc each time we get a
+       providerShutdown request (ideally we ought only have to close handles,
+       etc on a dll process detach).
+
+    2. There's the hack in TSPI_providerInit where tapisrv has to pass in
+       pointer to dwNumLines & dwNumPhones, becuase we determine the # of
+       devs when we send the CONNECT IOCTL
+
+    3. Ndistapi.h is not in sync w/ tapi.h & tspi.h, so make sure to use
+       the definitions in ndistapi.h as appropriate (like LINE_DEV_CAPS
+       instead of LINEDEVCAPS).
+
+    4. A slight perf gain might be realized by caching dev caps info for
+       each line (but can/will it chg on the fly?)
+
+    5. To keep bad 2.0 apps from blowing up if they try to look at version
+       1.4 or 2.0 structure fields we pad the area between the end of the
+       1.0 structure and the variable-length data with 0's.  This is done
+       in GetAddrCaps, GetCallInfo, GetCallStatus, GetDevCaps, &
+       GetLineDevStatus.
+
+    6. Since TAPI 2.0 service providers are required to be 100% unicode,
+       kmddsp munge all incoming unicode strings to ascii before passing
+       them to an underlying driver, and also converts all returned ascii
+       strings (embedded in structures) to unicode.
+
+--*/
+
+
+#include "windows.h"
+#include "winioctl.h"
+#include "stdarg.h"
+#include "stdio.h"
+#define ULONGLONG DWORDLONG
+#include "ntddndis.h"
+#include "ndistapi.h"
+#include "intrface.h"
+
+//
+// Note: the following are defined in both ndistapi.h & tapi.h (or tspi.h)
+//       and cause (more or less non-interesting) build warnings, so we
+//       undefine them after the first #include to do away with this
+//
+
+#undef LAST_LINEMEDIAMODE
+#undef TSPI_MESSAGE_BASE
+#undef LINE_NEWCALL
+#undef LINE_CALLDEVSPECIFIC
+
+#include "tapi.h"
+#include "tspi.h"
+#include "kmddsp.h"
+
+
+#define MYHACK
+
+
+void
+AsyncEventsThread(
+    LPVOID  lpParams
+    );
+
+LONG
+WINAPI
+TranslateDriverResult(
+    ULONG   ulResult
+    );
+
+//BOOL
+//WINAPI
+//_CRT_INIT(
+//    HINSTANCE   hDLL,
+//    DWORD   dwReason,
+//    LPVOID  lpReserved
+//    );
+
+#if DBG
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+DWORD   gdwDebugLevel;
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
+LPVOID
+WINAPI
+DrvAlloc(
+    DWORD   dwSize
+    );
+
+VOID
+WINAPI
+DrvFree(
+    LPVOID  lp
+    );
+
+void
+WINAPI
+ProcessEvent(
+    PNDIS_TAPI_EVENT    pEvent
+    );
+
+LONG
+WINAPI
+PrepareSyncRequest(
+    ULONG               Oid,
+    LPDWORD             lphWidget,
+    DWORD               dwWidgetType,
+    PNDISTAPI_REQUEST  *ppNdisTapiRequest,
+    DWORD               dwDataSize
+    );
+
+LONG
+WINAPI
+PrepareAsyncRequest(
+    ULONG                   Oid,
+    LPDWORD                 lphWidget,
+    DWORD                   dwWidgetType,
+    DWORD                   dwRequestID,
+    PASYNC_REQUEST_WRAPPER *ppAsyncRequestWrapper,
+    DWORD                   dwDataSize
+    );
+
+LONG
+WINAPI
+SyncDriverRequest(
+    DWORD               dwIoControlCode,
+    PNDISTAPI_REQUEST   pNdisTapiRequest
+    );
+
+LONG
+WINAPI
+AsyncDriverRequest(
+    DWORD                   dwIoControlCode,
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper
+    );
+
+
+//
+// Global vars
+//
+
+DWORD               gdwTlsIndex, gdwRequestID;
+HANDLE              ghDriverSync, ghDriverAsync, ghCompletionPort;
+LINEEVENT           gpfnLineEvent;
+ASYNC_COMPLETION    gpfnCompletionProc;
+PASYNC_EVENTS_THREAD_INFO   gpAsyncEventsThreadInfo;
+CRITICAL_SECTION    gInboundCallsCritSec, gRequestIDCritSec;
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+    {
+
+#if DBG
+
+    {
+        HKEY    hKey;
+        DWORD   dwDataSize, dwDataType;
+        TCHAR   szTelephonyKey[] =
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony",
+                szKmddspDebugLevel[] = "KmddspDebugLevel";
+
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            szTelephonyKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hKey
+            );
+
+        dwDataSize = sizeof (DWORD);
+        gdwDebugLevel=0;
+
+        RegQueryValueEx(
+            hKey,
+            szKmddspDebugLevel,
+            0,
+            &dwDataType,
+            (LPBYTE) &gdwDebugLevel,
+            &dwDataSize
+            );
+
+        RegCloseKey (hKey);
+    }
+
+#endif
+
+//        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+//        {
+//            return FALSE;
+//        }
+
+        DBGOUT((4, "DLL_PROCESS_ATTACH"));
+
+
+        //
+        // Get a thread local storage entry
+        //
+
+        if ((gdwTlsIndex = TlsAlloc()) == 0xffffffff)
+        {
+            DBGOUT((1, "TlsAlloc() failed"));
+
+            return FALSE;
+        }
+
+
+        //
+        // Init global sync objects
+        //
+
+        InitializeCriticalSection (&gInboundCallsCritSec);
+        InitializeCriticalSection (&gRequestIDCritSec);
+
+        break;
+    }
+    case DLL_PROCESS_DETACH:
+    {
+        //
+        // Free resources
+        //
+
+        PREQUEST_THREAD_INFO    pRequestThreadInfo;
+
+
+        DBGOUT((4, "DLL_PROCESS_DETACH"));
+
+        if ((pRequestThreadInfo = TlsGetValue (gdwTlsIndex)))
+        {
+            DrvFree (pRequestThreadInfo->pBuf);
+            DrvFree (pRequestThreadInfo);
+        }
+
+        TlsFree (gdwTlsIndex);
+
+        DeleteCriticalSection (&gInboundCallsCritSec);
+        DeleteCriticalSection (&gRequestIDCritSec);
+
+//        _CRT_INIT (hDLL, dwReason, lpReserved);
+
+        break;
+    }
+    case DLL_THREAD_ATTACH:
+    {
+        PREQUEST_THREAD_INFO pRequestThreadInfo;
+
+
+//        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+//        {
+//            DBGOUT((1, "DLL_THREAD_ATTACH, _CRT_INIT failed"));
+//        }
+
+        TlsSetValue (gdwTlsIndex, NULL);
+
+        break;
+    }
+    case DLL_THREAD_DETACH:
+    {
+        //
+        // Free resources
+        //
+
+        PREQUEST_THREAD_INFO    pRequestThreadInfo;
+
+
+        if ((pRequestThreadInfo = TlsGetValue (gdwTlsIndex)))
+        {
+            DrvFree (pRequestThreadInfo->pBuf);
+            DrvFree (pRequestThreadInfo);
+        }
+
+//        _CRT_INIT (hDLL, dwReason, lpReserved);
+
+        break;
+    }
+    } // switch
+
+    return TRUE;
+}
+
+
+#if DBG
+
+#define INSERTVARDATASTRING(a,b,c,d,e,f) InsertVarDataString(a,b,c,d,e,f)
+
+void
+PASCAL
+InsertVarDataString(
+    LPVOID  pStruct,
+    LPDWORD pdwXxxSize,
+    LPVOID  pNewStruct,
+    LPDWORD pdwNewXxxSize,
+    DWORD   dwFixedStructSize,
+    char   *pszFieldName
+    )
+
+#else
+
+#define INSERTVARDATASTRING(a,b,c,d,e,f) InsertVarDataString(a,b,c,d,e)
+
+void
+PASCAL
+InsertVarDataString(
+    LPVOID  pStruct,
+    LPDWORD pdwXxxSize,
+    LPVOID  pNewStruct,
+    LPDWORD pdwNewXxxSize,
+    DWORD   dwFixedStructSize
+    )
+
+#endif
+{
+    DWORD   dwXxxSize, dwTotalSize, dwXxxOffset;
+
+
+    //
+    // If the dwXxxSize field of the old struct is non-zero, then
+    // we need to do a ascii->unicode conversion on it.  Check to
+    // make sure that the size/offset are valid (if not set the
+    // data size/offset in the new struct to 0) and then convert.
+    //
+
+    if ((dwXxxSize = *pdwXxxSize))
+    {
+        dwXxxOffset = *(pdwXxxSize + 1);
+
+//#if DBG
+        dwTotalSize = ((LPVARSTRING) pStruct)->dwTotalSize;
+
+        if (dwXxxSize > (dwTotalSize - dwFixedStructSize) ||
+            dwXxxOffset < dwFixedStructSize ||
+            dwXxxOffset >= dwTotalSize ||
+            (dwXxxSize + dwXxxOffset) > dwTotalSize)
+        {
+            DBGOUT((
+                0,
+                "ERROR! bad %s values, size=x%x, offset=x%x",
+                pszFieldName,
+                dwXxxSize,
+                dwXxxOffset
+                ));
+
+            *pdwNewXxxSize = *(pdwNewXxxSize + 1) = 0;
+            return;
+        }
+//#endif
+
+        MultiByteToWideChar(
+            CP_ACP,
+            MB_PRECOMPOSED,
+            ((LPBYTE) pStruct) + dwXxxOffset,
+            dwXxxSize,
+            (LPWSTR) (((LPBYTE) pNewStruct) +
+                ((LPVARSTRING) pNewStruct)->dwUsedSize),
+            dwXxxSize * sizeof (WCHAR)
+            );
+
+        *pdwNewXxxSize = dwXxxSize * sizeof (WCHAR);
+        *(pdwNewXxxSize + 1) = ((LPVARSTRING) pNewStruct)->dwUsedSize; // offset
+        ((LPVARSTRING) pNewStruct)->dwUsedSize += (dwXxxSize * sizeof (WCHAR));
+    }
+}
+
+
+#if DBG
+
+#define INSERTVARDATA(a,b,c,d,e,f) InsertVarData(a,b,c,d,e,f)
+
+void
+PASCAL
+InsertVarData(
+    LPVOID  pStruct,
+    LPDWORD pdwXxxSize,
+    LPVOID  pNewStruct,
+    LPDWORD pdwNewXxxSize,
+    DWORD   dwFixedStructSize,
+    char   *pszFieldName
+    )
+
+#else
+
+#define INSERTVARDATA(a,b,c,d,e,f) InsertVarData(a,b,c,d,e)
+
+void
+PASCAL
+InsertVarData(
+    LPVOID  pStruct,
+    LPDWORD pdwXxxSize,
+    LPVOID  pNewStruct,
+    LPDWORD pdwNewXxxSize,
+    DWORD   dwFixedStructSize
+    )
+
+#endif
+{
+    DWORD   dwTotalSize, dwXxxSize, dwXxxOffset;
+
+
+    if ((dwXxxSize = *pdwXxxSize))
+    {
+        dwXxxOffset = *(pdwXxxSize + 1);
+
+//#if DBG
+        dwTotalSize = ((LPVARSTRING) pStruct)->dwTotalSize;
+
+        if (dwXxxSize > (dwTotalSize - dwFixedStructSize) ||
+            dwXxxOffset < dwFixedStructSize ||
+            dwXxxOffset >= dwTotalSize ||
+            (dwXxxSize + dwXxxOffset) > dwTotalSize)
+        {
+            DBGOUT((
+                0,
+                "ERROR! bad %s values, size=x%x, offset=x%x",
+                pszFieldName,
+                dwXxxSize,
+                dwXxxOffset
+                ));
+
+            *pdwNewXxxSize = *(pdwNewXxxSize + 1) = 0;
+            return;
+        }
+//#endif
+        CopyMemory(
+            ((LPBYTE) pNewStruct) + ((LPVARSTRING) pNewStruct)->dwUsedSize,
+            ((LPBYTE) pStruct) + dwXxxOffset,
+            dwXxxSize
+            );
+
+        *pdwNewXxxSize = dwXxxSize;
+        *(pdwNewXxxSize + 1) = ((LPVARSTRING) pNewStruct)->dwUsedSize; // offset
+        ((LPVARSTRING) pNewStruct)->dwUsedSize += dwXxxSize;
+    }
+}
+
+
+//
+// TSPI_lineXxx funcs
+//
+
+LONG
+TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    LONG                    lResult;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_ACCEPT,                // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_ACCEPT) + dwSize   // size of drv request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_ACCEPT  pNdisTapiAccept =
+            (PNDIS_TAPI_ACCEPT) pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiAccept->hdCall = (HDRV_CALL) hdCall;
+
+        if ((pNdisTapiAccept->ulUserUserInfoSize = (ULONG) dwSize))
+        {
+            CopyMemory(
+                pNdisTapiAccept->UserUserInfo,
+                lpsUserUserInfo,
+                dwSize
+                );
+        }
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    LONG                    lResult;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_ANSWER,                // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_ANSWER) + dwSize   // size of drv request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_ANSWER  pNdisTapiAnswer =
+            (PNDIS_TAPI_ANSWER) pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiAnswer->hdCall = (HDRV_CALL) hdCall;
+
+        if ((pNdisTapiAnswer->ulUserUserInfoSize = (ULONG) dwSize))
+        {
+            CopyMemory(
+                pNdisTapiAnswer->UserUserInfo,
+                lpsUserUserInfo,
+                dwSize
+                );
+        }
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE    hdLine
+    )
+{
+    LONG               lResult;
+    PDRVLINE           pLine = (PDRVLINE) hdLine;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_CLOSE,             // opcode
+            (LPDWORD) &hdLine,          // target handle
+            HT_HDLINE,                  // target handle type
+            &pNdisTapiRequest,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_CLOSE)     // size of drve req data
+
+            )) == TAPI_SUCCESS)
+    {
+        //
+        // Note that this is a command rather than a request, in that
+        // TAPI considers the line closed regardless of the request result.
+        //
+
+        PNDIS_TAPI_CLOSE    pNdisTapiClose =
+            (PNDIS_TAPI_CLOSE) pNdisTapiRequest->Data;
+
+
+        //
+        // Mark line as invalid so any related events that show up
+        // will be discarded
+        //
+
+        pLine->dwKey = INVALID_KEY;
+
+        pNdisTapiClose->hdLine = (HDRV_LINE) hdLine;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+
+
+        //
+        // Clean up our pLine. Make sure to clean up any calls in the
+        // inbound list that may not have been explicitly closed
+        // (i.e. new calls that showed up after TAPI had already
+        // started closing down this line)
+        //
+
+        EnterCriticalSection (&gInboundCallsCritSec);
+
+        {
+            PDRVCALL    pCall;
+
+
+            while ((pCall = pLine->pInboundCalls))
+            {
+                pLine->pInboundCalls = pCall->pNext;
+
+                DrvFree (pCall);
+            }
+        }
+
+        LeaveCriticalSection (&gInboundCallsCritSec);
+
+        DrvFree (pLine);
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL    hdCall
+    )
+{
+    LONG               lResult;
+    HDRVCALL           hdCallDrop = hdCall;
+    PDRVCALL           pCall = (PDRVCALL) hdCall;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_CLOSE_CALL,            // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            &pNdisTapiRequest,              // ptr to ptr to request buffer
+            sizeof (NDIS_TAPI_CLOSE_CALL)   // size of drve req data
+
+            )) == TAPI_SUCCESS)
+    {
+        //
+        // Note that this is a command rather than a request, in that
+        // TAPI considers the call closed regardless of the request
+        // result.
+        //
+
+        BOOL                    bInboundCall;
+        PNDIS_TAPI_CLOSE_CALL   pNdisTapiCloseCall;
+
+
+        //
+        // Safely determine if call is inbound or outbound, & if the
+        // latter then if necessary wait until the make call request
+        // has completed so we don't send a bad hdCall down to the
+        // driver with the close call request.
+        //
+        // We'll just return 0 if the call is bad or we AV (meaning
+        // a make call request failed & call struct was freed in post
+        // processing).
+        //
+
+        try
+        {
+            bInboundCall = (pCall->dwKey == INBOUND_CALL_KEY ? TRUE : FALSE);
+
+            if (bInboundCall == FALSE)
+            {
+                while (pCall->dwKey == OUTBOUND_CALL_KEY)
+                {
+                    if (pCall->bIncomplete == FALSE)
+                    {
+                        hdCall = (HDRVCALL) pCall->hd_Call;
+                        break;
+                    }
+                    else
+                    {
+                        Sleep (0);
+                    }
+                }
+
+                if (pCall->dwKey != OUTBOUND_CALL_KEY)
+                {
+                    return 0;
+                }
+            }
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            return 0;
+        }
+
+
+        //
+        // HACKHACK: the following is for legacy ndis wan isdn miniports
+        //
+        // Since there's no more "automatic" call dropping in TAPI when
+        // an app has closed the line & there are existing non-IDLE calls,
+        // and legacy NDIS WAN ISDN miniports rely on seeing an OID_TAPI_DROP,
+        // we need to synthesize this behavior if the call has not previously
+        // be dropped.
+        //
+        // Note: we do a sync rather than an async drop here
+        //
+
+        if (pCall->bDropped == FALSE)
+        {
+            HDRVCALL           hdCallClose2 = hdCallDrop;
+            PNDISTAPI_REQUEST  pNdisTapiRequestDrop;
+
+
+            if (PrepareSyncRequest(
+                    OID_TAPI_DROP,              // opcode
+                    (LPDWORD) &hdCallDrop,      // target handle
+                    HT_HDCALL,                  // target handle type
+                    &pNdisTapiRequestDrop,      // ptr to ptr to request buffer
+                    sizeof (NDIS_TAPI_DROP)     // size of driver request data
+
+                    ) == TAPI_SUCCESS)
+            {
+                PNDIS_TAPI_DROP pNdisTapiDrop = (PNDIS_TAPI_DROP)
+                                    pNdisTapiRequestDrop->Data;
+
+
+                //
+                // Mark the call as bad so any events get discarded
+                //
+
+                pCall->dwKey = INVALID_KEY;
+
+                pNdisTapiDrop->hdCall = (HDRV_CALL) hdCallDrop;
+
+                SyncDriverRequest(
+                    (DWORD) IOCTL_NDISTAPI_SET_INFO,
+                    pNdisTapiRequestDrop
+                    );
+            }
+
+            if ((lResult = PrepareSyncRequest(
+                    OID_TAPI_CLOSE_CALL,        // opcode
+                    (LPDWORD) &hdCallClose2,    // target handle
+                    HT_HDCALL,                  // target handle type
+                    &pNdisTapiRequest,          // ptr to ptr to request buffer
+                    sizeof (NDIS_TAPI_CLOSE_CALL)   // size of drve req data
+
+                    )) != TAPI_SUCCESS)
+            {
+                return lResult;
+            }
+        }
+
+
+        //
+        // Mark the call as bad so any events get discarded
+        //
+
+        pCall->dwKey = INVALID_KEY;
+
+
+        //
+        // Set up the params & call the driver
+        //
+
+        pNdisTapiCloseCall = (PNDIS_TAPI_CLOSE_CALL) pNdisTapiRequest->Data;
+
+        pNdisTapiCloseCall->hdCall = (HDRV_CALL) hdCall;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+
+
+        //
+        // Clean up our drv call
+        //
+
+        if (bInboundCall)
+        {
+            PDRVLINE pLine = (PDRVLINE) pCall->pLine;
+
+
+            EnterCriticalSection (&gInboundCallsCritSec);
+
+            if (pCall->pNext)
+            {
+                pCall->pNext->pPrev = pCall->pPrev;
+            }
+
+            if (pCall->pPrev)
+            {
+                pCall->pPrev->pNext = pCall->pNext;
+            }
+            else
+            {
+                pLine->pInboundCalls = pCall->pNext;
+            }
+
+            LeaveCriticalSection (&gInboundCallsCritSec);
+        }
+
+        DrvFree (pCall);
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_CONDITIONAL_MEDIA_DETECTION,   // opcode
+            (LPDWORD) &hdLine,                      // target handle
+            HT_HDLINE,                              // target handle type
+            &pNdisTapiRequest,                      // ptr to ptr to req buffer
+                                                    // size of drv request data
+            sizeof(NDIS_TAPI_CONDITIONAL_MEDIA_DETECTION) +
+                (lpCallParams->dwTotalSize - sizeof(LINE_CALL_PARAMS))
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION
+            pNdisTapiConditionalMediaDetection =
+               (PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION) pNdisTapiRequest->Data;
+
+
+        pNdisTapiConditionalMediaDetection->hdLine = (HDRV_LINE) hdLine;
+        pNdisTapiConditionalMediaDetection->ulMediaModes = (ULONG)
+            dwMediaModes;
+
+        CopyMemory(
+            &pNdisTapiConditionalMediaDetection->LineCallParams,
+            lpCallParams,
+            lpCallParams->dwTotalSize
+            );
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+TSPI_lineDevSpecific_postProcess(
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper,
+    LONG                    lResult,
+    LPDWORD                 callStateMsgParams
+    )
+{
+    if (lResult == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_DEV_SPECIFIC pNdisTapiDevSpecific =(PNDIS_TAPI_DEV_SPECIFIC)
+            pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        CopyMemory(
+            (LPVOID) pAsyncRequestWrapper->dwRequestSpecific,
+            pNdisTapiDevSpecific->Params,
+            pNdisTapiDevSpecific->ulParamsSize
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    LONG                    lResult;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    //
+    // Init the request
+    //
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_DEV_SPECIFIC,          // opcode
+            (LPDWORD) &hdLine,              // target handle
+            HT_HDLINE,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_DEV_SPECIFIC)+ // size of drv request data
+                (dwSize - 1)
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_DEV_SPECIFIC pNdisTapiDevSpecific =(PNDIS_TAPI_DEV_SPECIFIC)
+            pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiDevSpecific->hdLine = (HDRV_LINE) hdLine;
+        pNdisTapiDevSpecific->ulAddressID = (ULONG) dwAddressID;
+
+        if (hdCall)
+        {
+            LONG lResult = 0;
+
+
+            try
+            {
+                 pNdisTapiDevSpecific->hdCall = ((PDRVCALL)(hdCall))->hd_Call;
+            }
+            except (EXCEPTION_EXECUTE_HANDLER)
+                            // we expect some AVs and alignment faults
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+            }
+
+            if (lResult)
+            {
+                DrvFree (pAsyncRequestWrapper);
+                return lResult;
+            }
+        }
+        else
+        {
+            pNdisTapiDevSpecific->hdCall = (HDRV_CALL) NULL;
+        }
+
+        pNdisTapiDevSpecific->ulParamsSize = (ULONG) dwSize;
+
+        CopyMemory (pNdisTapiDevSpecific->Params, lpParams, dwSize);
+
+        pAsyncRequestWrapper->dwRequestSpecific = (DWORD) lpParams;
+        pAsyncRequestWrapper->pfnPostProcess =
+            TSPI_lineDevSpecific_postProcess;
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwLength = lstrlenW (lpszDestAddress) + 1;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_DIAL,                  // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_DIAL) + dwLength   // size of driver request data
+
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_DIAL pNdisTapiDial =
+            (PNDIS_TAPI_DIAL) pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiDial->hdCall = (HDRV_CALL) hdCall;
+        pNdisTapiDial->ulDestAddressSize = (ULONG) dwLength;
+
+
+        //
+        // Note: old miniports expect strings to be ascii
+        //
+
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDestAddress,
+            -1,
+            (LPSTR) pNdisTapiDial->szDestAddress,
+            dwLength,
+            NULL,
+            NULL
+            );
+
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+PASCAL
+TSPI_lineDrop_postProcess(
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper,
+    LONG                    lResult,
+    LPDWORD                 callStateMsgParams
+    )
+{
+    PDRVCALL    pCall = (PDRVCALL) pAsyncRequestWrapper->dwRequestSpecific;
+    HTAPICALL   htCall;
+    HTAPILINE   htLine;
+
+
+    //
+    // HACK ALERT!!!
+    //
+    // Some old-style miniports, notably pcimac, don't indicate IDLE msgs
+    // when they get a drop request- so we synthesize this for them.
+    //
+
+    if (lResult == TAPI_SUCCESS)
+    {
+        try
+        {
+            htCall = pCall->htCall;
+            htLine = ((PDRVLINE) pCall->pLine)->htLine;
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            return lResult;
+        }
+
+        (*gpfnLineEvent)(
+            htLine,
+            htCall,
+            LINE_CALLSTATE,
+            LINECALLSTATE_IDLE,
+            0,
+            0
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    LONG                    lResult;
+    PDRVCALL                pCall = (PDRVCALL) hdCall;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_DROP,                  // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_DROP) + dwSize // size of driver request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_DROP pNdisTapiDrop =
+            (PNDIS_TAPI_DROP) pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        //
+        // HACKHACK: the following is for legacy ndis wan isdn miniports
+        //
+        // Safely mark the call as dropped so the CloseCall code won't follow
+        // up with another "automatic" drop
+        //
+
+        try
+        {
+            pCall->bDropped = TRUE;
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            lResult = LINEERR_INVALCALLHANDLE;
+        }
+
+        if (lResult == 0)
+        {
+            pNdisTapiDrop->hdCall = (HDRV_CALL) hdCall;
+
+            if ((pNdisTapiDrop->ulUserUserInfoSize = (ULONG) dwSize))
+            {
+                CopyMemory(
+                    pNdisTapiDrop->UserUserInfo,
+                    lpsUserUserInfo,
+                    dwSize
+                    );
+            }
+
+            pAsyncRequestWrapper->dwRequestSpecific = (DWORD) pCall;
+            pAsyncRequestWrapper->pfnPostProcess = TSPI_lineDrop_postProcess;
+
+            lResult = AsyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_SET_INFO,
+                pAsyncRequestWrapper
+                );
+        }
+        else
+        {
+            DrvFree (pAsyncRequestWrapper);
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD              dwDeviceID,
+    DWORD              dwAddressID,
+    DWORD              dwTSPIVersion,
+    DWORD              dwExtVersion,
+    LPLINEADDRESSCAPS  lpAddressCaps
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_ADDRESS_CAPS,          // opcode
+            &dwDeviceID,                        // target handle
+            HT_DEVICEID,                        // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_ADDRESS_CAPS) +    // size of drv request data
+                (lpAddressCaps->dwTotalSize - sizeof(LINE_ADDRESS_CAPS))
+
+            )) == TAPI_SUCCESS)
+    {
+        PLINE_ADDRESS_CAPS          pCaps;
+        PNDIS_TAPI_GET_ADDRESS_CAPS pNdisTapiGetAddressCaps =
+            (PNDIS_TAPI_GET_ADDRESS_CAPS) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetAddressCaps->ulDeviceID   = (ULONG) dwDeviceID;
+        pNdisTapiGetAddressCaps->ulAddressID  = (ULONG) dwAddressID;
+        pNdisTapiGetAddressCaps->ulExtVersion = (ULONG) dwExtVersion;
+
+        pCaps = &pNdisTapiGetAddressCaps->LineAddressCaps;
+
+        pCaps->ulTotalSize  = lpAddressCaps->dwTotalSize;
+        pCaps->ulNeededSize =
+        pCaps->ulUsedSize   = sizeof (LINE_ADDRESS_CAPS);
+
+        ZeroMemory(
+            &pCaps->ulLineDeviceID,
+            sizeof (LINE_ADDRESS_CAPS) - 3 * sizeof (ULONG)
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            //
+            // Do some post processing to the returned data structure
+            // before passing it back to tapi:
+            // 1. Pad the area between the fixed 1.0 structure and the
+            //    var data that the miniports pass back with 0's so a
+            //    bad app that disregards the 1.0 version negotiation &
+            //    references new 1.4 or 2.0 structure fields won't blow up
+            // 2. Convert ascii strings to unicode, & rebase all var data
+            //
+
+            //
+            // The real needed size is the sum of that requested by the
+            // underlying driver, plus padding for the new TAPI 1.4/2.0
+            // structure fields, plus the size of the var data returned
+            // by the driver to account for the ascii->unicode conversion.
+            // (Granted, we are very liberal in computing the value for
+            // this last part, but at least this way it's fast & we'll
+            // never have too little buffer space.
+            //
+
+            lpAddressCaps->dwNeededSize =
+                pCaps->ulNeededSize +
+                (sizeof (LINEADDRESSCAPS) -         // v2.0 struct
+                    sizeof (LINE_ADDRESS_CAPS)) +   // v1.0 struct
+                (pCaps->ulNeededSize - sizeof (LINE_ADDRESS_CAPS));
+
+
+            //
+            // Copy over the fixed fields that don't need changing, i.e.
+            // everything from dwAddressSharing to dwCallCompletionModes
+            //
+
+            lpAddressCaps->dwLineDeviceID = dwDeviceID;
+
+            CopyMemory(
+                &lpAddressCaps->dwAddressSharing,
+                &pCaps->ulAddressSharing,
+                sizeof (LINE_ADDRESS_CAPS) - (12 * sizeof (DWORD))
+                );
+
+            if (lpAddressCaps->dwNeededSize > lpAddressCaps->dwTotalSize)
+            {
+                lpAddressCaps->dwUsedSize =
+                    (lpAddressCaps->dwTotalSize < sizeof (LINEADDRESSCAPS) ?
+                    lpAddressCaps->dwTotalSize : sizeof (LINEADDRESSCAPS));
+            }
+            else
+            {
+                lpAddressCaps->dwUsedSize = sizeof (LINEADDRESSCAPS);
+                                                                // v2.0 struct
+                INSERTVARDATASTRING(
+                    pCaps,
+                    &pCaps->ulAddressSize,
+                    lpAddressCaps,
+                    &lpAddressCaps->dwAddressSize,
+                    sizeof (LINE_ADDRESS_CAPS),
+                    "LINE_ADDRESS_CAPS.Address"
+                    );
+
+                INSERTVARDATA(
+                    pCaps,
+                    &pCaps->ulDevSpecificSize,
+                    lpAddressCaps,
+                    &lpAddressCaps->dwDevSpecificSize,
+                    sizeof (LINE_ADDRESS_CAPS),
+                    "LINE_ADDRESS_CAPS.DevSpecific"
+                    );
+
+                if (pCaps->ulCompletionMsgTextSize != 0)
+                {
+// BUGBUG TSPI_lineGetAddressCaps: convert ComplMsgText to unicode???
+
+                    INSERTVARDATA(
+                        pCaps,
+                        &pCaps->ulCompletionMsgTextSize,
+                        lpAddressCaps,
+                        &lpAddressCaps->dwCompletionMsgTextSize,
+                        sizeof (LINE_ADDRESS_CAPS),
+                        "LINE_ADDRESS_CAPS.CompletionMsgText"
+                        );
+
+                    lpAddressCaps->dwNumCompletionMessages =
+                        pCaps->ulNumCompletionMessages;
+                    lpAddressCaps->dwCompletionMsgTextEntrySize =
+                        pCaps->ulCompletionMsgTextEntrySize;
+                }
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwAddressID,
+    DWORD       dwAddressMode,
+    LPCWSTR     lpsAddress,
+    DWORD       dwSize
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+// BUGBUG unicode
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_ADDRESS_ID,            // opcode
+            (LPDWORD) &hdLine,                  // target handle
+            HT_HDLINE,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_ADDRESS_ID) +  // size of drv request data
+                dwSize/2 - 1
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_GET_ADDRESS_ID   pNdisTapiGetAddressID =
+            (PNDIS_TAPI_GET_ADDRESS_ID) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetAddressID->hdLine = (HDRV_LINE) hdLine;
+        pNdisTapiGetAddressID->ulAddressMode = (ULONG) dwAddressMode;
+        pNdisTapiGetAddressID->ulAddressSize = (ULONG) dwSize/2;
+
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpsAddress,
+            dwSize,
+            (LPSTR) pNdisTapiGetAddressID->szAddress,
+            dwSize/2,
+            NULL,
+            NULL
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            *lpdwAddressID = pNdisTapiGetAddressID->ulAddressID;
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_ADDRESS_STATUS,        // opcode
+            (LPDWORD) &hdLine,                  // target handle
+            HT_HDLINE,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_ADDRESS_STATUS) +  // size of drv request data
+                (lpAddressStatus->dwTotalSize - sizeof(LINE_ADDRESS_STATUS))
+
+            )) == TAPI_SUCCESS)
+    {
+        PLINE_ADDRESS_STATUS            pStatus;
+        PNDIS_TAPI_GET_ADDRESS_STATUS   pNdisTapiGetAddressStatus =
+            (PNDIS_TAPI_GET_ADDRESS_STATUS) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetAddressStatus->hdLine      = (HDRV_LINE) hdLine;
+        pNdisTapiGetAddressStatus->ulAddressID = (ULONG) dwAddressID;
+
+        pStatus = &pNdisTapiGetAddressStatus->LineAddressStatus;
+
+        pStatus->ulTotalSize  = (ULONG) lpAddressStatus->dwTotalSize;
+        pStatus->ulNeededSize =
+        pStatus->ulUsedSize   = sizeof (LINE_ADDRESS_STATUS);
+
+        ZeroMemory(
+            &pStatus->ulNumInUse,
+            sizeof (LINE_ADDRESS_STATUS) - 3 * sizeof (ULONG)
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            CopyMemory(
+                lpAddressStatus,
+                &pNdisTapiGetAddressStatus->LineAddressStatus,
+                pNdisTapiGetAddressStatus->LineAddressStatus.ulUsedSize
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL    hdCall,
+    LPDWORD     lpdwAddressID
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_CALL_ADDRESS_ID,       // opcode
+            (LPDWORD) &hdCall,                  // target handle
+            HT_HDCALL,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_CALL_ADDRESS_ID)   // size of drv request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_GET_CALL_ADDRESS_ID  pNdisTapiGetCallAddressID =
+            (PNDIS_TAPI_GET_CALL_ADDRESS_ID) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetCallAddressID->hdCall = (HDRV_CALL) hdCall;
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            *lpdwAddressID = (DWORD) pNdisTapiGetCallAddressID->ulAddressID;
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_CALL_INFO,             // opcode
+            (LPDWORD) &hdCall,                  // target handle
+            HT_HDCALL,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_CALL_INFO) +   // size of driver request data
+                (lpCallInfo->dwTotalSize - sizeof(LINE_CALL_INFO))
+
+            )) == TAPI_SUCCESS)
+    {
+        PLINE_CALL_INFO             pInfo;
+        PNDIS_TAPI_GET_CALL_INFO    pNdisTapiGetCallInfo =
+            (PNDIS_TAPI_GET_CALL_INFO) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetCallInfo->hdCall = (HDRV_CALL) hdCall;
+
+        pInfo = &pNdisTapiGetCallInfo->LineCallInfo;
+
+        pInfo->ulTotalSize  = (ULONG) lpCallInfo->dwTotalSize;
+        pInfo->ulNeededSize =
+        pInfo->ulUsedSize   = sizeof (LINE_CALL_INFO);
+
+        ZeroMemory(
+            &pInfo->hLine,
+            sizeof (LINE_CALL_INFO) - 3 * sizeof (ULONG)
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            //
+            // Do some post processing to the returned data structure
+            // before passing it back to tapi:
+            // 1. Pad the area between the fixed 1.0 structure and the
+            //    var data that the miniports pass back with 0's so a
+            //    bad app that disregards the 1.0 version negotiation &
+            //    references new 1.4 or 2.0 structure fields won't blow up
+            // 2. Convert ascii strings to unicode, & rebase all var data
+            //
+
+            //
+            // The real needed size is the sum of that requested by the
+            // underlying driver, plus padding for the new TAPI 1.4/2.0
+            // structure fields, plus the size of the var data returned
+            // by the driver to account for the ascii->unicode conversion.
+            // (Granted, we are very liberal in computing the value for
+            // this last part, but at least this way it's fast & we'll
+            // never have too little buffer space.
+            //
+
+            lpCallInfo->dwNeededSize =
+                pInfo->ulNeededSize +
+                (sizeof (LINECALLINFO) -        // v2.0 struct
+                    sizeof (LINE_CALL_INFO)) +  // v1.0 struct
+                (pInfo->ulNeededSize - sizeof (LINE_CALL_INFO));
+
+
+            //
+            // Copy over the fixed fields that don't need changing,
+            // i.e. everything from dwLineDeviceID to dwTrunk
+            //
+
+            CopyMemory(
+                &lpCallInfo->dwLineDeviceID,
+                &pInfo->ulLineDeviceID,
+                23 * sizeof (DWORD)
+                );
+
+            if (lpCallInfo->dwNeededSize > lpCallInfo->dwTotalSize)
+            {
+                lpCallInfo->dwUsedSize =
+                    (lpCallInfo->dwTotalSize < sizeof (LINECALLINFO) ?
+                    lpCallInfo->dwTotalSize : sizeof (LINECALLINFO));
+            }
+            else
+            {
+                lpCallInfo->dwUsedSize = sizeof (LINECALLINFO); // v2.0 struct
+
+                lpCallInfo->dwCallerIDFlags = pInfo->ulCallerIDFlags;
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulCallerIDSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwCallerIDSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.CallerID"
+                    );
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulCallerIDNameSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwCallerIDNameSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.CallerIDName"
+                    );
+
+                lpCallInfo->dwCalledIDFlags = pInfo->ulCalledIDFlags;
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulCalledIDSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwCalledIDSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.CalledID"
+                    );
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulCalledIDNameSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwCalledIDNameSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.CalledIDName"
+                    );
+
+                lpCallInfo->dwConnectedIDFlags = pInfo->ulConnectedIDFlags;
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulConnectedIDSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwConnectedIDSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.ConnectID"
+                    );
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulConnectedIDNameSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwConnectedIDNameSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.ConnectIDName"
+                    );
+
+                lpCallInfo->dwRedirectionIDFlags = pInfo->ulRedirectionIDFlags;
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulRedirectionIDSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwRedirectionIDSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.RedirectionID"
+                    );
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulRedirectionIDNameSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwRedirectionIDNameSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.RedirectionIDName"
+                    );
+
+                lpCallInfo->dwRedirectingIDFlags = pInfo->ulRedirectingIDFlags;
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulRedirectingIDSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwRedirectingIDSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.RedirectingID"
+                    );
+
+                INSERTVARDATASTRING(
+                    pInfo,
+                    &pInfo->ulRedirectingIDNameSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwRedirectingIDNameSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.RedirectingIDName"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulDisplaySize,
+                    lpCallInfo,
+                    &lpCallInfo->dwDisplaySize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.Display"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulUserUserInfoSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwUserUserInfoSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.UserUserInfo"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulHighLevelCompSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwHighLevelCompSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.HighLevelComp"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulLowLevelCompSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwLowLevelCompSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.LowLevelComp"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulChargingInfoSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwChargingInfoSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.ChargingInfo"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulTerminalModesSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwTerminalModesSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.TerminalModes"
+                    );
+
+                INSERTVARDATA(
+                    pInfo,
+                    &pInfo->ulDevSpecificSize,
+                    lpCallInfo,
+                    &lpCallInfo->dwDevSpecificSize,
+                    sizeof (LINE_CALL_INFO),
+                    "LINE_CALL_INFO.DevSpecific"
+                    );
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_CALL_STATUS,           // opcode
+            (LPDWORD) &hdCall,                  // target handle
+            HT_HDCALL,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_CALL_STATUS) + // size of driver request data
+                (lpCallStatus->dwTotalSize - sizeof(LINE_CALL_STATUS))
+
+            )) == TAPI_SUCCESS)
+    {
+        PLINE_CALL_STATUS           pStatus;
+        PNDIS_TAPI_GET_CALL_STATUS  pNdisTapiGetCallStatus =
+            (PNDIS_TAPI_GET_CALL_STATUS) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetCallStatus->hdCall = (HDRV_CALL) hdCall;
+
+        pStatus = &pNdisTapiGetCallStatus->LineCallStatus;
+
+        pStatus->ulTotalSize  = (ULONG) lpCallStatus->dwTotalSize;
+        pStatus->ulNeededSize =
+        pStatus->ulUsedSize   = sizeof (LINE_CALL_STATUS);
+
+        ZeroMemory(
+            &pStatus->ulCallState,
+            sizeof (LINE_CALL_STATUS) - 3 * sizeof (ULONG)
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            //
+            // Do some post processing to the returned data structure
+            // before passing it back to tapi:
+            // 1. Pad the area between the fixed 1.0 structure and the
+            //    var data that the miniports pass back with 0's so a
+            //    bad app that disregards the 1.0 version negotiation &
+            //    references new 1.4 or 2.0 structure fields won't blow up
+            // (no embedded ascii strings to convert to unicode)
+            //
+
+            //
+            // The real needed size is the sum of that requested by the
+            // underlying driver, plus padding for the new TAPI 1.4/2.0
+            // structure fields. (There are no embedded ascii strings to
+            // convert to unicode, so no extra space needed for that.)
+            //
+
+            lpCallStatus->dwNeededSize =
+                pStatus->ulNeededSize +
+                (sizeof (LINECALLSTATUS) -      // v2.0 struct
+                    sizeof (LINE_CALL_STATUS)); // v1.0 struct
+
+
+            //
+            // Copy over the fixed fields that don't need changing,
+            // i.e. everything from dwLineDeviceID to dwCallCompletionModes
+            //
+
+            CopyMemory(
+                &lpCallStatus->dwCallState,
+                &pStatus->ulCallState,
+                4 * sizeof (DWORD)
+                );
+
+            if (lpCallStatus->dwNeededSize > lpCallStatus->dwTotalSize)
+            {
+                lpCallStatus->dwUsedSize =
+                    (lpCallStatus->dwTotalSize < sizeof (LINECALLSTATUS) ?
+                    lpCallStatus->dwTotalSize : sizeof (LINECALLSTATUS));
+            }
+            else
+            {
+                lpCallStatus->dwUsedSize = sizeof (LINECALLSTATUS);
+                                                                // v2.0 struct
+                INSERTVARDATA(
+                    pStatus,
+                    &pStatus->ulDevSpecificSize,
+                    lpCallStatus,
+                    &lpCallStatus->dwDevSpecificSize,
+                    sizeof (LINE_CALL_STATUS),
+                    "LINE_CALL_STATUS.DevSpecific"
+                    );
+
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_DEV_CAPS,              // opcode
+            &dwDeviceID,                        // target handle
+            HT_DEVICEID,                        // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_DEV_CAPS) +    // size of driver request data
+                (lpLineDevCaps->dwTotalSize - sizeof(LINE_DEV_CAPS))
+
+            )) == TAPI_SUCCESS)
+    {
+        PLINE_DEV_CAPS          pCaps;
+        PNDIS_TAPI_GET_DEV_CAPS pNdisTapiGetDevCaps =
+            (PNDIS_TAPI_GET_DEV_CAPS) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetDevCaps->ulDeviceID   = (ULONG) dwDeviceID;
+        pNdisTapiGetDevCaps->ulExtVersion = (ULONG) dwExtVersion;
+
+        pCaps = &pNdisTapiGetDevCaps->LineDevCaps;
+
+        pCaps->ulTotalSize  = (ULONG) lpLineDevCaps->dwTotalSize;
+        pCaps->ulNeededSize =
+        pCaps->ulUsedSize   = sizeof (LINE_DEV_CAPS);
+
+        ZeroMemory(
+            &pCaps->ulProviderInfoSize,
+            sizeof (LINE_DEV_CAPS) - 3 * sizeof (ULONG)
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            //
+            // Do some post processing to the returned data structure
+            // before passing it back to tapi:
+            // 1. Pad the area between the fixed 1.0 structure and the
+            //    var data that the miniports pass back with 0's so a
+            //    bad app that disregards the 1.0 version negotiation &
+            //    references new 1.4 or 2.0 structure fields won't blow up
+            // 2. Convert ascii strings to unicode, & rebase all var data
+            //
+
+            //
+            // The real needed size is the sum of that requested by the
+            // underlying driver, plus padding for the new TAPI 1.4/2.0
+            // structure fields, plus the size of the var data returned
+            // by the driver to account for the ascii->unicode conversion.
+            // (Granted, we are very liberal in computing the value for
+            // this last part, but at least this way it's fast & we'll
+            // never have too little buffer space.
+            //
+
+            lpLineDevCaps->dwNeededSize =
+                pCaps->ulNeededSize +
+                (sizeof (LINEDEVCAPS) -         // v2.0 struct
+                    sizeof (LINE_DEV_CAPS)) +   // v1.0 struct
+                (pCaps->ulNeededSize - sizeof (LINE_DEV_CAPS));
+
+
+            //
+            // Copy over the fixed fields that don't need changing,
+            // i.e. everything from dwPermanentLineID to dwNumTerminals
+            //
+
+            CopyMemory(
+                &lpLineDevCaps->dwPermanentLineID,
+                &pCaps->ulPermanentLineID,
+                sizeof (LINE_DEV_CAPS) - (14 * sizeof (DWORD))
+                );
+
+            if (lpLineDevCaps->dwNeededSize > lpLineDevCaps->dwTotalSize)
+            {
+                lpLineDevCaps->dwUsedSize =
+                    (lpLineDevCaps->dwTotalSize < sizeof (LINEDEVCAPS) ?
+                    lpLineDevCaps->dwTotalSize : sizeof (LINEDEVCAPS));
+
+                lpLineDevCaps->dwLineNameSize   =
+                lpLineDevCaps->dwLineNameOffset = 0;
+            }
+            else
+            {
+                lpLineDevCaps->dwUsedSize = sizeof (LINEDEVCAPS);
+                                                                // v2.0 struct
+
+                INSERTVARDATASTRING(
+                    pCaps,
+                    &pCaps->ulProviderInfoSize,
+                    lpLineDevCaps,
+                    &lpLineDevCaps->dwProviderInfoSize,
+                    sizeof (LINE_DEV_CAPS),
+                    "LINE_DEV_CAPS.ProviderInfo"
+                    );
+
+                INSERTVARDATASTRING(
+                    pCaps,
+                    &pCaps->ulSwitchInfoSize,
+                    lpLineDevCaps,
+                    &lpLineDevCaps->dwSwitchInfoSize,
+                    sizeof (LINE_DEV_CAPS),
+                    "LINE_DEV_CAPS.SwitchInfo"
+                    );
+
+                INSERTVARDATASTRING(
+                    pCaps,
+                    &pCaps->ulLineNameSize,
+                    lpLineDevCaps,
+                    &lpLineDevCaps->dwLineNameSize,
+                    sizeof (LINE_DEV_CAPS),
+                    "LINE_DEV_CAPS.LineName"
+                    );
+
+                INSERTVARDATA(
+                    pCaps,
+                    &pCaps->ulTerminalCapsSize,
+                    lpLineDevCaps,
+                    &lpLineDevCaps->dwTerminalCapsSize,
+                    sizeof (LINE_DEV_CAPS),
+                    "LINE_DEV_CAPS.TerminalCaps"
+                    );
+
+// BUGBUG TSPI_lineGetDevCaps: convert DevCaps.TermText to unicode???
+
+                lpLineDevCaps->dwTerminalTextEntrySize =
+                    pCaps->ulTerminalTextEntrySize;
+
+                INSERTVARDATA(
+                    pCaps,
+                    &pCaps->ulTerminalTextSize,
+                    lpLineDevCaps,
+                    &lpLineDevCaps->dwTerminalTextSize,
+                    sizeof (LINE_DEV_CAPS),
+                    "LINE_DEV_CAPS.TerminalText"
+                    );
+
+                INSERTVARDATA(
+                    pCaps,
+                    &pCaps->ulDevSpecificSize,
+                    lpLineDevCaps,
+                    &lpLineDevCaps->dwDevSpecificSize,
+                    sizeof (LINE_DEV_CAPS),
+                    "LINE_DEV_CAPS.DevSpecific"
+                    );
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD       dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCWSTR     lpszDeviceClass
+    )
+{
+    LONG               lResult;
+    DWORD              dwLength = lstrlenW (lpszDeviceClass) + 1;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_DEV_CONFIG,            // opcode
+            &dwDeviceID,                        // target handle
+            HT_DEVICEID,                        // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_DEV_CONFIG) +  // size of driver request data
+                (lpDeviceConfig->dwTotalSize - sizeof(VAR_STRING)) + dwLength
+
+            )) == TAPI_SUCCESS)
+    {
+        PVAR_STRING                 pConfig;
+        PNDIS_TAPI_GET_DEV_CONFIG   pNdisTapiGetDevConfig =
+            (PNDIS_TAPI_GET_DEV_CONFIG) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetDevConfig->ulDeviceID          = (ULONG) dwDeviceID;
+        pNdisTapiGetDevConfig->ulDeviceClassSize   = (ULONG) dwLength;
+        pNdisTapiGetDevConfig->ulDeviceClassOffset = (ULONG)
+            sizeof(NDIS_TAPI_GET_DEV_CONFIG) +
+                (lpDeviceConfig->dwTotalSize - sizeof(VAR_STRING));
+
+        pConfig = &pNdisTapiGetDevConfig->DeviceConfig;
+
+        pConfig->ulTotalSize    = (ULONG) lpDeviceConfig->dwTotalSize;
+        pConfig->ulNeededSize   =
+        pConfig->ulUsedSize     = sizeof (VAR_STRING);
+        pConfig->ulStringFormat =
+        pConfig->ulStringSize   =
+        pConfig->ulStringOffset = 0;
+
+
+        //
+        // Note: old miniports expect strings to be ascii
+        //
+
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDeviceClass,
+            -1,
+            (LPSTR) (((LPBYTE) pNdisTapiGetDevConfig) +
+                pNdisTapiGetDevConfig->ulDeviceClassOffset),
+            dwLength,
+            NULL,
+            NULL
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            CopyMemory(
+                lpDeviceConfig,
+                &pNdisTapiGetDevConfig->DeviceConfig,
+                pNdisTapiGetDevConfig->DeviceConfig.ulUsedSize
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_EXTENSION_ID,          // opcode
+            &dwDeviceID,                        // target handle
+            HT_DEVICEID,                        // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_EXTENSION_ID)  // size of driver request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_GET_EXTENSION_ID pNdisTapiGetExtensionID =
+            (PNDIS_TAPI_GET_EXTENSION_ID) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetExtensionID->ulDeviceID = (ULONG) dwDeviceID;
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            CopyMemory(
+                lpExtensionID,
+                &pNdisTapiGetExtensionID->LineExtensionID,
+                sizeof(LINE_EXTENSION_ID)
+                );
+        }
+        else
+        {
+            //
+            // Rather than indicating a failure, we'll just zero out the
+            // ext id (implying driver doesn't support extensions) and
+            // return success to tapisrv so it'll complete the open ok
+            //
+
+            ZeroMemory(
+                lpExtensionID,
+                sizeof(LINE_EXTENSION_ID)
+                );
+
+            lResult = TAPI_SUCCESS;
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE    hdLine,
+    DWORD       dwAddressID,
+    HDRVCALL    hdCall,
+    DWORD       dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+{
+    LONG               lResult;
+    DWORD              dwLength = lstrlenW (lpszDeviceClass) + 1;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_ID,                    // opcode
+            (LPDWORD)(dwSelect == LINECALLSELECT_CALL ? // target handle
+                (LPDWORD) &hdCall : (LPDWORD) &hdLine),
+            (dwSelect == LINECALLSELECT_CALL ?  // target handle type
+                HT_HDCALL : HT_HDLINE),
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_ID) +          // size of driver request data
+                (lpDeviceID->dwTotalSize - sizeof(VAR_STRING)) + dwLength
+
+            )) == TAPI_SUCCESS)
+    {
+        PVAR_STRING         pID;
+        PNDIS_TAPI_GET_ID   pNdisTapiGetID =
+            (PNDIS_TAPI_GET_ID) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetID->hdLine      = (HDRV_LINE) hdLine;
+        pNdisTapiGetID->ulAddressID = (ULONG) dwAddressID;
+        pNdisTapiGetID->hdCall      = (HDRV_CALL) hdCall;
+        pNdisTapiGetID->ulSelect    = (ULONG) dwSelect;
+        pNdisTapiGetID->ulDeviceClassSize   = (ULONG) dwLength;
+        pNdisTapiGetID->ulDeviceClassOffset = (ULONG)
+            sizeof(NDIS_TAPI_GET_ID) +
+                (lpDeviceID->dwTotalSize - sizeof(VAR_STRING));
+
+        pID = &pNdisTapiGetID->DeviceID;
+
+        pID->ulTotalSize    = (ULONG) lpDeviceID->dwTotalSize;
+        pID->ulNeededSize   =
+        pID->ulUsedSize     = sizeof (VAR_STRING);
+        pID->ulStringFormat =
+        pID->ulStringSize   =
+        pID->ulStringOffset = 0;
+
+
+        //
+        // Note: old miniports expect strings to be ascii
+        //
+
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDeviceClass,
+            -1,
+            (LPSTR) (((LPBYTE) pNdisTapiGetID) +
+                pNdisTapiGetID->ulDeviceClassOffset),
+            dwLength,
+            NULL,
+            NULL
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            CopyMemory(
+                lpDeviceID,
+                &pNdisTapiGetID->DeviceID,
+                pNdisTapiGetID->DeviceID.ulUsedSize
+                );
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE        hdLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_GET_LINE_DEV_STATUS,       // opcode
+            (LPDWORD) &hdLine,                  // target handle
+            HT_HDLINE,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_GET_LINE_DEV_STATUS) + // size of drv request data
+                (lpLineDevStatus->dwTotalSize - sizeof(LINE_DEV_STATUS))
+
+            )) == TAPI_SUCCESS)
+    {
+        PLINE_DEV_STATUS                pStatus;
+        PNDIS_TAPI_GET_LINE_DEV_STATUS  pNdisTapiGetLineDevStatus =
+            (PNDIS_TAPI_GET_LINE_DEV_STATUS) pNdisTapiRequest->Data;
+
+
+        pNdisTapiGetLineDevStatus->hdLine = (HDRV_LINE) hdLine;
+
+        pStatus = &pNdisTapiGetLineDevStatus->LineDevStatus;
+
+        pStatus->ulTotalSize  = (ULONG) lpLineDevStatus->dwTotalSize;
+        pStatus->ulNeededSize =
+        pStatus->ulUsedSize   = sizeof (LINE_DEV_STATUS);
+
+        ZeroMemory(
+            &pStatus->ulNumOpens,
+            sizeof (LINE_DEV_STATUS) - 3 * sizeof (ULONG)
+            );
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            //
+            // Do some post processing to the returned data structure
+            // before passing it back to tapi:
+            // 1. Pad the area between the fixed 1.0 structure and the
+            //    var data that the miniports pass back with 0's so a
+            //    bad app that disregards the 1.0 version negotiation &
+            //    references new 1.4 or 2.0 structure fields won't blow up
+            // (no embedded ascii strings to convert to unicode)
+            //
+
+            //
+            // The real needed size is the sum of that requested by the
+            // underlying driver, plus padding for the new TAPI 1.4/2.0
+            // structure fields. (There are no embedded ascii strings to
+            // convert to unicode, so no extra space needed for that.)
+            //
+
+            lpLineDevStatus->dwNeededSize =
+                pStatus->ulNeededSize +
+                (sizeof (LINEDEVSTATUS) -       // v2.0 struct
+                    sizeof (LINE_DEV_STATUS));  // v1.0 struct
+
+
+            //
+            // Copy over the fixed fields that don't need changing,
+            // i.e. everything from dwNumActiveCalls to dwDevStatusFlags
+            //
+
+            CopyMemory(
+                &lpLineDevStatus->dwNumActiveCalls,
+                &pStatus->ulNumActiveCalls,
+                sizeof (LINE_DEV_STATUS) - (9 * sizeof (DWORD))
+                );
+
+            if (lpLineDevStatus->dwNeededSize > lpLineDevStatus->dwTotalSize)
+            {
+                lpLineDevStatus->dwUsedSize =
+                    (lpLineDevStatus->dwTotalSize < sizeof (LINEDEVSTATUS) ?
+                    lpLineDevStatus->dwTotalSize : sizeof (LINEDEVSTATUS));
+            }
+            else
+            {
+                lpLineDevStatus->dwUsedSize = sizeof (LINEDEVSTATUS);
+                                                                // v2.0 struct
+                INSERTVARDATA(
+                    pStatus,
+                    &pStatus->ulTerminalModesSize,
+                    lpLineDevStatus,
+                    &lpLineDevStatus->dwTerminalModesSize,
+                    sizeof (LINE_DEV_STATUS),
+                    "LINE_DEV_STATUS.TerminalModes"
+                    );
+
+                INSERTVARDATA(
+                    pStatus,
+                    &pStatus->ulDevSpecificSize,
+                    lpLineDevStatus,
+                    &lpLineDevStatus->dwDevSpecificSize,
+                    sizeof (LINE_DEV_STATUS),
+                    "LINE_DEV_STATUS.DevSpecific"
+                    );
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwNumAddressIDs
+    )
+{
+    //
+    // Since there isn't an OID_TAPI_GET_NUM_ADDRESS_IDS at this point
+    // we need to synthesize it by getting the dev caps and looking at
+    // the dwNumAddresses field of that structure.  We first do this
+    // with a fixed size (+) structure, then if that doesn't cut it
+    // (i.e. the provider hasn't chg'd the dwNumAddresses field) we
+    // alloc a larger buffer (as per the returned dwNeededSize field)
+    // and try again.  If we get an error along the way we just return
+    // 1 address- kludgy, but say "la vee".
+    //
+    // Note that we use the (P)LINE_DEV_CAPS types from ndistapi.h.
+    //
+
+    BOOL            bTryAgain = TRUE;
+    DWORD           dwTotalSize = sizeof (LINE_DEV_CAPS) + 128;
+    PDRVLINE        pLine = (PDRVLINE) hdLine;
+    PLINE_DEV_CAPS  pLineDevCaps;
+
+
+TSPI_lineGetNumAddressIDs_allocBuffer:
+
+    if ((pLineDevCaps = DrvAlloc (dwTotalSize)))
+    {
+        pLineDevCaps->ulTotalSize  = dwTotalSize;
+        pLineDevCaps->ulNeededSize =
+        pLineDevCaps->ulUsedSize   = sizeof (LINE_DEV_CAPS);
+
+        if (TSPI_lineGetDevCaps(
+                pLine->dwDeviceID,
+                0x10003,
+                0,
+                (LPLINEDEVCAPS) pLineDevCaps
+
+                ) == 0)
+        {
+            DWORD   dwNumAddresses = (DWORD) pLineDevCaps->ulNumAddresses,
+                    dwNeededSize   = (DWORD) pLineDevCaps->ulNeededSize;
+
+
+            DrvFree (pLineDevCaps);
+
+            if (dwNumAddresses != 0)
+            {
+                *lpdwNumAddressIDs = dwNumAddresses;
+
+                return 0;
+            }
+            else if (bTryAgain && (dwNeededSize > dwTotalSize))
+            {
+                dwTotalSize = dwNeededSize;
+
+                bTryAgain = FALSE;
+
+                goto TSPI_lineGetNumAddressIDs_allocBuffer;
+            }
+        }
+        else
+        {
+            DrvFree (pLineDevCaps);
+        }
+    }
+
+    *lpdwNumAddressIDs = 1; // if here an error occured, default to 1 addr
+
+    return 0;
+}
+
+
+LONG
+PASCAL
+TSPI_lineMakeCall_postProcess(
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper,
+    LONG                    lResult,
+    LPDWORD                 callStateMsgParams
+    )
+{
+    PDRVCALL    pCall = (PDRVCALL) pAsyncRequestWrapper->dwRequestSpecific;
+
+
+    if (lResult == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_MAKE_CALL    pNdisTapiMakeCall = (PNDIS_TAPI_MAKE_CALL)
+            pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        //
+        // Check to see if a call state msg was received before we had
+        // the chance to process the completion notification, & if so
+        // fill in the msg params
+        //
+
+        if (pCall->dwPendingCallState)
+        {
+            callStateMsgParams[0] = (DWORD) ((PDRVLINE) pCall->pLine)->htLine;
+            callStateMsgParams[1] = (DWORD) pCall->htCall;
+            callStateMsgParams[2] = pCall->dwPendingCallState;
+            callStateMsgParams[3] = pCall->dwPendingCallStateMode;
+            callStateMsgParams[4] = pCall->dwPendingMediaMode;
+        }
+
+        pCall->hd_Call     = pNdisTapiMakeCall->hdCall;
+        pCall->bIncomplete = FALSE;
+    }
+    else
+    {
+        pCall->dwKey = INVALID_KEY;
+        DrvFree (pCall);
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwLength;
+    PDRVCALL                pCall;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    //
+    // First alloc & init a DRVCALL
+    //
+
+    if (!(pCall = DrvAlloc (sizeof(DRVCALL))))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    pCall->dwKey       = OUTBOUND_CALL_KEY;
+    pCall->dwDeviceID  = ((PDRVLINE) hdLine)->dwDeviceID;
+    pCall->htCall      = htCall;
+    pCall->pLine       = (LPVOID) hdLine;
+    pCall->bIncomplete = TRUE;
+
+
+    //
+    // Init the request
+    //
+
+    dwLength = (lpszDestAddress ? lstrlenW (lpszDestAddress) + 1 : 0);
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_MAKE_CALL,             // opcode
+            (LPDWORD) &hdLine,              // target handle
+            HT_HDLINE,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_MAKE_CALL) +   // size of drv request data
+                dwLength + (lpCallParams ?
+                    (lpCallParams->dwTotalSize - sizeof(LINE_CALL_PARAMS)) : 0)
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_MAKE_CALL    pNdisTapiMakeCall = (PNDIS_TAPI_MAKE_CALL)
+            pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiMakeCall->hdLine = (HDRV_LINE) hdLine;
+        pNdisTapiMakeCall->htCall = (HTAPI_CALL) pCall;
+
+        pNdisTapiMakeCall->ulDestAddressSize = (ULONG) dwLength;
+
+        if (lpszDestAddress)
+        {
+            pNdisTapiMakeCall->ulDestAddressOffset =
+                sizeof(NDIS_TAPI_MAKE_CALL) +
+                    (lpCallParams ? (lpCallParams->dwTotalSize -
+                    sizeof(LINE_CALL_PARAMS)) : 0);
+
+            //
+            // Note: old miniports expect strings to be ascii
+            //
+
+            WideCharToMultiByte(
+                CP_ACP,
+                0,
+                lpszDestAddress,
+                dwLength,
+                (LPSTR) (((LPBYTE) pNdisTapiMakeCall) +
+                    pNdisTapiMakeCall->ulDestAddressOffset),
+                dwLength,
+                NULL,
+                NULL
+                );
+        }
+        else
+        {
+            pNdisTapiMakeCall->ulDestAddressOffset = 0;
+        }
+
+        if (lpCallParams)
+        {
+            pNdisTapiMakeCall->bUseDefaultLineCallParams = FALSE;
+
+            CopyMemory(
+                &pNdisTapiMakeCall->LineCallParams,
+                lpCallParams,
+                lpCallParams->dwTotalSize
+                );
+
+            if (lpCallParams->dwOrigAddressSize != 0)
+            {
+                WideCharToMultiByte(
+                    CP_ACP,
+                    0,
+                    (LPCWSTR) (((LPBYTE) lpCallParams) +
+                        lpCallParams->dwOrigAddressOffset),
+                    lpCallParams->dwOrigAddressSize / sizeof (WCHAR),
+                    (LPSTR) (((LPBYTE) &pNdisTapiMakeCall->LineCallParams) +
+                        lpCallParams->dwOrigAddressOffset),
+                    lpCallParams->dwOrigAddressSize,
+                    NULL,
+                    NULL
+                    );
+
+                pNdisTapiMakeCall->LineCallParams.ulOrigAddressSize /= 2;
+            }
+        }
+        else
+        {
+            pNdisTapiMakeCall->bUseDefaultLineCallParams = TRUE;
+        }
+
+        pAsyncRequestWrapper->dwRequestSpecific = (DWORD) pCall;
+        pAsyncRequestWrapper->pfnPostProcess = TSPI_lineMakeCall_postProcess;
+
+        *lphdCall = (HDRVCALL) pCall;
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_NEGOTIATE_EXT_VERSION,     // opcode
+            (LPDWORD) &dwDeviceID,              // target handle
+            HT_DEVICEID,                        // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_NEGOTIATE_EXT_VERSION) // size of drv req data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_NEGOTIATE_EXT_VERSION    pNdisTapiNegotiateExtVersion =
+            (PNDIS_TAPI_NEGOTIATE_EXT_VERSION) pNdisTapiRequest->Data;
+
+
+        pNdisTapiNegotiateExtVersion->ulDeviceID    = (ULONG) dwDeviceID;
+        pNdisTapiNegotiateExtVersion->ulLowVersion  = (ULONG) dwLowVersion;
+        pNdisTapiNegotiateExtVersion->ulHighVersion = (ULONG) dwHighVersion;
+
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            *lpdwExtVersion = pNdisTapiNegotiateExtVersion->ulExtVersion;
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    *lpdwTSPIVersion = 0x00010003;  // until the ndistapi spec widened
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD       dwDeviceID,
+    HTAPILINE   htLine,
+    LPHDRVLINE  lphdLine,
+    DWORD       dwTSPIVersion,
+    LINEEVENT   lpfnEventProc
+    )
+{
+    LONG               lResult;
+    PDRVLINE           pLine;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+
+    //
+    // First alloc & init a DRVLINE
+    //
+
+    if (!(pLine = DrvAlloc (sizeof(DRVLINE))))
+    {
+        return LINEERR_NOMEM;
+    }
+
+    pLine->dwKey         = LINE_KEY;
+    pLine->dwDeviceID    = dwDeviceID;
+    pLine->htLine        = htLine;
+
+
+    //
+    // Init the request
+    //
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_OPEN,              // opcode
+            (LPDWORD) &dwDeviceID,      // target handle
+            HT_DEVICEID,                // target handle type
+            &pNdisTapiRequest,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_OPEN)      // size of drve req data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_OPEN pNdisTapiOpen =
+            (PNDIS_TAPI_OPEN) pNdisTapiRequest->Data;
+
+
+        pNdisTapiOpen->ulDeviceID = (ULONG) dwDeviceID;
+        pNdisTapiOpen->htLine     = (HTAPI_LINE) pLine;
+
+
+        if ((lResult = SyncDriverRequest(
+                (DWORD) IOCTL_NDISTAPI_QUERY_INFO,
+                pNdisTapiRequest
+
+                )) == TAPI_SUCCESS)
+        {
+            pLine->hd_Line = pNdisTapiOpen->hdLine;
+
+            *lphdLine = (HDRVLINE) pLine;
+        }
+        else
+        {
+            DrvFree (pLine);
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    LONG                    lResult;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_SECURE_CALL,           // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_SECURE_CALL)   // size of drv request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SECURE_CALL pNdisTapiSecureCall =
+            (PNDIS_TAPI_SECURE_CALL)
+                pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiSecureCall->hdCall = (HDRV_CALL) hdCall;
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE    hdLine,
+    DWORD       dwExtVersion
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_SELECT_EXT_VERSION,        // opcode
+            (LPDWORD) &hdLine,                  // target handle
+            HT_HDLINE,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_SELECT_EXT_VERSION)    // size of drve req data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SELECT_EXT_VERSION   pNdisTapiSelectExtVersion =
+            (PNDIS_TAPI_SELECT_EXT_VERSION) pNdisTapiRequest->Data;
+
+
+        pNdisTapiSelectExtVersion->hdLine       = (HDRV_LINE) hdLine;
+        pNdisTapiSelectExtVersion->ulExtVersion = (ULONG) dwExtVersion;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    LONG                    lResult;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_SEND_USER_USER_INFO,   // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_SEND_USER_USER_INFO) + // size of drv request data
+                dwSize
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SEND_USER_USER_INFO pNdisTapiSendUserUserInfo =
+            (PNDIS_TAPI_SEND_USER_USER_INFO)
+                pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiSendUserUserInfo->hdCall = (HDRV_CALL) hdCall;
+
+        if ((pNdisTapiSendUserUserInfo->ulUserUserInfoSize = (ULONG) dwSize))
+        {
+            CopyMemory(
+                pNdisTapiSendUserUserInfo->UserUserInfo,
+                lpsUserUserInfo,
+                dwSize
+                );
+        }
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL    hdCall,
+    DWORD       dwAppSpecific
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_SET_APP_SPECIFIC,          // opcode
+            (LPDWORD) &hdCall,                  // target handle
+            HT_HDCALL,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_SET_APP_SPECIFIC)  // size of driver request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SET_APP_SPECIFIC pNdisTapiSetAppSpecific =
+            (PNDIS_TAPI_SET_APP_SPECIFIC) pNdisTapiRequest->Data;
+
+
+        pNdisTapiSetAppSpecific->hdCall        = (HDRV_CALL) hdCall;
+        pNdisTapiSetAppSpecific->ulAppSpecific = (ULONG) dwAppSpecific;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+    LONG                    lResult;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    if ((lResult = PrepareAsyncRequest(
+            OID_TAPI_SET_CALL_PARAMS,       // opcode
+            (LPDWORD) &hdCall,              // target handle
+            HT_HDCALL,                      // target handle type
+            dwRequestID,                    // request id
+            &pAsyncRequestWrapper,          // ptr to ptr to request buffer
+            sizeof(NDIS_TAPI_SET_CALL_PARAMS)   // size of drv request data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SET_CALL_PARAMS  pNdisTapiSetCallParams =
+            (PNDIS_TAPI_SET_CALL_PARAMS)
+                pAsyncRequestWrapper->NdisTapiRequest.Data;
+
+
+        pNdisTapiSetCallParams->hdCall = (HDRV_CALL) hdCall;
+        pNdisTapiSetCallParams->ulBearerMode = (ULONG) dwBearerMode;
+        pNdisTapiSetCallParams->ulMinRate = (ULONG) dwMinRate;
+        pNdisTapiSetCallParams->ulMaxRate = (ULONG) dwMaxRate;
+
+        if (lpDialParams)
+        {
+            pNdisTapiSetCallParams->bSetLineDialParams = TRUE;
+
+            CopyMemory(
+                &pNdisTapiSetCallParams->LineDialParams,
+                lpDialParams,
+                sizeof(LINE_DIAL_PARAMS)
+                );
+        }
+        else
+        {
+            pNdisTapiSetCallParams->bSetLineDialParams = FALSE;
+        }
+
+        lResult = AsyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pAsyncRequestWrapper
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE    hdLine,
+    DWORD       dwMediaModes
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult =PrepareSyncRequest(
+            OID_TAPI_SET_DEFAULT_MEDIA_DETECTION,   // opcode
+            (LPDWORD) &hdLine,                      // target handle
+            HT_HDLINE,                              // target handle type
+            &pNdisTapiRequest,                      // ptr to ptr to req buffer
+            sizeof(NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION)   // sizeof req data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION
+            pNdisTapiSetDefaultMediaDetection =
+                (PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION)
+                pNdisTapiRequest->Data;
+
+
+        pNdisTapiSetDefaultMediaDetection->hdLine       = (HDRV_LINE) hdLine;
+        pNdisTapiSetDefaultMediaDetection->ulMediaModes = (ULONG) dwMediaModes;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    LONG               lResult;
+    DWORD              dwLength = lstrlenW (lpszDeviceClass) + 1;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult =PrepareSyncRequest(
+            OID_TAPI_SET_DEV_CONFIG,        // opcode
+            &dwDeviceID,                    // target handle
+            HT_DEVICEID,                    // target handle type
+            &pNdisTapiRequest,              // ptr to ptr to req buffer
+            sizeof(NDIS_TAPI_SET_DEV_CONFIG) +  // sizeof req data
+                dwLength + dwSize
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SET_DEV_CONFIG   pNdisTapiSetDevConfig =
+            (PNDIS_TAPI_SET_DEV_CONFIG) pNdisTapiRequest->Data;
+
+
+        pNdisTapiSetDevConfig->ulDeviceID          = (ULONG) dwDeviceID;
+        pNdisTapiSetDevConfig->ulDeviceClassSize   = (ULONG) dwLength;
+        pNdisTapiSetDevConfig->ulDeviceClassOffset =
+            sizeof(NDIS_TAPI_SET_DEV_CONFIG) + dwSize - 1;
+        pNdisTapiSetDevConfig->ulDeviceConfigSize  = dwSize;
+
+        CopyMemory(
+            pNdisTapiSetDevConfig->DeviceConfig,
+            lpDeviceConfig,
+            dwSize
+            );
+
+        //
+        // Note: old miniports expect strings to be ascii
+        //
+
+        WideCharToMultiByte(
+            CP_ACP,
+            0,
+            lpszDeviceClass,
+            -1,
+            (LPSTR) (((LPBYTE) pNdisTapiSetDevConfig) +
+                pNdisTapiSetDevConfig->ulDeviceClassOffset),
+            dwLength,
+            NULL,
+            NULL
+            );
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaMode
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_SET_MEDIA_MODE,            // opcode
+            (LPDWORD) &hdCall,                  // target handle
+            HT_HDCALL,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to req buffer
+            sizeof(NDIS_TAPI_SET_MEDIA_MODE)    // size of drv req data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SET_MEDIA_MODE   pNdisTapiSetMediaMode =
+            (PNDIS_TAPI_SET_MEDIA_MODE) pNdisTapiRequest->Data;
+
+
+        pNdisTapiSetMediaMode->hdCall      = (HDRV_CALL) hdCall;
+        pNdisTapiSetMediaMode->ulMediaMode = (ULONG) dwMediaMode;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE    hdLine,
+    DWORD       dwLineStates,
+    DWORD       dwAddressStates
+    )
+{
+    LONG               lResult;
+    PNDISTAPI_REQUEST  pNdisTapiRequest;
+
+
+    if ((lResult = PrepareSyncRequest(
+            OID_TAPI_SET_STATUS_MESSAGES,       // opcode
+            (LPDWORD) &hdLine,                  // target handle
+            HT_HDLINE,                          // target handle type
+            &pNdisTapiRequest,                  // ptr to ptr to req buffer
+            sizeof(NDIS_TAPI_SET_STATUS_MESSAGES)   // size of drv req data
+
+            )) == TAPI_SUCCESS)
+    {
+        PNDIS_TAPI_SET_STATUS_MESSAGES  pNdisTapiSetStatusMessages =
+            (PNDIS_TAPI_SET_STATUS_MESSAGES) pNdisTapiRequest->Data;
+
+
+        pNdisTapiSetStatusMessages->hdLine          = (HDRV_LINE) hdLine;
+        pNdisTapiSetStatusMessages->ulLineStates    = (ULONG) dwLineStates;
+        pNdisTapiSetStatusMessages->ulAddressStates = (ULONG) dwAddressStates;
+
+        lResult = SyncDriverRequest(
+            (DWORD) IOCTL_NDISTAPI_SET_INFO,
+            pNdisTapiRequest
+            );
+    }
+
+    return lResult;
+}
+
+
+
+//
+// TAPI_providerXxx funcs
+//
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD       dwPermanentProviderID,
+    LPDWORD     lpdwNumLines,
+    LPDWORD     lpdwNumPhones,
+    HPROVIDER   hProvider,
+    LINEEVENT   lpfnLineCreateProc,
+    PHONEEVENT  lpfnPhoneCreateProc
+    )
+{
+    //
+    // Note: We really enum devs in providerInit, see the
+    // special case note there
+    //
+
+    *lpdwNumLines = 0;
+    *lpdwNumPhones = 0;
+
+    gpfnLineEvent = lpfnLineCreateProc;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions
+    )
+{
+    LONG    lResult= LINEERR_OPERATIONFAILED;
+    char    szDeviceName[] = "NDISTAPI";
+    char    szTargetPath[] = "\\Device\\NdisTapi";
+    char    szCompleteDeviceName[] = "\\\\.\\NDISTAPI";
+    DWORD   cbReturned, dwThreadID;
+
+
+    DBGOUT((3, "TSPI_providerInit: enter"));
+
+
+    //
+    // Inform tapisrv that we support multiple simultaneous requests
+    // (the WAN wrapper handles request serialization for miniports)
+    //
+
+    *lpdwTSPIOptions = 0;
+
+
+    //
+    // Create symbolic link to the kernel-mode driver
+    //
+
+    DefineDosDevice (DDD_RAW_TARGET_PATH, szDeviceName, szTargetPath);
+
+
+    //
+    // Open driver
+    //
+
+    if ((ghDriverSync = CreateFileA(
+            szCompleteDeviceName,
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL,                               // no security attrs
+            OPEN_EXISTING,
+            FILE_ATTRIBUTE_NORMAL,
+            NULL                                // no template file
+            )) == INVALID_HANDLE_VALUE)
+    {
+        DBGOUT((
+            0,
+            "CreateFile (%s, non-overlapped) failed, err=%ld",
+            szCompleteDeviceName,
+            GetLastError()
+            ));
+
+        goto providerInit_error0;
+    }
+
+
+    if ((ghDriverAsync = CreateFileA(
+            szCompleteDeviceName,
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL,                               // no security attrs
+            OPEN_EXISTING,
+            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
+            NULL                                // no template file
+            )) == INVALID_HANDLE_VALUE)
+    {
+        DBGOUT((
+            0,
+            "CreateFile (%s, overlapped) failed, err=%ld",
+            szCompleteDeviceName,
+            GetLastError()
+            ));
+
+        goto providerInit_error1;
+    }
+
+
+    //
+    // Create io completion port
+    //
+
+    if ((ghCompletionPort = CreateIoCompletionPort(
+            ghDriverAsync,
+            NULL,
+            0,
+            0
+
+            )) == INVALID_HANDLE_VALUE)
+    {
+        DBGOUT((
+            0,
+            "CreateIoCompletionPort failed, err=%ld",
+            GetLastError()
+            ));
+
+        goto providerInit_error2;
+    }
+
+
+    //
+    // Connect to driver- we send it a device ID base & it returns
+    // the number of devices it supports
+    //
+
+    {
+        DWORD adwConnectInfo[2] = { 1, 1 };
+
+
+        if (!DeviceIoControl(
+                ghDriverSync,
+                (DWORD) IOCTL_NDISTAPI_CONNECT,
+                adwConnectInfo, // BUGBUG
+                2*sizeof(DWORD),
+                &dwLineDeviceIDBase, // BUGBUG
+                sizeof(DWORD),
+                &cbReturned,
+                (LPOVERLAPPED) NULL
+                ) ||
+
+            (cbReturned < sizeof(DWORD)))
+        {
+            DBGOUT((0, "CONNECT failed, err=%ld", GetLastError()));
+
+            goto providerInit_error3;
+        }
+    }
+
+
+    //
+    // Alloc the resources needed by the AsyncEventThread, and then
+    // create the thread
+    //
+
+    if ((gpAsyncEventsThreadInfo = (PASYNC_EVENTS_THREAD_INFO)
+            DrvAlloc (sizeof(ASYNC_EVENTS_THREAD_INFO))) == NULL)
+    {
+        goto providerInit_error4;
+    }
+
+    gpAsyncEventsThreadInfo->dwBufSize = INITIAL_TLS_BUF_SIZE;
+
+    if ((gpAsyncEventsThreadInfo->pBuf1 = (PNDISTAPI_EVENT_DATA)
+            DrvAlloc (INITIAL_TLS_BUF_SIZE)) == NULL)
+    {
+        goto providerInit_error5;
+    }
+
+    if ((gpAsyncEventsThreadInfo->pBuf2 = (PNDISTAPI_EVENT_DATA)
+            DrvAlloc (INITIAL_TLS_BUF_SIZE)) == NULL)
+    {
+        goto providerInit_error6;
+    }
+
+    if ((gpAsyncEventsThreadInfo->hThread = CreateThread(
+            (LPSECURITY_ATTRIBUTES) NULL,   // no security attrs
+            0,                              // default stack size
+            (LPTHREAD_START_ROUTINE)        // func addr
+                AsyncEventsThread,
+            (LPVOID) NULL,                  // thread param
+            0,                              // create flags
+            &dwThreadID                     // thread id
+
+            )) == NULL)
+    {
+        DBGOUT((1, "CreateThread (GetAsyncEventsThread) failed"));
+
+        goto providerInit_error7;
+    }
+
+
+    //
+    //
+    //
+
+    gdwRequestID = 1;
+
+
+    //
+    // !!! Special case for KMDDSP.TSP only !!!
+    //
+    // For KMDDSP.TSP only, TAPISRV.EXE will pass pointers in the
+    // dwNumLines/dwNumPhones variables rather than an actual
+    // number of lines/phones, thereby allowing the driver to tell
+    // TAPISRV.EXE how many devices are currently registered.
+    //
+    // This is really due to a design/interface problem in NDISTAPI.SYS.
+    // Since the current CONNECT IOCTLS expects both a device ID base &
+    // returns the num devs, we can't really do this in
+    // TSPI_providerEnumDevices as the device ID base is unknown
+    // at that point
+    //
+
+    *((LPDWORD)dwNumLines)  = dwLineDeviceIDBase;
+    *((LPDWORD)dwNumPhones) = 0; // BUGBUG until we get OIDs for phones
+
+
+    //
+    // If here success
+    //
+
+    gpfnCompletionProc = lpfnCompletionProc;
+
+    lResult = TAPI_SUCCESS;
+
+    goto providerInit_return;
+
+
+    //
+    // Clean up resources if an error occured & then return
+    //
+
+providerInit_error7:
+
+    DrvFree (gpAsyncEventsThreadInfo->pBuf2);
+
+providerInit_error6:
+
+    DrvFree (gpAsyncEventsThreadInfo->pBuf1);
+
+providerInit_error5:
+
+    DrvFree (gpAsyncEventsThreadInfo);
+
+providerInit_error4:
+providerInit_error3:
+
+    CloseHandle (ghCompletionPort);
+
+providerInit_error2:
+
+    CloseHandle (ghDriverAsync);
+
+providerInit_error1:
+
+    CloseHandle (ghDriverSync);
+
+providerInit_error0:
+
+    DefineDosDevice (DDD_REMOVE_DEFINITION, szDeviceName, NULL);
+
+providerInit_return:
+
+    DBGOUT((3, "TSPI_providerInit: exit, result=x%x", lResult));
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    return TAPI_SUCCESS;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    return TAPI_SUCCESS;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD   dwTSPIVersion,
+    DWORD   dwPermanentProviderID
+    )
+{
+    char    deviceName[] = "NDISTAPI";
+    LONG    lResult = TAPI_SUCCESS;
+    BOOL    bResult;
+    ASYNC_REQUEST_WRAPPER   asyncRequestWrapper;
+
+
+    DBGOUT((3, "TSPI_providerShutdown: enter"));
+
+
+    // BUGBUG all we ought to have to do here is send a DISCONNECT IOCTL
+
+    //
+    // Post an async request that, once completed, will cause the async
+    // request thread to kill itself.  Wait until we're sure the thread
+    // is gone, then clean it's resources.
+    //
+
+    FillMemory (&asyncRequestWrapper, sizeof (ASYNC_REQUEST_WRAPPER), 0);
+
+    asyncRequestWrapper.dwKey       = ASYNCREQWRAPPER_KEY;
+    asyncRequestWrapper.dwRequestID = 0xffffffff;
+
+    bResult = PostQueuedCompletionStatus(
+        ghCompletionPort,
+        sizeof (ASYNC_REQUEST_WRAPPER),
+        0,
+        &asyncRequestWrapper.Overlapped
+        );
+
+    if (bResult== FALSE)
+    {
+        //
+        // Failed to post a completion msg to the async event thread,
+        // so we have to manually nuke the thread.  This is not the
+        // preferred method since resources can be left lying around
+        // (i.e. the thread stack isn't freed).
+        //
+
+        DBGOUT((
+            1,
+            "TSPI_providerShutdown: ERROR- manually terminating " \
+                "AsyncEventsThread, err=%d",
+            GetLastError()
+            ));
+
+        TerminateThread (gpAsyncEventsThreadInfo->hThread, 0);
+    }
+    else
+    {
+        WaitForSingleObject (gpAsyncEventsThreadInfo->hThread, INFINITE);
+    }
+
+    CloseHandle (gpAsyncEventsThreadInfo->hThread);
+    DrvFree (gpAsyncEventsThreadInfo->pBuf2);
+    DrvFree (gpAsyncEventsThreadInfo->pBuf1);
+    DrvFree (gpAsyncEventsThreadInfo);
+
+
+    //
+    // Close the driver & remove the symbolic link
+    //
+
+    CloseHandle (ghCompletionPort);
+    CloseHandle (ghDriverSync);
+    CloseHandle (ghDriverAsync);
+
+    DefineDosDevice (DDD_REMOVE_DEFINITION, deviceName, NULL);
+
+    DBGOUT((3, "TSPI_providerShutdown: exit, lResult=x%x", lResult));
+
+    return lResult;
+}
+
+
+//
+// Private support funcs
+//
+
+void
+AsyncEventsThread(
+    LPVOID  lpParams
+    )
+{
+    BOOL                    bReceivedLineEvents;
+    OVERLAPPED              overlapped;
+    PNDISTAPI_EVENT_DATA    pNewEventsBuf, pCurrentEventsBuf;
+
+
+    DBGOUT((3, "AsyncEventsThread: enter"));
+
+
+    // BUGBUG bufsize ought be based on reg setting for drivers
+
+    //
+    // There are 2 event data buffers so we can be getting new line events
+    // while processing current line events.  Mark the current events buf
+    // (buf2 in this case) as having 0 events the 1st time thru.
+    //
+
+    pNewEventsBuf = gpAsyncEventsThreadInfo->pBuf1;
+
+    gpAsyncEventsThreadInfo->pBuf2->ulUsedSize = 0;
+
+    pCurrentEventsBuf = gpAsyncEventsThreadInfo->pBuf2;
+
+    bReceivedLineEvents = TRUE;
+
+
+    //
+    // Loop waiting for completed requests and retrieving async events
+    //
+
+    while (1)
+    {
+        DWORD               i, cbReturned;
+        LPOVERLAPPED        lpOverlapped;
+        PNDIS_TAPI_EVENT    pEvent;
+
+
+        //
+        // Start an overlapped request to get new events
+        // (while we're processing the current ones)
+        //
+
+        if (bReceivedLineEvents)
+        {
+            //
+            // Don't need events when using completion ports
+            //
+
+            overlapped.hEvent = NULL;
+
+            pNewEventsBuf->ulTotalSize = gpAsyncEventsThreadInfo->dwBufSize -
+                 sizeof(NDISTAPI_EVENT_DATA) + 1;
+
+            pNewEventsBuf->ulUsedSize = 0;
+
+            DBGOUT((4, "AsyncEventsThread: sending GET_LINE_EVENTS"));
+
+            if (DeviceIoControl(
+                    ghDriverAsync,
+                    (DWORD) IOCTL_NDISTAPI_GET_LINE_EVENTS,
+                    pNewEventsBuf,
+                    sizeof(NDISTAPI_EVENT_DATA),
+                    pNewEventsBuf,
+                    gpAsyncEventsThreadInfo->dwBufSize,
+                    &cbReturned,
+                    &overlapped
+
+                    ) == FALSE)
+            {
+            }
+
+
+            //
+            // Handle the current events
+            //
+
+            pEvent = (PNDIS_TAPI_EVENT) pCurrentEventsBuf->Data;
+
+            for(i = 0;
+                i < (pCurrentEventsBuf->ulUsedSize / sizeof(NDIS_TAPI_EVENT));
+                i++
+                )
+            {
+                ProcessEvent (pEvent);
+                pEvent++;
+            }
+        }
+
+
+        //
+        // Wait for a request to complete
+        //
+
+        do
+        {
+            DWORD   dwNumBytesTransferred, dwCompletionKey;
+
+
+            DBGOUT((3, "Calling GetQComplStat"));
+
+            if (GetQueuedCompletionStatus(
+                    ghCompletionPort,
+                    &dwNumBytesTransferred,
+                    &dwCompletionKey,
+                    &lpOverlapped,
+                    (DWORD) -1              // infinite wait
+
+                    ) == FALSE && (lpOverlapped == NULL))
+            {
+                DBGOUT((
+                    1,
+                    "AsyncEventsThread: GetQComplStat failed, err=%d",
+                    GetLastError()
+                    ));
+            }
+
+        } while (lpOverlapped == NULL);
+
+
+        //
+        // Check the returned overlapped struct to determine if
+        // we have some events to process or a completed request
+        //
+
+        if (lpOverlapped == &overlapped)
+        {
+            bReceivedLineEvents = TRUE;
+
+            pNewEventsBuf = pCurrentEventsBuf;
+
+            pCurrentEventsBuf =
+                (pCurrentEventsBuf == gpAsyncEventsThreadInfo->pBuf1 ?
+                gpAsyncEventsThreadInfo->pBuf2 :
+                gpAsyncEventsThreadInfo->pBuf1);
+        }
+        else
+        {
+            LONG    lResult;
+            DWORD   dwRequestID, callStateMsgParams[5];
+            PASYNC_REQUEST_WRAPPER  pAsyncReqWrapper = (PASYNC_REQUEST_WRAPPER)
+                                        lpOverlapped;
+
+
+            bReceivedLineEvents = FALSE;
+
+
+            //
+            // Verify that pointer is valid
+            //
+
+            try
+            {
+                if (pAsyncReqWrapper->dwKey != ASYNCREQWRAPPER_KEY)
+                {
+                    DBGOUT((3,
+                        "AsyncEventsThread: bogus pReq x%x completed!",
+                        pAsyncReqWrapper
+                        ));
+
+                    continue;
+                }
+            }
+            except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+            {
+                DBGOUT((3,
+                    "AsyncEventsThread: bogus pReq x%x completed!",
+                    pAsyncReqWrapper
+                    ));
+
+                continue;
+            }
+
+
+            //
+            //
+            //
+
+            if ((dwRequestID = pAsyncReqWrapper->dwRequestID) == 0xffffffff)
+            {
+                DBGOUT((3, "AsyncEventsThread: exit"));
+
+                ExitThread (0);
+            }
+
+            lResult = TranslateDriverResult(
+                pAsyncReqWrapper->NdisTapiRequest.ulReturnValue
+                );
+
+            DBGOUT((3,
+                "AsyncEventsThread: pReq=x%x completed, reqID=x%x, lResult=x%x",
+                pAsyncReqWrapper,
+                dwRequestID,
+                lResult
+                ));
+
+
+            //
+            // Call the post processing proc if appropriate
+            //
+
+            callStateMsgParams[0] = 0;
+
+            if (pAsyncReqWrapper->pfnPostProcess)
+            {
+                (*pAsyncReqWrapper->pfnPostProcess)(
+                    pAsyncReqWrapper,
+                    lResult,
+                    callStateMsgParams
+                    );
+            }
+
+
+
+            //
+            // Free the async request wrapper
+            //
+
+            DrvFree (pAsyncReqWrapper);
+
+
+            //
+            // Call completion proc
+            //
+
+            (*gpfnCompletionProc)(dwRequestID, lResult);
+
+            if (callStateMsgParams[0])
+            {
+                (*gpfnLineEvent)(
+                    (HTAPILINE) callStateMsgParams[0],
+                    (HTAPICALL) callStateMsgParams[1],
+                    (DWORD) LINE_CALLSTATE,
+                    (DWORD) callStateMsgParams[2],
+                    (DWORD) callStateMsgParams[3],
+                    (DWORD) callStateMsgParams[4]
+                    );
+            }
+        }
+
+    } // while
+}
+
+
+LONG
+WINAPI
+PrepareSyncRequest(
+    ULONG               Oid,
+    LPDWORD             lphWidget,
+    DWORD               dwWidgetType,
+    PNDISTAPI_REQUEST  *ppNdisTapiRequest,
+    DWORD               dwDataSize
+    )
+{
+    LONG                    lResult = 0;
+    PNDISTAPI_REQUEST       pNdisTapiRequest;
+    PREQUEST_THREAD_INFO    pRequestThreadInfo;
+
+
+    //
+    // Retrieve the thread local storage (if there is none then create some)
+    //
+
+    if ((pRequestThreadInfo = TlsGetValue (gdwTlsIndex)) == NULL)
+    {
+        if (!(pRequestThreadInfo = DrvAlloc (sizeof(REQUEST_THREAD_INFO))))
+        {
+            return LINEERR_NOMEM;
+        }
+
+        pRequestThreadInfo->dwBufSize = INITIAL_TLS_BUF_SIZE;
+
+        if (!(pRequestThreadInfo->pBuf = DrvAlloc (INITIAL_TLS_BUF_SIZE)))
+        {
+            return LINEERR_NOMEM;
+        }
+
+        TlsSetValue (gdwTlsIndex, (LPVOID) pRequestThreadInfo);
+    }
+
+
+    //
+    // Check to make sure our driver request buffer is big enough to
+    // hold all the data for this request
+    //
+
+    if (pRequestThreadInfo->dwBufSize < (dwDataSize+sizeof(NDISTAPI_REQUEST)))
+    {
+        PNDISTAPI_REQUEST pTmpDrvReqBuf;
+
+
+        if (!(pTmpDrvReqBuf = DrvAlloc (dwDataSize+sizeof(NDISTAPI_REQUEST))))
+        {
+            return LINEERR_NOMEM;
+        }
+
+        DrvFree (pRequestThreadInfo->pBuf);
+
+        pRequestThreadInfo->pBuf = pTmpDrvReqBuf;
+
+        pRequestThreadInfo->dwBufSize = dwDataSize;
+    }
+
+    pNdisTapiRequest = pRequestThreadInfo->pBuf;
+
+
+    //
+    // Safely initialize thie driver request
+    //
+
+    pNdisTapiRequest->Oid = Oid;
+    pNdisTapiRequest->ulDataSize = (DWORD) dwDataSize;
+
+    try
+    {
+        switch (dwWidgetType)
+        {
+        case HT_HDCALL:
+        {
+            PDRVCALL    pCall = (PDRVCALL)(*lphWidget);
+
+
+            pNdisTapiRequest->ulDeviceID = pCall->dwDeviceID;
+            *lphWidget = pCall->hd_Call;
+
+            if (pCall->dwKey != INBOUND_CALL_KEY &&
+                pCall->dwKey != OUTBOUND_CALL_KEY)
+            {
+                lResult = LINEERR_INVALCALLHANDLE;
+            }
+
+            break;
+        }
+        case HT_HDLINE:
+        {
+            PDRVLINE    pLine = (PDRVLINE)(*lphWidget);
+
+
+            pNdisTapiRequest->ulDeviceID = pLine->dwDeviceID;
+            *lphWidget = pLine->hd_Line;
+
+            if (pLine->dwKey != LINE_KEY)
+            {
+                lResult = LINEERR_INVALLINEHANDLE;
+            }
+
+            break;
+        }
+        case HT_DEVICEID:
+
+            pNdisTapiRequest->ulDeviceID = *((ULONG *) lphWidget);
+            break;
+        }
+    }
+    except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+    {
+        lResult = (dwWidgetType == HT_HDCALL ? LINEERR_INVALCALLHANDLE :
+            LINEERR_INVALLINEHANDLE);
+    }
+
+    // Note: since request buf is tls we don't have to free it on error
+
+    EnterCriticalSection (&gRequestIDCritSec);
+
+    if (( *((ULONG *)pNdisTapiRequest->Data) = ++gdwRequestID) >= 0x7fffffff)
+    {
+        gdwRequestID = 1;
+    }
+
+    LeaveCriticalSection (&gRequestIDCritSec);
+
+    *ppNdisTapiRequest = pNdisTapiRequest;
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+PrepareAsyncRequest(
+    ULONG                   Oid,
+    LPDWORD                 lphWidget,
+    DWORD                   dwWidgetType,
+    DWORD                   dwRequestID,
+    PASYNC_REQUEST_WRAPPER *ppAsyncRequestWrapper,
+    DWORD                   dwDataSize
+    )
+{
+    LONG                    lResult = 0;
+    PNDISTAPI_REQUEST       pNdisTapiRequest;
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper;
+
+
+    //
+    // Alloc & init an async request wrapper
+    //
+
+    if (!(pAsyncRequestWrapper = DrvAlloc(
+            dwDataSize + sizeof(ASYNC_REQUEST_WRAPPER)
+            )))
+    {
+        return LINEERR_NOMEM;
+    }
+
+
+    //
+    // Don't need to create an event when using completion ports
+    //
+
+    pAsyncRequestWrapper->Overlapped.hEvent = (HANDLE) NULL;
+
+    pAsyncRequestWrapper->dwKey          = ASYNCREQWRAPPER_KEY;
+    pAsyncRequestWrapper->dwRequestID    = dwRequestID;
+    pAsyncRequestWrapper->pfnPostProcess = (POSTPROCESSPROC) NULL;
+
+
+    //
+    // Safely initialize the driver request
+    //
+
+    pNdisTapiRequest = &(pAsyncRequestWrapper->NdisTapiRequest);
+
+    pNdisTapiRequest->Oid = Oid;
+    pNdisTapiRequest->ulDataSize = (ULONG) dwDataSize;
+
+    try
+    {
+        if (dwWidgetType == HT_HDCALL)
+        {
+            pNdisTapiRequest->ulDeviceID =
+                ((PDRVCALL)(*lphWidget))->dwDeviceID;
+            *lphWidget = ((PDRVCALL)(*lphWidget))->hd_Call;
+        }
+        else // HT_HDLINE
+        {
+            pNdisTapiRequest->ulDeviceID =
+                ((PDRVLINE)(*lphWidget))->dwDeviceID;
+            *lphWidget = ((PDRVLINE)(*lphWidget))->hd_Line;
+        }
+    }
+    except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+    {
+        lResult = (dwWidgetType == HT_HDCALL ? LINEERR_INVALCALLHANDLE :
+            LINEERR_INVALLINEHANDLE);
+    }
+
+    if (lResult == 0)
+    {
+        EnterCriticalSection (&gRequestIDCritSec);
+
+        if (( *((ULONG *)pNdisTapiRequest->Data) = ++gdwRequestID)
+                >= 0x7fffffff)
+        {
+            gdwRequestID = 1;
+        }
+
+        LeaveCriticalSection (&gRequestIDCritSec);
+
+        *ppAsyncRequestWrapper = pAsyncRequestWrapper;
+    }
+    else
+    {
+        DrvFree (pAsyncRequestWrapper);
+    }
+
+    return lResult;
+}
+
+
+#if DBG
+static char *pszOidNames[] =
+{
+    "Accept",
+    "Answer",
+    "Close",
+    "CloseCall",
+    "ConditionalMediaDetection",
+    "ConfigDialog",
+    "DevSpecific",
+    "Dial",
+    "Drop",
+    "GetAddressCaps",
+    "GetAddressID",
+    "GetAddressStatus",
+    "GetCallAddressID",
+    "GetCallInfo",
+    "GetCallStatus",
+    "GetDevCaps",
+    "GetDevConfig",
+    "GetExtensionID",
+    "GetID",
+    "GetLineDevStatus",
+    "MakeCall",
+    "NegotiateExtVersion",
+    "Open",
+    "ProviderInitialize",
+    "ProviderShutdown",
+    "SecureCall",
+    "SelectExtVersion",
+    "SendUserUserInfo",
+    "SetAppSpecific",
+    "StCallParams",
+    "StDefaultMediaDetection",
+    "SetDevConfig",
+    "SetMediaMode",
+    "SetStatusMessages"
+};
+#endif
+
+LONG
+WINAPI
+SyncDriverRequest(
+    DWORD               dwIoControlCode,
+    PNDISTAPI_REQUEST   pNdisTapiRequest
+    )
+{
+    //
+    // This routine makes a non-overlapped request to NdisTapi.sys (so it
+    // doesn't return until the request is completed)
+    //
+
+    BOOL    bResult;
+    DWORD   cbReturned;
+
+
+    DBGOUT((
+        3,
+        "SyncDrvReq: Oid=%s, devID=%d, dataSize=%d, reqID=x%x, p1=x%x",
+        pszOidNames[pNdisTapiRequest->Oid - OID_TAPI_ACCEPT],
+        pNdisTapiRequest->ulDeviceID,
+        pNdisTapiRequest->ulDataSize,
+        *((ULONG *)pNdisTapiRequest->Data),
+        *(((ULONG *)pNdisTapiRequest->Data) + 1)
+        ));
+
+    if (DeviceIoControl(
+            ghDriverSync,
+            dwIoControlCode,
+            pNdisTapiRequest,
+            (DWORD) (sizeof(NDISTAPI_REQUEST) + pNdisTapiRequest->ulDataSize),
+            pNdisTapiRequest,
+            (DWORD) (sizeof(NDISTAPI_REQUEST) + pNdisTapiRequest->ulDataSize),
+            &cbReturned,
+            0
+
+            ) == FALSE)
+    {
+    }
+
+    //
+    // The errors returned by NdisTapi.sys don't match the TAPI LINEERR_'s,
+    // so return the translated value (but preserve the original driver
+    // return val so it's possible to distinguish between
+    // NDISTAPIERR_DEVICEOFFLINE & LINEERR_OPERATIONUNAVAIL, etc.)
+    //
+
+    return (TranslateDriverResult (pNdisTapiRequest->ulReturnValue));
+}
+
+
+LONG
+WINAPI
+AsyncDriverRequest(
+    DWORD                   dwIoControlCode,
+    PASYNC_REQUEST_WRAPPER  pAsyncRequestWrapper
+    )
+{
+    BOOL    bResult;
+    LONG    lResult;
+    DWORD   dwRequestSize, cbReturned, dwLastError;
+
+
+    DBGOUT((
+        3,
+        "AsyncDrvReq: pReq=x%x, Oid=%s, devID=%d, dataSize=%d, reqID=x%x, ddReqID=x%x, p1=x%x",
+        pAsyncRequestWrapper,
+        pszOidNames
+            [pAsyncRequestWrapper->NdisTapiRequest.Oid - OID_TAPI_ACCEPT],
+        pAsyncRequestWrapper->NdisTapiRequest.ulDeviceID,
+        pAsyncRequestWrapper->NdisTapiRequest.ulDataSize,
+        pAsyncRequestWrapper->dwRequestID,
+        *((ULONG *)pAsyncRequestWrapper->NdisTapiRequest.Data),
+        *(((ULONG *)pAsyncRequestWrapper->NdisTapiRequest.Data) + 1)
+        ));
+
+    lResult = (LONG) pAsyncRequestWrapper->dwRequestID;
+
+    dwRequestSize = sizeof(NDISTAPI_REQUEST) +
+        (pAsyncRequestWrapper->NdisTapiRequest.ulDataSize - 1);
+
+    bResult = DeviceIoControl(
+        ghDriverAsync,
+        dwIoControlCode,
+        &pAsyncRequestWrapper->NdisTapiRequest,
+        dwRequestSize,
+        &pAsyncRequestWrapper->NdisTapiRequest,
+        dwRequestSize,
+        &cbReturned,
+        &pAsyncRequestWrapper->Overlapped
+        );
+
+    dwLastError = GetLastError();
+
+    if ((bResult == FALSE) && (dwLastError == ERROR_IO_PENDING))
+    {
+        //
+        // Request is pending, just return (async events thread will
+        // take care of it when it completes)
+        //
+    }
+    else if (bResult == TRUE)
+    {
+        //
+        // Request completed synchronously, so call the completion proc
+        // & clean up
+        //
+
+        (*gpfnCompletionProc)(
+            pAsyncRequestWrapper->dwRequestID,
+            TranslateDriverResult(
+                pAsyncRequestWrapper->NdisTapiRequest.ulReturnValue
+                )
+            );
+
+        DrvFree (pAsyncRequestWrapper);
+    }
+    else
+    {
+        //
+        // Error
+        //
+
+        DBGOUT((1, "AsyncDrvReq: DevIoCtl failed, err=%d", dwLastError));
+    }
+
+    return lResult;
+}
+
+
+BOOL
+WINAPI
+ConvertLineAndCallHandles(
+    HTAPI_LINE *pht_Line,
+    HTAPI_CALL *pht_Call
+    )
+{
+    PDRVCALL    pCall;
+    PDRVLINE    pLine = (PDRVLINE) *pht_Line;
+
+
+    //
+    // Check to see that pLine is 64-bit aligned & has a good key
+    //
+
+    {
+        BOOL    bBadLine;
+
+
+        try
+        {
+            if (!((DWORD) pLine & 0x7) && pLine->dwKey == LINE_KEY)
+            {
+                *pht_Line = (HTAPI_LINE) pLine->htLine;
+                bBadLine = FALSE;
+            }
+            else
+            {
+                bBadLine = TRUE;
+            }
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            bBadLine = TRUE;
+        }
+
+        if (bBadLine)
+        {
+            return FALSE;
+        }
+    }
+
+
+    //
+    // Incoming calls will have a pCall with the high bit set (a value
+    // created by ndistapi), while outgoing calls won't have the high
+    // bit set (since they're real ptrs in app space [the low 2 gig])
+    //
+
+    pCall = (PDRVCALL) *pht_Call;
+
+    if ((DWORD) pCall < 0x80000000)
+    {
+        BOOL    bResult;
+
+
+        try
+        {
+            //
+            // Check that pCall is 64-bit aligned & has a good key
+            //
+
+            if (!((DWORD) pCall & 0x7) &&
+                pCall->dwKey == OUTBOUND_CALL_KEY)
+            {
+                *pht_Call = (HTAPI_CALL) pCall->htCall;
+                bResult = TRUE;
+            }
+            else
+            {
+                bResult = FALSE;
+            }
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            bResult = FALSE;
+        }
+
+        return bResult;
+    }
+
+
+    //
+    // If here it's an inbound call, so we need to walk the list
+    // of inbound pCalls on this line & find the right one
+    //
+
+    {
+        BOOL    bInCriticalSection;
+
+
+        try
+        {
+            HTAPI_CALL  ht_Call;
+
+
+            EnterCriticalSection (&gInboundCallsCritSec);
+
+            bInCriticalSection  = TRUE;
+
+            if ((pCall = pLine->pInboundCalls))
+            {
+                ht_Call = *pht_Call;
+
+                while (pCall && (pCall->ht_Call != ht_Call))
+                {
+                    pCall = pCall->pNext;
+                }
+            }
+
+            LeaveCriticalSection (&gInboundCallsCritSec);
+
+            bInCriticalSection = FALSE;
+
+            *pht_Call = (pCall ? (HTAPI_CALL)pCall->htCall : (HTAPI_CALL)NULL);
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            if (bInCriticalSection)
+            {
+                LeaveCriticalSection (&gInboundCallsCritSec);
+            }
+
+            pCall = NULL;
+        }
+    }
+
+    return (pCall ? TRUE : FALSE);
+}
+
+
+BOOL
+WINAPI
+ConvertLineHandle(
+    HTAPI_LINE *pht_Line
+    )
+{
+    PDRVLINE    pLine = (PDRVLINE) *pht_Line;
+
+
+    //
+    // Check to see that pLine is 64-bit aligned & has a good key
+    //
+
+    try
+    {
+        if (!((DWORD) pLine & 0x7) && pLine->dwKey == LINE_KEY)
+        {
+            *pht_Line = (HTAPI_LINE) pLine->htLine;
+            return TRUE;
+        }
+    }
+    except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+    {
+        // just fall thru
+    }
+
+    DBGOUT((4, "ConvertLineHandle: bad htLine=x%x", *pht_Line));
+
+    return FALSE;
+}
+
+
+LPVOID
+WINAPI
+DrvAlloc(
+    DWORD   dwSize
+    )
+{
+    LPBYTE  p;
+    LPDWORD pAligned;
+
+
+    //
+    // Alloc 16 extra bytes so we can make sure the pointer we pass back
+    // is 64-bit aligned & have space to store the original pointer
+    //
+
+    if ((p = (LPBYTE) LocalAlloc (LPTR, dwSize + 16)))
+    {
+        pAligned = (LPDWORD) (p + 8 - (((DWORD) p) & 0x7));
+        *pAligned = (DWORD) p;
+        pAligned++;
+        pAligned++;
+    }
+    else
+    {
+        // send reinit msg?
+
+        DBGOUT((
+            1,
+            "ServerAlloc: LocalAlloc (x%lx) failed, err=x%lx",
+            dwSize,
+            GetLastError())
+            );
+
+        pAligned = NULL;
+    }
+
+    return ((LPVOID) pAligned);
+}
+
+
+VOID
+WINAPI
+DrvFree(
+    LPVOID  p
+    )
+{
+    LPVOID  pOrig = (LPVOID) *(((LPDWORD) p) - 2);
+
+
+    LocalFree (pOrig);
+}
+
+
+VOID
+WINAPI
+ProcessEvent(
+    PNDIS_TAPI_EVENT    pEvent
+    )
+{
+    ULONG       ulMsg = pEvent->ulMsg;
+    HTAPI_LINE  ht_Line = (HTAPI_LINE) pEvent->htLine;
+
+
+    DBGOUT((
+        4,
+        "ProcessEvent: enter, msg=x%x, pLine=x%x, ht_call=x%x",
+        ulMsg,
+        ht_Line,
+        pEvent->htCall
+        ));
+
+    DBGOUT((
+        4,
+        "ProcessEvent: \tp1=x%x, p2=x%x, p3=x%x",
+        pEvent->ulParam1,
+        pEvent->ulParam2,
+        pEvent->ulParam3
+        ));
+
+    switch (ulMsg)
+    {
+    case LINE_ADDRESSSTATE:
+    case LINE_CLOSE:
+    case LINE_DEVSPECIFIC:
+    case LINE_LINEDEVSTATE:
+
+        if (ConvertLineHandle (&ht_Line))
+        {
+            (*gpfnLineEvent)(
+                (HTAPILINE) ht_Line,
+                (HTAPICALL) NULL,
+                (DWORD) ulMsg,
+                (DWORD) pEvent->ulParam1,
+                (DWORD) pEvent->ulParam2,
+                (DWORD) pEvent->ulParam3
+                );
+        }
+
+        break;
+
+    case LINE_CALLDEVSPECIFIC:
+    case LINE_CALLINFO:
+
+        if (ConvertLineAndCallHandles (&ht_Line, &pEvent->htCall))
+        {
+            (*gpfnLineEvent)(
+                (HTAPILINE) ht_Line,
+                (HTAPICALL) pEvent->htCall,
+                (DWORD) ulMsg,
+                (DWORD) pEvent->ulParam1,
+                (DWORD) pEvent->ulParam2,
+                (DWORD) pEvent->ulParam3
+                );
+        }
+
+        break;
+
+    case LINE_CALLSTATE:
+    {
+        //
+        // For outgoing calls there exists a race condition between
+        // receiving the first call state msg(s) and receiving the
+        // make call completion notification (if we pass a call state
+        // msg on to tapi for a call that hasn't been completed yet
+        // tapi will just discard the msg since the htCall really
+        // isn't valid at that point).  So if htCall references a
+        // valid outgoing call which hasn't completed yet, we'll save
+        // the call state params, and pass them on to tapi after we
+        // get & indicate a (successful) completion notification.
+        //
+        // (Note: incoming calls have high bit turned off)
+        //
+
+        PDRVCALL    pCall = (PDRVCALL) pEvent->htCall;
+
+
+        if ((DWORD) pCall < 0x80000000  &&  !((DWORD) pCall & 0x7))
+        {
+            try
+            {
+                if (pCall->dwKey == OUTBOUND_CALL_KEY &&
+                    pCall->bIncomplete == TRUE)
+                {
+                    pCall->dwPendingCallState     = pEvent->ulParam1;
+                    pCall->dwPendingCallStateMode = pEvent->ulParam2;
+                    pCall->dwPendingMediaMode     = pEvent->ulParam3;
+
+                    break;
+                }
+            }
+            except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+            {
+                break;
+            }
+        }
+
+        if (ConvertLineAndCallHandles (&ht_Line, &pEvent->htCall))
+        {
+            (*gpfnLineEvent)(
+                (HTAPILINE) ht_Line,
+                (HTAPICALL) pEvent->htCall,
+                (DWORD) ulMsg,
+                (DWORD) pEvent->ulParam1,
+                (DWORD) pEvent->ulParam2,
+                (DWORD) pEvent->ulParam3
+                );
+
+
+            //
+            // For old style miniports we want to indicate an IDLE
+            // immediately following the disconnected (several of
+            // the initial NDIS WAN miniports did not indicate an
+            // IDLE call state due to doc confusion)
+            //
+            // BUGBUG make sure we don't do this for new style
+            //        drivers (new style == anything that supports
+            //        OID_TAPI_NEGOTIATE_API_VERSION)
+            //
+
+            if (pEvent->ulParam1 == LINECALLSTATE_DISCONNECTED)
+            {
+                (*gpfnLineEvent)(
+                    (HTAPILINE) ht_Line,
+                    (HTAPICALL) pEvent->htCall,
+                    (DWORD) ulMsg,
+                    (DWORD) LINECALLSTATE_IDLE,
+                    (DWORD) 0,
+                    (DWORD) pEvent->ulParam3
+                    );
+            }
+        }
+
+        break;
+    }
+    case LINE_NEWCALL:
+    {
+        BOOL        bInCriticalSection = FALSE;
+        PDRVCALL    pCall;
+        PDRVLINE    pLine = (PDRVLINE) ht_Line;
+
+
+        if (!(pCall = DrvAlloc (sizeof(DRVCALL))))
+        {
+// BUGBUG LINE_NEWCALL: couldn't alloc drvCall, send drop/dealloc call OIDs
+
+            break;
+        }
+
+        pCall->dwKey   = INBOUND_CALL_KEY;
+        pCall->ht_Call = (HTAPI_CALL) pEvent->ulParam2;
+        pCall->hd_Call = (HDRV_CALL) pEvent->ulParam1;
+        pCall->pLine   = pLine;
+        //pCall->bIncomplete = FALSE; (already 0'd by alloc)
+
+        try
+        {
+            pCall->dwDeviceID = pLine->dwDeviceID;
+
+            EnterCriticalSection (&gInboundCallsCritSec);
+
+            bInCriticalSection = TRUE;
+
+            if (pLine->dwKey == LINE_KEY)
+            {
+                //
+                // Insert new call into inbound calls list
+                //
+
+                if ((pCall->pNext = pLine->pInboundCalls))
+                {
+                    pCall->pNext->pPrev = pCall;
+                }
+
+                pLine->pInboundCalls = pCall;
+            }
+            else
+            {
+                //
+                // Line was closed after this msg was sent, so clean up
+                //
+
+                DrvFree (pCall);
+                pCall = NULL;
+            }
+
+            LeaveCriticalSection (&gInboundCallsCritSec);
+
+            bInCriticalSection = FALSE;
+
+            if (pCall)
+            {
+                (*gpfnLineEvent)(
+                    (HTAPILINE) pLine->htLine,
+                    (HTAPICALL) NULL,
+                    ulMsg,
+                    (DWORD) pCall,
+                    (DWORD) &pCall->htCall,
+                    0
+                    );
+            }
+        }
+        except (EXCEPTION_EXECUTE_HANDLER)
+                    // we expect some AVs and alignment faults
+        {
+            if (bInCriticalSection)
+            {
+                LeaveCriticalSection (&gInboundCallsCritSec);
+            }
+
+            DrvFree (pCall);
+        }
+
+// BUGBUG check if pCall->htCall is NULL (tapi couldn't deal w/ newcall)
+
+        break;
+    }
+    default:
+
+        DBGOUT((2, "ProcessEvent: unknown msg, x%x", ulMsg));
+
+        break;
+
+    } // switch
+}
+
+
+LONG
+WINAPI
+TranslateDriverResult(
+    ULONG   ulResult
+    )
+{
+    typedef struct _RESULT_LOOKUP
+    {
+        ULONG  NdisTapiResult;
+
+        LONG   TapiResult;
+
+    } RESULT_LOOKUP, *PRESULT_LOOKUP;
+
+#ifdef MYHACK
+
+    typedef ULONG NDIS_STATUS;
+
+    #define NDIS_STATUS_SUCCESS   0x00000000L
+    #define NDIS_STATUS_RESOURCES 0xC000009AL
+    #define NDIS_STATUS_FAILURE   0xC0000001L
+
+#endif
+
+    static RESULT_LOOKUP aResults[] =
+    {
+
+    //
+    // Defined in NDIS.H
+    //
+
+    { NDIS_STATUS_SUCCESS                    ,0 },
+
+    //
+    // These errors are defined in NDISTAPI.H
+    //
+
+    { NDIS_STATUS_TAPI_ADDRESSBLOCKED        ,LINEERR_ADDRESSBLOCKED        },
+    { NDIS_STATUS_TAPI_BEARERMODEUNAVAIL     ,LINEERR_BEARERMODEUNAVAIL     },
+    { NDIS_STATUS_TAPI_CALLUNAVAIL           ,LINEERR_CALLUNAVAIL           },
+    { NDIS_STATUS_TAPI_DIALBILLING           ,LINEERR_DIALBILLING           },
+    { NDIS_STATUS_TAPI_DIALDIALTONE          ,LINEERR_DIALDIALTONE          },
+    { NDIS_STATUS_TAPI_DIALPROMPT            ,LINEERR_DIALPROMPT            },
+    { NDIS_STATUS_TAPI_DIALQUIET             ,LINEERR_DIALQUIET             },
+    { NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION,LINEERR_INCOMPATIBLEEXTVERSION},
+    { NDIS_STATUS_TAPI_INUSE                 ,LINEERR_INUSE                 },
+    { NDIS_STATUS_TAPI_INVALADDRESS          ,LINEERR_INVALADDRESS          },
+    { NDIS_STATUS_TAPI_INVALADDRESSID        ,LINEERR_INVALADDRESSID        },
+    { NDIS_STATUS_TAPI_INVALADDRESSMODE      ,LINEERR_INVALADDRESSMODE      },
+    { NDIS_STATUS_TAPI_INVALBEARERMODE       ,LINEERR_INVALBEARERMODE       },
+    { NDIS_STATUS_TAPI_INVALCALLHANDLE       ,LINEERR_INVALCALLHANDLE       },
+    { NDIS_STATUS_TAPI_INVALCALLPARAMS       ,LINEERR_INVALCALLPARAMS       },
+    { NDIS_STATUS_TAPI_INVALCALLSTATE        ,LINEERR_INVALCALLSTATE        },
+    { NDIS_STATUS_TAPI_INVALDEVICECLASS      ,LINEERR_INVALDEVICECLASS      },
+    { NDIS_STATUS_TAPI_INVALLINEHANDLE       ,LINEERR_INVALLINEHANDLE       },
+    { NDIS_STATUS_TAPI_INVALLINESTATE        ,LINEERR_INVALLINESTATE        },
+    { NDIS_STATUS_TAPI_INVALMEDIAMODE        ,LINEERR_INVALMEDIAMODE        },
+    { NDIS_STATUS_TAPI_INVALRATE             ,LINEERR_INVALRATE             },
+    { NDIS_STATUS_TAPI_NODRIVER              ,LINEERR_NODRIVER              },
+    { NDIS_STATUS_TAPI_OPERATIONUNAVAIL      ,LINEERR_OPERATIONUNAVAIL      },
+    { NDIS_STATUS_TAPI_RATEUNAVAIL           ,LINEERR_RATEUNAVAIL           },
+    { NDIS_STATUS_TAPI_RESOURCEUNAVAIL       ,LINEERR_RESOURCEUNAVAIL       },
+    { NDIS_STATUS_TAPI_STRUCTURETOOSMALL     ,LINEERR_STRUCTURETOOSMALL     },
+    { NDIS_STATUS_TAPI_USERUSERINFOTOOBIG    ,LINEERR_USERUSERINFOTOOBIG    },
+    { NDIS_STATUS_TAPI_ALLOCATED             ,LINEERR_ALLOCATED             },
+    { NDIS_STATUS_TAPI_INVALADDRESSSTATE     ,LINEERR_INVALADDRESSSTATE     },
+    { NDIS_STATUS_TAPI_INVALPARAM            ,LINEERR_INVALPARAM            },
+    { NDIS_STATUS_TAPI_NODEVICE              ,LINEERR_NODEVICE              },
+
+    //
+    // These errors are defined in NDIS.H
+    //
+
+    { NDIS_STATUS_RESOURCES                  ,LINEERR_NOMEM },
+    { NDIS_STATUS_FAILURE                    ,LINEERR_OPERATIONFAILED },
+
+    //
+    //
+    //
+
+    { NDISTAPIERR_UNINITIALIZED              ,LINEERR_OPERATIONFAILED },
+    { NDISTAPIERR_BADDEVICEID                ,LINEERR_OPERATIONFAILED },
+    { NDISTAPIERR_DEVICEOFFLINE              ,LINEERR_OPERATIONFAILED },
+
+    //
+    // The terminating fields
+    //
+
+    { 0xffffffff, 0xffffffff }
+
+    };
+
+    int i;
+
+
+    for (i = 0; aResults[i].NdisTapiResult != 0xffffffff; i++)
+    {
+        if (ulResult == aResults[i].NdisTapiResult)
+        {
+            return (aResults[i].TapiResult);
+        }
+    }
+
+    DBGOUT((1, "TranslateDriverResult: unknown driver result x%x", ulResult));
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & callsOutputDebugStringA
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        int     iNumChars;
+        char    buf[192] = "KMDDSP: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        iNumChars = wvsprintfA (&buf[8], lpszFormat, ap);
+
+        buf[iNumChars] = '\n';
+        buf[iNumChars + 1] = 0;
+
+        OutputDebugStringA (buf);
+
+        va_end(ap);
+    }
+}
+#endif
diff --git a/private/tapi/dev/sp/kmddsp/kmddsp.def b/private/tapi/dev/sp/kmddsp/kmddsp.def
new file mode 100644
index 000000000..5c302d179
--- /dev/null
+++ b/private/tapi/dev/sp/kmddsp/kmddsp.def
@@ -0,0 +1,107 @@
+LIBRARY   KMDDSP
+
+DATA      READ WRITE
+
+EXPORTS
+
+        TSPI_lineAccept
+;        TSPI_lineAddToConference
+        TSPI_lineAnswer
+;        TSPI_lineBlindTransfer
+        TSPI_lineClose
+        TSPI_lineCloseCall
+;        TSPI_lineCompleteCall
+;        TSPI_lineCompleteTransfer
+        TSPI_lineConditionalMediaDetection
+        TSPI_lineDevSpecific
+;        TSPI_lineDevSpecificFeature
+        TSPI_lineDial
+        TSPI_lineDrop
+;        TSPI_lineForward
+;        TSPI_lineGatherDigits
+;        TSPI_lineGenerateDigits
+;        TSPI_lineGenerateTone
+        TSPI_lineGetAddressCaps
+        TSPI_lineGetAddressID
+        TSPI_lineGetAddressStatus
+        TSPI_lineGetCallAddressID
+        TSPI_lineGetCallInfo
+        TSPI_lineGetCallStatus
+        TSPI_lineGetDevCaps
+        TSPI_lineGetDevConfig
+        TSPI_lineGetExtensionID
+;        TSPI_lineGetIcon
+        TSPI_lineGetID
+        TSPI_lineGetLineDevStatus
+        TSPI_lineGetNumAddressIDs
+;        TSPI_lineHold
+        TSPI_lineMakeCall
+;        TSPI_lineMonitorDigits
+;        TSPI_lineMonitorMedia
+;        TSPI_lineMonitorTones
+        TSPI_lineNegotiateExtVersion
+        TSPI_lineNegotiateTSPIVersion
+        TSPI_lineOpen
+;        TSPI_linePark
+;        TSPI_linePickup
+;        TSPI_linePrepareAddToConference
+;        TSPI_lineRedirect
+;        TSPI_lineRemoveFromConference
+        TSPI_lineSecureCall
+        TSPI_lineSelectExtVersion
+        TSPI_lineSendUserUserInfo
+        TSPI_lineSetAppSpecific
+        TSPI_lineSetCallParams
+        TSPI_lineSetDefaultMediaDetection
+        TSPI_lineSetDevConfig
+;        TSPI_lineSetMediaControl
+        TSPI_lineSetMediaMode
+        TSPI_lineSetStatusMessages
+;        TSPI_lineSetTerminal
+;        TSPI_lineSetupConference
+;        TSPI_lineSetupTransfer
+;        TSPI_lineSwapHold
+;        TSPI_lineUncompleteCall
+;        TSPI_lineUnhold
+;        TSPI_lineUnpark
+
+;        TSPI_phoneClose
+;        TSPI_phoneDevSpecific
+;        TSPI_phoneGetButtonInfo
+;        TSPI_phoneGetData
+;        TSPI_phoneGetDevCaps
+;        TSPI_phoneGetDisplay
+;        TSPI_phoneGetExtensionID
+;        TSPI_phoneGetGain
+;        TSPI_phoneGetHookSwitch
+;        TSPI_phoneGetIcon
+;        TSPI_phoneGetID
+;        TSPI_phoneGetLamp
+;        TSPI_phoneGetRing
+;        TSPI_phoneGetStatus
+;        TSPI_phoneGetVolume
+;        TSPI_phoneNegotiateExtVersion
+;        TSPI_phoneNegotiateTSPIVersion
+;        TSPI_phoneOpen
+;        TSPI_phoneSelectExtVersion
+;        TSPI_phoneSetButtonInfo
+;        TSPI_phoneSetData
+;        TSPI_phoneSetDisplay
+;        TSPI_phoneSetGain
+;        TSPI_phoneSetHookSwitch
+;        TSPI_phoneSetLamp
+;        TSPI_phoneSetRing
+;        TSPI_phoneSetStatusMessages
+;        TSPI_phoneSetVolume
+
+;        TSPI_providerConfig
+        TSPI_providerInit
+;        TSPI_providerInstall
+;        TSPI_providerRemove
+        TSPI_providerShutdown
+
+        TSPI_providerEnumDevices
+;        TSPI_providerCreateLineDevice
+;        TSPI_providerCreatePhoneDevice
+;        TSPI_lineSetCurrentLocation
+;        TSPI_lineReleaseUserUserInfo
diff --git a/private/tapi/dev/sp/kmddsp/kmddsp.h b/private/tapi/dev/sp/kmddsp/kmddsp.h
new file mode 100644
index 000000000..6f970b8e4
--- /dev/null
+++ b/private/tapi/dev/sp/kmddsp/kmddsp.h
@@ -0,0 +1,152 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    kmddsp.h
+
+Abstract:
+
+    Header file for tapi client module
+
+Author:
+
+    Dan Knudson (DanKn)    11-Apr-1995
+
+Revision History:
+
+--*/
+
+
+#define OUTBOUND_CALL_KEY       ((DWORD) 'OCAL')
+#define INBOUND_CALL_KEY        ((DWORD) 'ICAL')
+#define LINE_KEY                ((DWORD) 'KLIN')
+#define ASYNCREQWRAPPER_KEY     ((DWORD) 'ARWK')
+#define INVALID_KEY             ((DWORD) 'XXXX')
+
+#define HT_HDCALL               1
+#define HT_HDLINE               2
+#define HT_DEVICEID             3
+
+#define TAPI_SUCCESS            0
+#define INITIAL_TLS_BUF_SIZE    1024
+
+
+typedef LONG (*POSTPROCESSPROC)(PASYNC_REQUEST_WRAPPER, LONG, LPDWORD);
+
+
+typedef struct _REQUEST_THREAD_INFO
+{
+    //
+    // Size of following buffer
+    //
+
+    DWORD   dwBufSize;
+
+    //
+    // Pointer to a buffer used for making synchronous kernel-mode
+    // driver requests
+    //
+
+    LPVOID  pBuf;
+
+} REQUEST_THREAD_INFO, *PREQUEST_THREAD_INFO;
+
+
+typedef struct _ASYNC_REQUEST_WRAPPER
+{
+    //
+    // Note: Overlapped must remain 1st field in this struct
+    //
+
+    OVERLAPPED          Overlapped;
+
+    DWORD               dwKey;
+
+    DWORD               dwRequestID;
+
+    DWORD               dwRequestSpecific;
+
+    POSTPROCESSPROC     pfnPostProcess;
+
+    NDISTAPI_REQUEST    NdisTapiRequest;
+
+} ASYNC_REQUEST_WRAPPER, *PASYNC_REQUEST_WRAPPER;
+
+
+typedef struct _ASYNC_EVENTS_THREAD_INFO
+{
+    //
+    // Thread handle (used when terminating thread)
+    //
+
+    HANDLE              hThread;
+
+    //
+    // Size of following buffers
+    //
+
+    DWORD               dwBufSize;
+
+    //
+    // Pointers to buffers used for gathering async events for driver
+    //
+
+    PNDISTAPI_EVENT_DATA    pBuf1;
+
+    PNDISTAPI_EVENT_DATA    pBuf2;
+
+} ASYNC_EVENTS_THREAD_INFO, *PASYNC_EVENTS_THREAD_INFO;
+
+
+typedef struct _DRVCALL
+{
+    DWORD               dwKey;
+
+    DWORD               dwDeviceID;
+
+    HTAPICALL           htCall;
+
+    HTAPI_CALL          ht_Call;
+
+    HDRV_CALL           hd_Call;
+
+    LPVOID              pLine;
+
+    BOOL                bIncomplete;
+
+    BOOL                bDropped;
+
+    union
+    {
+        struct _DRVCALL    *pPrev;              // for incoming calls
+
+        DWORD           dwPendingCallState;     // for outgoing calls
+    };
+
+    union
+    {
+        struct _DRVCALL    *pNext;              // for incoming calls
+
+        DWORD           dwPendingCallStateMode; // for outgoing calls
+    };
+
+    DWORD               dwPendingMediaMode;     // for outgoing calls
+
+} DRVCALL, *PDRVCALL;
+
+
+typedef struct _DRVLINE
+{
+    DWORD               dwKey;
+
+    DWORD               dwDeviceID;
+
+    HTAPILINE           htLine;
+
+    HDRV_LINE           hd_Line;
+
+    PDRVCALL            pInboundCalls;
+
+} DRVLINE, *PDRVLINE;
diff --git a/private/tapi/dev/sp/kmddsp/kmddsp.rc b/private/tapi/dev/sp/kmddsp/kmddsp.rc
new file mode 100644
index 000000000..5fd14998d
--- /dev/null
+++ b/private/tapi/dev/sp/kmddsp/kmddsp.rc
@@ -0,0 +1,17 @@
+#include "windows.h"
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "TAPI Kernel-Mode Service Provider"
+#define VER_INTERNALNAME_STR        "kmddsp"
+#define VER_ORIGINALFILENAME_STR    "KMDDSP.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/kmddsp/makefile b/private/tapi/dev/sp/kmddsp/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/dev/sp/kmddsp/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/kmddsp/sources b/private/tapi/dev/sp/kmddsp/sources
new file mode 100644
index 000000000..0befc8f37
--- /dev/null
+++ b/private/tapi/dev/sp/kmddsp/sources
@@ -0,0 +1,53 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=kmddsp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=TSP
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+DLLBASE=0x60000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc;$(BASEDIR)\private\ntos\inc;$(BASEDIR)\private\ntos\ndis\ndistapi
+
+SOURCES=kmddsp.c  \
+        kmddsp.rc
+
+C_DEFINES=-DTAPI_NT=1
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/kmesp/dirs b/private/tapi/dev/sp/kmesp/dirs
new file mode 100644
index 000000000..0173083c2
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/dirs
@@ -0,0 +1,25 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     sys \
+     exe
diff --git a/private/tapi/dev/sp/kmesp/exe/kmesp.c b/private/tapi/dev/sp/kmesp/exe/kmesp.c
new file mode 100644
index 000000000..42b2a3841
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/kmesp.c
@@ -0,0 +1,1927 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    kmesp.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    12-Apr-1995
+
+Revision History:
+
+
+
+Notes:
+
+
+--*/
+
+
+#include "windows.h"
+#include "winioctl.h"
+#include "stdio.h"
+#include "stdarg.h"
+#include "string.h"
+#include "ndistapi.h"
+#include "kmesp.h"
+#include "resource.h"
+#include "..\sys\intrface.h"
+
+
+int
+WINAPI
+WinMain(
+    HINSTANCE   hInstance,
+    HINSTANCE   hPrevInstance,
+    LPSTR       lpCmdLine,
+    int         nCmdShow
+    )
+{
+    ghInst = hInstance;
+
+    DialogBox(
+        ghInst,
+        (LPCSTR) MAKEINTRESOURCE(IDD_DIALOG1),
+        (HWND) NULL,
+        (DLGPROC) MainWndProc
+        );
+
+    return 0;
+}
+
+
+void
+DoRequestUI(
+    PREQUEST_PARAMS pRequestParams
+    )
+{
+    LONG  i, count = SendMessage (ghwndList1, LB_GETCOUNT, 0, 0);
+    char  buf[64];
+
+
+    switch (pRequestParams->Oid)
+    {
+    case OID_TAPI_CLOSE:
+    {
+        char szLineName[8];
+
+
+        sprintf (szLineName, "Line%d", pRequestParams->hWidget);
+
+        for (i = 0; i < count; i++)
+        {
+            SendMessage (ghwndList1, LB_GETTEXT, (WPARAM) i, (LPARAM) buf);
+
+            if (strstr (buf, szLineName))
+            {
+                break;
+            }
+        }
+
+        sprintf (buf, "%s (closed)", szLineName);
+
+        SendMessage (ghwndList1, LB_DELETESTRING, (WPARAM) i, 0);
+        SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM) i, (LPARAM) buf);
+
+        break;
+    }
+    case OID_TAPI_CLOSE_CALL:
+    {
+        char szhdCall[16];
+
+
+        sprintf (szhdCall, "x%x", pRequestParams->hWidget);
+
+        for (i = 0; i < count; i++)
+        {
+            SendMessage (ghwndList1, LB_GETTEXT, (WPARAM) i, (LPARAM) buf);
+
+            if (strstr (buf, szhdCall))
+            {
+                break;
+            }
+        }
+
+        SendMessage (ghwndList1, LB_DELETESTRING, (WPARAM) i, 0);
+
+        break;
+    }
+    case OID_TAPI_MAKE_CALL:
+    {
+        if (pRequestParams->Status == NDIS_STATUS_SUCCESS)
+        {
+            char szLineName[8];
+
+
+            sprintf (szLineName, "Line%d", pRequestParams->hWidget);
+
+            for (i = 0; i < count; i++)
+            {
+                SendMessage (ghwndList1, LB_GETTEXT, (WPARAM) i, (LPARAM) buf);
+
+                if (strstr (buf, szLineName))
+                {
+                    break;
+                }
+            }
+
+            i++;
+
+            sprintf (buf, "  hdCall = x%x", pRequestParams->ulRequestSpecific);
+
+            SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM) i, (LPARAM) buf);
+        }
+    }
+    case OID_TAPI_OPEN:
+    {
+        if (pRequestParams->Status == NDIS_STATUS_SUCCESS)
+        {
+            PMYWIDGET pWidget;
+
+
+            for (i = 0; i < count; i++)
+            {
+                pWidget = (PMYWIDGET) SendMessage(
+                    ghwndList1,
+                    LB_GETITEMDATA,
+                    (WPARAM) i,
+                    0
+                    );
+
+                if (pWidget->LineID == pRequestParams->hWidget)
+                {
+                    break;
+                }
+            }
+
+            sprintf (buf, "%s (open)", szLineName);
+
+            SendMessage (ghwndList1, LB_DELETESTRING, (WPARAM) i, 0);
+            SendMessage (ghwndList1, LB_INSERTSTRING, (WPARAM) i, (LPARAM) buf);
+        }
+
+        break;
+    }
+    case OID_TAPI_PROVIDER_INITIALIZE:
+    {
+        if (pRequestParams->Status == NDIS_STATUS_SUCCESS)
+        {
+            for (i = 0; i < pRequestParams->ulRequestSpecific; i++)
+            {
+                PMYWIDGET   pWidget = MyAlloc (sizeod(MYWIDGET));
+
+
+                pWidget->LineID = pRequestParams->hWidget + i;
+
+                sprintf (buf, "Line%d (closed)", pRequestParams->hWidget + i);
+
+                SendMessage (ghwndList1, LB_ADDSTRING, 0, (LPARAM) buf);
+                SendMessage (ghwndList1, LB_SETITEMDATA, i, (LPARAM) pWidget);
+            }
+        }
+
+        break;
+    }
+    case OID_TAPI_PROVIDER_SHUTDOWN:
+    {
+        while ((pWidget = SendMessage (ghwndList1, LB_GETITEMDATA, 0, 0))
+                != LB_ERR)
+        {
+            MyFree (pWidget);
+
+            SendMessage (ghwndList1, LB_DELETESTRING, 0, 0);
+        }
+
+        break;
+    }
+    default:
+
+        break;
+    }
+}
+
+
+BOOL
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static HICON  hIcon;
+    static int    icyButton, icyBorder;
+
+    static BOOL bCaptured = FALSE;
+    static LONG xCapture, cxVScroll;
+    static int  cyWnd;
+    static HFONT  hFont;
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        char buf[64];
+        RECT rect;
+
+
+        //
+        // Init some globals
+        //
+
+#ifdef WIN32
+
+//        ghShowStrBufMutex = CreateMutex(
+//            NULL,   // no security attrs
+//            FALSE,  // unowned
+//            NULL    // unnamed
+//            );
+
+#endif
+
+        hIcon = LoadIcon (ghInst, MAKEINTRESOURCE(IDI_ICON1));
+
+        ghwndMain  = hwnd;
+        ghwndList1 = GetDlgItem (hwnd, IDC_LIST1);
+        ghwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+        ghwndEdit  = GetDlgItem (hwnd, IDC_EDIT1);
+        ghMenu     = GetMenu (hwnd);
+
+        icyBorder = GetSystemMetrics (SM_CYFRAME);
+        GetWindowRect (GetDlgItem (hwnd, IDC_BUTTON1), &rect);
+        icyButton = (rect.bottom - rect.top) + icyBorder + 3;
+        cxVScroll = 2*GetSystemMetrics (SM_CXVSCROLL);
+
+
+        //
+        // Get ini file settings
+        //
+
+        gbManualResults = FALSE;
+
+        gdwCompletionMode = (DWORD) GetProfileInt(
+            szMySection,
+            "CompletionMode",
+            1
+            );
+
+        PostMessage (hwnd, WM_COMMAND, IDM_SYNCCOMPL + gdwCompletionMode, 0);
+
+
+        //
+        // Set control fonts
+        //
+
+        {
+            HWND hwndCtrl = GetDlgItem (hwnd, IDC_BUTTON1);
+            hFont = CreateFont(
+                13, 5, 0, 0, 400, 0, 0, 0, 0, 1, 2, 1, 34, "MS Sans Serif"
+                );
+
+            do
+            {
+                SendMessage(
+                    hwndCtrl,
+                    WM_SETFONT,
+                    (WPARAM) hFont,
+                    0
+                    );
+
+            } while ((hwndCtrl = GetNextWindow (hwndCtrl, GW_HWNDNEXT)));
+        }
+
+
+        //
+        // Read in control size ratios
+        //
+
+        cxWnd   = GetProfileInt (szMySection, "cxWnd",   100);
+        cxList1 = GetProfileInt (szMySection, "cxList1", 25);
+
+
+        //
+        // Send self WM_SIZE to position child controls correctly
+        //
+
+        GetProfileString(
+            szMySection,
+            "Left",
+            "0",
+            buf,
+            63
+            );
+
+        if (strcmp (buf, "max") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMAXIMIZED);
+        }
+        else if (strcmp (buf, "min") == 0)
+        {
+            ShowWindow (hwnd, SW_SHOWMINIMIZED);
+        }
+        else
+        {
+            int left, top, right, bottom;
+            int cxScreen = GetSystemMetrics (SM_CXSCREEN);
+            int cyScreen = GetSystemMetrics (SM_CYSCREEN);
+
+
+            left   = GetProfileInt (szMySection, "Left",   0);
+            top    = GetProfileInt (szMySection, "Top",    3*cyScreen/4);
+            right  = GetProfileInt (szMySection, "Right",  cxScreen);
+            bottom = GetProfileInt (szMySection, "Bottom", cyScreen);
+
+            SetWindowPos(
+                hwnd,
+                HWND_TOP,
+                left,
+                top,
+                right - left,
+                bottom - top,
+                SWP_SHOWWINDOW
+                );
+
+            GetClientRect (hwnd, &rect);
+
+            SendMessage(
+                hwnd,
+                WM_SIZE,
+                0,
+                MAKELONG((rect.right-rect.left),(rect.bottom-rect.top))
+                );
+
+            ShowWindow (hwnd, SW_SHOW);
+        }
+
+        if ((ghDriver = CreateFile(
+                "\\\\.\\STUBMP",
+                GENERIC_READ | GENERIC_WRITE,
+                0,
+                NULL,
+                OPEN_EXISTING,
+                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
+                NULL
+
+                )) == INVALID_HANDLE_VALUE)
+        {
+            ShowStr (
+                "Error opening stubmp driver, lastErr=%ld",
+                GetLastError()
+                );
+        }
+        else
+        {
+            DWORD dwThreadID;
+
+
+            ShowStr ("Stubmp driver opened");
+
+            ghThread = CreateThread(
+                NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) EventsThread,
+                NULL,
+                0,
+                &dwThreadID
+                );
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+
+        switch (LOWORD((DWORD)wParam))
+        {
+        case IDM_REGISTER:
+        {
+            DWORD params = RT_REGISTER;
+
+
+            DevIoCtl (&params, sizeof(DWORD));
+
+            ShowStr ("Stubmp driver registered with connection wrapper");
+
+            break;
+        }
+        case IDM_DEREGISTER:
+        {
+            DWORD params = RT_DEREGISTER;
+
+
+            DevIoCtl (&params, sizeof(DWORD));
+
+            ShowStr ("Stubmp driver deregistered from connection wrapper");
+
+            break;
+        }
+        case IDM_SYNCCOMPL:
+        case IDM_ASYNCCOMPL:
+        case IDM_MANUALCOMPL:
+
+            gdwCompletionMode = LOWORD((DWORD)wParam) - IDM_SYNCCOMPL;
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_SYNCCOMPL,
+                MF_BYCOMMAND | (gdwCompletionMode == SYNC_COMPLETIONS ?
+                    MF_CHECKED : MF_UNCHECKED)
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_ASYNCCOMPL,
+                MF_BYCOMMAND | (gdwCompletionMode == ASYNC_COMPLETIONS ?
+                    MF_CHECKED : MF_UNCHECKED)
+                );
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_MANUALCOMPL,
+                MF_BYCOMMAND | (gdwCompletionMode == MANUAL_COMPLETIONS ?
+                    MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_MANUALRESULTS:
+
+            gbManualResults = (gbManualResults ? FALSE : TRUE);
+
+            CheckMenuItem(
+                ghMenu,
+                IDM_MANUALRESULTS,
+                MF_BYCOMMAND | (gbManualResults ? MF_CHECKED : MF_UNCHECKED)
+                );
+
+            break;
+
+        case IDM_EXIT:
+
+            PostMessage (hwnd, WM_CLOSE, 0, 0);
+            break;
+
+        case IDM_ABOUT:
+
+            DialogBox(
+                ghInst,
+                (LPCSTR) MAKEINTRESOURCE(IDD_DIALOG2),
+                hwnd,
+                (DLGPROC) AboutDlgProc
+                );
+
+            break;
+
+        case IDC_LIST2:
+
+            if (HIWORD(wParam) == LBN_DBLCLK)
+            {
+                LONG lSel = SendMessage (ghwndList2, LB_GETCURSEL, 0, 0);
+                ULONG args[3];
+                PREQUEST_PARAMS pRequestParams;
+
+
+                pRequestParams = (PREQUEST_PARAMS) SendMessage(
+                    ghwndList2,
+                    LB_GETITEMDATA,
+                    (WPARAM) lSel,
+                    0
+                    );
+
+                args[0] = RT_COMPLETEREQUEST;
+                args[1] = pRequestParams->pNdisRequest;
+                args[2] = pRequestParams->Status;
+
+                if (gbManualResults)
+                {
+                    char szDlgTitle[] = "Request result";
+                    PARAM_INFO params[] =
+                    {
+                        { "Status", PT_ORDINAL, pRequestParams->Status, aStatus }
+                    };
+                    PARAM_INFO_HEADER paramsHeader =
+                        { 1, szDlgTitle, 0, params };
+
+
+                    if (DialogBoxParam(
+                        ghInst,
+                        (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                        (HWND) ghwndMain,
+                        (DLGPROC) ParamsDlgProc,
+                        (LPARAM) &paramsHeader
+
+                        ) != IDOK)
+                    {
+                        break;
+                    }
+
+                    args[2] =
+                    pRequestParams->Status = params[0].dwValue;
+                }
+
+                DoRequestUI (pRequestParams);
+
+                DevIoCtl (args, 3 * sizeof(ULONG));
+
+                SendMessage (ghwndList2, LB_DELETESTRING, lSel, 0);
+
+                MyFree (pRequestParams);
+            }
+
+            break;
+
+        case IDC_BUTTON1:
+        {
+            LONG sel = SendMessage (ghwndList1, LB_GETCURSEL, 0, 0);
+
+
+            if (sel != LB_ERR)
+            {
+                PARAM_INFO params[] =
+                {
+                    { "Line",     PT_DWORD,   0, NULL },
+                    { "hdCall",   PT_DWORD,   0, NULL },
+                    { "dwMsg",    PT_ORDINAL, 0, aLineMsgs },
+                    { "dwParam1", PT_DWORD,   0, NULL },
+                    { "dwParam2", PT_DWORD,   0, NULL },
+                    { "dwParam3", PT_DWORD,   0, NULL }
+                };
+                PARAM_INFO_HEADER paramsHeader =
+                    { 6, "Line event", 0, params };
+                char buf[64];
+
+
+                SendMessage(
+                    ghwndList1,
+                    LB_GETTEXT,
+                    (WPARAM) sel,
+                    (LPARAM) buf
+                    );
+
+                if (strstr (buf, "Line"))
+                {
+                }
+
+                if (DialogBoxParam(
+                        ghInst,
+                        (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                        (HWND) hwnd,
+                        (DLGPROC) ParamsDlgProc,
+                        (LPARAM) &paramsHeader
+                        ) == IDOK)
+                {
+                }
+            }
+
+            break;
+        }
+        case IDC_BUTTON2:
+
+            MessageBox (hwnd, "new call", "xxx", MB_OK);
+
+            break;
+
+        case IDC_BUTTON3:
+
+            SetWindowText (ghwndEdit, "");
+            break;
+        }
+
+        break;
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    case WM_MOUSEMOVE:
+    {
+        LONG x = (LONG)((short)LOWORD(lParam));
+        int y = (int)((short)HIWORD(lParam));
+        int cxList1New;
+
+
+        if (((y > icyButton) && (x > cxList1)) || bCaptured)
+        {
+            SetCursor(
+                LoadCursor ((HINSTANCE) NULL, MAKEINTRESOURCE(IDC_SIZEWE))
+                );
+        }
+
+        if (bCaptured)
+        {
+            x = (x < cxVScroll ?  cxVScroll : x);
+            x = (x > (cxWnd - cxVScroll) ?  (cxWnd - cxVScroll) : x);
+
+            cxList1New = (int) (cxList1 + x - xCapture);
+
+            SetWindowPos(
+                ghwndList1,
+                GetNextWindow (ghwndList1, GW_HWNDPREV),
+                0,
+                icyButton,
+                cxList1New,
+                2*cyWnd/3,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndList2,
+                GetNextWindow (ghwndList2, GW_HWNDPREV),
+                0,
+                icyButton + 2*cyWnd/3 + icyBorder,
+                cxList1New,
+                cyWnd/3 - icyBorder,
+                SWP_SHOWWINDOW
+                );
+
+            SetWindowPos(
+                ghwndEdit,
+                GetNextWindow (ghwndEdit, GW_HWNDPREV),
+                (int) cxList1New + icyBorder,
+                icyButton,
+                (int)cxWnd - (cxList1New + icyBorder),
+                cyWnd,
+                SWP_SHOWWINDOW
+                );
+        }
+
+        break;
+    }
+    case WM_LBUTTONDOWN:
+    {
+        if (((int)((short)HIWORD(lParam)) > icyButton) &&
+             ((int)((short)LOWORD(lParam)) > cxList1))
+        {
+            xCapture = (LONG)LOWORD(lParam);
+
+            SetCapture (hwnd);
+
+            bCaptured = TRUE;
+        }
+
+        break;
+    }
+    case WM_LBUTTONUP:
+    {
+        if (bCaptured)
+        {
+            POINT p;
+            LONG  x;
+
+            GetCursorPos (&p);
+            MapWindowPoints (HWND_DESKTOP, hwnd, &p, 1);
+            x = (LONG) p.x;
+
+            ReleaseCapture();
+
+            x = (x < cxVScroll ? cxVScroll : x);
+            x = (x > (cxWnd - cxVScroll) ? (cxWnd - cxVScroll) : x);
+
+            cxList1 = cxList1 + (x - xCapture);
+
+            bCaptured = FALSE;
+
+            InvalidateRect (hwnd, NULL, TRUE);
+        }
+
+        break;
+    }
+    case WM_SIZE:
+    {
+        LONG width = (LONG)LOWORD(lParam);
+
+
+        //
+        // Adjust globals based on new size
+        //
+
+        cxList1 = (cxList1 * width) / cxWnd;
+        cxWnd = width;
+        cyWnd = ((int)HIWORD(lParam)) - icyButton;
+
+
+        //
+        // Now reposition the child windows
+        //
+
+        SetWindowPos(
+            ghwndList1,
+            GetNextWindow (ghwndList1, GW_HWNDPREV),
+            0,
+            icyButton,
+            (int) cxList1,
+            2*cyWnd/3,
+            SWP_SHOWWINDOW
+            );
+
+        SetWindowPos(
+            ghwndList2,
+            GetNextWindow (ghwndList2, GW_HWNDPREV),
+            0,
+            icyButton + 2*cyWnd/3 + icyBorder,
+            (int) cxList1,
+            cyWnd/3 - icyBorder,
+            SWP_SHOWWINDOW
+            );
+
+        SetWindowPos(
+            ghwndEdit,
+            GetNextWindow (ghwndEdit, GW_HWNDPREV),
+            (int) cxList1 + icyBorder,
+            icyButton,
+            (int)width - ((int)cxList1 + icyBorder),
+            cyWnd,
+            SWP_SHOWWINDOW
+            );
+
+        InvalidateRect (hwnd, NULL, TRUE);
+
+        break;
+    }
+    case WM_CLOSE:
+
+        SaveIniSettings();
+        DestroyIcon (hIcon);
+        EndDialog (hwnd, 0);
+        DeleteObject (hFont);
+        CloseHandle (ghDriver);
+        TerminateThread (ghThread, 0);
+        break;
+    }
+
+    return FALSE;
+}
+
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            EndDialog (hwnd, 0);
+            break;
+        }
+        break;
+
+#ifdef WIN32
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+#else
+    case WM_CTLCOLOR:
+    {
+        if (HIWORD(lParam) == CTLCOLOR_STATIC)
+        {
+            SetBkColor ((HDC) wParam, RGB (192,192,192));
+            return (BOOL) GetStockObject (LTGRAY_BRUSH);
+        }
+        break;
+    }
+#endif
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
+
+
+void
+ShowStr(
+    LPCSTR format,
+    ...
+    )
+{
+    char buf[256];
+
+    va_list ap;
+
+    va_start(ap, format);
+
+    vsprintf (buf,
+              format,
+              ap
+              );
+
+    strcat (buf, "\r\n");
+
+    SendMessage (ghwndEdit, EM_SETSEL, (WPARAM)0x7fffffe, (LPARAM)0x7ffffff);
+    SendMessage (ghwndEdit, EM_REPLACESEL, 0, (LPARAM) buf);
+
+    va_end(ap);
+}
+
+
+LPVOID
+MyAlloc(
+    DWORD   dwSize
+    )
+{
+    return (LocalAlloc (LPTR, dwSize));
+}
+
+
+void
+MyFree(
+    LPVOID  p
+    )
+{
+    LocalFree (p);
+}
+
+
+void
+DevIoCtl(
+    LPVOID  pData,
+    DWORD   dwSize
+    )
+{
+    if (ghDriver != INVALID_HANDLE_VALUE)
+    {
+        DWORD cbReturned;
+
+        DeviceIoControl (
+            ghDriver,
+            (DWORD) IOCTL_STUBMP_APPREQUEST,
+            pData,
+            dwSize,
+            NULL,
+            0,
+            &cbReturned,
+            0
+            );
+    }
+}
+
+
+void
+SaveIniSettings(
+    void
+    )
+{
+    char buf[32];
+    RECT rect;
+
+
+    GetWindowRect (ghwndMain, &rect);
+
+    {
+        typedef struct _SAVE_VALUE
+        {
+            char    *lpszVal;
+
+            DWORD   dwValue;
+
+        } SAVE_VALUE, *PSAVE_VALUE;
+
+        SAVE_VALUE aValues[] =
+        {
+            { "CompletionMode",      gdwCompletionMode             },
+            { "Left",                (DWORD) rect.left             },
+            { "Top",                 (DWORD) rect.top              },
+            { "Right",               (DWORD) rect.right            },
+            { "Bottom",              (DWORD) rect.bottom           },
+            { "cxWnd",               (DWORD) cxWnd                 },
+            { "cxList1",             (DWORD) cxList1               },
+            { NULL,                  0 }
+        };
+        int i;
+
+
+        for (i = 0; aValues[i].lpszVal; i++)
+        {
+            wsprintf (buf, "%ld", aValues[i].dwValue); // decimal
+
+            WriteProfileString(
+               szMySection,
+               aValues[i].lpszVal,
+               (LPCSTR) buf
+               );
+        }
+
+        if (IsIconic (ghwndMain))
+        {
+            WriteProfileString(
+                szMySection,
+                "Left",
+                "min"
+                );
+        }
+        else if (IsZoomed (ghwndMain))
+        {
+            WriteProfileString(
+                szMySection,
+                "Left",
+                "max"
+                );
+        }
+    }
+}
+
+
+void
+EventsThread(
+    LPVOID  p
+    )
+{
+    ULONG      *pFullBuf, *pEmptyBuf, *pBuf1, *pBuf2;
+    DWORD       dwBufSize = 1024;
+    OVERLAPPED  overlapped;
+
+
+    pFullBuf  = pBuf1 = LocalAlloc (LPTR, dwBufSize);
+    pEmptyBuf = pBuf2 = LocalAlloc (LPTR, dwBufSize);
+
+    *pFullBuf = 0;
+
+    overlapped.hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
+
+    while (1)
+    {
+        DWORD cbReturned, dwNumBytes;
+
+
+        *pEmptyBuf = dwBufSize;
+
+        DeviceIoControl (
+            ghDriver,
+            (DWORD) IOCTL_STUBMP_GETEVENTS,
+            pEmptyBuf,
+            dwBufSize,
+            pEmptyBuf,
+            dwBufSize,
+            &cbReturned,
+            &overlapped
+            );
+
+        dwNumBytes = *pFullBuf;
+
+        pFullBuf++;
+
+        while (dwNumBytes)
+        {
+            switch (*pFullBuf)
+            {
+            case ET_REQUEST:
+            {
+                //
+                // Stubmp received request, show it
+                //
+
+                static char *pszLookup[] =
+                {
+                    "Accept: hdCall=x%x",
+                    "Answer: hdCall=x%x",
+                    "Close: hdLine=x%x",
+                    "CloseCall: hdCall=x%x",
+                    "ConditionalMediaDetection: ",
+                    "ConfigDialog: DeviceID=x%lx",
+                    "DevSpecific: hdLine=x%lx",
+                    "Dial: hdCall=x%lx",
+                    "Drop: hdCall=x%lx",
+                    "GetAddressCaps: DeviceID=x%lx",
+                    "GetAddressID: hdLine=x%lx",
+                    "GetAddressStatus: hdline=x%lx",
+                    "GetCallAddressID: hdCall=x%lx",
+                    "GetCallInfo: hdCall=x%lx",
+                    "GetCallStatus: hdCall=x%lx",
+                    "GetDevCaps: DeviceID=x%lx",
+                    "GetDevConfig: DeviceID=x%lx",
+                    "GetExtensionID: DeviceID=x%lx",
+                    "GetID: hXxx=x%lx",
+                    "GetLineDevStatus: hdLine=x%lx",
+                    "MakeCall: hdLine=x%lx",
+                    "NegotiateExtVersion: DeviceID=x%lx",
+                    "Open: DeviceID=x%lx",
+                    "Initialize: DeviceIDBase=x%lx",
+                    "Shutdown",
+                    "SecureCall: hdCall=x%lx",
+                    "SelectExtVersion: hdLine=x%lx",
+                    "SendUserUserInfo: hdCall=x%lx",
+                    "SetAppSpecific: hdCall=x%lx",
+                    "SetCallParams: hdCall=x%lx",
+                    "SetDefaultMediaDetection: hdLine=x%lx",
+                    "SetDevConfig: DeviceID=x%lx",
+                    "SetMediaMode: hdCall=x%lx",
+                    "SetStatusMessages: hdLine=x%lx"
+                };
+                PREQUEST_PARAMS pRequestParams = (PREQUEST_PARAMS) pFullBuf;
+
+
+                ShowStr(
+                    pszLookup[pRequestParams->Oid - OID_TAPI_ACCEPT],
+                    pRequestParams->hWidget
+                    );
+
+                if (pRequestParams->bNeedsCompleting)
+                {
+                    PREQUEST_PARAMS pRequestParamsSav;
+
+
+                    if ((gdwCompletionMode == MANUAL_COMPLETIONS) &&
+                        (pRequestParamsSav = MyAlloc (sizeof(REQUEST_PARAMS))))
+                    {
+                        char    buf[128];
+                        int     i;
+                        LONG    index;
+
+
+                        sprintf(
+                            buf,
+                            "pReq=x%x: ",
+                            pRequestParams->pNdisRequest
+                            );
+
+                        i = strlen (buf);
+
+                        sprintf(
+                            buf + i,
+                            pszLookup[pRequestParams->Oid - OID_TAPI_ACCEPT],
+                            pRequestParams->hWidget
+                            );
+
+                        index = SendMessage(
+                            ghwndList2,
+                            LB_ADDSTRING,
+                            0,
+                            (LPARAM) buf
+                            );
+
+                        memcpy(
+                            pRequestParamsSav,
+                            pRequestParams,
+                            sizeof(REQUEST_PARAMS)
+                            );
+
+                        SendMessage(
+                            ghwndList2,
+                            LB_SETITEMDATA,
+                            (WPARAM) index,
+                            (LPARAM) pRequestParamsSav
+                            );
+                    }
+                    else
+                    {
+                        ULONG args[3] =
+                        {
+                              RT_COMPLETEREQUEST,
+                              pRequestParams->pNdisRequest,
+                              pRequestParams->Status
+                        };
+
+
+                        if (gbManualResults)
+                        {
+                            char szDlgTitle[] = "Request result";
+                            PARAM_INFO params[] =
+                            {
+                                { "Status", PT_ORDINAL, args[2], aStatus }
+                            };
+                            PARAM_INFO_HEADER paramsHeader =
+                                { 1, szDlgTitle, 0, params };
+
+
+                            if (DialogBoxParam(
+                                    ghInst,
+                                    (LPCSTR)MAKEINTRESOURCE(IDD_DIALOG3),
+                                    (HWND) ghwndMain,
+                                    (DLGPROC) ParamsDlgProc,
+                                    (LPARAM) &paramsHeader
+                                    ) == IDOK)
+                            {
+                                args[2] =
+                                pRequestParams->Status = params[0].dwValue;
+                            }
+                        }
+
+                        DoRequestUI (pRequestParams);
+
+                        DevIoCtl (args, 3 * sizeof(ULONG));
+                    }
+                }
+                else
+                {
+                    DoRequestUI (pRequestParams);
+                }
+
+                pFullBuf += (sizeof(REQUEST_PARAMS) / sizeof(ULONG));
+                dwNumBytes -= sizeof(REQUEST_PARAMS);
+
+                break;
+            }
+            } // switch
+        }
+
+        WaitForSingleObject (overlapped.hEvent, INFINITE);
+
+        pFullBuf = pEmptyBuf;
+
+        pEmptyBuf = (pFullBuf == pBuf1 ? pBuf2 : pBuf1);
+    }
+
+    CloseHandle (overlapped.hEvent);
+
+    ExitThread (0);
+}
+
+
+BOOL
+CALLBACK
+ParamsDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    DWORD  i;
+
+    typedef struct _DLG_INST_DATA
+    {
+        PPARAM_INFO_HEADER pParamsHeader;
+
+        LONG lLastSel;
+
+        char szComboText[MAX_STRING_PARAM_SIZE];
+
+        HGLOBAL hComboDS;
+
+        LPVOID  pComboSeg;
+
+        HWND    hwndCombo;
+
+    } DLG_INST_DATA, *PDLG_INST_DATA;
+
+    PDLG_INST_DATA pDlgInstData = (PDLG_INST_DATA)
+        GetWindowLong (hwnd, DWL_USER);
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        //
+        // Alloc a dlg instance data struct, init it, & save a ptr to it
+        //
+
+        pDlgInstData = (PDLG_INST_DATA) MyAlloc (sizeof(DLG_INST_DATA));
+
+        // BUGBUG if (!pDlgInstData)
+
+        pDlgInstData->pParamsHeader = (PPARAM_INFO_HEADER) lParam;
+        pDlgInstData->lLastSel = -1;
+
+        SetWindowLong (hwnd, DWL_USER, (LONG) pDlgInstData);
+
+
+        //
+        // Limit the max text length for the combobox's edit field
+        // (NOTE: A combobox ctrl actually has two child windows: a
+        // edit ctrl & a listbox.  We need to get the hwnd of the
+        // child edit ctrl & send it the LIMITTEXT msg.)
+        //
+
+        {
+            HWND hwndChild = GetWindow (pDlgInstData->hwndCombo, GW_CHILD);
+
+
+            while (hwndChild)
+            {
+                char buf[8];
+
+
+                GetClassName (hwndChild, buf, 7);
+
+                if (_stricmp (buf, "edit") == 0)
+                {
+                    break;
+                }
+
+                hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+            }
+
+            SendMessage(
+                hwndChild,
+                EM_LIMITTEXT,
+                (WPARAM) MAX_STRING_PARAM_SIZE - 1,
+                0
+                );
+        }
+
+
+        //
+        // Misc other init
+        //
+
+        pDlgInstData->pParamsHeader = (PPARAM_INFO_HEADER) lParam;
+
+        SetWindowText (hwnd, pDlgInstData->pParamsHeader->pszDlgTitle);
+
+        for (i = 0; i < pDlgInstData->pParamsHeader->dwNumParams; i++)
+        {
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST1,
+                LB_INSERTSTRING,
+                (WPARAM) -1,
+                (LPARAM) pDlgInstData->pParamsHeader->aParams[i].szName
+                );
+        }
+
+        break;
+    }
+    case WM_COMMAND:
+    {
+        LONG      lLastSel      = pDlgInstData->lLastSel;
+        char far *lpszComboText = pDlgInstData->szComboText;
+        PPARAM_INFO_HEADER pParamsHeader = pDlgInstData->pParamsHeader;
+
+
+        switch (LOWORD(wParam))
+        {
+        case IDOK:
+
+            if (lLastSel != -1)
+            {
+                char buf[MAX_STRING_PARAM_SIZE];
+
+
+                //
+                // Save val of currently selected param
+                //
+
+                i = GetDlgItemText (hwnd, IDC_COMBO1, buf, MAX_STRING_PARAM_SIZE-1);
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    LONG lComboSel;
+
+
+                    lComboSel = SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_GETCURSEL,
+                        0,
+                        0
+                        );
+
+                    if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                    {
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD) 0;
+                    }
+                    else // "Valid string"
+                    {
+                        strncpy(
+                            pParamsHeader->aParams[lLastSel].u.buf,
+                            buf,
+                            MAX_STRING_PARAM_SIZE - 1
+                            );
+
+                        pParamsHeader->aParams[lLastSel].u.buf[MAX_STRING_PARAM_SIZE-1] = 0;
+
+                        pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                            pParamsHeader->aParams[lLastSel].u.buf;
+                    }
+
+                    break;
+                }
+                case PT_DWORD:
+                case PT_FLAGS:
+                case PT_ORDINAL:
+                {
+                    if (!sscanf(
+                            buf,
+                            "%08lx",
+                            &pParamsHeader->aParams[lLastSel].dwValue
+                            ))
+                    {
+                        //
+                        // Default to 0
+                        //
+
+                        pParamsHeader->aParams[lLastSel].dwValue = 0;
+                    }
+
+                    break;
+                }
+                } // switch
+            }
+
+            // Drop thru to IDCANCEL cleanup code
+
+        case IDCANCEL:
+
+            MyFree (pDlgInstData);
+            EndDialog (hwnd, (int)LOWORD(wParam));
+            break;
+
+        case IDC_LIST1:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                char buf[MAX_STRING_PARAM_SIZE] = "";
+                LPCSTR lpstr = buf;
+                LONG lSel =
+                    SendDlgItemMessage (hwnd, IDC_LIST1, LB_GETCURSEL, 0, 0);
+
+
+                if (lLastSel != -1)
+                {
+                    //
+                    // Save the old param value
+                    //
+
+                    i = GetDlgItemText(
+                        hwnd,
+                        IDC_COMBO1,
+                        buf,
+                        MAX_STRING_PARAM_SIZE - 1
+                        );
+
+                    switch (pParamsHeader->aParams[lLastSel].dwType)
+                    {
+                    case PT_STRING:
+                    {
+                        LONG lComboSel;
+
+
+                        lComboSel = SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_GETCURSEL,
+                            0,
+                            0
+                            );
+
+                        if (lComboSel == 0) // "NULL string (dwXxxSize = 0)"
+                        {
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)0;
+                        }
+                        else // "Valid string" or no sel
+                        {
+                            strncpy(
+                                pParamsHeader->aParams[lLastSel].u.buf,
+                                buf,
+                                MAX_STRING_PARAM_SIZE - 1
+                                );
+
+                            pParamsHeader->aParams[lLastSel].u.buf[MAX_STRING_PARAM_SIZE - 1] = 0;
+
+                            pParamsHeader->aParams[lLastSel].dwValue = (DWORD)
+                                pParamsHeader->aParams[lLastSel].u.buf;
+                        }
+
+                        break;
+                    }
+                    case PT_DWORD:
+                    case PT_FLAGS:
+                    case PT_ORDINAL:
+                    {
+                        if (!sscanf(
+                                buf,
+                                "%08lx",
+                                &pParamsHeader->aParams[lLastSel].dwValue
+                                ))
+                        {
+                            //
+                            // Default to 0
+                            //
+
+                            pParamsHeader->aParams[lLastSel].dwValue = 0;
+                        }
+
+                        break;
+                    }
+                    } // switch
+                }
+
+
+                SendDlgItemMessage (hwnd, IDC_LIST2, LB_RESETCONTENT, 0, 0);
+                SendDlgItemMessage (hwnd, IDC_COMBO1, CB_RESETCONTENT, 0, 0);
+
+                switch (pParamsHeader->aParams[lSel].dwType)
+                {
+                case PT_STRING:
+                {
+                    char * aszOptions[] =
+                    {
+                        "NUL (dwXxxSize=0)",
+                        "Valid string"
+                    };
+
+
+                    for (i = 0; i < 2; i++)
+                    {
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) aszOptions[i]
+                            );
+                    }
+
+                    if (pParamsHeader->aParams[lSel].dwValue == 0)
+                    {
+                        i = 0;
+                        buf[0] = 0;
+                    }
+                    else
+                    {
+                        i = 1;
+                        lpstr = (LPCSTR) pParamsHeader->aParams[lSel].dwValue;
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_SETCURSEL,
+                        (WPARAM) i,
+                        0
+                        );
+
+                    break;
+                }
+                case PT_DWORD:
+                {
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "0000000"
+                        );
+
+                    if (pParamsHeader->aParams[lSel].u.dwDefValue)
+                    {
+                        //
+                        // Add the default val string to the combo
+                        //
+
+                        wsprintf(
+                            buf,
+                            "%08lx",
+                            pParamsHeader->aParams[lSel].u.dwDefValue
+                            );
+
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_COMBO1,
+                            CB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) buf
+                            );
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "ffffffff"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_ORDINAL:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].u.pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue ==
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                case PT_FLAGS:
+                {
+                    //
+                    // Stick the bit flag strings in the list box
+                    //
+
+                    HWND hwndList2 = GetDlgItem (hwnd, IDC_LIST2);
+                    PLOOKUP pLookup = (PLOOKUP)
+                        pParamsHeader->aParams[lSel].u.pLookup;
+
+                    for (i = 0; pLookup[i].dwVal != 0xffffffff; i++)
+                    {
+                        SendMessage(
+                            hwndList2,
+                            LB_INSERTSTRING,
+                            (WPARAM) -1,
+                            (LPARAM) pLookup[i].lpszVal
+                            );
+
+                        if (pParamsHeader->aParams[lSel].dwValue &
+                            pLookup[i].dwVal)
+                        {
+                            SendMessage(
+                                hwndList2,
+                                LB_SETSEL,
+                                (WPARAM) TRUE,
+                                (LPARAM) MAKELPARAM((WORD)i,0)
+                                );
+                        }
+                    }
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select none"
+                        );
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_COMBO1,
+                        CB_INSERTSTRING,
+                        (WPARAM) -1,
+                        (LPARAM) (char far *) "select all"
+                        );
+
+                    wsprintf(
+                        buf,
+                        "%08lx",
+                        pParamsHeader->aParams[lSel].dwValue
+                        );
+
+                    break;
+                }
+                } //switch
+
+                SetDlgItemText (hwnd, IDC_COMBO1, lpstr);
+
+                pDlgInstData->lLastSel = lSel;
+            }
+            break;
+
+        case IDC_LIST2:
+
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+                //
+                // BUGBUG in the PT_ORDINAL case we should compare the
+                // currently selected item(s) against the previous DWORD
+                // val and figure out which item we need to deselect,
+                // if any, in order to maintain a mutex of values
+                //
+
+                PLOOKUP pLookup = (PLOOKUP)
+                    pParamsHeader->aParams[lLastSel].u.pLookup;
+                char buf[16];
+                DWORD dwValue = 0;
+                int far *ai;
+                LONG i, lSelCount =
+                    SendDlgItemMessage (hwnd, IDC_LIST2, LB_GETSELCOUNT, 0, 0);
+
+
+                ai = (int far *) MyAlloc ((size_t)lSelCount * sizeof(int));
+
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST2,
+                    LB_GETSELITEMS,
+                    (WPARAM) lSelCount,
+                    (LPARAM) ai
+                    );
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_FLAGS)
+                {
+                    for (i = 0; i < lSelCount; i++)
+                    {
+                        dwValue |= pLookup[ai[i]].dwVal;
+                    }
+                }
+                else // if (.dwType == PT_ORDINAL)
+                {
+                    if (lSelCount == 1)
+                    {
+                        dwValue = pLookup[ai[0]].dwVal;
+                    }
+                    else if (lSelCount == 2)
+                    {
+                        //
+                        // Figure out which item we need to de-select, since
+                        // we're doing ordinals & only want 1 item selected
+                        // at a time
+                        //
+
+                        GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                        if (sscanf (buf, "%08lx", &dwValue))
+                        {
+                            if (pLookup[ai[0]].dwVal == dwValue)
+                            {
+                                SendDlgItemMessage(
+                                    hwnd,
+                                    IDC_LIST2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[0]
+                                    );
+
+                                dwValue = pLookup[ai[1]].dwVal;
+                            }
+                            else
+                            {
+                                SendDlgItemMessage(
+                                    hwnd,
+                                    IDC_LIST2,
+                                    LB_SETSEL,
+                                    0,
+                                    (LPARAM) ai[1]
+                                    );
+
+                                dwValue = pLookup[ai[0]].dwVal;
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                    else if (lSelCount > 2)
+                    {
+                        //
+                        // Determine previous selection & de-select all the
+                        // latest selections
+                        //
+
+                        GetDlgItemText (hwnd, IDC_COMBO1, buf, 16);
+
+                        if (sscanf (buf, "%08lx", &dwValue))
+                        {
+                            for (i = 0; i < lSelCount; i++)
+                            {
+                                if (pLookup[ai[i]].dwVal != dwValue)
+                                {
+                                    SendDlgItemMessage(
+                                        hwnd,
+                                        IDC_LIST2,
+                                        LB_SETSEL,
+                                        0,
+                                        (LPARAM) ai[i]
+                                        );
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // BUGBUG de-select items???
+
+                            dwValue = 0;
+                        }
+                    }
+                }
+
+                MyFree (ai);
+                wsprintf (buf, "%08lx", dwValue);
+                SetDlgItemText (hwnd, IDC_COMBO1, buf);
+            }
+            break;
+
+        case IDC_COMBO1:
+
+            switch (HIWORD(wParam))
+            {
+            case CBN_SELCHANGE:
+            {
+                LONG lSel =
+                    SendDlgItemMessage (hwnd, IDC_COMBO1, CB_GETCURSEL, 0, 0);
+
+
+                switch (pParamsHeader->aParams[lLastSel].dwType)
+                {
+                case PT_ORDINAL:
+
+                    //
+                    // The only option here is "select none"
+                    //
+
+                    strcpy (lpszComboText, "00000000");
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+                    break;
+
+                case PT_FLAGS:
+                {
+                    BOOL bSelect = (lSel ? TRUE : FALSE);
+
+                    SendDlgItemMessage(
+                        hwnd,
+                        IDC_LIST2,
+                        LB_SETSEL,
+                        (WPARAM) bSelect,
+                        (LPARAM) -1
+                        );
+
+                    if (bSelect)
+                    {
+                        PLOOKUP pLookup = (PLOOKUP)
+                            pParamsHeader->aParams[lLastSel].u.pLookup;
+                        DWORD dwValue = 0;
+                        int far *ai;
+                        LONG i, lSelCount =
+                            SendDlgItemMessage (hwnd, IDC_LIST2, LB_GETSELCOUNT, 0, 0);
+
+
+                        ai = (int far *) MyAlloc(
+                            (size_t)lSelCount * sizeof(int)
+                            );
+
+                        SendDlgItemMessage(
+                            hwnd,
+                            IDC_LIST2,
+                            LB_GETSELITEMS,
+                            (WPARAM) lSelCount,
+                            (LPARAM) ai
+                            );
+
+                        for (i = 0; i < lSelCount; i++)
+                        {
+                            dwValue |= pLookup[ai[i]].dwVal;
+                        }
+
+                        MyFree (ai);
+                        wsprintf (lpszComboText, "%08lx", dwValue);
+
+                    }
+                    else
+                    {
+                        strcpy (lpszComboText, "00000000");
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+                }
+                case PT_STRING:
+
+                    if (lSel == 1)
+                    {
+                        strncpy(
+                            lpszComboText,
+                            pParamsHeader->aParams[lLastSel].u.buf,
+                            MAX_STRING_PARAM_SIZE
+                            );
+
+                        lpszComboText[MAX_STRING_PARAM_SIZE-1] = 0;
+                    }
+                    else
+                    {
+                        lpszComboText[0] = 0;
+                    }
+
+                    PostMessage (hwnd, WM_USER+55, 0, 0);
+
+                    break;
+
+                case PT_DWORD:
+
+                    break;
+
+                } // switch
+                break;
+            }
+            case CBN_EDITCHANGE:
+            {
+                //
+                // If user entered text in the edit field then copy the
+                // text to our buffer
+                //
+
+                if (pParamsHeader->aParams[lLastSel].dwType == PT_STRING)
+                {
+                    char buf[MAX_STRING_PARAM_SIZE];
+
+
+                    GetDlgItemText(
+                        hwnd,
+                        IDC_COMBO1,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    strncpy(
+                        pParamsHeader->aParams[lLastSel].u.buf,
+                        buf,
+                        MAX_STRING_PARAM_SIZE
+                        );
+
+                    pParamsHeader->aParams[lLastSel].u.buf
+                        [MAX_STRING_PARAM_SIZE-1] = 0;
+                }
+                break;
+            }
+            } // switch
+
+        } // switch
+
+        break;
+    }
+    case WM_USER+55:
+
+        SetDlgItemText (hwnd, IDC_COMBO1, pDlgInstData->szComboText);
+        break;
+
+    case WM_CTLCOLORSTATIC:
+
+        SetBkColor ((HDC) wParam, RGB (192,192,192));
+        return (BOOL) GetStockObject (LTGRAY_BRUSH);
+
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    }
+    }
+
+    return FALSE;
+}
diff --git a/private/tapi/dev/sp/kmesp/exe/kmesp.def b/private/tapi/dev/sp/kmesp/exe/kmesp.def
new file mode 100644
index 000000000..1118020aa
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/kmesp.def
@@ -0,0 +1,11 @@
+NAME         kmesp
+STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+HEAPSIZE     1024
+STACKSIZE    8192
+
+EXPORTS
+    MainWndProc
+    AboutDlgProc
+    ParamsDlgProc
diff --git a/private/tapi/dev/sp/kmesp/exe/kmesp.h b/private/tapi/dev/sp/kmesp/exe/kmesp.h
new file mode 100644
index 000000000..3e7eab0fa
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/kmesp.h
@@ -0,0 +1,246 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    kmesp.h
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    12-Apr-1995
+
+Revision History:
+
+
+
+Notes:
+
+
+--*/
+
+
+#define SYNC_COMPLETIONS   0
+#define ASYNC_COMPLETIONS  1
+#define MANUAL_COMPLETIONS 2
+
+#define PT_DWORD                1
+#define PT_FLAGS                2
+#define PT_STRING               3
+#define PT_ORDINAL              4
+
+#define MAX_STRING_PARAM_SIZE   32
+
+
+typedef struct _LOOKUP
+{
+    DWORD       dwVal;
+
+    char far   *lpszVal;
+
+} LOOKUP, *PLOOKUP;
+
+
+typedef struct _PARAM_INFO
+{
+    char far    *szName;
+
+    DWORD       dwType;
+
+    DWORD       dwValue;
+
+    union
+    {
+        PLOOKUP     pLookup;
+
+        char far    *buf;
+
+        LPVOID      ptr;
+
+        DWORD       dwDefValue;
+
+    } u;
+
+} PARAM_INFO, far *PPARAM_INFO;
+
+
+typedef struct _PARAM_INFO_HEADER
+{
+    DWORD       dwNumParams;
+
+    LPSTR       pszDlgTitle;
+
+    DWORD       dwEventType;
+
+    PPARAM_INFO    aParams;
+
+} PARAM_INFO_HEADER, far *PPARAM_INFO_HEADER;
+
+
+typedef struct _MYWIDGET
+{
+    ULONG       LineID;
+
+    ULONG       hdCall;
+
+} MYWIDGET, *PMYWIDGET;
+
+BOOL    gbManualResults;
+HWND    ghwndMain,
+        ghwndList1,
+        ghwndList2,
+        ghwndEdit;
+DWORD   gdwCompletionMode;
+HMENU   ghMenu;
+HANDLE  ghInst, ghThread;
+char    szMySection[] = "KMESP";
+LONG    cxList1, cxWnd;
+HANDLE  ghDriver = INVALID_HANDLE_VALUE;
+
+
+BOOL
+CALLBACK
+MainWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+BOOL
+CALLBACK
+AboutDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+void
+ShowStr(
+    LPCSTR format,
+    ...
+    );
+
+void
+DevIoCtl(
+    LPVOID  pData,
+    DWORD   dwSize
+    );
+
+void
+SaveIniSettings(
+    void
+    );
+
+void
+EventsThread(
+    LPVOID  p
+    );
+
+BOOL
+CALLBACK
+ParamsDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+LPVOID
+MyAlloc(
+    DWORD   dwSize
+    );
+
+void
+MyFree(
+    LPVOID  p
+    );
+
+
+//
+// BUGBUG Hack alert
+//
+
+typedef ULONG NDIS_STATUS;
+
+#define NDIS_STATUS_SUCCESS   0x00000000L
+#define NDIS_STATUS_RESOURCES 0xC000009AL
+#define NDIS_STATUS_FAILURE   0xC0000001L
+
+
+LOOKUP aStatus[] =
+{
+    //
+    // Defined in NDIS.H
+    //
+
+    { NDIS_STATUS_SUCCESS                    ,"SUCCESS"                 },
+
+    //
+    // These errors are defined in NDISTAPI.H
+    //
+
+    { NDIS_STATUS_TAPI_ADDRESSBLOCKED        ,"ADDRESSBLOCKED"          },
+    { NDIS_STATUS_TAPI_BEARERMODEUNAVAIL     ,"BEARERMODEUNAVAIL"       },
+    { NDIS_STATUS_TAPI_CALLUNAVAIL           ,"CALLUNAVAIL"             },
+    { NDIS_STATUS_TAPI_DIALBILLING           ,"DIALBILLING"             },
+    { NDIS_STATUS_TAPI_DIALDIALTONE          ,"DIALDIALTONE"            },
+    { NDIS_STATUS_TAPI_DIALPROMPT            ,"DIALPROMPT"              },
+    { NDIS_STATUS_TAPI_DIALQUIET             ,"DIALQUIET"               },
+    { NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION,"INCOMPATIBLEEXTVERSION"  },
+    { NDIS_STATUS_TAPI_INUSE                 ,"INUSE"                   },
+    { NDIS_STATUS_TAPI_INVALADDRESS          ,"INVALADDRESS"            },
+    { NDIS_STATUS_TAPI_INVALADDRESSID        ,"INVALADDRESSID"          },
+    { NDIS_STATUS_TAPI_INVALADDRESSMODE      ,"INVALADDRESSMODE"        },
+    { NDIS_STATUS_TAPI_INVALBEARERMODE       ,"INVALBEARERMODE"         },
+    { NDIS_STATUS_TAPI_INVALCALLHANDLE       ,"INVALCALLHANDLE"         },
+    { NDIS_STATUS_TAPI_INVALCALLPARAMS       ,"INVALCALLPARAMS"         },
+    { NDIS_STATUS_TAPI_INVALCALLSTATE        ,"INVALCALLSTATE"          },
+    { NDIS_STATUS_TAPI_INVALDEVICECLASS      ,"INVALDEVICECLASS"        },
+    { NDIS_STATUS_TAPI_INVALLINEHANDLE       ,"INVALLINEHANDLE"         },
+    { NDIS_STATUS_TAPI_INVALLINESTATE        ,"INVALLINESTATE"          },
+    { NDIS_STATUS_TAPI_INVALMEDIAMODE        ,"INVALMEDIAMODE"          },
+    { NDIS_STATUS_TAPI_INVALRATE             ,"INVALRATE"               },
+    { NDIS_STATUS_TAPI_NODRIVER              ,"NODRIVER"                },
+    { NDIS_STATUS_TAPI_OPERATIONUNAVAIL      ,"OPERATIONUNAVAIL"        },
+    { NDIS_STATUS_TAPI_RATEUNAVAIL           ,"RATEUNAVAIL"             },
+    { NDIS_STATUS_TAPI_RESOURCEUNAVAIL       ,"RESOURCEUNAVAIL"         },
+    { NDIS_STATUS_TAPI_STRUCTURETOOSMALL     ,"STRUCTURETOOSMALL"       },
+    { NDIS_STATUS_TAPI_USERUSERINFOTOOBIG    ,"USERUSERINFOTOOBIG"      },
+    { NDIS_STATUS_TAPI_ALLOCATED             ,"ALLOCATED"               },
+    { NDIS_STATUS_TAPI_INVALADDRESSSTATE     ,"INVALADDRESSSTATE"       },
+    { NDIS_STATUS_TAPI_INVALPARAM            ,"INVALPARAM"              },
+    { NDIS_STATUS_TAPI_NODEVICE              ,"NODEVICE"                },
+
+    //
+    // These errors are defined in NDIS.H
+    //
+
+    { NDIS_STATUS_RESOURCES                  ,"RESOURCES"               },
+    { NDIS_STATUS_FAILURE                    ,"FAILURE"                 },
+
+    //
+    //
+    //
+
+    { 0xffffffff                             ,""                        }
+};
+
+
+LOOKUP aLineMsgs[] =
+{
+    { LINE_ADDRESSSTATE     ,"ADDRESSSTATE"     },
+    { LINE_CALLINFO         ,"CALLINFO"         },
+    { LINE_CALLSTATE        ,"CALLSTATE"        },
+    { LINE_CLOSE            ,"CLOSE"            },
+    { LINE_DEVSPECIFIC      ,"DEVSPECIFIC"      },
+    { LINE_LINEDEVSTATE     ,"LINEDEVSTATE"     },
+    { LINE_CALLDEVSPECIFIC  ,"CALLDEVSPECIFIC"  },
+
+    { 0xffffffff            ,"" }
+};
diff --git a/private/tapi/dev/sp/kmesp/exe/kmesp.ico b/private/tapi/dev/sp/kmesp/exe/kmesp.ico
new file mode 100644
index 000000000..516eb3f84
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/kmesp.ico
diff --git a/private/tapi/dev/sp/kmesp/exe/kmesp.rc b/private/tapi/dev/sp/kmesp/exe/kmesp.rc
new file mode 100644
index 000000000..c940efe95
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/kmesp.rc
@@ -0,0 +1,164 @@
+//Microsoft App Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#ifdef WIN32
+#include "windows.h"
+#else
+#include "afxres.h"
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+#ifdef APSTUDIO_INVOKED
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 292, 217
+STYLE WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU | 
+    WS_THICKFRAME
+CAPTION "KMESP"
+MENU IDR_MENU1
+FONT 6, "Courier"
+BEGIN
+    PUSHBUTTON      "LEvt",IDC_BUTTON1,1,1,16,16
+    PUSHBUTTON      "Call+",IDC_BUTTON2,19,1,16,16
+    PUSHBUTTON      "Clear",IDC_BUTTON3,37,1,16,16
+    EDITTEXT        IDC_EDIT1,129,19,117,195,ES_MULTILINE | ES_AUTOVSCROLL |
+                    ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL | 0x1000
+    LISTBOX         IDC_LIST1,62,17,65,197,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LISTBOX         IDC_LIST2,0,0,0,0,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+END
+
+IDD_DIALOG2 DIALOG DISCARDABLE  0, 0, 185, 69
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "About KMESP"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,69,50,50,14
+    LTEXT           "KMESP v1.0",38,88,12,70,7
+    LTEXT           "Copyright (c) 1995 Microsoft Corporation",70,24,30,160,
+                    12
+    ICON            IDI_ICON1,IDC_STATIC1,60,5,18,20
+END
+
+IDD_DIALOG3 DIALOG DISCARDABLE  0, 0, 205, 192
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+FONT 8, "MS Sans Serif"
+BEGIN
+    LTEXT           "Parameters:",55,4,6,42,7
+    LISTBOX         IDC_LIST1,4,16,100,148,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Value:",56,116,6,30,7
+    COMBOBOX        IDC_COMBO1,116,16,80,47,CBS_SIMPLE | CBS_AUTOHSCROLL |
+                    CBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    LTEXT           "Bit flags:",57,116,66,40,9
+    LISTBOX         IDC_LIST2,116,75,80,89,LBS_MULTIPLESEL | 
+                    LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "OK",IDOK,116,171,36,14
+    PUSHBUTTON      "Cancel",IDCANCEL,160,171,37,14
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MENU1 MENU DISCARDABLE
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "Register provider",                   IDM_REGISTER
+        MENUITEM "Deregister provider",                 IDM_DEREGISTER
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                               IDM_EXIT
+    END
+    POPUP "&Options"
+    BEGIN
+        MENUITEM "&Outgoing call state progress...",    IDM_OUTCALLSTATEPROG
+        MENUITEM SEPARATOR
+        POPUP "Complete async requests"
+        BEGIN
+            MENUITEM "Synchronously",                   IDM_SYNCCOMPL
+            MENUITEM "Asynchronously",                  IDM_ASYNCCOMPL
+            MENUITEM "Manually",                        IDM_MANUALCOMPL
+        END
+        MENUITEM "User-specified request results",      IDM_MANUALRESULTS
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Using KMESP...",                     IDM_USAGE
+        MENUITEM SEPARATOR
+        MENUITEM "&About...",                           IDM_ABOUT
+    END
+END
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+IDI_ICON1               ICON    DISCARDABLE     "KMESP.ICO"
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+IDR_ACCELERATOR1 ACCELERATORS DISCARDABLE
+BEGIN
+    VK_F1,     IDC_F1HELP,   VIRTKEY
+    VK_TAB,    IDC_PREVCTRL, VIRTKEY, SHIFT
+    VK_TAB,    IDC_NEXTCTRL, VIRTKEY
+    VK_RETURN, IDC_ENTER,    VIRTKEY
+END
+
+
+#ifndef APSTUDIO_INVOKED
+////////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
diff --git a/private/tapi/dev/sp/kmesp/exe/makefile b/private/tapi/dev/sp/kmesp/exe/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/kmesp/exe/resource.h b/private/tapi/dev/sp/kmesp/exe/resource.h
new file mode 100644
index 000000000..45cab7e79
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/resource.h
@@ -0,0 +1,49 @@
+//{{NO_DEPENDENCIES}}
+// App Studio generated include file.
+// Used by ESP.RC
+//
+#define IDD_DIALOG1                     101
+#define IDD_DIALOG2                     102
+#define IDD_DIALOG3                     103
+#define IDR_MENU1                       104
+#define IDI_ICON1                       105
+#define IDR_ACCELERATOR1                106
+#define IDC_LIST1                       1000
+#define IDC_LIST2                       1001
+#define IDC_LIST3                       1002
+#define IDC_EDIT1                       1003
+#define IDC_STATIC1                     1004
+#define IDC_BUTTON1                     1005
+#define IDC_BUTTON2                     1006
+#define IDC_BUTTON3                     1007
+#define IDC_COMBO1                      1008
+#define IDC_F1HELP                      1009
+#define IDC_PREVCTRL                    1010
+#define IDC_NEXTCTRL                    1011
+#define IDC_ENTER                       1012
+#define IDM_ABOUT                       40000
+#define IDM_EXIT                        40001
+#define IDM_DEFAULTS                    40002
+#define IDM_OUTCALLSTATEPROG            40003
+#define IDM_INSTALL                     40004
+#define IDM_UNINSTALL                   40005
+#define IDM_USAGE                       40006
+#define IDM_DUMPGLOBALS                 40007
+#define IDM_SYNCCOMPL                   40008
+#define IDM_ASYNCCOMPL                  40009
+#define IDM_MANUALCOMPL                 40010
+#define IDM_MANUALRESULTS               40011
+#define IDM_REGISTER                    40012
+#define IDM_DEREGISTER                  40013
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+
+#define _APS_NEXT_RESOURCE_VALUE        107
+#define _APS_NEXT_COMMAND_VALUE         40014
+#define _APS_NEXT_CONTROL_VALUE         1013
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/sp/kmesp/exe/sources b/private/tapi/dev/sp/kmesp/exe/sources
new file mode 100644
index 000000000..534eb3023
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/exe/sources
@@ -0,0 +1,48 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=kmesp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc;$(BASEDIR)\private\ntos\inc;$(BASEDIR)\private\ntos\ndis\ndistapi
+
+USE_CRTDLL=1
+
+SOURCES=kmesp.c \
+        kmesp.rc
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/kmesp/sys/intrface.h b/private/tapi/dev/sp/kmesp/sys/intrface.h
new file mode 100644
index 000000000..ad481827b
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/intrface.h
@@ -0,0 +1,138 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    intrface.h
+
+Abstract:
+
+
+Environment:
+
+    Kernel & user mode
+
+Revision History:
+
+--*/
+
+
+//
+//
+//
+
+#define RT_REGISTER             1
+#define RT_DEREGISTER           2
+#define RT_COMPLETEREQUEST      3
+#define RT_SYNCCOMPLETIONS      4
+#define RT_ASYNCCOMPLETIONS     5
+#define RT_INCOMINGCALL         6
+#define RT_EVENT                7
+
+#define ET_REQUEST              1
+
+
+//
+// Define the various device type values.  Note that values used by Microsoft
+// Corporation are in the range 0-32767, and 32768-65535 are reserved for use
+// by customers.
+//
+
+#define FILE_DEVICE_STUBMP  0x00008300
+
+
+
+//
+// Macro definition for defining IOCTL and FSCTL function control codes.  Note
+// that function codes 0-2047 are reserved for Microsoft Corporation, and
+// 2048-4095 are reserved for customers.
+//
+
+#define STUBMP_IOCTL_INDEX  0x830
+
+
+
+//
+// IOCTL defs
+//
+
+#define IOCTL_STUBMP_APPREQUEST       CTL_CODE(FILE_DEVICE_STUBMP,      \
+                                               STUBMP_IOCTL_INDEX,      \
+                                               METHOD_BUFFERED,         \
+                                               FILE_ANY_ACCESS)
+
+#define IOCTL_STUBMP_GETEVENTS        CTL_CODE(FILE_DEVICE_STUBMP,      \
+                                               STUBMP_IOCTL_INDEX+1,    \
+                                               METHOD_BUFFERED,         \
+                                               FILE_ANY_ACCESS)
+
+
+//
+// From ntddndis.h
+//
+
+#define OID_TAPI_ACCEPT                     0x07030101
+#define OID_TAPI_ANSWER                     0x07030102
+#define OID_TAPI_CLOSE                      0x07030103
+#define OID_TAPI_CLOSE_CALL                 0x07030104
+#define OID_TAPI_CONDITIONAL_MEDIA_DETECTION 0x07030105
+#define OID_TAPI_CONFIG_DIALOG              0x07030106
+#define OID_TAPI_DEV_SPECIFIC               0x07030107
+#define OID_TAPI_DIAL                       0x07030108
+#define OID_TAPI_DROP                       0x07030109
+#define OID_TAPI_GET_ADDRESS_CAPS           0x0703010A
+#define OID_TAPI_GET_ADDRESS_ID             0x0703010B
+#define OID_TAPI_GET_ADDRESS_STATUS         0x0703010C
+#define OID_TAPI_GET_CALL_ADDRESS_ID        0x0703010D
+#define OID_TAPI_GET_CALL_INFO              0x0703010E
+#define OID_TAPI_GET_CALL_STATUS            0x0703010F
+#define OID_TAPI_GET_DEV_CAPS               0x07030110
+#define OID_TAPI_GET_DEV_CONFIG             0x07030111
+#define OID_TAPI_GET_EXTENSION_ID           0x07030112
+#define OID_TAPI_GET_ID                     0x07030113
+#define OID_TAPI_GET_LINE_DEV_STATUS        0x07030114
+#define OID_TAPI_MAKE_CALL                  0x07030115
+#define OID_TAPI_NEGOTIATE_EXT_VERSION      0x07030116
+#define OID_TAPI_OPEN                       0x07030117
+#define OID_TAPI_PROVIDER_INITIALIZE        0x07030118
+#define OID_TAPI_PROVIDER_SHUTDOWN          0x07030119
+#define OID_TAPI_SECURE_CALL                0x0703011A
+#define OID_TAPI_SELECT_EXT_VERSION         0x0703011B
+#define OID_TAPI_SEND_USER_USER_INFO        0x0703011C
+#define OID_TAPI_SET_APP_SPECIFIC           0x0703011D
+#define OID_TAPI_SET_CALL_PARAMS            0x0703011E
+#define OID_TAPI_SET_DEFAULT_MEDIA_DETECTION 0x0703011F
+#define OID_TAPI_SET_DEV_CONFIG             0x07030120
+#define OID_TAPI_SET_MEDIA_MODE             0x07030121
+#define OID_TAPI_SET_STATUS_MESSAGES        0x07030122
+
+
+typedef struct _REQUESTBLOCK
+{
+    ULONG   ulRequestType;
+
+    char    Data[1];
+
+} REQUESTBLOCK, *PREQUESTBLOCK;
+
+
+typedef struct _REQUEST_PARAMS
+{
+    ULONG       ulRequestType;
+
+    ULONG       bNeedsCompleting;
+
+    ULONG       pNdisRequest;
+
+    ULONG       Status;
+
+    ULONG       Oid;
+
+    ULONG       RequestID;
+
+    ULONG       hWidget;
+
+    ULONG       ulRequestSpecific;
+
+} REQUEST_PARAMS, *PREQUEST_PARAMS;
diff --git a/private/tapi/dev/sp/kmesp/sys/makefile b/private/tapi/dev/sp/kmesp/sys/makefile
new file mode 100644
index 000000000..58189757d
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/makefile
@@ -0,0 +1,7 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the driver components of the Windows NT DDK
+#
+
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/kmesp/sys/sources b/private/tapi/dev/sp/kmesp/sys/sources
new file mode 100644
index 000000000..7e06f7bbb
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/sources
@@ -0,0 +1,34 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+TARGETNAME=stubmp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DRIVER
+
+INCLUDES=$(BASEDIR)\private\ntos\inc
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\ndistapi.lib
+
+SOURCES=stubmp.c
diff --git a/private/tapi/dev/sp/kmesp/sys/stubmp.c b/private/tapi/dev/sp/kmesp/sys/stubmp.c
new file mode 100644
index 000000000..690c14899
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/stubmp.c
@@ -0,0 +1,1465 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    stubmp.c
+
+Abstract:
+
+
+
+Author:
+
+    Dan Knudson (DanKn)    11-Apr-1995
+
+Environment:
+
+    kernel mode only
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+#include "ntddk.h"
+//#include "ntos.h"
+#include "ndismain.h"
+#include "stdarg.h"
+#include "stdio.h"
+#include "ndistapi.h"
+#include "stubmp.h"
+#include "intrface.h"
+
+
+
+PDEVICE_EXTENSION DeviceExtension;
+
+
+#ifdef DBG
+
+//ULONG StubmpDebugLevel = 3;
+ULONG StubmpDebugLevel = 0;
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN ULONG  DbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
+
+
+NTSTATUS
+StubmpDispatch(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PIRP Irp
+    );
+
+NDIS_STATUS
+StubmpRequest(
+    NDIS_HANDLE     NdisBindingHandle,
+    PNDIS_REQUEST   NdisRequest
+    );
+
+VOID
+StubmpUnload(
+    IN PDRIVER_OBJECT DriverObject
+    );
+
+VOID
+StubmpCancel(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PIRP Irp
+    );
+
+VOID
+WriteRingBuffer(
+    IN  PVOID   StatusBuffer,
+    IN  UINT    StatusBufferSize
+    );
+
+
+NTSTATUS
+DriverEntry(
+    IN PDRIVER_OBJECT  DriverObject,
+    IN PUNICODE_STRING RegistryPath
+    )
+/*++
+
+Routine Description:
+
+    Installable driver initialization entry point.
+    This entry point is called directly by the I/O system.
+
+Arguments:
+
+    DriverObject - pointer to the driver object
+
+    RegistryPath - pointer to a unicode string representing the path
+                   to driver-specific key in the registry
+
+Return Value:
+
+    STATUS_SUCCESS if successful,
+    STATUS_UNSUCCESSFUL otherwise
+
+--*/
+{
+    ULONG           i, ulNumLines       = 4,
+                    ulNumAddrsPerLine   = 4,
+                    ulNumCallsPerLine   = 4;
+    PDEVICE_OBJECT  deviceObject        = NULL;
+    NTSTATUS        ntStatus;
+    WCHAR           deviceNameBuffer[]  = L"\\Device\\Stubmp";
+    UNICODE_STRING  deviceNameUnicodeString;
+    WCHAR           deviceLinkBuffer[]  = L"\\DosDevices\\Stubmp";
+    UNICODE_STRING  deviceLinkUnicodeString;
+
+
+    DBGOUT ((2, "DriverEntry: enter"));
+
+
+    //
+    // Create an EXCLUSIVE device, i.e. only 1 thread at a time can send
+    // i/o requests.
+    //
+
+    RtlInitUnicodeString (&deviceNameUnicodeString, deviceNameBuffer);
+
+    ntStatus = IoCreateDevice(
+        DriverObject,
+        sizeof(DEVICE_EXTENSION) + (ulNumLines - 1) * sizeof(PDRVLINE),
+        &deviceNameUnicodeString,
+        FILE_DEVICE_STUBMP,
+        0,
+        FALSE,          // not exclusive
+        &deviceObject
+        );
+
+    if (NT_SUCCESS(ntStatus))
+    {
+        ULONG   numBytesPerLine = sizeof(DRVLINE) +
+                    (ulNumCallsPerLine - 1) * sizeof(DRVCALL);
+
+        DeviceExtension = (PDEVICE_EXTENSION)
+            deviceObject->DeviceExtension;
+
+        RtlZeroMemory (DeviceExtension, sizeof (DEVICE_EXTENSION));
+
+        DeviceExtension->CompleteAsync     = TRUE;
+
+        DeviceExtension->ulNumLines        = ulNumLines;
+        DeviceExtension->ulNumAddrsPerLine = ulNumAddrsPerLine;
+        DeviceExtension->ulNumCallsPerLine = ulNumCallsPerLine;
+
+
+        KeInitializeSpinLock (&DeviceExtension->EventSpinLock);
+
+        DeviceExtension->EventDataQueueLength = 1024;
+
+        DeviceExtension->EventDataQueue =
+        DeviceExtension->DataIn =
+        DeviceExtension->DataOut = ExAllocatePoolWithTag(
+                NonPagedPool,
+                DeviceExtension->EventDataQueueLength,
+                'TAPI'
+                );
+
+
+        //
+        //
+        //
+
+        for (i = 0; i < ulNumLines; i++)
+        {
+            DeviceExtension->apLines[i] = ExAllocatePoolWithTag(
+                NonPagedPool,
+                numBytesPerLine,
+                'TAPI'
+                );
+
+            RtlZeroMemory (DeviceExtension->apLines[i], numBytesPerLine);
+        }
+
+
+        //
+        // Create a symbolic link that Win32 apps can specify to gain access
+        // to this driver/device
+        //
+
+        RtlInitUnicodeString (&deviceLinkUnicodeString, deviceLinkBuffer);
+
+        ntStatus = IoCreateSymbolicLink(
+            &deviceLinkUnicodeString,
+            &deviceNameUnicodeString
+            );
+
+        if (!NT_SUCCESS(ntStatus))
+        {
+            DBGOUT ((0, "DriverEntry: IoCreateSymbolicLink failed"));
+        }
+
+
+
+        //
+        // Init dispatch points for device control, create, close.
+        //
+
+        DriverObject->MajorFunction[IRP_MJ_CREATE]         =
+        DriverObject->MajorFunction[IRP_MJ_CLOSE]          =
+        DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = StubmpDispatch;
+        DriverObject->DriverUnload                         = StubmpUnload;
+    }
+
+
+done_DriverEntry:
+
+    if (!NT_SUCCESS(ntStatus))
+    {
+        //
+        // Something went wrong, so clean up (free resources, etc.)
+        //
+
+        if (deviceObject)
+        {
+            IoDeleteDevice (deviceObject);
+        }
+    }
+
+    return ntStatus;
+}
+
+
+
+NTSTATUS
+StubmpDispatch(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PIRP           Irp
+    )
+/*++
+
+Routine Description:
+
+    Process the IRPs sent to this device.
+
+Arguments:
+
+    DeviceObject - pointer to a device object
+
+    Irp          - pointer to an I/O Request Packet
+
+Return Value:
+
+
+--*/
+{
+
+    PVOID   ioBuffer;
+    ULONG   inputBufferLength;
+    ULONG   outputBufferLength;
+    ULONG   ioControlCode;
+    NTSTATUS    ntStatus;
+    NDIS_TAPI_EVENT event;
+    PIO_STACK_LOCATION  irpStack;
+
+
+    Irp->IoStatus.Status      = STATUS_SUCCESS;
+    Irp->IoStatus.Information = 0;
+
+
+    //
+    // Get a pointer to the current location in the Irp. This is where
+    //     the function codes and parameters are located.
+    //
+
+    irpStack = IoGetCurrentIrpStackLocation (Irp);
+
+
+
+    //
+    // Get the pointer to the input/output buffer and it's length
+    //
+
+    ioBuffer           = Irp->AssociatedIrp.SystemBuffer;
+    inputBufferLength  =
+        irpStack->Parameters.DeviceIoControl.InputBufferLength;
+    outputBufferLength =
+        irpStack->Parameters.DeviceIoControl.OutputBufferLength;
+
+
+
+    switch (irpStack->MajorFunction)
+    {
+    case IRP_MJ_CREATE:
+
+        DBGOUT ((2, "IRP_MJ_CREATE"));
+
+        break;
+
+    case IRP_MJ_CLOSE:
+
+        DBGOUT ((2, "IRP_MJ_CLOSE"));
+
+        break;
+
+    case IRP_MJ_DEVICE_CONTROL:
+
+        ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
+
+        switch (ioControlCode)
+        {
+        case IOCTL_STUBMP_APPREQUEST:
+        {
+            PREQUESTBLOCK pRequestBlock = (PREQUESTBLOCK) ioBuffer;
+
+
+            DBGOUT ((2, "IOCTL_STUBMP_APPREQUEST"));
+
+            switch (pRequestBlock->ulRequestType)
+            {
+            case RT_REGISTER:
+
+                NdisTapiRegisterProvider(
+                    (NDIS_HANDLE) 0x55,
+                    (REQUEST_PROC) StubmpRequest
+                    );
+
+                break;
+
+            case RT_DEREGISTER:
+
+                NdisTapiDeregisterProvider ((NDIS_HANDLE) 0x55);
+
+                break;
+
+            case RT_COMPLETEREQUEST:
+            {
+                ULONG *args = (ULONG *) (pRequestBlock->Data);
+
+
+                DBGOUT ((2, "completing req x%x", *args));
+
+                NdisTapiCompleteRequest(
+                    (NDIS_HANDLE) 0x55,
+                    (PNDIS_REQUEST) *args,
+                    (NDIS_STATUS) *(args + 1)
+                    );
+
+                break;
+            }
+            case RT_SYNCCOMPLETIONS:
+
+                DeviceExtension->CompleteAsync = FALSE;
+                break;
+
+            case RT_ASYNCCOMPLETIONS:
+
+                DeviceExtension->CompleteAsync = TRUE;
+                break;
+
+            case RT_INCOMINGCALL:
+
+                //BUGBUG
+                break;
+
+            case RT_EVENT:
+
+                //BUGBUG
+                break;
+
+            default:
+
+                break;
+            }
+
+            break;
+        }
+        case IOCTL_STUBMP_GETEVENTS:
+        {
+            KIRQL   oldIrql;
+            KIRQL   cancelIrql;
+            BOOLEAN satisfiedRequest = FALSE;
+
+
+            //
+            // Sync event buf access by acquiring EventSpinLock
+            //
+
+            KeAcquireSpinLock (&DeviceExtension->EventSpinLock, &oldIrql);
+
+
+            //
+            // Inspect DeviceExtension to see if there's any data available
+            //
+
+            DBGOUT((
+                2,
+                "IOCTL_STUBMP_GETEVENTS, Irp=x%x, bytesInQ=x%x",
+                Irp,
+                DeviceExtension->BytesInQueue
+                ));
+
+            if (DeviceExtension->BytesInQueue != 0)
+            {
+                ULONG   bytesInQueue;
+                ULONG   bytesToMove;
+                ULONG   moveSize;
+                PCHAR   EventBuffer = (PCHAR) ((ULONG *) ioBuffer + 1);
+
+
+                bytesInQueue = DeviceExtension->BytesInQueue;
+
+                bytesToMove = *((ULONG *) ioBuffer);
+
+                bytesToMove = (bytesInQueue < bytesToMove) ? bytesInQueue : bytesToMove;
+
+
+                //
+                // moveSize <- MIN(Number of bytes to be moved from the event data queue,
+                //                 Number of bytes to end of event data queue).
+                //
+
+                bytesInQueue =
+                    ((PCHAR) DeviceExtension->EventDataQueue +
+                     DeviceExtension->EventDataQueueLength) -
+                    (PCHAR) DeviceExtension->DataOut;
+
+                moveSize = (bytesToMove < bytesInQueue) ? bytesToMove : bytesInQueue;
+
+
+                //
+                // Move bytes from the class input data queue to SystemBuffer, until
+                // the request is satisfied or we wrap the class input data buffer.
+                //
+
+                RtlMoveMemory(
+                    EventBuffer,
+                    (PCHAR) DeviceExtension->DataOut,
+                    moveSize
+                    );
+
+                EventBuffer += moveSize;
+
+
+                //
+                // If the data wraps in the event data buffer, copy the rest
+                // of the data from the start of the input data queue
+                // buffer through the end of the queued data.
+                //
+
+                if ((bytesToMove - moveSize) > 0)
+                {
+                    //
+                    // moveSize <- Remaining number bytes to move.
+                    //
+
+                    moveSize = bytesToMove - moveSize;
+
+                    //
+                    // Move the bytes from the
+                    //
+
+                    RtlMoveMemory(
+                        EventBuffer,
+                        (PCHAR) DeviceExtension->EventDataQueue,
+                        moveSize
+                        );
+
+                    //
+                    // Update the class input data queue removal pointer.
+                    //
+
+                    DeviceExtension->DataOut =
+                        ((PCHAR) DeviceExtension->EventDataQueue) + moveSize;
+                }
+                else
+                {
+                    //
+                    // Update the input data queue removal pointer.
+                    //
+
+                    DeviceExtension->DataOut =
+                        ((PCHAR) DeviceExtension->DataOut) + moveSize;
+                }
+
+
+                //
+                // Update the event data queue EventCount.
+                //
+
+                DeviceExtension->BytesInQueue -= bytesToMove;
+
+
+                //
+                //
+                //
+
+                *((ULONG *) ioBuffer) = bytesToMove;
+
+
+                //
+                //
+                //
+
+                Irp->IoStatus.Status      = STATUS_SUCCESS;
+                Irp->IoStatus.Information = sizeof(ULONG) + bytesToMove;
+
+                satisfiedRequest = TRUE;
+            }
+            else
+            {
+                //
+                // Hold the request pending.  It remains in the cancelable
+                // state.  When new line event input is received
+                // (NdisTapiIndicateStatus) or generated (i.e.
+                // LINEDEVSTATE_REINIT) the data will get copied & the
+                // request completed.
+                //
+
+                DeviceExtension->EventsRequestIrp = Irp;
+
+                Irp->IoStatus.Status = STATUS_PENDING;
+
+                IoAcquireCancelSpinLock (&cancelIrql);
+                IoSetCancelRoutine (Irp, StubmpCancel);
+                IoReleaseCancelSpinLock (cancelIrql);
+            }
+
+            KeReleaseSpinLock (&DeviceExtension->EventSpinLock, oldIrql);
+
+
+            //
+            // If request not satisfied just return pending
+            //
+
+            if (!satisfiedRequest)
+            {
+                return STATUS_PENDING;
+            }
+
+            break;
+        }
+        default:
+
+            Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
+
+            DBGOUT ((2, "unknown IRP_MJ_DEVICE_CONTROL"));
+
+            break;
+
+        }
+
+        break;
+    }
+
+
+    //
+    // DON'T get cute and try to use the status field of
+    // the irp in the return status.  That IRP IS GONE as
+    // soon as you call IoCompleteRequest.
+    //
+
+    ntStatus = Irp->IoStatus.Status;
+
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+
+    //
+    // We never have pending operation so always return the status code.
+    //
+
+    return ntStatus;
+}
+
+
+PDRVLINE
+GetpLine(
+    HDRV_LINE   hdLine
+    )
+{
+    return (DeviceExtension->apLines
+        [(ULONG) hdLine - DeviceExtension->DeviceIDBase]);
+
+}
+
+
+NDIS_STATUS
+StubmpRequest(
+    NDIS_HANDLE     NdisBindingHandle,
+    PNDIS_REQUEST   NdisRequest
+    )
+{
+    BOOLEAN         completeAsync = DeviceExtension->CompleteAsync;
+    ULONG           i, j, ulRequestSpecific = 0;
+    NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
+    NDIS_TAPI_EVENT event;
+
+
+    //
+    // Handle the request
+    //
+
+    if (NdisRequest->RequestType == NdisRequestQueryInformation)
+    {
+        switch (NdisRequest->DATA.QUERY_INFORMATION.Oid)
+        {
+        case OID_TAPI_CONFIG_DIALOG:
+        {
+            PNDIS_TAPI_CONFIG_DIALOG pConfigDialog =
+                (PNDIS_TAPI_CONFIG_DIALOG)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_DEV_SPECIFIC:
+        {
+            PNDIS_TAPI_DEV_SPECIFIC pDevSpecific =
+                (PNDIS_TAPI_DEV_SPECIFIC)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_ADDRESS_CAPS:
+        {
+            PNDIS_TAPI_GET_ADDRESS_CAPS pGetAddressCaps =
+                (PNDIS_TAPI_GET_ADDRESS_CAPS)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_ADDRESS_ID:
+        {
+            PNDIS_TAPI_GET_ADDRESS_ID pGetAddressID =
+                (PNDIS_TAPI_GET_ADDRESS_ID)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_ADDRESS_STATUS:
+        {
+            PNDIS_TAPI_GET_ADDRESS_STATUS pGetAddressStatus =
+                (PNDIS_TAPI_GET_ADDRESS_STATUS)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_CALL_ADDRESS_ID:
+        {
+            PNDIS_TAPI_GET_CALL_ADDRESS_ID pGetCallAddressID =
+                (PNDIS_TAPI_GET_CALL_ADDRESS_ID)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_CALL_INFO:
+        {
+            PNDIS_TAPI_GET_CALL_INFO pGetCallInfo =
+                (PNDIS_TAPI_GET_CALL_INFO)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_CALL_STATUS:
+        {
+            PNDIS_TAPI_GET_CALL_STATUS pGetCallStatus =
+                (PNDIS_TAPI_GET_CALL_STATUS)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_DEV_CAPS:
+        {
+            PNDIS_TAPI_GET_DEV_CAPS pGetDevCaps = (PNDIS_TAPI_GET_DEV_CAPS)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_DEV_CONFIG:
+        {
+            PNDIS_TAPI_GET_DEV_CONFIG pGetDevConfig =
+                (PNDIS_TAPI_GET_DEV_CONFIG)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_EXTENSION_ID:
+        {
+            PNDIS_TAPI_GET_EXTENSION_ID pGetExtensionID =
+                (PNDIS_TAPI_GET_EXTENSION_ID)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_ID:
+        {
+            PNDIS_TAPI_GET_ID pGetID = (PNDIS_TAPI_GET_ID)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_GET_LINE_DEV_STATUS:
+        {
+            PNDIS_TAPI_GET_LINE_DEV_STATUS pGetLineDevStatus =
+                (PNDIS_TAPI_GET_LINE_DEV_STATUS)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_MAKE_CALL:
+        {
+            PNDIS_TAPI_MAKE_CALL pMakeCall = (PNDIS_TAPI_MAKE_CALL)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+            PDRVLINE pLine = GetpLine (pMakeCall->hdLine);
+
+
+            for (i = 0; i < DeviceExtension->ulNumCallsPerLine; i++)
+            {
+                if (!pLine->aCalls[i].htCall)
+                {
+                    pLine->aCalls[i].htCall = pMakeCall->htCall;
+                    pLine->aCalls[i].pLine = pLine;
+
+                    pMakeCall->hdCall = (HDRV_CALL) (pLine->aCalls + i);
+
+                    break;
+                }
+            }
+
+            if (i == DeviceExtension->ulNumCallsPerLine)
+            {
+                status = NDIS_STATUS_TAPI_CALLUNAVAIL;
+            }
+
+            ulRequestSpecific = (ULONG) (pLine->aCalls + i);
+
+            break;
+        }
+        case OID_TAPI_NEGOTIATE_EXT_VERSION:
+        {
+            PNDIS_TAPI_NEGOTIATE_EXT_VERSION pNegotiateExtVersion =
+                (PNDIS_TAPI_NEGOTIATE_EXT_VERSION)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_OPEN:
+        {
+            PNDIS_TAPI_OPEN pOpen = (PNDIS_TAPI_OPEN)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+            PDRVLINE pLine = DeviceExtension->apLines
+                [pOpen->ulDeviceID - DeviceExtension->DeviceIDBase];
+
+
+            ulRequestSpecific =
+            pLine->htLine     = pOpen->htLine;
+
+            pOpen->hdLine = (HDRV_LINE) pOpen->ulDeviceID;
+
+            break;
+        }
+        case OID_TAPI_PROVIDER_INITIALIZE:
+        {
+            PNDIS_TAPI_PROVIDER_INITIALIZE pInitialize =
+                (PNDIS_TAPI_PROVIDER_INITIALIZE)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+
+
+            DeviceExtension->DeviceIDBase = pInitialize->ulDeviceIDBase;
+
+            for (i = 0; i < DeviceExtension->ulNumLines; i++)
+            {
+                DeviceExtension->apLines[i]->ulDeviceID =
+                    pInitialize->ulDeviceIDBase + i;
+
+                for (j = 0; j < DeviceExtension->ulNumCallsPerLine; j++)
+                {
+                    DeviceExtension->apLines[i]->aCalls[j].htCall =
+                        (HTAPI_CALL) NULL;
+                }
+            }
+
+            ulRequestSpecific =
+            pInitialize->ulNumLineDevs = DeviceExtension->ulNumLines;
+
+            break;
+        }
+        default:
+
+            break;
+
+        } // switch
+
+
+        //
+        // Send info about this request to the app
+        //
+
+        {
+            ULONG  *args = (ULONG *)
+                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer;
+            ULONG   requestData[8] =
+            {
+                ET_REQUEST,
+                (ULONG) completeAsync,
+                (ULONG) NdisRequest,
+                (ULONG) status,
+                (ULONG) NdisRequest->DATA.QUERY_INFORMATION.Oid,
+                *args,
+                *(args+1),
+                ulRequestSpecific
+            };
+
+
+            WriteRingBuffer (requestData, 8 * sizeof(ULONG));
+        }
+    }
+
+    else if (NdisRequest->RequestType == NdisRequestSetInformation)
+    {
+        switch (NdisRequest->DATA.SET_INFORMATION.Oid)
+        {
+        case OID_TAPI_ACCEPT:
+        {
+            PNDIS_TAPI_ACCEPT pAccept = (PNDIS_TAPI_ACCEPT)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_ANSWER:
+        {
+            PNDIS_TAPI_ANSWER pAnswer = (PNDIS_TAPI_ANSWER)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_CLOSE:
+        {
+            PNDIS_TAPI_CLOSE pClose = (PNDIS_TAPI_CLOSE)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+            PDRVLINE pLine = GetpLine (pClose->hdLine);
+
+
+            pLine->htLine = 0;
+
+            break;
+        }
+        case OID_TAPI_CLOSE_CALL:
+        {
+            PNDIS_TAPI_CLOSE_CALL pCloseCall = (PNDIS_TAPI_CLOSE_CALL)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+            PDRVCALL pCall = (PDRVCALL) pCloseCall->hdCall;
+
+
+            pCall->htCall = (HTAPI_CALL) NULL;
+
+            break;
+        }
+        case OID_TAPI_CONDITIONAL_MEDIA_DETECTION:
+        {
+            PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION pConditionalMediaDetection =
+                (PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_DIAL:
+        {
+            PNDIS_TAPI_DIAL pDial = (PNDIS_TAPI_DIAL)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_DROP:
+        {
+            PNDIS_TAPI_DROP pDrop = (PNDIS_TAPI_DROP)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_PROVIDER_SHUTDOWN:
+        {
+            PNDIS_TAPI_PROVIDER_SHUTDOWN pShutdown =
+                (PNDIS_TAPI_PROVIDER_SHUTDOWN)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SECURE_CALL:
+        {
+            PNDIS_TAPI_SECURE_CALL pSecureCall = (PNDIS_TAPI_SECURE_CALL)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SELECT_EXT_VERSION:
+        {
+            PNDIS_TAPI_SELECT_EXT_VERSION pSelectExtVersion =
+                (PNDIS_TAPI_SELECT_EXT_VERSION)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SEND_USER_USER_INFO:
+        {
+            PNDIS_TAPI_SEND_USER_USER_INFO pSendUserUserInfo =
+                (PNDIS_TAPI_SEND_USER_USER_INFO)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SET_APP_SPECIFIC:
+        {
+            PNDIS_TAPI_SET_APP_SPECIFIC pSetApSpecific =
+                (PNDIS_TAPI_SET_APP_SPECIFIC)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SET_CALL_PARAMS:
+        {
+            PNDIS_TAPI_SET_CALL_PARAMS pSetCallParams =
+                (PNDIS_TAPI_SET_CALL_PARAMS)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SET_DEFAULT_MEDIA_DETECTION:
+        {
+            PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION pSetDefaultMediaDetection =
+                (PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SET_DEV_CONFIG:
+        {
+            PNDIS_TAPI_SET_DEV_CONFIG pSetDevConfig =
+                (PNDIS_TAPI_SET_DEV_CONFIG)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SET_MEDIA_MODE:
+        {
+            PNDIS_TAPI_SET_MEDIA_MODE pSetMediaMode =
+                (PNDIS_TAPI_SET_MEDIA_MODE)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        case OID_TAPI_SET_STATUS_MESSAGES:
+        {
+            PNDIS_TAPI_SET_STATUS_MESSAGES pSetStatusMessages =
+                (PNDIS_TAPI_SET_STATUS_MESSAGES)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+
+
+            break;
+        }
+        default:
+
+            break;
+
+        } // switch
+
+
+        //
+        // Send info about this request to the app
+        //
+
+        {
+            ULONG  *args = (ULONG *)
+                NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
+            REQUEST_PARAMS requestParams =
+            {
+                ET_REQUEST,
+                (ULONG) completeAsync,
+                (ULONG) NdisRequest,
+                (ULONG) status,
+                (ULONG) NdisRequest->DATA.SET_INFORMATION.Oid,
+                *args,
+                *(args+1),
+                ulRequestSpecific
+            };
+
+
+            WriteRingBuffer (&requestParams, sizeof(REQUEST_PARAMS));
+        }
+    }
+    else
+    {
+        DBGOUT((1, "StubmpRequest: unknown NdisRequest->RequestType"));
+    }
+
+
+    if (completeAsync)
+    {
+        status = NDIS_STATUS_PENDING;
+
+        DBGOUT((2, "StubmpRequest: Req x%x pending", NdisRequest));
+    }
+    else
+    {
+        DBGOUT((2, "StubmpRequest: Req x%x completing sync", NdisRequest));
+    }
+
+    return status;
+}
+
+
+
+VOID
+StubmpUnload(
+    IN PDRIVER_OBJECT DriverObject
+    )
+/*++
+
+Routine Description:
+
+    Free all the allocated resources, etc.
+
+Arguments:
+
+    DriverObject - pointer to a driver object
+
+Return Value:
+
+
+--*/
+{
+    ULONG           i;
+    WCHAR           deviceLinkBuffer[]  = L"\\DosDevices\\Stubmp";
+    UNICODE_STRING  deviceLinkUnicodeString;
+
+
+    DBGOUT ((2, "StubmpUnload: enter"));
+
+
+    //
+    // Delete the symbolic link
+    //
+
+    RtlInitUnicodeString (&deviceLinkUnicodeString,
+                          deviceLinkBuffer
+                          );
+
+    IoDeleteSymbolicLink (&deviceLinkUnicodeString);
+
+
+    //
+    // Free all the resources
+    //
+
+    for (i = 0; i < DeviceExtension->ulNumLines; i++)
+    {
+        ExFreePool (DeviceExtension->apLines[i]);
+    }
+
+
+    //
+    // Delete the device object
+    //
+
+    IoDeleteDevice (DriverObject->DeviceObject);
+}
+
+
+VOID
+StubmpCancel(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PIRP Irp
+    )
+{
+    KIRQL   oldIrql;
+
+
+    DBGOUT((2,"StubmpCancel: enter"));
+
+
+    //
+    // Release the cancel spinlock
+    //
+
+    IoReleaseCancelSpinLock (Irp->CancelIrql);
+
+
+    //
+    // Acquire the EventSpinLock & check to see if we're canceling a
+    // pending get-events Irp
+    //
+
+    KeAcquireSpinLock (&DeviceExtension->EventSpinLock, &oldIrql);
+
+    if (Irp == DeviceExtension->EventsRequestIrp)
+    {
+        DeviceExtension->EventsRequestIrp = NULL;
+    }
+
+    KeReleaseSpinLock (&DeviceExtension->EventSpinLock, oldIrql);
+
+
+StubmpCancel_done:
+
+    //
+    // Complete the request with STATUS_CANCELLED.
+    //
+
+    Irp->IoStatus.Status      = STATUS_CANCELLED;
+    Irp->IoStatus.Information = 0;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+    DBGOUT((2,"StubmpCancel: exit (completing irp=x%x)", Irp));
+
+    return;
+}
+
+
+#ifdef DBG
+VOID
+DbgPrt(
+    IN ULONG  DbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (DbgLevel <= StubmpDebugLevel)
+    {
+        char    buf[256] = "STUBMP.SYS: ";
+        va_list ap;
+
+        va_start (ap, DbgMessage);
+
+        vsprintf (&buf[12], DbgMessage, ap);
+
+        strcat (buf, "\n");
+
+        DbgPrint (buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+#endif
+
+
+VOID
+WriteRingBuffer(
+    IN  PVOID   StatusBuffer,
+    IN  UINT    StatusBufferSize
+    )
+/*++
+
+Routine Description:
+
+    This func gets called by Ndis when a miniport driver calls
+    NdisIndicateStatus to notify us of an async event
+    (i.e. new call, call state chg, dev state chg, etc.)
+
+Arguments:
+
+
+
+Return Value:
+
+
+--*/
+
+{
+    PIRP    irp;
+    KIRQL   oldIrql;
+    KIRQL   cancelIrql;
+    ULONG   bytesInQueue;
+    ULONG   bytesToMove;
+    ULONG   moveSize;
+    BOOLEAN satisfiedPendingEventsRequest = FALSE;
+    PCHAR   ioBuffer;
+
+
+    DBGOUT((2,"WriteRingBuffer: enter"));
+
+    bytesInQueue = StatusBufferSize;
+
+    moveSize = 0;
+
+
+    //
+    // Sync event buf access by acquiring EventSpinLock
+    //
+
+    KeAcquireSpinLock (&DeviceExtension->EventSpinLock, &oldIrql);
+
+
+    //
+    // Check of there is an outstanding request to satisfy
+    //
+
+    if (DeviceExtension->EventsRequestIrp)
+    {
+        //
+        // Acquire the cancel spinlock, remove the request from the
+        // cancellable state, and free the cancel spinlock.
+        //
+
+        IoAcquireCancelSpinLock (&cancelIrql);
+        irp = DeviceExtension->EventsRequestIrp;
+        IoSetCancelRoutine (irp, NULL);
+        DeviceExtension->EventsRequestIrp = NULL;
+        IoReleaseCancelSpinLock (cancelIrql);
+
+
+        //
+        // Copy as much of the input data possible from the input data
+        // queue to the SystemBuffer to satisfy the read.
+        //
+
+        ioBuffer = irp->AssociatedIrp.SystemBuffer;
+
+        bytesToMove = *((ULONG *) ioBuffer);
+
+        moveSize = (bytesInQueue < bytesToMove) ? bytesInQueue : bytesToMove;
+
+        RtlMoveMemory (
+            ioBuffer + sizeof(ULONG),
+            (PCHAR) StatusBuffer,
+            moveSize
+            );
+
+
+        //
+        // Set the flag so that we start the next packet and complete
+        // this read request (with STATUS_SUCCESS) prior to return.
+        //
+
+        *((ULONG *) ioBuffer) = moveSize;
+
+        irp->IoStatus.Status = STATUS_SUCCESS;
+
+        irp->IoStatus.Information = sizeof(ULONG) + moveSize;
+
+        satisfiedPendingEventsRequest = TRUE;
+    }
+
+
+    //
+    // If there is still data in the input data queue, move it
+    // to the event data queue
+    //
+
+    StatusBuffer = ((PCHAR) StatusBuffer) + moveSize;
+
+    moveSize = bytesInQueue - moveSize;
+
+    if (moveSize > 0)
+    {
+        //
+        // Move the remaining data from the status data queue to the
+        // event data queue.  The move will happen in two parts in
+        // the case where the event data buffer wraps.
+        //
+
+        bytesInQueue = DeviceExtension->EventDataQueueLength -
+            DeviceExtension->BytesInQueue;
+
+        bytesToMove = moveSize;
+
+        if (bytesInQueue == 0)
+        {
+            //
+            // Refuse to move any bytes that would cause an event data
+            // queue overflow.  Just drop the bytes on the floor, and
+            // log an overrun error.
+            //
+
+            DBGOUT((1,"WriteRingBuffer: event queue overflow"));
+        }
+        else
+        {
+            //
+            // There is room in the event data queue, so move the
+            // remaining status data to it.
+            //
+            // bytesToMove <- MIN(Number of unused bytes in event data queue,
+            //                    Number of bytes remaining in status buffer)
+            //
+            // This is the total number of bytes that actually will move from
+            // the status data buffer to the event data queue.
+            //
+
+            bytesToMove = (bytesInQueue < bytesToMove) ?
+                bytesInQueue : bytesToMove;
+
+
+            //
+            // bytesInQueue <- Number of unused bytes from insertion pointer
+            // to the end of the event data queue (i.e., until the buffer
+            // wraps)
+            //
+
+            bytesInQueue =
+                ((PCHAR) DeviceExtension->EventDataQueue +
+                DeviceExtension->EventDataQueueLength) -
+                (PCHAR) DeviceExtension->DataIn;
+
+
+            //
+            // moveSize <- Number of bytes to handle in the first move.
+            //
+
+            moveSize = (bytesToMove < bytesInQueue) ?
+                bytesToMove : bytesInQueue;
+
+
+            //
+            // Do the move from the status data buffer to the event data queue
+            //
+
+            RtlMoveMemory(
+                (PCHAR) DeviceExtension->DataIn,
+                (PCHAR) StatusBuffer,
+                moveSize
+                );
+
+            //
+            // Increment the event data queue pointer and the status data
+            // buffer insertion pointer.  Wrap the insertion pointer,
+            // if necessary.
+            //
+
+            StatusBuffer = ((PCHAR) StatusBuffer) + moveSize;
+
+            DeviceExtension->DataIn =
+               ((PCHAR) DeviceExtension->DataIn) + moveSize;
+
+            if ((PCHAR) DeviceExtension->DataIn >=
+                ((PCHAR) DeviceExtension->EventDataQueue +
+                 DeviceExtension->EventDataQueueLength))
+            {
+                DeviceExtension->DataIn =
+                    DeviceExtension->EventDataQueue;
+            }
+
+            if ((bytesToMove - moveSize) > 0)
+            {
+                //
+                // Special case.  The data must wrap in the event data
+                // buffer. Copy the rest of the status data into the
+                // beginning of the event data queue.
+                //
+
+                //
+                // moveSize <- Number of bytes to handle in the second move.
+                //
+
+                moveSize = bytesToMove - moveSize;
+
+
+                //
+                // Do the move from the status data buffer to the event data
+                // queue
+                //
+
+                RtlMoveMemory(
+                    (PCHAR) DeviceExtension->DataIn,
+                    (PCHAR) StatusBuffer,
+                    moveSize
+                    );
+
+                //
+                // Update the event data queue insertion pointer
+                //
+
+                DeviceExtension->DataIn =
+                    ((PCHAR) DeviceExtension->DataIn) + moveSize;
+            }
+
+            //
+            // Update the event data queue counter
+            //
+
+            DeviceExtension->BytesInQueue += bytesToMove;
+        }
+    }
+
+
+    //
+    // Release the spinlock
+    //
+
+    KeReleaseSpinLock (&DeviceExtension->EventSpinLock, oldIrql);
+
+
+    //
+    // If we satisfied an outstanding get events request then complete it
+    //
+
+    if (satisfiedPendingEventsRequest)
+    {
+        IoCompleteRequest (irp, IO_NO_INCREMENT);
+
+        DBGOUT((2, "WriteRingBuffer: completing req x%x", irp));
+    }
+
+
+    DBGOUT((2,"WriteRingBuffer: exit"));
+
+    return;
+}
diff --git a/private/tapi/dev/sp/kmesp/sys/stubmp.h b/private/tapi/dev/sp/kmesp/sys/stubmp.h
new file mode 100644
index 000000000..baaa77638
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/stubmp.h
@@ -0,0 +1,109 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    stubmp.h
+
+Abstract:
+
+
+Environment:
+
+    Kernel mode
+
+Revision History:
+
+--*/
+
+
+typedef struct _DRVCALL
+{
+    PVOID       pLine;
+
+    HTAPI_CALL  htCall;
+
+    ULONG       ulAddressID;
+
+    ULONG       ulCallState;
+
+    ULONG       ulMediaMode;
+
+    ULONG       ulAppSpecific;
+
+} DRVCALL, *PDRVCALL;
+
+
+typedef struct _DRVLINE
+{
+    ULONG       ulDeviceID;
+
+    HTAPI_LINE  htLine;
+
+    DRVCALL     aCalls[1];
+
+} DRVLINE, *PDRVLINE;
+
+
+typedef struct _DEVICE_EXTENSION
+{
+    PIRP        EventsRequestIrp;
+
+    KSPIN_LOCK  EventSpinLock;
+
+    PVOID       EventDataQueue;
+
+    ULONG       EventDataQueueLength;
+
+    PVOID       DataIn;
+
+    PVOID       DataOut;
+
+    ULONG       BytesInQueue;
+
+    ULONG       DeviceIDBase;
+
+    BOOLEAN     CompleteAsync;
+
+    ULONG       ulNumLines;
+
+    ULONG       ulNumAddrsPerLine;
+
+    ULONG       ulNumCallsPerLine;
+
+    PDRVLINE    apLines[1];
+
+} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
+
+
+//
+// The following are types/exports from ndistapi.sys
+//
+
+typedef VOID (*REQUEST_PROC)(PNDIS_STATUS, NDIS_HANDLE, PNDIS_REQUEST);
+
+VOID
+NdisTapiRegisterProvider(
+    IN  NDIS_HANDLE     ProviderHandle,
+    IN  REQUEST_PROC    RequestProc
+    );
+
+VOID
+NdisTapiDeregisterProvider(
+    IN  NDIS_HANDLE ProviderHandle
+    );
+
+VOID
+NdisTapiCompleteRequest(
+    IN  NDIS_HANDLE     NdisHandle,
+    IN  PNDIS_REQUEST   NdisRequest,
+    IN  NDIS_STATUS     NdisStatus
+    );
+
+VOID
+NdisTapiIndicateStatus(
+    IN  ULONG   DriverHandle,
+    IN  PVOID   StatusBuffer,
+    IN  UINT    StatusBufferSize
+    );
diff --git a/private/tapi/dev/sp/kmesp/sys/stubmp.ini b/private/tapi/dev/sp/kmesp/sys/stubmp.ini
new file mode 100644
index 000000000..ed306d876
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/stubmp.ini
@@ -0,0 +1,4 @@
+\registry\machine\system\currentcontrolset\services\Stubmp
+    Type = REG_DWORD 0x00000001
+    Start = REG_DWORD 0x00000003
+    ErrorControl = REG_DWORD 0x00000001
diff --git a/private/tapi/dev/sp/kmesp/sys/stubmp.src b/private/tapi/dev/sp/kmesp/sys/stubmp.src
new file mode 100644
index 000000000..bc4acf939
--- /dev/null
+++ b/private/tapi/dev/sp/kmesp/sys/stubmp.src
@@ -0,0 +1,2 @@
+NAME        STUBMP.SYS
+DESCRIPTION 'STUBMP.SYS'
diff --git a/private/tapi/dev/sp/makefile b/private/tapi/dev/sp/makefile
new file mode 100644
index 000000000..2c4195dfe
--- /dev/null
+++ b/private/tapi/dev/sp/makefile
@@ -0,0 +1,27 @@
+!if "$(OS)" == "Windows_NT"
+
+clean:
+  echo "Clean target null in this directory"
+
+!else
+
+##########################################################################
+#
+#       Microsoft Confidential
+#       Copyright (C) Microsoft Corporation 1995
+#       All Rights Reserved.
+#
+##########################################################################
+
+
+ROOT = ..\..\..\..
+DIR = sp
+
+IS_OEM=1
+
+DIRLIST = tsp3216
+#DIRLIST = atsp32 esp.new remotesp tsp3216
+
+!include $(ROOT)\root.mk
+
+!endif
diff --git a/private/tapi/dev/sp/pdisp32/makefile b/private/tapi/dev/sp/pdisp32/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/dev/sp/pdisp32/pdisp.c b/private/tapi/dev/sp/pdisp32/pdisp.c
new file mode 100644
index 000000000..5e2a5605d
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/pdisp.c
@@ -0,0 +1,1594 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    pdisp.c
+
+Abstract:
+
+
+
+Author:
+
+    ???    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include <memory.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "pdisp.h"
+
+BOOL CALLBACK __export ConfigDlgProc(HWND, UINT, WPARAM, LPARAM);
+
+HANDLE  SerialOpenComms (LPSTR, LPSTR);
+void    LoadIniStrings (DWORD);
+long    appCall (int, char *, long);
+
+
+#define msgMakeCall                     1
+#define msgDrop                         2
+
+
+// The number of entries in the devices and speed array.
+
+#define NUMPORTS 4
+
+char *lpszCommDevArray[NUMPORTS] = { "COM1", "COM2", "COM3", "COM4" };
+
+
+// Various tags in the ini file.
+
+char s_telephon_ini[] = "telephon.ini";
+
+char s_one[]       = "1";
+char s_zero[]      = "0";
+char s_numlines[]  = "NumLines";
+char s_numphones[] = "NumPhones";
+char s_providerx[] = "Provider%d";
+
+char s_port[]      = "Port";
+char s_linename[]  = "LineName";
+char s_lineaddr[]  = "LineAddress";
+
+HANDLE       hInst      = NULL;
+ATSPLineData line;
+char         gszProviderInfo[255];
+
+
+long
+appCall(
+    int             msg,
+    char           *str,
+    long            dwRequestID
+    );
+
+long
+lineDropCore(
+    ATSPLineData   *theLine,
+    DWORD           dwRequestID
+    );
+
+#ifdef WIN32
+
+BOOL
+WINAPI
+_CRT_INIT(
+    HINSTANCE   hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    );
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    if (!_CRT_INIT (hInst, dwReason, lpReserved))
+    {
+        OutputDebugString ("PDISP32: DllMain: _CRT_INIT() failed\n\r");
+    }
+
+
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+
+        hInst = hDLL;
+
+        break;
+
+    case DLL_PROCESS_DETACH:
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+
+        break;
+    }
+
+    return TRUE;
+}
+
+#else
+
+int
+FAR
+PASCAL
+LibMain(
+    HANDLE  hInstance,
+    WORD    wDataSegment,
+    WORD    wHeapSize,
+    LPSTR   lpszCmdLine
+    )
+{
+        if (hInst != NULL)
+                return FALSE;
+
+        hInst = hInstance;
+
+        return TRUE;
+}
+
+VOID
+FAR
+PASCAL
+__export
+WEP(
+    int bSystemExit
+    )
+{
+    hInst = NULL;
+}
+
+#endif // WIN32
+
+
+static BOOL initialised = FALSE;
+
+
+//
+// -------------------------- TSPI_lineXxx funcs ------------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE        hdLine,
+    DWORD           dwMediaModes,
+    LPLINECALLPARAMS  const lpCallParams
+    )
+{
+    DebugMsg (("Entering TSPI_lineConditionalMediaDetection"));
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    if (dwMediaModes != LINEMEDIAMODE_INTERACTIVEVOICE)
+    {
+        return LINEERR_INVALMEDIAMODE;
+    }
+
+    return 0;
+}
+
+/*  BUGBUG needs to use new TUISPI stuff
+LONG
+TSPIAPI
+TSPI_lineConfigDialog(
+    DWORD           dwDeviceID,
+    HWND            hwndOwner,
+    LPCSTR          lpszDeviceClass
+    )
+{
+    DebugMsg (("Entering TSPI_lineConfigDialog"));
+
+    if (dwDeviceID != line.lineID)
+    {
+        return LINEERR_BADDEVICEID;
+    }
+
+    DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), hwndOwner, ConfigDlgProc);
+
+    return 0;
+}
+*/
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE        hdLine
+    )
+{
+    DebugMsg (("Entering TSPI_lineClose"));
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+
+    //
+    // call drop in case there is still an active call on the line
+    //
+
+    lineDropCore (&line, 0);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL        hdCall
+    )
+{
+    DebugMsg (("Entering TSPI_lineCloseCall"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+
+    //
+    // call drop in case there is still an active call on the line
+    //
+
+    lineDropCore (&line, 0);
+
+    line.callState = 0;
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    // Transition a call to the IDLE state.
+
+    DebugMsg (("Entering TSPI_lineDrop"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+            return LINEERR_INVALCALLHANDLE;
+
+    return lineDropCore (&line, dwRequestID);       // it was our active call
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwAddressID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+    int cbLineAddr;
+
+    DebugMsg (("Entering TSPI_lineGetAddressCaps"));
+
+    // We support only one line and one address.
+
+    if (dwDeviceID != line.lineID)
+    {
+            return LINEERR_BADDEVICEID;
+    }
+
+    if (dwAddressID != 0)
+    {
+            return LINEERR_INVALADDRESSID;
+    }
+
+    cbLineAddr = strlen (line.lineaddr) + 1;
+
+    lpAddressCaps->dwNeededSize = sizeof (LINEADDRESSCAPS) + cbLineAddr;
+
+    if (lpAddressCaps->dwTotalSize < lpAddressCaps->dwNeededSize)
+    {
+        lpAddressCaps->dwUsedSize = sizeof (LINEADDRESSCAPS);
+    }
+    else
+    {
+        memcpy(
+            (char *) lpAddressCaps + sizeof (LINEADDRESSCAPS),
+            line.lineaddr,
+            cbLineAddr
+            );
+
+        lpAddressCaps->dwAddressSize    = cbLineAddr;
+        lpAddressCaps->dwAddressOffset  = sizeof (LINEADDRESSCAPS);
+        lpAddressCaps->dwUsedSize       = lpAddressCaps->dwNeededSize;
+    }
+
+    lpAddressCaps->dwLineDeviceID       = line.lineID;
+
+    lpAddressCaps->dwAddressSharing     = LINEADDRESSSHARING_PRIVATE;
+    lpAddressCaps->dwAddressStates      = LINEADDRESSSTATE_OTHER |
+                                          LINEADDRESSSTATE_INUSEZERO |
+                                          LINEADDRESSSTATE_INUSEONE |
+                                          LINEADDRESSSTATE_NUMCALLS;
+    lpAddressCaps->dwCallInfoStates     = LINECALLINFOSTATE_OTHER |
+                                          LINECALLINFOSTATE_APPSPECIFIC |
+                                          LINECALLINFOSTATE_NUMOWNERINCR |
+                                          LINECALLINFOSTATE_NUMOWNERDECR |
+                                          LINECALLINFOSTATE_NUMMONITORS |
+                                          LINECALLINFOSTATE_DIALPARAMS;
+    lpAddressCaps->dwCallerIDFlags      = LINECALLPARTYID_UNAVAIL;
+    lpAddressCaps->dwCalledIDFlags      = LINECALLPARTYID_UNAVAIL;
+    lpAddressCaps->dwConnectedIDFlags   = LINECALLPARTYID_UNAVAIL;
+    lpAddressCaps->dwRedirectionIDFlags = LINECALLPARTYID_UNAVAIL;
+    lpAddressCaps->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL;
+    lpAddressCaps->dwCallStates         = LINECALLSTATE_IDLE |
+                                          LINECALLSTATE_DIALTONE |
+                                          LINECALLSTATE_DIALING |
+                                          LINECALLSTATE_BUSY |
+                                          LINECALLSTATE_CONNECTED |
+                                          LINECALLSTATE_PROCEEDING |
+                                          LINECALLSTATE_UNKNOWN;
+    lpAddressCaps->dwDialToneModes      = LINEDIALTONEMODE_UNAVAIL;
+    lpAddressCaps->dwBusyModes          = LINEBUSYMODE_UNAVAIL;
+    lpAddressCaps->dwSpecialInfo        = LINESPECIALINFO_UNAVAIL;
+    lpAddressCaps->dwDisconnectModes    = LINEDISCONNECTMODE_UNKNOWN;
+    lpAddressCaps->dwMaxNumActiveCalls  = 1;
+    lpAddressCaps->dwAddrCapFlags       = LINEADDRCAPFLAGS_BLOCKIDDEFAULT |
+                                          LINEADDRCAPFLAGS_DIALED |
+                                          LINEADDRCAPFLAGS_PARTIALDIAL;
+    lpAddressCaps->dwCallFeatures       = LINECALLFEATURE_DIAL |
+                                          LINECALLFEATURE_DROP;
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE        hdLine,
+    LPDWORD         lpdwAddressID,
+    DWORD           dwAddressMode,
+    LPCSTR          lpsAddress,
+    DWORD           dwSize
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetAddressID"));
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    assert (dwAddressMode == LINEADDRESSMODE_DIALABLEADDR);
+
+    if (strcmp (line.lineaddr, lpsAddress))
+    {
+        return LINEERR_INVALADDRESS;
+    }
+    else
+    {
+        *lpdwAddressID = 0;     // we support only 1 line
+        return 0;
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetAddressStatus"));
+
+    if (dwAddressID)
+    {
+        return LINEERR_INVALADDRESSID;
+    }
+
+    lpAddressStatus->dwUsedSize   =
+    lpAddressStatus->dwNeededSize = sizeof (LINEADDRESSSTATUS);
+
+    // if we are idle a call can be made
+
+    if (line.callState == 0)   // our internal flag that line is not in use
+    {
+        lpAddressStatus->dwAddressFeatures = LINEADDRFEATURE_MAKECALL;
+    }
+    else
+    {
+        lpAddressStatus->dwNumInUse              = 1;
+        lpAddressStatus->dwNumActiveCalls = 1;
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL        hdCall,
+    LPDWORD         lpdwAddressID
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetCallAddressID"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+
+    //
+    // There is but a single address where a call may exist.
+    //
+
+    *lpdwAddressID = 0;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    int cbDestAddr = strlen (line.DestAddress) + 1;
+
+    DebugMsg (("Entering TSPI_lineGetCallInfo"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+    lpCallInfo->dwUsedSize   = sizeof (LINECALLINFO);
+    lpCallInfo->dwNeededSize = sizeof (LINECALLINFO) + cbDestAddr;
+
+    if (lpCallInfo->dwTotalSize >= lpCallInfo->dwNeededSize)
+    {
+        memcpy(
+            (char *) lpCallInfo + sizeof (LINECALLINFO),
+            line.DestAddress,
+            cbDestAddr
+            );
+
+        lpCallInfo->dwDisplayableAddressSize   = cbDestAddr;
+        lpCallInfo->dwDisplayableAddressOffset = sizeof (LINECALLINFO);
+        lpCallInfo->dwUsedSize                 = lpCallInfo->dwNeededSize;
+    }
+
+    lpCallInfo->dwLineDeviceID       = line.lineID;
+    lpCallInfo->dwBearerMode         = LINEBEARERMODE_VOICE;
+    lpCallInfo->dwMediaMode          = line.dwMediaMode;
+    lpCallInfo->dwAppSpecific        = line.dwAppSpecific;
+    lpCallInfo->dwCallParamFlags     = LINECALLPARAMFLAGS_IDLE |
+                                       LINECALLPARAMFLAGS_BLOCKID;
+    lpCallInfo->dwCallStates         = LINECALLSTATE_IDLE |
+                                       LINECALLSTATE_CONNECTED;
+    lpCallInfo->dwOrigin             = LINECALLORIGIN_OUTBOUND;
+    lpCallInfo->dwReason             = LINECALLREASON_UNAVAIL;
+    lpCallInfo->dwCallerIDFlags      = LINECALLPARTYID_UNAVAIL;
+    lpCallInfo->dwCalledIDFlags      = LINECALLPARTYID_UNAVAIL;
+    lpCallInfo->dwConnectedIDFlags   = LINECALLPARTYID_UNAVAIL;
+    lpCallInfo->dwRedirectionIDFlags = LINECALLPARTYID_UNAVAIL;
+    lpCallInfo->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL        hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetCallStatus"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+    lpCallStatus->dwCallState = line.callState;
+
+    if (line.callState == LINECALLSTATE_CONNECTED)
+    {
+        lpCallStatus->dwCallFeatures = LINECALLFEATURE_DROP;
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    int cbname = strlen (line.linename)   + 1;
+    int cbinfo = strlen (gszProviderInfo) + 1;
+
+
+    DebugMsg (("Entering TSPI_lineGetDevCaps"));
+
+    if (dwDeviceID != line.lineID)
+    {
+        return LINEERR_BADDEVICEID;
+    }
+
+    lpLineDevCaps->dwUsedSize   = sizeof (LINEDEVCAPS);
+    lpLineDevCaps->dwNeededSize = sizeof (LINEDEVCAPS) + cbinfo + cbname;
+
+    if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwUsedSize + cbinfo)
+    {
+        // Copy in the provider info
+
+        memcpy(
+            (char *)lpLineDevCaps + lpLineDevCaps->dwUsedSize,
+            gszProviderInfo,
+            cbinfo
+            );
+
+        lpLineDevCaps->dwProviderInfoSize   = cbinfo;
+        lpLineDevCaps->dwProviderInfoOffset = lpLineDevCaps->dwUsedSize;
+        lpLineDevCaps->dwUsedSize           += cbinfo;
+    }
+
+    if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwUsedSize + cbname)
+    {
+        // Copy in the line name
+
+        memcpy(
+            (char *) lpLineDevCaps + lpLineDevCaps->dwUsedSize,
+            line.linename,
+            cbname
+            );
+
+        lpLineDevCaps->dwLineNameSize   = cbname;
+        lpLineDevCaps->dwLineNameOffset = lpLineDevCaps->dwUsedSize;
+        lpLineDevCaps->dwUsedSize       += cbname;
+    }
+
+
+    lpLineDevCaps->dwPermanentLineID = (line.dwppID << 16) + 0;
+
+    // TAPI.DLL fills in APIVersion and ExtVersion.
+
+    lpLineDevCaps->dwNumAddresses      = 1;
+    lpLineDevCaps->dwMaxNumActiveCalls = 1;
+    lpLineDevCaps->dwStringFormat      = STRINGFORMAT_ASCII;
+    lpLineDevCaps->dwBearerModes       = LINEBEARERMODE_VOICE;
+    lpLineDevCaps->dwMediaModes        = LINEMEDIAMODE_INTERACTIVEVOICE;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    DWORD           dwSelect,
+    LPVARSTRING     lpDeviceID,
+    LPCSTR          lpszDeviceClass,
+    HANDLE          hTargetProcess
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetID"));
+
+
+    // Since we have only one device, we don't have to
+    // check the location of the line, address, or call.
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    if (strcmp (lpszDeviceClass, "tapi/line") == 0)
+    {
+        lpDeviceID->dwNeededSize = sizeof (VARSTRING) + sizeof (DWORD);
+
+        if (lpDeviceID->dwTotalSize >= lpDeviceID->dwNeededSize)
+        {
+            lpDeviceID->dwUsedSize          = lpDeviceID->dwNeededSize;
+            lpDeviceID->dwStringFormat      = STRINGFORMAT_BINARY;
+            lpDeviceID->dwStringSize        = sizeof (DWORD);
+            lpDeviceID->dwStringOffset      = sizeof (VARSTRING);
+
+            *((DWORD *) ((char *) lpDeviceID + sizeof (VARSTRING))) =
+                line.lineID;
+        }
+
+        return 0;
+    }
+
+#ifdef COMMSUPPORT
+
+    if (strcmp (lpszDeviceClass, "comm") == 0)
+    {
+        int cbport = strlen (line.port) + 1;
+
+
+        lpDeviceID->dwNeededSize = sizeof (VARSTRING) + cbport;
+
+        if (lpDeviceID->dwTotalSize >= lpDeviceID->dwNeededSize)
+        {
+            lpDeviceID->dwUsedSize     = lpDeviceID->dwNeededSize;
+            lpDeviceID->dwStringFormat = STRINGFORMAT_ASCII;
+            lpDeviceID->dwStringSize   = cbport;
+            lpDeviceID->dwStringOffset = sizeof (VARSTRING);
+
+            memcpy(
+                (char *) lpDeviceID + sizeof (VARSTRING),
+                line.port,
+                cbport
+                );
+        }
+
+        return 0;
+    }
+
+#endif
+
+    return LINEERR_NODEVICE;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE        hdLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetLineDevStatus"));
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    lpLineDevStatus->dwUsedSize   =
+    lpLineDevStatus->dwNeededSize = sizeof (LINEDEVSTATUS);
+
+    lpLineDevStatus->dwOpenMediaModes = line.dwLineMediaModes;
+    lpLineDevStatus->dwRoamMode       = LINEROAMMODE_UNAVAIL;
+
+    if (line.callState == 0)
+    {
+        lpLineDevStatus->dwNumActiveCalls = 0;
+        lpLineDevStatus->dwLineFeatures   = LINEFEATURE_MAKECALL;
+    }
+    else
+    {
+        lpLineDevStatus->dwNumActiveCalls = 1;
+        lpLineDevStatus->dwDevStatusFlags = LINEDEVSTATUSFLAGS_CONNECTED |
+                                            LINEDEVSTATUSFLAGS_INSERVICE;
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE        hdLine,
+    LPDWORD         lpNumAddressIDs
+    )
+{
+    DebugMsg (("Entering TSPI_lineGetNumAddressIDs"));
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    *lpNumAddressIDs = 1;   // We only support one address
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCSTR          lpszDestAddress,
+    DWORD           dwCountryCode,
+    LPLINECALLPARAMS const  lpCallParams
+    )
+{
+    DebugMsg (("Entering TSPI_lineMakeCall"));
+
+    if (lpszDestAddress &&
+        (strlen (lpszDestAddress) > TAPIMAXDESTADDRESSSIZE))
+    {
+       return LINEERR_INVALPOINTER;
+    }
+
+    if (line.callState != 0)
+    {
+        return LINEERR_RESOURCEUNAVAIL;
+    }
+
+    if (lpCallParams)
+    {
+        if (lpCallParams->dwCallParamFlags &
+            ~(LINECALLPARAMFLAGS_IDLE | LINECALLPARAMFLAGS_BLOCKID))
+        {
+            return LINEERR_INVALCALLPARAMS;
+        }
+    }
+
+    // fill in fields of the call record
+
+    line.htCall = htCall;                   // we have no hdcall of our own
+    *lphdCall   = (HDRVCALL) htCall;
+
+    if (lpszDestAddress)
+    {
+        strcpy (line.DestAddress, lpszDestAddress);
+    }
+    else
+    {
+        line.DestAddress[0] = 0;
+    }
+
+    return appCall (msgMakeCall, line.DestAddress, dwRequestID);
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD           dwDeviceID,
+    DWORD           dwLowVersion,
+    DWORD           dwHighVersion,
+    LPDWORD         lpdwTSPIVersion
+    )
+{
+    DebugMsg (("Entering TSPI_lineNegotiateTSPIVersion"));
+
+    // line.lineID will contain garbage before provider_init has
+    // been called (ie. first time through). However, we can guarantee
+    // that the first call will be with INITIALIZE_NEGOTIATION and that
+    // is followed immediately by provider_init. This would be a problem
+    // if the line data structure was dynamically allocated !
+
+    // we support only one line
+
+    if (dwDeviceID == INITIALIZE_NEGOTIATION || dwDeviceID == line.lineID)
+    {
+        *lpdwTSPIVersion = 0x00010003;
+
+        if (dwLowVersion  > 0x00010003 ||     // the app is too new for us
+            dwHighVersion < 0x00010003)       // we are too new for the app
+        {
+            return LINEERR_INCOMPATIBLEAPIVERSION;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    return LINEERR_BADDEVICEID;    // The requested device doesn't exist
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD           dwDeviceID,
+    HTAPILINE       htLine,
+    LPHDRVLINE      lphdLine,
+    DWORD           dwTSPIVersion,
+    LINEEVENT       lpfnEventProc
+    )
+{
+     DebugMsg (("Entering TSPI_lineOpen"));
+
+     if (dwDeviceID != line.lineID)
+     {
+         return LINEERR_BADDEVICEID;
+     }
+
+
+     //
+     // Since we only support outgoing calls, we don't open
+     // the serial port until we need to make a call
+     //
+
+     line.lpfnEventProc = lpfnEventProc;
+     line.htLine        = htLine;
+     *lphdLine          = (HDRVLINE) &line;
+
+     return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL        hdCall,
+    DWORD           dwAppSpecific
+    )
+{
+    DebugMsg (("Entering TSPI_lineSetAppSpecific"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+    line.dwAppSpecific = dwAppSpecific;
+
+    line.lpfnEventProc(
+        line.htLine,
+        line.htCall,
+        LINE_CALLINFO,
+        LINECALLINFOSTATE_APPSPECIFIC,
+        0,
+        0
+        );
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE        hdLine,
+    DWORD           dwMediaModes
+    )
+{
+    DebugMsg (("Entering TSPI_lineSetDefaultMediaDetection"));
+
+    if (hdLine != (HDRVLINE) &line)
+    {
+        return LINEERR_INVALLINEHANDLE;
+    }
+
+    if (dwMediaModes && dwMediaModes != LINEMEDIAMODE_INTERACTIVEVOICE)
+    {
+        return LINEERR_INVALMEDIAMODE;
+    }
+
+    line.dwLineMediaModes = dwMediaModes;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL        hdCall,
+    DWORD           dwMediaMode
+    )
+{
+    DebugMsg (("Entering TSPI_lineSetMediaMode"));
+
+    if (hdCall != (HDRVCALL) line.htCall)
+    {
+        return LINEERR_INVALCALLHANDLE;
+    }
+
+    if (dwMediaMode != LINEMEDIAMODE_INTERACTIVEVOICE)
+    {
+        return LINEERR_INVALMEDIAMODE;
+    }
+
+    line.dwMediaMode = dwMediaMode;
+
+    return 0;
+}
+
+
+//
+// ------------------------- TSPI_providerXxx funcs ---------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND            hwnd,
+    DWORD           dwPermanentProviderId
+    )
+{
+    DebugMsg (("Entering TSPI_providerConfig"));
+
+    if (!initialised)
+    {
+        LoadIniStrings (dwPermanentProviderId);
+    }
+    else if (dwPermanentProviderId != line.dwppID)
+    {
+        return LINEERR_NOMULTIPLEINSTANCE;
+    }
+
+    DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), hwnd, ConfigDlgProc);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions
+    )
+{
+    DebugMsg (("Entering TSPI_providerInit"));
+
+//    assert (dwTSPIVersion == ATSP_VERSION);
+//    assert (dwNumLines    == 1);
+//    assert (dwNumPhones   == 0);
+
+    if (initialised)
+    {
+        return LINEERR_NOMULTIPLEINSTANCE;
+    }
+
+    // initialise our internal structures
+
+    memset (&line, 0, sizeof (ATSPLineData));
+
+    line.lpfnCompletion = lpfnCompletionProc;
+    line.lineID         = dwLineDeviceIDBase;
+    line.dwMediaMode    = LINEMEDIAMODE_INTERACTIVEVOICE;
+    line.hcd            = INVALID_HANDLE_VALUE;
+
+    LoadIniStrings (dwPermanentProviderID);
+
+    initialised = TRUE;
+
+    *lpdwTSPIOptions = LINETSPIOPTION_NONREENTRANT;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND            hwnd,
+    DWORD           dwPermanentProviderId
+    )
+{
+    int res;
+    char szProvider[sizeof (s_providerx) + 5]; // room for 65535
+
+
+    DebugMsg (("Entering TSPI_providerInstall"));
+
+    if (!initialised)
+    {
+        LoadIniStrings (dwPermanentProviderId);
+    }
+    else if (dwPermanentProviderId != line.dwppID)
+    {
+        res = ID_MULTIPLE_INST;
+        goto error;
+    }
+
+    wsprintf (szProvider, s_providerx, (int) dwPermanentProviderId);
+
+
+    //
+    // we support 1 line and 0 phones
+    //
+
+    WritePrivateProfileString(
+        szProvider,
+        s_numlines,
+        s_one,
+        s_telephon_ini
+        );
+
+    WritePrivateProfileString(
+        szProvider,
+        s_numphones,
+        s_zero,
+        s_telephon_ini
+        );
+
+
+    //
+    // Flush the ini file cache
+    //
+
+    WritePrivateProfileString (0, 0, 0, s_telephon_ini);
+
+
+    //
+    // display the config dlg
+    //
+
+    if (DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), hwnd, ConfigDlgProc)
+            == 0)
+    {
+            return 0;
+    }
+    else
+    {
+            return LINEERR_OPERATIONFAILED;
+    }
+
+
+error:
+
+    {
+        char szerr[255];
+        char title[255];
+
+
+        LoadString (hInst, res, szerr, sizeof (szerr));
+        LoadString (hInst, ID_ATSP_ERROR, title, sizeof (title));
+
+        MessageBox (hwnd, szerr, title, MB_APPLMODAL | MB_ICONEXCLAMATION);
+
+        return LINEERR_OPERATIONFAILED;
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND            hwnd,
+    DWORD           dwPermanentProviderId
+    )
+{
+    DebugMsg (("Entering TSPI_providerRemove"));
+
+    // BUGBUG: need to nuke the ProviderN section
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD   dwTSPIVersion,
+    DWORD   dwPermanentProviderID
+    )
+{
+    DebugMsg (("Entering TSPI_providerShutdown"));
+
+    initialised = FALSE;
+
+    return 0;
+}
+
+
+//
+// ------------------------ Private support routines --------------------------
+//
+
+void
+LoadIniStrings(
+    DWORD ppID
+    )
+{
+    char section[sizeof (s_providerx) + 5];         // room for 65535
+
+
+    wsprintf (section, s_providerx, (int) ppID);
+    line.dwppID = ppID;
+
+    // user preferences come from the telephon.ini file
+
+    GetPrivateProfileString(
+        section,
+        s_port,
+        "COM1",
+        line.port,
+        sizeof (line.port),
+        s_telephon_ini
+        );
+
+    GetPrivateProfileString(
+        section,
+        s_linename,
+        "",
+        line.linename,
+        sizeof (line.linename),
+        s_telephon_ini
+        );
+
+    GetPrivateProfileString(
+        section,
+        s_lineaddr,
+        "",
+        line.lineaddr,
+        sizeof (line.lineaddr),
+        s_telephon_ini
+        );
+
+    // the provider info string comes from the resource file
+
+    gszProviderInfo[0] = 0;         // in case loadstring fails
+
+    LoadString(
+        hInst,
+        ID_PROVIDER_INFO,
+        gszProviderInfo,
+        sizeof (gszProviderInfo)
+        );
+
+    return;
+}
+
+
+BOOL
+CALLBACK
+__export
+ConfigDlgProc(
+    HWND            hDlg,
+    UINT            uiMsg,
+    WPARAM          wParam,
+    LPARAM          lParam
+    )
+{
+    int CurrSel;
+
+    switch (uiMsg)
+    {
+    case WM_INITDIALOG:
+    {
+        for (CurrSel = 0; CurrSel < NUMPORTS; CurrSel++)
+        {
+            //
+            // List the port in the combo box.
+            //
+
+            SendDlgItemMessage(
+                hDlg,
+                ID_PORT,
+                CB_ADDSTRING,
+                0,
+                (LPARAM) ((LPSTR) lpszCommDevArray[CurrSel])
+                );
+        }
+
+        CurrSel = (int) SendDlgItemMessage(
+            hDlg,
+            ID_PORT,
+            CB_FINDSTRING,
+            0,
+            (LPARAM) (LPSTR) line.port
+            );
+
+        SendDlgItemMessage (hDlg, ID_PORT, CB_SETCURSEL, CurrSel, 0);
+
+        SendDlgItemMessage(
+            hDlg,
+            ID_LINENAME,
+            WM_SETTEXT,
+            0,
+            (LPARAM) (LPSTR) line.linename
+            );
+
+        SendDlgItemMessage(
+            hDlg,
+            ID_LINEADDR,
+            WM_SETTEXT,
+            0,
+            (LPARAM) (LPSTR) line.lineaddr
+            );
+        break;
+    }
+    case WM_COMMAND:
+    {
+        switch (wParam)
+        {
+        case IDOK:
+        {
+            char szp[sizeof (s_providerx) + 5];             // room for 65535
+            wsprintf (szp, s_providerx, (int) line.dwppID);
+
+
+            //
+            // Port
+            //
+
+            CurrSel = (int) SendDlgItemMessage(
+                hDlg,
+                ID_PORT,
+                CB_GETCURSEL,
+                0,
+                0
+                );
+
+            SendDlgItemMessage(
+                hDlg,
+                ID_PORT,
+                CB_GETLBTEXT,
+                CurrSel,
+                (LPARAM) (LPSTR) line.port
+                );
+
+            WritePrivateProfileString (szp, s_port, line.port, s_telephon_ini);
+
+
+            //
+            // Line Name
+            //
+
+            SendDlgItemMessage(
+                hDlg,
+                ID_LINENAME,
+                WM_GETTEXT,
+                sizeof (line.linename),
+                (LPARAM) (LPSTR) line.linename
+                );
+
+            WritePrivateProfileString(
+                szp,
+                s_linename,
+                line.linename,
+                s_telephon_ini
+                );
+
+
+            //
+            // Line Address
+            //
+
+            SendDlgItemMessage(
+                hDlg,
+                ID_LINEADDR,
+                WM_GETTEXT,
+                sizeof (line.lineaddr),
+                (LPARAM) (LPSTR) line.lineaddr
+                );
+
+            WritePrivateProfileString(
+                szp,
+                s_lineaddr,
+                line.lineaddr,
+                s_telephon_ini
+                );
+
+
+            //
+            // Flush the ini file cache
+            //
+
+            WritePrivateProfileString (0, 0, 0, s_telephon_ini);
+            EndDialog (hDlg, 0);
+
+            break;
+        }
+        case IDCANCEL:
+
+            EndDialog (hDlg, -1);
+            break;
+        }
+
+        break;
+    }
+
+    default:
+
+        return FALSE;
+
+    } // switch
+
+    return TRUE;
+}
+
+
+#if DBG
+void
+CDECL
+SPTrace(
+    LPCSTR  lpszFormat,
+    ...
+    )
+{
+#ifdef WIN32
+    char    buf[128] = "PDISP32: ";
+#else
+    char    buf[128] = "PDISP: ";
+#endif
+    va_list ap;
+
+
+    va_start(ap, lpszFormat);
+
+#ifdef WIN32
+    wvsprintf (&buf[9], lpszFormat, ap);
+#else
+    wvsprintf (&buf[7], lpszFormat, ap);
+#endif
+
+    strcat (buf, "\n");
+
+    OutputDebugString (buf);
+
+    va_end(ap);
+}
+#endif
+
+
+UINT
+myatoi(
+    LPSTR           speed
+    )
+{
+    UINT i;
+
+    for (i = 0; *speed; speed++)
+    {
+        i = i * 10 + (*speed - '0');
+    }
+
+    return i;
+}
+
+
+#define TXQUEUE 512
+#define RXQUEUE 512
+
+HANDLE
+SerialOpenComms(
+    LPSTR           port,
+    LPSTR           speed
+    )
+{
+#ifdef WIN32
+
+    HANDLE hcd = CreateFile(
+        port,
+        GENERIC_READ | GENERIC_WRITE,
+        0,    // no sharing
+        NULL, // no security attrs
+        OPEN_EXISTING,
+        0,    // no attrs/flags
+        NULL  // no template file
+        );
+
+    if (hcd == INVALID_HANDLE_VALUE)
+    {
+        DebugMsg (("CreateFile(%s) failed, err=%ld", port, GetLastError()));
+    }
+
+#else
+
+    int hcd = OpenComm (port, RXQUEUE, TXQUEUE);
+
+#endif
+
+
+    if (hcd >= 0)
+     {
+        DCB dcb;
+
+#ifdef WIN32
+        if (GetCommState (hcd, &dcb))
+#else
+        if (GetCommState (hcd, &dcb) == 0)
+#endif
+        {
+              memset (&dcb.BaudRate, 0, sizeof (DCB) - sizeof (dcb.DCBlength));
+
+              dcb.BaudRate = myatoi (speed);
+              dcb.ByteSize = 8;
+              dcb.fBinary  = TRUE;
+//                      dcb.fChEvt   = TRUE;
+              dcb.XonChar  = 17;
+              dcb.XoffChar = 19;
+//                      dcb.EvtChar  = '\n';
+
+              if (SetCommState (hcd, &dcb))
+              {
+                  DebugMsg (("Opened: %s:%s", port, speed));
+                  return hcd;
+              }
+        }
+
+#ifdef WIN32
+        CloseHandle (hcd);
+#else
+        CloseComm (hcd);
+
+        DebugMsg (("***Comm port failed to open"));
+#endif
+
+    }
+
+    return INVALID_HANDLE_VALUE;
+}
+
+
+long
+appCall(
+    int             msg,
+    char           *str,
+    long            dwRequestID
+    )
+{
+    long wait;
+#ifdef WIN32
+    DWORD dwBytesWritten;
+#endif
+
+
+    if (msg == msgMakeCall)
+    {
+        line.hcd = SerialOpenComms (line.port, "9600");
+
+        if (line.hcd == INVALID_HANDLE_VALUE)
+        {
+            return LINEERR_RESOURCEUNAVAIL;
+        }
+        else
+        {
+            char dial[255];
+
+
+            wsprintf (dial, "ATMH9D%s;\r", str);
+
+#ifdef WIN32
+            if (WriteFile(
+                    line.hcd,
+                    dial,
+                    strlen (dial),
+                    &dwBytesWritten,
+                    NULL
+                    ))
+#else
+            if (WriteComm (line.hcd, dial, strlen (dial)) > 0)
+#endif
+            {
+                DebugMsg (("Sent: %s", dial));
+
+                line.callState = LINECALLSTATE_CONNECTED;
+
+                line.lpfnCompletion (dwRequestID, 0);
+
+                line.lpfnEventProc(
+                    line.htLine,
+                    line.htCall,
+                    LINE_CALLSTATE,
+                    LINECALLSTATE_CONNECTED,
+                    0,
+                    0
+                    );
+            }
+            else
+            {
+                DebugMsg (("failed to write string"));
+#ifdef WIN32
+                return -1; // BUGBUG
+#else
+                return GetCommError (line.hcd, NULL);
+#endif
+            }
+        }
+    }
+    else    // must be linedrop
+    {
+        if (line.hcd == INVALID_HANDLE_VALUE)
+        {
+            DebugMsg (("idle"));
+        }
+        else
+        {
+            wait = GetTickCount();
+
+#ifdef WIN32
+            WriteFile (line.hcd, "\r", 1, &dwBytesWritten, NULL);
+#else
+            WriteComm (line.hcd, "\r", 1);
+#endif
+
+            while (GetTickCount() - wait < 250);
+
+#ifdef WIN32
+            if (WriteFile (line.hcd, "ATH8\r", 6, &dwBytesWritten, NULL))
+#else
+            if (WriteComm (line.hcd, "ATH8\r", 6) > 0)
+#endif
+            {
+                DebugMsg (("Sent: %s", str));
+            }
+            else
+            {
+                DebugMsg (("failed to hang up"));
+            }
+
+            wait = GetTickCount();
+            while (GetTickCount() - wait < 250);
+
+            EscapeCommFunction (line.hcd, CLRDTR);  // drop DTR
+
+#ifdef WIN32
+            if (!CloseHandle (line.hcd))
+#else
+            if (CloseComm (line.hcd))
+#endif
+            {
+                DebugMsg (("Couldn't close the serial port"));
+            }
+
+            line.hcd = INVALID_HANDLE_VALUE;
+            line.callState = LINECALLSTATE_IDLE;
+            line.lpfnEventProc(
+                line.htLine,
+                line.htCall,
+                LINE_CALLSTATE,
+                LINECALLSTATE_IDLE,
+                0,
+                0
+                );
+        }
+
+        if (dwRequestID)
+        {
+            line.lpfnCompletion (dwRequestID, 0);
+        }
+    }
+
+    return dwRequestID;
+}
+
+
+long
+lineDropCore(
+    ATSPLineData   *theLine,
+    DWORD           dwRequestID
+    )
+{
+    // if the call is not idle, transition to idle and close the comms port
+
+    return appCall (msgDrop, 0, dwRequestID);
+}
diff --git a/private/tapi/dev/sp/pdisp32/pdisp.h b/private/tapi/dev/sp/pdisp32/pdisp.h
new file mode 100644
index 000000000..02af3a478
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/pdisp.h
@@ -0,0 +1,62 @@
+#include <windows.h>
+
+#define __far
+#define __pascal
+#define __export
+#define TSPIAPI WINAPI
+
+
+#include "TSPI.H"
+#include "pdisprc.h"
+
+#define ATSP_VERSION 0x00010003
+
+#define SMALLBUFFER 40
+
+typedef struct lineInfo
+{
+        // We have only a single call on a single address on a single line
+        // This structure is constructed in TSPI_Initialize
+
+        LINEEVENT          lpfnEventProc;          // TAPI event callback func
+        ASYNC_COMPLETION   lpfnCompletion;         // TAPI Completion callback
+
+        DWORD              lineID;                 // the tapi ID of our line
+        DWORD              dwLineMediaModes;
+        DWORD              dwppID;                 // Our permanent provider ID
+        HTAPILINE          htLine;                 // TAPI opaque line handle
+        HTAPICALL          htCall;                 // TAPI opaque call handle
+
+        DWORD              callState;              // The state of this call
+//      DWORD              dwRequestID;            // for async requests
+        DWORD              dwMediaMode;
+        DWORD              dwAppSpecific;
+
+#ifdef WIN32
+        HANDLE             hcd;                    // the associated COM device
+#else
+        int                hcd;                    // the associated COM device
+#endif
+        char               port[SMALLBUFFER];      // "COM1"
+        char               linename[SMALLBUFFER];  // "My Phone"
+        char               lineaddr[SMALLBUFFER];  // "555-1212"
+
+        char               DestAddress[TAPIMAXDESTADDRESSSIZE];
+
+} ATSPLineData;
+
+
+// Debug Message Macro
+
+#if DBG
+
+#include <stdarg.h>
+#include <stdio.h>
+void CDECL SPTrace(LPCSTR pszFormat, ...);
+#define DebugMsg(_x_)  SPTrace _x_
+
+#else
+
+#define DebugMsg(_x_)
+
+#endif
diff --git a/private/tapi/dev/sp/pdisp32/pdisp.rc b/private/tapi/dev/sp/pdisp32/pdisp.rc
new file mode 100644
index 000000000..c2c8c799e
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/pdisp.rc
@@ -0,0 +1,45 @@
+#include <windows.h>
+//#include <tapiver.h>
+#include "pdisprc.h"
+
+
+IDD_CFGDLG DIALOG DISCARDABLE  20, 15, 177, 95
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "PDI Configuration"
+FONT 8, "MS Sans Serif"
+BEGIN
+    LTEXT           "&Communications Port",ID_STATIC,9,7,70,9,NOT WS_GROUP
+    COMBOBOX        ID_PORT,9,18,90,52,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "&Line Name",ID_STATIC,8,36,100,8
+    EDITTEXT        ID_LINENAME,9,46,90,12,ES_AUTOHSCROLL
+    LTEXT           "Phone &Number",ID_STATIC,8,64,94,9
+    EDITTEXT        ID_LINEADDR,9,73,90,12,ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "OK",IDOK,111,16,56,14
+    PUSHBUTTON      "Cancel",IDCANCEL,111,36,56,14
+END
+
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_PROVIDER_INFO "Microsoft Internal Use PDI Modem Service Provider"
+    ID_MULTIPLE_INST "The selected service provider is already installed in the system and cannot support multiple instances."
+    ID_ATSP_ERROR    "PDI Service Provider Error"
+END
+
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) PDI Modem Service Provider"
+#define VER_INTERNALNAME_STR        "pdisp32"
+#define VER_ORIGINALFILENAME_STR    "PDISP32.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/pdisp32/pdisp32.def b/private/tapi/dev/sp/pdisp32/pdisp32.def
new file mode 100644
index 000000000..55fa6a3c5
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/pdisp32.def
@@ -0,0 +1,31 @@
+LIBRARY         PDISP32
+PROTMODE
+CODE            MOVEABLE DISCARDABLE
+DATA            PRELOAD MOVEABLE
+
+EXPORTS
+        TSPI_providerInstall
+        TSPI_providerRemove
+        TSPI_providerConfig
+        TSPI_lineNegotiateTSPIVersion
+        TSPI_providerInit
+        TSPI_providerShutdown
+        TSPI_lineClose
+        TSPI_lineCloseCall
+        TSPI_lineConditionalMediaDetection
+        TSPI_lineDrop
+        TSPI_lineGetAddressCaps
+        TSPI_lineGetAddressID
+        TSPI_lineGetAddressStatus
+        TSPI_lineGetCallAddressID
+        TSPI_lineGetCallInfo
+        TSPI_lineGetCallStatus
+        TSPI_lineGetDevCaps
+        TSPI_lineGetID
+        TSPI_lineGetLineDevStatus
+        TSPI_lineGetNumAddressIDs
+        TSPI_lineMakeCall
+        TSPI_lineOpen
+        TSPI_lineSetAppSpecific
+        TSPI_lineSetDefaultMediaDetection
+        TSPI_lineSetMediaMode
diff --git a/private/tapi/dev/sp/pdisp32/pdisprc.h b/private/tapi/dev/sp/pdisp32/pdisprc.h
new file mode 100644
index 000000000..888328e6f
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/pdisprc.h
@@ -0,0 +1,18 @@
+// dialog IDs
+
+#define ID_PROVIDER_INFO		2
+#define ID_MULTIPLE_INST		3
+#define ID_NO_DRIVER				4
+#define ID_ATSP_ERROR			5
+
+#define IDI_MODEM					10
+
+#define IDD_CFGDLG				101
+
+#define ID_PORT					1000
+#define ID_LINENAME				1002
+#define ID_LINEADDR				1003
+
+#define ID_STATIC					-1
+
+
diff --git a/private/tapi/dev/sp/pdisp32/sources b/private/tapi/dev/sp/pdisp32/sources
new file mode 100644
index 000000000..29bb081cf
--- /dev/null
+++ b/private/tapi/dev/sp/pdisp32/sources
@@ -0,0 +1,54 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=pdisp32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=TSP
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+DLLBASE=0x61000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=pdisp.c \
+        pdisp.rc
+
+C_DEFINES=-DTAPI_NT=1
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/remotesp/dialogs.dlg b/private/tapi/dev/sp/remotesp/dialogs.dlg
new file mode 100644
index 000000000..03123d66b
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/dialogs.dlg
@@ -0,0 +1,16 @@
+100 DIALOG 6, 18, 175, 92
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "RemoteSP Configuration"
+FONT 8, "MS Shell Dlg"
+BEGIN
+    GROUPBOX        "TAPI Servers", 109, 4, 2, 167, 69
+    LTEXT           "New:", 101, 10, 16, 21, 8
+    EDITTEXT        IDC_EDIT1, 10, 24, 48, 12, ES_AUTOHSCROLL
+    PUSHBUTTON      "Add >>", IDC_ADD, 64, 24, 44, 12
+    PUSHBUTTON      "Remove <<", IDC_REMOVE, 64, 39, 44, 12
+    LTEXT           "Connect to:", 102, 116, 16, 41, 8
+    LISTBOX         IDC_LIST1, 116, 24, 48, 43, WS_VSCROLL | WS_TABSTOP
+    PUSHBUTTON      "OK", IDOK, 32, 75, 40, 14
+    PUSHBUTTON      "Cancel", IDCANCEL, 104, 75, 40, 14
+END
diff --git a/private/tapi/dev/sp/remotesp/line.ico b/private/tapi/dev/sp/remotesp/line.ico
new file mode 100644
index 000000000..6c2186e09
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/line.ico
diff --git a/private/tapi/dev/sp/remotesp/makefile b/private/tapi/dev/sp/remotesp/makefile
new file mode 100644
index 000000000..7145f6049
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   remotesp Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/remotesp/makefile.def b/private/tapi/dev/sp/remotesp/makefile.def
new file mode 100644
index 000000000..49994e9cb
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/makefile.def
@@ -0,0 +1,77 @@
+##############################################################################
+#
+#   remotesp.tsp Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+WANT_C932=1
+#WANT_C1032=1
+IS_32 = TRUE
+WIN32=1
+IS_OEM = TRUE
+
+BUILDDLL=1
+DLLENTRY=DllMain
+
+DEPENDNAME=..\depend.mk
+
+CLEANLIST=*.tsp
+
+TARGETS=remotesp.tsp
+
+SRCDIR=..
+
+BUILD_COFF=1
+
+
+L32EXE=remotesp.tsp		# Name of exe.
+L32DEF=..\remotesp.def              # Our def file.
+L32MAP=remotesp.map		# Our map file.
+L32SYM=remotesp.sym		# Our sym file.
+L32LIBS=\
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+#        $(W32LIBID)\comctl32.lib                \
+        $(W32LIBID)\advapi32.lib                \
+#        $(W32LIBID)\version.lib                 \
+#        $(W32LIBID)\comdlg32.lib                \
+#        $(W32LIBID)\comctl32.lib                \
+#        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+#        $(ROOT)\dev\tools\c932\lib\libc.lib     \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib     \
+        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib
+
+
+
+#        $(W32LIBID)\lz32.lib                    \
+#        $(ROOT)\dev\tools\c932\lib\msvcrt.lib \
+#        $(ROOT)\dev\tools\c932\lib\oldnames.lib \
+#        $(ROOT)\dev\tools\c932\lib\rpcndr.lib   \
+
+L32RES=remotesp.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = remotesp.obj tapsrv_c.obj rmotsp_s.obj
+
+
+L32FLAGS=$(L32FLAGS)
+
+
+!include $(ROOT)\dev\master.mk
+
+INCLUDE=..;..\..\..\client;..\..\..\server;$(INCLUDE)
+
+#CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Od -Fc -GD
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Ox
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/remotesp/phone.ico b/private/tapi/dev/sp/remotesp/phone.ico
new file mode 100644
index 000000000..ee34203e3
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/phone.ico
diff --git a/private/tapi/dev/sp/remotesp/remotesp.c b/private/tapi/dev/sp/remotesp/remotesp.c
new file mode 100644
index 000000000..1679bd3fc
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/remotesp.c
@@ -0,0 +1,7677 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    remotesp.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    09-Aug-1995
+
+Revision History:
+
+
+Notes:
+
+    In a nutshell, this service provider connects to tapisrv.exe on remote
+    pc's via the same rpc interface used by tapi32, and sends the remote
+    tapisrv's the same kinds of requests (as defined in \dev\server\line.h
+    & phone.h).
+
+    This service provider also acts as an rpc server, receiving async event
+    notifications from the remote tapisrv's.  Remote tapisrv's call our
+    RemoteSPAttach() function at init time (during our call to their
+    ClientAttach() proc) to establish a binding instance, and then can call
+    RemoteSPEventProc() to send async events. Since we don't want to block
+    the servers for any length of time, we immediately queue the events they
+    send us, and a dedicated thread (EventHandlerThread) services this
+    queue.
+
+    Now a brief note on handle resolution.  When we open a line or a phone,
+    we alloc our own DRVXXX structure to represent this widget, and pass
+    tapisrv a pointer to this widget in the open request (see the
+    hRemoteLine field in LINEOPEN_PARAMS in line.h).  Then, when remote
+    tapisrv's send us events on those lines/phones, they pass us the
+    widget pointer we passed them (instead of the normal hLine/hPhone).
+    This allows us to easily find and reference our data structure
+    associated with this widget.  Dealing with calls is a little more
+    problematic, since remote tapisrv's can present incoming calls, and
+    there is no clean way to initially specify our own handle to the call
+    as with lines or phones.  (A RemoteSPNewCall() function which would
+    allow for this handle swapping was considered, but not implemented due
+    to possible blocking problems on the remote server.)  The solution
+    is to maintain a list of calls in each line structure, and when call
+    events are parsed we resolve the hCall by walking the list of calls in
+    the corresponding line (tapisrv is nice enough to indicate our line
+    pointer in dwParam4 of the relevant messages).  Since we expect client
+    machines using remotesp to have a relatively low call bandwidth, this
+    look up method should be pretty fast.
+
+    BUGBUG when an rpc exception is hit we may want to check the return
+           value instead of just blindly doing retries (may be a fatal error
+           that a retry wouldn't help, like server_not_found)
+
+--*/
+
+
+#include "remotesp.h"
+#include "rmotsp.h"
+
+
+const TCHAR gszTelephonyKey[] =
+                "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony";
+
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+    {
+
+#if DBG
+
+    {
+        HKEY    hTelephonyKey;
+        DWORD   dwDataSize, dwDataType;
+        TCHAR   szRemotespDebugLevel[] = "RemotespDebugLevel";
+
+
+        RegOpenKeyEx(
+            HKEY_LOCAL_MACHINE,
+            gszTelephonyKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hTelephonyKey
+            );
+
+        dwDataSize = sizeof (DWORD);
+        gdwDebugLevel=0;
+
+        RegQueryValueEx(
+            hTelephonyKey,
+            szRemotespDebugLevel,
+            0,
+            &dwDataType,
+            (LPBYTE) &gdwDebugLevel,
+            &dwDataSize
+            );
+
+        RegCloseKey (hTelephonyKey);
+    }
+
+#endif
+
+        //
+        //
+        //
+
+//        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+//        {
+//        }
+
+        DBGOUT((2, "DLL_PROCESS_ATTACH"));
+
+        ghInst = hDLL;
+
+
+        //
+        // Alloc a Tls index
+        //
+
+        if ((gdwTlsIndex = TlsAlloc()) == 0xffffffff)
+        {
+            DBGOUT((1, "DLL_PROCESS_ATTACH, TlsAlloc() failed"));
+
+            return FALSE;
+        }
+
+
+        //
+        // Initialize Tls to NULL for this thread
+        //
+
+        TlsSetValue (gdwTlsIndex, NULL);
+
+
+        //
+        // Init a couple of critical sections for serializing
+        // access to resources
+        //
+
+        InitializeCriticalSection (&gEventBufferCriticalSection);
+        InitializeCriticalSection (&gCallListCriticalSection);
+
+
+        //
+        // Load the device icons
+        //
+
+        ghLineIcon  = LoadIcon (hDLL, MAKEINTRESOURCE(IDI_ICON3));
+        ghPhoneIcon = LoadIcon (hDLL, MAKEINTRESOURCE(IDI_ICON2));
+
+        break;
+    }
+    case DLL_PROCESS_DETACH:
+    {
+        PCLIENT_THREAD_INFO pTls;
+
+
+        DBGOUT((2, "DLL_PROCESS_DETACH"));
+
+
+        //
+        // Clean up any Tls
+        //
+
+        if ((pTls = (PCLIENT_THREAD_INFO) TlsGetValue (gdwTlsIndex)))
+        {
+            if (pTls->pBuf)
+            {
+                DrvFree (pTls->pBuf);
+            }
+
+            DrvFree (pTls);
+        }
+
+        TlsFree (gdwTlsIndex);
+
+//        _CRT_INIT (hDLL, dwReason, lpReserved);
+
+
+        //
+        // Free the critical sections & icons
+        //
+
+        DeleteCriticalSection (&gEventBufferCriticalSection);
+        DeleteCriticalSection (&gCallListCriticalSection);
+
+        DestroyIcon (ghLineIcon);
+        DestroyIcon (ghPhoneIcon);
+
+        break;
+    }
+    case DLL_THREAD_ATTACH:
+
+//        if (!_CRT_INIT (hDLL, dwReason, lpReserved))
+//        {
+//        }
+
+
+        //
+        // Initialize Tls to NULL for this thread
+        //
+
+        TlsSetValue (gdwTlsIndex, NULL);
+
+        break;
+
+    case DLL_THREAD_DETACH:
+    {
+        PCLIENT_THREAD_INFO pTls;
+
+
+        //
+        // Clean up any Tls
+        //
+
+        if ((pTls = (PCLIENT_THREAD_INFO) TlsGetValue (gdwTlsIndex)))
+        {
+            if (pTls->pBuf)
+            {
+                DrvFree (pTls->pBuf);
+            }
+
+            DrvFree (pTls);
+        }
+
+//        _CRT_INIT (hDLL, dwReason, lpReserved);
+
+        break;
+    }
+    } // switch
+
+    return TRUE;
+}
+
+
+PASYNCEVENTMSG
+GetEventFromQueue(
+    void
+    )
+{
+    DWORD           dwUsedSize, dwMoveSize, dwMoveSizeWrapped;
+    PASYNCEVENTMSG  pMsg = gEventHandlerThreadParams.pMsg;
+
+
+    //
+    // Enter the critical section to serialize access to the event
+    // queue, and grab an event from the queue.  Copy it to our local
+    // event buf so that we can leave the critical section asap and
+    // not block other threads writing to the queue.
+    //
+
+    EnterCriticalSection (&gEventBufferCriticalSection);
+
+
+    //
+    // If there are no events in the queue return NULL
+    //
+
+    if (gEventHandlerThreadParams.dwEventBufferUsedSize == 0)
+    {
+        pMsg = NULL;
+
+        goto GetEventFromQueue_done;
+    }
+
+
+    //
+    // Copy the fixed portion of the msg to the local buf
+    //
+
+    dwUsedSize = (gEventHandlerThreadParams.pEventBuffer +
+        gEventHandlerThreadParams.dwEventBufferTotalSize)  -
+        gEventHandlerThreadParams.pDataOut;
+
+    if (dwUsedSize >= sizeof (ASYNCEVENTMSG))
+    {
+        dwMoveSize        = sizeof (ASYNCEVENTMSG);
+        dwMoveSizeWrapped = 0;
+    }
+    else
+    {
+        dwMoveSize        = dwUsedSize;
+        dwMoveSizeWrapped = sizeof (ASYNCEVENTMSG) - dwUsedSize;
+    }
+
+    CopyMemory (pMsg, gEventHandlerThreadParams.pDataOut, dwMoveSize);
+
+    if (dwMoveSizeWrapped)
+    {
+        CopyMemory(
+            ((LPBYTE) pMsg) + dwMoveSize,
+            gEventHandlerThreadParams.pEventBuffer,
+            dwMoveSizeWrapped
+            );
+
+        gEventHandlerThreadParams.pDataOut =
+            gEventHandlerThreadParams.pEventBuffer + dwMoveSizeWrapped;
+    }
+    else
+    {
+        gEventHandlerThreadParams.pDataOut += dwMoveSize;
+    }
+
+
+    //
+    // See if there's any extra data in this msg
+    //
+
+    if (pMsg->dwTotalSize > sizeof (ASYNCEVENTMSG))
+    {
+        BOOL    bCopy = TRUE;
+
+
+        //
+        // See if we need to grow the msg buffer
+        //
+
+        if (pMsg->dwTotalSize > gEventHandlerThreadParams.dwMsgSize)
+        {
+            DWORD   dwNewMsgSize = pMsg->dwTotalSize + 256;
+
+
+            if ((pMsg = DrvAlloc (dwNewMsgSize)))
+            {
+                CopyMemory(
+                    pMsg,
+                    gEventHandlerThreadParams.pMsg,
+                    sizeof(ASYNCEVENTMSG)
+                    );
+
+                DrvFree (gEventHandlerThreadParams.pMsg);
+
+                gEventHandlerThreadParams.pMsg = pMsg;
+
+                gEventHandlerThreadParams.dwMsgSize = dwNewMsgSize;
+            }
+            else
+            {
+                //
+                // Couldn't alloc a bigger buf, so try to complete this
+                // msg as gracefully as possible
+                //
+
+                bCopy = FALSE;
+
+                switch (pMsg->dwMsg)
+                {
+                case LINE_REPLY:
+
+                    pMsg->dwParam2 = LINEERR_NOMEM;
+                    break;
+
+                case PHONE_REPLY:
+
+                    pMsg->dwParam2 = PHONEERR_NOMEM;
+                    break;
+
+                default:  // BUGBUG any other msgs to special case?
+
+                    break;
+                }
+            }
+        }
+
+
+        dwUsedSize = (gEventHandlerThreadParams.pEventBuffer +
+            gEventHandlerThreadParams.dwEventBufferTotalSize)  -
+            gEventHandlerThreadParams.pDataOut;
+
+        if (dwUsedSize >= (pMsg->dwTotalSize - sizeof (ASYNCEVENTMSG)))
+        {
+            dwMoveSize        = pMsg->dwTotalSize - sizeof (ASYNCEVENTMSG);
+            dwMoveSizeWrapped = 0;
+        }
+        else
+        {
+            dwMoveSize        = dwUsedSize;
+            dwMoveSizeWrapped = (pMsg->dwTotalSize  - sizeof (ASYNCEVENTMSG)) -
+                dwUsedSize;
+        }
+
+        if (bCopy)
+        {
+            CopyMemory(
+                pMsg + 1,
+                gEventHandlerThreadParams.pDataOut,
+                dwMoveSize
+                );
+        }
+
+        if (dwMoveSizeWrapped)
+        {
+            if (bCopy)
+            {
+                CopyMemory(
+                    ((LPBYTE) (pMsg + 1)) + dwMoveSize,
+                    gEventHandlerThreadParams.pEventBuffer,
+                    dwMoveSizeWrapped
+                    );
+            }
+
+            gEventHandlerThreadParams.pDataOut =
+                gEventHandlerThreadParams.pEventBuffer + dwMoveSizeWrapped;
+        }
+        else
+        {
+            gEventHandlerThreadParams.pDataOut += dwMoveSize;
+        }
+    }
+
+    gEventHandlerThreadParams.dwEventBufferUsedSize -= pMsg->dwTotalSize;
+
+GetEventFromQueue_done:
+
+    LeaveCriticalSection (&gEventBufferCriticalSection);
+
+    ResetEvent (gEventHandlerThreadParams.hEvent);
+
+    return pMsg;
+}
+
+
+void
+EventHandlerThread(
+    LPVOID  pParams
+    )
+{
+    //
+    // NOTES:
+    //
+    // 1. depending on server side implementation, we may experience race
+    //    conditions where msgs that we expect to show up in a certain
+    //    sequence show up out of sequence (i.e. call state msgs that show
+    //    up before make call completion msgs), which could present problems.
+    //
+    //    one solution is to to queue call state/info msgs to incomplete
+    //    calls (to be sent after call is completed).  another is not to send
+    //    any call state msgs after the idle is received
+    //
+
+    PASYNCEVENTMSG  pMsg;
+
+
+    DBGOUT((3, "EventHandlerThread: enter"));
+
+    while (1)
+    {
+        //
+        // Wait for an event to show up in the queue
+        //
+
+        WaitForSingleObject (gEventHandlerThreadParams.hEvent, INFINITE);
+
+        if (gEventHandlerThreadParams.bExit)
+        {
+            break;
+        }
+
+
+        //
+        // Process the events in the queue
+        //
+
+        while ((pMsg = GetEventFromQueue()))
+        {
+            switch (pMsg->dwMsg)
+            {
+            case LINE_ADDRESSSTATE:
+
+                //assert (((PDRVLINE)(pMsg->hDevice))->dwKey == DRVLINE_KEY);
+
+                (*gpfnLineEventProc)(
+                    ((PDRVLINE)(pMsg->hDevice))->htLine,
+                    NULL,
+                    pMsg->dwMsg,
+                    pMsg->dwParam1,
+                    pMsg->dwParam2,
+                    pMsg->dwParam3
+                    );
+
+                break;
+
+            case LINE_CALLINFO:
+            case LINE_CALLSTATE:
+            case LINE_GENERATE:
+            case LINE_MONITORDIGITS:
+            case LINE_MONITORMEDIA:
+            case LINE_MONITORTONE:
+            {
+                //
+                // For all the msgs where hDevice refers to a call tapisrv
+                // will pass us the pLine (hRemoteLine) for that call in
+                // dwParam4 to make the lookup of the corresponding pCall
+                // easier
+                //
+
+                HCALL       hCall = (HCALL) pMsg->hDevice;
+                PDRVCALL    pCall;
+                PDRVLINE    pLine = (PDRVLINE) pMsg->dwParam4;
+                HTAPICALL   htCall;
+
+
+                //assert (pLine->dwKey == DRVLINE_KEY);
+
+                EnterCriticalSection (&gCallListCriticalSection);
+
+                pCall = (PDRVCALL) pLine->pCalls;
+
+                while (pCall && (pCall->hCall != hCall))
+                {
+                    pCall = pCall->pNext;
+                }
+
+                htCall = (pCall ? pCall->htCall : NULL);
+
+                LeaveCriticalSection (&gCallListCriticalSection);
+
+                if (!pCall)
+                {
+                    continue;
+                }
+
+                (*gpfnLineEventProc)(
+                    pLine->htLine,
+                    htCall,
+                    pMsg->dwMsg,
+                    pMsg->dwParam1,
+                    pMsg->dwParam2,
+                    pMsg->dwParam3
+                    );
+
+                break;
+            }
+            case LINE_DEVSPECIFIC:
+            case LINE_DEVSPECIFICFEATURE:
+            {
+                //
+                // For all the msgs where hDevice refers to a call tapisrv
+                // will pass us the pLine (hRemoteLine) for that call in
+                // dwParam4 to make the lookup of the corresponding pCall
+                // easier
+                //
+
+                HTAPICALL htCall;
+                PDRVLINE  pLine;
+
+
+                if (pMsg->dwParam4)
+                {
+                    HCALL       hCall = (HCALL) pMsg->hDevice;
+                    PDRVCALL    pCall;
+
+
+                    pLine = (PDRVLINE) pMsg->dwParam4;
+
+                    //assert (pLine->dwKey == DRVLINE_KEY);
+
+                    EnterCriticalSection (&gCallListCriticalSection);
+
+                    pCall = (PDRVCALL) pLine->pCalls;
+
+                    while (pCall && (pCall->hCall != hCall))
+                    {
+                        pCall = pCall->pNext;
+                    }
+
+                    htCall = (pCall ? pCall->htCall : NULL);
+
+                    LeaveCriticalSection (&gCallListCriticalSection);
+
+                    if (pCall)
+                    {
+                        pMsg->dwMsg = (pMsg->dwMsg == LINE_DEVSPECIFIC ?
+                            LINE_CALLDEVSPECIFIC :
+                            LINE_CALLDEVSPECIFICFEATURE);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+                else
+                {
+                    pLine = (PDRVLINE) pMsg->hDevice;
+
+                    //assert (pLine->dwKey == DRVLINE_KEY);
+
+                    htCall = NULL;
+                }
+
+                (*gpfnLineEventProc)(
+                    pLine->htLine,
+                    htCall,
+                    pMsg->dwMsg,
+                    pMsg->dwParam1,
+                    pMsg->dwParam2,
+                    pMsg->dwParam3
+                    );
+
+                break;
+            }
+            case PHONE_BUTTON:
+            case PHONE_DEVSPECIFIC:
+
+                //assert (((PDRVPHONE)(pMsg->hDevice))->dwKey == DRVPHONE_KEY);
+
+                (*gpfnPhoneEventProc)(
+                    ((PDRVPHONE)(pMsg->hDevice))->htPhone,
+                    pMsg->dwMsg,
+                    pMsg->dwParam1,
+                    pMsg->dwParam2,
+                    pMsg->dwParam3
+                    );
+
+                break;
+
+            case LINE_LINEDEVSTATE:
+
+                if (pMsg->dwParam1 & LINEDEVSTATE_REINIT)
+                {
+                    //
+                    // Be on our best behavior and immediately shutdown
+                    // our init instances on the server
+                    //
+
+                    Shutdown ((PDRVSERVER) pMsg->pInitData);
+                }
+
+                //assert (((PDRVLINE)(pMsg->hDevice))->dwKey == DRVLINE_KEY);
+
+                (*gpfnLineEventProc)(
+                    ((PDRVLINE)(pMsg->hDevice))->htLine,
+                    NULL,
+                    pMsg->dwMsg,
+                    pMsg->dwParam1,
+                    pMsg->dwParam2,
+                    pMsg->dwParam3
+                    );
+
+                break;
+
+            case PHONE_STATE:
+
+                if (pMsg->dwParam1 & PHONESTATE_REINIT)
+                {
+                    //
+                    // Be on our best behavior and immediately shutdown
+                    // our init instances on the server
+                    //
+
+                    Shutdown ((PDRVSERVER) pMsg->pInitData);
+                }
+
+                //assert (((PDRVPHONE)(pMsg->hDevice))->dwKey == DRVPHONE_KEY);
+
+                (*gpfnPhoneEventProc)(
+                    ((PDRVPHONE)(pMsg->hDevice))->htPhone,
+                    pMsg->dwMsg,
+                    pMsg->dwParam1,
+                    pMsg->dwParam2,
+                    pMsg->dwParam3
+                    );
+
+                break;
+
+            case LINE_CLOSE:
+            {
+                PDRVCALL    pCall;
+                PDRVLINE    pLine = (PDRVLINE) pMsg->hDevice;
+
+
+                //assert (pLine->dwKey == DRVLINE_KEY);
+
+
+                //
+                // Nullify the hLine field so that when TSPI_Close
+                // is called we know not to call the server
+                //
+
+                pLine->hLine = NULL;
+
+
+                //
+                // Safely walk the call list for this line & nullify
+                // each call's hCall field so that when TSPI_CloseCall
+                // is called we know not to call the server
+                //
+
+                EnterCriticalSection (&gCallListCriticalSection);
+
+                pCall = pLine->pCalls;
+
+                while (pCall)
+                {
+                    pCall->hCall = NULL;
+                    pCall = pCall->pNext;
+                }
+
+                LeaveCriticalSection (&gCallListCriticalSection);
+
+                (*gpfnLineEventProc)(pLine->htLine, NULL, LINE_CLOSE, 0, 0, 0);
+
+                break;
+            }
+            case PHONE_CLOSE:
+            {
+                PDRVPHONE   pPhone = (PDRVPHONE) pMsg->hDevice;
+
+
+                //assert (pPhone->dwKey == DRVPHONE_KEY);
+
+
+                //
+                // Nullify the hPhone field so that when TSPI_Close
+                // is called we know not to call the server
+                //
+
+                pPhone->hPhone = NULL;
+
+                (*gpfnPhoneEventProc)(pPhone->htPhone, PHONE_CLOSE, 0, 0, 0);
+
+                break;
+            }
+            case LINE_GATHERDIGITS: // BUGBUG
+
+                break;
+
+            case LINE_REPLY:
+            case PHONE_REPLY:
+            {
+                if (pMsg->pfnPostProcessProc)
+                {
+                    (*((POSTPROCESSPROC)(pMsg->pfnPostProcessProc)))(pMsg);
+                }
+
+                (*gpfnCompletionProc)(pMsg->dwParam1, pMsg->dwParam2);
+
+                break;
+            }
+            case LINE_CREATE:
+
+                // BUGBUG AddLine((PDRVSERVER) pMsg->pInitData, locDevID, srvDevID, FALSE);
+                //        (*gpfnLineCreateProc)()
+
+                break;
+
+            case PHONE_CREATE:
+
+                // BUGBUG AddPhone((PDRVSERVER) pMsg->pInitData, locDevID, srvDevID, FALSE);
+                //        (*gpfnPhoneCreateProc)()
+
+                break;
+
+            case LINE_APPNEWCALL:
+            {
+                PDRVLINE pLine = (PDRVLINE) pMsg->hDevice;
+                PDRVCALL pCall = DrvAlloc (sizeof (DRVCALL));
+
+
+                if (pCall)
+                {
+                    AddCallToList (pLine, pCall);
+
+                    pCall->hCall       = (HCALL) pMsg->dwParam2;
+                    pCall->dwAddressID = pMsg->dwParam1;
+
+                    (*gpfnLineEventProc)(
+                        pLine->htLine,
+                        NULL,
+                        LINE_NEWCALL,
+                        (DWORD) pCall,
+                        (DWORD) (&pCall->htCall),
+                        (DWORD) 0
+                        );
+
+                }
+                else
+                {
+                    // BUGBUG LINE_APPNEWCALL: err case (pCall == NULL)
+                }
+
+                break;
+            }
+            } // switch (pMsg->dwMsg)
+
+        } // while ((pMsg = GetEventFromQueue()))
+
+    } // while (1)
+
+    DBGOUT((3, "EventHandlerThread: exit"));
+
+    ExitThread (0);
+}
+
+
+PDRVLINE
+GetLineFromID(
+    DWORD   dwDeviceID
+    )
+{
+    PDRVLINE    pLine;
+
+
+    //
+    // First check to see if it's a "static" device, i.e. a device
+    // that we knew about at start up time, in which case we know
+    // it's exact location in the lookup table
+    //
+
+    if (dwDeviceID < (gdwLineDeviceIDBase + gdwInitialNumLineDevices))
+    {
+        pLine = gpLineLookup->aEntries + dwDeviceID - gdwLineDeviceIDBase;
+    }
+
+
+    //
+    // If here, the id references a "dynamic" device, i.e. one that
+    // we found out about on the fly via a CREATE msg, so we need to
+    // walk the lookup table(s) to find it
+    //
+    // TODO: the for loop down below is not the most efficient
+    //
+
+    else
+    {
+        PDRVLINELOOKUP  pLookup = gpLineLookup;
+
+
+        while (pLookup->aEntries[pLookup->dwUsedEntries - 1].
+                dwDeviceIDLocal < dwDeviceID)
+        {
+            pLookup = pLookup->pNext;
+        }
+
+        for(
+            pLine = pLookup->aEntries;
+            pLine->dwDeviceIDLocal != dwDeviceID;
+            pLine++
+            );
+    }
+
+    return pLine;
+}
+
+
+PDRVPHONE
+GetPhoneFromID(
+    DWORD   dwDeviceID
+    )
+{
+    PDRVPHONE   pPhone;
+
+
+    //
+    // First check to see if it's a "static" device, i.e. a device
+    // that we knew about at start up time, in which case we know
+    // it's exact location in the lookup table
+    //
+
+    if (dwDeviceID < (gdwPhoneDeviceIDBase + gdwInitialNumPhoneDevices))
+    {
+        pPhone = gpPhoneLookup->aEntries + dwDeviceID - gdwPhoneDeviceIDBase;
+    }
+
+
+    //
+    // If here, the id references a "dynamic" device, i.e. one that
+    // we found out about on the fly via a CREATE msg, so we need to
+    // walk the lookup table(s) to find it
+    //
+    // TODO: the for loop down below is not the most efficient
+    //
+
+    else
+    {
+        PDRVPHONELOOKUP pLookup = gpPhoneLookup;
+
+
+        while (pLookup->aEntries[pLookup->dwUsedEntries - 1].
+                dwDeviceIDLocal < dwDeviceID)
+        {
+            pLookup = pLookup->pNext;
+        }
+
+        for(
+            pPhone = pLookup->aEntries;
+            pPhone->dwDeviceIDLocal != dwDeviceID;
+            pPhone++
+            );
+    }
+
+    return pPhone;
+}
+
+
+BOOL
+WINAPI
+GrowBuf(
+    LPBYTE *ppBuf,
+    LPDWORD pdwBufSize,
+    DWORD   dwCurrValidBytes,
+    DWORD   dwBytesToAdd
+    )
+{
+    DWORD   dwNewBufSize = *pdwBufSize * 2;
+    LPBYTE  pNewBuf;
+
+
+    //
+    // Try to get a new buffer big enough to hold
+    // (dwCurrValidBytes + dwBytesToAdd)
+    //
+
+    while (dwNewBufSize < (dwCurrValidBytes + dwBytesToAdd))
+    {
+        dwNewBufSize *= 2;
+    }
+
+    if (!(pNewBuf = DrvAlloc (dwNewBufSize)))
+    {
+        return FALSE;
+    }
+
+
+    //
+    // Copy the "valid" bytes in the old buf to the new buf,
+    // then free the old buf
+    //
+
+    CopyMemory (pNewBuf, *ppBuf, dwCurrValidBytes);
+
+    DrvFree (*ppBuf);
+
+
+    //
+    // Reset the pointers to the new buf & buf size
+    //
+
+    *ppBuf = pNewBuf;
+    *pdwBufSize = dwNewBufSize;
+
+    return TRUE;
+}
+
+
+PCLIENT_THREAD_INFO
+WINAPI
+GetTls(
+    void
+    )
+{
+    PCLIENT_THREAD_INFO pClientThreadInfo;
+
+
+    if (!(pClientThreadInfo = TlsGetValue (gdwTlsIndex)))
+    {
+        pClientThreadInfo = (PCLIENT_THREAD_INFO)
+            DrvAlloc (sizeof(CLIENT_THREAD_INFO));
+
+        if (!pClientThreadInfo)
+        {
+            return NULL;
+        }
+
+        pClientThreadInfo->pBuf = DrvAlloc (INITIAL_CLIENT_THREAD_BUF_SIZE);
+
+        if (!pClientThreadInfo->pBuf)
+        {
+            DrvFree (pClientThreadInfo);
+
+            return NULL;
+        }
+
+        pClientThreadInfo->dwBufSize = INITIAL_CLIENT_THREAD_BUF_SIZE;
+
+        TlsSetValue (gdwTlsIndex, (LPVOID) pClientThreadInfo);
+    }
+
+    return pClientThreadInfo;
+}
+
+
+#if DBG
+
+LONG
+WINAPI
+RemoteDoFunc(
+    PREMOTE_FUNC_ARGS   pFuncArgs,
+    char               *pszFuncName
+    )
+
+#else
+
+LONG
+WINAPI
+RemoteDoFunc(
+    PREMOTE_FUNC_ARGS   pFuncArgs
+    )
+
+#endif
+{
+    DWORD   dwFuncClassErrorIndex = (pFuncArgs->Flags & 0x00000030) >> 4;
+    LONG    lResult;
+    BOOL    bCopyOnSuccess = FALSE;
+    DWORD   i, j, dwValue, dwUsedSize, dwNeededSize;
+    PDRVSERVER          pServer;
+    PCLIENT_THREAD_INFO pTls;
+
+
+    //
+    // Get the tls
+    //
+
+    if (!(pTls = GetTls()))
+    {
+        lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+        goto RemoteDoFunc_return;
+    }
+
+
+    //
+    // Validate all the func args
+    //
+
+    dwNeededSize = dwUsedSize = sizeof (TAPI32_MSG);
+
+    for (i = 0, j = 0; i < (pFuncArgs->Flags & NUM_ARGS_MASK); i++, j++)
+    {
+        dwValue = ((PTAPI32_MSG) pTls->pBuf)->Params[j] = pFuncArgs->Args[i];
+
+        switch (pFuncArgs->ArgTypes[i])
+        {
+        case Dword:
+
+            //
+            // Nothing to check, just continue
+            //
+
+            continue;
+
+        case LineID:
+        {
+            PDRVLINE    pLine = GetLineFromID (dwValue);
+
+
+            pServer = pLine->pServer;
+
+            ((PTAPI32_MSG) pTls->pBuf)->Params[j] = pLine->dwDeviceIDServer;
+
+            continue;
+        }
+        case PhoneID:
+        {
+            PDRVPHONE   pPhone = GetPhoneFromID (dwValue);
+
+
+            pServer = pPhone->pServer;
+
+            ((PTAPI32_MSG) pTls->pBuf)->Params[j] = pPhone->dwDeviceIDServer;
+
+            continue;
+        }
+        case Hdcall:
+
+            //
+            // Save the pServer & adjust the call handle as understood by
+            // the server
+            //
+
+            pServer = ((PDRVCALL) dwValue)->pServer;
+
+            ((PTAPI32_MSG) pTls->pBuf)->Params[j] = (DWORD)
+                ((PDRVCALL) dwValue)->hCall;
+
+            continue;
+
+        case Hdline:
+
+            //
+            // Save the pServer & adjust the line handle as understood by
+            // the server
+            //
+
+            pServer = ((PDRVLINE) dwValue)->pServer;
+
+            ((PTAPI32_MSG) pTls->pBuf)->Params[j] = (DWORD)
+                ((PDRVLINE) dwValue)->hLine;
+
+            continue;
+
+        case Hdphone:
+
+            //
+            // Save the pServer & adjust the phone handle as understood by
+            // the server
+            //
+
+            pServer = ((PDRVPHONE) dwValue)->pServer;
+
+            ((PTAPI32_MSG) pTls->pBuf)->Params[j] = (DWORD)
+                ((PDRVPHONE) dwValue)->hPhone;
+
+            continue;
+
+        case lpDword:
+
+            bCopyOnSuccess = TRUE;
+
+            continue;
+
+        case lpsz:
+
+            //
+            // Check if dwValue is a valid string ptr and if so
+            // copy the contents of the string to the extra data
+            // buffer passed to the server, else indicate no data
+            //
+
+            if (dwValue)
+            {
+                DWORD   n = (lstrlenW ((WCHAR *) dwValue) + 1) *
+                            sizeof (WCHAR),
+                        nAligned = (n + 3) & 0xfffffffc;
+
+
+                if ((nAligned + dwUsedSize) > pTls->dwBufSize)
+                {
+                    if (!GrowBuf(
+                            &pTls->pBuf,
+                            &pTls->dwBufSize,
+                            dwUsedSize,
+                            nAligned
+                            ))
+                    {
+                        lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+                        goto RemoteDoFunc_return;
+                    }
+                }
+
+                CopyMemory (pTls->pBuf + dwUsedSize, (LPBYTE) dwValue, n);
+
+
+                //
+                // Pass the server the offset of the string in the var data
+                // portion of the buffer
+                //
+
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] =
+                    dwUsedSize - sizeof (TAPI32_MSG);
+
+
+                //
+                // Increment the total number of data bytes
+                //
+
+                dwUsedSize   += nAligned;
+                dwNeededSize += nAligned;
+            }
+            else
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = TAPI_NO_DATA;
+            }
+
+            continue;
+
+        case lpGet_Struct:
+        case lpGet_SizeToFollow:
+        {
+            BOOL  bSizeToFollow = (pFuncArgs->ArgTypes[i]==lpGet_SizeToFollow);
+            DWORD dwSize;
+
+
+            if (bSizeToFollow)
+            {
+#if DBG
+                //
+                // Check to make sure the following arg is of type Size
+                //
+
+                if ((i == ((pFuncArgs->Flags & NUM_ARGS_MASK) - 1)) ||
+                    (pFuncArgs->ArgTypes[i + 1] != Size))
+                {
+                    DBGOUT((
+                        2,
+                        "DoFunc: error, lpGet_SizeToFollow !followed by Size"
+                        ));
+
+                    lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                    goto RemoteDoFunc_return;
+                }
+#endif
+                dwSize = pFuncArgs->Args[i + 1];
+            }
+            else
+            {
+                dwSize = *((LPDWORD) dwValue); // lpXxx->dwTotalSize
+            }
+
+            if (bSizeToFollow)
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = TAPI_NO_DATA;
+                ((PTAPI32_MSG) pTls->pBuf)->Params[++j] = pFuncArgs->Args[++i];
+            }
+            else
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = dwSize;
+            }
+
+
+            //
+            // Now set the bCopyOnSuccess flag to indicate that we've data
+            // to copy back on successful completion, and add to the
+            // dwNeededSize field
+            //
+
+            bCopyOnSuccess = TRUE;
+
+            dwNeededSize += dwSize;
+
+            continue;
+        }
+        case lpSet_Struct:
+        case lpSet_SizeToFollow:
+        {
+            BOOL  bSizeToFollow = (pFuncArgs->ArgTypes[i]==lpSet_SizeToFollow);
+            DWORD dwSize, dwSizeAligned;
+
+#if DBG
+            //
+            // Check to make sure the following arg is of type Size
+            //
+
+            if (bSizeToFollow &&
+                ((i == ((pFuncArgs->Flags & NUM_ARGS_MASK) - 1)) ||
+                (pFuncArgs->ArgTypes[i + 1] != Size)))
+            {
+                DBGOUT((
+                    2,
+                    "DoFunc: error, lpSet_SizeToFollow !followed by Size"
+                    ));
+
+                lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                goto RemoteDoFunc_return;
+            }
+#endif
+            if (bSizeToFollow)
+            {
+                dwSize = (dwValue ? pFuncArgs->Args[i + 1] : 0);
+            }
+            else
+            {
+                dwSize = (dwValue ? *((LPDWORD) dwValue) : 0);
+            }
+
+            if (dwSize)
+            {
+                //
+                // Grow the buffer if necessary, & do the copy
+                //
+
+                dwSizeAligned = (dwSize + 3) & 0xfffffffc;
+
+                if ((dwSizeAligned + dwUsedSize) > pTls->dwBufSize)
+                {
+                    if (!GrowBuf(
+                            &pTls->pBuf,
+                            &pTls->dwBufSize,
+                            dwUsedSize,
+                            dwSizeAligned
+                            ))
+                    {
+                        lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+                        goto RemoteDoFunc_return;
+                    }
+                }
+
+                CopyMemory (pTls->pBuf + dwUsedSize, (LPBYTE) dwValue, dwSize);
+            }
+            else
+            {
+                dwSizeAligned = 0;
+            }
+
+
+            //
+            // Pass the server the offset of the data in the var data
+            // portion of the buffer
+            //
+
+            if (dwSize)
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] =
+                    dwUsedSize - sizeof (TAPI32_MSG);
+            }
+            else
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[j] = TAPI_NO_DATA;
+            }
+
+
+            //
+            // Increment the dwXxxSize vars appropriately
+            //
+
+            dwUsedSize   += dwSizeAligned;
+            dwNeededSize += dwSizeAligned;
+
+
+            //
+            // Since we already know the next arg (Size) just handle
+            // it here so we don't have to run thru the loop again
+            //
+
+            if (bSizeToFollow)
+            {
+                ((PTAPI32_MSG) pTls->pBuf)->Params[++j] = pFuncArgs->Args[++i];
+            }
+
+            continue;
+        }
+#if DBG
+        case Size:
+
+            DBGOUT((2, "DoFunc: error, hit case Size"));
+
+            continue;
+
+        default:
+
+            DBGOUT((2, "DoFunc: error, unknown arg type"));
+
+            continue;
+#endif
+        } // switch
+
+    } // for
+
+
+    //
+    //
+    //
+
+    if (pServer->bDisconnected)
+    {
+        lResult = gaServerDisconnectedErrors[dwFuncClassErrorIndex];
+    }
+
+
+    //
+    // Now make the request
+    //
+
+    if (dwNeededSize > pTls->dwBufSize)
+    {
+        if (!GrowBuf(
+            &pTls->pBuf,
+            &pTls->dwBufSize,
+            dwUsedSize,
+            dwNeededSize - pTls->dwBufSize
+            ))
+        {
+            lResult = gaNoMemErrors[dwFuncClassErrorIndex];
+            goto RemoteDoFunc_return;
+        }
+    }
+
+    ((PTAPI32_MSG) pTls->pBuf)->u.Req_Func = (DWORD)HIWORD(pFuncArgs->Flags);
+
+    {
+        DWORD   dwRetryCount = 0;
+
+
+        do
+        {
+            RpcTryExcept
+            {
+                ClientRequest(
+                    pServer->phContext,
+                    pTls->pBuf,
+                    dwNeededSize,
+                    &dwUsedSize
+                    );
+
+                lResult = ((PTAPI32_MSG) pTls->pBuf)->u.Ack_ReturnValue;
+
+                dwRetryCount = gdwRetryCount;
+
+
+                //
+                // If this is an async func & success, then munge the result to
+                // be the local async request id
+                //
+
+                if ((pFuncArgs->Flags & ASYNC) && (lResult > 0))
+                {
+                    lResult = pFuncArgs->Args[0];
+                }
+            }
+            RpcExcept (1)
+            {
+                if (dwRetryCount++ < gdwRetryCount)
+                {
+                    Sleep (gdwRetryTimeout);
+                }
+                else
+                {
+                    lResult = gaOpFailedErrors[dwFuncClassErrorIndex];
+                }
+            }
+            RpcEndExcept
+
+        } while (dwRetryCount < gdwRetryCount);
+    }
+
+
+    //
+    // If request completed successfully and the bCopyOnSuccess flag
+    // is set then we need to copy data back to client buffer(s)
+    //
+
+    if ((lResult == TAPI_SUCCESS) && bCopyOnSuccess)
+    {
+        for (i = 0, j = 0; i < (pFuncArgs->Flags & NUM_ARGS_MASK); i++, j++)
+        {
+            PTAPI32_MSG pMsg = (PTAPI32_MSG) pTls->pBuf;
+
+
+            switch (pFuncArgs->ArgTypes[i])
+            {
+            case Dword:
+            case LineID:
+            case PhoneID:
+            case Hdcall:
+            case Hdline:
+            case Hdphone:
+            case lpsz:
+            case lpSet_Struct:
+
+                continue;
+
+            case lpDword:
+
+                //
+                // Fill in the pointer with the return value
+                //
+
+                *((LPDWORD) pFuncArgs->Args[i]) = pMsg->Params[j];
+
+                continue;
+
+            case lpGet_SizeToFollow:
+
+                //
+                // Fill in the buf with the return data
+                //
+
+                CopyMemory(
+                    (LPBYTE) pFuncArgs->Args[i],
+                    pTls->pBuf + pMsg->Params[j] + sizeof(TAPI32_MSG),
+                    pMsg->Params[j+1]
+                    );
+
+
+                //
+                // Increment i (and j, since Size passed as arg in msg)
+                // to skip following Size arg in pFuncArgs->Args
+                //
+
+                i++;
+                j++;
+
+                continue;
+
+            case lpSet_SizeToFollow:
+
+                //
+                // Increment i (and j, since Size passed as arg in msg)
+                // to skip following Size arg in pFuncArgs->Args
+                //
+
+                i++;
+                j++;
+
+                continue;
+
+            case lpGet_Struct:
+
+                //
+                // Params[j] contains the offset in the var data
+                // portion of pTls->pBuf of some TAPI struct.
+                // Get the dwUsedSize value from this struct &
+                // copy that many bytes from pTls->pBuf to client buf
+                //
+
+                if (pMsg->Params[j] != TAPI_NO_DATA)
+                {
+
+                    LPDWORD pStruct;
+
+
+                    pStruct = (LPDWORD) (pTls->pBuf + sizeof(TAPI32_MSG) +
+                        pMsg->Params[j]);
+
+                    CopyMemory(
+                        (LPBYTE) pFuncArgs->Args[i],
+                        (LPBYTE) pStruct,
+                        *(pStruct + 2)      // ptr to dwUsedSize field
+                        );
+                }
+
+                continue;
+
+            default:
+
+                continue;
+            }
+        }
+    }
+
+RemoteDoFunc_return:
+
+    DBGOUT((3, "%s: exit, returning x%x", pszFuncName, lResult));
+
+    return lResult;
+}
+
+
+//
+// --------------------------- TAPI_lineXxx funcs -----------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lAccept),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineAccept"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdConfCall,
+    HDRVCALL        hdConsultCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        Hdcall
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdConfCall,
+        (DWORD) hdConsultCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lAddToConference),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineAddToConference"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lAnswer),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineAnswer"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpsz,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lBlindTransfer),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineBlindTransfer"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE    hdLine
+    )
+{
+    //
+    // Check if the hLine is still valid (could have been zeroed
+    // out on LINE_CLOSE, so no need to call server)
+    //
+
+    if (((PDRVLINE) hdLine)->hLine)
+    {
+        static REMOTE_ARG_TYPES argTypes[] =
+        {
+            Hdline
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 1, lClose),
+            (LPDWORD) &hdLine,
+            argTypes
+        };
+
+
+        REMOTEDOFUNC (&funcArgs, "lineClose");
+    }
+
+    //assert (((PDRVLINE) hdLine)->pCalls == NULL);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL    hdCall
+    )
+{
+    //
+    // Check if the hCall is still valid (could have been zeroed
+    // out on LINE_CLOSE, so no need to call server)
+    //
+
+    if (((PDRVCALL) hdCall)->hCall)
+    {
+        static REMOTE_ARG_TYPES argTypes[] =
+        {
+            Hdcall
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 1, lDeallocateCall),   // API differs
+            (LPDWORD) &hdCall,
+            argTypes
+        };
+
+
+        REMOTEDOFUNC (&funcArgs, "lineCloseCall");
+    }
+
+    RemoveCallFromList ((PDRVCALL) hdCall);
+    DrvFree ((LPVOID) hdCall);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPDWORD         lpdwCompletionID,
+    DWORD           dwCompletionMode,
+    DWORD           dwMessageID
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdcall,
+        Dword, // BUGBUG? should be lpDword?
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) 0,          // BUGBUG ppproc
+        (DWORD) hdCall,
+        (DWORD) lpdwCompletionID,
+        (DWORD) dwCompletionMode,
+        (DWORD) dwMessageID
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lCompleteCall),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineCompleteCall"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    HDRVCALL        hdConsultCall,
+    HTAPICALL       htConfCall,
+    LPHDRVCALL      lphdConfCall,
+    DWORD           dwTransferMode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdcall,
+        Hdcall,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) 0,
+        (DWORD) hdCall,
+        (DWORD) hdConsultCall,
+        (DWORD) 0,
+        (DWORD) dwTransferMode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lCompleteTransfer),
+        args,
+        argTypes
+    };
+    LONG        lResult;
+    PDRVCALL    pConfCall;
+
+
+    if (dwTransferMode == LINETRANSFERMODE_CONFERENCE)
+    {
+        if (!(pConfCall = DrvAlloc (sizeof (DRVCALL))))
+        {
+            return LINEERR_NOMEM;
+        }
+
+
+        //
+        // Assume success & add the call to the line's list before we
+        // even make the request.  This makes cleanup alot easier if
+        // the server goes down or some such uncooth event.
+        //
+
+        AddCallToList ((PDRVLINE) ((PDRVCALL) hdCall)->pLine, pConfCall);
+
+        pConfCall->htCall = htConfCall;
+
+        *lphdConfCall = (HDRVCALL) pConfCall;
+
+        args[1] = (DWORD) ((POSTPROCESSPROC) TSPI_lineMakeCall_PostProcess);
+        args[4] = (DWORD) pConfCall;
+    }
+    else
+    {
+        pConfCall = NULL;
+    }
+
+    if ((lResult = REMOTEDOFUNC (&funcArgs, "lineCompleteTransfer")) < 0)
+    {
+        if (pConfCall)
+        {
+            RemoveCallFromList (pConfCall);
+            DrvFree (pConfCall);
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    // BUGBUG TSPI_lineConditionalMediaDetection
+
+    // try an open on the specified line w/ the specified media modes
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+void
+PASCAL
+TSPI_lineDevSpecific_PostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "lineDevSpecificPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD   dwSize  = pMsg->dwTotalSize - sizeof (TAPI32_MSG);
+        LPBYTE  pParams = (LPBYTE) pMsg->dwParam3;
+
+
+        CopyMemory (pParams, (LPBYTE) (pMsg + 1), dwSize);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdline,
+        Dword,
+        Dword,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineDevSpecific_PostProcess),
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) hdCall,
+        (DWORD) lpParams,   // pass the actual pointer (for post processing)
+        (DWORD) lpParams,   // pass data
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 8, lDevSpecific),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineDevSpecific"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwFeature,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdline,
+        Dword,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineDevSpecific_PostProcess),
+        (DWORD) hdLine,
+        (DWORD) dwFeature,
+        (DWORD) lpParams,   // pass the actual pointer (for post processing)
+        (DWORD) lpParams,   // pass data
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lDevSpecificFeature),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineDevSpecificFeature"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpsz,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lDial),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineDial"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lDrop),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineDrop"));
+}
+
+/*
+LONG
+TSPIAPI
+TSPI_lineDropOnClose(
+    HDRVCALL    hdCall
+    )
+{
+    // BUGBUG TSPI_lineDropOnClose (how about not exporting this?)
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineDropNoOwner(
+    HDRVCALL    hdCall
+    )
+{
+    // BUGBUG TSPI_lineDropNoOwner (how about not exporting this?)
+
+    return LINEERR_OPERATIONFAILED;
+}
+*/
+
+LONG
+TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    // BUGBUG TSPI_lineForward
+
+    // remember to use ppproc param
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwEndToEndID,
+    DWORD       dwDigitModes,
+    LPWSTR      lpsDigits,
+    DWORD       dwNumDigits,
+    LPCWSTR     lpszTerminationDigits,
+    DWORD       dwFirstDigitTimeout,
+    DWORD       dwInterDigitTimeout
+    )
+{
+    // BUGBUG TSPI_lineGatherDigits
+
+    // remember to use ppproc param, the dwEndToEndID presents a problem
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwEndToEndID,
+    DWORD       dwDigitMode,
+    LPCWSTR     lpszDigits,
+    DWORD       dwDuration
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        Dword,
+        lpsz,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) dwDigitMode,
+        (DWORD) lpszDigits,
+        (DWORD) dwDuration,
+        (DWORD) dwEndToEndID,
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGenerateDigits),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGenerateDigits"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        Dword,
+        Dword,
+        Dword,
+        Dword,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) dwToneMode,
+        (DWORD) dwDuration,
+        (DWORD) dwNumTones,
+        (DWORD) TAPI_NO_DATA,
+        (DWORD) 0,
+        (DWORD) dwEndToEndID
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 7, lGenerateTone),
+        args,
+        argTypes
+    };
+
+
+    if (dwToneMode == LINETONEMODE_CUSTOM)
+    {
+        argTypes[4] = lpSet_SizeToFollow;
+        args[4]     = (DWORD) lpTones;
+        argTypes[5] = Size;
+        args[5]     = dwNumTones * sizeof(LINEGENERATETONE);
+    }
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGenerateTone"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD              dwDeviceID,
+    DWORD              dwAddressID,
+    DWORD              dwTSPIVersion,
+    DWORD              dwExtVersion,
+    LPLINEADDRESSCAPS  lpAddressCaps
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        LineID,
+        Dword,
+        Dword,
+        Dword,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) (GetLineFromID (dwDeviceID))->pServer->hLineApp,
+        (DWORD) dwDeviceID,
+        (DWORD) dwAddressID,
+        (DWORD) dwTSPIVersion,
+        (DWORD) dwExtVersion,
+        (DWORD) lpAddressCaps,
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, lGetAddressCaps),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetAddressCaps"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwAddressID,
+    DWORD       dwAddressMode,
+    LPCWSTR     lpsAddress,
+    DWORD       dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdline,
+        lpDword,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) lpdwAddressID,
+        (DWORD) dwAddressMode,
+        (DWORD) lpsAddress,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGetAddressID),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetAddressID"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdline,
+        Dword,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) lpAddressStatus
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetAddressStatus),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetAddressStatus"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL    hdCall,
+    LPDWORD     lpdwAddressID
+    )
+{
+    *lpdwAddressID = ((PDRVCALL) hdCall)->dwAddressID;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL        hdCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) lpCallInfo
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetCallInfo),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetCallInfo"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) lpCallStatus
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetCallStatus),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetCallStatus"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD           dwDeviceID,
+    DWORD           dwTSPIVersion,
+    DWORD           dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        LineID,
+        Dword,
+        Dword,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) (GetLineFromID (dwDeviceID))->pServer->hLineApp,
+        (DWORD) dwDeviceID,
+        (DWORD) dwTSPIVersion,
+        (DWORD) dwExtVersion,
+        (DWORD) lpLineDevCaps
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, lGetDevCaps),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetDevCaps"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD       dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCWSTR     lpszDeviceClass
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        LineID,
+        lpGet_Struct,
+        lpsz
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwDeviceID,
+        (DWORD) lpDeviceConfig,
+        (DWORD) lpszDeviceClass
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lGetDevConfig),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetDevConfig"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+    CopyMemory(
+        lpExtensionID,
+        &(GetLineFromID (dwDeviceID))->ExtensionID,
+        sizeof (LINEEXTENSIONID)
+        );
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD   dwDeviceID,
+    LPCWSTR lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    *lphIcon = ghLineIcon;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE    hdLine,
+    DWORD       dwAddressID,
+    HDRVCALL    hdCall,
+    DWORD       dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+{
+    if (lstrcmpiW (lpszDeviceClass, L"tapi/line") != 0)
+    {
+        REMOTE_ARG_TYPES argTypes[] =
+        {
+            (dwSelect == LINECALLSELECT_CALL ? Dword : Hdline),
+            Dword,
+            (dwSelect == LINECALLSELECT_CALL ? Hdcall : Dword),
+            Dword,
+            lpGet_Struct,
+            lpsz
+        };
+        DWORD args[] =
+        {
+            (DWORD) hdLine,
+            (DWORD) dwAddressID,
+            (DWORD) hdCall,
+            (DWORD) dwSelect,
+            (DWORD) lpDeviceID,
+            (DWORD) lpszDeviceClass
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 6, lGetID),
+            args,
+            argTypes
+        };
+
+
+        return (REMOTEDOFUNC (&funcArgs, "lineGetID"));
+    }
+
+    if (lpDeviceID->dwTotalSize <
+        (lpDeviceID->dwNeededSize = sizeof (VARSTRING) + sizeof (DWORD)))
+    {
+        lpDeviceID->dwUsedSize = 3 * sizeof (DWORD);
+    }
+    else
+    {
+        lpDeviceID->dwUsedSize = lpDeviceID->dwNeededSize;
+
+        lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+        lpDeviceID->dwStringSize   = sizeof (DWORD);
+        lpDeviceID->dwStringOffset = sizeof (VARSTRING);
+
+        if (dwSelect == LINECALLSELECT_CALL)
+        {
+            *((LPDWORD)(lpDeviceID + 1)) =
+                ((PDRVCALL) hdCall)->pLine->dwDeviceIDLocal;
+        }
+        else
+        {
+            *((LPDWORD)(lpDeviceID + 1)) =
+                ((PDRVLINE) hdLine)->dwDeviceIDLocal;
+        }
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE        hdLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdline,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) lpLineDevStatus
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetLineDevStatus),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetLineDevStatus"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE    hdLine,
+    LPDWORD     lpdwNumAddressIDs
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdline,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) lpdwNumAddressIDs
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lGetNumAddressIDs),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineGetNumAddressIDs"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lHold),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineHold"));
+}
+
+void
+PASCAL
+TSPI_lineMakeCall_PostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    PDRVCALL    pCall = (PDRVCALL) pMsg->dwParam4;
+
+
+    DBGOUT((3, "TSPI_lineMakeCall_PostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%x, dwP2=x%x, dwP3=x%x, dwP4=x%x",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        pCall->hCall = (HCALL) pMsg->dwParam3;
+    }
+    else
+    {
+        RemoveCallFromList (pCall);
+
+        DrvFree (pCall);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdline,
+        Dword,
+        lpsz,
+        Dword,
+        lpSet_Struct,
+        Dword
+    };
+    PDRVCALL    pCall = DrvAlloc (sizeof (DRVCALL));
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineMakeCall_PostProcess),
+        (DWORD) hdLine,
+        (DWORD) pCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode,
+        (DWORD) lpCallParams,
+        (DWORD) 0xffffffff      // dwCallParamsCodePage
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 8, lMakeCall),
+        args,
+        argTypes
+    };
+    LONG    lResult;
+
+
+    if (pCall)
+    {
+        //
+        // Assume success & add the call to the line's list before we
+        // even make the request.  This makes cleanup alot easier if
+        // the server goes down or some such uncooth event.
+        //
+
+        AddCallToList ((PDRVLINE) hdLine, pCall);
+
+        pCall->htCall = htCall;
+
+        *lphdCall = (HDRVCALL) pCall;
+
+        if ((lResult = REMOTEDOFUNC (&funcArgs, "lineMakeCall")) < 0)
+        {
+            RemoveCallFromList (pCall);
+
+            DrvFree (pCall);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL    hdCall,
+    DWORD       dwDigitModes
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) dwDigitModes
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lMonitorDigits),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineMonitorDigits"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaModes
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) dwMediaModes
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lMonitorMedia),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineMonitorMedia"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) lpToneList,
+        (DWORD) dwNumEntries * sizeof (LINEMONITORTONE),
+        (DWORD) dwToneListID
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lMonitorTones),
+        args,
+        argTypes
+    };
+
+
+    if (!lpToneList)
+    {
+        funcArgs.ArgTypes[1] = Dword;
+        funcArgs.Args[1]     = TAPI_NO_DATA;
+        funcArgs.ArgTypes[2] = Dword;
+    }
+
+    return (REMOTEDOFUNC (&funcArgs, "lineMonitorTones"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        LineID,
+        Dword,
+        Dword,
+        Dword,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) (GetLineFromID (dwDeviceID))->pServer->hLineApp,
+        (DWORD) dwDeviceID,
+        (DWORD) dwTSPIVersion,
+        (DWORD) dwLowVersion,
+        (DWORD) dwHighVersion,
+        (DWORD) lpdwExtVersion,
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, lNegotiateExtVersion),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineNegotiateExtVersion"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    if (dwDeviceID == INITIALIZE_NEGOTIATION)
+    {
+        *lpdwTSPIVersion = TAPI_VERSION_CURRENT;
+    }
+    else
+    {
+        *lpdwTSPIVersion = (GetLineFromID (dwDeviceID))->dwXPIVersion;
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD       dwDeviceID,
+    HTAPILINE   htLine,
+    LPHDRVLINE  lphdLine,
+    DWORD       dwTSPIVersion,
+    LINEEVENT   lpfnEventProc
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,      // hLineApp
+        LineID,     // dev id
+        lpDword,    // lphLine
+        Dword,      // API version
+        Dword,      // ext version
+        Dword,      // callback inst
+        Dword,      // privileges
+        Dword,      // dw media modes
+        Dword,      // call params
+        Dword,      // dwAsciiCallParamsCodePage
+        Dword       // remote hLine
+    };
+    PDRVLINE pLine = GetLineFromID (dwDeviceID);
+    DWORD args[] =
+    {
+        (DWORD) pLine->pServer->hLineApp,
+        (DWORD) dwDeviceID,
+        (DWORD) &pLine->hLine,
+        (DWORD) dwTSPIVersion,
+        (DWORD) 0,
+        (DWORD) 0,
+        (DWORD) LINECALLPRIVILEGE_NONE,
+        (DWORD) 0,
+        (DWORD) 0,
+        (DWORD) 0xffffffff,
+        (DWORD) pLine
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 11, lOpen),
+        args,
+        argTypes
+    };
+
+
+    pLine->dwKey  = DRVLINE_KEY;
+    pLine->htLine = htLine;
+
+    *lphdLine = (HDRVLINE) pLine;
+
+#if DBG
+
+    {
+        LONG lResult = REMOTEDOFUNC (&funcArgs, "lineOpen");
+
+        return lResult;
+    }
+
+#else
+
+    return (REMOTEDOFUNC (&funcArgs, "lineOpen"));
+
+#endif
+}
+
+
+void
+PASCAL
+TSPI_linePark_PostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    DBGOUT((3, "lineParkPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD       dwSize = pMsg->dwTotalSize - sizeof (TAPI32_MSG);
+        LPVARSTRING pNonDirAddress = (LPVARSTRING) pMsg->dwParam3;
+
+
+        CopyMemory (pNonDirAddress, (LPBYTE) (pMsg + 1), dwSize);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    DWORD           dwParkMode,
+    LPCWSTR         lpszDirAddress,
+    LPVARSTRING     lpNonDirAddress
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdcall,
+        Dword,
+        lpsz,
+        Dword,          // pass ptr as Dword for post processing
+        lpGet_Struct    // pass ptr as lpGet_Xx to retrieve dwTotalSize
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_linePark_PostProcess),
+        (DWORD) hdCall,
+        (DWORD) dwParkMode,
+        (DWORD) lpszDirAddress,
+        (DWORD) lpNonDirAddress,
+        (DWORD) lpNonDirAddress
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lPark),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "linePark"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCWSTR         lpszDestAddress,
+    LPCWSTR         lpszGroupID
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdline,
+        Dword,
+        Dword,
+        lpsz,
+        lpsz
+    };
+    PDRVCALL pCall = DrvAlloc (sizeof (DRVCALL));
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineMakeCall_PostProcess),
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) pCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) lpszGroupID
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lPickup),
+        args,
+        argTypes
+    };
+    LONG lResult;
+
+
+    if (pCall)
+    {
+        AddCallToList ((PDRVLINE) hdLine, pCall);
+
+        pCall->htCall  = htCall;
+
+        *lphdCall = (HDRVCALL) pCall;
+
+        if ((lResult = REMOTEDOFUNC (&funcArgs, "linePickup")) < 0)
+        {
+            RemoveCallFromList (pCall);
+
+            DrvFree (pCall);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdcall,
+        Dword,
+        lpSet_Struct,
+        Dword
+    };
+    PDRVCALL pConsultCall = DrvAlloc (sizeof (DRVCALL));
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineMakeCall_PostProcess),
+        (DWORD) hdConfCall,
+        (DWORD) pConsultCall,
+        (DWORD) lpCallParams,
+        (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lPrepareAddToConference),
+        args,
+        argTypes
+    };
+    LONG lResult;
+
+
+    if (pConsultCall)
+    {
+        AddCallToList (((PDRVCALL) hdConfCall)->pLine, pConsultCall);
+
+        pConsultCall->htCall  = htConsultCall;
+
+        *lphdConsultCall = (HDRVCALL) pConsultCall;
+
+        if ((lResult = REMOTEDOFUNC (&funcArgs, "linePrepareAddToConference"))
+                < 0)
+        {
+            RemoveCallFromList (pConsultCall);
+
+            DrvFree (pConsultCall);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCWSTR         lpszDestAddress,
+    DWORD           dwCountryCode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpsz,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lRedirect),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineRedirect"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineReleaseUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lReleaseUserUserInfo),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineReleaseUserUserInfo"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lRemoveFromConference),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineRemoveFromConference"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lSecureCall),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSecureCall"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE    hdLine,
+    DWORD       dwExtVersion
+    )
+{
+    // BUGBUG TSPI_lineSelectExtVersion
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPCSTR          lpsUserUserInfo,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lSendUserUserInfo),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSendUserUserInfo"));
+}
+
+/*   BUGBUG wait 'til spec is complete for agent SPIs
+LONG
+TSPIAPI
+TSPI_lineSetAgent(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    LPLINEAGENTLIST lpAgentList
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdline,
+        Dword,
+        lpSet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) lpAgentList
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lSetAgent),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetAgent"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetAgentActivity(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    LPCSTR          lpszAgentActivity
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdline,
+        Dword,
+        lpsz
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdLine,
+        (DWORD) dwAdressID,
+        (DWORD) lpszAgentActivity
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lSetAgentActivity),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetAgentActivity"));
+}
+
+
+TSPIAPI
+TSPI_lineSetAgentState(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    DWORD           dwAgentState,
+    DWORD           dwNextAgentState
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdline,
+        Dword,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdLine,
+        (DWORD) dwAdressID,
+        (DWORD) dwAgentState,
+        (DWORD) dwNextAgentState
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 5, lSetAgentState),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetAgentState"));
+}
+*/
+
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL    hdCall,
+    DWORD       dwAppSpecific
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) dwAppSpecific
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lSetAppSpecific),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetAppSpecific"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallData(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPVOID          lpCallData,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpCallData,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lSetCallData),
+        (LPDWORD) args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetCallData"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        Dword,
+        Dword,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) dwBearerMode,
+        (DWORD) dwMinRate,
+        (DWORD) dwMaxRate,
+        (DWORD) lpDialParams,
+        (DWORD) (lpDialParams ? sizeof (LINEDIALPARAMS) : 0)
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 7, lSetCallParams),
+        (LPDWORD) args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetCallParams"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallQualityOfService(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    LPVOID          lpSendingFlowspec,
+    DWORD           dwSendingFlowspecSize,
+    LPVOID          lpReceivingFlowspec,
+    DWORD           dwReceivingFlowspecSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        lpSet_SizeToFollow,
+        Size,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) lpSendingFlowspec,
+        (DWORD) dwSendingFlowspecSize,
+        (DWORD) lpReceivingFlowspec,
+        (DWORD) dwReceivingFlowspecSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lSetCallQualityOfService),
+        (LPDWORD) args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetCallQualityOfService"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCallTreatment(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall,
+    DWORD           dwTreatment
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall,
+        (DWORD) dwTreatment
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSetCallTreatment),
+        (LPDWORD) args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetCallTreatment"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetCurrentLocation(
+    DWORD   dwLocation
+    )
+{
+    // BUGBUG TSPI_lineSetCurrentLocation
+
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE    hdLine,
+    DWORD       dwMediaModes
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdline,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) dwMediaModes,
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lSetDefaultMediaDetection),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetDefaultMediaDetection"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCWSTR lpszDeviceClass
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        LineID,
+        lpSet_SizeToFollow,
+        Size,
+        lpsz
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwDeviceID,
+        (DWORD) lpDeviceConfig,
+        (DWORD) dwSize,
+        (DWORD) lpszDeviceClass
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 4, lSetDevConfig),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetDevConfig"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetLineDevStatus(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwStatusToChange,
+    DWORD           fStatus
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdline,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdLine,
+        (DWORD) dwStatusToChange,
+        (DWORD) fStatus
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 4, lSetLineDevStatus),
+        (LPDWORD) args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetLineDevStatus"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        (dwSelect == LINECALLSELECT_CALL ? Dword : Hdline),
+        Dword,
+        (dwSelect == LINECALLSELECT_CALL ? Hdcall : Dword),
+        Dword,
+        lpSet_SizeToFollow,
+        Size,
+        lpSet_SizeToFollow,
+        Size,
+        lpSet_SizeToFollow,
+        Size,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) hdCall,
+        (DWORD) dwSelect,
+        (DWORD) lpDigitList,
+        (DWORD) dwDigitNumEntries,
+        (DWORD) lpMediaList,
+        (DWORD) dwMediaNumEntries,
+        (DWORD) lpToneList,
+        (DWORD) dwToneNumEntries,
+        (DWORD) lpCallStateList,
+        (DWORD) dwCallStateNumEntries
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 12, lSetMediaControl),
+        args,
+        argTypes
+    };
+
+
+    dwDigitNumEntries     *= sizeof (LINEMEDIACONTROLDIGIT);
+    dwMediaNumEntries     *= sizeof (LINEMEDIACONTROLMEDIA);
+    dwToneNumEntries      *= sizeof (LINEMEDIACONTROLTONE);
+    dwCallStateNumEntries *= sizeof (LINEMEDIACONTROLCALLSTATE);
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetMediaControl"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL    hdCall,
+    DWORD       dwMediaMode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdcall,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdCall,
+        (DWORD) dwMediaMode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 2, lSetMediaMode),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetMediaMode"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE    hdLine,
+    DWORD       dwLineStates,
+    DWORD       dwAddressStates
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdline,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdLine,
+        (DWORD) dwLineStates,
+        (DWORD) dwAddressStates
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 3, lSetStatusMessages),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetStatusMessages"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HDRVCALL        hdCall,
+    DWORD           dwSelect,
+    DWORD           dwTerminalModes,
+    DWORD           dwTerminalID,
+    DWORD           bEnable
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        (dwSelect == LINECALLSELECT_CALL ? Dword : Hdline),
+        Dword,
+        (dwSelect == LINECALLSELECT_CALL ? Hdcall : Dword),
+        Dword,
+        Dword,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) hdCall,
+        (DWORD) dwSelect,
+        (DWORD) dwTerminalModes,
+        (DWORD) dwTerminalID,
+        (DWORD) bEnable
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 8, lSetTerminal),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSetTerminal"));
+}
+
+
+void
+PASCAL
+TSPI_lineSetupConference_PostProcess(
+    PASYNCEVENTMSG  pMsg
+    )
+{
+    PDRVCALL    pConfCall = (PDRVCALL) pMsg->dwParam4,
+                pConsultCall = (PDRVCALL) *(&pMsg->dwParam4 + 2);
+
+    DBGOUT((3, "TSPI_lineSetupConference_PostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%x, dwP2=x%x, dwP3=x%x",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3
+        ));
+    DBGOUT((
+        3,
+        "\t\tdwP4=x%x, dwP5=x%x, dwP6=x%x",
+        pMsg->dwParam4,
+        *(&pMsg->dwParam4 + 1),
+        pConsultCall
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        HCALL   hConfCall    = (HCALL) pMsg->dwParam3,
+                hConsultCall = (HCALL) *(&pMsg->dwParam4 + 1);
+
+
+        pConfCall->hCall    = hConfCall;
+        pConsultCall->hCall = hConsultCall;
+    }
+    else
+    {
+        RemoveCallFromList (pConfCall);
+        RemoveCallFromList (pConsultCall);
+
+        DrvFree (pConfCall);
+        DrvFree (pConsultCall);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        (hdCall ? Hdcall : Dword),
+        (hdCall ? Dword : Hdline),
+        Dword,
+        Dword,
+        Dword,
+        lpSet_Struct,
+        Dword
+    };
+    PDRVCALL    pConfCall = DrvAlloc (sizeof (DRVCALL)),
+                pConsultCall = DrvAlloc (sizeof (DRVCALL));
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineSetupConference_PostProcess),
+        (DWORD) hdCall,
+        (DWORD) hdLine,
+        (DWORD) pConfCall,
+        (DWORD) pConsultCall,
+        (DWORD) dwNumParties,
+        (DWORD) lpCallParams,
+        (DWORD) 0xffffffff      // dwAsciiCallParamsCodePage
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 9, lSetupConference),
+        args,
+        argTypes
+    };
+    LONG    lResult;
+
+
+    if (pConfCall)
+    {
+        if (pConsultCall)
+        {
+            PDRVLINE pLine;
+
+
+            pLine = (hdCall ? ((PDRVCALL) hdCall)->pLine : (PDRVLINE) hdLine);
+
+            AddCallToList (pLine, pConfCall);
+            AddCallToList (pLine, pConsultCall);
+
+            pConfCall->htCall     = htConfCall;
+            pConsultCall->htCall  = htConsultCall;
+
+            *lphdConfCall    = (HDRVCALL) pConfCall;
+            *lphdConsultCall = (HDRVCALL) pConsultCall;
+
+            if ((lResult = REMOTEDOFUNC (&funcArgs, "lineSetupConference"))
+                    < 0)
+            {
+                RemoveCallFromList (pConfCall);
+                RemoveCallFromList (pConsultCall);
+
+                DrvFree (pConfCall);
+                DrvFree (pConsultCall);
+            }
+        }
+        else
+        {
+            DrvFree (pConfCall);
+            lResult = LINEERR_NOMEM;
+        }
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdcall,
+        Dword,
+        lpSet_Struct,
+        Dword
+    };
+    PDRVCALL    pConsultCall = DrvAlloc (sizeof (DRVCALL));
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineMakeCall_PostProcess),
+        (DWORD) hdCall,
+        (DWORD) pConsultCall,
+        (DWORD) lpCallParams,
+        (DWORD) 0xffffffff,     // dwAsciiCallParamsCodePage
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lSetupTransfer),
+        args,
+        argTypes
+    };
+    LONG    lResult;
+
+
+    if (pConsultCall)
+    {
+        AddCallToList (((PDRVCALL) hdCall)->pLine, pConsultCall);
+
+        pConsultCall->htCall  = htConsultCall;
+
+        *lphdConsultCall = (HDRVCALL) pConsultCall;
+
+        if ((lResult = REMOTEDOFUNC (&funcArgs, "lineSetupTransfer")) < 0)
+        {
+            RemoveCallFromList (pConsultCall);
+
+            DrvFree (pConsultCall);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdActiveCall,
+    HDRVCALL        hdHeldCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdActiveCall,
+        (DWORD) hdHeldCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lSwapHold),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineSwapHold"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwCompletionID
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdline,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdLine,
+        (DWORD) dwCompletionID
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 3, lUncompleteCall),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineUncompleteCall"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID   dwRequestID,
+    HDRVCALL        hdCall
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdcall
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdCall
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 2, lUnhold),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "lineUnhold"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID   dwRequestID,
+    HDRVLINE        hdLine,
+    DWORD           dwAddressID,
+    HTAPICALL       htCall,
+    LPHDRVCALL      lphdCall,
+    LPCWSTR         lpszDestAddress
+    )
+{
+    REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdline,
+        Dword,
+        Dword,
+        lpsz
+    };
+    PDRVCALL    pCall = DrvAlloc (sizeof (DRVCALL));
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_lineMakeCall_PostProcess),
+        (DWORD) hdLine,
+        (DWORD) dwAddressID,
+        (DWORD) pCall,
+        (DWORD) lpszDestAddress
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | ASYNC | 6, lUnpark),
+        args,
+        argTypes
+    };
+    LONG    lResult;
+
+
+    if (pCall)
+    {
+        AddCallToList ((PDRVLINE) hdLine, pCall);
+
+        pCall->htCall  = htCall;
+
+        *lphdCall = (HDRVCALL) pCall;
+
+        if ((lResult = REMOTEDOFUNC (&funcArgs, "lineUnpark")) < 0)
+        {
+            RemoveCallFromList (pCall);
+
+            DrvFree (pCall);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_NOMEM;
+    }
+
+    return lResult;
+}
+
+
+
+//
+// -------------------------- TSPI_phoneXxx funcs -----------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE   hdPhone
+    )
+{
+    //
+    // Check if the hPhone is still valid (could have been zeroed
+    // out on PHONE_CLOSE, so no need to call server)
+    //
+
+    if (((PDRVPHONE) hdPhone)->hPhone)
+    {
+        static REMOTE_ARG_TYPES argTypes[] =
+        {
+            Hdphone
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (PHONE_FUNC | SYNC | 1, pClose),
+            (LPDWORD) &hdPhone,
+            argTypes
+        };
+
+
+        REMOTEDOFUNC (&funcArgs, "phoneClose");
+    }
+
+    return 0;
+}
+
+
+void
+PASCAL
+TSPI_phoneDevSpecific_PostProcess(
+    PASYNCEVENTMSG pMsg
+    )
+{
+    DBGOUT((3, "phoneDevSpecificPostProcess: enter"));
+    DBGOUT((
+        3,
+        "\t\tdwP1=x%lx, dwP2=x%lx, dwP3=x%lx, dwP4=x%lx",
+        pMsg->dwParam1,
+        pMsg->dwParam2,
+        pMsg->dwParam3,
+        pMsg->dwParam4
+        ));
+
+    if (pMsg->dwParam2 == 0)
+    {
+        DWORD   dwSize  = pMsg->dwTotalSize - sizeof (TAPI32_MSG);
+        LPBYTE  pParams = (LPBYTE) pMsg->dwParam3;
+
+
+        CopyMemory (pParams, (LPBYTE) (pMsg + 1), dwSize);
+    }
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    LPVOID          lpParams,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Dword,
+        Hdphone,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) ((POSTPROCESSPROC) TSPI_phoneDevSpecific_PostProcess),
+        (DWORD) hdPhone,
+        (DWORD) lpParams,   // pass the actual pointer (for post processing)
+        (DWORD) lpParams,   // pass data
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 6, pDevSpecific),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneDevSpecific"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        Dword,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) lpButtonInfo
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetButtonInfo),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetButtonInfo"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE   hdPhone,
+    DWORD       dwDataID,
+    LPVOID      lpData,
+    DWORD       dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        Dword,
+        lpGet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) dwDataID,
+        (DWORD) lpData,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 4, pGetData),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetData"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD       dwDeviceID,
+    DWORD       dwTSPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        PhoneID,
+        Dword,
+        Dword,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) (GetPhoneFromID (dwDeviceID))->pServer->hPhoneApp,
+        (DWORD) dwDeviceID,
+        (DWORD) dwTSPIVersion,
+        (DWORD) dwExtVersion,
+        (DWORD) lpPhoneCaps
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 5, pGetDevCaps),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetDevCaps"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDisplay
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) lpDisplay
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 2, pGetDisplay),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetDisplay"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    CopyMemory(
+        lpExtensionID,
+        &(GetPhoneFromID (dwDeviceID))->ExtensionID,
+        sizeof (PHONEEXTENSIONID)
+        );
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE   hdPhone,
+    DWORD       dwHookSwitchDev,
+    LPDWORD     lpdwGain
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        Dword,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) lpdwGain
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetGain),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetGain"));
+}
+
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE   hdPhone,
+    LPDWORD     lpdwHookSwitchDevs
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) lpdwHookSwitchDevs
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 2, pGetHookSwitch),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetHookSwitch"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD   dwDeviceID,
+    LPCWSTR lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    *lphIcon = ghPhoneIcon;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE   hdPhone,
+    LPVARSTRING lpDeviceID,
+    LPCWSTR     lpszDeviceClass,
+    HANDLE      hTargetProcess
+    )
+{
+    if (lstrcmpiW (lpszDeviceClass, L"tapi/phone") != 0)
+    {
+        static REMOTE_ARG_TYPES argTypes[] =
+        {
+            Hdphone,
+            lpGet_Struct,
+            lpsz
+        };
+        DWORD args[] =
+        {
+            (DWORD) hdPhone,
+            (DWORD) lpDeviceID,
+            (DWORD) lpszDeviceClass
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (PHONE_FUNC | SYNC | 3, pGetID),
+            args,
+            argTypes
+        };
+
+
+        return (REMOTEDOFUNC (&funcArgs, "phoneGetID"));
+    }
+
+    if (lpDeviceID->dwTotalSize <
+        (lpDeviceID->dwNeededSize = sizeof (VARSTRING) + sizeof (DWORD)))
+    {
+        lpDeviceID->dwUsedSize = 3 * sizeof (DWORD);
+    }
+    else
+    {
+        lpDeviceID->dwUsedSize = lpDeviceID->dwNeededSize;
+
+        lpDeviceID->dwStringFormat = STRINGFORMAT_BINARY;
+        lpDeviceID->dwStringSize   = sizeof (DWORD);
+        lpDeviceID->dwStringOffset = sizeof (VARSTRING);
+
+        *((LPDWORD)(lpDeviceID + 1)) =
+            ((PDRVPHONE) hdPhone)->dwDeviceIDLocal;
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE   hdPhone,
+    DWORD       dwButtonLampID,
+    LPDWORD     lpdwLampMode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        Dword,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) lpdwLampMode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetLamp),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetLamp"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE   hdPhone,
+    LPDWORD     lpdwRingMode,
+    LPDWORD     lpdwVolume
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        lpDword,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) lpdwRingMode,
+        (DWORD) lpdwVolume
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetRing),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetRing"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE       hdPhone,
+    LPPHONESTATUS   lpPhoneStatus
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        lpGet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) lpPhoneStatus
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 2, pGetStatus),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetStatus"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE   hdPhone,
+    DWORD       dwHookSwitchDev,
+    LPDWORD     lpdwVolume
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        Dword,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) lpdwVolume
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 3, pGetVolume),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneGetVolume"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwTSPIVersion,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        PhoneID,
+        Dword,
+        Dword,
+        Dword,
+        lpDword
+    };
+    DWORD args[] =
+    {
+        (DWORD) (GetPhoneFromID (dwDeviceID))->pServer->hPhoneApp,
+        (DWORD) dwDeviceID,
+        (DWORD) dwTSPIVersion,
+        (DWORD) dwLowVersion,
+        (DWORD) dwHighVersion,
+        (DWORD) lpdwExtVersion,
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (LINE_FUNC | SYNC | 6, pNegotiateExtVersion),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneNegotiateExtVersion"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD   dwDeviceID,
+    DWORD   dwLowVersion,
+    DWORD   dwHighVersion,
+    LPDWORD lpdwTSPIVersion
+    )
+{
+    if (dwDeviceID == INITIALIZE_NEGOTIATION)
+    {
+        *lpdwTSPIVersion = TAPI_VERSION_CURRENT;
+    }
+    else
+    {
+        *lpdwTSPIVersion = (GetPhoneFromID (dwDeviceID))->dwXPIVersion;
+    }
+
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneOpen(
+    DWORD       dwDeviceID,
+    HTAPIPHONE  htPhone,
+    LPHDRVPHONE lphdPhone,
+    DWORD       dwTSPIVersion,
+    PHONEEVENT  lpfnEventProc
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,      // hPhoneApp
+        PhoneID,    // dev id
+        lpDword,    // lphPhone
+        Dword,      // API version
+        Dword,      // ext version
+        Dword,      // callback inst
+        Dword,      // privilege
+        Dword       // remote hPhone
+    };
+    PDRVPHONE   pPhone = GetPhoneFromID (dwDeviceID);
+    DWORD args[] =
+    {
+        (DWORD) pPhone->pServer->hPhoneApp,
+        (DWORD) dwDeviceID,
+        (DWORD) &pPhone->hPhone,
+        (DWORD) dwTSPIVersion,
+        (DWORD) 0, // BUGBUG
+        (DWORD) 0,
+        (DWORD) PHONEPRIVILEGE_OWNER,
+        (DWORD) pPhone
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 8, pOpen),
+        args,
+        argTypes
+    };
+
+
+    pPhone->htPhone = htPhone;
+
+    *lphdPhone = (HDRVPHONE) pPhone;
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneOpen"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE   hdPhone,
+    DWORD       dwExtVersion
+    )
+{
+    // BUGBUG TSPI_phoneSelectExtVersion
+
+    return PHONEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        lpSet_Struct
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) lpButtonInfo
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetButtonInfo),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetButtonInfo"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwDataID,
+    LPVOID          const lpData,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwDataID,
+        (DWORD) lpData,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 5, pSetData),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetData"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwRow,
+    DWORD           dwColumn,
+    LPCWSTR         lpsDisplay,
+    DWORD           dwSize
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        Dword,
+        lpSet_SizeToFollow,
+        Size
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwRow,
+        (DWORD) dwColumn,
+        (DWORD) lpsDisplay,
+        (DWORD) dwSize
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 6, pSetDisplay),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetDisplay"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDev,
+    DWORD           dwGain
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) dwGain
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetGain),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetGain"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDevs,
+    DWORD           dwHookSwitchMode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwHookSwitchDevs,
+        (DWORD) dwHookSwitchMode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetHookSwitch),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetHookswitch"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwButtonLampID,
+    DWORD           dwLampMode
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) dwLampMode
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetLamp),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetLamp"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwRingMode,
+    DWORD           dwVolume
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwRingMode,
+        (DWORD) dwVolume
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetRing),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetRing"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE   hdPhone,
+    DWORD       dwPhoneStates,
+    DWORD       dwButtonModes,
+    DWORD       dwButtonStates
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Hdphone,
+        Dword,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) hdPhone,
+        (DWORD) dwPhoneStates,
+        (DWORD) dwButtonModes,
+        (DWORD) dwButtonStates
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | SYNC | 4, pSetStatusMessages),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetStatusMessages"));
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID   dwRequestID,
+    HDRVPHONE       hdPhone,
+    DWORD           dwHookSwitchDev,
+    DWORD           dwVolume
+    )
+{
+    static REMOTE_ARG_TYPES argTypes[] =
+    {
+        Dword,
+        Hdphone,
+        Dword,
+        Dword
+    };
+    DWORD args[] =
+    {
+        (DWORD) dwRequestID,
+        (DWORD) hdPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) dwVolume
+    };
+    REMOTE_FUNC_ARGS funcArgs =
+    {
+        MAKELONG (PHONE_FUNC | ASYNC | 4, pSetVolume),
+        args,
+        argTypes
+    };
+
+
+    return (REMOTEDOFUNC (&funcArgs, "phoneSetVolume"));
+}
+
+
+
+//
+// ------------------------- TSPI_providerXxx funcs ---------------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    //
+    // Although this func is never called by TAPI v2.0, we export
+    // it so that the Telephony Control Panel Applet knows that it
+    // can configure this provider via lineConfigProvider(),
+    // otherwise Telephon.cpl will not consider it configurable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreateLineDevice(
+    DWORD   dwTempID,
+    DWORD   dwDeviceID
+    )
+{
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreatePhoneDevice(
+    DWORD   dwTempID,
+    DWORD   dwDeviceID
+    )
+{
+    return LINEERR_OPERATIONFAILED;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD       dwPermanentProviderID,
+    LPDWORD     lpdwNumLines,
+    LPDWORD     lpdwNumPhones,
+    HPROVIDER   hProvider,
+    LINEEVENT   lpfnLineCreateProc,
+    PHONEEVENT  lpfnPhoneCreateProc
+    )
+{
+    char    szProviderN[16];
+    char   *pszServerName;
+    DWORD   hClientInst, dwNumServers, i;
+    RPC_BINDING_HANDLE  hBindingInst;
+
+    HKEY    hTelephonyKey;
+    HKEY    hProviderNKey;
+    DWORD   dwDataSize;
+    DWORD   dwDataType;
+
+
+    RegOpenKeyEx(
+        HKEY_LOCAL_MACHINE,
+        gszTelephonyKey,
+        0,
+        KEY_ALL_ACCESS,
+        &hTelephonyKey
+        );
+
+
+    //
+    // BUGBUG The following is a cheesy hack to allow us access to net
+    //        since tapisrv is currently running on LocalSystem
+    //
+    //        Once the service acct stuff is worked out we can nuke this
+    //        (still need the GetMachineName code tho')
+    //
+
+    {
+//        char    szProviders[] = "Providers";
+        char    szUserName[32], szDomainName[32], szPassword[32];
+        HKEY    hProvidersKey;
+        DWORD   dwSize = MAX_COMPUTERNAME_LENGTH + 1;
+
+
+        RegOpenKeyEx(
+            hTelephonyKey,
+            "Providers",
+            0,
+            KEY_ALL_ACCESS,
+            &hProvidersKey
+            );
+
+        dwDataSize = sizeof(szUserName);
+
+        RegQueryValueEx(
+            hProvidersKey,
+            "User",
+            0,
+            &dwDataType,
+            (LPBYTE) szUserName,
+            &dwDataSize
+            );
+
+        szUserName[dwDataSize] = '\0';
+
+        dwDataSize = sizeof(szDomainName);
+
+        RegQueryValueEx(
+            hProvidersKey,
+            "Domain",
+            0,
+            &dwDataType,
+            (LPBYTE) szDomainName,
+            &dwDataSize
+            );
+
+        szDomainName[dwDataSize] = '\0';
+
+        dwDataSize = sizeof(szPassword);
+
+        RegQueryValueEx(
+            hProvidersKey,
+            "Password",
+            0,
+            &dwDataType,
+            (LPBYTE) szPassword,
+            &dwDataSize
+            );
+
+        szPassword[dwDataSize] = '\0';
+
+        RegCloseKey (hProvidersKey);
+
+        if (LogonUser(
+                szUserName,
+                szDomainName,
+                szPassword,
+                LOGON32_LOGON_SERVICE,
+                LOGON32_PROVIDER_DEFAULT,
+                &hToken
+                ))
+        {
+            DBGOUT((3, "LogonUser() succeeded"));
+
+            wsprintf (gszDomainUser, "%s\\%s", szDomainName, szUserName);
+
+            GetComputerNameW (gszMachineName, &dwSize);
+
+            DBGOUT((
+                3,
+                "\tdomainUser='%s', machine='%ws'",
+                gszDomainUser,
+                gszMachineName
+                ));
+        }
+        else
+        {
+            hToken = NULL;
+
+            DBGOUT((1, ""));
+            DBGOUT((1, "LogonUser() failed, err=%d", GetLastError()));
+            DBGOUT((1, "\tuserName='%s'", szUserName));
+            DBGOUT((1, "\tdomainName='%s'", szDomainName));
+            DBGOUT((1, "\tpassword='%s'", szPassword));
+            DBGOUT((1, ""));
+
+            RegCloseKey (hTelephonyKey);
+
+            return LINEERR_OPERATIONFAILED;
+        }
+    }
+
+
+    //
+    // Init gEventHandlerThreadParams & start EventHandlerThread
+    //
+
+    gEventHandlerThreadParams.dwEventBufferTotalSize = 1024;
+    gEventHandlerThreadParams.dwEventBufferUsedSize  = 0;
+
+    if (!(gEventHandlerThreadParams.pEventBuffer = DrvAlloc(
+            gEventHandlerThreadParams.dwEventBufferTotalSize
+            )))
+    {
+    }
+
+    gEventHandlerThreadParams.pDataIn  =
+        gEventHandlerThreadParams.pDataOut =
+            gEventHandlerThreadParams.pEventBuffer;
+
+    gEventHandlerThreadParams.dwMsgSize = 512;
+
+    if (!(gEventHandlerThreadParams.pMsg = DrvAlloc(
+            gEventHandlerThreadParams.dwMsgSize
+            )))
+    {
+    }
+
+    if (!(gEventHandlerThreadParams.hEvent = CreateEvent(
+            (LPSECURITY_ATTRIBUTES) NULL,   // no security attrs
+            TRUE,                           // manual reset
+            FALSE,                          // initially non-signaled
+            NULL                            // unnamed
+            )))
+    {
+    }
+
+    gEventHandlerThreadParams.bExit = FALSE;
+
+    {
+        DWORD   dwTID;
+
+
+        if (!(gEventHandlerThreadParams.hThread = CreateThread(
+                (LPSECURITY_ATTRIBUTES) NULL,
+                0,
+                (LPTHREAD_START_ROUTINE) EventHandlerThread,
+                NULL,
+                0,
+                &dwTID
+                )))
+        {
+            DBGOUT((
+                1,
+                "CreateThread('EventHandlerThread') failed, err=%d",
+                GetLastError()
+                ));
+
+            RegCloseKey (hTelephonyKey);
+
+            return LINEERR_OPERATIONFAILED;
+        }
+    }
+
+
+    //
+    // Register the Rpc interface (leverage tapisrv's rpc server thread)
+    //
+
+    {
+        RPC_STATUS  status;
+        unsigned char * pszSecurity         = NULL;
+        unsigned int    cMaxCalls           = 20;
+
+
+        status = RpcServerUseProtseqEp(
+            "ncacn_np",
+            cMaxCalls,
+            "\\pipe\\remotesp",
+            pszSecurity             // Security descriptor
+            );
+
+        DBGOUT((3, "RpcServerUseProtseqEp(np) ret'd %d", status));
+
+        if (status)
+        {
+        }
+
+        status = RpcServerRegisterIf(
+            remotesp_ServerIfHandle,  // interface to register
+            NULL,                     // MgrTypeUuid
+            NULL                      // MgrEpv; null means use default
+            );
+
+        DBGOUT((3, "RpcServerRegisterIf ret'd %d", status));
+
+        if (status)
+        {
+        }
+    }
+
+
+    //
+    // Init globals
+    //
+    // NOTE: tapi's xxxEvent & xxxCreate procs are currently one in the same
+    //
+
+    wsprintf (szProviderN, "Provider%d", dwPermanentProviderID);
+
+    gdwPermanentProviderID = dwPermanentProviderID;
+
+    gpfnLineEventProc  = lpfnLineCreateProc;
+    gpfnPhoneEventProc = lpfnPhoneCreateProc;
+
+    gpServers     = (PDRVSERVER) NULL;
+    gpLineLookup  = (PDRVLINELOOKUP) NULL;
+    gpPhoneLookup = (PDRVPHONELOOKUP) NULL;
+
+    RegOpenKeyEx(
+        hTelephonyKey,
+        szProviderN,
+        0,
+        KEY_ALL_ACCESS,
+        &hProviderNKey
+        );
+
+    dwDataSize = sizeof(dwNumServers);
+    dwNumServers = 0;
+
+    RegQueryValueEx(
+        hProviderNKey,
+        "NumServers",
+        0,
+        &dwDataType,
+        (LPBYTE) &dwNumServers,
+        &dwDataSize
+        );
+
+    dwDataSize = sizeof(gdwRetryCount);
+    gdwRetryCount = 0;
+
+    RegQueryValueEx(
+        hProviderNKey,
+        "RetryCount",
+        0,
+        &dwDataType,
+        (LPBYTE) &gdwRetryCount,
+        &dwDataSize
+        );
+
+    dwDataSize = sizeof(gdwRetryTimeout);
+    gdwRetryTimeout = 0;
+
+    RegQueryValueEx(
+        hProviderNKey,
+        "RetryTimeout",
+        0,
+        &dwDataType,
+        (LPBYTE) &gdwRetryTimeout,
+        &dwDataSize
+        );
+
+    DBGOUT((
+        4,
+        "TSPI_ProviderEnumDevices: pN='%s', numSrvs=%d",
+        szProviderN,
+        dwNumServers
+        ));
+
+
+    if (!ImpersonateLoggedOnUser (hToken)) // BUGBUG local system hack
+    {
+        DBGOUT((1, "ImpersonateLoggedOnUser failed, err=%d", GetLastError()));
+
+        RegCloseKey (hProviderNKey);
+        RegCloseKey (hTelephonyKey);
+
+        return LINEERR_OPERATIONFAILED;
+
+    }
+
+
+    //
+    // Initialize all the servers
+    //
+
+    for (i = 0; i < dwNumServers; i++)
+    {
+        char                    szServerN[32];
+        DWORD                   dwNumLineDevices, dwNumPhoneDevices;
+        HLINEAPP                hLineApp;
+        HPHONEAPP               hPhoneApp;
+        PCONTEXT_HANDLE_TYPE    phContext = NULL;
+
+
+        wsprintf (szServerN, "Server%d", i);
+
+        pszServerName = DrvAlloc (64);
+
+        dwDataSize = 64;
+
+        RegQueryValueEx(
+            hProviderNKey,
+            szServerN,
+            0,
+            &dwDataType,
+            (LPBYTE) pszServerName,
+            &dwDataSize
+            );
+
+        pszServerName[dwDataSize] = '\0';
+
+        DBGOUT((1, "init: srvNam='%s'", pszServerName));
+
+        if (!pszServerName[0])
+        {
+            continue;
+        }
+
+
+        //
+        // Init the RPC connection
+        //
+
+        gpServer = DrvAlloc (sizeof (DRVSERVER));
+
+        {
+            DWORD       dwUsedSize, dwBufSize;
+            RPC_STATUS  status;
+            TAPI32_MSG  msg[2];
+            unsigned char * pszStringBinding = NULL;
+
+
+            status = RpcStringBindingCompose(
+                NULL,               // uuid
+                "ncacn_np",         // prot
+                pszServerName,      // server name
+                "\\pipe\\tapsrv",   // interface name
+                NULL,               // options
+                &pszStringBinding
+                );
+
+            if (status)
+            {
+                DBGOUT((
+                    0,
+                    "RpcStringBindingCompose failed: err=%d, szNetAddr='%s'",
+                    status,
+                    pszServerName
+                    ));
+            }
+
+            status = RpcBindingFromStringBinding(
+                pszStringBinding,
+                &hTapSrv
+                );
+
+            if (status)
+            {
+                DBGOUT((
+                    0,
+                    "RpcBindingFromStringBinding failed, err=%d, szBinding='%s'",
+                    status,
+                    pszStringBinding
+                    ));
+            }
+
+            {
+                DWORD dwRetryCount = 0;
+
+
+                do
+                {
+                    WCHAR szDomainUser[32];
+
+
+                    MultiByteToWideChar(
+                        CP_ACP,
+                        MB_PRECOMPOSED,
+                        (LPCSTR) gszDomainUser,
+                        -1,
+                        szDomainUser,
+                        32
+                        );
+
+                    RpcTryExcept
+                    {
+                        long lUnused;
+
+
+                        ClientAttach(
+                            (PCONTEXT_HANDLE_TYPE *) &phContext,
+                            0xffffffff, // dwProcessID, -1 implies remotesp
+                            (long *) &lUnused,
+                            szDomainUser,
+                            gszMachineName
+                            );
+
+                        dwRetryCount = gdwRetryCount;
+                    }
+                    RpcExcept (1)
+                    {
+                        if (dwRetryCount++ < gdwRetryCount)
+                        {
+                            Sleep (gdwRetryTimeout);
+                        }
+                        else
+                        {
+                            // BUGBUG gracefully handle cliAttach except error
+                        }
+                    }
+                    RpcEndExcept
+
+                } while (dwRetryCount < gdwRetryCount);
+            }
+
+            RpcBindingFree (&hTapSrv);
+
+            RpcStringFree (&pszStringBinding);
+
+
+            //
+            //
+            //
+
+            {
+                PLINEINITIALIZE_PARAMS pParams;
+                BOOL  bExit = FALSE;
+
+
+                msg[0].u.Req_Func = lInitialize;
+
+                pParams = (PLINEINITIALIZE_PARAMS) msg;
+
+
+                //
+                // NOTE: we pass the pServer in place of the lpfnCallback
+                //       so the we always know which server is sending us
+                //       async events
+                //
+
+                pParams->hInstance       = 0;
+                pParams->lpfnCallback    = (LINECALLBACK) ((LPVOID) gpServer);
+                pParams->dwFriendlyNameOffset =
+                pParams->dwModuleNameOffset   = 0;
+                pParams->dwAPIVersion    = TAPI_VERSION_CURRENT;
+
+                lstrcpyW ((WCHAR *) (msg + 1), gszMachineName);
+
+                dwBufSize  =
+                dwUsedSize = sizeof (TAPI32_MSG) +
+                    (lstrlenW (gszMachineName) + 1) * sizeof (WCHAR);
+
+                {
+                    DWORD dwRetryCount = 0;
+
+                    do
+                    {
+                        RpcTryExcept
+                        {
+                            ClientRequest(
+                                phContext,
+                                (char *) &msg,
+                                dwBufSize,
+                                &dwUsedSize
+                                );
+
+                            dwRetryCount = gdwRetryCount;
+                        }
+                        RpcExcept (1)
+                        {
+                            DBGOUT((1, "init: xcpt in lInit"));
+
+                            if (dwRetryCount++ < gdwRetryCount)
+                            {
+                                Sleep (gdwRetryTimeout);
+                            }
+                            else
+                            {
+                                // BUGBUG need graceful cleanup
+                                bExit = TRUE;
+                            }
+                        }
+                        RpcEndExcept
+
+                    } while (dwRetryCount < gdwRetryCount);
+                }
+
+                if (bExit)
+                {
+                    // BUGBUG check the result of lineInit
+                }
+
+                hLineApp         = pParams->hLineApp;
+                dwNumLineDevices = pParams->dwNumDevs;
+            }
+
+
+            //
+            //
+            //
+
+            {
+                PPHONEINITIALIZE_PARAMS pParams;
+
+
+                msg[0].u.Req_Func = pInitialize;
+
+                pParams = (PPHONEINITIALIZE_PARAMS) msg;
+
+                //
+                // NOTE: we pass the pServer in place of the lpfnCallback
+                //       so the we always know which server is sending us
+                //       async events
+                //
+
+                pParams->hInstance       = 0;
+                pParams->lpfnCallback    = (PHONECALLBACK) ((LPVOID) gpServer);
+                pParams->dwFriendlyNameOffset =
+                pParams->dwModuleNameOffset = 0;
+                pParams->dwAPIVersion    = TAPI_VERSION_CURRENT;
+
+                lstrcpyW ((WCHAR *) (msg + 1), gszMachineName);
+
+                dwBufSize  =
+                dwUsedSize = sizeof (TAPI32_MSG) +
+                    (lstrlenW (gszMachineName) + 1) * sizeof (WCHAR);
+
+                {
+                    DWORD dwRetryCount = 0;
+
+
+                    do
+                    {
+                        RpcTryExcept
+                        {
+                            ClientRequest(
+                                phContext,
+                                (char *) &msg,
+                                dwBufSize,
+                                &dwUsedSize
+                                );
+
+                            dwRetryCount = gdwRetryCount;
+                        }
+                        RpcExcept (1)
+                        {
+                            if (dwRetryCount++ < gdwRetryCount)
+                            {
+                                Sleep (gdwRetryTimeout);
+                            }
+                            else
+                            {
+                                // BUGBUG gracefully handle phoneInit except error
+                            }
+                        }
+                        RpcEndExcept
+
+                    } while (dwRetryCount < gdwRetryCount);
+                }
+
+                // BUGBUG check the result of phoneInit
+
+                hPhoneApp         = pParams->hPhoneApp;
+                dwNumPhoneDevices = pParams->dwNumDevs;
+            }
+        }
+
+        //
+        //
+        //
+
+        DBGOUT((
+            1,
+            "TSPI_providerEnumDevices: srv='%s', lines=%d, phones=%d",
+            pszServerName,
+            dwNumLineDevices,
+            dwNumPhoneDevices
+            ));
+
+        {
+            DWORD       j;
+
+
+            gpServer->pServerName = pszServerName;
+            gpServer->phContext   = phContext;
+            gpServer->hLineApp    = hLineApp;
+            gpServer->hPhoneApp   = hPhoneApp;
+            gpServer->pNext       = gpServers;
+
+            gpServers = gpServer;
+
+            for (j = 0; j < dwNumLineDevices; j++)
+            {
+                AddLine (gpServer, j, j, TRUE);
+            }
+
+            for (j = 0; j < dwNumPhoneDevices; j++)
+            {
+                AddPhone (gpServer, j, j, TRUE);
+            }
+        }
+
+    } // for (i = 0; i < iNumServers; i++)
+
+    RevertToSelf(); // BUGBUG LocalSystem hack
+
+    gdwInitialNumLineDevices =
+    *lpdwNumLines = (gpLineLookup ? gpLineLookup->dwUsedEntries : 0);
+
+    gdwInitialNumPhoneDevices =
+    *lpdwNumPhones = (gpPhoneLookup ? gpPhoneLookup->dwUsedEntries : 0);
+
+    // BUGBUG TSPI_provEnumDev: we ought really do alot of error clean up here
+
+    RegCloseKey (hProviderNKey);
+    RegCloseKey (hTelephonyKey);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerFreeDialogInstance(
+    HDRVDIALOGINSTANCE  hdDlgInst
+    )
+{
+    // BUGBUG TSPI_providerFreeDialogInstance: implement
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerGenericDialogData(
+    DWORD               dwObjectID,
+    DWORD               dwObjectType,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    // BUGBUG TSPI_providerGenericDialogData: implement
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions
+    )
+{
+    if (!hToken)
+    {
+        return LINEERR_OPERATIONFAILED;
+    }
+
+    gdwLineDeviceIDBase  = dwLineDeviceIDBase;
+    gdwPhoneDeviceIDBase = dwPhoneDeviceIDBase;
+
+    gpfnCompletionProc = lpfnCompletionProc;
+
+    *lpdwTSPIOptions = 0;
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    //
+    // Although this func is never called by TAPI v2.0, we export
+    // it so that the Telephony Control Panel Applet knows that it
+    // can add this provider via lineAddProvider(), otherwise
+    // Telephon.cpl will not consider it installable
+    //
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    //
+    // Although this func is never called by TAPI v2.0, we export
+    // it so that the Telephony Control Panel Applet knows that it
+    // can remove this provider via lineRemoveProvider(), otherwise
+    // Telephon.cpl will not consider it removable
+    //
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD   dwTSPIVersion,
+    DWORD   dwPermanentProviderID
+    )
+{
+    PDRVSERVER  pServer;
+    RPC_STATUS  status;
+
+
+    //
+    // Set the flag instructing the EventHandlerThread to terminate
+    //
+
+    gEventHandlerThreadParams.bExit = TRUE;
+
+
+    //
+    // Send detach to each server, then wait for the async event threads
+    // to terminate and free the resources
+    //
+
+    if (!ImpersonateLoggedOnUser (hToken)) // BUGBUG LocalSystem hack
+    {
+        DBGOUT((1, "ImpersonateLoggedOnUser failed, err=%d", GetLastError()));
+
+        // fall thru
+    }
+
+    pServer = gpServers;
+
+    while (pServer)
+    {
+        DWORD       dwRetryCount = 0;
+        PDRVSERVER  pNextServer = pServer->pNext;
+
+
+        do
+        {
+            RpcTryExcept
+            {
+                ClientDetach (&pServer->phContext);
+
+                dwRetryCount = gdwRetryCount;
+            }
+            RpcExcept (1)
+            {
+                if (dwRetryCount++ < gdwRetryCount)
+                {
+                    Sleep (gdwRetryTimeout);
+                }
+            }
+            RpcEndExcept
+
+        } while (dwRetryCount < gdwRetryCount);
+
+        DrvFree (pServer->pServerName);
+        DrvFree (pServer);
+
+        pServer = pNextServer;
+    }
+
+    RevertToSelf(); // BUGBUG LocalSystem hack
+
+    CloseHandle (hToken);
+
+
+    //
+    // Unregister out rpc server interface
+    //
+
+    status = RpcServerUnregisterIf(
+        remotesp_ServerIfHandle,    // interface to register
+        NULL,                       // MgrTypeUuid
+        0                           // wait for calls to complete
+        );
+
+    DBGOUT((3, "RpcServerUntegisterIf ret'd %d", status));
+
+
+    //
+    // Wait for the EventHandlerThread to terminate, then clean up
+    // the related resources
+    //
+
+    while (WaitForSingleObject (gEventHandlerThreadParams.hThread, 0) !=
+            WAIT_OBJECT_0)
+    {
+        SetEvent (gEventHandlerThreadParams.hEvent);
+        Sleep (0);
+    }
+
+    CloseHandle (gEventHandlerThreadParams.hThread);
+    CloseHandle (gEventHandlerThreadParams.hEvent);
+    DrvFree (gEventHandlerThreadParams.pEventBuffer);
+    DrvFree (gEventHandlerThreadParams.pMsg);
+
+
+    //
+    // Free the lookup tables
+    //
+
+    while (gpLineLookup)
+    {
+        PDRVLINELOOKUP  pNextLineLookup = gpLineLookup->pNext;
+
+
+        DrvFree (gpLineLookup);
+
+        gpLineLookup = pNextLineLookup;
+    }
+
+    while (gpPhoneLookup)
+    {
+        PDRVPHONELOOKUP pNextPhoneLookup = gpPhoneLookup->pNext;
+
+
+        DrvFree (gpPhoneLookup);
+
+        gpPhoneLookup = pNextPhoneLookup;
+    }
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerUIIdentify(
+    LPWSTR   lpszUIDLLName
+    )
+{
+    wcscpy (lpszUIDLLName, L"remotesp.tsp");
+
+    return 0;
+}
+
+
+//
+// ---------------------------- TUISPI_xxx funcs ------------------------------
+//
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+    char buf[128];
+
+
+    wsprintf (buf, "devID=%d, devClass='%ws'", dwDeviceID, lpszDeviceClass);
+
+    MessageBox (hwndOwner, buf, "REMOTESP: TUISPI_lineConfigDialog", MB_OK);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_lineConfigDialogEdit(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+    char buf[128];
+
+
+    wsprintf (buf, "devID=%d, devClass='%ws'", dwDeviceID, lpszDeviceClass);
+
+    MessageBox (hwndOwner, buf, "REMOTESP: TUISPI_lineConfigDialogEdit",MB_OK);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_phoneConfigDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+    char buf[128];
+
+
+    wsprintf (buf, "devID=%d, devClass='%ws'", dwDeviceID, lpszDeviceClass);
+
+    MessageBox (hwndOwner, buf, "REMOTESP: TUISPI_phoneConfigDialog", MB_OK);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerConfig(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    DialogBoxParam(
+        ghInst,
+        MAKEINTRESOURCE(100),
+        hwndOwner,
+        (DLGPROC) ConfigDlgProc,
+        (LPARAM) dwPermanentProviderID
+        );
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerGenericDialog(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HTAPIDIALOGINSTANCE htDlgInst,
+    LPVOID              lpParams,
+    DWORD               dwSize,
+    HANDLE              hEvent
+    )
+{
+    char buf[128];
+
+
+    SetEvent (hEvent);
+
+    wsprintf (buf, "htDlgInst=x%x", htDlgInst);
+
+    MessageBox (NULL, buf,"REMOTESP: TUISPI_providerGenericDialog",MB_OK);
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerGenericDialogData(
+    HTAPIDIALOGINSTANCE htDlgInst,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    DBGOUT((
+        3,
+        "TUISPI_providerGenericDialogData: enter (lpParams=x%x, dwSize=x%x)",
+        lpParams,
+        dwSize
+        ));
+
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerInstall(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    char    buf[32];
+    LONG    lResult = LINEERR_OPERATIONFAILED;
+    HKEY    hTelephonyKey, hProviderNKey;
+    DWORD   dwDataType, dwDataSize, dwTemp, dwDisposition;
+
+
+    if (ProviderInstall ("remotesp.tsp", TRUE) == 0)
+    {
+        //
+        // Initialize our ProviderN section
+        //
+
+        wsprintf (buf, "Provider%d", dwPermanentProviderID);
+
+        if (RegCreateKeyEx(
+                HKEY_LOCAL_MACHINE,
+                gszTelephonyKey,
+                0,
+                "",
+                REG_OPTION_NON_VOLATILE,
+                KEY_ALL_ACCESS,
+                (LPSECURITY_ATTRIBUTES) NULL,
+                &hTelephonyKey,
+                &dwDisposition
+
+                ) == ERROR_SUCCESS)
+        {
+            if (RegCreateKeyEx(
+                    hTelephonyKey,
+                    buf,
+                    0,
+                    "",
+                    REG_OPTION_NON_VOLATILE,
+                    KEY_ALL_ACCESS,
+                    (LPSECURITY_ATTRIBUTES) NULL,
+                    &hProviderNKey,
+                    &dwDisposition
+
+                    ) == ERROR_SUCCESS)
+            {
+                dwTemp = 0;
+
+                RegSetValueEx(
+                    hProviderNKey,
+                    gszNumServers,
+                    0,
+                    REG_DWORD,
+                    (LPBYTE) &dwTemp,
+                    sizeof(dwTemp)
+                    );
+
+                RegCloseKey (hProviderNKey);
+                RegCloseKey (hTelephonyKey);
+
+                DialogBoxParam(
+                    ghInst,
+                    MAKEINTRESOURCE(100),
+                    hwndOwner,
+                    (DLGPROC) ConfigDlgProc,
+                    (LPARAM) dwPermanentProviderID
+                    );
+
+                lResult = 0;
+            }
+            else
+            {
+                RegCloseKey (hTelephonyKey);
+            }
+        }
+    }
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TUISPI_providerRemove(
+    TUISPIDLLCALLBACK   lpfnUIDLLCallback,
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    char    buf[32];
+    LONG    lResult;
+    HKEY    hTelephonyKey;
+
+
+    //
+    // Clean up our ProviderN section
+    //
+
+    wsprintf (buf, "Provider%d", dwPermanentProviderID);
+
+    if (RegOpenKeyExA(
+            HKEY_LOCAL_MACHINE,
+            gszTelephonyKey,
+            0,
+            KEY_ALL_ACCESS,
+            &hTelephonyKey
+
+            ) == ERROR_SUCCESS)
+    {
+        RegDeleteKey (hTelephonyKey, buf);
+        RegCloseKey (hTelephonyKey);
+        lResult = 0;
+    }
+    else
+    {
+        lResult = LINEERR_OPERATIONFAILED;
+    }
+
+    return lResult;
+}
+
+
+//
+// ------------------------ Private support routines --------------------------
+//
+
+#if DBG
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+{
+    if (dwDbgLevel <= gdwDebugLevel)
+    {
+        char    buf[128] = "REMOTESP: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+        wvsprintf (&buf[10], lpszFormat, ap);
+        lstrcatA (buf, "\n");
+        OutputDebugStringA (buf);
+        va_end(ap);
+    }
+}
+#endif
+
+
+LONG
+AddLine(
+    PDRVSERVER  pServer,
+    DWORD       dwDeviceIDLocal,
+    DWORD       dwDeviceIDServer,
+    BOOL        bInit
+    )
+{
+    PDRVLINE        pLine;
+    PDRVLINELOOKUP  pLineLookup;
+
+
+    if (!gpLineLookup)
+    {
+        if (!(gpLineLookup = DrvAlloc(
+                sizeof(DRVLINELOOKUP) +
+                    (DEF_NUM_LINE_ENTRIES-1) * sizeof (DRVLINE)
+                )))
+        {
+            return LINEERR_NOMEM;
+        }
+
+        gpLineLookup->dwTotalEntries = DEF_NUM_LINE_ENTRIES;
+    }
+
+    pLineLookup = gpLineLookup;
+
+    while (pLineLookup->pNext)
+    {
+        pLineLookup = pLineLookup->pNext;
+    }
+
+    if (pLineLookup->dwUsedEntries == pLineLookup->dwTotalEntries)
+    {
+        PDRVLINELOOKUP  pNewLineLookup;
+
+
+        if (!(pNewLineLookup = DrvAlloc(
+                sizeof(DRVLINELOOKUP) +
+                    (2 * pLineLookup->dwTotalEntries - 1) * sizeof(DRVLINE)
+                )))
+        {
+            return LINEERR_NOMEM;
+        }
+
+        pNewLineLookup->dwTotalEntries = 2 * pLineLookup->dwTotalEntries;
+
+        if (bInit)
+        {
+            pNewLineLookup->dwUsedEntries = pLineLookup->dwTotalEntries;
+
+            CopyMemory(
+                pNewLineLookup->aEntries,
+                pLineLookup->aEntries,
+                pLineLookup->dwTotalEntries * sizeof (DRVLINE)
+                );
+
+            DrvFree (pLineLookup);
+
+            gpLineLookup = pNewLineLookup;
+
+        }
+
+        pLineLookup = pNewLineLookup;
+    }
+
+    pLine = pLineLookup->aEntries + pLineLookup->dwUsedEntries;
+
+    pLine->pServer          = pServer;
+    pLine->dwDeviceIDLocal  = dwDeviceIDLocal;
+    pLine->dwDeviceIDServer = dwDeviceIDServer;
+
+    pLineLookup->dwUsedEntries++;
+
+
+    //
+    // Negotiate the API/SPI version
+    //
+
+    {
+        static REMOTE_ARG_TYPES argTypes[] =
+        {
+            Dword,
+            LineID,
+            Dword,
+            Dword,
+            lpDword,
+            lpGet_SizeToFollow,
+            Size
+        };
+        DWORD args[] =
+        {
+            (DWORD) pServer->hLineApp,
+            (DWORD) dwDeviceIDLocal,
+            (DWORD) TAPI_VERSION1_0,
+            (DWORD) TAPI_VERSION_CURRENT,
+            (DWORD) &pLine->dwXPIVersion,
+            (DWORD) &pLine->ExtensionID,
+            (DWORD) sizeof (LINEEXTENSIONID),
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (LINE_FUNC | SYNC | 7, lNegotiateAPIVersion),
+            args,
+            argTypes
+        };
+
+
+        REMOTEDOFUNC (&funcArgs, "lineNegotiateAPIVersion");
+    }
+
+    return 0;
+}
+
+
+LONG
+AddPhone(
+    PDRVSERVER  pServer,
+    DWORD       dwDeviceIDLocal,
+    DWORD       dwDeviceIDServer,
+    BOOL        bInit
+    )
+{
+    PDRVPHONE       pPhone;
+    PDRVPHONELOOKUP pPhoneLookup;
+
+
+    if (!gpPhoneLookup)
+    {
+        if (!(gpPhoneLookup = DrvAlloc(
+                sizeof(DRVPHONELOOKUP) +
+                    (DEF_NUM_PHONE_ENTRIES-1) * sizeof (DRVPHONE)
+                )))
+        {
+            return (bInit ? LINEERR_NOMEM : PHONEERR_NOMEM);
+        }
+
+        gpPhoneLookup->dwTotalEntries = DEF_NUM_PHONE_ENTRIES;
+    }
+
+    pPhoneLookup = gpPhoneLookup;
+
+    while (pPhoneLookup->pNext)
+    {
+        pPhoneLookup = pPhoneLookup->pNext;
+    }
+
+    if (pPhoneLookup->dwUsedEntries == pPhoneLookup->dwTotalEntries)
+    {
+        PDRVPHONELOOKUP pNewPhoneLookup;
+
+
+        if (!(pNewPhoneLookup = DrvAlloc(
+                sizeof(DRVPHONELOOKUP) +
+                    (2 * pPhoneLookup->dwTotalEntries - 1) * sizeof(DRVPHONE)
+                )))
+        {
+            return (bInit ? LINEERR_NOMEM : PHONEERR_NOMEM);
+        }
+
+        pNewPhoneLookup->dwTotalEntries = 2 * pPhoneLookup->dwTotalEntries;
+
+        if (bInit)
+        {
+            pNewPhoneLookup->dwUsedEntries = pPhoneLookup->dwTotalEntries;
+
+            CopyMemory(
+                pNewPhoneLookup->aEntries,
+                pPhoneLookup->aEntries,
+                pPhoneLookup->dwTotalEntries * sizeof (DRVPHONE)
+                );
+
+            DrvFree (pPhoneLookup);
+
+            gpPhoneLookup = pNewPhoneLookup;
+        }
+
+        pPhoneLookup = pNewPhoneLookup;
+    }
+
+    pPhone = pPhoneLookup->aEntries + pPhoneLookup->dwUsedEntries;
+
+    pPhone->pServer          = pServer;
+    pPhone->dwDeviceIDLocal  = dwDeviceIDLocal;
+    pPhone->dwDeviceIDServer = dwDeviceIDServer;
+
+    pPhoneLookup->dwUsedEntries++;
+
+
+    //
+    // Negotiate the API/SPI version
+    //
+
+    {
+        static REMOTE_ARG_TYPES argTypes[] =
+        {
+            Dword,
+            PhoneID,
+            Dword,
+            Dword,
+            lpDword,
+            lpGet_SizeToFollow,
+            Size
+        };
+        DWORD args[] =
+        {
+            (DWORD) pServer->hPhoneApp,
+            (DWORD) dwDeviceIDLocal,
+            (DWORD) TAPI_VERSION1_0,
+            (DWORD) TAPI_VERSION_CURRENT,
+            (DWORD) &pPhone->dwXPIVersion,
+            (DWORD) &pPhone->ExtensionID,
+            (DWORD) sizeof (PHONEEXTENSIONID),
+        };
+        REMOTE_FUNC_ARGS funcArgs =
+        {
+            MAKELONG (PHONE_FUNC | SYNC | 7, pNegotiateAPIVersion),
+            args,
+            argTypes
+        };
+
+
+        REMOTEDOFUNC (&funcArgs, "phoneNegotiateAPIVersion");
+    }
+
+    return 0;
+}
+
+
+LPVOID
+DrvAlloc(
+    DWORD   dwSize
+    )
+{
+    return (LocalAlloc (LPTR, dwSize));
+}
+
+
+void
+DrvFree(
+    LPVOID  p
+    )
+{
+    LocalFree (p);
+}
+
+
+void
+__RPC_FAR *
+__RPC_API
+midl_user_allocate(
+    size_t len
+    )
+{
+    return (DrvAlloc (len));
+}
+
+
+void
+__RPC_API
+midl_user_free(
+    void __RPC_FAR * ptr
+    )
+{
+    DrvFree (ptr);
+}
+
+
+LONG
+RemoteSPAttach(
+    PCONTEXT_HANDLE_TYPE2  *pphContext
+    )
+{
+    //
+    // This func is called by TapiSrv.exe on a remote machine as a
+    // result of the call to ClientAttach in TSPI_providerEnumDevices.
+    // The gpServer variable contains a pointer to the DRVSERVER
+    // structure we are currently initializing for this tapi server,
+    // so we'll use this as the context value.
+    //
+
+    DBGOUT((3, "RemoteSPAttach: enter"));
+
+    *pphContext = (PCONTEXT_HANDLE_TYPE) gpServer;
+
+    return 0;
+}
+
+
+void
+RemoteSPEventProc(
+    PCONTEXT_HANDLE_TYPE2   phContext,
+    unsigned char          *pBuffer,
+    long                    lSize
+    )
+{
+    //
+    // This func is called by tapisrv on a remote machine.  We want to do
+    // things as quickly as possible here and return so we don't block the
+    // calling server thread.
+    //
+
+    DWORD   dwMoveSize = (DWORD) lSize, dwMoveSizeWrapped = 0;
+
+
+    //
+    // Enter the critical section to sync access to gEventHandlerThreadParams
+    //
+
+    EnterCriticalSection (&gEventBufferCriticalSection);
+
+
+    //
+    // Check to see if there's enough room for this msg in the event buffer.
+    // If not, then alloc a new event buffer, copy contents of existing buffer
+    // to new buffer (careful to preserve ordering of valid data), free the
+    // existing buffer, and reset the pointers.
+    //
+
+    if ((gEventHandlerThreadParams.dwEventBufferUsedSize + lSize) >
+            gEventHandlerThreadParams.dwEventBufferTotalSize)
+    {
+        DWORD  dwMoveSize2, dwMoveSizeWrapped2, dwNewEventBufferTotalSize;
+        LPBYTE pNewEventBuffer;
+
+
+        //
+        // Alloc a few more bytes than actually needed in the hope that we
+        // won't have to do this again soon (we don't want to go overboard
+        // & alloc a whole bunch since we don't currently free the buffer
+        // until provider shutdown)
+        //
+
+        dwNewEventBufferTotalSize =
+            gEventHandlerThreadParams.dwEventBufferUsedSize + lSize + 512;
+
+        if (!(pNewEventBuffer = DrvAlloc (dwNewEventBufferTotalSize)))
+        {
+            // BUGBUG we're hosed, blow off the msg (send a REINIT?)
+
+            LeaveCriticalSection (&gEventBufferCriticalSection);
+
+            return;
+        }
+
+        if (gEventHandlerThreadParams.dwEventBufferUsedSize != 0)
+        {
+            if (gEventHandlerThreadParams.pDataIn >
+                    gEventHandlerThreadParams.pDataOut)
+            {
+                dwMoveSize2 = (DWORD) (gEventHandlerThreadParams.pDataIn -
+                    gEventHandlerThreadParams.pDataOut);
+
+                dwMoveSizeWrapped2 = 0;
+            }
+            else
+            {
+                dwMoveSize2 = (DWORD) ((gEventHandlerThreadParams.pEventBuffer
+                    + gEventHandlerThreadParams.dwEventBufferTotalSize)
+                    - gEventHandlerThreadParams.pDataOut);
+
+                dwMoveSizeWrapped2 = (DWORD) (gEventHandlerThreadParams.pDataIn
+                    - gEventHandlerThreadParams.pEventBuffer);
+            }
+
+            CopyMemory(
+                pNewEventBuffer,
+                gEventHandlerThreadParams.pDataOut,
+                dwMoveSize2
+                );
+
+            if (dwMoveSizeWrapped2)
+            {
+                CopyMemory(
+                    pNewEventBuffer + dwMoveSize2,
+                    gEventHandlerThreadParams.pEventBuffer,
+                    dwMoveSizeWrapped2
+                    );
+            }
+
+            DrvFree (gEventHandlerThreadParams.pEventBuffer);
+
+            gEventHandlerThreadParams.pDataIn = pNewEventBuffer + dwMoveSize2 +
+                dwMoveSizeWrapped2;
+        }
+        else
+        {
+            gEventHandlerThreadParams.pDataIn = pNewEventBuffer;
+        }
+
+        gEventHandlerThreadParams.pDataOut =
+        gEventHandlerThreadParams.pEventBuffer = pNewEventBuffer;
+
+        gEventHandlerThreadParams.dwEventBufferTotalSize =
+            dwNewEventBufferTotalSize;
+    }
+
+
+    //
+    // Write the msg data to the buffer
+    //
+
+    if (gEventHandlerThreadParams.pDataIn >=
+            gEventHandlerThreadParams.pDataOut)
+    {
+        DWORD dwFreeSize;
+
+
+        dwFreeSize = gEventHandlerThreadParams.dwEventBufferTotalSize -
+            (gEventHandlerThreadParams.pDataIn -
+            gEventHandlerThreadParams.pEventBuffer);
+
+        if (dwMoveSize > dwFreeSize)
+        {
+            dwMoveSizeWrapped = dwMoveSize - dwFreeSize;
+
+            dwMoveSize = dwFreeSize;
+        }
+    }
+
+    CopyMemory (gEventHandlerThreadParams.pDataIn, pBuffer, dwMoveSize);
+
+    if (dwMoveSizeWrapped != 0)
+    {
+        CopyMemory(
+            gEventHandlerThreadParams.pEventBuffer,
+            pBuffer + dwMoveSize,
+            dwMoveSizeWrapped
+            );
+
+        gEventHandlerThreadParams.pDataIn =
+            gEventHandlerThreadParams.pEventBuffer + dwMoveSizeWrapped;
+    }
+    else
+    {
+        gEventHandlerThreadParams.pDataIn += dwMoveSize;
+    }
+
+    gEventHandlerThreadParams.dwEventBufferUsedSize += (DWORD) lSize;
+
+
+    //
+    // Tell the EventHandlerThread there's another event to handle by
+    // signaling the event
+    //
+
+    SetEvent (gEventHandlerThreadParams.hEvent);
+
+
+    //
+    // We're done...
+    //
+
+    LeaveCriticalSection (&gEventBufferCriticalSection);
+
+
+    DBGOUT((3, "WriteEventBuffer: bytesWritten=x%x", lSize));
+}
+
+
+void
+__RPC_USER
+PCONTEXT_HANDLE_TYPE2_rundown(
+    PCONTEXT_HANDLE_TYPE2   phContext
+    )
+{
+    //
+    // This func is called when a server dies.  We need to close any open
+    // lines/phones associated with the server, complete pending reqs, and...
+    //
+    // BUGBUG PCONTEXT_HANDLE_TYPE2_rundown
+    //
+}
+
+
+void
+RemoteSPDetach(
+    PCONTEXT_HANDLE_TYPE2   *pphContext
+    )
+{
+    DBGOUT((3, "RemoteSPDetach: enter"));
+
+    PCONTEXT_HANDLE_TYPE2_rundown (*pphContext);
+
+    *pphContext = (PCONTEXT_HANDLE_TYPE) NULL;
+
+    DBGOUT((3, "RemoteSPDetach: exit"));
+}
+
+
+LONG
+AddCallToList(
+    PDRVLINE    pLine,
+    PDRVCALL    pCall
+    )
+{
+    //
+    // Initialize some common fields in the call
+    //
+
+    pCall->pServer = pLine->pServer;
+    pCall->pLine   = pLine;
+
+
+    //
+    // Safely add the call to the line's list
+    //
+
+    EnterCriticalSection (&gCallListCriticalSection);
+
+    if ((pCall->pNext = (PDRVCALL) pLine->pCalls))
+    {
+        pCall->pNext->pPrev = pCall;
+    }
+
+    pLine->pCalls = pCall;
+
+    LeaveCriticalSection (&gCallListCriticalSection);
+
+    return 0;
+}
+
+
+LONG
+RemoveCallFromList(
+    PDRVCALL    pCall
+    )
+{
+    //
+    // Safely remove the call from the line's list
+    //
+
+    EnterCriticalSection (&gCallListCriticalSection);
+
+    if (pCall->pNext)
+    {
+        pCall->pNext->pPrev = pCall->pPrev;
+    }
+
+    if (pCall->pPrev)
+    {
+        pCall->pPrev->pNext = pCall->pNext;
+    }
+    else
+    {
+        pCall->pLine->pCalls = pCall->pNext;
+    }
+
+    LeaveCriticalSection (&gCallListCriticalSection);
+
+    return 0;
+}
+
+
+void
+Shutdown(
+    PDRVSERVER  pServer
+    )
+{
+    //
+    // Do a lineShutdown
+    //
+
+    {
+        DWORD                   dwSize;
+        TAPI32_MSG              msg;
+        PLINESHUTDOWN_PARAMS    pParams;
+
+
+        msg.u.Req_Func = lShutdown;
+
+        pParams = (PLINESHUTDOWN_PARAMS) &msg;
+
+        pParams->hLineApp = pServer->hLineApp;
+
+        dwSize = sizeof (TAPI32_MSG);
+
+        {
+            DWORD dwRetryCount = 0;
+
+
+            do
+            {
+                RpcTryExcept
+                {
+                    ClientRequest(
+                        pServer->phContext,
+                        (char *) &msg,
+                        dwSize,
+                        &dwSize
+                        );
+
+                    dwRetryCount = gdwRetryCount;
+                }
+                RpcExcept (1)
+                {
+                    // TODO may want to increase the retry count here since we
+                    //      have to do this, & a million other clients may be
+                    //      trying to do the same thing at the same time
+
+                    if (dwRetryCount++ < gdwRetryCount)
+                    {
+                        Sleep (gdwRetryTimeout);
+                    }
+                }
+                RpcEndExcept
+
+            } while (dwRetryCount < gdwRetryCount);
+        }
+    }
+
+
+    //
+    // Do a phoneShutdown
+    //
+
+    {
+        DWORD                   dwSize;
+        TAPI32_MSG              msg;
+        PPHONESHUTDOWN_PARAMS   pParams;
+
+
+        msg.u.Req_Func = pShutdown;
+
+        pParams = (PPHONESHUTDOWN_PARAMS) &msg;
+
+        pParams->hPhoneApp = pServer->hPhoneApp;
+
+        dwSize = sizeof (TAPI32_MSG);
+
+        {
+            DWORD dwRetryCount = 0;
+
+
+            do
+            {
+                RpcTryExcept
+                {
+                    ClientRequest(
+                        pServer->phContext,
+                        (char *) &msg,
+                        dwSize,
+                        &dwSize
+                        );
+
+                    dwRetryCount = gdwRetryCount;
+                }
+                RpcExcept (1)
+                {
+                    // TODO may want to increase the retry count here since we
+                    //      have to do this, & a million other clients may be
+                    //      trying to do the same thing at the same time
+
+                    if (dwRetryCount++ < gdwRetryCount)
+                    {
+                        Sleep (gdwRetryTimeout);
+                    }
+                }
+                RpcEndExcept
+
+            } while (dwRetryCount < gdwRetryCount);
+        }
+    }
+
+
+    //
+    // Mark the server as disconnected (so no more requests will be sent)
+    //
+
+    pServer->bDisconnected = TRUE;
+
+
+    //
+    // Walk the line lookup tables & send a CLOSE msg for each open line
+    // associated with the server
+    //
+
+    {
+        PDRVLINELOOKUP  pLookup = gpLineLookup;
+
+
+        while (pLookup)
+        {
+            DWORD     i;
+            PDRVLINE  pLine;
+
+
+            for(
+                i = 0, pLine = pLookup->aEntries;
+                i < pLookup->dwUsedEntries;
+                i++, pLine++
+                )
+            {
+                if (pLine->pServer == pServer)
+                {
+                    pLine->pServer = NULL;
+
+                    if (pLine->htLine)
+                    {
+                        PDRVCALL pCall;
+
+
+                        pLine->hLine = NULL;
+
+                        EnterCriticalSection (&gCallListCriticalSection);
+
+                        pCall = pLine->pCalls;
+
+                        while (pCall)
+                        {
+                            pCall->hCall = NULL;
+
+                            pCall = pCall->pNext;
+                        }
+
+                        LeaveCriticalSection (&gCallListCriticalSection);
+
+                        (*gpfnLineEventProc)(
+                            pLine->htLine,
+                            NULL,
+                            LINE_CLOSE,
+                            0,
+                            0,
+                            0
+                            );
+                    }
+                }
+            }
+
+            pLookup = pLookup->pNext;
+        }
+    }
+
+
+    //
+    // Walk the phone lookup tables & send a CLOSE msg for each open phone
+    // associated with the server
+    //
+
+    {
+        PDRVPHONELOOKUP pLookup = gpPhoneLookup;
+
+
+        while (pLookup)
+        {
+            DWORD     i;
+            PDRVPHONE pPhone;
+
+
+            for(
+                i = 0, pPhone = pLookup->aEntries;
+                i < pLookup->dwUsedEntries;
+                i++, pPhone++
+                )
+            {
+                if (pPhone->pServer == pServer)
+                {
+                    pPhone->pServer = NULL;
+
+                    if (pPhone->htPhone)
+                    {
+                        pPhone->hPhone = NULL;
+
+                        (*gpfnPhoneEventProc)(
+                            pPhone->htPhone,
+                            PHONE_CLOSE,
+                            0,
+                            0,
+                            0
+                            );
+                    }
+                }
+            }
+
+            pLookup = pLookup->pNext;
+        }
+    }
+}
+
+
+BOOL
+CALLBACK
+ConfigDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    )
+{
+    static  HKEY    hTelephonyKey, hProviderNKey;
+
+    DWORD   dwDataType, dwDataSize;
+
+
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+        char    buf[32], szProviderN[16], szServerN[16];
+        BOOL    bReadOnly;
+        DWORD   i, iNumServers;
+        DWORD   dwPermanentProviderID = (DWORD) lParam;
+
+
+        //
+        // First try to open the Telephony key with read/write access.
+        // If that fails, disable any controls that could cause a chg
+        // in config & try opening again with read only access.
+        //
+
+        if (RegOpenKeyEx(
+                HKEY_LOCAL_MACHINE,
+                gszTelephonyKey,
+                0,
+                KEY_ALL_ACCESS,
+                &hTelephonyKey
+
+                ) != ERROR_SUCCESS)
+        {
+            EnableWindow (GetDlgItem (hwnd, IDC_ADD), FALSE);
+            EnableWindow (GetDlgItem (hwnd, IDC_REMOVE), FALSE);
+            EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
+
+            if (RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    gszTelephonyKey,
+                    0,
+                    KEY_READ,
+                    &hTelephonyKey
+
+                    ) != ERROR_SUCCESS)
+            {
+                EndDialog (hwnd, 0);
+                return FALSE;
+            }
+
+            bReadOnly = TRUE;
+        }
+        else
+        {
+            bReadOnly = FALSE;
+        }
+
+        wsprintf (szProviderN, "%s%d", gszProvider, dwPermanentProviderID);
+
+        RegOpenKeyEx(
+            hTelephonyKey,
+            szProviderN,
+            0,
+            (bReadOnly ? KEY_READ : KEY_ALL_ACCESS),
+            &hProviderNKey
+            );
+
+        dwDataSize = sizeof(iNumServers);
+
+        RegQueryValueEx(
+            hProviderNKey,
+            gszNumServers,
+            0,
+            &dwDataType,
+            (LPBYTE) &iNumServers,
+            &dwDataSize
+            );
+
+        for (i = 0; i < iNumServers; i++)
+        {
+            wsprintf (szServerN, "%s%d", gszServer, i);
+
+            dwDataSize = sizeof(buf);
+
+            RegQueryValueEx(
+                hProviderNKey,
+                szServerN,
+                0,
+                &dwDataType,
+                (LPBYTE) buf,
+                &dwDataSize
+                );
+
+            buf[dwDataSize] = '\0';
+
+            SendDlgItemMessage(
+                hwnd,
+                IDC_LIST1,
+                LB_ADDSTRING,
+                0,
+                (LPARAM) buf
+                );
+        }
+
+        SetWindowLong (hwnd, GWL_USERDATA, dwPermanentProviderID);
+
+        break;
+    }
+    case WM_COMMAND:
+
+        switch (LOWORD(wParam))
+        {
+        case IDC_ADD:
+        {
+            char buf[32];
+
+
+            GetDlgItemText (hwnd, IDC_EDIT1, buf, 31);
+
+            if (buf[0])
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_ADDSTRING,
+                    0,
+                    (LPARAM) buf
+                    );
+            }
+
+            SetDlgItemText (hwnd, IDC_EDIT1, "");
+
+            break;
+        }
+        case IDC_REMOVE:
+        {
+            char buf[32];
+            LONG lSel;
+
+
+            if ((lSel = SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_GETCURSEL,
+                    0,
+                    0
+
+                    )) != LB_ERR)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_GETTEXT,
+                    lSel,
+                    (LPARAM) buf
+                    );
+
+                SendDlgItemMessage (hwnd, IDC_LIST1, LB_DELETESTRING, lSel, 0);
+
+                SetDlgItemText (hwnd, IDC_EDIT1, buf);
+            }
+
+            break;
+        }
+        case IDOK:
+        {
+            char    buf[32], szServerN[16], szProviderN[16];
+            DWORD   i, lCount;
+
+
+            wsprintf(
+                szProviderN,
+                "%s%d",
+                gszProvider,
+                GetWindowLong (hwnd, GWL_USERDATA)
+                );
+
+            lCount = SendDlgItemMessage (hwnd, IDC_LIST1, LB_GETCOUNT, 0, 0);
+
+            RegSetValueEx(
+                hProviderNKey,
+                gszNumServers,
+                0,
+                REG_DWORD,
+                (LPBYTE) &lCount,
+                sizeof(lCount)
+                );
+
+            for (i = 0; i < lCount; i++)
+            {
+                SendDlgItemMessage(
+                    hwnd,
+                    IDC_LIST1,
+                    LB_GETTEXT,
+                    i,
+                    (LPARAM) buf
+                    );
+
+                wsprintf (szServerN, "%s%d", gszServer, i);
+
+                RegSetValueEx(
+                    hProviderNKey,
+                    szServerN,
+                    0,
+                    REG_SZ,
+                    (LPBYTE) buf,
+                    lstrlenA (buf) + 1
+                    );
+            }
+
+            // fall thru to below
+        }
+        case IDCANCEL:
+
+            RegCloseKey (hProviderNKey);
+            RegCloseKey (hTelephonyKey);
+            EndDialog (hwnd, 0);
+            break;
+
+        } // switch (LOWORD(wParam))
+
+        break;
+
+/* don't want to bring in another lib just yet
+    case WM_PAINT:
+    {
+        PAINTSTRUCT ps;
+
+        BeginPaint (hwnd, &ps);
+        FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+        EndPaint (hwnd, &ps);
+
+        break;
+    } */
+    } // switch (msg)
+
+    return FALSE;
+}
+
+
+LONG
+PASCAL
+ProviderInstall(
+    char   *pszProviderName,
+    BOOL    bNoMultipleInstance
+    )
+{
+    LONG    lResult;
+
+
+    //
+    // If only one installation instance of this provider is
+    // allowed then we want to check the provider list to see
+    // if the provider is already installed
+    //
+
+    if (bNoMultipleInstance)
+    {
+        LONG                (WINAPI *pfnGetProviderList)();
+        DWORD               dwTotalSize, i;
+        HINSTANCE           hTapi32;
+        LPLINEPROVIDERLIST  pProviderList;
+        LPLINEPROVIDERENTRY pProviderEntry;
+
+
+        //
+        // Load Tapi32.dll & get a pointer to the lineGetProviderList
+        // func.  We don't want to statically link because this module
+        // plays the part of both core SP & UI DLL, and we don't want
+        // to incur the performance hit of automatically loading
+        // Tapi32.dll when running as a core SP within Tapisrv.exe's
+        // context.
+        //
+
+        if (!(hTapi32 = LoadLibrary ("tapi32.dll")))
+        {
+            DBGOUT((
+                1,
+                "LoadLibrary(tapi32.dll) failed, err=%d",
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONFAILED;
+            goto ProviderInstall_return;
+        }
+
+        if (!((FARPROC) pfnGetProviderList = GetProcAddress(
+                hTapi32,
+                (LPCSTR) "lineGetProviderList"
+                )))
+        {
+            DBGOUT((
+                1,
+                "GetProcAddr(lineGetProviderList) failed, err=%d",
+                GetLastError()
+                ));
+
+            lResult = LINEERR_OPERATIONFAILED;
+            goto ProviderInstall_unloadTapi32;
+        }
+
+
+        //
+        // Loop until we get the full provider list
+        //
+
+        dwTotalSize = sizeof (LINEPROVIDERLIST);
+
+        goto ProviderInstall_allocProviderList;
+
+ProviderInstall_getProviderList:
+
+        if ((lResult = (*pfnGetProviderList)(0x00020000, pProviderList)) != 0)
+        {
+            goto ProviderInstall_freeProviderList;
+        }
+
+        if (pProviderList->dwNeededSize > pProviderList->dwTotalSize)
+        {
+            dwTotalSize = pProviderList->dwNeededSize;
+
+            LocalFree (pProviderList);
+
+ProviderInstall_allocProviderList:
+
+            if (!(pProviderList = LocalAlloc (LPTR, dwTotalSize)))
+            {
+                lResult = LINEERR_NOMEM;
+                goto ProviderInstall_unloadTapi32;
+            }
+
+            pProviderList->dwTotalSize = dwTotalSize;
+
+            goto ProviderInstall_getProviderList;
+        }
+
+
+        //
+        // Inspect the provider list entries to see if this provider
+        // is already installed
+        //
+
+        pProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) pProviderList) +
+            pProviderList->dwProviderListOffset);
+
+        for (i = 0; i < pProviderList->dwNumProviders; i++)
+        {
+            char   *pszInstalledProviderName = ((char *) pProviderList) +
+                        pProviderEntry->dwProviderFilenameOffset,
+                   *p;
+
+
+            //
+            // Make sure pszInstalledProviderName points at <filename>
+            // and not <path>\filename by walking backeards thru the
+            // string searching for last '\\'
+            //
+
+            p = pszInstalledProviderName +
+                lstrlen (pszInstalledProviderName) - 1;
+
+            for (; *p != '\\'  &&  p != pszInstalledProviderName; p--);
+
+            pszInstalledProviderName =
+                (p == pszInstalledProviderName ? p : p + 1);
+
+            if (lstrcmpiA (pszInstalledProviderName, pszProviderName) == 0)
+            {
+                lResult = LINEERR_NOMULTIPLEINSTANCE;
+                goto ProviderInstall_freeProviderList;
+            }
+
+            pProviderEntry++;
+        }
+
+
+        //
+        // If here then the provider isn't currently installed,
+        // so do whatever configuration stuff is necessary and
+        // indicate SUCCESS
+        //
+
+        lResult = 0;
+
+
+ProviderInstall_freeProviderList:
+
+        LocalFree (pProviderList);
+
+ProviderInstall_unloadTapi32:
+
+        FreeLibrary (hTapi32);
+    }
+    else
+    {
+        //
+        // Do whatever configuration stuff is necessary and return SUCCESS
+        //
+
+        lResult = 0;
+    }
+
+ProviderInstall_return:
+
+    return lResult;
+}
diff --git a/private/tapi/dev/sp/remotesp/remotesp.def b/private/tapi/dev/sp/remotesp/remotesp.def
new file mode 100644
index 000000000..f962cad77
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/remotesp.def
@@ -0,0 +1,126 @@
+LIBRARY     REMOTESP
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept
+        TSPI_lineAddToConference
+        TSPI_lineAnswer
+        TSPI_lineBlindTransfer
+        TSPI_lineClose
+        TSPI_lineCloseCall
+        TSPI_lineCompleteCall
+        TSPI_lineCompleteTransfer
+        TSPI_lineConditionalMediaDetection
+        TSPI_lineDevSpecific
+        TSPI_lineDevSpecificFeature
+        TSPI_lineDial
+        TSPI_lineDrop
+        TSPI_lineForward
+        TSPI_lineGatherDigits
+        TSPI_lineGenerateDigits
+        TSPI_lineGenerateTone
+        TSPI_lineGetAddressCaps
+        TSPI_lineGetAddressID
+        TSPI_lineGetAddressStatus
+        TSPI_lineGetCallAddressID
+        TSPI_lineGetCallInfo
+        TSPI_lineGetCallStatus
+        TSPI_lineGetDevCaps
+        TSPI_lineGetDevConfig
+        TSPI_lineGetExtensionID
+        TSPI_lineGetIcon
+        TSPI_lineGetID
+        TSPI_lineGetLineDevStatus
+        TSPI_lineGetNumAddressIDs
+        TSPI_lineHold
+        TSPI_lineMakeCall
+        TSPI_lineMonitorDigits
+        TSPI_lineMonitorMedia
+        TSPI_lineMonitorTones
+        TSPI_lineNegotiateExtVersion
+        TSPI_lineNegotiateTSPIVersion
+        TSPI_lineOpen
+        TSPI_linePark
+        TSPI_linePickup
+        TSPI_linePrepareAddToConference
+        TSPI_lineRedirect
+        TSPI_lineRemoveFromConference
+        TSPI_lineSecureCall
+        TSPI_lineSelectExtVersion
+        TSPI_lineSendUserUserInfo
+        TSPI_lineSetAppSpecific
+        TSPI_lineSetCallParams
+        TSPI_lineSetDefaultMediaDetection
+        TSPI_lineSetDevConfig
+        TSPI_lineSetMediaControl
+        TSPI_lineSetMediaMode
+        TSPI_lineSetStatusMessages
+        TSPI_lineSetTerminal
+        TSPI_lineSetupConference
+        TSPI_lineSetupTransfer
+        TSPI_lineSwapHold
+        TSPI_lineUncompleteCall
+        TSPI_lineUnhold
+        TSPI_lineUnpark
+
+        TSPI_phoneClose
+        TSPI_phoneDevSpecific
+        TSPI_phoneGetButtonInfo
+        TSPI_phoneGetData
+        TSPI_phoneGetDevCaps
+        TSPI_phoneGetDisplay
+        TSPI_phoneGetExtensionID
+        TSPI_phoneGetGain
+        TSPI_phoneGetHookSwitch
+        TSPI_phoneGetIcon
+        TSPI_phoneGetID
+        TSPI_phoneGetLamp
+        TSPI_phoneGetRing
+        TSPI_phoneGetStatus
+        TSPI_phoneGetVolume
+        TSPI_phoneNegotiateExtVersion
+        TSPI_phoneNegotiateTSPIVersion
+        TSPI_phoneOpen
+        TSPI_phoneSelectExtVersion
+        TSPI_phoneSetButtonInfo
+        TSPI_phoneSetData
+        TSPI_phoneSetDisplay
+        TSPI_phoneSetGain
+        TSPI_phoneSetHookSwitch
+        TSPI_phoneSetLamp
+        TSPI_phoneSetRing
+        TSPI_phoneSetStatusMessages
+        TSPI_phoneSetVolume
+
+        TSPI_providerConfig
+        TSPI_providerInit
+        TSPI_providerInstall
+        TSPI_providerRemove
+        TSPI_providerShutdown
+
+        TSPI_providerEnumDevices
+        TSPI_providerCreateLineDevice
+        TSPI_providerCreatePhoneDevice
+        TSPI_lineSetCurrentLocation
+        TSPI_lineReleaseUserUserInfo
+
+        TSPI_lineSetCallData
+        TSPI_lineSetCallQualityOfService
+        TSPI_lineSetCallTreatment
+        TSPI_lineSetLineDevStatus
+        TSPI_providerFreeDialogInstance
+        TSPI_providerGenericDialogData
+        TSPI_providerUIIdentify
+
+        TUISPI_lineConfigDialog
+        TUISPI_lineConfigDialogEdit
+        TUISPI_phoneConfigDialog
+        TUISPI_providerConfig
+        TUISPI_providerGenericDialog
+        TUISPI_providerGenericDialogData
+        TUISPI_providerInstall
+        TUISPI_providerRemove
+
+        ConfigDlgProc
diff --git a/private/tapi/dev/sp/remotesp/remotesp.h b/private/tapi/dev/sp/remotesp/remotesp.h
new file mode 100644
index 000000000..31394788d
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/remotesp.h
@@ -0,0 +1,388 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    remotesp.h
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+#include "windows.h"
+#include "stddef.h"
+#include "stdarg.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "client.h"
+#include "server.h"
+#include "line.h"
+#undef DEVICE_ID
+#include "phone.h"
+#include "tapsrv.h"
+#include "tapi.h"
+#include "tspi.h"
+#include "resource.h"
+
+
+#define NO_DATA                         0xffffffff
+
+#define DEF_NUM_LINE_ENTRIES            16
+#define DEF_NUM_PHONE_ENTRIES           16
+
+#define IDI_ICON1                       101
+#define IDI_ICON2                       102
+#define IDI_ICON3                       103
+
+#define DRVLINE_KEY                     ((DWORD) 'DRVL')
+#define DRVCALL_KEY                     ((DWORD) 'DRVC')
+#define DRVPHONE_KEY                    ((DWORD) 'DRVP')
+
+
+typedef struct _DRVSERVER
+{
+    char                   *pServerName;
+
+    PCONTEXT_HANDLE_TYPE    phContext;
+
+    HLINEAPP                hLineApp;
+
+    HPHONEAPP               hPhoneApp;
+
+    BOOL                    bDisconnected;
+
+    struct _DRVSERVER      *pNext;
+
+} DRVSERVER, *PDRVSERVER;
+
+
+typedef struct _DRVLINE
+{
+    DWORD                   dwKey;
+
+    PDRVSERVER              pServer;
+
+    DWORD                   dwDeviceIDLocal;
+
+    DWORD                   dwDeviceIDServer;
+
+    DWORD                   dwXPIVersion;
+
+    LINEEXTENSIONID         ExtensionID;
+
+    HLINE                   hLine;
+
+    HTAPILINE               htLine;
+
+    LPVOID                  pCalls;
+
+} DRVLINE, *PDRVLINE;
+
+
+typedef struct _DRVCALL
+{
+    DWORD                   dwKey;
+
+    PDRVSERVER              pServer;
+
+    PDRVLINE                pLine;
+
+    DWORD                   dwAddressID;
+
+    HCALL                   hCall;
+
+    HTAPICALL               htCall;
+
+    struct _DRVCALL        *pPrev;
+
+    struct _DRVCALL        *pNext;
+
+} DRVCALL, *PDRVCALL;
+
+
+typedef struct _DRVPHONE
+{
+    DWORD                   dwKey;
+
+    PDRVSERVER              pServer;
+
+    DWORD                   dwDeviceIDLocal;
+
+    DWORD                   dwDeviceIDServer;
+
+    DWORD                   dwXPIVersion;
+
+    PHONEEXTENSIONID        ExtensionID;
+
+    HPHONE                  hPhone;
+
+    HTAPIPHONE              htPhone;
+
+} DRVPHONE, *PDRVPHONE;
+
+
+typedef struct _DRVLINELOOKUP
+{
+    DWORD                   dwTotalEntries;
+
+    DWORD                   dwUsedEntries;
+
+    struct _DRVLINELOOKUP  *pNext;
+
+    DRVLINE                 aEntries[1];
+
+} DRVLINELOOKUP, *PDRVLINELOOKUP;
+
+
+typedef struct _DRVPHONELOOKUP
+{
+    DWORD                   dwTotalEntries;
+
+    DWORD                   dwUsedEntries;
+
+    struct _DRVPHONELOOKUP *pNext;
+
+    DRVPHONE                aEntries[1];
+
+} DRVPHONELOOKUP, *PDRVPHONELOOKUP;
+
+
+typedef enum
+{
+    Dword,
+    LineID,
+    PhoneID,
+    Hdcall,
+    Hdline,
+    Hdphone,
+    lpDword,
+    lpsz,
+    lpGet_SizeToFollow,
+    lpSet_SizeToFollow,
+    lpSet_Struct,
+    lpGet_Struct,
+    Size
+
+} REMOTE_ARG_TYPES, *PREMOTE_ARG_TYPES;
+
+
+typedef struct _REMOTE_FUNC_ARGS
+{
+    DWORD                   Flags;
+
+    LPDWORD                 Args;
+
+    PREMOTE_ARG_TYPES       ArgTypes;
+
+} REMOTE_FUNC_ARGS, *PREMOTE_FUNC_ARGS;
+
+
+HANDLE              ghInst;
+
+char                gszServer[] = "Server",
+                    gszProvider[] = "Provider",
+                    gszNumServers[] = "NumServers",
+                    gszTelephonIni[] = "Telephon.ini";
+
+WCHAR               gszMachineName[MAX_COMPUTERNAME_LENGTH + 1];
+char                gszDomainUser[64];
+
+DWORD               gdwLineDeviceIDBase,
+                    gdwPhoneDeviceIDBase,
+                    gdwInitialNumLineDevices,
+                    gdwInitialNumPhoneDevices,
+                    gdwTlsIndex,
+                    gdwPermanentProviderID,
+                    gdwRetryCount,
+                    gdwRetryTimeout;
+
+HICON               ghLineIcon,
+                    ghPhoneIcon;
+
+HANDLE              hToken,
+                    ghRpcServerThread;
+
+LINEEVENT           gpfnLineEventProc;
+PHONEEVENT          gpfnPhoneEventProc;
+PDRVSERVER          gpServer,
+                    gpServers;
+PDRVLINELOOKUP      gpLineLookup;
+PDRVPHONELOOKUP     gpPhoneLookup;
+
+ASYNC_COMPLETION    gpfnCompletionProc;
+
+CRITICAL_SECTION    gEventBufferCriticalSection,
+                    gCallListCriticalSection;
+
+LONG gaNoMemErrors[3] =
+{
+    0,
+    LINEERR_NOMEM,
+    PHONEERR_NOMEM
+};
+
+LONG gaOpFailedErrors[3] =
+{
+    0,
+    LINEERR_OPERATIONFAILED,
+    PHONEERR_OPERATIONFAILED
+};
+
+
+LONG gaServerDisconnectedErrors[3] =
+{
+    0,
+    LINEERR_NODRIVER,
+    PHONEERR_NODRIVER
+};
+
+struct
+{
+    HANDLE          hThread;
+
+    DWORD           dwEventBufferTotalSize;
+
+    DWORD           dwEventBufferUsedSize;
+
+    LPBYTE          pEventBuffer;
+
+    LPBYTE          pDataIn;
+
+    LPBYTE          pDataOut;
+
+    PASYNCEVENTMSG  pMsg;
+
+    DWORD           dwMsgSize;
+
+    HANDLE          hEvent;
+
+    BOOL            bExit;
+
+} gEventHandlerThreadParams;
+
+
+
+
+
+#if DBG
+
+LONG
+WINAPI
+RemoteDoFunc(
+    PREMOTE_FUNC_ARGS   pFuncArgs,
+    char               *pszFuncName
+    );
+
+#define REMOTEDOFUNC(arg1,arg2) RemoteDoFunc(arg1,arg2)
+
+DWORD gdwDebugLevel = 0;
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+LONG
+WINAPI
+RemoteDoFunc(
+    PREMOTE_FUNC_ARGS   pFuncArgs
+    );
+
+#define REMOTEDOFUNC(arg1,arg2) RemoteDoFunc(arg1)
+
+#define DBGOUT(arg)
+
+#endif
+
+
+BOOL
+WINAPI
+_CRT_INIT(
+    HINSTANCE   hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    );
+
+void
+PASCAL
+TSPI_lineMakeCall_PostProcess(
+    PASYNCEVENTMSG  pMsg
+    );
+
+LONG
+AddLine(
+    PDRVSERVER  pServer,
+    DWORD       dwDeviceIDLocal,
+    DWORD       dwDeviceIDServer,
+    BOOL        bInit
+    );
+
+LONG
+AddPhone(
+    PDRVSERVER  pServer,
+    DWORD       dwDeviceIDLocal,
+    DWORD       dwDeviceIDServer,
+    BOOL        bInit
+    );
+
+LPVOID
+DrvAlloc(
+    DWORD   dwSize
+    );
+
+void
+DrvFree(
+    LPVOID  p
+    );
+
+LONG
+AddCallToList(
+    PDRVLINE    pLine,
+    PDRVCALL    pCall
+    );
+
+LONG
+RemoveCallFromList(
+    PDRVCALL    pCall
+    );
+
+void
+Shutdown(
+    PDRVSERVER  pServer
+    );
+
+
+BOOL
+CALLBACK
+ConfigDlgProc(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wParam,
+    LPARAM lParam
+    );
+
+LONG
+PASCAL
+ProviderInstall(
+    char   *pszProviderName,
+    BOOL    bNoMultipleInstance
+    );
diff --git a/private/tapi/dev/sp/remotesp/remotesp.ico b/private/tapi/dev/sp/remotesp/remotesp.ico
new file mode 100644
index 000000000..516eb3f84
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/remotesp.ico
diff --git a/private/tapi/dev/sp/remotesp/remotesp.rc b/private/tapi/dev/sp/remotesp/remotesp.rc
new file mode 100644
index 000000000..d6728ec08
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/remotesp.rc
@@ -0,0 +1,23 @@
+#include "windows.h"
+#include "resource.h"
+#include "dialogs.dlg"
+
+IDI_ICON1               ICON    DISCARDABLE     "REMOTESP.ICO"
+IDI_ICON2               ICON    DISCARDABLE     "PHONE.ICO"
+IDI_ICON3               ICON    DISCARDABLE     "LINE.ICO"
+
+#if TAPI_NT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Remote Service Provider"
+#define VER_INTERNALNAME_STR        "remotesp"
+#define VER_ORIGINALFILENAME_STR    "REMOTESP.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/remotesp/resource.h b/private/tapi/dev/sp/remotesp/resource.h
new file mode 100644
index 000000000..176b4c1e0
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/resource.h
@@ -0,0 +1,7 @@
+#define IDI_ICON1                       101
+#define IDI_ICON2                       102
+#define IDI_ICON3                       103
+#define IDC_EDIT1                       201
+#define IDC_ADD                         202
+#define IDC_REMOVE                      203
+#define IDC_LIST1                       204
diff --git a/private/tapi/dev/sp/remotesp/sources b/private/tapi/dev/sp/remotesp/sources
new file mode 100644
index 000000000..1b0200380
--- /dev/null
+++ b/private/tapi/dev/sp/remotesp/sources
@@ -0,0 +1,58 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=remotesp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=tsp
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib   \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib   \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=.;..\..\client;..\..\server;$(BASEDIR)\public\sdk\inc
+
+SOURCES=remotesp.c  \
+        tapsrv_c.c  \
+        rmotsp_s.c  \
+        remotesp.rc
+
+C_DEFINES=-DTAPI_NT=1
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/repeater/app/makefile b/private/tapi/dev/sp/repeater/app/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/app/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/repeater/app/repapp.c b/private/tapi/dev/sp/repeater/app/repapp.c
new file mode 100644
index 000000000..0c8f7a862
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/app/repapp.c
@@ -0,0 +1,1093 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+#include <stdio.h>
+#include <commdlg.h>
+#include "resource.h"
+#include "..\new\logger.h"
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+static LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                                     UINT   uMsg,
+                                     WPARAM wParam,
+                                     LPARAM lParam);
+BOOL LogFileNameProc();
+BOOL DoStructKey();
+BOOL DoPostKey();
+BOOL DoPreKey();
+void WriteToListBox(LPSTR lpszText, ...);
+BOOL ReadInLogFile();
+BOOL OpenLogFile();
+BOOL ReadKey(LPDWORD lpdwKey);
+
+//////////////////////////////////////////////////////////////////////////////
+//  GLOBALS
+//////////////////////////////////////////////////////////////////////////////
+HINSTANCE       ghInstance;
+HWND            ghMainWnd;
+HWND            ghListWnd;
+char            gszLogFileName[MAX_PATH];
+HANDLE          ghLogFile;
+
+LPSTR glpszFunctions[] =
+{
+    "TSPI_lineAccept",
+    "TSPI_lineAddToConference",
+    "TSPI_lineAgentSpecific",
+    "TSPI_lineAnswer",
+    "TSPI_lineBlindTransfer",
+    "TSPI_lineClose",
+    "TSPI_lineCloseCall",
+    "TSPI_lineCompleteCall",
+    "TSPI_lineCompleteTransfer",
+    "TSPI_lineConditionalMediaDetection",
+    "TSPI_lineDevSpecific",
+    "TSPI_lineDevSpecificFeature",
+    "TSPI_lineDial",
+    "TSPI_lineDrop",
+    "TSPI_lineForward",
+    "TSPI_lineGatherDigits",
+    "TSPI_lineGenerateDigits",
+    "TSPI_lineGenerateTone",
+    "TSPI_lineGetAddressCaps",
+    "TSPI_lineGetAddressID",
+    "TSPI_lineGetAddressStatus",
+    "TSPI_lineGetAgentActivityList",
+    "TSPI_lineGetAgentCaps",
+    "TSPI_lineGetAgentGroupList",
+    "TSPI_lineGetAgentStatus",
+    "TSPI_lineGetCallAddressID",
+    "TSPI_lineGetCallInfo",
+    "TSPI_lineGetCallStatus",
+    "TSPI_lineGetDevCaps",
+    "TSPI_lineGetDevConfig",
+    "TSPI_lineGetExtensionID",
+    "TSPI_lineGetIcon",
+    "TSPI_lineGetID",
+    "TSPI_lineGetLineDevStatus",
+    "TSPI_lineGetNumAddressIDs",
+    "TSPI_lineHold",
+    "TSPI_lineMakeCall",
+    "TSPI_lineMonitorDigits",
+    "TSPI_lineMonitorMedia",
+    "TSPI_lineMonitorTones",
+    "TSPI_lineNegotiateExtVersion",
+    "TSPI_lineNegotiateTSPIVersion",
+    "TSPI_lineOpen",
+    "TSPI_linePark",
+    "TSPI_linePickup",
+    "TSPI_linePrepareAddToConference",
+    "TSPI_lineRedirect",
+    "TSPI_lineReleaseUserUserInfo",
+    "TSPI_lineRemoveFromConference",
+    "TSPI_lineSecureCall",
+    "TSPI_lineSelectExtVersion",
+    "TSPI_lineSendUserUserInfo",
+    "TSPI_lineSetAgentActivity",
+    "TSPI_lineSetAgentGroup",
+    "TSPI_lineSetAgentState",
+    "TSPI_lineSetAppSpecific",
+    "TSPI_lineSetCallData",
+    "TSPI_lineSetCallParams",
+    "TSPI_lineSetCallQualityOfService",
+    "TSPI_lineSetCallTreatment",
+    "TSPI_lineSetCurrentLocation",
+    "TSPI_lineSetDefaultMediaDetection",
+    "TSPI_lineSetDevConfig",
+    "TSPI_lineSetLineDevStatus",
+    "TSPI_lineSetMediaControl",
+    "TSPI_lineSetMediaMode",
+    "TSPI_lineSetStatusMessages",
+    "TSPI_lineSetTerminal",
+    "TSPI_lineSetupConference",
+    "TSPI_lineSetupTransfer",
+    "TSPI_lineSwapHold",
+    "TSPI_lineUncompleteCall",
+    "TSPI_lineUnhold",
+    "TSPI_lineUnpark",
+    "TSPI_phoneClose",
+    "TSPI_phoneDevSpecific",
+    "TSPI_phoneGetButtonInfo",
+    "TSPI_phoneGetData",
+    "TSPI_phoneGetDevCaps",
+    "TSPI_phoneGetDisplay",
+    "TSPI_phoneGetExtensionID",
+    "TSPI_phoneGetGain",
+    "TSPI_phoneGetHookSwitch",
+    "TSPI_phoneGetIcon",
+    "TSPI_phoneGetID",
+    "TSPI_phoneGetLamp",
+    "TSPI_phoneGetRing",
+    "TSPI_phoneGetStatus",
+    "TSPI_phoneGetVolume",
+    "TSPI_phoneNegotiateExtVersion",
+    "TSPI_phoneNegotiateTSPIVersion",
+    "TSPI_phoneOpen",
+    "TSPI_phoneSelectExtVersion",
+    "TSPI_phoneSetButtonInfo",
+    "TSPI_phoneSetData",
+    "TSPI_phoneSetDisplay",
+    "TSPI_phoneSetGain",
+    "TSPI_phoneSetHookSwitch",
+    "TSPI_phoneSetLamp",
+    "TSPI_phoneSetRing",
+    "TSPI_phoneSetStatusMessages",
+    "TSPI_phoneSetVolume",
+    "TSPI_providerCreateLineDevice",
+    "TSPI_providerCreatePhoneDevice",
+    "TSPI_providerEnumDevices",
+    "TSPI_providerFreeDialogInstance",
+    "TSPI_providerGenericDialogData",
+    "TSPI_providerInit",
+    "TSPI_providerShutdown",
+    "TSPI_providerUIIdentify",
+    NULL
+};
+
+LPSTR glpszMessages[] = 
+{
+        "LINE_ADDRESSSTATE",
+        "LINE_CALLINFO",
+        "LINE_CALLSTATE",
+        "LINE_CLOSE",
+        "LINE_DEVSPECIFIC",
+        "LINE_DEVSPECIFICFEATURE",
+        "LINE_GATHERDIGITS",
+        "LINE_GENERATE",
+        "LINE_LINEDEVSTATE",
+        "LINE_MONITORDIGITS",
+        "LINE_MONITORMEDIA",
+        "LINE_MONITORTONE",
+        "LINE_REPLY",
+        "LINE_REQUEST",
+        "PHONE_BUTTON",
+        "PHONE_CLOSE",
+        "PHONE_DEVSPECIFIC",
+        "PHONE_REPLY",
+        "PHONE_STATE",
+        "LINE_CREATE",
+        "PHONE_CREATE",
+        "LINE_AGENTSPECIFIC",
+        "LINE_AGENTSTATUS",
+        "LINE_APPNEWCALL",
+        "LINE_PROXYREQUEST",
+        "LINE_REMOVE",
+        "PHONE_REMOVE"
+};
+
+LPSTR glpszMessages500[] =
+{
+        "LINE_NEWCALL",
+        "LINE_CALLDEVSPECIFIC",
+        "LINE_CALLDEVSPECIFICFEATURE",
+        "LINE_CREATEDIALOGINSTANCE",
+        "LINE_SENDDIALOGINSTANCEDATA"
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+
+int WINAPI WinMain (HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow)
+{
+    MSG msg;
+
+    ghInstance = hInstance;
+
+    if (!CreateMainWindow(nCmdShow))
+    {
+        return 0;
+    }
+
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    return 1;
+}
+
+
+//*****************************************************************************
+// CreateMainWindow()
+//*****************************************************************************
+
+BOOL CreateMainWindow (int nCmdShow)
+{
+    WNDCLASS wc;
+    static char szClassName[] = "TapiClientWndClass";
+
+    wc.style         = 0;
+    wc.lpfnWndProc   = MainWndProc;
+    wc.cbClsExtra    = 0;
+    wc.cbWndExtra    = 0;
+    wc.hInstance     = ghInstance;
+    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wc.lpszMenuName  = MAKEINTRESOURCE(IDR_REPAPPMENU);
+    wc.lpszClassName = szClassName;
+
+
+    if (!RegisterClass(&wc))
+    {
+        return FALSE;
+    }
+
+    ghMainWnd = CreateWindow(szClassName, 
+                             "Repeater Log App",
+                             WS_OVERLAPPEDWINDOW,
+                             0,
+                             0,
+                             GetSystemMetrics(SM_CXSCREEN)/2,
+                             GetSystemMetrics(SM_CYSCREEN)/2,
+                             NULL, 
+                             NULL, 
+                             ghInstance, 
+                             NULL);
+
+    ghListWnd = CreateWindow("LISTBOX",
+                             NULL,
+                             WS_CHILD | WS_VISIBLE | WS_VSCROLL | LBS_USETABSTOPS,
+                             0,
+                             0,
+                             0,
+                             0,
+                             ghMainWnd,
+                             NULL,
+                             ghInstance,
+                             NULL);
+
+    if (ghListWnd == NULL)
+    {
+        return FALSE;
+    }
+
+
+    if (ghMainWnd == NULL)
+    {
+        return FALSE;
+    }
+
+    ShowWindow(ghMainWnd, nCmdShow);
+    UpdateWindow(ghMainWnd);
+    return TRUE;
+}
+
+
+//*****************************************************************************
+// MainWndProc()
+//*****************************************************************************
+
+LRESULT CALLBACK MainWndProc (HWND   hwnd,
+                              UINT   uMsg,
+                              WPARAM wParam,
+                              LPARAM lParam)
+{
+    switch (uMsg)
+    {
+
+        case WM_SIZE:
+        {
+            RECT    rc;
+
+            GetClientRect(hwnd,
+                          &rc);
+
+            MoveWindow(ghListWnd,
+                       0, 0,
+                       rc.right,
+                       rc.bottom,
+                       TRUE);
+
+            break;
+        }
+    case WM_COMMAND:
+    {
+        if (LOWORD(wParam) == ID_FILE_EXIT)
+        {
+            DestroyWindow(hwnd);
+            break;
+        }
+
+        if (LOWORD(wParam) == ID_FILE_LOGFILENAME)
+        {
+            if (LogFileNameProc())
+            {
+                SendMessage(ghListWnd,
+                            LB_RESETCONTENT,
+                            0,
+                            0);
+                
+                ReadInLogFile();
+            }
+
+            break;
+        }
+
+        return DefWindowProc(hwnd, uMsg, wParam, lParam);
+    }
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            break;
+
+        default:
+            return DefWindowProc(hwnd, uMsg, wParam, lParam);
+    }
+    return 0;
+}
+
+BOOL LogFileNameProc()
+{
+    OPENFILENAME            ofn;
+    BOOL                    bReturn;
+
+    gszLogFileName[0] = '\0';
+
+    ofn.lStructSize = sizeof(ofn);
+    ofn.hwndOwner = ghMainWnd;
+    ofn.hInstance = ghInstance;
+    ofn.lpstrFilter = "Log Files\0*.log\0\0";
+    ofn.lpstrCustomFilter = NULL;
+    ofn.nMaxCustFilter = 0;
+    ofn.nFilterIndex = 0;
+    ofn.lpstrFile = gszLogFileName;
+    ofn.nMaxFile = MAX_PATH;
+    ofn.lpstrFileTitle = NULL;
+    ofn.nMaxFileTitle = 0;
+    ofn.lpstrInitialDir = NULL;
+    ofn.lpstrTitle =NULL;
+    ofn.Flags = OFN_FILEMUSTEXIST;
+    ofn.nFileOffset = 0;
+    ofn.nFileExtension = 0;
+    ofn.lpstrDefExt = "LOG";
+    ofn.lCustData = 0;
+    ofn.lpfnHook = NULL;
+    ofn.lpTemplateName = NULL;
+
+    bReturn = GetOpenFileName(&ofn);
+
+    return bReturn;
+}
+
+BOOL ReadInLogFile()
+{
+    DWORD       dwKey;
+    
+    if (!OpenLogFile())
+    {
+        MessageBox(NULL,
+                   "Couldn't open file",
+                   NULL,
+                   MB_OK);
+
+        return FALSE;
+    }
+
+    while (TRUE)
+    {
+        if (!ReadKey(&dwKey))
+        {
+//            MessageBox(NULL,
+//                       "Couldn't readkey",
+//                       NULL,
+//                       MB_OK);
+            break;
+        }
+
+        else if (dwKey == DWPREKEY)
+        {
+            if (!DoPreKey())
+            {
+//                MessageBox(NULL,
+//                           "Couldn't do pre key",
+//                           NULL,
+//                           MB_OK);
+
+                break;
+            }
+        }
+
+        else if (dwKey == DWPOSTKEY)
+        {
+            if (!DoPostKey())
+            {
+//                MessageBox(NULL,
+//                           "Couldn't do post key",
+//                           NULL,
+//                           MB_OK);
+
+                break;
+            }
+        }
+
+        else if (dwKey == DWSTRCKEY)
+        {
+            if (!DoStructKey())
+            {
+//                MessageBox(NULL,
+//                           "Couldn't do struct key",
+//                           NULL,
+//                           MB_OK);
+
+                break;
+            }
+        }
+
+        else
+        {
+            MessageBox(NULL,
+                       "Error reading in log file",
+                       NULL,
+                       MB_OK);
+            break;
+        }
+    } // while
+
+    return TRUE;
+}
+
+BOOL OpenLogFile()
+{
+    ghLogFile = CreateFile(gszLogFileName,
+                           GENERIC_READ,
+                           FILE_SHARE_READ, //0,
+                           NULL,
+                           OPEN_EXISTING,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL);
+
+    if (ghLogFile == INVALID_HANDLE_VALUE)
+    {
+        return FALSE;
+    }
+
+    SetFilePointer(ghLogFile,
+                   0,
+                   NULL,
+                   FILE_BEGIN);
+
+    return TRUE;
+}
+
+BOOL ReadKey(LPDWORD lpdwKey)
+{
+    DWORD       dwSize;
+
+    if (!ReadFile(ghLogFile,
+                  lpdwKey,
+                  sizeof(DWORD),
+                  &dwSize,
+                  NULL))
+    {
+        return FALSE;
+    }
+
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+    SetFilePointer(ghLogFile,
+                   0-dwSize,
+                   NULL,
+                   FILE_CURRENT);
+
+    return TRUE;
+}
+
+BOOL DoPreKey()
+{
+    PREHEADER       PreHeader;
+    DWORD           dwSize;
+
+    if (!ReadFile(ghLogFile,
+                  &PreHeader,
+                  sizeof(PreHeader),
+                  &dwSize,
+                  NULL))
+    {
+        return FALSE;
+    }
+
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+    
+
+    if (dwSize != sizeof(PreHeader))
+    {
+        return FALSE;
+    }
+
+    WriteToListBox("PreHeader - Time: %lu Type: %lu",
+                   PreHeader.dwTime,
+                   PreHeader.dwType);
+
+    switch(PreHeader.dwType)
+    {
+        case LINEMSG:
+        {
+            LINEMSGSTRUCT   LineMsg;
+            LPSTR           lpszMsg;
+
+            if (!ReadFile(ghLogFile,
+                          &LineMsg,
+                          sizeof(LineMsg),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+            
+            if (LineMsg.dwMsg < 500)
+            {
+                lpszMsg = glpszMessages[LineMsg.dwMsg];
+            }
+            else
+            {
+                lpszMsg = glpszMessages500[LineMsg.dwMsg-500];
+            }
+
+            WriteToListBox("\tLine Message: %s", 
+                           lpszMsg);
+            WriteToListBox("\t\thtLine: %lx, htCall: %lx", 
+                           LineMsg.htLine, 
+                           LineMsg.htCall);
+            WriteToListBox("\t\tdwParam1: %lx, dwParam2: %lx, dwParam3: %lx",
+                           LineMsg.dw1,
+                           LineMsg.dw2,
+                           LineMsg.dw3);
+
+            break;
+        }
+
+        case PHONEMSG:
+        {
+            PHONEMSGSTRUCT  PhoneMsg;
+            LPSTR           lpszMsg;
+
+            if (!ReadFile(ghLogFile,
+                          &PhoneMsg,
+                          sizeof(PhoneMsg),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+            
+
+            if (PhoneMsg.dwMsg < 500)
+            {
+                lpszMsg = glpszMessages[PhoneMsg.dwMsg];
+            }
+            else
+            {
+                lpszMsg = glpszMessages500[PhoneMsg.dwMsg-500];
+            }
+
+
+            WriteToListBox("\tPhone Message: %s", 
+                           lpszMsg);
+            WriteToListBox("\t\thtPhone: %lx", 
+                           PhoneMsg.htPhone);
+            WriteToListBox("\t\tdwParam1: %lx, dwParam2: %lx, dwParam3: %lx",
+                           PhoneMsg.dw1,
+                           PhoneMsg.dw2,
+                           PhoneMsg.dw3);
+
+            break;
+        }
+
+        case ASYNCMSG:
+        {
+            ASYNCSTRUCT  AsyncMsg;
+
+            if (!ReadFile(ghLogFile,
+                          &AsyncMsg,
+                          sizeof(AsyncMsg),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+            
+
+            WriteToListBox("\tAsync Message - dwRequestID: %lx, lResult: %lx",
+                           AsyncMsg.dwRequestID,
+                           AsyncMsg.lResult);
+
+            break;
+        }
+
+        case SPFUNC1:
+        {
+            LOGSPFUNC1      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            break;
+        }
+
+        case SPFUNC2:
+        {
+            LOGSPFUNC2      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+            
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+
+            break;
+        }
+        case SPFUNC3:
+        {
+            LOGSPFUNC3      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+
+            break;
+        }
+
+        case SPFUNC4:
+        {
+            LOGSPFUNC4      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+
+            break;
+        }
+
+        case SPFUNC5:
+        {
+            LOGSPFUNC5      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+            WriteToListBox("\tParam5: %lx",
+                           LogStruct.dwParam5);
+
+            break;
+        }
+
+        case SPFUNC6:
+        {
+            LOGSPFUNC6      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+            WriteToListBox("\tParam5: %lx",
+                           LogStruct.dwParam5);
+            WriteToListBox("\tParam6: %lx",
+                           LogStruct.dwParam6);
+
+            break;
+        }
+
+        case SPFUNC7:
+        {
+            LOGSPFUNC7      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+            WriteToListBox("\tParam5: %lx",
+                           LogStruct.dwParam5);
+            WriteToListBox("\tParam6: %lx",
+                           LogStruct.dwParam6);
+            WriteToListBox("\tParam7: %lx",
+                           LogStruct.dwParam7);
+
+            break;
+        }
+
+        case SPFUNC8:
+        {
+            LOGSPFUNC8      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+            WriteToListBox("\tParam5: %lx",
+                           LogStruct.dwParam5);
+            WriteToListBox("\tParam6: %lx",
+                           LogStruct.dwParam6);
+            WriteToListBox("\tParam7: %lx",
+                           LogStruct.dwParam7);
+            WriteToListBox("\tParam8: %lx",
+                           LogStruct.dwParam8);
+
+            break;
+        }
+
+        case SPFUNC9:
+        {
+            LOGSPFUNC9      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+            
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+            WriteToListBox("\tParam5: %lx",
+                           LogStruct.dwParam5);
+            WriteToListBox("\tParam6: %lx",
+                           LogStruct.dwParam6);
+            WriteToListBox("\tParam7: %lx",
+                           LogStruct.dwParam7);
+            WriteToListBox("\tParam8: %lx",
+                           LogStruct.dwParam8);
+            WriteToListBox("\tParam9: %lx",
+                           LogStruct.dwParam9);
+
+            break;
+        }
+
+        case SPFUNC12:
+        {
+            LOGSPFUNC12      LogStruct;
+
+            if (!ReadFile(ghLogFile,
+                          &LogStruct,
+                          sizeof(LogStruct),
+                          &dwSize,
+                          NULL))
+            {
+                return FALSE;
+            }
+            
+            if (dwSize == 0)
+            {
+                return FALSE;
+            }
+            
+
+            WriteToListBox("\tFunction: %s",
+                           glpszFunctions[LogStruct.dwSPFUNC]);
+            WriteToListBox("\tParam1: %lx",
+                           LogStruct.dwParam1);
+            WriteToListBox("\tParam2: %lx",
+                           LogStruct.dwParam2);
+            WriteToListBox("\tParam3: %lx",
+                           LogStruct.dwParam3);
+            WriteToListBox("\tParam4: %lx",
+                           LogStruct.dwParam4);
+            WriteToListBox("\tParam5: %lx",
+                           LogStruct.dwParam5);
+            WriteToListBox("\tParam6: %lx",
+                           LogStruct.dwParam6);
+            WriteToListBox("\tParam7: %lx",
+                           LogStruct.dwParam7);
+            WriteToListBox("\tParam8: %lx",
+                           LogStruct.dwParam8);
+            WriteToListBox("\tParam9: %lx",
+                           LogStruct.dwParam9);
+            WriteToListBox("\tParam11: %lx",
+                           LogStruct.dwParam10);
+            WriteToListBox("\tParam11: %lx",
+                           LogStruct.dwParam11);
+            WriteToListBox("\tParam12: %lx",
+                           LogStruct.dwParam12);
+
+            break;
+        }
+        
+    } // switch
+
+    return TRUE;
+
+}
+
+BOOL DoPostKey()
+{
+    POSTSTRUCT      PostStruct;
+    DWORD           dwSize;
+
+    if (!ReadFile(ghLogFile,
+                  &PostStruct,
+                  sizeof(PostStruct),
+                  &dwSize,
+                  NULL))
+    {
+        return FALSE;
+    }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+    WriteToListBox("Post Struct - dwTime: %lu, lReturn: %lx",
+                   PostStruct.dwTime,
+                   PostStruct.lReturn);
+
+    return TRUE;
+}
+
+BOOL DoStructKey()
+{
+    STRUCTHEADER        StructHeader;
+    DWORD               dwSize;
+    LPVOID              pBuffer;
+
+    if (!ReadFile(ghLogFile,
+                  &StructHeader,
+                  sizeof(StructHeader),
+                  &dwSize,
+                  NULL))
+    {
+        return FALSE;
+    }
+
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+
+    WriteToListBox("Struct Header - dwSize: %lu, dwID: %lx",
+                    StructHeader.dwSize,
+                    StructHeader.dwID);
+
+    if (StructHeader.dwSize == 0)
+    {
+        return TRUE;
+    }
+    
+    pBuffer = GlobalAlloc(GPTR, StructHeader.dwSize);
+
+    // read in structure, but don't do anything with it for now
+    if (!ReadFile(ghLogFile,
+                  pBuffer,
+                  StructHeader.dwSize,
+                  &dwSize,
+                  NULL))
+    {
+        GlobalFree(pBuffer);
+        return FALSE;
+    }
+    if (dwSize == 0)
+    {
+        return FALSE;
+    }
+
+    GlobalFree(pBuffer);
+                  
+    return TRUE;
+}
+
+void WriteToListBox(LPSTR lpszText, ...)
+{
+    char        szBuffer[1024];
+    va_list     list;
+
+    va_start(list,lpszText);
+
+    vsprintf(szBuffer,lpszText,list);
+
+    SendMessage(ghListWnd,
+                LB_ADDSTRING,
+                0,
+                (LPARAM)szBuffer);
+}
+
diff --git a/private/tapi/dev/sp/repeater/app/repapp.rc b/private/tapi/dev/sp/repeater/app/repapp.rc
new file mode 100644
index 000000000..25619c74a
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/app/repapp.rc
@@ -0,0 +1,37 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_REPAPPMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Log File Name",              ID_FILE_LOGFILENAME
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       ID_FILE_EXIT
+    END
+END
+
+
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony API Repeater Log File Reader"
+#define VER_INTERNALNAME_STR        "REPAPP"
+#define VER_ORIGINALFILENAME_STR    "REPAPP.EXE"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1996.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/repeater/app/resource.h b/private/tapi/dev/sp/repeater/app/resource.h
new file mode 100644
index 000000000..7bd879f3b
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/app/resource.h
@@ -0,0 +1,22 @@
+#include <windows.h>
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by repapp.rc
+//
+#define IDD_LOGFILENAME                 101
+#define IDR_REPAPPMENU                  102
+#define IDC_LOGFILENAME                 1000
+#define ID_FILE_LOGFILENAME             40001
+#define ID_FILE_EXIT                    40002
+#define IDC_STATIC                      -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        103
+#define _APS_NEXT_COMMAND_VALUE         40003
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/sp/repeater/app/sources b/private/tapi/dev/sp/repeater/app/sources
new file mode 100644
index 000000000..24be8c8f2
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/app/sources
@@ -0,0 +1,56 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=repapp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32l.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib 
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=repapp.rc \
+        repapp.c 
+
+C_DEFINES=-DWINVER=0x0400 
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/repeater/dirs b/private/tapi/dev/sp/repeater/dirs
new file mode 100644
index 000000000..57bb36ac0
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/dirs
@@ -0,0 +1,4 @@
+DIRS=\
+	 new   \
+     app  \
+     setup
diff --git a/private/tapi/dev/sp/repeater/new/debug.c b/private/tapi/dev/sp/repeater/new/debug.c
new file mode 100644
index 000000000..a5fc2c9b9
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/debug.c
@@ -0,0 +1,180 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include  <windowsx.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include  <tapi.h>                  
+#include "debug.h"
+
+
+
+extern const char far szINIfilename[];
+
+DWORD   gdwDebugLevel;
+
+
+static char szNewBuff[256];
+
+
+DWORD RepeaterDebugLevel = 0;
+static fRepeaterDebugLevelValid = FALSE;
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+
+{
+   static char    buf[128] = "Repeater: ";
+
+
+   if (!fRepeaterDebugLevelValid)
+   {
+RepeaterDebugLevel = 0;
+/*
+      RepeaterDebugLevel =   GetPrivateProfileInt( "Debug",
+                                                   "RepeaterDebugLevel",
+                                                   0,
+                                                   szINIfilename );
+*/
+      RepeaterDebugLevel = 99;
+
+      if ( RepeaterDebugLevel > 0 )
+      {
+         wsprintf(
+                   &buf[10],
+                   "RepeaterDebugLevel= %d\n\r",
+                   RepeaterDebugLevel);
+
+         OutputDebugString((LPSTR)buf);
+
+
+         fRepeaterDebugLevelValid = TRUE;
+      }
+
+   }
+
+
+   //
+   // Is the message otherwise "low" enough to display?
+   //
+    if (dwDbgLevel <= RepeaterDebugLevel)
+    {
+        char    buf[128] = "Repeater: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        wvsprintf (&buf[10],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugString(buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+
+
+
+
+
+
+//VOID
+//DbgPrt(
+//    IN DWORD  dwDbgLevel,
+//    IN PUCHAR lpszFormat,
+//    IN ...
+//    )
+///*++
+//
+//Routine Description:
+//
+//    Formats the incoming debug message & calls DbgPrint
+//
+//Arguments:
+//
+//    DbgLevel   - level of message verboseness
+//
+//    DbgMessage - printf-style format string, followed by appropriate
+//                 list of arguments
+//
+//Return Value:
+//
+//
+//--*/
+//{
+//    
+//    static BOOL fAlreadyGotIt = FALSE;
+//    static char    buf[128] = "TAPI CPL: ";
+//#define TEXT_START 10
+//
+//    if (!fAlreadyGotIt)
+//    {
+//
+//        gdwDebugLevel = (DWORD) GetPrivateProfileInt(
+//            "Debug",
+//            "Repeater32DebugLevel",
+//            0x0,
+//            "Telephon.ini"
+//            );
+//
+//        fAlreadyGotIt = TRUE;
+//
+//        wsprintf(&buf[TEXT_START], "Repeater32DebugLevel=%d \r\n", gdwDebugLevel);
+//        OutputDebugStringA(buf);
+//    }
+//
+//
+//    if (dwDbgLevel <= gdwDebugLevel)
+//    {
+//        va_list ap;
+//
+//
+//        va_start(ap, lpszFormat);
+//
+//        vsprintf (&buf[TEXT_START],
+//                  lpszFormat,
+//                  ap
+//                  );
+//
+//        lstrcat (buf, "\n");
+//
+//        OutputDebugStringA (buf);
+//
+//        va_end(ap);
+//    }
+//}
+//
+
+#endif
diff --git a/private/tapi/dev/sp/repeater/new/debug.h b/private/tapi/dev/sp/repeater/new/debug.h
new file mode 100644
index 000000000..11abf22ec
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/debug.h
@@ -0,0 +1,25 @@
+#if DBG
+
+
+#if !WIN32
+#define IN
+#define PUCHAR char *
+#endif
+
+
+
+#define DBGOUT(arg) DbgPrt arg
+
+extern VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/sp/repeater/new/depend.mk b/private/tapi/dev/sp/repeater/new/depend.mk
new file mode 100644
index 000000000..7f4b4291c
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/depend.mk
@@ -0,0 +1,7 @@
+.\logger.obj: ..\logger.c ..\logger.h ..\debug.h
+
+.\Repeater.obj: ..\Repeater.c ..\Repeater.h ..\debug.h
+
+.\debug.obj: ..\debug.c ..\debug.h
+
+.\Repeater.res: ..\Repeater.rc
diff --git a/private/tapi/dev/sp/repeater/new/logger.c b/private/tapi/dev/sp/repeater/new/logger.c
new file mode 100644
index 000000000..1f145c143
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/logger.c
@@ -0,0 +1,945 @@
+#define STRICT
+
+#include <windows.h>
+#include <windowsx.h>
+#include <tspi.h>
+#ifndef WIN32
+#include <memory.h>
+#endif
+#include "logger.h"
+#include "debug.h"
+
+#ifndef TCHAR
+#define TCHAR   char
+#endif
+
+#if ! defined(TEXT)
+#define TEXT(string) string
+#endif
+
+#ifndef LPCWSTR
+#define LPCWSTR LPCSTR
+#endif
+
+extern BOOL      gfTerminateNow;
+DWORD            gdwTotalBlocks;
+DWORD            gdwID = 0;
+CHUNK            gChunks[MAXCHUNKS];
+
+typedef struct tagLOGSTRUCT
+{
+    int                     iSize;
+    struct tagLOGSTRUCT*    pNext;
+    
+} LOGSTRUCT, * PLOGSTRUCT;
+
+
+#ifdef WIN32
+PLOGSTRUCT              gpBegin = NULL, gpEnd = NULL;
+CRITICAL_SECTION        gcsLogging;
+CRITICAL_SECTION        gcsID;
+#endif
+
+#ifdef WIN32
+HANDLE                  ghLogFile = NULL;
+#else
+HFILE                   ghLogFile = NULL;
+#endif
+
+#ifndef MAX_PATH
+#define MAX_PATH    260
+#endif
+
+#ifndef WIN32
+char                    gszFileName[MAX_PATH];
+#endif
+
+BOOL InitLogging();
+void WriteData();
+BOOL CopyIDToList(int iCount, LPVOID pBuffer);
+
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+#ifdef WIN32
+
+DWORD WINAPI LoggingThread( LPVOID pThreadParm )
+{
+
+    DBGOUT((3, "Entering LoggingThread"));
+
+    while ( !gfTerminateNow )
+    {
+
+        if (NULL != gpBegin)
+        {
+            WriteData();
+        }
+
+        Sleep(0);
+
+    }
+
+    DBGOUT((3, "Closing File Handle"));
+
+    CloseHandle(ghLogFile);
+
+    DBGOUT((3, "Exiting thread"));
+
+    ExitThread(0);
+    return 0;
+}
+#endif //WIN32
+
+#if 0
+#ifdef WIN32
+void CopyData(LPVOID pBuffer, int iCount)
+{
+    PLOGSTRUCT      pNew;
+
+    // if we have a lot of stuff to write, hold up here and
+    // wait until we've written a bunch
+    if (gdwTotalBlocks > MAXCHUNKS)
+    {
+        while (gdwTotalBlocks > MINCHUNKS)
+        {
+            Sleep(0);
+        }
+    }
+    
+    pNew = (PLOGSTRUCT)GlobalAlloc(GPTR, iCount+sizeof(LOGSTRUCT));
+
+    pNew->pNext = NULL;
+    pNew->iSize = iCount;
+
+    memcpy(pNew+1, pBuffer, iCount);
+    
+    EnterCriticalSection(&gcsLogging);
+    if (gpBegin == NULL)
+    {
+        gpBegin = pNew;
+    }
+    else
+    {
+        gpEnd->pNext = pNew;
+    }
+
+    gpEnd = pNew;
+    LeaveCriticalSection(&gcsLogging);
+
+    gdwTotalBlocks++;
+
+}
+
+#else
+void CopyData(LPVOID pBuffer, int iCount)
+{
+    OFSTRUCT ofstruct;
+
+    ofstruct.cBytes = sizeof(ofstruct);
+
+    ghLogFile = OpenFile(gszFileName,
+                         &ofstruct,
+                         OF_READWRITE);
+
+    if (ghLogFile == HFILE_ERROR)
+    {
+        DBGOUT((3,"OpenFile failed"));
+        return;
+    }
+
+    _llseek(ghLogFile,
+            0,
+            2);
+    
+    if (_lwrite(ghLogFile,
+            pBuffer,
+            iCount) == HFILE_ERROR)
+    {
+        char        szbuf[128];
+
+        wsprintf(szbuf, "icount %d", iCount);
+        MessageBox(NULL, szbuf, NULL, MB_OK);        
+        MessageBox(NULL, "writefile error", NULL, MB_OK);
+    }
+
+    _lclose(ghLogFile);
+}
+#endif
+
+#endif // 0
+
+#ifdef WIN32
+void WriteData()
+{
+    PLOGSTRUCT      pHold;
+    DWORD           dwNumBytes;
+    
+    while (gpBegin != NULL)
+    {
+        WriteFile(ghLogFile,
+                  (LPCVOID)(gpBegin+1),
+                  gpBegin->iSize,
+                  &dwNumBytes,
+                  NULL);
+
+        if (dwNumBytes != (DWORD)(gpBegin->iSize))
+        {
+            //bugbug do something
+        }
+
+        EnterCriticalSection(&gcsLogging);
+
+        pHold = gpBegin;
+
+        gpBegin = gpBegin->pNext;
+        
+        LeaveCriticalSection(&gcsLogging);
+        
+        GlobalFree(pHold);
+
+        gdwTotalBlocks--;
+    }
+            
+}
+#endif
+#define SZFILEBASE      "rep"
+#define SZFILEEXT       ".log"
+#define SZREPEATERKEY   "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Repeater"
+#define SZLOGFILE       "LogFileDirectory"
+#define SZREPEATER      "Repeater"
+#define SZTELEPHONINI   "telephon.ini"
+
+BOOL InitLogging()
+{
+    TCHAR           szFileName[MAX_PATH];
+    TCHAR           szFilePath[MAX_PATH];
+    int             i = 0;
+#ifdef WIN32
+    HKEY            hRepeaterKey;
+    DWORD           dwSize;
+#else
+    OFSTRUCT        ofstruct;
+#endif
+    
+    DBGOUT((3, "Entering InitLogging"));
+
+#ifdef WIN32
+    RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+                 SZREPEATERKEY,
+                 0,
+                 KEY_ALL_ACCESS,
+                 &hRepeaterKey);
+
+    dwSize = MAX_PATH;
+    RegQueryValueEx(hRepeaterKey,
+                    SZLOGFILE,
+                    NULL,
+                    NULL,
+                    szFilePath,
+                    &dwSize);
+    
+    RegCloseKey(hRepeaterKey);
+#else
+    GetPrivateProfileString(SZREPEATER,
+                            SZLOGFILE,
+                            "",
+                            szFilePath,
+                            MAX_PATH,
+                            SZTELEPHONINI);
+#endif
+                            
+    
+    gdwTotalBlocks = 0;
+
+    while (TRUE)
+    {
+#ifdef WIN32
+        HANDLE      hFile;
+        WIN32_FIND_DATA FindData;
+        
+        wsprintf(szFileName,
+                 "%s%s%d%s",
+                 szFilePath,
+                 SZFILEBASE,
+                 i,
+                 SZFILEEXT);
+
+        /*
+        ghLogFile = CreateFile(szFileName,
+                               GENERIC_WRITE,
+                               0,
+                               NULL,
+                               OPEN_EXISTING,
+                               FILE_ATTRIBUTE_NORMAL,
+                               NULL);
+
+        if (ghLogFile == INVALID_HANDLE_VALUE)
+        {
+            break;
+        }
+
+        CloseHandle(ghLogFile);*/
+
+        hFile = FindFirstFile(szFileName,
+                         &FindData);
+
+        if (hFile == INVALID_HANDLE_VALUE)
+        {
+            break;
+        }
+
+        FindClose(hFile);
+
+//        CloseHandle(hFile);
+
+#else
+        ofstruct.cBytes = sizeof(ofstruct);
+        
+        ghLogFile = OpenFile(szFileName,
+                             &ofstruct,
+                             OF_EXIST);
+
+        if (ghLogFile == HFILE_ERROR)
+        {
+            break;
+        }
+        
+        _lclose(ghLogFile);
+#endif
+
+        i++;
+    }
+                
+#ifdef WIN32
+
+    DBGOUT((3, "log file name is %s", szFileName));
+    ghLogFile = CreateFile(szFileName,
+                           GENERIC_WRITE,
+                           FILE_SHARE_READ, //0,
+                           NULL,
+                           CREATE_ALWAYS,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL);
+
+    if (ghLogFile == INVALID_HANDLE_VALUE)
+    {
+        DBGOUT((3, "InitLogging failed CreateFile"));
+        return FALSE;
+    }
+
+#else
+
+    lstrcpy(gszFileName, szFileName);
+
+    ofstruct.cBytes = sizeof(ofstruct);
+    
+    ghLogFile = OpenFile(gszFileName,
+                         &ofstruct,
+                         OF_CREATE);
+
+    _lclose(ghLogFile);
+/*    
+    ofstruct.cBytes = sizeof(ofstruct);
+
+    DBGOUT((3, szFileName));
+    
+    ghLogFile = OpenFile(szFileName,
+                         &ofstruct,
+                         OF_CREATE | OF_READWRITE);
+
+    if (ghLogFile == HFILE_ERROR)
+    {
+        DBGOUT((3, "InitLogging failed OpenFile"));
+        return FALSE;
+    }*/
+#endif
+
+#ifdef WIN32
+    InitializeCriticalSection(&gcsLogging);
+    InitializeCriticalSection(&gcsID);
+    
+    gpBegin = NULL;
+    gpEnd = NULL;
+#endif
+
+    DBGOUT((3, "Exiting InitLogging"));
+    return TRUE;
+}
+
+
+
+void WritePreHeader(DWORD dwID, DWORD dwType)
+{
+	return;
+/*	
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = dwType;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+	*/
+}
+
+void WriteStruct(DWORD dwID,
+                 DWORD dwSize,
+                 LPVOID lpBuf)
+{
+    STRUCTHEADER    StructHeader;
+
+	if (!lpBuf)
+	{
+		return;
+	}
+
+
+    StructHeader.dwKey  = DWSTRCKEY;
+    StructHeader.dwSize = dwSize;
+    StructHeader.dwID   = (DWORD)lpBuf;
+
+    CopyData(dwID, (LPVOID)&StructHeader, sizeof(StructHeader));
+    CopyData(dwID, lpBuf, (int)dwSize);
+}
+
+void WritePostStruct(DWORD dwID,
+                     LONG lResult)
+{
+    POSTSTRUCT      PostStruct;
+
+    PostStruct.dwKey = DWPOSTKEY;
+    PostStruct.dwTime = GetTickCount();
+    PostStruct.lReturn = lResult;
+
+    CopyData(dwID, (LPVOID)&PostStruct, sizeof(PostStruct));
+}
+
+void WriteLineMsgStruct(DWORD dwID,
+                       HTAPILINE htLine,
+                       HTAPICALL htCall,
+                       DWORD dwMsg,
+                       DWORD dw1,
+                       DWORD dw2,
+                       DWORD dw3)
+{
+    LINEMSGSTRUCT       LineMsgStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = LINEMSG;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LineMsgStruct.dwMsg     = dwMsg;
+    LineMsgStruct.htLine    = htLine;
+    LineMsgStruct.htCall    = htCall;
+    LineMsgStruct.dw1       = dw1;
+    LineMsgStruct.dw2       = dw2;
+    LineMsgStruct.dw3       = dw3;
+
+    CopyData(dwID, (LPVOID)&LineMsgStruct, sizeof(LineMsgStruct));
+}
+
+void WritePhoneMsgStruct(DWORD dwID,
+                         HTAPIPHONE htPhone,
+                         DWORD dwMsg,
+                         DWORD dw1,
+                         DWORD dw2,
+                         DWORD dw3)
+{
+    PHONEMSGSTRUCT       PhoneMsgStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = PHONEMSG;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    PhoneMsgStruct.dwMsg     = dwMsg;
+    PhoneMsgStruct.htPhone   = htPhone;
+    PhoneMsgStruct.dw1       = dw1;
+    PhoneMsgStruct.dw2       = dw2;
+    PhoneMsgStruct.dw3       = dw3;
+
+    CopyData(dwID, (LPVOID)&PhoneMsgStruct, sizeof(PhoneMsgStruct));
+}
+
+void WriteAsyncStruct(DWORD dwID,
+                      DWORD dwRequestID,
+                      LONG  lResult)
+{
+    ASYNCSTRUCT     AsyncStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = ASYNCMSG;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    AsyncStruct.dwRequestID = dwRequestID;
+    AsyncStruct.lResult     = lResult;
+   
+
+    CopyData(dwID, (LPVOID)&AsyncStruct, sizeof(AsyncStruct));
+}
+void WriteLogStruct1(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1)
+{
+    LOGSPFUNC1      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC1;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void WriteLogStruct2(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2)
+{
+    LOGSPFUNC2      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC2;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void WriteLogStruct3(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3)
+{
+    LOGSPFUNC3      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC3;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+
+void WriteLogStruct4(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4)
+{
+    LOGSPFUNC4      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC4;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void WriteLogStruct5(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5)
+{
+    LOGSPFUNC5      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC5;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+    LogStruct.dwParam5 = dwParam5;
+
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void WriteLogStruct6(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6)
+{
+    LOGSPFUNC6      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC6;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+    LogStruct.dwParam5 = dwParam5;
+    LogStruct.dwParam6 = dwParam6;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void WriteLogStruct7(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6,
+                     DWORD dwParam7)
+{
+    LOGSPFUNC7      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC7;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+    LogStruct.dwParam5 = dwParam5;
+    LogStruct.dwParam6 = dwParam6;
+    LogStruct.dwParam7 = dwParam7;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+
+void WriteLogStruct8(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6,
+                     DWORD dwParam7,
+                     DWORD dwParam8)
+{
+    LOGSPFUNC8      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC8;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+    LogStruct.dwParam5 = dwParam5;
+    LogStruct.dwParam6 = dwParam6;
+    LogStruct.dwParam7 = dwParam7;
+    LogStruct.dwParam8 = dwParam8;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+
+void WriteLogStruct9(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6,
+                     DWORD dwParam7,
+                     DWORD dwParam8,
+                     DWORD dwParam9)
+{
+    LOGSPFUNC9      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC9;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+    LogStruct.dwParam5 = dwParam5;
+    LogStruct.dwParam6 = dwParam6;
+    LogStruct.dwParam7 = dwParam7;
+    LogStruct.dwParam8 = dwParam8;
+    LogStruct.dwParam9 = dwParam9;
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void WriteLogStruct12(DWORD dwID,
+                      DWORD dwSPFUNC,
+                      DWORD dwParam1,
+                      DWORD dwParam2,
+                      DWORD dwParam3,
+                      DWORD dwParam4,
+                      DWORD dwParam5,
+                      DWORD dwParam6,
+                      DWORD dwParam7,
+                      DWORD dwParam8,
+                      DWORD dwParam9,
+                      DWORD dwParam10,
+                      DWORD dwParam11,                      
+                      DWORD dwParam12)
+{
+    LOGSPFUNC12      LogStruct;
+    PREHEADER   PreHeader;
+
+    PreHeader.dwKey    = DWPREKEY;
+    PreHeader.dwTime   = GetTickCount();
+    PreHeader.dwType   = SPFUNC12;
+
+    CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader));
+
+    LogStruct.dwSPFUNC = dwSPFUNC;
+    LogStruct.dwParam1 = dwParam1;
+    LogStruct.dwParam2 = dwParam2;
+    LogStruct.dwParam3 = dwParam3;
+    LogStruct.dwParam4 = dwParam4;
+    LogStruct.dwParam5 = dwParam5;
+    LogStruct.dwParam6 = dwParam6;
+    LogStruct.dwParam7 = dwParam7;
+    LogStruct.dwParam8 = dwParam8;
+    LogStruct.dwParam9 = dwParam9;
+    LogStruct.dwParam10 = dwParam10;
+    LogStruct.dwParam11 = dwParam11;
+    LogStruct.dwParam12 = dwParam12;    
+
+    CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct));
+}
+
+void CopyData(DWORD dwID, LPVOID lpBuf, int dwSize)
+{
+    memcpy((LPBYTE)gChunks[dwID].pBuffer + gChunks[dwID].iStart,
+           lpBuf,
+           dwSize);
+
+    gChunks[dwID].iStart += dwSize;
+}
+
+BOOL GetChunkID(LPDWORD lpdwID)
+{
+#ifdef WIN32
+	EnterCriticalSection(&gcsID);
+#endif
+    while (TRUE)
+    {
+        while (gdwID < MAXCHUNKS)
+        {
+            if (!gChunks[gdwID].bInUse)
+            {
+                goto gotid;
+            }
+
+            gdwID++;
+        }
+
+        gdwID = 0;
+#ifdef WIN32
+        Sleep(0);
+#endif
+    }
+
+gotid:
+
+    *lpdwID = gdwID;
+    gChunks[gdwID].bInUse = TRUE;
+
+#ifdef WIN32
+    LeaveCriticalSection(&gcsID);
+#endif
+    return TRUE;
+}
+
+BOOL ReleaseID(DWORD dwID)
+{
+    CopyIDToList(gChunks[dwID].iStart,
+                 gChunks[dwID].pBuffer);
+
+#ifdef WIN32
+    GlobalFree(gChunks[dwID].pBuffer);
+#else
+	GlobalFreePtr(gChunks[dwID].pBuffer);
+#endif
+    gChunks[dwID].iStart = 0;
+    gChunks[dwID].pBuffer = NULL;
+    gChunks[dwID].bInUse = FALSE;
+
+    return TRUE;
+}
+
+#ifdef WIN32
+BOOL CopyIDToList(int iCount, LPVOID pBuffer)
+{
+    PLOGSTRUCT      pNew;
+
+    // if we have a lot of stuff to write, hold up here and
+    // wait until we've written a bunch
+    if (gdwTotalBlocks > MAXCHUNKS)
+    {
+        while (gdwTotalBlocks > MINCHUNKS)
+        {
+            Sleep(0);
+        }
+    }
+    
+    pNew = (PLOGSTRUCT)GlobalAlloc(GPTR, iCount+sizeof(LOGSTRUCT));
+
+    pNew->pNext = NULL;
+    pNew->iSize = iCount;
+
+    memcpy(pNew+1, pBuffer, iCount);
+    
+    EnterCriticalSection(&gcsLogging);
+    if (gpBegin == NULL)
+    {
+        gpBegin = pNew;
+    }
+    else
+    {
+        gpEnd->pNext = pNew;
+    }
+
+    gpEnd = pNew;
+    LeaveCriticalSection(&gcsLogging);
+
+    gdwTotalBlocks++;
+
+    return TRUE;
+}
+#else
+BOOL CopyIDToList(int iCount, LPVOID pBuffer)
+{
+    OFSTRUCT ofstruct;
+
+    ofstruct.cBytes = sizeof(ofstruct);
+
+    ghLogFile = OpenFile(gszFileName,
+                         &ofstruct,
+                         OF_READWRITE);
+
+    if (ghLogFile == HFILE_ERROR)
+    {
+        DBGOUT((3,"OpenFile failed"));
+        return FALSE;
+    }
+
+    _llseek(ghLogFile,
+            0,
+            2);
+    
+    if (_lwrite(ghLogFile,
+            pBuffer,
+            iCount) == HFILE_ERROR)
+    {
+        DBGOUT((3, "_lwrite failed"));
+    }
+
+    _lclose(ghLogFile);
+
+	return TRUE;
+}
+#endif
+
+BOOL AllocChunk(DWORD dwID, DWORD dwSize)
+{
+    LPVOID      pbuf;
+
+    // ok, i messed up and forgot to alloc for structheader.
+    // so i'll just add the size of 4 struct headers to each
+    // alloc.  what a hack - o - rama
+    dwSize += 4*sizeof(STRUCTHEADER);
+
+#ifdef WIN32
+    pbuf = (LPVOID)GlobalAlloc(GPTR, dwSize);
+#else
+	pbuf = (LPVOID)GlobalAllocPtr(GPTR, dwSize);
+#endif
+
+    if (!pbuf)
+    {
+        gChunks[dwID].pBuffer = NULL;
+        return FALSE;
+    }
+
+#ifdef WIN32
+    memset(pbuf, 0, dwSize);
+#else
+	memset(pbuf, 0, (int)dwSize);
+#endif
+    gChunks[dwID].pBuffer = pbuf;
+    gChunks[dwID].bInUse = TRUE;
+    gChunks[dwID].iStart = 0;
+
+    return TRUE;
+}
+
diff --git a/private/tapi/dev/sp/repeater/new/logger.h b/private/tapi/dev/sp/repeater/new/logger.h
new file mode 100644
index 000000000..60b8c850b
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/logger.h
@@ -0,0 +1,317 @@
+#include <windows.h>
+#include <tspi.h>
+
+DWORD WINAPI LoggingThread( LPVOID pThreadParm );
+// void CopyData(LPVOID pBuffer, int iCount);
+void CopyData(DWORD dwID, LPVOID lpBuf, int dwSize);
+
+
+#define MAXCHUNKS       5000
+#define MINCHUNKS       1000
+
+// these are the preheader types
+
+#define LINEMSG             1
+#define PHONEMSG            2
+#define ASYNCMSG            3
+#define SPFUNC1             4
+#define SPFUNC2             5
+#define SPFUNC3             6
+#define SPFUNC4             7
+#define SPFUNC5             8
+#define SPFUNC6             9
+#define SPFUNC7             10
+#define SPFUNC8             11
+#define SPFUNC9             12
+#define SPFUNC12            13
+
+#define MYFOURCC( ch0, ch1, ch2, ch3 )                                \
+                ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |    \
+                ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
+
+#define DWPREKEY            MYFOURCC('P','R','E',' ')
+#define DWPOSTKEY           MYFOURCC('P','O','S','T')
+#define DWSTRCKEY           MYFOURCC('S','T','R','C')
+
+typedef struct tagCHUNK
+{
+    int         iStart;
+    LPVOID      pBuffer;
+    BOOL        bInUse;
+} CHUNK, * PCHUNK;
+
+typedef struct tagPREHEADER
+{
+    DWORD       dwKey;          // 'PRE '
+    DWORD       dwTime;
+    DWORD       dwType;
+} PREHEADER, * PPREHEADER;
+
+typedef struct tagPOSTSTRUCT
+{
+    DWORD       dwKey;          // 'POST'
+    DWORD       dwTime;
+    LONG        lReturn;
+} POSTSTRUCT, * PPOSTSTRUCT;
+
+typedef struct tagSTRUCTHEADER
+{
+    DWORD       dwKey;          // 'STRC'
+    DWORD       dwSize;
+    DWORD       dwID;
+} STRUCTHEADER, * PSTRUCTHEADER;
+
+typedef struct tagLINEMSGSTRUCT
+{
+    DWORD               dwMsg;
+    HTAPILINE           htLine;
+    HTAPICALL           htCall;
+    DWORD               dw1;
+    DWORD               dw2;
+    DWORD               dw3;
+    
+} LINEMSGSTRUCT, * PLINEMSGSTRUCT;
+
+
+typedef struct tagPHONEMSGSTRUCT
+{
+    DWORD               dwMsg;
+    HTAPIPHONE           htPhone;
+    DWORD               dw1;
+    DWORD               dw2;
+    DWORD               dw3;
+    
+} PHONEMSGSTRUCT, * PPHONEMSGSTRUCT;
+
+
+typedef struct tagASYNCSTRUCT
+{
+    DWORD               dwRequestID;
+    LONG                lResult;
+    
+} ASYNCSTRUCT, * PASYNCSTRUCT;
+
+typedef struct tagLOGSPFUNC1
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    
+} LOGSPFUNC1, * PLOGSPFUNC1;
+    
+typedef struct tagLOGSPFUNC2
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;    
+    
+} LOGSPFUNC2, * PLOGSPFUNC2;
+    
+typedef struct tagLOGSPFUNC3
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;    
+    
+} LOGSPFUNC3, * PLOGSPFUNC3;
+    
+typedef struct tagLOGSPFUNC4
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;    
+    
+} LOGSPFUNC4, * PLOGSPFUNC4;
+    
+
+typedef struct tagLOGSPFUNC5
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;
+    DWORD               dwParam5;        
+    
+} LOGSPFUNC5, * PLOGSPFUNC5;
+    
+
+typedef struct tagLOGSPFUNC6
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;
+    DWORD               dwParam5;
+    DWORD               dwParam6;            
+    
+} LOGSPFUNC6, * PLOGSPFUNC6;
+    
+
+typedef struct tagLOGSPFUNC7
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;
+    DWORD               dwParam5;
+    DWORD               dwParam6;
+    DWORD               dwParam7;    
+    
+} LOGSPFUNC7, * PLOGSPFUNC7;
+    
+
+typedef struct tagLOGSPFUNC8
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;
+    DWORD               dwParam5;
+    DWORD               dwParam6;
+    DWORD               dwParam7;
+    DWORD               dwParam8;    
+    
+} LOGSPFUNC8, * PLOGSPFUNC8;
+    
+typedef struct tagLOGSPFUNC9
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;
+    DWORD               dwParam5;
+    DWORD               dwParam6;
+    DWORD               dwParam7;
+    DWORD               dwParam8;
+    DWORD               dwParam9;        
+    
+} LOGSPFUNC9, * PLOGSPFUNC9;
+
+typedef struct tagLOGSPFUNC12
+{
+    DWORD               dwSPFUNC;
+    DWORD               dwParam1;
+    DWORD               dwParam2;
+    DWORD               dwParam3;
+    DWORD               dwParam4;
+    DWORD               dwParam5;
+    DWORD               dwParam6;
+    DWORD               dwParam7;
+    DWORD               dwParam8;
+    DWORD               dwParam9;
+    DWORD               dwParam10;
+    DWORD               dwParam11;
+    DWORD               dwParam12;            
+    
+} LOGSPFUNC12, * PLOGSPFUNC12;
+
+void WritePreHeader(DWORD dwID, DWORD dwType);
+void WriteStruct(DWORD dwID,
+                 DWORD dwSize,
+                 LPVOID lpBuf);
+void WritePostStruct(DWORD dwID,
+                     LONG lReturn);
+void WriteLineMsgStruct(DWORD dwID,
+                        HTAPILINE htLine,
+                        HTAPICALL htCall,
+                        DWORD dwMsg,
+                        DWORD dw1,
+                        DWORD dw2,
+                        DWORD dw3);
+void WritePhoneMsgStruct(DWORD dwID,
+                         HTAPIPHONE htPhone,
+                         DWORD dwMsg,
+                         DWORD dw1,
+                         DWORD dw2,
+                         DWORD dw3);
+void WriteAsyncStruct(DWORD dwID,
+                      DWORD,
+                      LONG);
+void WriteLogStruct1(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1);
+void WriteLogStruct2(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2);
+void WriteLogStruct3(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3);
+void WriteLogStruct4(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4);
+void WriteLogStruct5(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5);
+void WriteLogStruct6(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6);
+void WriteLogStruct7(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6,
+                     DWORD dwParam7);
+void WriteLogStruct8(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6,
+                     DWORD dwParam7,
+                     DWORD dwParam8);
+void WriteLogStruct9(DWORD dwID,
+                     DWORD dwSPFUNC,
+                     DWORD dwParam1,
+                     DWORD dwParam2,
+                     DWORD dwParam3,
+                     DWORD dwParam4,
+                     DWORD dwParam5,
+                     DWORD dwParam6,
+                     DWORD dwParam7,
+                     DWORD dwParam8,
+                     DWORD dwParam9);
+void WriteLogStruct12(DWORD dwID,
+                      DWORD dwSPFUNC,
+                      DWORD dwParam1,
+                      DWORD dwParam2,
+                      DWORD dwParam3,
+                      DWORD dwParam4,
+                      DWORD dwParam5,
+                      DWORD dwParam6,
+                      DWORD dwParam7,
+                      DWORD dwParam8,
+                      DWORD dwParam9,
+                      DWORD dwParam10,
+                      DWORD dwParam11,                      
+                      DWORD dwParam12);
+BOOL ReleaseID(DWORD dwID);
+BOOL GetChunkID(LPDWORD lpdwID);
+BOOL AllocChunk(DWORD dwID, DWORD dwSize);
+
diff --git a/private/tapi/dev/sp/repeater/new/makefile b/private/tapi/dev/sp/repeater/new/makefile
new file mode 100644
index 000000000..7cc5b6412
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tsp3216s.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/repeater/new/makefile.def b/private/tapi/dev/sp/repeater/new/makefile.def
new file mode 100644
index 000000000..403b6f324
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/makefile.def
@@ -0,0 +1,51 @@
+ROOT=..\..\..\..\..\..
+
+IS_OEM=1
+IS_32 = TRUE
+WANT_C932=1
+WIN32=1
+
+BUILDDLL=1
+DLLENTRY=DllMain
+
+
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=Repeater
+TARGETS=Repeater.tsp Repeater.sym
+
+
+SRCDIR=..
+
+SYMDIR=.
+
+
+BUILD_COFF=1
+
+
+
+L32EXE=Repeater.tsp		# Name of exe.
+L32DEF=..\Repeater.def              # Our def file.
+L32MAP=Repeater.map		# Our map file.
+L32SYM=Repeater.sym		# Our sym file.
+L32RES=Repeater.res	# Resource file.
+L32OBJS= Repeater.obj logger.obj debug.obj
+L32LIBS= \
+    $(DEVROOT)\lib\user32.lib  \
+    $(DEVROOT)\lib\kernel32.lib 
+
+
+L32FLAGS=$(L32FLAGS) -MAP -DEF:..\REPEATER.DEF
+
+!include $(ROOT)\dev\master.mk
+
+
+INCLUDE=..\..\..\..\inc;$(ROOT)\win\thunk;$(ROOT)\win\core\inc;$(INCLUDE)
+
+#CFLAGS=$(CFLAGS) -DDONT_DECLARE_TSPI_FUNCTIONS=1
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/repeater/new/rep16.def b/private/tapi/dev/sp/repeater/new/rep16.def
new file mode 100644
index 000000000..d0ab25f46
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/rep16.def
@@ -0,0 +1,122 @@
+LIBRARY     repeater
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept                        @500
+        TSPI_lineAddToConference               @501
+        TSPI_lineAnswer                        @502
+        TSPI_lineBlindTransfer                 @503
+        TSPI_lineClose                         @504
+        TSPI_lineCloseCall                     @505
+        TSPI_lineCompleteCall                  @506
+        TSPI_lineCompleteTransfer              @507
+        TSPI_lineConditionalMediaDetection     @508
+        TSPI_lineConfigDialog                  @509
+        TSPI_lineDevSpecific                   @510
+        TSPI_lineDevSpecificFeature            @511
+        TSPI_lineDial                          @512
+        TSPI_lineDrop                          @513
+        TSPI_lineForward                       @514
+        TSPI_lineGatherDigits                  @515
+        TSPI_lineGenerateDigits                @516
+        TSPI_lineGenerateTone                  @517
+        TSPI_lineGetAddressCaps                @518
+        TSPI_lineGetAddressID                  @519
+        TSPI_lineGetAddressStatus              @520
+        TSPI_lineGetCallAddressID              @521
+        TSPI_lineGetCallInfo                   @522
+        TSPI_lineGetCallStatus                 @523
+        TSPI_lineGetDevCaps                    @524
+        TSPI_lineGetDevConfig                  @525
+        TSPI_lineGetExtensionID                @526
+        TSPI_lineGetIcon                       @527
+        TSPI_lineGetID                         @528
+        TSPI_lineGetLineDevStatus              @529
+        TSPI_lineGetNumAddressIDs              @530
+        TSPI_lineHold                          @531
+        TSPI_lineMakeCall                      @532
+        TSPI_lineMonitorDigits                 @533
+        TSPI_lineMonitorMedia                  @534
+        TSPI_lineMonitorTones                  @535
+        TSPI_lineNegotiateExtVersion           @536
+        TSPI_lineNegotiateTSPIVersion          @537
+        TSPI_lineOpen                          @538
+        TSPI_linePark                          @539
+        TSPI_linePickup                        @540
+        TSPI_linePrepareAddToConference        @541
+        TSPI_lineRedirect                      @542
+        TSPI_lineRemoveFromConference          @543
+        TSPI_lineSecureCall                    @544
+        TSPI_lineSelectExtVersion              @545
+        TSPI_lineSendUserUserInfo              @546
+        TSPI_lineSetAppSpecific                @547
+        TSPI_lineSetCallParams                 @548
+        TSPI_lineSetDefaultMediaDetection      @549
+        TSPI_lineSetDevConfig                  @550
+        TSPI_lineSetMediaControl               @551
+        TSPI_lineSetMediaMode                  @552
+        TSPI_lineSetStatusMessages             @553
+        TSPI_lineSetTerminal                   @554
+        TSPI_lineSetupConference               @555
+        TSPI_lineSetupTransfer                 @556
+        TSPI_lineSwapHold                      @557
+        TSPI_lineUncompleteCall                @558
+        TSPI_lineUnhold                        @559
+        TSPI_lineUnpark                        @560
+
+        TSPI_phoneClose                        @561
+        TSPI_phoneConfigDialog                 @562
+        TSPI_phoneDevSpecific                  @563
+        TSPI_phoneGetButtonInfo                @564
+        TSPI_phoneGetData                      @565
+        TSPI_phoneGetDevCaps                   @566
+        TSPI_phoneGetDisplay                   @567
+        TSPI_phoneGetExtensionID               @568
+        TSPI_phoneGetGain                      @569
+        TSPI_phoneGetHookSwitch                @570
+        TSPI_phoneGetIcon                      @571
+        TSPI_phoneGetID                        @572
+        TSPI_phoneGetLamp                      @573
+        TSPI_phoneGetRing                      @574
+        TSPI_phoneGetStatus                    @575
+        TSPI_phoneGetVolume                    @576
+        TSPI_phoneNegotiateExtVersion          @577
+        TSPI_phoneNegotiateTSPIVersion         @578
+        TSPI_phoneOpen                         @579
+        TSPI_phoneSelectExtVersion             @580
+        TSPI_phoneSetButtonInfo                @581
+        TSPI_phoneSetData                      @582
+        TSPI_phoneSetDisplay                   @583
+        TSPI_phoneSetGain                      @584
+        TSPI_phoneSetHookSwitch                @585
+        TSPI_phoneSetLamp                      @586
+        TSPI_phoneSetRing                      @587
+        TSPI_phoneSetStatusMessages            @588
+        TSPI_phoneSetVolume                    @589
+
+        TSPI_providerConfig                    @590
+        TSPI_providerInit                      @591
+        TSPI_providerInstall                   @592
+        TSPI_providerRemove                    @593
+        TSPI_providerShutdown                  @594
+
+        TSPI_providerEnumDevices               @595
+        TSPI_lineDropOnClose                   @596
+        TSPI_lineDropNoOwner                   @597
+        TSPI_providerCreateLineDevice          @598
+        TSPI_providerCreatePhoneDevice         @599
+        TSPI_lineSetCurrentLocation            @600
+        TSPI_lineConfigDialogEdit              @601
+        TSPI_lineReleaseUserUserInfo           @602
+
+;        TSPI_lineSetCallData                   @603
+;        TSPI_lineSetCallQualityOfService       @604
+;        TSPI_lineSetCallTreatment              @605
+;        TSPI_lineSetLineDevStatus              @606
+;        TSPI_providerFreeDialogInstance        @607
+;        TSPI_providerGenericDialogData         @608
+;        TSPI_providerUIIdentify                @609
+
+
diff --git a/private/tapi/dev/sp/repeater/new/rep16.mak b/private/tapi/dev/sp/repeater/new/rep16.mak
new file mode 100644
index 000000000..ea96290a1
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/rep16.mak
@@ -0,0 +1,80 @@
+##### DLL Macros #####
+DLLNAME     = repeater
+DLLSRCS     = repeater.c logger.c debug.c
+DLLOBJS     = repeater.obj logger.obj debug.obj
+
+##### DLL Library Macros #####
+DLLLIBS    = libw ldllcew ver
+DLLMOD	   = -ALw -DDLL
+
+##### APP/DLL Include Macros #####
+DLLINCLS  =
+
+##### APP/DLL Resource Macros #####
+APPRCFILES =
+DLLRCFILES =
+
+##### DEBUG Version Built #####
+DEBUG	= 1
+
+##### Build Option Macros #####
+!if $(DEBUG)
+DDEF	= -DDEBUG -DDBG
+CLOPT	= -Zid -Od
+MOPT	= -Zi
+LOPT	=  /CO /LI /MAP
+!else
+DDEF	=
+CLOPT	= -Os
+LOPT	=
+!endif
+
+##### General Macros #####
+DEF	=
+
+##### Tool Macros #####
+CC	= cl -nologo -c $(DLLMOD) -G2sw -Zp -W3 $(CLOPT) $(DDEF) $(DEF)
+LINK	= link /NOD /NOE $(LOPT)
+RC	= rc $(DDEF) $(DEF)
+HC	= hc
+
+##### Inference Rules #####
+.asm.obj:
+    $(ASM) $*.asm;
+
+.rc.res:
+    $(RC) -r $*.rc
+
+##### Main (default) Target #####
+goal:  $(DLLNAME).tsp
+
+##### Dependents For Goal and Command Lines #####
+##### DLL Built Separately #####
+.c.obj :
+    $(CC) $(DLLSRCS)
+    
+
+$(DLLNAME).tsp: $(DLLOBJS) rep16.def
+    $(LINK) @<<
+    $(DLLOBJS),
+    $(DLLNAME).tsp,
+    $(DLLNAME).map,
+    $(DLLLIBS),
+    rep16.def
+<<
+    implib $(DLLNAME).lib rep16.def
+
+#    $(RC) -T $(DLLNAME).tsp
+#!if $(DEBUG)
+#    cvpack -p $(DLLNAME).tsp
+#!endif
+
+##### Dependents #####
+$(DLLOBJS): $(DLLINCLS)
+
+##### Clean Directory #####
+clean:
+    -del *.obj
+    -del *.tsp
+    -del *.map
+    -del *.sym
diff --git a/private/tapi/dev/sp/repeater/new/repeater.c b/private/tapi/dev/sp/repeater/new/repeater.c
new file mode 100644
index 000000000..bf0d84dcd
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/repeater.c
@@ -0,0 +1,6251 @@
+#pragma warning(disable: 4087)
+
+#define STRICT
+#define UNICODE
+
+#include <windows.h>
+#include <windowsx.h>
+
+#ifndef WIN32
+#define TAPI_CURRENT_VERSION 0x00010004
+#endif
+
+#include <tapi.h>
+#include <tspi.h>
+
+#include "tsp3216.h"
+
+#include "Repeater.h"
+#include "logger.h"
+#include "debug.h"
+
+#ifndef WIN32
+#define TCHAR   char
+#define TEXT(string) string
+#define LPCWSTR LPCSTR
+#endif
+
+#ifdef WIN32
+extern CRITICAL_SECTION        gcsLogging;
+extern CRITICAL_SECTION        gcsID;
+#endif
+
+#define TSPAPI PASCAL
+typedef LONG (TSPAPI* TSPAPIPROC)(void);
+
+#if DBG
+#define RepeaterDebugString(_x_) DbgPrt _x_
+#else
+#define RepeaterDebugString(_x_)
+#endif
+
+// globals
+
+HINSTANCE           ghThisInst;
+BOOL                gfTerminateNow = FALSE;
+BOOL                gbStarted = FALSE;
+DWORD               dwPermanentProvider;
+DWORD               dwNumLines;
+DWORD               dwNumPhones;
+
+#ifdef WIN32
+DWORD               gdwLoggingThreadID;
+HANDLE              ghLoggingThread;
+#endif
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+HDRVDIALOGINSTANCE  gDlgInst;
+#endif
+
+//////////////////////////////////////////////////////
+HINSTANCE           hProvider = NULL; 
+TSPAPIPROC FAR *    lpfnProcAddress = NULL;
+
+#ifdef WIN32
+#define MYALLOC(x,y)	((x) = GlobalAlloc(GPTR, (y)))
+#define MYFREE(x)		GlobalFree(x)
+#else
+#define MYALLOC(x,y)	((x) = (LPVOID)MAKELONG(0, GlobalAlloc(GPTR, (y))))
+#define MYFREE(x)       (GlobalFree((HGLOBAL)HIWORD(x)))
+                        
+#endif
+					     
+
+LINEEVENT   glpLineEventProc32;
+PHONEEVENT  glpPhoneEventProc32;
+
+ASYNC_COMPLETION glpAsyncCompletionProc32 = NULL;
+
+void InitLogging();
+
+#ifndef WIN32
+const char far szIniFile[] = "telephon.INI";
+#endif
+
+
+#define BOGUS_REQUEST_ID    (0xfffffffd)
+
+#define NORMALCHUNK         sizeof(PREHEADER) + sizeof(POSTSTRUCT)
+
+// all tspi function names
+// since all functions are exported by name
+char *gaszTSPIFuncNames[] =
+{
+    "TSPI_lineAccept",
+    "TSPI_lineAddToConference",
+    "TSPI_lineAgentSpecific",
+    "TSPI_lineAnswer",
+    "TSPI_lineBlindTransfer",
+    "TSPI_lineClose",
+    "TSPI_lineCloseCall",
+    "TSPI_lineCompleteCall",
+    "TSPI_lineCompleteTransfer",
+    "TSPI_lineConditionalMediaDetection",
+    "TSPI_lineDevSpecific",
+    "TSPI_lineDevSpecificFeature",
+    "TSPI_lineDial",
+    "TSPI_lineDrop",
+    "TSPI_lineForward",
+    "TSPI_lineGatherDigits",
+    "TSPI_lineGenerateDigits",
+    "TSPI_lineGenerateTone",
+    "TSPI_lineGetAddressCaps",
+    "TSPI_lineGetAddressID",
+    "TSPI_lineGetAddressStatus",
+    "TSPI_lineGetAgentActivityList",
+    "TSPI_lineGetAgentCaps",
+    "TSPI_lineGetAgentGroupList",
+    "TSPI_lineGetAgentStatus",
+    "TSPI_lineGetCallAddressID",
+    "TSPI_lineGetCallInfo",
+    "TSPI_lineGetCallStatus",
+    "TSPI_lineGetDevCaps",
+    "TSPI_lineGetDevConfig",
+    "TSPI_lineGetExtensionID",
+    "TSPI_lineGetIcon",
+    "TSPI_lineGetID",
+    "TSPI_lineGetLineDevStatus",
+    "TSPI_lineGetNumAddressIDs",
+    "TSPI_lineHold",
+    "TSPI_lineMakeCall",
+    "TSPI_lineMonitorDigits",
+    "TSPI_lineMonitorMedia",
+    "TSPI_lineMonitorTones",
+    "TSPI_lineNegotiateExtVersion",
+    "TSPI_lineNegotiateTSPIVersion",
+    "TSPI_lineOpen",
+    "TSPI_linePark",
+    "TSPI_linePickup",
+    "TSPI_linePrepareAddToConference",
+    "TSPI_lineRedirect",
+    "TSPI_lineReleaseUserUserInfo",
+    "TSPI_lineRemoveFromConference",
+    "TSPI_lineSecureCall",
+    "TSPI_lineSelectExtVersion",
+    "TSPI_lineSendUserUserInfo",
+    "TSPI_lineSetAgentActivity",
+    "TSPI_lineSetAgentGroup",
+    "TSPI_lineSetAgentState",
+    "TSPI_lineSetAppSpecific",
+    "TSPI_lineSetCallData",
+    "TSPI_lineSetCallParams",
+    "TSPI_lineSetCallQualityOfService",
+    "TSPI_lineSetCallTreatment",
+    "TSPI_lineSetCurrentLocation",
+    "TSPI_lineSetDefaultMediaDetection",
+    "TSPI_lineSetDevConfig",
+    "TSPI_lineSetLineDevStatus",
+    "TSPI_lineSetMediaControl",
+    "TSPI_lineSetMediaMode",
+    "TSPI_lineSetStatusMessages",
+    "TSPI_lineSetTerminal",
+    "TSPI_lineSetupConference",
+    "TSPI_lineSetupTransfer",
+    "TSPI_lineSwapHold",
+    "TSPI_lineUncompleteCall",
+    "TSPI_lineUnhold",
+    "TSPI_lineUnpark",
+    "TSPI_phoneClose",
+    "TSPI_phoneDevSpecific",
+    "TSPI_phoneGetButtonInfo",
+    "TSPI_phoneGetData",
+    "TSPI_phoneGetDevCaps",
+    "TSPI_phoneGetDisplay",
+    "TSPI_phoneGetExtensionID",
+    "TSPI_phoneGetGain",
+    "TSPI_phoneGetHookSwitch",
+    "TSPI_phoneGetIcon",
+    "TSPI_phoneGetID",
+    "TSPI_phoneGetLamp",
+    "TSPI_phoneGetRing",
+    "TSPI_phoneGetStatus",
+    "TSPI_phoneGetVolume",
+    "TSPI_phoneNegotiateExtVersion",
+    "TSPI_phoneNegotiateTSPIVersion",
+    "TSPI_phoneOpen",
+    "TSPI_phoneSelectExtVersion",
+    "TSPI_phoneSetButtonInfo",
+    "TSPI_phoneSetData",
+    "TSPI_phoneSetDisplay",
+    "TSPI_phoneSetGain",
+    "TSPI_phoneSetHookSwitch",
+    "TSPI_phoneSetLamp",
+    "TSPI_phoneSetRing",
+    "TSPI_phoneSetStatusMessages",
+    "TSPI_phoneSetVolume",
+    "TSPI_providerCreateLineDevice",
+    "TSPI_providerCreatePhoneDevice",
+    "TSPI_providerEnumDevices",
+    "TSPI_providerFreeDialogInstance",
+    "TSPI_providerGenericDialogData",
+    "TSPI_providerInit",
+    "TSPI_providerShutdown",
+    "TSPI_providerUIIdentify",
+    "TSPI_lineConfigDialog",
+    "TSPI_lineConfigDialogEdit",
+    "TSPI_phoneConfigDialog",
+    "TSPI_providerConfig"    
+    "TSPI_lineDropOnClose",
+    "TSPI_lineDropNoOwner",
+    NULL
+};
+
+  
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank1(
+            DWORD dwBlank1
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank1 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank2(
+            DWORD dwBlank1,
+            DWORD dwBlank2
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank2 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank3(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank3 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank4(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank4 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank5(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5 
+            )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank5 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank6(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank6 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank7(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank7 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank8(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+                DWORD dwBlank8
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank8 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank9(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+            DWORD dwBlank8,
+            DWORD dwBlank9                
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank9 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank10(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+            DWORD dwBlank8,
+            DWORD dwBlank9,
+            DWORD dwBlank10                 
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank10 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank11(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+            DWORD dwBlank8,
+            DWORD dwBlank9,
+            DWORD dwBlank10,
+            DWORD dwBlank11                 
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank11 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_LineBlank12(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+            DWORD dwBlank8,
+            DWORD dwBlank9,
+            DWORD dwBlank10,
+            DWORD dwBlank11,
+            DWORD dwBlank12            
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank12 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank1(
+            DWORD dwBlank1
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank1 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank2(
+            DWORD dwBlank1,
+            DWORD dwBlank2
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank2 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank3(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank3 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank4(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank4 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank5(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5 
+            )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank5 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank6(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank6 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank7(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank7 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}   
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank8(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+            DWORD dwBlank8                 
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank8 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}   
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_PhoneBlank9(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7,
+            DWORD dwBlank8,
+            DWORD dwBlank9                 
+           )
+{
+    RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank9 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}   
+
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+// function definitions
+
+#ifdef DEBUG
+VOID RepeaterOutputDebug(int level, LPSTR errString)
+    {    
+    char outString[1024];
+
+    // if(level <= ???)
+        {
+        wsprintf(outString, "Repeater:(%d) %s\r\n", level, errString);
+        OutputDebugString(outString);    
+        }
+    }
+#endif
+
+VOID
+   InitializeSPs(VOID);
+    
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+void StartMeUp( void )
+{
+
+    gbStarted = TRUE;
+    
+        MYALLOC(lpfnProcAddress, sizeof(gaszTSPIFuncNames)/sizeof(gaszTSPIFuncNames[0]) * sizeof(TSPAPIPROC));
+    
+#ifdef WIN32
+        //
+        // Kick off the logging thread
+        //
+        InitLogging();
+
+        DBGOUT((3, "Entering StartMeUp"));
+
+        ghLoggingThread = CreateThread(
+                                       NULL,
+                                       0,
+                                       LoggingThread,
+                                       NULL,
+                                       0,
+                                       &gdwLoggingThreadID
+                                      );
+#else
+        InitLogging();
+#endif
+
+        InitializeSPs();
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+VOID
+   InitializeSPs(VOID)
+{
+    TCHAR   LibFileName[MAXBUFSIZE];
+    TCHAR   szBuffer[MAXBUFSIZE];
+#ifdef WIN32
+    HKEY    hKey;
+    DWORD   dwSize, dwType;
+#endif
+
+    // under the telephony key, there should be a repeater key,
+    // that is exactly like the providers key.  the repeater key
+    // should list the provider to actually be used.  the provider
+    // key should list repeater as the only sp.
+
+#ifdef WIN32
+    RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+                 TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Repeater"),
+                 0,
+                 KEY_QUERY_VALUE,
+                 &hKey);
+#endif
+
+#ifdef WIN32
+    dwSize = MAXBUFSIZE;
+    dwType = REG_SZ;
+    RegQueryValueEx(hKey,
+                    TEXT("ProviderFilename0"),
+                    NULL,
+                    &dwType,
+                    (LPBYTE)LibFileName,
+                    &dwSize);
+#else
+    GetPrivateProfileString(TEXT("Repeater"),
+                            TEXT("ProviderFilename0"),
+                            TEXT(""),
+                            LibFileName,
+                            MAXBUFSIZE,
+                            szIniFile);
+
+#endif
+        
+    DBGOUT((1, "Loading provider"));
+    
+    hProvider = LoadLibrary(LibFileName);
+
+    if ( hProvider )
+    {
+        DBGOUT((1, "LoadLibrary succeeded"));
+
+#ifdef WIN32
+
+        dwSize = sizeof(DWORD);
+        dwType = REG_DWORD;
+
+        RegQueryValueEx(hKey,
+                        TEXT("ProviderID0"),
+                        NULL,
+                        &dwType,
+                        (LPBYTE)&dwPermanentProvider,
+                        &dwSize);
+#else
+        dwPermanentProvider=
+            GetPrivateProfileInt("Repeater",
+                                 TEXT("ProviderID0"),
+                                 0,
+                                 szIniFile);
+
+        // try to read NumPhones and NumLines from telephon.ini
+        // if the sp implements enumdevices, these numbers
+        // will get overwritten anyway
+        dwNumLines = GetPrivateProfileInt("Provider0",
+                                          "NumLines",
+                                          0,
+                                          szIniFile);
+            
+        dwNumPhones = GetPrivateProfileInt("Provider0",
+                                           "NumPhones",
+                                           0,
+                                           szIniFile);
+#endif
+    }   
+
+    else
+    {   
+        DBGOUT((1, "    provider FAILED TO LOAD!"));
+    }
+
+
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+TSPAPIPROC GetProcAddressHashed(DWORD iFunction, UINT nNumParms)
+{
+
+    static  TSPAPIPROC DefaultLineTable[] =
+            {
+                (TSPAPIPROC)TSPI_LineBlank1,
+                (TSPAPIPROC)TSPI_LineBlank2,
+                (TSPAPIPROC)TSPI_LineBlank3,
+                (TSPAPIPROC)TSPI_LineBlank4,
+                (TSPAPIPROC)TSPI_LineBlank5,
+                (TSPAPIPROC)TSPI_LineBlank6,
+                (TSPAPIPROC)TSPI_LineBlank7,
+                (TSPAPIPROC)TSPI_LineBlank8,
+                (TSPAPIPROC)TSPI_LineBlank9,
+                (TSPAPIPROC)TSPI_LineBlank10,
+                (TSPAPIPROC)TSPI_LineBlank11,
+                (TSPAPIPROC)TSPI_LineBlank12                
+            };
+
+    static  TSPAPIPROC DefaultPhoneTable[] =
+            {
+                (TSPAPIPROC)TSPI_PhoneBlank1,
+                (TSPAPIPROC)TSPI_PhoneBlank2,
+                (TSPAPIPROC)TSPI_PhoneBlank3,
+                (TSPAPIPROC)TSPI_PhoneBlank4,
+                (TSPAPIPROC)TSPI_PhoneBlank5,
+                (TSPAPIPROC)TSPI_PhoneBlank6,
+                (TSPAPIPROC)TSPI_PhoneBlank7,
+                (TSPAPIPROC)TSPI_PhoneBlank8,
+                (TSPAPIPROC)TSPI_PhoneBlank9,                
+            };
+
+    TSPAPIPROC *pfn;
+    TSPAPIPROC *FunctionTable;
+
+
+    //
+    // Find out if it's a phone function or a line function
+    //
+    if (
+        (iFunction >= SP_PHONECLOSE)
+        &&
+        (iFunction <= SP_PHONESETVOLUME)
+       )
+    {
+        //
+        // It's a phone function
+        //
+        FunctionTable = DefaultPhoneTable;
+    }
+    else
+    {
+        //
+        // It's a line function
+        //
+        FunctionTable = DefaultLineTable;
+    }
+
+    if ( nNumParms > (sizeof(DefaultLineTable)/sizeof(TSPAPIPROC)) )
+    {
+        DBGOUT((1, ">Num funcs function was requested!"));
+        return 0;
+    }
+
+    // get the pointer to the function
+    pfn = &lpfnProcAddress[iFunction];
+
+    // have we already gotten the address?
+    if( NULL == *pfn )
+    {
+
+        // nope, call get proc address
+        DBGOUT((5, "%s address being gotten", gaszTSPIFuncNames[iFunction]));
+
+        *pfn = (TSPAPIPROC)GetProcAddress(hProvider,
+                                          gaszTSPIFuncNames[iFunction]);
+
+        //
+        // Did it fail?
+        //
+        if( NULL == *pfn )
+        {
+            DBGOUT((1, "Getting address failed"));
+            *pfn = FunctionTable[ nNumParms - 1 ];
+        }
+    }
+
+    DBGOUT((1, "leaving getprocess address *pfn %lx", *pfn));
+
+    return *pfn;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+#ifdef WIN32
+void PASCAL  LineEventProc(
+#else
+void CALLBACK __export LineEventProc(
+#endif
+    HTAPILINE htLine,
+    HTAPICALL htCall,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+
+    DWORD dwID;
+
+    DBGOUT((1,  "Line event callback"));
+
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, sizeof(PREHEADER) + sizeof(LINEMSGSTRUCT));
+
+   switch (dwMsg)
+   {
+    case LINE_NEWCALL:
+    case LINE_CALLSTATE:
+    case LINE_CALLDEVSPECIFIC:
+    case LINE_CALLDEVSPECIFICFEATURE:
+    case LINE_CALLINFO:
+    case LINE_GATHERDIGITS:
+    case LINE_GENERATE:
+    case LINE_MONITORDIGITS:
+    case LINE_MONITORMEDIA:
+    case LINE_MONITORTONE:
+    case LINE_ADDRESSSTATE:
+    case LINE_CLOSE:
+    case LINE_DEVSPECIFIC:
+    case LINE_DEVSPECIFICFEATURE:
+    case LINE_LINEDEVSTATE:
+    case LINE_CREATE:
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    case LINE_CREATEDIALOGINSTANCE:
+    case LINE_REMOVE:
+#endif
+        break;
+        
+   } // end of switch (dwMsg)                
+
+   WritePreHeader(dwID,
+                  LINEMSG);
+
+   WriteLineMsgStruct(dwID,
+                      htLine,
+                      htCall,
+                      dwMsg,
+                      dwParam1,
+                      dwParam2,
+                      dwParam3);
+
+   ReleaseID(dwID);
+
+   (*glpLineEventProc32)(htLine,
+                         htCall,
+                         dwMsg,
+                         dwParam1,
+                         dwParam2,
+                         dwParam3);
+
+}
+
+#ifdef WIN32
+void PASCAL
+#else
+void CALLBACK __export
+#endif
+PhoneEventProc(
+    HTAPIPHONE htPhone,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+
+    DWORD dwID;
+    
+    DBGOUT((1, "Phone event callback"));
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, sizeof(PREHEADER) + sizeof(PHONEMSGSTRUCT));
+    
+    switch(dwMsg)
+    {
+        case PHONE_BUTTON:
+        case PHONE_CLOSE:
+        case PHONE_DEVSPECIFIC:
+        case PHONE_STATE:
+        case PHONE_CREATE:
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+        case PHONE_REMOVE:
+#endif
+            break;
+    } // end of switch(dwMsg)
+
+    WritePreHeader(dwID,
+                   PHONEMSG);
+
+    WritePhoneMsgStruct(dwID,
+                        htPhone,
+                        dwMsg,
+                        dwParam1,
+                        dwParam2,
+                        dwParam3);
+
+    ReleaseID(dwID);
+
+    (*glpPhoneEventProc32)(htPhone,
+                           dwMsg,
+                           dwParam1,
+                           dwParam2,
+                           dwParam3);
+
+}
+
+
+#ifdef WIN32
+void CALLBACK //ASYNC_COMPLETION // PASCAL
+#else
+void CALLBACK __export
+#endif
+AsyncCompletionProc(DRV_REQUESTID dwRequestID,
+                    LONG lResult)
+{
+
+    DWORD   dwID;
+    
+    DBGOUT((1, "Async completion callback"));
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, sizeof(PREHEADER) + sizeof(ASYNCSTRUCT));
+    
+    WritePreHeader(dwID,
+                   ASYNCMSG);
+
+    WriteAsyncStruct(dwID,
+                     dwRequestID,
+                     lResult);
+
+    ReleaseID(dwID);
+
+    (*glpAsyncCompletionProc32)( dwRequestID, lResult );
+
+}
+
+
+
+
+//
+// -------------------- TSPIAPI TSPI_line functions ---------------------------
+//
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineAccept(DRV_REQUESTID       dwRequestID,
+                HDRVCALL            hdCall,
+                LPCSTR              lpsUserUserInfo,
+                DWORD               dwSize)
+{
+    LONG            lReturn;
+    DWORD           dwID;
+    
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_lineAccept"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID,
+                    SP_LINEACCEPT,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpsUserUserInfo,
+                    (DWORD)dwSize);
+
+    WriteStruct(dwID,
+                dwSize,
+                (LPVOID)lpsUserUserInfo);
+
+    lReturn = (* GetProcAddressHashed(SP_LINEACCEPT, 4))(
+                  dwRequestID,
+                  hdCall,
+                  lpsUserUserInfo,
+                  dwSize);
+
+    WritePostStruct(dwID,
+                    lReturn);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HDRVCALL            hdConsultCall
+    )
+{
+    LONG            lReturn;
+    DWORD           dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3));    
+
+    RepeaterDebugString((2, "Entering TSPI_lineAddToConference"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINEADDTOCONFERENCE,
+                    dwRequestID,
+                    (DWORD)hdConfCall,
+                    (DWORD)hdConsultCall);
+
+    lReturn = (* GetProcAddressHashed(SP_LINEADDTOCONFERENCE,3))(
+                  dwRequestID,
+                  hdConfCall,
+                  hdConsultCall);
+
+    WritePostStruct(dwID, lReturn);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+    LONG                lReturn;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize);
+    
+    RepeaterDebugString((2, "Entering TSPI_lineAnswer"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEACCEPT,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpsUserUserInfo,
+                    (DWORD)dwSize);
+
+    WriteStruct(dwID, dwSize, (LPVOID)lpsUserUserInfo);
+
+    lReturn = (* GetProcAddressHashed(SP_LINEANSWER, 4))(
+                           dwRequestID,
+                           hdCall,
+                           lpsUserUserInfo,
+                           dwSize);
+
+    WritePostStruct(dwID, lReturn);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode)
+{
+    LONG                    lReturn;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + lstrlen(lpszDestAddress));
+    
+    RepeaterDebugString((2, "Entering TSPI_lineBlindTransfer"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEBLINDTRANSFER,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpszDestAddress,
+                    dwCountryCode);
+
+    WriteStruct(dwID, lstrlen(lpszDestAddress), (LPVOID)lpszDestAddress);
+
+    lReturn = (* GetProcAddressHashed(SP_LINEBLINDTRANSFER, 4))(
+                           dwRequestID,
+                           hdCall,
+                           lpszDestAddress,
+                           dwCountryCode
+                           );
+
+    WritePostStruct(dwID, lReturn);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE            hdLine
+    )
+{
+    LONG                lReturn;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1));
+    
+    RepeaterDebugString((2, "Entering TSPI_lineClose"));
+
+    WritePreHeader(dwID, SPFUNC1);
+
+    WriteLogStruct1(dwID, SP_LINECLOSE,
+                    (DWORD)hdLine);
+
+    lReturn = (* GetProcAddressHashed(SP_LINECLOSE, 1))(hdLine);
+
+    WritePostStruct(dwID, lReturn);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL            hdCall
+    )
+{
+    LONG            lReturn;
+    DWORD           dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1));
+    
+
+    RepeaterDebugString((2, "Entering TSPI_lineCloseCall"));
+
+    WritePreHeader(dwID, SPFUNC1);
+
+    WriteLogStruct1(dwID, SP_LINECLOSECALL,
+                    (DWORD)hdCall);
+
+    lReturn = (* GetProcAddressHashed(SP_LINECLOSECALL, 1))(hdCall);
+
+    WritePostStruct(dwID, lReturn);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    )
+{
+    LONG                    lReturn;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(DWORD));
+    
+
+    RepeaterDebugString((2, "Entering TSPI_lineCompleteCall"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINECOMPLETECALL,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpdwCompletionID,
+                    dwCompletionMode,
+                    (DWORD)hdCall);
+
+    lReturn = (* GetProcAddressHashed(SP_LINECOMPLETECALL, 5))(
+                   dwRequestID,
+                   hdCall,
+                   lpdwCompletionID,
+                   dwCompletionMode,
+                   hdCall
+                 );
+
+    WritePostStruct(dwID, lReturn);
+
+    WriteStruct(dwID, sizeof(DWORD),
+                (LPVOID)lpdwCompletionID);
+
+    ReleaseID(dwID);
+
+    return lReturn;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVCALL            hdConsultCall,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    DWORD               dwTransferMode
+    )
+{
+    LONG                lReturn;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + sizeof(MYHDRVCALL));
+    
+
+    RepeaterDebugString((2, "Entering TSPI_lineCompleteTransfer"));
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_LINECOMPLETETRANSFER,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)hdConsultCall,
+                    (DWORD)htConfCall,
+                    (DWORD)lphdConfCall,
+                    dwTransferMode);
+
+    lReturn = (* GetProcAddressHashed(SP_LINECOMPLETETRANSFER, 6))(
+                   dwRequestID,
+                   hdCall,
+                   hdConsultCall,
+                   htConfCall,
+                   lphdConfCall,
+                   dwTransferMode
+                 );
+
+    WritePostStruct(dwID, lReturn);
+
+	if (lReturn >= 0)
+	{
+		WriteStruct(dwID, sizeof(HDRVCALL),
+			        (LPVOID)lphdConfCall);
+	}
+
+
+    ReleaseID(dwID);
+
+    return lReturn;
+    
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     (lpCallParams ? lpCallParams->dwTotalSize : 0));
+    
+    RepeaterDebugString((2, "Entering TSPI_lineConditionalMediaDetection"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINECONDITIONALMEDIADETECTION,
+                    (DWORD)hdLine,
+                    dwMediaModes,
+                    (DWORD)lpCallParams);
+
+    if (lpCallParams)
+    {
+        WriteStruct(dwID, lpCallParams->dwTotalSize,
+                    (LPVOID)lpCallParams);
+    }
+
+    lResult =  (* GetProcAddressHashed(SP_LINECONDITIONALMEDIADETECTION, 3))(
+                       hdLine,
+                       dwMediaModes,
+                       lpCallParams);
+
+    WritePostStruct(dwID, lResult);
+
+    RepeaterDebugString((2, "Leaving TSPI_lineConditionalMediaDetection"));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass
+    )
+{
+
+    LONG               lResult = 0;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + lstrlen(lpszDeviceClass));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINECONFIGDIALOG,
+                    dwDeviceID,
+#ifdef WIN32
+                    (DWORD)hwndOwner,
+#else
+                    MAKELONG(hwndOwner, 0),
+#endif
+                    (DWORD)lpszDeviceClass);
+
+    WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                (LPVOID)lpszDeviceClass);
+
+    lResult =
+           (* GetProcAddressHashed(SP_LINECONFIGDIALOG, 3))(
+                     dwDeviceID,
+                     hwndOwner,
+                     lpszDeviceClass
+                     );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+    
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineConfigDialogEdit(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCWSTR             lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    RepeaterDebugString((2, "Entering TSPI_lineConfigDialogEdit"));
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC6) +
+                     dwSize +
+                     lstrlen(lpszDeviceClass) +
+                     (lpDeviceConfigOut ? lpDeviceConfigOut->dwTotalSize : 0));
+
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_LINECONFIGDIALOGEDIT,
+                    dwDeviceID,
+#ifdef WIN32
+                    (DWORD)hwndOwner,
+#else
+                    (DWORD)MAKELONG(hwndOwner, 0),
+#endif
+                    (DWORD)lpszDeviceClass,
+                    (DWORD)lpDeviceConfigIn,
+                    dwSize,
+                    (DWORD)lpDeviceConfigOut);
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+    if (lpDeviceConfigIn)
+    {
+        WriteStruct(dwID, dwSize,
+                    (LPVOID)lpDeviceConfigIn);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINECONFIGDIALOGEDIT, 6))(
+                    dwDeviceID,
+                    hwndOwner,
+                    lpszDeviceClass,
+                    lpDeviceConfigIn,
+                    dwSize,
+                    lpDeviceConfigOut);
+    
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        if (lpDeviceConfigOut)
+        {
+            WriteStruct(dwID, lpDeviceConfigOut->dwTotalSize,
+                        (LPVOID)lpDeviceConfigOut);
+        }
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + dwSize + dwSize);
+
+
+    RepeaterDebugString((2, "Entering TSPI_lineDevSpecific"));
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_LINEDEVSPECIFIC,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    dwAddressID,
+                    (DWORD)hdCall,
+                    (DWORD)lpParams,
+                    dwSize);
+
+    WriteStruct(dwID, dwSize,
+                (LPVOID)lpParams);
+
+
+    lResult =  (* GetProcAddressHashed(SP_LINEDEVSPECIFIC, 6))(
+                       dwRequestID,
+                       hdLine,
+                       dwAddressID,
+                       hdCall,
+                       lpParams,
+                       dwSize);
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, dwSize,
+		            (LPVOID)lpParams);
+	}
+
+    ReleaseID(dwID);
+    
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID,  NORMALCHUNK + sizeof(LOGSPFUNC5) + dwSize + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_lineDevSpecificFeature"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEDEVSPECIFICFEATURE,
+                   dwRequestID,
+                   (DWORD)hdLine,
+                   dwFeature,
+                   (DWORD)lpParams,
+                   dwSize);
+
+    WriteStruct(dwID, dwSize,
+                (LPVOID)lpParams);
+
+    lResult =  (* GetProcAddressHashed(SP_LINEDEVSPECIFICFEATURE, 5))(
+                       dwRequestID,
+                       hdLine,
+                       dwFeature,
+                       lpParams,
+                       dwSize);
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, dwSize,
+		            (LPVOID)lpParams);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + lstrlen(lpszDestAddress));
+
+    RepeaterDebugString((2, "Entering TSPI_lineDial"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEDIAL,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpszDestAddress,
+                    dwCountryCode);
+
+    if (lpszDestAddress)
+    {
+        WriteStruct(dwID, lstrlen(lpszDestAddress),
+                    (LPVOID)lpszDestAddress);
+    }
+
+    lResult =  (* GetProcAddressHashed(SP_LINEDIAL, 4))(
+        dwRequestID,
+        hdCall,
+        lpszDestAddress,
+        dwCountryCode
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_lineDrop"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEDROP,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpsUserUserInfo,
+                    dwSize);
+
+    WriteStruct(dwID, dwSize,
+                (LPVOID)lpsUserUserInfo);
+
+    lResult =  (* GetProcAddressHashed(SP_LINEDROP, 4))(
+        dwRequestID,
+        hdCall,
+        lpsUserUserInfo,
+        dwSize
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineDropOnClose(
+    HDRVCALL            hdCall
+    )
+{
+
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1));
+
+    RepeaterDebugString((2, "Entering TSPI_lineDropOnClose"));
+
+    WritePreHeader(dwID, SPFUNC1);
+
+    WriteLogStruct1(dwID, SP_LINEDROPONCLOSE,
+                    (DWORD)hdCall);
+
+    lResult = (* GetProcAddressHashed(SP_LINEDROPONCLOSE, 1))
+                  (hdCall);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineDropNoOwner(
+    HDRVCALL            hdCall
+    )
+{
+    TSPAPIPROC          pfn;
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1));
+
+
+    RepeaterDebugString((2, "Entering TSPI_lineDropNoOwner"));
+
+
+    WritePreHeader(dwID, SPFUNC1);
+
+    WriteLogStruct1(dwID, SP_LINEDROPNOOWNER,
+                    (DWORD)hdCall);
+    
+    pfn = (TSPAPIPROC)GetProcAddressHashed(SP_LINEDROPNOOWNER, 1);
+
+    
+    if (pfn != (TSPAPIPROC)TSPI_LineBlank1)
+    {
+        lResult = (*pfn)(hdCall);
+    }
+    else
+    {
+      RepeaterDebugString((4, "  This SP does not export DROPNOOWNER, so we'll call LINEDROP"));
+
+      lResult = (* GetProcAddressHashed(SP_LINEDROP, 4))( 
+                  (DWORD) BOGUS_REQUEST_ID,
+                  (DWORD) hdCall,
+                  (DWORD) NULL,
+                  (DWORD) 0
+               );
+
+      //
+      // Did we get an error back sync?
+      //
+      if ( 
+            (lResult < 0)
+          &&
+            (lResult != BOGUS_REQUEST_ID)
+         )
+      {
+         //
+         // Yup. Return it.
+         //
+      }
+      else
+      {
+         //
+         // No, we got back the req id.  Return success.
+         //
+         lResult = 0;
+      }
+    }
+
+    RepeaterDebugString((3, "Leaving TSPI_lineDropNoOwner,  return code=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+    
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG 
+TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC9) +
+                     (lpForwardList ? lpForwardList->dwTotalSize : 0) +
+                     (lpCallParams ? lpCallParams->dwTotalSize : 0) +
+                     sizeof(HDRVCALL));
+
+    RepeaterDebugString((2, "Entering TSPI_lineForward"));
+
+    WritePreHeader(dwID, SPFUNC9);
+
+    WriteLogStruct9(dwID, SP_LINEFORWARD,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    (DWORD)bAllAddresses,
+                    dwAddressID,
+                    (DWORD)lpForwardList,
+                    (DWORD)dwNumRingsNoAnswer,
+                    (DWORD)htConsultCall,
+                    (DWORD)lphdConsultCall,
+                    (DWORD)lpCallParams);
+
+    if (lpForwardList)
+    {
+        WriteStruct(dwID, lpForwardList->dwTotalSize,
+                    (LPVOID)lpForwardList);
+    }
+
+    if (lpCallParams)
+    {
+        WriteStruct(dwID, lpCallParams->dwTotalSize,
+                    (LPVOID)lpCallParams);
+    }
+
+    lResult =  (* GetProcAddressHashed(SP_LINEFORWARD, 9))(
+        dwRequestID,
+        (HDRVLINE)hdLine,
+        bAllAddresses,
+        dwAddressID,
+        lpForwardList,
+        dwNumRingsNoAnswer,
+        htConsultCall,
+        lphdConsultCall,
+        lpCallParams
+        );
+
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(HDRVCALL),
+		            (LPVOID)lphdConsultCall);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitModes,
+#ifdef WIN32
+    LPWSTR              lpsDigits,
+#else
+    LPSTR               lpsDigits,
+#endif
+    DWORD               dwNumDigits,
+    LPCWSTR             lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC8) + lstrlen(lpszTerminationDigits));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGatherDigits"));
+
+    WritePreHeader(dwID, SPFUNC8);
+
+    WriteLogStruct8(dwID, SP_LINEGATHERDIGITS,
+                    (DWORD)hdCall,
+                    dwEndToEndID,
+                    dwDigitModes,
+                    (DWORD)lpsDigits,
+                    dwNumDigits,
+                    (DWORD)lpszTerminationDigits,
+                    dwFirstDigitTimeout,
+                    dwInterDigitTimeout);
+
+
+    // lpsDigits?
+
+    if (lpszTerminationDigits)
+    {
+        WriteStruct(dwID, lstrlen(lpszTerminationDigits),
+                    (LPVOID)lpszTerminationDigits);
+    }
+
+    lResult =  (* GetProcAddressHashed(SP_LINEGATHERDIGITS, 8))(
+        hdCall,
+        dwEndToEndID,
+        dwDigitModes,
+        lpsDigits,
+        dwNumDigits,
+        lpszTerminationDigits,
+        dwFirstDigitTimeout,
+        dwInterDigitTimeout);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitMode,
+    LPCWSTR              lpszDigits,
+    DWORD               dwDuration
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + lstrlen(lpszDigits));
+
+    RepeaterDebugString((2,  "Entering TSPI_lineGenerateDigits"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEGENERATEDIGITS,
+                    (DWORD)hdCall,
+                    dwEndToEndID,
+                    dwDigitMode,
+                    (DWORD)lpszDigits,
+                    dwDuration);
+
+    if (lpszDigits)
+    {
+        WriteStruct(dwID, lstrlen(lpszDigits),
+                    (LPVOID)lpszDigits);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINEGENERATEDIGITS, 5))(
+        hdCall,
+        dwEndToEndID,
+        dwDigitMode,
+        lpszDigits,
+        dwDuration );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + dwNumTones * sizeof(LINEGENERATETONE));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGenerateTone"));
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_LINEGENERATETONE,
+                    (DWORD)hdCall,
+                    dwEndToEndID,
+                    dwToneMode,
+                    dwDuration,
+                    dwNumTones,
+                    (DWORD)lpTones);
+
+    WriteStruct(dwID, dwNumTones * sizeof(LINEGENERATETONE),
+                (LPVOID)lpTones);
+
+    lResult = (* GetProcAddressHashed(SP_LINEGENERATETONE, 6))(
+        hdCall,
+        dwEndToEndID,
+        dwToneMode,
+        dwDuration,
+        dwNumTones,
+        lpTones );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC5) +
+                     (lpAddressCaps ? lpAddressCaps->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetAddressCaps"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEGETADDRESSCAPS,
+                    dwDeviceID,
+                    dwAddressID,
+                    dwTSPIVersion,
+                    dwExtVersion,
+                    (DWORD)lpAddressCaps);
+
+    lResult = (* GetProcAddressHashed(SP_LINEGETADDRESSCAPS, 5))(
+        dwDeviceID,
+        dwAddressID,
+        dwTSPIVersion,
+        dwExtVersion,
+        lpAddressCaps
+        );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpAddressCaps)
+        {
+            WriteStruct(dwID, lpAddressCaps->dwUsedSize,
+                        (LPVOID)lpAddressCaps);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCWSTR              lpsAddress,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + dwSize + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetAddressID"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEGETADDRESSID,
+                    (DWORD)hdLine,
+                    (DWORD)lpdwAddressID,
+                    dwAddressMode,
+                    (DWORD)lpsAddress,
+                    dwSize);
+
+    WriteStruct(dwID, dwSize,
+                (LPVOID)lpsAddress);
+
+    lResult =
+               (* GetProcAddressHashed(SP_LINEGETADDRESSID, 5))(
+                           hdLine,
+                           lpdwAddressID,
+                           dwAddressMode,
+                           lpsAddress,
+                           dwSize
+                           );
+
+    RepeaterDebugString((2, "Leaving TSPI_lineGetAddressID"));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(DWORD),
+		            (LPVOID)lpdwAddressID);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     (lpAddressStatus ? lpAddressStatus->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetAddressStatus"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINEGETADDRESSSTATUS,
+                    (DWORD)hdLine,
+                    dwAddressID,
+                    (DWORD)lpAddressStatus);
+
+    lResult =  (* GetProcAddressHashed(SP_LINEGETADDRESSSTATUS, 3))(
+                          hdLine,
+                          dwAddressID,
+                          lpAddressStatus);
+
+    RepeaterDebugString((2, "Leaving TSPI_lineGetAddressStatus"));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpAddressStatus)
+        {
+            WriteStruct(dwID, lpAddressStatus->dwUsedSize,
+                        (LPVOID)lpAddressStatus);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwAddressID
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetCallAddressID"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEGETCALLADDRESSID,
+                    (DWORD)hdCall,
+                    (DWORD)lpdwAddressID);
+
+    lResult = (* GetProcAddressHashed(SP_LINEGETCALLADDRESSID, 2))(
+                 hdCall,
+                 lpdwAddressID
+                 );
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwAddressID);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL            hdCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC2) +
+                     (lpCallInfo? lpCallInfo->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetCallInfo"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEGETCALLINFO,
+                    (DWORD)hdCall,
+                    (DWORD)lpCallInfo);
+
+    lResult = (* GetProcAddressHashed(SP_LINEGETCALLINFO, 2))(
+        hdCall,
+        lpCallInfo
+        );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpCallInfo)
+        {
+            WriteStruct(dwID, lpCallInfo->dwUsedSize,
+                        (LPVOID)lpCallInfo);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+
+    LONG            lResult;
+    DWORD           dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC2) +
+                     (lpCallStatus ? lpCallStatus->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetCallStatus"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEGETCALLSTATUS,
+                    (DWORD)hdCall,
+                    (DWORD)lpCallStatus);
+
+
+    lResult = (* GetProcAddressHashed(SP_LINEGETCALLSTATUS, 2))(
+        hdCall,
+        lpCallStatus
+        );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpCallStatus)
+        {
+            WriteStruct(dwID, lpCallStatus->dwUsedSize,
+                        (LPVOID)lpCallStatus);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+ {
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC4) +
+                     (lpLineDevCaps ? lpLineDevCaps->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetDevCaps"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEGETDEVCAPS,
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    dwExtVersion,
+                    (DWORD)lpLineDevCaps);
+
+    lResult =
+       (* GetProcAddressHashed(SP_LINEGETDEVCAPS, 4))(
+        dwDeviceID,
+        dwTSPIVersion,
+        dwExtVersion,
+        lpLineDevCaps
+        );
+
+    DBGOUT((2, "Leaving TSPI_lineGetDevCaps retcode=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpLineDevCaps)
+        {
+            WriteStruct(dwID, lpLineDevCaps->dwUsedSize,
+                        (LPVOID)lpLineDevCaps);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCWSTR              lpszDeviceClass
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     (lpDeviceConfig ? lpDeviceConfig->dwTotalSize : 0) +
+                     lstrlen(lpszDeviceClass));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetDevConfig"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINEGETDEVCONFIG,
+                    dwDeviceID,
+                    (DWORD)lpDeviceConfig,
+                    (DWORD)lpszDeviceClass);
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+    lResult =
+       (* GetProcAddressHashed(SP_LINEGETDEVCONFIG, 3))(
+        dwDeviceID,
+        lpDeviceConfig,
+        lpszDeviceClass
+        );
+
+    DBGOUT((2, "Leaving TSPI_lineGetDevConfig retcode=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpDeviceConfig)
+        {
+            WriteStruct(dwID, lpDeviceConfig->dwUsedSize,
+                        (LPVOID)lpDeviceConfig);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+
+    LONG               lResult = 0;
+    DWORD              dwID;
+    TSPAPIPROC         lpfn;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(LINEEXTENSIONID));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetExtensionID"));
+
+    lpfn = (TSPAPIPROC)GetProcAddressHashed(SP_LINEGETEXTENSIONID, 3);
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINEGETEXTENSIONID,
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    (DWORD)lpExtensionID);
+
+    if (lpfn != (TSPAPIPROC)TSPI_LineBlank3)
+    {
+
+    lResult =
+       (* lpfn)(
+        dwDeviceID,
+        dwTSPIVersion,
+        lpExtensionID
+        );
+    }
+    else
+    {
+       RepeaterDebugString((2, "  SP does not support TSPI_lineGetExtensionID. (We'll fill in zeros.)"));
+
+       lpExtensionID->dwExtensionID0 = 0;
+       lpExtensionID->dwExtensionID1 = 0;
+       lpExtensionID->dwExtensionID2 = 0;
+       lpExtensionID->dwExtensionID3 = 0;
+    }
+
+
+
+    RepeaterDebugString((2, "Leaving TSPI_lineGetExtensionID retcode=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(LINEEXTENSIONID),
+		            (LPVOID)lpExtensionID);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCWSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     lstrlen(lpszDeviceClass) +
+                     sizeof(HICON));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetIcon"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINEGETICON,
+                    dwDeviceID,
+                    (DWORD)lpszDeviceClass,
+                    (DWORD)lphIcon);
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+    lResult =
+       (* GetProcAddressHashed(SP_LINEGETICON, 3))(
+        dwDeviceID,
+        lpszDeviceClass,
+        lphIcon
+        );
+
+    DBGOUT((2, "Leaving TSPI_lineGetIcon retcode=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(HICON),
+		            (LPVOID)lphIcon);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+               ,
+    HANDLE              hTargetProcess
+#endif
+    )
+{
+    LONG            lResult;
+    DWORD           dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC7) +
+                     lstrlen(lpszDeviceClass) +
+                     (lpDeviceID ? lpDeviceID->dwTotalSize : 0));
+
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetID"));
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+
+    WritePreHeader(dwID, SPFUNC7);
+    
+    WriteLogStruct7(dwID, SP_LINEGETID,
+                   (DWORD)hdLine,
+                   (DWORD)dwAddressID,
+                   (DWORD)hdCall,
+                   (DWORD)dwSelect,
+                   (DWORD)lpDeviceID,
+                   (DWORD)lpszDeviceClass,
+                   (DWORD)hTargetProcess);
+#else
+    WritePreHeader(dwID, SPFUNC6);
+    
+    WriteLogStruct6(dwID, SP_LINEGETID,
+                   (DWORD)hdLine,
+                   (DWORD)dwAddressID,
+                   (DWORD)hdCall,
+                   (DWORD)dwSelect,
+                   (DWORD)lpDeviceID,
+                   (DWORD)lpszDeviceClass );
+#endif
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+                
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)    
+    lResult =  (* GetProcAddressHashed(SP_LINEGETID, 7))(
+                          hdLine,
+                          dwAddressID,
+                          hdCall,
+                          dwSelect,
+                          lpDeviceID,
+                          lpszDeviceClass,
+                          hTargetProcess);
+#else
+    lResult =  (* GetProcAddressHashed(SP_LINEGETID, 6))(
+                          hdLine,
+                          dwAddressID,
+                          hdCall,
+                          dwSelect,
+                          lpDeviceID,
+                          lpszDeviceClass);
+#endif    
+
+    RepeaterDebugString((2, "Leaving TSPI_lineGetID - lResult=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        if (lpDeviceID)
+        {
+            WriteStruct(dwID, lpDeviceID->dwUsedSize,
+                        (LPVOID)lpDeviceID);
+        }
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE            hdLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC2) +
+                     (lpLineDevStatus ? lpLineDevStatus->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetLineDevStatus"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEGETLINEDEVSTATUS,
+                    (DWORD)hdLine,
+                    (DWORD)lpLineDevStatus);
+
+    lResult =  (* GetProcAddressHashed(SP_LINEGETLINEDEVSTATUS, 2))(
+                      hdLine,
+                      lpLineDevStatus);
+
+    RepeaterDebugString((2, "Leaving TSPI_lineGetLineDevStatus"));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpLineDevStatus)
+        {
+            WriteStruct(dwID, lpLineDevStatus->dwUsedSize,
+                        (LPVOID)lpLineDevStatus);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwNumAddressIDs
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_lineGetNumAddressIDs"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEGETNUMADDRESSIDS,
+                    (DWORD)hdLine,
+                    (DWORD)lpdwNumAddressIDs);
+
+    lResult =  (* GetProcAddressHashed(SP_LINEGETNUMADDRESSIDS, 2))(
+                          hdLine,
+                          lpdwNumAddressIDs );
+
+    RepeaterDebugString((2, "Leaving TSPI_lineGetNumAddressIDs - returning 0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(DWORD),
+		            (LPVOID)lpdwNumAddressIDs);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineHold"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEHOLD,
+                    dwRequestID,
+                    (DWORD)hdCall);
+
+    lResult = (* GetProcAddressHashed(SP_LINEHOLD, 2))(
+        dwRequestID,
+        hdCall
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC7) +
+                     sizeof(HDRVCALL) +
+                     lstrlen(lpszDestAddress) +
+                     (lpCallParams?lpCallParams->dwTotalSize:0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineMakeCall"));
+
+    WritePreHeader(dwID, SPFUNC7);
+
+    WriteLogStruct7(dwID, SP_LINEMAKECALL,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    (DWORD)htCall,
+                    (DWORD)lphdCall,
+                    (DWORD)lpszDestAddress,
+                    dwCountryCode,
+                    (DWORD)lpCallParams);
+
+    if (lpszDestAddress)
+    {
+        WriteStruct(dwID, lstrlen(lpszDestAddress),
+                    (LPVOID)lpszDestAddress);
+    }
+
+    if (lpCallParams)
+    {
+        WriteStruct(dwID, lpCallParams->dwTotalSize,
+                    (LPVOID)lpCallParams);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINEMAKECALL, 7))
+        (
+         dwRequestID,
+         hdLine,
+         htCall,
+         lphdCall,
+         lpszDestAddress,
+         dwCountryCode,
+         lpCallParams
+        );
+
+
+    RepeaterDebugString((2, "Leaving TSPI_lineMakeCall - returning 0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        WriteStruct(dwID, sizeof(HDRVCALL),
+                    (LPVOID)lphdCall);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwDigitModes
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineMonitorDigits"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEMONITORDIGITS,
+                    (DWORD)hdCall,
+                    dwDigitModes);
+
+    lResult =  (* GetProcAddressHashed(SP_LINEMONITORDIGITS, 2))(
+        hdCall,
+        dwDigitModes
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaModes
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineMonitorMedia"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEMONITORMEDIA,
+                    (DWORD)hdCall,
+                    dwMediaModes);
+
+    lResult = (* GetProcAddressHashed(SP_LINEMONITORMEDIA, 2))(
+        hdCall,
+        dwMediaModes
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwNumEntries * sizeof(LINEMONITORTONE));
+
+    RepeaterDebugString((2, "Entering TSPI_lineMonitorTones"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEMONITORTONES,
+                    (DWORD)hdCall,
+                    dwToneListID,
+                    (DWORD)lpToneList,
+                    dwNumEntries);
+
+    WriteStruct(dwID, sizeof(LINEMONITORTONE) * dwNumEntries,
+                (LPVOID)lpToneList);
+
+    lResult = (* GetProcAddressHashed(SP_LINEMONITORTONES, 4))(
+        hdCall,
+        dwToneListID,
+        lpToneList,
+        dwNumEntries
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_lineNegotiateExtVersion"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINENEGOTIATEEXTVERSION,
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    dwLowVersion,
+                    dwHighVersion,
+                    (DWORD)lpdwExtVersion);
+
+    lResult =
+        (* GetProcAddressHashed(SP_LINENEGOTIATEEXTVERSION, 5))(
+        dwDeviceID,
+        dwTSPIVersion,
+        dwLowVersion,
+        dwHighVersion,
+        lpdwExtVersion
+        );
+
+
+    DBGOUT((2, "Leaving TSPI_lineNegotiateExeVersion retcode=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(DWORD),
+		            (LPVOID)lpdwExtVersion);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    )
+{
+    LONG               lResult = 0;
+    DWORD              dwID;
+
+    if (!gbStarted)
+    {
+        StartMeUp();
+    }
+    
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + sizeof(DWORD));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINENEGOTIATETSPIVERSION,
+                    dwDeviceID,
+                    dwLowVersion,
+                    dwHighVersion,
+                    (DWORD)lpdwTSPIVersion);
+
+    RepeaterDebugString((2, "Entering TSPI_lineNegotiateTSPIVersion"));
+
+    /// bugbugbug!! call the *(&(^$ function
+
+    lResult = (* GetProcAddressHashed(SP_LINENEGOTIATETSPIVERSION, 4))(
+                    dwDeviceID,
+                    dwLowVersion,
+                    dwHighVersion,
+                    lpdwTSPIVersion);
+    
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(DWORD),
+		            (LPVOID)lpdwTSPIVersion);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD               dwDeviceID,
+    HTAPILINE           htLine,
+    LPHDRVLINE          lphdLine,
+    DWORD               dwTSPIVersion,
+    LINEEVENT           lpfnEventProc
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(HDRVLINE));
+
+    RepeaterDebugString((2,  "Entering TSPI_lineOpen"));
+
+    glpLineEventProc32 = lpfnEventProc;
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEOPEN,
+                    dwDeviceID,
+                    (DWORD)htLine,
+                    (DWORD)lphdLine,
+                    dwTSPIVersion,
+                    (DWORD)lpfnEventProc);
+
+    lResult =
+       (* GetProcAddressHashed(SP_LINEOPEN, 5))(
+        dwDeviceID,
+        htLine,
+        lphdLine,
+        dwTSPIVersion,
+        LineEventProc
+        );
+
+    DBGOUT((2, "Leaving TSPI_lineOpen retcode=0x%08lx", lResult));
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(HDRVLINE),
+		            (LPVOID)lphdLine);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwParkMode,
+    LPCWSTR             lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC5) +
+                     lstrlen(lpszDirAddress) +
+                     (lpNonDirAddress ? lpNonDirAddress->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_linePark"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEPARK,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    dwParkMode,
+                    (DWORD)lpszDirAddress,
+                    (DWORD)lpNonDirAddress);
+
+    if (dwParkMode & LINEPARKMODE_DIRECTED)
+    {
+        if (lpszDirAddress)
+        {
+            WriteStruct(dwID, lstrlen(lpszDirAddress),
+                        (LPVOID)lpszDirAddress);
+        }
+    }
+
+    lResult =
+       (* GetProcAddressHashed(SP_LINEPARK, 5))(
+        dwRequestID,
+        hdCall,
+        dwParkMode,
+        lpszDirAddress,
+        lpNonDirAddress);
+
+    WritePostStruct(dwID, lResult);
+
+    if ((lResult >= 0) && (dwParkMode & LINEPARKMODE_NONDIRECTED))
+    {
+        if (lpNonDirAddress)
+        {
+            WriteStruct(dwID, lpNonDirAddress->dwUsedSize,
+                        (LPVOID)lpNonDirAddress);
+        }
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress,
+    LPCWSTR             lpszGroupID
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC7) +
+                     lstrlen(lpszDestAddress) +
+                     lstrlen(lpszGroupID) +
+                     sizeof(HDRVCALL));
+
+    RepeaterDebugString((2, "Entering TSPI_linePickup"));
+
+    WritePreHeader(dwID, SPFUNC7);
+
+    WriteLogStruct7(dwID, SP_LINEPICKUP,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    (DWORD)dwAddressID,
+                    (DWORD)htCall,
+                    (DWORD)lphdCall,
+                    (DWORD)lpszDestAddress,
+                    (DWORD)lpszGroupID);
+
+    if (lpszDestAddress)
+    {
+        WriteStruct(dwID, lstrlen(lpszDestAddress),
+                    (LPVOID)lpszDestAddress);
+    }
+
+    if (lpszGroupID)
+    {
+        WriteStruct(dwID, lstrlen(lpszGroupID),
+                    (LPVOID)lpszGroupID);
+    }
+
+   lResult =
+       (* GetProcAddressHashed(SP_LINEPICKUP, 7))(
+        dwRequestID,
+        hdLine,
+        dwAddressID,
+        htCall,
+        lphdCall,
+        lpszDestAddress,
+        lpszGroupID);
+ 
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        WriteStruct(dwID, sizeof(HDRVCALL),
+                    (LPVOID)lphdCall);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC5) +
+                     (lpCallParams?lpCallParams->dwTotalSize:0) +
+                     sizeof(HDRVCALL));
+
+    RepeaterDebugString((2, "Entering TSPI_linePrepareAddToConference"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINEPREPAREADDTOCONFERENCE,
+                    dwRequestID,
+                    (DWORD)hdConfCall,
+                    (DWORD)htConsultCall,
+                    (DWORD)lphdConsultCall,
+                    (DWORD)lpCallParams);
+
+    if (lpCallParams)
+    {
+        WriteStruct(dwID, lpCallParams->dwTotalSize,
+                    (LPVOID)lpCallParams);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINEPREPAREADDTOCONFERENCE,
+                                      5))(
+                    dwRequestID,
+                    hdConfCall,
+                    htConsultCall,
+                    lphdConsultCall,
+                    lpCallParams);
+
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        WriteStruct(dwID, sizeof(HDRVCALL),
+                    (LPVOID)lphdConsultCall);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCWSTR             lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC4) +
+                     lstrlen(lpszDestAddress));
+
+    RepeaterDebugString((2, "Entering TSPI_lineRedirect"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINEREDIRECT,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpszDestAddress,
+                    dwCountryCode);
+
+    if (lpszDestAddress)
+    {
+        WriteStruct(dwID, lstrlen(lpszDestAddress),
+                    (LPVOID)lpszDestAddress);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINEREDIRECT,
+                                      4))(
+                    dwRequestID,
+                    hdCall,
+                    lpszDestAddress,
+                    dwCountryCode);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+{
+    LONG               lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+    
+    RepeaterDebugString((2, "Entering TSPI_lineRemoveFromConference"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEREMOVEFROMCONFERENCE,
+                    dwRequestID,
+                    (DWORD)hdCall);
+
+    lResult = (* GetProcAddressHashed(SP_LINEREMOVEFROMCONFERENCE,
+                                      2))(
+                    dwRequestID,
+                    hdCall);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+    
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSecureCall"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINESECURECALL,
+                    dwRequestID,
+                    (DWORD)hdCall);
+
+    lResult = (* GetProcAddressHashed(SP_LINESECURECALL,
+                                      2))(
+                    dwRequestID,
+                    hdCall);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE            hdLine,
+    DWORD               dwExtVersion
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSelectExtVersion"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINESELECTEXTVERSION,
+                    (DWORD)hdLine,
+                    (DWORD)dwExtVersion);
+
+    lResult = (* GetProcAddressHashed(SP_LINESELECTEXTVERSION,
+                                      2))(
+                    hdLine,
+                    dwExtVersion);
+                                      
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_lineSendUserUserInfo"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINESENDUSERUSERINFO,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)lpsUserUserInfo,
+                    dwSize);
+
+    if (lpsUserUserInfo)
+    {
+        WriteStruct(dwID, dwSize,
+                    (LPVOID)lpsUserUserInfo);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINESENDUSERUSERINFO,
+                                      4))(
+                    dwRequestID,
+                    hdCall,
+                    lpsUserUserInfo,
+                    dwSize);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL            hdCall,
+    DWORD               dwAppSpecific
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetAppSpecific"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINESETAPPSPECIFIC,
+                    (DWORD)hdCall,
+                    dwAppSpecific);
+
+    lResult = (* GetProcAddressHashed(SP_LINESETAPPSPECIFIC, 2))(
+        hdCall,
+        dwAppSpecific
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + sizeof(LINEDIALPARAMS));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetCallParams"));
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_LINESETCALLPARAMS,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    dwBearerMode,
+                    dwMinRate,
+                    dwMaxRate,
+                    (DWORD)lpDialParams);
+
+    if (lpDialParams)
+    {
+        WriteStruct(dwID, sizeof(LINEDIALPARAMS),
+                    (LPVOID)lpDialParams);
+    }
+
+    lResult =  (* GetProcAddressHashed(SP_LINESETCALLPARAMS, 6))(
+        dwRequestID,
+        hdCall,
+        dwBearerMode,
+        dwMinRate,
+        dwMaxRate,
+        lpDialParams
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetCurrentLocation(
+    DWORD               dwLocation
+    )
+{
+    LONG        lResult;
+    DWORD              dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetCurrentLocation"));
+
+    WritePreHeader(dwID, SPFUNC1);
+
+    WriteLogStruct1(dwID, SP_LINESETCURRENTLOCATION,
+                    dwLocation);
+
+    lResult = (* GetProcAddressHashed(SP_LINESETCURRENTLOCATION, 1))
+                  (dwLocation);
+    
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetDefaultMediaDetection"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINESETDEFAULTMEDIADETECTION,
+                    (DWORD)hdLine,
+                    dwMediaModes);
+
+    lResult = (* GetProcAddressHashed(
+            SP_LINESETDEFAULTMEDIADETECTION,
+            2
+            ))(hdLine, dwMediaModes);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCWSTR              lpszDeviceClass
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC4) +
+                     dwSize +
+                     lstrlen(lpszDeviceClass));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetDevConfig"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_LINESETDEVCONFIG,
+                    (DWORD)dwDeviceID,
+                    (DWORD)lpDeviceConfig,
+                    dwSize,
+                    (DWORD)lpszDeviceClass);
+
+    if (lpDeviceConfig)
+    {
+        WriteStruct(dwID, dwSize,
+                    (LPVOID)lpDeviceConfig);
+    }
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINESETDEVCONFIG, 4))(
+        dwDeviceID,
+        lpDeviceConfig,
+        dwSize,
+        lpszDeviceClass
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    )
+{
+    LONG            lResult;
+    DWORD           dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC12) +
+                     sizeof(LINEMEDIACONTROLDIGIT) * dwDigitNumEntries +
+                     sizeof(LINEMEDIACONTROLMEDIA) * dwMediaNumEntries +
+                     sizeof(LINEMEDIACONTROLTONE) * dwToneNumEntries +
+                     sizeof(LINEMEDIACONTROLCALLSTATE) * dwCallStateNumEntries);
+
+    
+    RepeaterDebugString((2, "Entering TSPI_lineSetMediaControl"));
+
+    WritePreHeader(dwID, SPFUNC12);
+
+    WriteLogStruct12(dwID, SP_LINESETMEDIACONTROL,
+                     (DWORD)hdLine,
+                     dwAddressID,
+                     (DWORD)hdCall,
+                     dwSelect,
+                     (DWORD)lpDigitList,
+                     dwDigitNumEntries,
+                     (DWORD)lpMediaList,
+                     dwMediaNumEntries,
+                     (DWORD)lpToneList,
+                     dwToneNumEntries,
+                     (DWORD)lpCallStateList,
+                     dwCallStateNumEntries);
+
+    if (lpDigitList)
+    {
+        WriteStruct(dwID, sizeof(LINEMEDIACONTROLDIGIT) * dwDigitNumEntries,
+                    (LPVOID)lpDigitList);
+    }
+
+    if (lpMediaList)
+    {
+        WriteStruct(dwID, sizeof(LINEMEDIACONTROLMEDIA) * dwMediaNumEntries,
+                    (LPVOID)lpMediaList);
+    }
+
+    if (lpToneList)
+    {
+        WriteStruct(dwID, sizeof(LINEMEDIACONTROLTONE) * dwToneNumEntries,
+                    (LPVOID)lpToneList);
+    }
+
+    if (lpCallStateList)
+    {
+        WriteStruct(dwID, sizeof(LINEMEDIACONTROLCALLSTATE) * dwCallStateNumEntries,
+                    (LPVOID)lpCallStateList);
+    }
+    
+    lResult = (* GetProcAddressHashed(SP_LINESETMEDIACONTROL,
+                                      12))
+              (hdLine,
+               dwAddressID,
+               hdCall,
+               dwSelect,
+               lpDigitList,
+               dwDigitNumEntries,
+               lpMediaList,
+               dwMediaNumEntries,
+               lpToneList,
+               dwToneNumEntries,
+               lpCallStateList,
+               dwCallStateNumEntries);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaMode
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetMediaMode"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINESETMEDIAMODE,
+                    (DWORD)hdCall,
+                    dwMediaMode);
+
+    lResult = (* GetProcAddressHashed(SP_LINESETMEDIAMODE, 2))(
+        hdCall,
+        dwMediaMode
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE            hdLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetStatusMessages"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINESETSTATUSMESSAGES,
+                    (DWORD)hdLine,
+                    dwLineStates,
+                    dwAddressStates);
+
+    lResult = (* GetProcAddressHashed(SP_LINESETSTATUSMESSAGES, 3))(
+        hdLine,
+        dwLineStates,
+        dwAddressStates
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC8));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetTerminal"));
+
+    WritePreHeader(dwID, SPFUNC8);
+
+    WriteLogStruct8(dwID, SP_LINESETTERMINAL,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    dwAddressID,
+                    (DWORD)hdCall,
+                    dwSelect,
+                    dwTerminalModes,
+                    dwTerminalID,
+                    bEnable);
+
+    lResult = (* GetProcAddressHashed(SP_LINESETTERMINAL,
+                                      8))(
+                    dwRequestID,
+                    hdLine,
+                    dwAddressID,
+                    hdCall,
+                    dwSelect,
+                    dwTerminalModes,
+                    dwTerminalID,
+                    bEnable);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC9) +
+                     sizeof(HDRVCALL) +
+                     sizeof(HDRVCALL));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetupConference"));
+
+    WritePreHeader(dwID, SPFUNC9);
+
+    WriteLogStruct9(dwID, SP_LINESETUPCONFERENCE,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)hdLine,
+                    (DWORD)htConfCall,
+                    (DWORD)lphdConfCall,
+                    (DWORD)htConsultCall,
+                    (DWORD)lphdConsultCall,
+                    dwNumParties,
+                    (DWORD)lpCallParams);
+
+    lResult = (* GetProcAddressHashed(SP_LINESETUPCONFERENCE,
+                                      9))(
+                    dwRequestID,
+                    hdCall,
+                    hdLine,
+                    htConfCall,
+                    lphdConfCall,
+                    htConsultCall,
+                    lphdConsultCall,
+                    dwNumParties,
+                    lpCallParams);
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(HDRVCALL),
+		            (LPVOID)lphdConfCall);
+
+	    WriteStruct(dwID, sizeof(HDRVCALL),
+		            (LPVOID)lphdConsultCall);
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC5) +
+                     sizeof(HDRVCALL) +
+                     (lpCallParams ? lpCallParams->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSetupTransfer"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_LINESETUPTRANSFER,
+                    dwRequestID,
+                    (DWORD)hdCall,
+                    (DWORD)htConsultCall,
+                    (DWORD)lphdConsultCall,
+                    (DWORD)lpCallParams);
+
+    if (lpCallParams)
+    {
+        WriteStruct(dwID, lpCallParams->dwTotalSize,
+                    (LPVOID)lpCallParams);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_LINESETUPTRANSFER,
+                                      5))(
+                    dwRequestID,
+                    hdCall,
+                    htConsultCall,
+                    lphdConsultCall,
+                    lpCallParams);
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        WriteStruct(dwID, sizeof(HDRVCALL),
+                    (LPVOID)lphdConsultCall);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdActiveCall,
+    HDRVCALL            hdHeldCall
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3));
+
+    RepeaterDebugString((2, "Entering TSPI_lineSwapHold"));
+
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINESWAPHOLD,
+                    dwRequestID,
+                    (DWORD)hdActiveCall,
+                    (DWORD)hdHeldCall);
+
+
+    lResult = (* GetProcAddressHashed(SP_LINESWAPHOLD,
+                                      3))(
+                    dwRequestID,
+                    hdActiveCall,
+                    hdHeldCall);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwCompletionID
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3));
+
+    RepeaterDebugString((2, "Entering TSPI_lineUncompleteCall"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_LINEUNCOMPLETECALL,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    dwCompletionID);
+
+    lResult = (* GetProcAddressHashed(SP_LINEUNCOMPLETECALL,
+                                      3))(
+                    dwRequestID,
+                    hdLine,
+                    dwCompletionID);
+
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineUnhold"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINEUNHOLD,
+                    dwRequestID,
+                    (DWORD)hdCall);
+
+    lResult = (* GetProcAddressHashed(SP_LINEUNHOLD,
+                                      2))(
+                    dwRequestID,
+                    hdCall);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCWSTR             lpszDestAddress
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC6) +
+                     lstrlen(lpszDestAddress) +
+                     sizeof(HDRVCALL));
+
+    RepeaterDebugString((2, "Entering TSPI_lineUnpark"));
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_LINEUNPARK,
+                    dwRequestID,
+                    (DWORD)hdLine,
+                    dwAddressID,
+                    (DWORD)htCall,
+                    (DWORD)lphdCall,
+                    (DWORD)lpszDestAddress);
+
+    if (lpszDestAddress)
+    {
+        WriteStruct(dwID, lstrlen(lpszDestAddress),
+                    (LPVOID)lpszDestAddress);
+    }
+
+    lResult= (* GetProcAddressHashed(SP_LINEUNPARK,
+                                     6))(
+                    dwRequestID,
+                    hdLine,
+                    dwAddressID,
+                    htCall,
+                    lphdCall,
+                    lpszDestAddress);
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >= 0)
+    {
+        WriteStruct(dwID, sizeof(HDRVCALL),
+                    (LPVOID)lphdCall);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+LONG
+TSPIAPI
+TSPI_lineReleaseUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_lineReleaseUserUserInfo"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_LINERELEASEUSERUSERINFO,
+                    (DWORD)dwRequestID,
+                    (DWORD)hdCall);
+    
+    lResult = (* GetProcAddressHashed(SP_LINERELEASEUSERUSERINFO,
+                                      2))(
+                    dwRequestID,
+                    hdCall);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+
+//
+// ----------------------- TSPIAPI TSPI_phone functions -----------------------
+//
+
+LONG
+TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE           hdPhone
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneClose"));
+
+    WritePreHeader(dwID, SPFUNC1);
+
+    WriteLogStruct1(dwID, SP_PHONECLOSE,
+                   (DWORD)hdPhone);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONECLOSE, 1))(
+                           hdPhone
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneClose - lResult=0x%08lx", lResult));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneConfigDialog(
+    DWORD                   dwDeviceID,
+    HWND                    hwndOwner,
+    LPCWSTR                 lpszDeviceClass
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     lstrlen(lpszDeviceClass));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONECONFIGDIALOG,
+                   dwDeviceID,
+#ifdef WIN32
+                   (DWORD)hwndOwner,
+#else
+                   (DWORD)MAKELONG(hwndOwner, 0),
+#endif
+                   (DWORD)lpszDeviceClass);
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_PHONECONFIGDIALOG, 3))(
+                    dwDeviceID,
+                    hwndOwner,
+                    lpszDeviceClass);
+    
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_phoneDevSpecific"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONEDEVSPECIFIC,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    (DWORD)lpParams,
+                    (DWORD)dwSize);
+
+    if (lpParams)
+    {
+        WriteStruct(dwID, dwSize,
+                    (LPVOID)lpParams);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_PHONEDEVSPECIFIC,
+                                      4))(
+                    dwRequestID,
+                    hdPhone,
+                    lpParams,
+                    dwSize);
+    
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     (lpButtonInfo ? lpButtonInfo->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetButtonInfo"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETBUTTONINFO,
+                    (DWORD)hdPhone,
+                    dwButtonLampID,
+                    (DWORD)lpButtonInfo);
+
+    lResult = (* GetProcAddressHashed(SP_PHONEGETBUTTONINFO,
+                                      3))(
+                    hdPhone,
+                    dwButtonLampID,
+                    lpButtonInfo);
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpButtonInfo)
+        {
+            WriteStruct(dwID, lpButtonInfo->dwUsedSize,
+                        (LPVOID)lpButtonInfo);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetData"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONEGETDATA,
+                    (DWORD)hdPhone,
+                    (DWORD)dwDataID,
+                    (DWORD)lpData,
+                    dwSize);
+
+    lResult = (* GetProcAddressHashed(SP_PHONEGETDATA,
+                                      4))(
+                    hdPhone,
+                    dwDataID,
+                    lpData,
+                    dwSize);
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpData)
+        {
+            WriteStruct(dwID, dwSize,
+                        lpData);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC4) +
+                     (lpPhoneCaps ? lpPhoneCaps->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetDevCaps"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONEGETDEVCAPS,
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    dwExtVersion,
+                    (DWORD)lpPhoneCaps);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETDEVCAPS, 4))(
+                           dwDeviceID,
+                           dwTSPIVersion,
+                           dwExtVersion,
+                           lpPhoneCaps
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpPhoneCaps)
+        {            
+            WriteStruct(dwID, lpPhoneCaps->dwUsedSize,
+                        (LPVOID)lpPhoneCaps);
+        }
+	}
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetDevCaps"));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDisplay
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC2) +
+                     (lpDisplay ? lpDisplay->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetDisplay"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_PHONEGETDISPLAY,
+                    (DWORD)hdPhone,
+                    (DWORD)lpDisplay);
+
+    lResult = (* GetProcAddressHashed(SP_PHONEGETDISPLAY,
+                                      2))(
+                    hdPhone,
+                    lpDisplay);
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpDisplay)
+        {
+            WriteStruct(dwID, lpDisplay->dwUsedSize,
+                        (LPVOID)lpDisplay);
+        }
+	}
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+    TSPAPIPROC          lpfn;
+    
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(PHONEEXTENSIONID));
+
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetExtensionID"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETEXTENSIONID,
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    (DWORD)lpExtensionID);
+
+
+    lpfn = GetProcAddressHashed(SP_PHONEGETEXTENSIONID, 3);
+
+    //
+    // Does this service provider export this function?
+    //
+    if (lpfn != (TSPAPIPROC)TSPI_PhoneBlank3)
+    {
+        lResult =  (* lpfn)(
+                           dwDeviceID,
+                           dwTSPIVersion,
+                           lpExtensionID
+                           );
+    }
+    else
+    {
+       //
+       // Nope. Fill it fulla rocks.
+       //
+       RepeaterDebugString((2, "  SP# does not support TSPI_phoneGetExtensionID. (We'll zero it)"));
+
+       lpExtensionID->dwExtensionID0 = 0;
+       lpExtensionID->dwExtensionID1 = 0;
+       lpExtensionID->dwExtensionID2 = 0;
+       lpExtensionID->dwExtensionID3 = 0;
+
+       lResult = 0;
+    }
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+        if (lpExtensionID)
+        {
+            WriteStruct(dwID, sizeof(PHONEEXTENSIONID),
+                        (LPVOID)lpExtensionID);
+        }
+	}
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetExtensionID - lResult=0x%08lx",lResult));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetGain"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETGAIN,
+                    (DWORD)hdPhone,
+                    dwHookSwitchDev,
+                    (DWORD)lpdwGain);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETGAIN, 3))(
+                           hdPhone,
+                           dwHookSwitchDev,
+                           lpdwGain
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(DWORD),
+		            (LPVOID)lpdwGain);
+	}
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetGain"));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetHookSwitch"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_PHONEGETHOOKSWITCH,
+                   (DWORD)hdPhone,
+                   (DWORD)lpdwHookSwitchDevs);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETHOOKSWITCH, 2))(
+                           hdPhone,
+                           lpdwHookSwitchDevs
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(DWORD),
+		            (LPVOID)lpdwHookSwitchDevs);
+	}
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetHoosSwitch"));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCWSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC3) +
+                     sizeof(HICON) +
+                     lstrlen(lpszDeviceClass));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetIcon"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETICON,
+                    dwDeviceID,
+                    (DWORD)lpszDeviceClass,
+                    (DWORD)lphIcon);
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETICON, 3))(
+                           dwDeviceID,
+                           lpszDeviceClass,
+                           lphIcon
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+	if (lResult >= 0)
+	{
+	    WriteStruct(dwID, sizeof(HICON),
+		            (LPVOID)lphIcon);
+	}
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetIcon"));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCWSTR             lpszDeviceClass
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+                ,
+    HANDLE              hTargetProcess
+#endif
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC4) +
+                     lstrlen(lpszDeviceClass) +
+                     (lpDeviceID ? lpDeviceID->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetID"));
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONEGETID,
+                    (DWORD)hdPhone,
+                    (DWORD)lpDeviceID,
+                    (DWORD)lpszDeviceClass,
+                    (DWORD)hTargetProcess
+                   );
+#else
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETID,
+                    (DWORD)hdPhone,
+                    (DWORD)lpDeviceID,
+                    (DWORD)lpszDeviceClass
+                   );
+#endif    
+    
+
+    if (lpszDeviceClass)
+    {
+        WriteStruct(dwID, lstrlen(lpszDeviceClass),
+                    (LPVOID)lpszDeviceClass);
+    }
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETID, 4))(
+                           hdPhone,
+                           lpDeviceID,
+                           lpszDeviceClass,
+                           hTargetProcess
+                           );
+#else
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETID, 3))(
+                           hdPhone,
+                           lpDeviceID,
+                           lpszDeviceClass
+                           );
+#endif
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        if (lpDeviceID)
+        {
+            WriteStruct(dwID, lpDeviceID->dwUsedSize,
+                        (LPVOID)lpDeviceID);
+        }
+    }
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetID - lResult=0x%08lx",
+                            lResult));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    )
+{
+
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetLamp"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETLAMP,
+                    (DWORD)hdPhone,
+                    dwButtonLampID,
+                    (DWORD)lpdwLampMode);
+
+    lResult = (* GetProcAddressHashed(SP_PHONEGETLAMP,
+                                3))(
+                    hdPhone,
+                    dwButtonLampID,
+                    lpdwLampMode);
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwLampMode);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetRing"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETRING,
+                    (DWORD)hdPhone,
+                    (DWORD)lpdwRingMode,
+                    (DWORD)lpdwVolume);
+
+    lResult = (* GetProcAddressHashed(SP_PHONEGETRING,
+                                3))(
+                    hdPhone,
+                    lpdwRingMode,
+                    lpdwVolume);
+    
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwRingMode);
+
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwVolume);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE           hdPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK +
+                     sizeof(LOGSPFUNC2) +
+                     (lpPhoneStatus ? lpPhoneStatus->dwTotalSize : 0));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetStatus"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_PHONEGETSTATUS,
+                   (DWORD)hdPhone,
+                   (DWORD)lpPhoneStatus);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETSTATUS, 2))(
+                           hdPhone,
+                           lpPhoneStatus
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        if (lpPhoneStatus)
+        {
+            WriteStruct(dwID, lpPhoneStatus->dwUsedSize,
+                        (LPVOID)lpPhoneStatus);
+        }
+    }
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetStatus - lResult=0x%08lx",
+                            lResult));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneGetVolume"));
+
+    WritePreHeader(dwID, SPFUNC3);
+
+    WriteLogStruct3(dwID, SP_PHONEGETVOLUME,
+                    (DWORD)hdPhone,
+                    dwHookSwitchDev,
+                    (DWORD)lpdwVolume);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONEGETVOLUME, 3))(
+                           hdPhone,
+                           dwHookSwitchDev,
+                           lpdwVolume
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwVolume);
+    }
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneGetVolume - lResult=0x%08lx",
+                            lResult));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+    TSPAPIPROC          lpfn;
+
+    
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneNegotiateExtVersion"));
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_PHONENEGOTIATEEXTVERSION,
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    dwLowVersion,
+                    dwHighVersion,
+                    (DWORD)lpdwExtVersion);
+
+    lpfn = GetProcAddressHashed(SP_PHONENEGOTIATEEXTVERSION,
+                                5);
+
+    if (lpfn)
+    {
+        lResult = (*lpfn)(
+                    dwDeviceID,
+                    dwTSPIVersion,
+                    dwLowVersion,
+                    dwHighVersion,
+                    lpdwExtVersion);
+    }
+    else
+    {
+        lResult = PHONEERR_OPERATIONUNAVAIL;
+    }
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwExtVersion);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + sizeof(DWORD));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneNegotiateTSPIVersion"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONENEGOTIATETSPIVERSION,
+                    dwDeviceID,
+                    dwLowVersion,
+                    dwHighVersion,
+                    (DWORD)lpdwTSPIVersion);
+
+    lResult = (* GetProcAddressHashed(SP_PHONENEGOTIATETSPIVERSION, 4))(
+        dwDeviceID,
+        dwLowVersion,
+        dwHighVersion,
+        lpdwTSPIVersion);
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        WriteStruct(dwID, sizeof(DWORD),
+                    (LPVOID)lpdwTSPIVersion);
+    }
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneOpen(
+    DWORD               dwDeviceID,
+    HTAPIPHONE          htPhone,
+    LPHDRVPHONE         lphdPhone,
+    DWORD               dwTSPIVersion,
+    PHONEEVENT          lpfnEventProc
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(HDRVPHONE));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneOpen"));
+
+    glpPhoneEventProc32 = lpfnEventProc;
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    WriteLogStruct5(dwID, SP_PHONEOPEN,
+                    dwDeviceID,
+                    (DWORD)htPhone,
+                    (DWORD)lphdPhone,
+                    dwTSPIVersion,
+                    (DWORD)PhoneEventProc);
+    lResult =
+    (* GetProcAddressHashed(SP_PHONEOPEN, 5))(
+        dwDeviceID,
+        htPhone,
+        lphdPhone,
+        dwTSPIVersion,
+        PhoneEventProc
+        );
+
+    WritePostStruct(dwID, lResult);
+
+    if (lResult >=0)
+    {
+        WriteStruct(dwID, sizeof(HDRVPHONE),
+                    (LPVOID)lphdPhone);
+    }
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneOpen - lResult=0x%08lx", lResult));
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE           hdPhone,
+    DWORD               dwExtVersion
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSelectExtVersion"));
+
+    WritePreHeader(dwID, SPFUNC2);
+
+    WriteLogStruct2(dwID, SP_PHONESELECTEXTVERSION,
+                   (DWORD)hdPhone,
+                   dwExtVersion);
+
+    lResult = (* GetProcAddressHashed(SP_PHONESELECTEXTVERSION,
+                                      2))(
+                    hdPhone,
+                    dwExtVersion);
+            
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetButtonInfo"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETBUTTONINFO,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    dwButtonLampID,
+                    (DWORD)lpButtonInfo);
+
+    lResult = (* GetProcAddressHashed(SP_PHONESETBUTTONINFO,
+                                      4))(
+                    dwRequestID,
+                    hdPhone,
+                    dwButtonLampID,
+                    lpButtonInfo);
+                    
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + dwSize);
+
+    WritePreHeader(dwID, SPFUNC5);
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetData"));
+
+    WriteLogStruct5(dwID, SP_PHONESETDATA,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    dwDataID,
+                    (DWORD)lpData,
+                    dwSize);
+
+    if (lpData)
+    {
+        WriteStruct(dwID,
+                    dwSize,
+                    (LPVOID)lpData);
+    }
+
+    lResult = (* GetProcAddressHashed(SP_PHONESETDATA,
+                                      5))(
+                    dwRequestID,
+                    hdPhone,
+                    dwDataID,
+                    lpData,
+                    dwSize);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCWSTR             lpsDisplay,
+    DWORD               dwSize
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + dwSize);
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetDisplay"));
+
+    WritePreHeader(dwID, SPFUNC6);
+
+    WriteLogStruct6(dwID, SP_PHONESETDISPLAY,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    dwRow,
+                    dwColumn,
+                    (DWORD)lpsDisplay,
+                    dwSize);
+
+    if (lpsDisplay)
+    {
+        WriteStruct(dwID,
+                    dwSize,
+                    (LPVOID)lpsDisplay);
+    }
+    
+    lResult = (* GetProcAddressHashed(SP_PHONESETDISPLAY,
+                                      6))(
+                    dwRequestID,
+                    hdPhone,
+                    dwRow,
+                    dwColumn,
+                    lpsDisplay,
+                    dwSize);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetGain"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETGAIN,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    dwHookSwitchDev,
+                    dwGain);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONESETGAIN, 4))(
+                           dwRequestID,
+                           hdPhone,
+                           dwHookSwitchDev,
+                           dwGain
+                           );
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneSetGain - lResult=0x%08lx",
+                            lResult));
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetHookSwitch"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETHOOKSWITCH,
+                   dwRequestID,
+                   (DWORD)hdPhone,
+                   dwHookSwitchDevs,
+                   dwHookSwitchMode);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONESETHOOKSWITCH, 4))(
+                           dwRequestID,
+                           hdPhone,
+                           dwHookSwitchDevs,
+                           dwHookSwitchMode
+                           );
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneSetHookSwitch - lResult=0x%08lx",
+                            lResult));
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetLamp"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETLAMP,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    (DWORD)dwButtonLampID,
+                    dwLampMode);
+
+    lResult = (* GetProcAddressHashed(SP_PHONESETLAMP,
+                                      4))(
+                    dwRequestID,
+                    hdPhone,
+                    dwButtonLampID,
+                    dwLampMode);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetRing"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETRING,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    dwRingMode,
+                    dwVolume);
+
+    lResult = (* GetProcAddressHashed(SP_PHONESETRING,
+                                      4))(
+                    dwRequestID,
+                    hdPhone,
+                    dwRingMode,
+                    dwVolume);
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE           hdPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    )
+{
+    LONG                    lResult;
+    DWORD                   dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetStatusMessages"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETSTATUSMESSAGES,
+                    (DWORD)hdPhone,
+                    dwPhoneStates,
+                    dwButtonModes,
+                    dwButtonStates);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONESETSTATUSMESSAGES, 4))(
+                           hdPhone,
+                           dwPhoneStates,
+                           dwButtonModes,
+                           dwButtonStates
+                           );
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneSetStatusMessages"));
+
+    WritePostStruct(dwID, lResult);
+
+    ReleaseID(dwID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    )
+{
+    LONG                lResult;
+    DWORD               dwID;
+
+    GetChunkID(&dwID);
+    AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4));
+
+    RepeaterDebugString((2, "Entering TSPI_phoneSetVolume"));
+
+    WritePreHeader(dwID, SPFUNC4);
+
+    WriteLogStruct4(dwID, SP_PHONESETVOLUME,
+                    dwRequestID,
+                    (DWORD)hdPhone,
+                    dwHookSwitchDev,
+                    dwVolume);
+
+    lResult =  (* GetProcAddressHashed(SP_PHONESETVOLUME, 4))(
+                           dwRequestID,
+                           hdPhone,
+                           dwHookSwitchDev,
+                           dwVolume
+                           );
+
+    WritePostStruct(dwID, lResult);
+
+    RepeaterDebugString((2, "Leaving TSPI_phoneSetVolume - lResult=0x%08lx",
+                            lResult));
+
+    ReleaseID(dwID);
+    
+    return lResult;
+}
+
+
+
+
+//
+// ----------------------- TSPIAPI TSPI_provider functions --------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    LONG lResult;
+
+    lResult = (* GetProcAddressHashed(SP_PROVIDERCONFIG, 2))
+                    (hwndOwner,
+                     dwPermanentProviderID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+                  ,
+    LPDWORD             lpdwTSPIOptions
+#endif
+    )
+{
+    LONG lResult;
+
+    if (!gbStarted)
+    {
+        StartMeUp();
+    }
+
+    RepeaterDebugString((2, "Entering TSPI_providerInit"));
+
+    glpAsyncCompletionProc32 = lpfnCompletionProc;
+
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)        
+        lResult = (* GetProcAddressHashed(SP_PROVIDERINIT, 8))
+            (
+            dwTSPIVersion,
+            dwPermanentProviderID,
+            dwLineDeviceIDBase,
+            dwPhoneDeviceIDBase,
+            dwNumLines,
+            dwNumPhones,
+            AsyncCompletionProc,
+            lpdwTSPIOptions
+            );
+#else
+        lResult = (* GetProcAddressHashed( SP_PROVIDERINIT, 7))
+            (
+            dwTSPIVersion,
+            dwPermanentProvider,
+            dwLineDeviceIDBase,
+            dwPhoneDeviceIDBase,
+            dwNumLines,
+            dwNumPhones,
+            AsyncCompletionProc
+            );
+#endif        
+        
+    DBGOUT((1, "leaving provider init"));
+    
+    return lResult;
+}
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+{
+    return 0;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+    DWORD               dwTSPIVersion
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+                      ,
+    DWORD               dwPermanentProviderID
+#endif
+    )
+{
+    RepeaterDebugString((2, "Entering TSPI_providerShutdown"));
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+        (* GetProcAddressHashed(SP_PROVIDERSHUTDOWN, 2))(
+            dwTSPIVersion,
+            dwPermanentProviderID
+            );
+#else
+        (* GetProcAddressHashed(SP_PROVIDERSHUTDOWN, 1))(
+            dwTSPIVersion
+            );
+#endif
+
+//        FreeLibrary(hProvider);
+
+//        MYFREE(lpfnProcAddress);
+        
+    return(ERR_NONE);
+}
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD               dwPermanentProviderID,
+    LPDWORD             lpdwNumLines,
+    LPDWORD             lpdwNumPhones,
+    HPROVIDER           hProvider,
+    LINEEVENT           lpfnLineCreateProc,
+    PHONEEVENT          lpfnPhoneCreateProc
+    )
+{
+    TSPAPIPROC  lpfn;
+
+    if (!gbStarted)
+    {
+        StartMeUp();
+    }
+
+    RepeaterDebugString((2, "Entering TSPI_providerEnumDevices"));
+
+
+    glpLineEventProc32 = lpfnLineCreateProc;
+    glpPhoneEventProc32 = lpfnPhoneCreateProc;
+
+//    InitializeSPs();
+
+    lpfn = GetProcAddressHashed(SP_PROVIDERENUMDEVICES, 6);
+
+    if (lpfn != (TSPAPIPROC)TSPI_LineBlank6)
+    {
+       DBGOUT((1, "calling providerenumdevices"));
+                       
+       (* lpfn)(
+               dwPermanentProvider,
+               &dwNumLines,
+               &dwNumPhones,
+               hProvider,
+               LineEventProc,
+               PhoneEventProc
+               );
+
+       *lpdwNumLines = dwNumLines;
+       *lpdwNumPhones = dwNumPhones;
+     }
+     else
+     {
+         DBGOUT((1, "failed to get entry"));
+     }
+
+     DBGOUT((2, " TSPI_providerEnumDevices: #lines= %d  #phones= %d",
+            *lpdwNumLines,
+            *lpdwNumPhones));
+
+    return(ERR_NONE);
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreateLineDevice(
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    )
+{
+    LONG            lResult;
+
+    lResult =  (* GetProcAddressHashed(SP_PROVIDERCREATELINEDEVICE, 2))(
+                        dwTempID,
+                        dwDeviceID);
+
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerCreatePhoneDevice(
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    )
+{
+    LONG            lResult;
+
+    lResult =  (* GetProcAddressHashed(SP_PROVIDERCREATEPHONEDEVICE, 2))(
+                        dwTempID,
+                        dwDeviceID);
+
+    return lResult;
+    
+}
+
+#if (TAPI_CURRENT_VERSION >= 0x00020000)
+
+LONG
+TSPIAPI
+TSPI_providerFreeDialogInstance(
+    HDRVDIALOGINSTANCE  hdDlgInst
+    )
+{
+   LONG lResult;
+
+   RepeaterDebugString((2, "Entering TSPI_providerFreeDialogInstance"));
+
+
+   lResult =  (* GetProcAddressHashed(SP_PROVIDERFREEDIALOGINSTANCE,1))(
+                             hdDlgInst);
+
+   return lResult;
+}
+
+
+
+LONG
+TSPIAPI
+TSPI_providerGenericDialogData(
+    DWORD               dwObjectID,
+    DWORD               dwObjectType,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+{
+   LONG lResult;
+
+   RepeaterDebugString((2, "Entering TSPI_providerGenericDialogData"));
+
+   lResult =  (* GetProcAddressHashed(SP_PROVIDERGENERICDIALOGDATA, 4))(
+                             dwObjectID,
+                             dwObjectType,
+                             lpParams,
+                             dwSize);
+
+   return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_providerUIIdentify(
+    LPWSTR              lpszUIDLLName
+    )
+{
+   LONG lResult;
+
+   RepeaterDebugString((2, "Entering TSPI_providerUIIdentify"));
+
+   lResult =  (* GetProcAddressHashed(SP_PROVIDERUIIDENTIFY, 1))(
+                             lpszUIDLLName);
+
+   return lResult;
+}
+
+#endif // tapi 2.0
+
+#ifdef WIN32
+
+BOOL WINAPI  DllMain(
+    HANDLE hModule,
+    DWORD dwReason,
+    DWORD dwReserved
+    )
+{
+    
+    DBGOUT((1, "DllEntryPoint entered reason=%lx\r\n", dwReason));
+
+
+    if ( dwReason == 1 )
+    {
+//        StartMeUp();
+        // don't do nothin'
+    }
+
+    if (dwReason == 0)
+    {
+        if (gbStarted)
+        {
+            gfTerminateNow = TRUE;
+
+            WaitForSingleObject(ghLoggingThread,
+                                2000);
+
+            CloseHandle(ghLoggingThread);
+            DeleteCriticalSection(&gcsLogging);
+            DeleteCriticalSection(&gcsID);
+            FreeLibrary(hProvider);
+
+            MYFREE(lpfnProcAddress);
+        }
+        
+        
+    }
+
+
+    return(1); // success
+}
+
+#else
+
+int
+FAR
+PASCAL
+LibMain(HANDLE hInstance,
+        WORD   wDataSegment,
+        WORD   wHeapSize,
+        LPSTR  lpszCmdLine)
+{
+    StartMeUp();
+    return TRUE;
+}
+
+#endif
diff --git a/private/tapi/dev/sp/repeater/new/repeater.def b/private/tapi/dev/sp/repeater/new/repeater.def
new file mode 100644
index 000000000..01ec325c7
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/repeater.def
@@ -0,0 +1,122 @@
+LIBRARY     repeater.tsp
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept                        @500
+        TSPI_lineAddToConference               @501
+        TSPI_lineAnswer                        @502
+        TSPI_lineBlindTransfer                 @503
+        TSPI_lineClose                         @504
+        TSPI_lineCloseCall                     @505
+        TSPI_lineCompleteCall                  @506
+        TSPI_lineCompleteTransfer              @507
+        TSPI_lineConditionalMediaDetection     @508
+;        TSPI_lineConfigDialog                  @509
+        TSPI_lineDevSpecific                   @510
+        TSPI_lineDevSpecificFeature            @511
+        TSPI_lineDial                          @512
+        TSPI_lineDrop                          @513
+        TSPI_lineForward                       @514
+        TSPI_lineGatherDigits                  @515
+        TSPI_lineGenerateDigits                @516
+        TSPI_lineGenerateTone                  @517
+        TSPI_lineGetAddressCaps                @518
+        TSPI_lineGetAddressID                  @519
+        TSPI_lineGetAddressStatus              @520
+        TSPI_lineGetCallAddressID              @521
+        TSPI_lineGetCallInfo                   @522
+        TSPI_lineGetCallStatus                 @523
+        TSPI_lineGetDevCaps                    @524
+        TSPI_lineGetDevConfig                  @525
+        TSPI_lineGetExtensionID                @526
+        TSPI_lineGetIcon                       @527
+        TSPI_lineGetID                         @528
+        TSPI_lineGetLineDevStatus              @529
+        TSPI_lineGetNumAddressIDs              @530
+        TSPI_lineHold                          @531
+        TSPI_lineMakeCall                      @532
+        TSPI_lineMonitorDigits                 @533
+        TSPI_lineMonitorMedia                  @534
+        TSPI_lineMonitorTones                  @535
+        TSPI_lineNegotiateExtVersion           @536
+        TSPI_lineNegotiateTSPIVersion          @537
+        TSPI_lineOpen                          @538
+        TSPI_linePark                          @539
+        TSPI_linePickup                        @540
+        TSPI_linePrepareAddToConference        @541
+        TSPI_lineRedirect                      @542
+        TSPI_lineRemoveFromConference          @543
+        TSPI_lineSecureCall                    @544
+        TSPI_lineSelectExtVersion              @545
+        TSPI_lineSendUserUserInfo              @546
+        TSPI_lineSetAppSpecific                @547
+        TSPI_lineSetCallParams                 @548
+        TSPI_lineSetDefaultMediaDetection      @549
+        TSPI_lineSetDevConfig                  @550
+        TSPI_lineSetMediaControl               @551
+        TSPI_lineSetMediaMode                  @552
+        TSPI_lineSetStatusMessages             @553
+        TSPI_lineSetTerminal                   @554
+        TSPI_lineSetupConference               @555
+        TSPI_lineSetupTransfer                 @556
+        TSPI_lineSwapHold                      @557
+        TSPI_lineUncompleteCall                @558
+        TSPI_lineUnhold                        @559
+        TSPI_lineUnpark                        @560
+
+        TSPI_phoneClose                        @561
+;        TSPI_phoneConfigDialog                 @562
+        TSPI_phoneDevSpecific                  @563
+        TSPI_phoneGetButtonInfo                @564
+        TSPI_phoneGetData                      @565
+        TSPI_phoneGetDevCaps                   @566
+        TSPI_phoneGetDisplay                   @567
+        TSPI_phoneGetExtensionID               @568
+        TSPI_phoneGetGain                      @569
+        TSPI_phoneGetHookSwitch                @570
+        TSPI_phoneGetIcon                      @571
+        TSPI_phoneGetID                        @572
+        TSPI_phoneGetLamp                      @573
+        TSPI_phoneGetRing                      @574
+        TSPI_phoneGetStatus                    @575
+        TSPI_phoneGetVolume                    @576
+        TSPI_phoneNegotiateExtVersion          @577
+        TSPI_phoneNegotiateTSPIVersion         @578
+        TSPI_phoneOpen                         @579
+        TSPI_phoneSelectExtVersion             @580
+        TSPI_phoneSetButtonInfo                @581
+        TSPI_phoneSetData                      @582
+        TSPI_phoneSetDisplay                   @583
+        TSPI_phoneSetGain                      @584
+        TSPI_phoneSetHookSwitch                @585
+        TSPI_phoneSetLamp                      @586
+        TSPI_phoneSetRing                      @587
+        TSPI_phoneSetStatusMessages            @588
+        TSPI_phoneSetVolume                    @589
+
+        TSPI_providerConfig                    @590
+        TSPI_providerInit                      @591
+        TSPI_providerInstall                   @592
+        TSPI_providerRemove                    @593
+        TSPI_providerShutdown                  @594
+
+        TSPI_providerEnumDevices               @595
+;        TSPI_lineDropOnClose                   @596
+;        TSPI_lineDropNoOwner                   @597
+        TSPI_providerCreateLineDevice          @598
+        TSPI_providerCreatePhoneDevice         @599
+        TSPI_lineSetCurrentLocation            @600
+;        TSPI_lineConfigDialogEdit              @601
+        TSPI_lineReleaseUserUserInfo           @602
+
+;        TSPI_lineSetCallData                   @603
+;        TSPI_lineSetCallQualityOfService       @604
+;        TSPI_lineSetCallTreatment              @605
+;        TSPI_lineSetLineDevStatus              @606
+        TSPI_providerFreeDialogInstance        @607
+        TSPI_providerGenericDialogData         @608
+        TSPI_providerUIIdentify                @609
+
+
diff --git a/private/tapi/dev/sp/repeater/new/repeater.h b/private/tapi/dev/sp/repeater/new/repeater.h
new file mode 100644
index 000000000..8157b9e2f
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/repeater.h
@@ -0,0 +1,177 @@
+/*  TSP3216S.H
+    Copyright 1995 (C) Microsoft Corporation
+
+    32-bit TAPI service provider to act as a cover for a system's 16-bit SPs
+
+    16-bit part: TSP3216S.DLL
+    32-bit part: TSP3216L.DLL
+
+    t-jereh 20-July-1995
+
+    TODO:
+    1) allow debug levels
+    2) if oom in InitializeSPs(), fail
+
+ */
+
+#define MAXBUFSIZE 256 /* maximum buffer size */
+
+#define ERR_NONE 0 /* success return value */
+
+#define TAPI_CUR_VER 0x00010004
+
+#define TSPI_PROC_LAST 118 /* there are TSPI functions from 500 to 617 */
+
+
+// structs
+
+typedef struct tagMYLINE
+    {
+    HDRVLINE hdLine;
+    int iProvider;
+    DWORD dwDeviceID;
+    LINEEVENT lpfnEventProc;
+    HTAPILINE htLine;
+    } MYLINE, FAR *LPMYLINE;
+
+
+typedef struct tagMYPHONE
+    {
+    HDRVPHONE hdPhone;
+    int iProvider;
+    DWORD dwDeviceID;
+    PHONEEVENT lpfnEventProc;
+    HTAPIPHONE htPhone;
+    } MYPHONE, FAR *LPMYPHONE;
+
+typedef struct tagMYHDRVCALL
+{
+    HTAPICALL  htCall;
+    HDRVCALL   hdCall;
+    int        iProvider;
+    DWORD      dwDeviceID;
+} MYHDRVCALL, FAR *LPMYHDRVCALL;
+
+typedef struct tagMYTEMPID
+{
+    int        iProvider;
+    DWORD      dwTempID;
+} MYTEMPID, FAR *LPMYTEMPID;
+
+#define SP_LINEACCEPT                       0
+#define SP_LINEADDTOCONFERENCE              1
+#define SP_LINEAGENTSPECIFIC                2
+#define SP_LINEANSWER                       3
+#define SP_LINEBLINDTRANSFER                4
+#define SP_LINECLOSE                        5
+#define SP_LINECLOSECALL                    6
+#define SP_LINECOMPLETECALL                 7
+#define SP_LINECOMPLETETRANSFER             8
+#define SP_LINECONDITIONALMEDIADETECTION    9
+#define SP_LINEDEVSPECIFIC                  10
+#define SP_LINEDEVSPECIFICFEATURE           11
+#define SP_LINEDIAL                         12
+#define SP_LINEDROP                         13
+#define SP_LINEFORWARD                      14
+#define SP_LINEGATHERDIGITS                 15
+#define SP_LINEGENERATEDIGITS               16
+#define SP_LINEGENERATETONE                 17
+#define SP_LINEGETADDRESSCAPS               18
+#define SP_LINEGETADDRESSID                 19
+#define SP_LINEGETADDRESSSTATUS             20
+#define SP_LINEGETAGENTACTIVITYLIST         21
+#define SP_LINEGETAGENTCAPS                 22
+#define SP_LINEGETAGENTGROUPLIST            23
+#define SP_LINEGETAGENTSTATUS               24
+#define SP_LINEGETCALLADDRESSID             25
+#define SP_LINEGETCALLINFO                  26
+#define SP_LINEGETCALLSTATUS                27
+#define SP_LINEGETDEVCAPS                   28
+#define SP_LINEGETDEVCONFIG                 29
+#define SP_LINEGETEXTENSIONID               30
+#define SP_LINEGETICON                      31
+#define SP_LINEGETID                        32
+#define SP_LINEGETLINEDEVSTATUS             33
+#define SP_LINEGETNUMADDRESSIDS             34
+#define SP_LINEHOLD                         35
+#define SP_LINEMAKECALL                     36
+#define SP_LINEMONITORDIGITS                37
+#define SP_LINEMONITORMEDIA                 38
+#define SP_LINEMONITORTONES                 39
+#define SP_LINENEGOTIATEEXTVERSION          40
+#define SP_LINENEGOTIATETSPIVERSION         41
+#define SP_LINEOPEN                         42
+#define SP_LINEPARK                         43
+#define SP_LINEPICKUP                       44
+#define SP_LINEPREPAREADDTOCONFERENCE       45
+#define SP_LINEREDIRECT                     46
+#define SP_LINERELEASEUSERUSERINFO          47
+#define SP_LINEREMOVEFROMCONFERENCE         48
+#define SP_LINESECURECALL                   49
+#define SP_LINESELECTEXTVERSION             50
+#define SP_LINESENDUSERUSERINFO             51
+#define SP_LINESETAGENTACTIVITY             52
+#define SP_LINESETAGENTGROUP                53
+#define SP_LINESETAGENTSTATE                54
+#define SP_LINESETAPPSPECIFIC               55
+#define SP_LINESETCALLDATA                  56
+#define SP_LINESETCALLPARAMS                57
+#define SP_LINESETCALLQUALITYOFSERVICE      58
+#define SP_LINESETCALLTREATMENT             59
+#define SP_LINESETCURRENTLOCATION           60
+#define SP_LINESETDEFAULTMEDIADETECTION     61
+#define SP_LINESETDEVCONFIG                 62
+#define SP_LINESETLINEDEVSTATUS             63
+#define SP_LINESETMEDIACONTROL              64
+#define SP_LINESETMEDIAMODE                 65
+#define SP_LINESETSTATUSMESSAGES            66
+#define SP_LINESETTERMINAL                  67
+#define SP_LINESETUPCONFERENCE              68
+#define SP_LINESETUPTRANSFER                69
+#define SP_LINESWAPHOLD                     70
+#define SP_LINEUNCOMPLETECALL               71
+#define SP_LINEUNHOLD                       72
+#define SP_LINEUNPARK                       73
+#define SP_PHONECLOSE                       74
+#define SP_PHONEDEVSPECIFIC                 75
+#define SP_PHONEGETBUTTONINFO               76
+#define SP_PHONEGETDATA                     77
+#define SP_PHONEGETDEVCAPS                  78
+#define SP_PHONEGETDISPLAY                  79
+#define SP_PHONEGETEXTENSIONID              80
+#define SP_PHONEGETGAIN                     81
+#define SP_PHONEGETHOOKSWITCH               82
+#define SP_PHONEGETICON                     83
+#define SP_PHONEGETID                       84
+#define SP_PHONEGETLAMP                     85
+#define SP_PHONEGETRING                     86
+#define SP_PHONEGETSTATUS                   87
+#define SP_PHONEGETVOLUME                   88
+#define SP_PHONENEGOTIATEEXTVERSION         89
+#define SP_PHONENEGOTIATETSPIVERSION        90
+#define SP_PHONEOPEN                        91
+#define SP_PHONESELECTEXTVERSION            92
+#define SP_PHONESETBUTTONINFO               93
+#define SP_PHONESETDATA                     94
+#define SP_PHONESETDISPLAY                  95
+#define SP_PHONESETGAIN                     96
+#define SP_PHONESETHOOKSWITCH               97
+#define SP_PHONESETLAMP                     98
+#define SP_PHONESETRING                     99
+#define SP_PHONESETSTATUSMESSAGES           100
+#define SP_PHONESETVOLUME                   101
+#define SP_PROVIDERCREATELINEDEVICE         102
+#define SP_PROVIDERCREATEPHONEDEVICE        103
+#define SP_PROVIDERENUMDEVICES              104
+#define SP_PROVIDERFREEDIALOGINSTANCE       105
+#define SP_PROVIDERGENERICDIALOGDATA        106
+#define SP_PROVIDERINIT                     107
+#define SP_PROVIDERSHUTDOWN                 108
+#define SP_PROVIDERUIIDENTIFY               109
+#define SP_LINECONFIGDIALOG                 110
+#define SP_LINECONFIGDIALOGEDIT             111
+#define SP_PHONECONFIGDIALOG                112
+#define SP_PROVIDERCONFIG                   113
+#define SP_LINEDROPONCLOSE                  114
+#define SP_LINEDROPNOOWNER                  115
+#define SP_LASTPROCNUMBER                   (SP_LINEDROPNOOWNER + 1)
diff --git a/private/tapi/dev/sp/repeater/new/repeater.rc b/private/tapi/dev/sp/repeater/new/repeater.rc
new file mode 100644
index 000000000..cdd206da8
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/repeater.rc
@@ -0,0 +1,19 @@
+#include "windows.h"
+
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony API Repeater Service Provider"
+#define VER_INTERNALNAME_STR        "REPEATER"
+#define VER_ORIGINALFILENAME_STR    "REPEATER.TSP"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1996.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/repeater/new/repeater.txt b/private/tapi/dev/sp/repeater/new/repeater.txt
new file mode 100644
index 000000000..bff82259a
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/repeater.txt
@@ -0,0 +1,87 @@
+At install time:
+
+// If for record, list all providers and ask user which one to record
+// (Multiple at once?   *Not at first.)
+
+// If for playback, install as a new provider(?)
+
+
+-----------------------------------------------------------------------------
+At record time:
+
+// Insert between TAPI & target SP (multiple SPs at once?  *Not at first.)
+
+// Really cool to self-modify export table so that only functions exported
+// are those exported by the target SP  (unlikely)
+
+// On startup, spin a thread that will take messages & write to a file
+
+// When a message comes up, all parms & timestamp will be added to a queue and the
+// other thread will be signaled to put messages to the queue
+
+// When a function call comes down, parms will be recorded for comparison
+// to parms sent down during playback  (THIS DEFINITION NEEDS WORK!!)
+
+
+// !! Events going up should get TWO timestamps!!! One since startup and
+// !! one since last (non-status?) function going down.
+
+
+// After a function call, the return stuff (retcode, async buffer if any,
+// async retcode) and timestamp are recorded
+
+
+Features for recording:
+
+// At set times, or before/after passing functions down to target SP
+// and/or after/during messages up, call status functions on calls & lines
+// so that if, during playback, status is unexpectedly asked for (because
+// the ISV is trying something new) "correct" status is returned
+
+
+-----------------------------------------------------------------------------
+At playback:
+
+// Already installed.  Separate app to kick off, log stuff, and maybe get
+// some user intervention (eg: have user manually kick off each event; have
+// user alter data going up/down; etc)
+
+// FileOpen common-dialog box to open Repeater file
+
+// Talk through sidedoor (NOT LINEDEVSPECIFIC - MUST NOT ALREADY init provider)
+// to get filename to Repeater
+
+// On startup, spin a thread that will log stuff?
+
+// When function calls come down, check them off the list if they are expected
+// If not expected, log it (maybe even log it if it was expected, LOGLEVEL)
+// If not expected, THEN WHAT? If a status call, return same status if this
+// call was reported previously for 2 calls then the same status that was
+// returned next.  IE: A developer is working to fix a bug in an event stream
+// and sets a loop to check the status of a call before continuing.  He should
+// receive a couple of "not done yet" statuses before the "ok, it's done"
+// status.
+
+// When completing async events, be sure to use the GOOD (current) asyncID!
+
+// If a function call does not happen by (SOME AMOUNT OF TIME - the next
+// status up message?), then log it.
+
+// Pass any events up at the time delta they happened. (Delta from func down?)
+
+// What about UI functions?  Probably just put up a MessageBox that says
+// "Kilroy was here"
+
+
+Features for playback:
+
+// Have playback optionally ignore function down stuff.  So that a PBX maker
+// can record events that are calls coming in and send that to ISVs.  The
+// ISV can then test their apps against incoming calls on the PBX.
+
+// How valuable to be able to insert into a playback stream?  EG: A PBX
+// stream has incoming calls, but to test IVR stuff, an ISV wants to simulate
+// DTMF pressed.   EG2: An ISV realizes what he did wrong and wants to run
+// a simulation and so wants to change one of the status returned messages.
+// - changes a disconnect to dialing, then inserts a conntected then changes
+// the disconnect to happen a MINUTE later...
diff --git a/private/tapi/dev/sp/repeater/new/sources b/private/tapi/dev/sp/repeater/new/sources
new file mode 100644
index 000000000..52bde1c8c
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/sources
@@ -0,0 +1,53 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=repeater
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETEXT=TSP
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+DLLBASE=0x60000000
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+SOURCES=repeater.c  \
+        logger.c    \
+        debug.c     \
+        repeater.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/repeater/new/tsp3216.h b/private/tapi/dev/sp/repeater/new/tsp3216.h
new file mode 100644
index 000000000..4b4959868
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/new/tsp3216.h
@@ -0,0 +1,10 @@
+#define TSP3216L_MESSAGE (WM_USER+10)
+
+enum {CALLBACK_ASYNCCOMPLETION,
+                     CALLBACK_LINEEVENT,
+                     CALLBACK_PHONEEVENT,
+                     CALLBACK_LINECREATE,
+                     CALLBACK_PHONECREATE
+                    } CALLBACK_TYPES;
+
+
diff --git a/private/tapi/dev/sp/repeater/setup/makefile b/private/tapi/dev/sp/repeater/setup/makefile
new file mode 100644
index 000000000..f1084966b
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/setup/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   Dialer.exe Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/repeater/setup/resource.h b/private/tapi/dev/sp/repeater/setup/resource.h
new file mode 100644
index 000000000..c20e295b0
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/setup/resource.h
@@ -0,0 +1,22 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by Setup.rc
+//
+#define IDD_REPEATER                    101
+#define IDC_FILEDIRECTORY               1000
+#define IDC_SPNAME                      1001
+#define ID_UNINSTALL                    1002
+#define ID_INSTALL                      1003
+#define ID_MOREINFO                     1004
+#define IDC_STATIC                      -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        102
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1005
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/dev/sp/repeater/setup/setup.cpp b/private/tapi/dev/sp/repeater/setup/setup.cpp
new file mode 100644
index 000000000..79169a1a1
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/setup/setup.cpp
@@ -0,0 +1,779 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+#include <commdlg.h>
+#include "resource.h"
+
+//////////////////////////////////////////////////////////////////////////////
+//  PROTOTYPES
+//////////////////////////////////////////////////////////////////////////////
+static BOOL CreateMainWindow (int nCmdShow);
+
+BOOL CALLBACK RepeaterDlgProc (HWND   hwnd,
+			       UINT   uMsg,
+			       WPARAM wParam,
+			       LPARAM lParam);
+BOOL DoInstall(HWND);
+BOOL DoUninstall(HWND);
+BOOL DoMoreInfo();
+
+//////////////////////////////////////////////////////////////////////////////
+//  GLOBALS
+//////////////////////////////////////////////////////////////////////////////
+HINSTANCE       ghInstance;
+BOOL            gbIsNT = FALSE;
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// WinMain()
+//
+//////////////////////////////////////////////////////////////////////////////
+
+int WINAPI WinMain (HINSTANCE hInstance,
+                    HINSTANCE hPrevInstance,
+                    LPSTR     lpszCmdLine,
+                    int       nCmdShow)
+{
+    ghInstance = GetModuleHandle(NULL);
+
+    if (GetVersion() < 0x80000000)
+    {
+	gbIsNT = TRUE;
+    }
+
+    DialogBox(ghInstance,
+	      MAKEINTRESOURCE(IDD_REPEATER),
+	      GetDesktopWindow(),
+	      (DLGPROC)RepeaterDlgProc);
+    return 1;
+}
+
+
+//*****************************************************************************
+// MainWndProc()
+//*****************************************************************************
+
+BOOL CALLBACK RepeaterDlgProc (HWND   hwnd,
+			       UINT   uMsg,
+			       WPARAM wParam,
+				LPARAM lParam)
+{
+    switch (uMsg)
+    {
+    case WM_INITDIALOG:
+
+	SetWindowPos(hwnd,
+		     HWND_TOP,
+		     GetSystemMetrics(SM_CXSCREEN)/4,
+		     GetSystemMetrics(SM_CYSCREEN)/4,
+		     0,
+		     0,
+		     SWP_NOSIZE);
+
+
+	SetFocus(GetDlgItem(hwnd,
+			    IDC_SPNAME));
+
+	return 0;
+
+    case WM_COMMAND:
+
+	switch (LOWORD(wParam))
+	{
+	case ID_UNINSTALL:
+	    if (DoUninstall(hwnd))
+	    {
+				MessageBox(hwnd,
+						   "Repeater successfully uninstalled.",
+						   "Repeater Setup",
+						   NULL);
+		EndDialog(hwnd, 1);
+	    }
+	    break;
+
+	case ID_INSTALL:
+	    if (DoInstall(hwnd))
+	    {
+				MessageBox(hwnd,
+						   "Repeater successfully installed.",
+						   "Repeater Setup",
+						   NULL);
+		EndDialog(hwnd, 1);
+	    }
+	    break;
+
+	case ID_MOREINFO:
+	    if (DoMoreInfo())
+	    {
+		EndDialog(hwnd, 1);
+	    }
+	    break;
+
+	case IDCANCEL:
+	    EndDialog(hwnd, 0);
+	    break;
+	default:
+	    return FALSE;
+	}
+
+    default:
+	return FALSE;
+   }
+
+    return TRUE;
+}
+
+#define SZTAPIKEY       "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony"
+#define SZREPEATERSETUP "Repeater Setup"
+#define SZPROVIDERS     "Providers"
+#define SZREPEATER      "Repeater"
+#define SZNUMPROVIDERS  "NumProviders"
+#define SZREPEATERFILENAME  "Repeater.TSP"
+#define SZLOGDIR        "LogFileDirectory"
+#define SZPROVIDERFILENAME "ProviderFilename"
+#define SZPROVIDER      "Provider"
+#define SZPROVIDERID    "ProviderID"
+#define SZTELEPHONINI   "TELEPHON.INI"
+
+
+BOOL DoInstall(HWND hWnd)
+{
+    char            szSPName[256];
+    char            szLogFilePath[256];
+    char            szTestName[256];
+    int             i;
+    HANDLE          hFileHandle;
+    DWORD           dwSize;
+    DWORD           dwHold, dwNumProviders;
+    HKEY            hTapiKey, hProvidersKey, hRepeaterKey;
+    char            szbuf[64], szfilebuf[256];
+    char            sznum[16];
+
+
+
+    GetDlgItemText(hWnd,
+                   IDC_SPNAME,
+                   szSPName,
+                   256);
+
+    GetDlgItemText(hWnd,
+                   IDC_FILEDIRECTORY,
+                   szLogFilePath,
+                   256);
+
+    i = lstrlen(szLogFilePath);
+    if (szLogFilePath[i-1] != '\\')
+    {
+        szLogFilePath[i+1]=0;
+        szLogFilePath[i]='\\';
+    }
+
+    wsprintf(szTestName, "%s%s", szLogFilePath, "testme");
+    if ((hFileHandle = CreateFile(szTestName,
+                                  GENERIC_READ,
+                                  FILE_SHARE_READ,
+                                  NULL,
+                                  OPEN_ALWAYS,
+                                  FILE_ATTRIBUTE_NORMAL,
+                                  NULL)) == INVALID_HANDLE_VALUE)
+    {
+        MessageBox(NULL, "Directory does not exist", NULL, MB_OK);
+        return FALSE;
+    }
+    else
+    {
+        CloseHandle(hFileHandle);
+        DeleteFile(szTestName);
+    }
+
+    if (gbIsNT)
+    {
+        // get tapi key
+        RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+                     SZTAPIKEY,
+                     0,
+                     KEY_ALL_ACCESS,
+                     &hTapiKey);
+
+        // get providers key
+        RegOpenKeyEx(hTapiKey,
+                     SZPROVIDERS,
+                     0,
+                     KEY_ALL_ACCESS,
+                     &hProvidersKey);
+
+        // create repeater key
+        RegCreateKeyEx(hTapiKey,
+                       SZREPEATER,
+                       0,
+                       "Repeater Type",
+                       REG_OPTION_VOLATILE,
+                       KEY_ALL_ACCESS,
+                       NULL,
+                       &hRepeaterKey,
+                       &dwHold);
+
+        // get number of providers
+        dwSize = sizeof(DWORD);
+        RegQueryValueEx(hProvidersKey,
+                        SZNUMPROVIDERS,
+                        NULL,
+                        NULL,
+                        (LPBYTE)&dwNumProviders,
+                        &dwSize);
+
+        // find the provider
+        for (i = 0; i < (int)dwNumProviders; i++)
+        {
+            wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i);
+
+            dwSize = 256;
+            RegQueryValueEx(hProvidersKey,
+                            szbuf,
+                            NULL,
+                            NULL,
+                            (LPBYTE)szfilebuf,
+                            &dwSize);
+
+            // if it's the same break
+            if (!lstrcmpi(szfilebuf, szSPName))
+            {
+                break;
+            }
+
+        }
+
+        // didn't find the provider
+        if (i == (int)dwNumProviders)
+        {
+            char    szmessage[256];
+
+            wsprintf(szmessage,
+                     "Provider %s is not installed\n",
+                     szSPName);
+
+            MessageBox(hWnd,
+                       szmessage,
+                       SZREPEATERSETUP,
+                       MB_OK);
+
+            // return false so they can reenter the name correctly
+            return FALSE;
+        }
+
+
+    }
+
+    else // win95
+    {
+        // get number of providers
+        dwNumProviders = GetPrivateProfileInt(SZPROVIDERS,
+                                              SZNUMPROVIDERS,
+                                              0, 
+                                              SZTELEPHONINI);
+
+        // find the provider
+        for (i = 0; i < (int)dwNumProviders; i++)
+        {
+            wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i);
+
+            GetPrivateProfileString(SZPROVIDERS,
+                                    szbuf,
+                                    "",
+                                    szfilebuf,
+                                    256,
+                                    SZTELEPHONINI);
+
+            // if it's the same break
+            if (!lstrcmpi(szfilebuf, szSPName))
+            {
+                break;
+            }
+
+        }
+
+        // didn't find the provider
+        if (i == (int)dwNumProviders)
+        {
+            char    szmessage[256];
+
+            wsprintf(szmessage,
+                     "Provider %s is not installed\n",
+                     szSPName);
+
+            MessageBox(hWnd,
+                       szmessage,
+                       SZREPEATERSETUP,
+                       MB_OK);
+
+            // return false so they can reenter the name correctly
+            return FALSE;
+        }
+
+    }
+
+    // ok now copy repeater
+
+    {
+        char szfile[MAX_PATH];
+        char sztarget[MAX_PATH];
+        char szdir[MAX_PATH];
+        int     j;
+
+        GetModuleFileName(NULL,
+                          szdir,
+                          MAX_PATH);
+
+        j = lstrlen(szdir);
+        while (szdir[j] != '\\')
+        {
+            szdir[j] = 0;
+            j--;
+        }
+
+        // get rid of \ too
+        szdir[j] = 0;
+
+        wsprintf(szfile, "%s\\%s", szdir, SZREPEATERFILENAME);
+
+        GetSystemDirectory(szdir, MAX_PATH);
+
+        wsprintf(sztarget, "%s\\%s", szdir, SZREPEATERFILENAME);
+
+        if (!CopyFile(szfile,
+                      sztarget,
+                      FALSE))
+        {
+            if (GetLastError() == ERROR_FILE_NOT_FOUND)
+            {
+                // ask them where the file is
+                OPENFILENAME            ofn;
+                BOOL                    bReturn;
+
+                szfile[0] = '\0';
+
+                ofn.lStructSize = sizeof(ofn);
+                ofn.hwndOwner = hWnd;
+                ofn.hInstance = ghInstance;
+                ofn.lpstrFilter = "TSP Files\0*.tsp\0\0";
+                ofn.lpstrCustomFilter = NULL;
+                ofn.nMaxCustFilter = 0;
+                ofn.nFilterIndex = 0;
+                ofn.lpstrFile = szfile;
+                ofn.nMaxFile = MAX_PATH;
+                ofn.lpstrFileTitle = NULL;
+                ofn.nMaxFileTitle = 0;
+                ofn.lpstrInitialDir = NULL;
+                ofn.lpstrTitle ="Location of REPEATER.TSP";
+                ofn.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER;
+                ofn.nFileOffset = 0;
+                ofn.nFileExtension = 0;
+                ofn.lpstrDefExt = "TSP";
+                ofn.lCustData = 0;
+                ofn.lpfnHook = NULL;
+                ofn.lpTemplateName = NULL;
+
+                bReturn = GetOpenFileName(&ofn);
+
+                if (!bReturn)
+                {
+                    return FALSE;
+                }
+
+                if (!CopyFile(szfile,
+                              sztarget,
+                              FALSE))
+                {
+                    MessageBox(NULL, "Copy file failed", NULL, MB_OK);
+                    return FALSE;
+                }
+
+            }
+            else
+            {
+                MessageBox(NULL, "CopyFile failed", NULL, MB_OK);
+                return FALSE;            
+            }
+
+        }
+    }   
+
+
+
+    if (gbIsNT)
+    {
+        // now i is the provider number, so put repeater there
+        // and move provider's info to repeater key
+
+        // set ProviderFilenameX=repeater.tsp
+        dwSize = lstrlen(SZREPEATERFILENAME) + 1;
+        RegSetValueEx(hProvidersKey,
+                      szbuf,
+                      0,
+                      REG_SZ,
+                      (LPBYTE)SZREPEATERFILENAME,
+                      dwSize);
+
+        // set providerfilename0 = szProviderName
+        dwSize = lstrlen(szSPName) + 1;
+        wsprintf(szfilebuf, "%s%d", SZPROVIDERFILENAME, 0);
+        RegSetValueEx(hRepeaterKey,
+                      szfilebuf,
+                      0,
+                      REG_SZ,
+                      (LPBYTE)szSPName,
+                      dwSize);
+
+        // get provider id
+
+        wsprintf(szbuf, "%s%d", SZPROVIDERID, i);
+        dwSize = sizeof(DWORD);
+        RegQueryValueEx(hProvidersKey,
+                        szbuf,
+                        NULL,
+                        NULL,
+                        (LPBYTE)&dwHold,
+                        &dwSize);
+
+        // write in as provider ID 0
+        wsprintf(szbuf, "%s%d", SZPROVIDERID, 0);
+        dwSize = sizeof(DWORD);
+        RegSetValueEx(hRepeaterKey,
+                      szbuf,
+                      0,
+                      REG_DWORD,
+                      (LPBYTE)&dwHold,
+                      dwSize);
+
+        // write num providers in repeater key (always 1)
+        dwHold = 1;
+        dwSize = sizeof(DWORD);
+        RegSetValueEx(hRepeaterKey,
+                      SZNUMPROVIDERS,
+                      0,
+                      REG_DWORD,
+                      (LPBYTE)&dwHold,
+                      dwSize);
+
+        dwSize = lstrlen(szLogFilePath) + 1;
+        RegSetValueEx(hRepeaterKey,
+                      SZLOGDIR,
+                      0,
+                      REG_SZ,
+                      (LPBYTE)szLogFilePath,
+                      dwSize);
+
+        RegCloseKey(hRepeaterKey);
+        RegCloseKey(hProvidersKey);
+        RegCloseKey(hTapiKey);
+    }
+    else
+    {
+        // now i is the provider number, so put repeater there
+        // and move provider's info to repeater key
+
+        // set ProviderFilenameX=repeater.tsp
+        WritePrivateProfileString(SZPROVIDERS,
+                                  szbuf,
+                                  SZREPEATERFILENAME,
+                                  SZTELEPHONINI);
+        // set providerfilename0 = szProviderName
+        wsprintf(szfilebuf, "%s%d", SZPROVIDERFILENAME, 0);
+        WritePrivateProfileString(SZREPEATER,
+                                  szfilebuf,
+                                  szSPName,
+                                  SZTELEPHONINI);
+
+        // get provider id
+        wsprintf(szbuf, "%s%d", SZPROVIDERID, i);
+        dwHold = GetPrivateProfileInt(SZPROVIDERS,
+                                      szbuf,
+                                      0,
+                                      SZTELEPHONINI);
+
+        // write in as provider ID 0
+        wsprintf(szbuf, "%s%d", SZPROVIDERID, 0);
+        wsprintf(sznum, "%d", dwHold);
+        WritePrivateProfileString(SZREPEATER,
+                                  szbuf,
+                                  sznum,
+                                  SZTELEPHONINI);
+
+        // write num providers in repeater key (always 1)
+        WritePrivateProfileString(SZREPEATER,
+                                  SZNUMPROVIDERS,
+                                  "1",
+                                  SZTELEPHONINI);
+
+        WritePrivateProfileString(SZREPEATER,
+                                  SZLOGDIR,
+                                  szLogFilePath,
+                                  SZTELEPHONINI);
+
+
+    }    
+    return TRUE;
+}
+
+BOOL DoUninstall(HWND hWnd)
+{
+    if (gbIsNT)
+    {
+	DWORD           dwSize, dwHold, dwNumProviders;
+	HKEY            hTapiKey, hProvidersKey, hRepeaterKey;
+	char            szbuf[64], szfilebuf[256];
+	int             i;
+
+	// get tapi key
+	RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+		     SZTAPIKEY,
+		     0,
+		     KEY_ALL_ACCESS,
+		     &hTapiKey);
+
+	// get providers key
+	RegOpenKeyEx(hTapiKey,
+		     SZPROVIDERS,
+		     0,
+		     KEY_ALL_ACCESS,
+		     &hProvidersKey);
+
+	RegOpenKeyEx(hTapiKey,
+		     SZREPEATER,
+		     0,
+		     KEY_ALL_ACCESS,
+		     &hRepeaterKey);
+
+	// get number of providers
+	dwSize = sizeof(DWORD);
+	RegQueryValueEx(hProvidersKey,
+			SZNUMPROVIDERS,
+			NULL,
+			NULL,
+			(LPBYTE)&dwNumProviders,
+			&dwSize);
+
+	// find the provider
+	for (i = 0; i < (int)dwNumProviders; i++)
+	{
+	    wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i);
+
+	    dwSize = 256;
+	    RegQueryValueEx(hProvidersKey,
+			    szbuf,
+			    NULL,
+			    NULL,
+			    (LPBYTE)szfilebuf,
+			    &dwSize);
+
+	    // if it's the same break
+	    if (!lstrcmpi(szfilebuf, SZREPEATERFILENAME))
+	    {
+		break;
+	    }
+
+	}
+
+	// didn't find the repeater provider
+	if (i == (int)dwNumProviders)
+	{
+	    MessageBox(hWnd,
+		       "Repeater is not installed",
+		       SZREPEATERSETUP,
+		       MB_OK);
+
+	    return TRUE;
+	}
+
+	// now i is the provider number, so put repeater there
+	// and move provider's info to repeater key
+
+	// get original sp's name
+	wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, 0);
+	dwSize = 256;
+	RegQueryValueEx(hRepeaterKey,
+			szbuf,
+			NULL,
+			NULL,
+			(LPBYTE)szfilebuf,
+			&dwSize);
+
+	// write name back into provider's key
+	wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, i);
+	dwSize = lstrlen(szfilebuf) + 1;
+	RegSetValueEx(hProvidersKey,
+		      szbuf,
+		      0,
+		      REG_SZ,
+		      (LPBYTE)szfilebuf,
+		      dwSize);
+
+	// get provider id
+	wsprintf(szbuf, "%s%d", SZPROVIDERID, 0);
+	dwSize = sizeof(DWORD);
+	RegQueryValueEx(hRepeaterKey,
+			szbuf,
+			NULL,
+			NULL,
+			(LPBYTE)&dwHold,
+			&dwSize);
+
+	// write in as provider ID
+	wsprintf(szbuf, "%s%d", SZPROVIDERID, i);
+	dwSize = sizeof(DWORD);
+	RegSetValueEx(hProvidersKey,
+		      szbuf,
+		      0,
+		      REG_DWORD,
+		      (LPBYTE)&dwHold,
+		      dwSize);
+
+	RegCloseKey(hRepeaterKey);
+	RegCloseKey(hProvidersKey);
+	RegDeleteKey(hTapiKey,
+		     SZREPEATER);
+	RegCloseKey(hTapiKey);
+
+    }
+
+    else // win95
+    {
+	DWORD           dwHold, dwNumProviders;
+	char            szbuf[64], szfilebuf[256];
+	int             i;
+
+	// get number of providers
+	dwNumProviders = GetPrivateProfileInt(SZPROVIDERS,
+					      SZNUMPROVIDERS,
+					      0,
+					      SZTELEPHONINI);
+
+	// find the provider
+	for (i = 0; i < (int)dwNumProviders; i++)
+	{
+	    wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i);
+
+	    GetPrivateProfileString(SZPROVIDERS,
+				    szbuf,
+				    "",
+				    szfilebuf,
+				    256,
+				    SZTELEPHONINI);
+	    // if it's the same break
+	    if (!lstrcmpi(szfilebuf, SZREPEATERFILENAME))
+	    {
+		break;
+	    }
+
+	}
+
+	// didn't find the repeater provider
+	if (i == (int)dwNumProviders)
+	{
+	    MessageBox(hWnd,
+		       "Repeater is not installed",
+		       SZREPEATERSETUP,
+		       MB_OK);
+
+	    return TRUE;
+	}
+
+	// now i is the provider number, so put repeater there
+	// and move provider's info to repeater key
+
+	// get original sp's name
+	wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, 0);
+	GetPrivateProfileString(SZREPEATER,
+				szbuf,
+				"",
+				szfilebuf,
+				256,
+				SZTELEPHONINI);
+
+	// write name back into provider's key
+	wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, i);
+	WritePrivateProfileString(SZPROVIDERS,
+				  szbuf,
+				  szfilebuf,
+				  SZTELEPHONINI);
+
+	// get provider id
+	wsprintf(szbuf, "%s%d", SZPROVIDERID, 0);
+	dwHold = GetPrivateProfileInt(SZREPEATER,
+				      szbuf,
+				      0,
+				      SZTELEPHONINI);
+
+	// write in as provider ID
+	wsprintf(szbuf, "%s%d", SZPROVIDERID, i);
+	wsprintf(szfilebuf, "%d", dwHold);
+	WritePrivateProfileString(SZPROVIDERS,
+				  szbuf,
+				  szfilebuf,
+				  SZTELEPHONINI);
+
+    }
+
+    // ok now copy repeater
+
+    {
+	char szfile[MAX_PATH];
+	char szdir[MAX_PATH];
+
+	GetSystemDirectory(szdir, MAX_PATH);
+
+	wsprintf(szfile, "%s\\%s", szdir, SZREPEATERFILENAME);
+
+	if (!DeleteFile(szfile))
+	{
+	    MessageBox(NULL, "DeleteFile failed", NULL, MB_OK);
+	    return FALSE;
+	}
+    }   
+	
+
+    return TRUE;
+}
+
+
+BOOL DoMoreInfo()
+{
+    char                szname[MAX_PATH], szbuf[MAX_PATH];
+    int                 i;
+    PROCESS_INFORMATION pi;
+    STARTUPINFO         si;
+
+    FillMemory(&si,
+	       sizeof(si),
+	       0);
+    
+    si.cb = sizeof(si);
+
+    GetModuleFileName(NULL,
+		      szname,
+		      MAX_PATH);
+
+    i = lstrlen(szname);
+    
+    while (szname[i] != '\\')
+    {
+	szname[i] = 0;
+	i--;
+    }
+
+    wsprintf(szbuf, "notepad.exe %srepeater.txt", szname);
+    CreateProcess(NULL,
+		  szbuf,
+		  NULL,
+		  NULL,
+		  FALSE,
+		  NORMAL_PRIORITY_CLASS,
+		  NULL,
+		  NULL,
+		  &si,
+		  &pi);
+    return FALSE;
+}
diff --git a/private/tapi/dev/sp/repeater/setup/setup.rc b/private/tapi/dev/sp/repeater/setup/setup.rc
new file mode 100644
index 000000000..63272a2af
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/setup/setup.rc
@@ -0,0 +1,46 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include <windows.h>
+#include "resource.h"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_REPEATER DIALOG DISCARDABLE  0, 0, 268, 159
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Repeater Setup"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "&Install",ID_INSTALL,211,7,50,14
+    PUSHBUTTON      "&Uninstall",ID_UNINSTALL,211,24,50,14
+    PUSHBUTTON      "&More Info",ID_MOREINFO,211,42,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,211,59,50,14
+    EDITTEXT        IDC_SPNAME,7,98,229,14,ES_AUTOHSCROLL
+    EDITTEXT        IDC_FILEDIRECTORY,7,132,229,14,ES_AUTOHSCROLL
+    LTEXT           "Full path to directory to hold log files:",IDC_STATIC,7,
+                    121,228,8
+    LTEXT           "Name of service provider (the .TSP file)  EX: repeater.tsp",
+                    IDC_STATIC,7,86,226,8
+    LTEXT           "This program will install or uninstall the Repeater service provider.  The TAPI service provider that Repeater is collecting information about MUST be installed before this program can be run. ",
+                    IDC_STATIC,11,11,186,35
+END
+
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony API Repeater Setup"
+#define VER_INTERNALNAME_STR        "SETUP"
+#define VER_ORIGINALFILENAME_STR    "SETUP.EXE"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1996.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/repeater/setup/sources b/private/tapi/dev/sp/repeater/setup/sources
new file mode 100644
index 000000000..f1ddd48a6
--- /dev/null
+++ b/private/tapi/dev/sp/repeater/setup/sources
@@ -0,0 +1,55 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=setup
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\shell32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib 
+
+INCLUDES=.;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=setup.rc \
+        setup.cpp
+
+C_DEFINES=-DWINVER=0x0400
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/tsp1632/makefile b/private/tapi/dev/sp/tsp1632/makefile
new file mode 100644
index 000000000..5bcdbc56d
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/makefile
@@ -0,0 +1,25 @@
+!if "$(OS)" == "Windows_NT"
+
+!else
+
+##########################################################################
+#
+#       Microsoft Confidential
+#       Copyright (C) Microsoft Corporation 1995
+#       All Rights Reserved.
+#
+##########################################################################
+
+
+ROOT = ..\..\..\..\..
+DIR = tsp1632
+
+IS_OEM=1
+
+DIRLIST = script tsp1632l tsp1632s
+
+!include $(ROOT)\root.mk
+
+NTMAKEENV=.
+
+!endif
diff --git a/private/tapi/dev/sp/tsp1632/script/makefile b/private/tapi/dev/sp/tsp1632/script/makefile
new file mode 100644
index 000000000..c23c3c66a
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/makefile
@@ -0,0 +1,16 @@
+#   THUNK Make file
+#
+#
+# Build Environment
+
+ROOT=..\..\..\..\..\..
+IS_OEM=1
+
+VERSIONLIST=debug retail
+DEFAULTVERDIR=debug
+DIR=thunk
+
+COMMONMKFILE=subthk.mk
+
+!include $(ROOT)\root.mk
+
diff --git a/private/tapi/dev/sp/tsp1632/script/subthk.mk b/private/tapi/dev/sp/tsp1632/script/subthk.mk
new file mode 100644
index 000000000..1f14abff8
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/subthk.mk
@@ -0,0 +1,49 @@
+#   THUNK Make file
+#
+#
+
+# Build Environment
+ROOT=..\..\..\..\..\..\..
+IS_OEM=1
+
+# international mode
+
+!ifdef  DBCS
+FDTHK      = FdThkDB
+!else
+FDTHK      = FdThk
+!endif
+
+THKASM   = TapiThk.asm Tapi32.asm TapiFThk.asm
+FTHKASM  = TapiFThk.asm
+
+
+TARGETS= $(THKASM)
+
+
+#DEPENDNAME=..\depend.mk
+
+#!include $(ROOT)\win\core\core.mk
+
+INCLUDE =
+
+#WIN32DEV=..\..\..\..\dev
+#WINCORE=..\..
+
+THUNKCOM   = $(ROOT)\dev\tools\binr\thunk.exe
+
+THUNK      = $(THUNKCOM) $(THUNKOPT)
+
+!IF "$(VERDIR)" == "maxdebug" || "$(VERDIR)" == "debug"
+THUNKOPT   =
+!ELSE
+THUNKOPT   =
+!ENDIF
+
+
+$(THKASM) :  $(THUNKCOM) ..\$(@B).thk
+    $(THUNK) -NC THUNK16B -o $(@B) ..\$(@B).thk
+
+
+TapiThk.asm TapiFThk.asm Tapi32.asm: ..\TapiThk.inc
+
diff --git a/private/tapi/dev/sp/tsp1632/script/tapi32.inc b/private/tapi/dev/sp/tsp1632/script/tapi32.inc
new file mode 100644
index 000000000..ceb07849a
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapi32.inc
@@ -0,0 +1,11 @@
+; Callback24 PROTO NEAR STDCALL :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD
+;Callback24 PROTO NEAR STDCALL :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD
+
+include thkrp.inc
+include cbcheck.inc
+include thkframe.inc
+include public.inc
+include thkmacro.inc
+
+externDef Callback24:far16
+
diff --git a/private/tapi/dev/sp/tsp1632/script/tapi32.thk b/private/tapi/dev/sp/tsp1632/script/tapi32.thk
new file mode 100644
index 000000000..127088392
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapi32.thk
@@ -0,0 +1,31 @@
+/*
+ * Lzexpand APIs thunks for Win32s
+ */
+//__foldwin32sstuff __foldwin32sstuff;
+//foldstyleinitialization = true;
+
+
+enablemapdirect3216 = true;
+//preload32=true;
+//flatthunks = true;
+
+#include "..\types.thk"
+
+typedef DWORD	HTAPI;
+typedef HTAPI	*LPHTAPI;
+typedef HTAPI	HAPP;
+typedef HAPP	HLINEAPP;
+
+
+// Thunk for callback
+BOOL _TapiCallbackThunk( HLINEAPP hDevice,
+                        DWORD dwMessage,
+                        DWORD dwInstance,
+                        DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3,
+                        DWORD cbProc32)
+{
+   target = Callback28;
+}
+
diff --git a/private/tapi/dev/sp/tsp1632/script/tapicbid.inc b/private/tapi/dev/sp/tsp1632/script/tapicbid.inc
new file mode 100644
index 000000000..06b100729
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapicbid.inc
@@ -0,0 +1,17 @@
+; Callback-type id's for TAPI callbacks. All callback-type id's are
+; 32-bits long and the upper 16-bits must be set to the module's
+; Callback Client id.
+;
+; WARNING -- WARNING -- WARNING
+;
+;   Win32c.dll uses the lower 16 bits of CBID's to index directly into
+;   the tables stored in GDI.EXE (gdicb16.asm) and GDI32.DLL (gdicb32.asm).
+;   Those tables *must* match these id's or callbacks will fail miserably.
+;   Do everyone a big favor and add new id's only at the end, and never
+;   change an existing id.
+;   
+
+ID_LINEINITIALIZE		equ	0
+ID_PHONEINITIALIZE		equ	1
+ID_LINESHUTDOWN			equ	2
+ID_PHONESHUTDOWN		equ	3
diff --git a/private/tapi/dev/sp/tsp1632/script/tapifthk.inc b/private/tapi/dev/sp/tsp1632/script/tapifthk.inc
new file mode 100644
index 000000000..e2099aa99
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapifthk.inc
@@ -0,0 +1 @@
+; empty file !
diff --git a/private/tapi/dev/sp/tsp1632/script/tapifthk.thk b/private/tapi/dev/sp/tsp1632/script/tapifthk.thk
new file mode 100644
index 000000000..ff6cc6fdd
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapifthk.thk
@@ -0,0 +1,587 @@
+/*
+ * Lzexpand APIs thunks for Win32s
+ */
+//__foldwin32sstuff __foldwin32sstuff;
+//foldstyleinitialization = true;
+
+enablemapdirect1632 = true;
+//preload32=true;
+//flatthunks = false;
+
+#include "..\types.thk"
+
+typedef DWORD	HTAPI;
+typedef HTAPI	*LPHTAPI;
+typedef HTAPI	HAPP;
+typedef HAPP 	*LPHAPP;	
+typedef HTAPI	HLINEAPP;
+typedef HTAPI	HPHONEAPP;
+typedef HTAPI	HCALL;
+typedef HCALL	*LPHCALL;	
+typedef HTAPI	HLINE;
+typedef HLINE	*LPHLINE;	
+typedef HTAPI	HPHONE;
+typedef HPHONE	*LPHPHONE;	
+typedef HICON	*LPHICON;
+typedef LPSTR	LPCSTR;
+/* LPVOID in types.thk */
+typedef LPVOID	LPLINETRANSLATEOUTPUT;		/* LP to data structure */
+typedef LPVOID	LPLINETRANSLATECAPS;		/* LP to data structure */
+typedef LPVOID	LPLINEFORWARDLIST;
+typedef LPVOID	LPLINECALLPARAMS;
+typedef LPVOID	LPLINEGENERATETONE;
+typedef LPVOID	LPLINEADDRESSCAPS;
+typedef LPVOID	LPLINEADDRESSSTATUS;
+typedef LPVOID	LPLINECALLINFO;
+typedef LPVOID	LPLINECALLSTATUS;
+typedef LPVOID	LPLINECALLLIST;
+typedef LPVOID	LPLINEDEVCAPS;
+typedef LPVOID	LPLINEDEVSTATUS;
+typedef LPVOID	LPLINEMONITORTONE;
+typedef LPVOID	LPLINEEXTENSIONID;
+typedef LPVOID	LPVARSTRING;
+typedef LPVOID	LPLINEDIALPARAMS;
+typedef LPVOID	LPLINEMEDIACONTROLDIGIT;
+typedef LPVOID	LPLINEMEDIACONTROLMEDIA;
+typedef LPVOID	LPLINEMEDIACONTROLTONE;
+typedef LPVOID	LPLINEMEDIACONTROLCALLSTATE;
+typedef	LPVOID	LPPHONEBUTTONINFO;
+typedef	LPVOID	LPPHONECAPS;
+typedef	LPVOID	LPPHONESTATUS;
+typedef	LPVOID	LPPHONEEXTENSIONID;
+typedef	LPVOID	LPLINECOUNTRYLIST;
+typedef LPVOID	LPLINEPROVIDERLIST;
+
+
+
+//
+//
+typedef DWORD     DRV_REQUESTID;
+typedef DWORD     HDRVLINE;
+typedef DWORD     HDRVPHONE;
+typedef DWORD     HTAPICALL;
+typedef DWORD     HTAPILINE;
+typedef DWORD     HDRVCALL;
+typedef HDRVCALL  * LPHDRVCALL;
+typedef HDRVLINE  * LPHDRVLINE;
+typedef HDRVPHONE * LPHDRVPHONE;
+
+typedef DWORD  HTAPIPHONE;
+
+typedef DWORD	LINEEVENT;
+typedef DWORD	PHONEEVENT;
+
+typedef LPVOID ASYNC_COMPLETION;
+
+typedef DWORD  HPROVIDER;
+//
+//
+
+
+
+
+
+
+//UINT GetTapiHInst(void) =
+//UINT GetTapiHInst(void)
+//{}
+
+
+UINT NewData(void) =
+UINT NewData(void)
+{}
+
+UINT NewData2(void) =
+UINT NewData2(void)
+{}
+
+
+
+/* Tapi Address Translation procedures */
+
+LONG  TSPI_lineSetCurrentLocation (DWORD dwLocation) =
+LONG  TSPI_lineSetCurrentLocation (DWORD dwLocation)
+{}
+
+//LONG lineSetTollList (HLINEAPP hLineApp, DWORD dwPermanentLineID, LPCSTR lpszAddressIn, DWORD dwTollListOption) =
+//LONG lineSetTollList (HLINEAPP hLineApp, DWORD dwPermanentLineID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
+//{}
+
+//LONG lineTranslateAddress (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, 
+//                DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput) =
+//LONG lineTranslateAddress (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, 
+//                DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
+//{}
+
+//LONG lineGetTranslateCaps (HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps) =
+//LONG lineGetTranslateCaps (HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
+//{}
+
+
+/* Tapi function prototypes */
+
+LONG  TSPI_lineAccept (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineAccept (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HDRVCALL hdConsultCall) =
+LONG  TSPI_lineAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HDRVCALL hdConsultCall)
+{}
+
+LONG  TSPI_lineAnswer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineAnswer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineBlindTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode) =
+LONG  TSPI_lineBlindTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{}
+
+LONG  TSPI_lineClose (HDRVLINE hdLine) =
+LONG  TSPI_lineClose (HDRVLINE hdLine)
+{}
+
+LONG  TSPI_lineCloseCall(HDRVCALL hdCall) =
+LONG  TSPI_lineCloseCall(HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineConditionalMediaDetection (HDRVLINE hdLine, DWORD dwMediaModes, LPLINECALLPARAMS lpLineCallParams) =
+LONG  TSPI_lineConditionalMediaDetection (HDRVLINE hdLine, DWORD dwMediaModes, LPLINECALLPARAMS lpLineCallParams)
+{}
+
+LONG  TSPI_lineConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{}
+
+//LONG lineDeallocateCall (HDRVCALL hdCall) =
+//LONG lineDeallocateCall (HDRVCALL hdCall)
+//{}
+
+LONG  TSPI_lineDial (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode) =
+LONG  TSPI_lineDial (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{}
+
+LONG  TSPI_lineDrop (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineDrop (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineDropNoOwner (HDRVCALL hdCall) =
+LONG  TSPI_lineDropNoOwner (HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineDropOnClose (HDRVCALL hdCall) =
+LONG  TSPI_lineDropOnClose (HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineGenerateDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitMode, LPCSTR lpszDigits, DWORD dwDuration) =
+LONG  TSPI_lineGenerateDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitMode, LPCSTR lpszDigits, DWORD dwDuration)
+{}
+
+LONG  TSPI_lineGenerateTone (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE  lpTones) =
+LONG  TSPI_lineGenerateTone (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE  lpTones)
+{}
+
+LONG  TSPI_lineGetAddressCaps (DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, 
+		DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps) =
+LONG  TSPI_lineGetAddressCaps (DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, 
+		DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
+{}
+
+LONG  TSPI_lineGetAddressID (HDRVLINE hdLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize) =
+LONG  TSPI_lineGetAddressID (HDRVLINE hdLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
+{}
+
+LONG  TSPI_lineGetAddressStatus (HDRVLINE hdLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus) =
+LONG  TSPI_lineGetAddressStatus (HDRVLINE hdLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
+{}
+
+LONG  TSPI_lineGetCallAddressID (HDRVCALL hdCall, LPDWORD lpdwAddressID) =
+LONG  TSPI_lineGetCallAddressID (HDRVCALL hdCall, LPDWORD lpdwAddressID)
+{}
+
+LONG  TSPI_lineGetCallInfo (HDRVCALL hdCall, LPLINECALLINFO lpCallInfo) =
+LONG  TSPI_lineGetCallInfo (HDRVCALL hdCall, LPLINECALLINFO lpCallInfo)
+{}
+
+LONG  TSPI_lineGetCallStatus (HDRVCALL hdCall, LPLINECALLSTATUS lpCallStatus) =
+LONG  TSPI_lineGetCallStatus (HDRVCALL hdCall, LPLINECALLSTATUS lpCallStatus)
+{}
+
+//LONG lineGetConfRelatedCalls (HDRVCALL hdCall, LPLINECALLLIST lpCallList) =
+//LONG lineGetConfRelatedCalls (HDRVCALL hdCall, LPLINECALLLIST lpCallList)
+//{} 
+ 
+LONG  TSPI_lineGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps) =
+LONG  TSPI_lineGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
+{}
+
+LONG  TSPI_lineGetDevConfig (DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineGetDevConfig (DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_lineGetExtensionID (DWORD dwDeviceID, DWORD dwTSPIVersion, LPLINEEXTENSIONID lpExtensionID) =
+LONG  TSPI_lineGetExtensionID (DWORD dwDeviceID, DWORD dwTSPIVersion, LPLINEEXTENSIONID lpExtensionID)
+{}
+
+//LONG lineGetNewCalls (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList) =
+//LONG lineGetNewCalls (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
+//{}
+
+LONG  TSPI_lineGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon) =
+LONG  TSPI_lineGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon)
+{} 
+ 
+LONG  TSPI_lineGetID (HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineGetID (HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_lineGetLineDevStatus (HDRVLINE hdLine, LPLINEDEVSTATUS lpLineDevStatus) =
+LONG  TSPI_lineGetLineDevStatus (HDRVLINE hdLine, LPLINEDEVSTATUS lpLineDevStatus)
+{}
+
+LONG  TSPI_lineGetNumAddressIDs (HDRVLINE hdLine, LPDWORD lpdwNumAddressIDS) =
+LONG  TSPI_lineGetNumAddressIDs (HDRVLINE hdLine, LPDWORD lpdwNumAddressIDS)
+{}
+
+//LONG lineGetNumRings (HDRVLINE hdLine, DWORD dwAddressID, LPDWORD lpdwNumRings) =
+//LONG lineGetNumRings (HDRVLINE hdLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
+//{}
+
+//LONG lineGetRequest (HDRVLINEAPP hdLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer) =
+//LONG lineGetRequest (HDRVLINEAPP hdLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
+//{}
+
+//LONG lineGetStatusMessages (HDRVLINE hdLine, LPDWORD lpdwLineStates, LPDWORD lpdwAddressStates) =
+//LONG lineGetStatusMessages (HDRVLINE hdLine, LPDWORD lpdwLineStates, LPDWORD lpdwAddressStates)
+//{}
+
+//LONG lineHandoff (HDRVCALL hdCall, LPCSTR lpszModuleName, DWORD dwMediaMode) =
+//LONG lineHandoff (HDRVCALL hdCall, LPCSTR lpszModuleName, DWORD dwMediaMode)
+//{}
+
+LONG  TSPI_lineHold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineHold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineReleaseUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineReleaseUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineMonitorDigits (HDRVCALL hdCall, DWORD dwDigitModes) =
+LONG  TSPI_lineMonitorDigits (HDRVCALL hdCall, DWORD dwDigitModes)
+{}
+
+LONG  TSPI_lineMonitorMedia (HDRVCALL hdCall, DWORD dwMediaModes) =
+LONG  TSPI_lineMonitorMedia (HDRVCALL hdCall, DWORD dwMediaModes)
+{}
+
+LONG  TSPI_lineMonitorTones (HDRVCALL hdCall, DWORD dwToneListID, LPLINEMONITORTONE  lpToneList, DWORD dwNumEntries) =
+LONG  TSPI_lineMonitorTones (HDRVCALL hdCall, DWORD dwToneListID, LPLINEMONITORTONE  lpToneList, DWORD dwNumEntries)
+{}
+
+LONG  TSPI_lineNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion) =
+LONG  TSPI_lineNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTsPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion)
+{}
+
+LONG  TSPI_lineNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwLowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion) =
+LONG  TSPI_lineNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwLowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion)
+{}
+
+LONG  TSPI_lineOpen (DWORD dwDeviceID, HTAPILINE htLine, LPHDRVLINE lphdLine, DWORD dwTSPIVersion,
+                LINEEVENT lpfnEventProc) =
+LONG  TSPI_lineOpen (DWORD dwDeviceID, HTAPILINE htLine, LPHDRVLINE lphdLine, DWORD dwTSPIVersion,
+                LINEEVENT lpfnEventProc)
+{}
+
+LONG  TSPI_lineRedirect (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode) =
+LONG  TSPI_lineRedirect (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{}
+
+LONG  TSPI_lineRemoveFromConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineRemoveFromConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineSecureCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineSecureCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineSelectExtVersion (HDRVLINE hdLine, DWORD dwExtVersion) =
+LONG  TSPI_lineSelectExtVersion (HDRVLINE hdLine, DWORD dwExtVersion)
+{}
+
+LONG  TSPI_lineSendUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineSendUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineSetAppSpecific (HDRVCALL hdCall, DWORD dwAppSpecific) =
+LONG  TSPI_lineSetAppSpecific (HDRVCALL hdCall, DWORD dwAppSpecific)
+{}
+
+LONG  TSPI_lineSetCallParams (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS  lpDialParams) =
+LONG  TSPI_lineSetCallParams (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS  lpDialParams)
+{}
+
+//LONG lineSetCallPrivilege (HDRVCALL hdCall, DWORD dwCallPrivilege) =
+//LONG lineSetCallPrivilege (HDRVCALL hdCall, DWORD dwCallPrivilege)
+//{}
+
+LONG  TSPI_lineSetDevConfig (DWORD dwDeviceID, LPVOID  lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineSetDevConfig (DWORD dwDeviceID, LPVOID  lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_lineSetMediaControl (HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPLINEMEDIACONTROLDIGIT  lpDigitList, DWORD dwDigitNumEntries, 
+        LPLINEMEDIACONTROLMEDIA  lpMediaList, DWORD dwMediaNumEntries, LPLINEMEDIACONTROLTONE  lpToneList, DWORD dwToneNumEntries, LPLINEMEDIACONTROLCALLSTATE  lpCallStateList, DWORD dwCallStateNumEntries) =
+LONG  TSPI_lineSetMediaControl (HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPLINEMEDIACONTROLDIGIT  lpDigitList, DWORD dwDigitNumEntries, 
+        LPLINEMEDIACONTROLMEDIA  lpMediaList, DWORD dwMediaNumEntries, LPLINEMEDIACONTROLTONE  lpToneList, DWORD dwToneNumEntries, LPLINEMEDIACONTROLCALLSTATE  lpCallStateList, DWORD dwCallStateNumEntries)
+{}
+
+LONG  TSPI_lineSetDefaultMediaDetection(HDRVLINE hdLine, DWORD dwMediaModes) =
+LONG  TSPI_lineSetDefaultMediaDetection(HDRVLINE hdLine, DWORD dwMediaModes)
+{}
+
+LONG  TSPI_lineSetMediaMode (HDRVCALL hdCall, DWORD dwMediaModes) =
+LONG  TSPI_lineSetMediaMode (HDRVCALL hdCall, DWORD dwMediaModes)
+{}
+
+//LONG lineSetNumRings (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwNumRings) =
+//LONG lineSetNumRings (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwNumRings)
+//{}
+
+LONG  TSPI_lineSetStatusMessages (HDRVLINE hdLine, DWORD dwLineStates, DWORD dwAddressStates) =
+LONG  TSPI_lineSetStatusMessages (HDRVLINE hdLine, DWORD dwLineStates, DWORD dwAddressStates)
+{}
+
+LONG  TSPI_lineSetTerminal (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, 
+		DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable) =
+LONG  TSPI_lineSetTerminal (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, 
+		DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
+{}
+
+LONG  TSPI_lineSwapHold (DRV_REQUESTID dwRequestID, HDRVCALL hdActiveCall, HDRVCALL hdHeldCall) =
+LONG  TSPI_lineSwapHold (DRV_REQUESTID dwRequestID, HDRVCALL hdActiveCall, HDRVCALL hdHeldCall)
+{}
+
+LONG  TSPI_lineUncompleteCall (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwCompletionID) =
+LONG  TSPI_lineUncompleteCall (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwCompletionID)
+{}
+
+LONG  TSPI_lineUnhold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineUnhold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_phoneClose (HDRVPHONE hdPhone) =
+LONG  TSPI_phoneClose (HDRVPHONE hdPhone)
+{}
+
+LONG  TSPI_phoneConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass) =
+LONG  TSPI_phoneConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_phoneGetButtonInfo (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo) =
+LONG  TSPI_phoneGetButtonInfo (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo)
+{}
+
+LONG  TSPI_phoneGetData (HDRVPHONE hdPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize) =
+LONG  TSPI_phoneGetData (HDRVPHONE hdPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
+{}
+
+LONG  TSPI_phoneGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps) =
+LONG  TSPI_phoneGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps)
+{}
+
+LONG  TSPI_phoneGetDisplay (HDRVPHONE hdPhone, LPVARSTRING lpDisplay) =
+LONG  TSPI_phoneGetDisplay (HDRVPHONE hdPhone, LPVARSTRING lpDisplay)
+{}
+
+LONG  TSPI_phoneGetExtensionID (DWORD dwDevice, DWORD dwTSPIVersion, LPPHONEEXTENSIONID lpExtensionID) =
+LONG  TSPI_phoneGetExtensionID (DWORD dwDevice, DWORD dwTSPIVersion, LPPHONEEXTENSIONID lpExtensionID)
+{}
+
+LONG  TSPI_phoneGetGain (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain) =
+LONG  TSPI_phoneGetGain (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain)
+{}
+
+LONG  TSPI_phoneGetHookSwitch (HDRVPHONE hdPhone, LPDWORD lpdwHookSwitchDevs) =
+LONG  TSPI_phoneGetHookSwitch (HDRVPHONE hdPhone, LPDWORD lpdwHookSwitchDevs)
+{}
+
+LONG  TSPI_phoneGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon) =
+LONG  TSPI_phoneGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon)
+{}
+
+LONG  TSPI_phoneGetID (HDRVPHONE hdPhone, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass) =
+LONG  TSPI_phoneGetID (HDRVPHONE hdPhone, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_phoneGetLamp (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPDWORD lpdwLampMode) =
+LONG  TSPI_phoneGetLamp (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPDWORD lpdwLampMode)
+{}
+
+LONG  TSPI_phoneGetRing (HDRVPHONE hdPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume) =
+LONG  TSPI_phoneGetRing (HDRVPHONE hdPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume)
+{}
+
+LONG  TSPI_phoneGetStatus (HDRVPHONE hdPhone, LPPHONESTATUS lpPhoneStatus) =
+LONG  TSPI_phoneGetStatus (HDRVPHONE hdPhone, LPPHONESTATUS lpPhoneStatus)
+{}
+
+//LONG phoneGetStatusMessages (HDRVPHONE hdPhone, LPDWORD lpdwPhoneStates, LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates) =
+//LONG phoneGetStatusMessages (HDRVPHONE hdPhone, LPDWORD lpdwPhoneStates, LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates)
+//{}
+
+LONG  TSPI_phoneGetVolume (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwVolume) =
+LONG  TSPI_phoneGetVolume (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwVolume)
+{}
+
+LONG  TSPI_phoneNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion) =
+LONG  TSPI_phoneNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion)
+{}
+
+LONG  TSPI_phoneNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwTSPILowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion) =
+LONG  TSPI_phoneNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwTSPILowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion)
+{}
+
+LONG  TSPI_phoneOpen (DWORD dwDeviceID, HTAPIPHONE htPhone, LPHDRVPHONE lphdPhone,
+                DWORD dwTSPIVersion, PHONEEVENT lpfnEventProc) =
+LONG  TSPI_phoneOpen (DWORD dwDeviceID, HTAPIPHONE htPhone, LPHDRVPHONE lphdPhone,
+                DWORD dwTSPIVersion, PHONEEVENT lpfnEventProc)
+{}
+
+LONG  TSPI_phoneSelectExtVersion (HDRVPHONE hdPhone, DWORD dwExtVersion) =
+LONG  TSPI_phoneSelectExtVersion (HDRVPHONE hdPhone, DWORD dwExtVersion)
+{}
+
+LONG  TSPI_phoneSetButtonInfo (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO  lpButtonInfo) =
+LONG  TSPI_phoneSetButtonInfo (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO  lpButtonInfo)
+{}
+
+LONG  TSPI_phoneSetData (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwDataID, LPVOID  lpData, DWORD dwSize) =
+LONG  TSPI_phoneSetData (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwDataID, LPVOID  lpData, DWORD dwSize)
+{}
+
+LONG  TSPI_phoneSetDisplay (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpsDisplay, DWORD dwSize) =
+LONG  TSPI_phoneSetDisplay (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpsDisplay, DWORD dwSize)
+{}
+
+LONG  TSPI_phoneSetGain (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwGain) =
+LONG  TSPI_phoneSetGain (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwGain)
+{}
+
+LONG  TSPI_phoneSetHookSwitch (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode) =
+LONG  TSPI_phoneSetHookSwitch (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode)
+{}
+
+LONG  TSPI_phoneSetLamp (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, DWORD dwLampMode) =
+LONG  TSPI_phoneSetLamp (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, DWORD dwLampMode)
+{}
+
+LONG  TSPI_phoneSetRing (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRingMode, DWORD dwVolume) =
+LONG  TSPI_phoneSetRing (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRingMode, DWORD dwVolume)
+{}
+
+LONG  TSPI_phoneSetStatusMessages (HDRVPHONE hdPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates) =
+LONG  TSPI_phoneSetStatusMessages (HDRVPHONE hdPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates)
+{}
+
+LONG  TSPI_phoneSetVolume (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwVolume) =
+LONG  TSPI_phoneSetVolume (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwVolume)
+{}
+
+
+/* TAPI 1.1 extensions */
+
+
+//LONG lineTranslateDialog (HDRVLINEAPP hdLineApp, DWORD dwDeviceId, DWORD dwAPIVersion, HWND hWnd, LPSTR lpszAddressIn) =
+//LONG lineTranslateDialog (HDRVLINEAPP hdLineApp, DWORD dwDeviceId, DWORD dwAPIVersion, HWND hWnd, LPSTR lpszAddressIn)
+//{}
+
+//LONG lineGetCountry (DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList) =
+//LONG lineGetCountry (DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
+//{}
+
+//LONG lineGetAppPriority (LPCSTR lpszAppName, DWORD dwMediaMode, LPLINEEXTENSIONID lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority) =
+//LONG lineGetAppPriority (LPCSTR lpszAppName, DWORD dwMediaMode, LPLINEEXTENSIONID lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
+//{}
+
+//LONG lineSetAppPriority (LPCSTR lpszAppName, DWORD dwMediaMode, LPLINEEXTENSIONID lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority) =
+//LONG lineSetAppPriority (LPCSTR lpszAppName, DWORD dwMediaMode, LPLINEEXTENSIONID lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
+//{}
+
+//LONG lineAddProvider (LPCSTR lpszProviderFilename, HWND hwndOwner, LPDWORD lpdwPermanentProviderID) =
+//LONG lineAddProvider (LPCSTR lpszProviderFilename, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
+//{}
+
+//LONG lineConfigProvider (HWND hwndOwner, DWORD dwPermanentProviderID) =
+//LONG lineConfigProvider (HWND hwndOwner, DWORD dwPermanentProviderID)
+//{}
+
+//LONG lineRemoveProvider (DWORD dwPermanentProviderID, HWND hwndOwner) =
+//LONG lineRemoveProvider (DWORD dwPermanentProviderID, HWND hwndOwner)
+//{}
+
+//LONG lineGetProviderList (DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList) =
+//LONG lineGetProviderList (DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
+//{}
+
+LONG  TSPI_lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID  lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut) =
+LONG  TSPI_lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID  lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
+{}
+
+
+
+
+LONG TSPI_providerConfig (HWND hwndOwner, DWORD dwPermanentProviderID) =
+LONG TSPI_providerConfig (HWND hwndOwner, DWORD dwPermanentProviderID)
+{}
+
+LONG TSPI_providerCreateLineDevice (DWORD dwTempID, DWORD dwDeviceID ) =
+LONG TSPI_providerCreateLineDevice (DWORD dwTempID, DWORD dwDeviceID )
+{}
+
+LONG TSPI_providerCreatePhoneDevice (DWORD dwTempID, DWORD dwDeviceID ) =
+LONG TSPI_providerCreatePhoneDevice (DWORD dwTempID, DWORD dwDeviceID )
+{}
+
+LONG TSPI_providerEnumDevices(DWORD dwPermanentProviderID,
+                         LPDWORD lpdwNumLines, LPDWORD lpdwNumPhones,
+                         HPROVIDER hProvider, LINEEVENT lpfnLineCreateProc,
+                         PHONEEVENT lpfnPhoneCreateProc) =
+LONG TSPI_providerEnumDevices(DWORD dwPermanentProviderID,
+                         LPDWORD lpdwNumLines, LPDWORD lpdwNumPhones,
+                         HPROVIDER hProvider, LINEEVENT lpfnLineCreateProc,
+                         PHONEEVENT lpfnPhoneCreateProc)
+{}
+
+LONG TSPI_providerInit (DWORD dwTSPIVersion, DWORD dwPermanentProviderID,
+                        DWORD dwLineDeviceIDBase, DWORD dwPhoneDeviceIDBase,
+                        DWORD dwNumLines, DWORD dwNumPhones,
+                        ASYNC_COMPLETION lpfnCompletionProc) =
+LONG TSPI_providerInit (DWORD dwTSPIVersion, DWORD dwPermanentProviderID,
+                        DWORD dwLineDeviceIDBase, DWORD dwPhoneDeviceIDBase,
+                        DWORD dwNumLines, DWORD dwNumPhones,
+                        ASYNC_COMPLETION lpfnCompletionProc)
+{}
+
+LONG TSPI_providerInstall (HWND hwndOwner, DWORD dwPermanentProviderID) =
+LONG TSPI_providerInstall (HWND hwndOwner, DWORD dwPermanentProviderID)
+{}
+
+LONG TSPI_providerRemove (HWND hwndOwner, DWORD dwPermanentProviderID) =
+LONG TSPI_providerRemove (HWND hwndOwner, DWORD dwPermanentProviderID)
+{}
+
+LONG TSPI_providerShutdown (DWORD dwTSPIVersion) =
+LONG TSPI_providerShutdown (DWORD dwTSPIVersion)
+{}
+
+
+// // LONG DllEntryPoint(HANDLE hinstDLL, DWORD dwReason, LPVOID lpReserved) =
+// // LONG DllEntryPoint(HANDLE hinstDLL, DWORD dwReason, LPVOID lpReserved)
+// // {}
diff --git a/private/tapi/dev/sp/tsp1632/script/tapithk.inc b/private/tapi/dev/sp/tsp1632/script/tapithk.inc
new file mode 100644
index 000000000..63ad5baca
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapithk.inc
@@ -0,0 +1,1234 @@
+
+CodeData equ <THUNK16BCodeData>
+
+include thkrp.inc
+include cbcheck.inc
+include thkframe.inc
+include public.inc
+include thkmacro.inc
+;include struc.inc
+
+include cbcid.inc
+include tapicbid.inc
+
+;externDef IsBadCodePtr:far16
+externDef CALLBACK_BODY_16:far16
+externDef Escape:far16
+externDef AllocCallback:far16
+externDef MapLS:far16
+externDef UnmapLS:far16
+ifdef DEBUG
+externDef _wsprintf:far16
+externDef OutputDebugString:far16
+endif
+
+externDef FreeCallback:far16
+
+
+externDef lineInitialize:far16
+externDef phoneInitialize:far16
+externDef lineShutdown:far16
+externDef phoneShutdown:far16
+
+
+public addrCBLineInit	;Address of callback routine passed in lineInitialize
+public addrCBPhoneInit	;Address of callback routine passed in phoneInitialize
+public cbcidTapi	;Callback ID for client returned by RegisterCBClient
+_DATA	  SEGMENT
+addrCBLineInit		dd 0
+addrCBPhoneInit		dd 0
+cbcidTapi		dd 0
+_DATA ENDS
+
+ifdef DEBUG
+;; Writes message to debug port.
+;;
+;; Usage:
+;;	DPRINT "I'm feeling buggy."
+;;
+DPRINT	macro	string
+	local	mes, skip_mes
+
+	jmp	skip_mes
+mes	db	&string&,13,10,0
+skip_mes:
+	push	eax	;Save all registers not preserved by PASCAL format.
+	push	ebx
+	push	ecx
+	push	edx
+	
+	push	cs	;Arg: OutputDebugString(lpstr)
+	push	offset mes
+	call	OutputDebugString
+
+	pop	edx
+	pop	ecx
+	pop	ebx
+	pop	eax
+endm  ;DPRINT
+endif
+
+
+;-----------------------------------------------------------------------;
+; body_LINEINITIALIZE16
+;-----------------------------------------------------------------------;
+body_LINEINITIALIZE16 macro
+
+;LONG lineInitialize16 (LPHLINEAPP lphLineApp,
+;                     HINSTANCE hInstance,
+;                     LINECALLBACK lpfnCallback,
+;                     LPCSTR lpszAppName,
+;                     LPDWORD lpdwNumDevs)
+;
+bp_lphLineApp  		equ     <bp_top>
+bp_hInstance    	equ	<bp_top+4>
+bp_lpfnCallback		equ	<bp_top+8>
+bp_lpszAppName  	equ	<bp_top+12>
+bp_lpdwNumDevs  	equ	<bp_top+16>
+;
+
+bp_lpszAppNameTmp	equ	<dword ptr [bp-4]>
+bp_lpdwNumDevsTmp	equ	<dword ptr [bp-8]>
+bp_lphLineAppTmp	equ	<dword ptr [bp-12]>
+
+        ;
+        ; First order of business: check the code pointer.  If it's
+        ; bogus, we leave.
+        ;
+
+;        push    dword ptr bp_lpfnCallback
+;        call    IsBadCodePtr
+;        or      eax, eax
+;        jnz     DoNothing
+
+	sub	eax, eax
+	push	eax				;bp_lpszAppNameTmp
+	push	eax				;bp_lpdwNumDevsTmp
+	push	eax				;bp_lphLineAppTmp
+
+	push	dword ptr bp_lphLineApp
+	call	MapLS
+	mov	bp_lphLineAppTmp, eax
+	push	eax
+
+        mov     eax, dword ptr bp_hInstance     ; Get the hInst
+        or	eax, eax                        ; Is it NULL?
+        jz	@f                              ; Yup, and that's ok.
+	MAP_NULL_HINST eax                      ; Needs to be mapped.
+        push    ax
+
+;	mov	ax, seg addrCBLineInit
+;	mov	ds, ax
+;	mov	eax, dword ptr bp_lpfnCallback
+;	mov	addrCBLineInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_LINEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+
+	push	dword ptr bp_lpfnCallback
+
+	push	dword ptr bp_lpszAppName
+	call	MapLS
+	mov	bp_lpszAppNameTmp, eax
+	push	eax
+
+	push	dword ptr bp_lpdwNumDevs
+	call	MapLS
+	mov	bp_lpdwNumDevsTmp, eax
+	push	eax
+
+
+	call	lineInitialize
+
+
+	shl	eax,16                          ; Convert the 16bit retcode...
+	shrd	eax,edx,16                      ; to a 32bit retcode.
+
+	push	eax                             ; Save the retcode for later.
+
+	push	dword ptr bp_lpdwNumDevsTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lpszAppNameTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lphLineAppTmp
+	call	UnMapLS
+
+	pop	eax                             ; Get the retcode
+
+;DoNothing:
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_PHONEINITIALIZE
+;-----------------------------------------------------------------------;
+body_PHONEINITIALIZE16 macro
+
+;LONG phoneInitialize (LPHPHONEAPP lphPhoneApp,
+;                      HINSTANCE hInstance,
+;                      PHONECALLBACK lpfnCallback,
+;                      LPCSTR lpszAppName,
+;                      LPDWORD lpdwNumDevs)
+;
+bp_lphPhoneApp  	equ     <bp_top>
+bp_hInstance    	equ	<bp_top+4>
+bp_lpfnCallback		equ	<bp_top+8>
+bp_lpszAppName  	equ	<bp_top+12>
+bp_lpdwNumDevs  	equ	<bp_top+16>
+;
+
+bp_lpszAppNameTmp	equ	<dword ptr [bp-4]>
+bp_lpdwNumDevsTmp	equ	<dword ptr [bp-8]>
+bp_lphPhoneAppTmp	equ	<dword ptr [bp-12]>
+
+	sub	eax, eax
+	push	eax				;bp_lpszAppNameTmp
+	push	eax				;bp_lpdwNumDevsTmp
+	push	eax				;bp_lphPhoneAppTmp
+
+	push	dword ptr bp_lphPhoneApp
+	call	MapLS
+	mov	bp_lphPhoneAppTmp, eax
+	push	eax
+
+        mov     eax, dword ptr bp_hInstance     ; Get the hInst
+        or	eax, eax                        ; Is it NULL?
+        jz	@f                              ; Yup, and that's ok.
+	MAP_NULL_HINST eax                      ; Needs to be mapped.
+        push    ax
+
+;	mov	ax, seg addrCBPhoneInit
+;	mov	ds, ax
+;	mov	eax, dword ptr bp_lpfnCallback
+;	mov	addrCBPhoneInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_PHONEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+	push    dword ptr bp_lpfnCallback
+
+	push	dword ptr bp_lpszAppName
+	call	MapLS
+	mov	bp_lpszAppNameTmp, eax
+	push	eax
+
+	push	dword ptr bp_lpdwNumDevs
+	call	MapLS
+	mov	bp_lpdwNumDevsTmp, eax
+	push	eax
+
+
+	call	phoneInitialize
+
+
+	shl	eax,16                          ; Convert the 16bit retcode...
+	shrd	eax,edx,16                      ; to a 32bit retcode.
+
+	push	eax                             ; Save the retcode for later.
+
+	push	dword ptr bp_lpdwNumDevsTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lpszAppNameTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lphPhoneAppTmp
+	call	UnMapLS
+
+	pop	eax                             ; Get the retcode
+
+endm
+
+
+;-----------------------------------------------------------------------;
+;-----------------------------------------------------------------------;
+;PUSH__LINEINITIALIZE_hInstance	macro	iOffset, iJunk
+;   local   Null_OK
+;	
+;    mov	eax, [bp+iOffset]	;;Allow NULL to be passed here (for now)
+;    or	eax, eax
+;    jz	Null_OK
+;    MAP_NULL_HINST eax
+;Null_OK:
+;    push    ax
+;
+;endm ;PUSH__LINEINITIALIZE_hInstance
+;
+;
+;-----------------------------------------------------------------------;
+;-----------------------------------------------------------------------;
+;PUSH__PHONEINITIALIZE_hInstance	macro	iOffset, iJunk
+;   local   Null_OK
+;	
+;    mov	eax, [bp+iOffset]	;;Allow NULL to be passed here (for now)
+;    or	eax, eax
+;    jz	Null_OK
+;    MAP_NULL_HINST eax
+;Null_OK:
+;    push    ax
+;
+;endm ;PUSH__PHONEINITIALIZE_hInstance
+;
+;
+;;-----------------------------------------------------------------------;
+;; PUSH__LINEINITIALIZE_lpfnCallback (similar to PUSH_SetAbortProc_pfnAbort)
+;;-----------------------------------------------------------------------;
+;PUSH__LINEINITIALIZE_lpfnCallback    macro iOffset, iTempOffset
+;;	assume	ds:DATA16
+;
+;	mov	ax, seg addrCBLineInit
+;	mov	ds, ax
+;
+;	mov	eax, dword ptr [bp+iOffset]
+;	mov	addrCBLineInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_LINEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+;endm
+;
+;
+;-----------------------------------------------------------------------;
+; PUSH__PHONEINITIALIZE_lpfnCallback
+;-----------------------------------------------------------------------;
+;PUSH__PHONEINITIALIZE_lpfnCallback    macro iOffset, iTempOffset
+;	assume	ds:DATA16
+;	mov	ax, seg addrCBPhoneInit
+;	mov	ds, ax
+;
+;	mov	eax, dword ptr [bp+iOffset]
+;	mov	addrCBPhoneInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_PHONEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+;endm
+
+
+;==============================================================================
+; local macro, free resources allocated for a call-back function
+; check if it is a NULL pointer before calling FreeCallBack.
+; eax contains the 32-bit address of the mapped call-back function
+; ecx contains the callback ID ((cbcidTapi << 16) + ID[PHONE/LINE]INITIALIZE)
+;==============================================================================
+;FREE_CALLBACK_TAPI  macro
+;        local   done
+;
+;        or      eax,eax
+;        jz      done                            ;don't process NULL pointers
+;
+;        push    bx                              ;save BX
+;        push    es                              ;save ES
+;
+;        push    eax                             ;32-bit callback address
+;        push    ecx
+;        call    FreeCallback
+;
+;        pop     es                              ;restore ES
+;        pop     bx                              ;restore BX
+;done:
+;endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINESHUTDOWN
+; Use FREE_CALLBACK instead of directly calling FreeCallback so that we
+; check for NULL pointers.
+;-----------------------------------------------------------------------;
+body_LINESHUTDOWN16 macro
+bp_hLineApp     equ     <bp_top>
+;	assume	ds:DATA16
+	mov	ax, seg addrCBLineInit
+	mov	ds, ax
+
+	mov	eax, dword ptr bp_hLineApp
+	push	eax
+ifdef DEBUG
+	int	3
+endif
+	call	lineShutdown
+
+; return code long --> long
+	rol	eax,16
+	xchg	ax,dx
+	rol	eax,16
+
+;	push	eax	;; Save
+;	push	ecx	;; Save
+;
+;	mov	eax,  addrCBLineInit
+;
+;	mov	ecx, cbcidTapi
+;	shl	ecx, 16
+;	add	ecx, ID_LINEINITIALIZE
+;
+;	FREE_CALLBACK_TAPI
+;
+;	pop	ecx
+;	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_PHONESHUTDOWN
+;-----------------------------------------------------------------------;
+body_PHONESHUTDOWN16 macro
+bp_hLineApp     equ     <bp_top>
+;	assume	ds:DATA16
+	mov	ax, seg addrCBPhoneInit
+	mov	ds, ax
+
+	mov	eax, dword ptr bp_hLineApp
+	push	eax
+	call	phoneShutdown
+
+; return code long --> long
+	rol	eax,16
+	xchg	ax,dx
+	rol	eax,16
+
+;	push	eax	;; Save it
+;	push	ecx	;; Save it
+;
+;	mov	eax,  addrCBPhoneInit
+;
+;	mov	ecx, cbcidTapi
+;	shl	ecx, 16
+;	add	ecx, ID_PHONEINITIALIZE
+;
+;	FREE_CALLBACK_TAPI
+;
+;	pop	ecx
+;	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEFORWARD
+;-----------------------------------------------------------------------;
+body_LINEFORWARD macro
+
+bp_hLine     		equ     <bp_top>
+bp_bAllAddresses	equ	<bp_top+4>
+bp_dwAddressID		equ	<bp_top+8>
+bp_lpForwardList	equ	<bp_top+12>
+bp_dwNumRingsNoAnswer	equ	<bp_top+16>
+bp_lphConsultCall	equ	<bp_top+20>
+bp_lpCallParams		equ	<bp_top+24>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  bAllAddresses
+; dword ptr [ebp+16]:  dwAddressID
+; dword ptr [ebp+20]:  lpForwardList
+; dword ptr [ebp+24]:  dwNumRingsNoAnswer
+; dword ptr [ebp+28]:  lphConsultCall
+; dword ptr [ebp+32]:  lpCallParams
+;
+
+bp_lpForwardListTmp	equ	<dword ptr [bp-4]>
+bp_lphConsultCallTmp	equ	<dword ptr [bp-8]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-12]>
+
+
+	sub	eax, eax
+	push	eax				;bp_lpForwardListTmp
+	push	eax				;bp_lphConsultCallTmp
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_bAllAddresses	;bAllAddresses: dword->dword
+	push	dword ptr bp_dwAddressID	;dwAddressID: dword->dword
+	push	dword ptr bp_lpForwardList
+	call	MapLS
+	mov	bp_lpForwardListTmp, eax
+	push	eax
+	push	dword ptr bp_dwNumRingsNoAnswer	;dwNumRingsNoAnswer: dword->dword
+	push	dword ptr bp_lphConsultCall
+	call	MapLS
+	mov	bp_lphConsultCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	lineForward
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+	push	dword ptr bp_lpForwardListTmp
+	call	UnMapLS
+;
+; Don't UnMap lphConsultCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphConsultCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEMAKECALL
+;-----------------------------------------------------------------------;
+body_LINEMAKECALL macro
+
+bp_hLine     		equ     <bp_top>
+bp_lphCall		equ	<bp_top+4>
+bp_lpszDestAddress	equ	<bp_top+8>
+bp_dwCountryCode	equ	<bp_top+12>
+bp_lpCallParams		equ	<bp_top+16>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  lphCall
+; dword ptr [ebp+16]:  lpszDestAddress
+; dword ptr [ebp+20]:  dwCountryCode
+; dword ptr [ebp+24]:  lpCallParams
+;
+
+bp_lphCallTmp		equ	<dword ptr [bp-4]>
+bp_lpszDestAddressTmp	equ	<dword ptr [bp-8]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-12]>
+
+
+	sub	eax, eax
+	push	eax				;bp_lphCallTmp
+	push	eax				;bp_lpszDestAddress
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_lphCall
+	call	MapLS
+	mov	bp_lphCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpszDestAddress
+	call	MapLS
+	mov	bp_lpszDestAddressTmp, eax
+	push	eax
+	push	dword ptr bp_dwCountryCode	;dwCountryCode: dword->dword
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+	
+	call	lineMakeCall
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszDestAddressTmp
+	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEUNPARK
+;-----------------------------------------------------------------------;
+body_LINEUNPARK macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwAddressID		equ	<bp_top+4>
+bp_lphCall		equ	<bp_top+8>
+bp_lpszDestAddress	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwAddressID
+; dword ptr [ebp+16]:  lphCall
+; dword ptr [ebp+20]:  lpszDestAddress
+;
+
+bp_lphCallTmp		equ	<dword ptr [bp-4]>
+bp_lpszDestAddressTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lphCallTmp
+	push	eax				;bp_lpszDestAddress
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwCountryCode	;dwCountryCode: dword->dword
+	push	dword ptr bp_lphCall
+	call	MapLS
+	mov	bp_lphCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpszDestAddress
+	call	MapLS
+	mov	bp_lpszDestAddressTmp, eax
+	push	eax
+
+	call	lineUnpark
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszDestAddressTmp
+	call	UnMapLS
+	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEPICKUP
+;-----------------------------------------------------------------------;
+body_LINEPICKUP macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwAddressID		equ	<bp_top+4>
+bp_lphCall		equ	<bp_top+8>
+bp_lpszDestAddress	equ	<bp_top+12>
+bp_lpszGroupID		equ	<bp_top+16>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwAddressID
+; dword ptr [ebp+16]:  lphCall
+; dword ptr [ebp+20]:  lpszDestAddress
+; dword ptr [ebp+24]:  lpszGroupID
+;
+
+bp_lphCallTmp		equ	<dword ptr [bp-4]>
+bp_lpszDestAddressTmp	equ	<dword ptr [bp-8]>
+bp_lpszGroupIDTmp	equ	<dword ptr [bp-12]>
+
+	sub	eax, eax
+	push	eax				;bp_lphCallTmp
+	push	eax				;bp_lpszDestAddressTmp
+	push	eax				;bp_lpszGroupIDTmp
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwAddressID	;dwAddressID: dword->dword
+	push	dword ptr bp_lphCall
+	call	MapLS
+	mov	bp_lphCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpszDestAddress
+	call	MapLS
+	mov	bp_lpszDestAddressTmp, eax
+	push	eax
+	push	dword ptr bp_lpszGroupID
+	call	MapLS
+	mov	bp_lpszGroupIDTmp, eax
+	push	eax
+
+	call	linePickup
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszDestAddressTmp
+	call	UnMapLS
+	push	dword ptr bp_lpszGroupIDTmp
+	call	UnMapLS
+	pop	eax
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINESETUPCONFERENCE
+;-----------------------------------------------------------------------;
+body_LINESETUPCONFERENCE macro
+
+bp_hCall     		equ     <bp_top>
+bp_hLine     		equ     <bp_top+4>
+bp_lphConfCall		equ	<bp_top+8>
+bp_lphConsultCall	equ	<bp_top+12>
+bp_dwNumParties		equ	<bp_top+16>
+bp_lpCallParams		equ	<bp_top+20>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  hLine
+; dword ptr [ebp+16]:  lphConfCall
+; dword ptr [ebp+20]:  lphConsultCall
+; dword ptr [ebp+24]:  dwNumParties
+; dword ptr [ebp+28]:  lpCallParams
+;
+
+bp_lphConfCallTmp	equ	<dword ptr [bp-4]>
+bp_lphConsultCallTmp	equ	<dword ptr [bp-8]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-12]>
+
+	sub	eax, eax
+	push	eax				;bp_lphConfCallTmp
+	push	eax				;bp_lphConsultCallTmp
+	push	eax				;bp_lpCallParamsTmp
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_lphConfCall
+	call	MapLS
+	mov	bp_lphConfCallTmp, eax
+	push	eax
+	push	dword ptr bp_lphConsultCall
+	call	MapLS
+	mov	bp_lphConsultCallTmp, eax
+	push	eax
+	push	dword ptr bp_dwNumParties	;dwNumParties: dword->dword
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	lineSetupConference
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphConfCallTmp and lphConsultCallTmp: Done in tapi.dll
+; due to async read/write.
+;
+;	push	dword ptr bp_lphConfCallTmp
+;	call	UnMapLS
+;	push	dword ptr bp_lphConsultCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINECOMPLETETRANSFER
+;-----------------------------------------------------------------------;
+body_LINECOMPLETETRANSFER macro
+
+bp_hCall     		equ     <bp_top>
+bp_hConsultCall		equ     <bp_top+4>
+bp_lphConfCall		equ	<bp_top+8>
+bp_dwTransferMode	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  hConsultCall
+; dword ptr [ebp+16]:  lphConfCall
+; dword ptr [ebp+20]:  dwTransferMode
+;
+
+bp_lphConfCallTmp	equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lphConfCallTmp
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_hConsultCall	;hConsultCall: dword->dword
+	push	dword ptr bp_lphConfCall
+	call	MapLS
+	mov	bp_lphConfCallTmp, eax
+	push	eax
+	push	dword ptr bp_dwTransferMode	;dwTransferMode: dword->dword
+
+	call	lineCompleteTransfer
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lphConfCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphConfCallTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEPREPAREADDTOCONFERENCE
+;-----------------------------------------------------------------------;
+body_LINEPREPAREADDTOCONFERENCE macro
+
+bp_hConfCall     	equ     <bp_top>
+bp_lphAddCall		equ	<bp_top+4>
+bp_lpCallParams		equ	<bp_top+8>
+;
+; dword ptr [ebp+8]:  hConfCall
+; dword ptr [ebp+12]:  lphAddCall
+; dword ptr [ebp+16]:  lpCallParams
+;
+
+bp_lphAddCallTmp	equ	<dword ptr [bp-4]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lphAddCallTmp
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hConfCall		;hConfCall: dword->dword
+	push	dword ptr bp_lphAddCall
+	call	MapLS
+	mov	bp_lphAddCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	linePrepareAddToConference
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax                             ; Save it
+
+;
+; Don't UnMap lphAddCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphAddCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINESETUPTRANSFER
+;-----------------------------------------------------------------------;
+body_LINESETUPTRANSFER macro
+
+bp_hCall     		equ     <bp_top>
+bp_lphConsultCall	equ	<bp_top+4>
+bp_lpCallParams		equ	<bp_top+8>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  lphConsultCall
+; dword ptr [ebp+16]:  lpCallParams
+;
+
+bp_lphConsultCallTmp	equ	<dword ptr [bp-4]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lphConsultCallTmp
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_lphConsultCall
+	call	MapLS
+	mov	bp_lphConsultCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	lineSetupTransfer
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax                             ; Save it
+
+;
+; Don't UnMap lphConsultCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphConsultCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+
+
+;-----------------------------------------------------------------------;
+; body_LINECOMPLETECALL
+;-----------------------------------------------------------------------;
+body_LINECOMPLETECALL macro
+
+bp_hCall     		equ     <bp_top>
+bp_lpdwCompletionID	equ	<bp_top+4>
+bp_dwCompletionMode	equ	<bp_top+8>
+bp_dwMessageID		equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  lpdwCompletionID
+; dword ptr [ebp+16]:  dwCompletionMode
+; dword ptr [ebp+20]:  dwMessageID
+;
+
+bp_lpdwCompletionIDTmp	equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lpdwCompletionID
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_lpdwCompletionID
+	call	MapLS
+	mov	bp_lpdwCompletionIDTmp, eax
+	push	eax
+	push	dword ptr bp_dwCompletionMode
+	push	dword ptr bp_dwMessageID
+
+	call	lineCompleteCall
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpdwCompletionIDTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpdwCompletionIDTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+        
+;-----------------------------------------------------------------------;
+; body_LINEDEVSPECIFIC
+;-----------------------------------------------------------------------;
+body_LINEDEVSPECIFIC macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwAddressID		equ	<bp_top+4>
+bp_hCall     		equ     <bp_top+8>
+bp_lpParams		equ	<bp_top+12>
+bp_dwSize		equ	<bp_top+16>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwAddressID
+; dword ptr [ebp+16]:  hCall
+; dword ptr [ebp+20]:  lpParams
+; dword ptr [ebp+24]:  dwSize
+;
+
+bp_lpParamsTmp		equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lpParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwAddressID	;dwAddressID: dword->dword
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_lpParams
+	call	MapLS
+	mov	bp_lpParamsTmp, eax
+	push	eax
+	push	dword ptr bp_dwSize		;dwSize: dword->dword
+
+	call	lineDevSpecific
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpParams: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpParamsTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+;-----------------------------------------------------------------------;
+; body_PHONEDEVSPECIFIC
+;-----------------------------------------------------------------------;
+body_PHONEDEVSPECIFIC macro
+
+bp_hPhone     		equ     <bp_top>
+bp_lpParams		equ	<bp_top+4>
+bp_dwSize		equ	<bp_top+8>
+;
+; dword ptr [ebp+8]:  hPhone
+; dword ptr [ebp+12]:  lpParams
+; dword ptr [ebp+16]:  dwSize
+;
+
+;bp_lpParamsTmp		equ	<dword ptr [bp-4]>
+;
+	sub	eax, eax
+	push	eax				;bp_lpParams
+
+	push	dword ptr bp_hPhone		;hPhone: dword->dword
+	push	dword ptr bp_lpParams
+	call	MapLS
+	mov	bp_lpParamsTmp, eax
+	push	eax
+	push	dword ptr bp_dwSize		;dwSize: dword->dword
+
+	call	phoneDevSpecific
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpParams: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpParamsTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINEDEVSPECIFICFEATURE
+;-----------------------------------------------------------------------;
+body_LINEDEVSPECIFICFEATURE macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwFeature		equ	<bp_top+4>
+bp_lpParams		equ	<bp_top+8>
+bp_dwSize		equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwFeature
+; dword ptr [ebp+16]:  lpParams
+; dword ptr [ebp+20]:  dwSize
+;
+
+bp_lpParamsTmp		equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lpParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwFeature		;dwFeature: dword->dword
+	push	dword ptr bp_lpParams
+	call	MapLS
+	mov	bp_lpParamsTmp, eax
+	push	eax
+	push	dword ptr bp_dwSize		;dwSize: dword->dword
+
+	call	lineDevSpecificFeature
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpParams: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpParamsTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEGATHERDIGITS
+;-----------------------------------------------------------------------;
+body_LINEGATHERDIGITS macro
+
+bp_hCall     		equ     <bp_top>
+bp_dwDigitModes		equ	<bp_top+4>
+bp_lpsDigits		equ	<bp_top+8>
+bp_dwNumDigits		equ	<bp_top+12>
+bp_lpszTermDigits 	equ	<bp_top+16>
+bp_dwFirstDigitTimeout	equ	<bp_top+20>
+bp_dwInterDigitTimeout	equ	<bp_top+24>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  dwDigitModes
+; dword ptr [ebp+16]:  lpsDigits
+; dword ptr [ebp+20]:  dwNumDigits
+; dword ptr [ebp+24]:  lpszTerminationDigits
+; dword ptr [ebp+28]:  dwFirstDigitTimeout
+; dword ptr [ebp+32]:  dwInterDigitTimeout
+;
+
+bp_lpsDigitsTmp		equ	<dword ptr [bp-4]>
+bp_lpszTermDigitsTmp 	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lpsDigitsTmp
+	push	eax				;bp_lpszTerminationDigitsTmp
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_dwDigitModes	;dwDigitModes: dword->dword
+	push	dword ptr bp_lpsDigits
+	call	MapLS
+	mov	bp_lpsDigitsTmp, eax
+	push	eax
+	push	dword ptr bp_dwNumDigits	;dwNumDigits: dword->dword
+	push	dword ptr bp_lpszTermDigits
+	call	MapLS
+	mov	bp_lpszTermDigitsTmp, eax
+	push	eax
+	push	dword ptr bp_dwFirstDigitTimeout ;dwFirstDigitTimeout: dword->dword
+	push	dword ptr bp_dwInterDigitTimeout ;dwInterDigitTimeout: dword->dword
+
+	call	lineGatherDigits
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax                             ; Save it
+
+;
+; Don't UnMap lpsDigits: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpsDigitsTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszTermDigitsTmp
+	call	UnMapLS
+
+	pop	eax
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINEPARK
+;-----------------------------------------------------------------------;
+body_LINEPARK macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwParkMode		equ	<bp_top+4>
+bp_lpszDirAddress	equ	<bp_top+8>
+bp_lpNonDirAddress	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwParkMode
+; dword ptr [ebp+16]:  lpszDirAddress
+; dword ptr [ebp+20]:  lpNonDirAddress
+;
+
+bp_lpszDirAddressTmp	equ	<dword ptr [bp-4]>
+bp_lpNonDirAddressTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lpszDirAddressTmp
+	push	eax				;bp_lpNonDirAddressTmp
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwParkMode		;dwParkMode: dworkd->dword
+	push	dword ptr bp_lpszDirAddress
+	call	MapLS
+	mov	bp_lpszDirAddressTmp, eax
+	push	eax
+	push	dword ptr bp_lpNonDirAddress
+	call	MapLS
+	mov	bp_lpNonDirAddressTmp, eax
+	push	eax
+
+	call	linePark
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax   ; Save it
+
+	push	dword ptr bp_lpszDirAddressTmp
+	call	UnMapLS
+;
+; Don't UnMap lpNonDirAddressTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpNonDirAddressTmp
+;	call	UnMapLS
+
+	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_TAPIREQUESTMEDIACALL
+;-----------------------------------------------------------------------;
+body_TAPIREQUESTMEDIACALL macro
+        mov     eax, -16
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_TAPIREQUESTDROP
+;-----------------------------------------------------------------------;
+body_TAPIREQUESTDROP macro
+        mov     eax, -16
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEREGISTERREQUESTRECIPIENT
+;-----------------------------------------------------------------------;
+body_LINEREGISTERREQUESTRECIPIENT macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwRegistrationInstance  equ	<bp_top+4>
+bp_dwRequestMode	equ	<bp_top+8>
+bp_dwEnable     	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:   hLine
+; dword ptr [ebp+12]:  dwRegistrationInstance
+; dword ptr [ebp+16]:  dwRequestMode
+; dword ptr [ebp+20]:  bEnable
+;
+
+;
+;	sub	eax, eax
+;	push	eax				;bp_lpszDirAddressTmp
+;	push	eax				;bp_lpNonDirAddressTmp
+;
+
+;
+;       If this is a 32bit app asking to register for media calls, tell 'em
+;       'e's nuts.
+;
+        test    dword ptr bp_dwRequestMode, 2 ;*** *** ***Or should this be 6?
+        jz     @f
+
+ifdef DEBUG
+	DPRINT "32bit apps aren't allowed to register for Media calls"
+endif
+        mov     eax, 80000038h
+        jmp     Done_LRRR
+
+@@:
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwRegistrationInstance
+	push	dword ptr bp_dwRequestMode
+	push	dword ptr bp_dwEnable
+
+	call	lineRegisterRequestRecipient
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+Done_LRRR:
+
+endm
+
diff --git a/private/tapi/dev/sp/tsp1632/script/tapithk.thk b/private/tapi/dev/sp/tsp1632/script/tapithk.thk
new file mode 100644
index 000000000..2f656b5f6
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/tapithk.thk
@@ -0,0 +1,309 @@
+/*
+ * Lzexpand APIs thunks for Win32s
+ */
+//__foldwin32sstuff __foldwin32sstuff;
+//**********************************foldstyleinitialization = true;
+
+
+enablemapdirect1632 = true;
+//preload32=true;
+//flatthunks = false;
+
+#include "..\types.thk"
+
+
+typedef HANDLE	HINSTANCE;
+typedef DWORD	HTAPI;
+typedef HTAPI	*LPHTAPI;
+typedef HTAPI	HAPP;
+typedef HAPP    HLINEAPP;
+typedef HAPP    HPHONEAPP;
+typedef HAPP 	*LPHAPP;	
+typedef HTAPI	HCALL;
+typedef HCALL	*LPHCALL;	
+typedef HTAPI   HLINE;
+typedef HLINE   *LPHLINE; 
+typedef HTAPI   HPHONE;
+typedef HPHONE  *LPHPHONE; 
+typedef HICON	*LPHICON;
+typedef void	LINECALLBACK;
+typedef void	PHONECALLBACK;
+typedef LPSTR	LPCSTR;
+
+typedef HLINEAPP *LPHLINEAPP;
+typedef HPHONEAPP *LPHPHONEAPP;
+typedef LPVOID	LPLINEEXTENSIONID;
+
+typedef WORD	WPARAM;
+
+typedef LPVOID	LPLINETRANSLATEOUTPUT;		/* LP to data structure */
+typedef LPVOID	LPLINETRANSLATECAPS;		/* LP to data structure */
+typedef LPVOID	LPLINEFORWARDLIST;
+typedef LPVOID	LPLINECALLPARAMS;
+typedef LPVOID	LPLINEGENERATETONE;
+typedef LPVOID	LPLINEADDRESSCAPS;
+typedef LPVOID	LPLINEADDRESSSTATUS;
+typedef LPVOID	LPLINECALLINFO;
+typedef LPVOID	LPLINECALLSTATUS;
+typedef LPVOID	LPLINECALLLIST;
+typedef LPVOID	LPLINEDEVCAPS;
+typedef LPVOID	LPLINEDEVSTATUS;
+typedef LPVOID	LPLINEMONITORTONE;
+typedef LPVOID	LPVARSTRING;
+typedef LPVOID	LPLINEDIALPARAMS;
+typedef LPVOID	LPLINEMEDIACONTROLDIGIT;
+typedef LPVOID	LPLINEMEDIACONTROLMEDIA;
+typedef LPVOID	LPLINEMEDIACONTROLTONE;
+typedef LPVOID	LPLINEMEDIACONTROLCALLSTATE;
+typedef	LPVOID	LPPHONEBUTTONINFO;
+typedef	LPVOID	LPPHONECAPS;
+typedef	LPVOID	LPPHONESTATUS;
+typedef	LPVOID	LPPHONEEXTENSIONID;
+typedef	LPVOID	LPLINECOUNTRYLIST;
+typedef LPVOID	LPLINEPROVIDERLIST;
+
+
+
+
+typedef DWORD    DRV_REQUESTID;
+typedef LPHLINE  HDRVLINE;
+typedef LPHCALL  HTAPICALL;
+typedef LPHCALL  HDRVCALL;
+typedef LPHCALL  LPHDRVCALL;
+
+typedef DWORD  HDRVPHONE;
+
+
+
+
+// // /* Simple Telephony prototypes */
+// // 
+// // LONG tapiRequestMakeCall (LPCSTR lpszDestAddress, LPCSTR lpszAppName, LPCSTR lpszCalledParty, LPCSTR lpszComment) =
+// // LONG tapiRequestMakeCall (LPCSTR lpszDestAddress, LPCSTR lpszAppName, LPCSTR lpszCalledParty, LPCSTR lpszComment)
+// // {
+// // }
+// // 
+// // /*PROBLEM? WORD as parameter */
+// // LONG tapiRequestMediaCall (HWND hWnd, WORD wRequestID, LPCSTR lpszDeviceClass, LPCSTR lpDeviceID, DWORD dwSize, 
+// // 		DWORD dwSecure, LPCSTR lpszDestAddress, LPCSTR lpszAppName, LPCSTR lpszCalledParty, LPCSTR lpszComment) =
+// // LONG tapiRequestMediaCall (HWND hWnd, WORD wRequestID, LPCSTR lpszDeviceClass, LPCSTR lpDeviceID, DWORD dwSize, 
+// // 		DWORD dwSecure, LPCSTR lpszDestAddress, LPCSTR lpszAppName, LPCSTR lpszCalledParty, LPCSTR lpszComment)
+// // {
+// // //    body = special;
+// // }
+// // 
+// // /*PROBLEM? WORD as parameter */
+// // LONG tapiRequestDrop (HWND hWnd, WPARAM wRequestID) =
+// // LONG tapiRequestDrop (HWND hWnd, WPARAM wRequestID)
+// // {
+// // //    body = special;
+// // }
+// // 
+// // LONG tapiGetLocationInfo(LPSTR lpszCountryCode,	LPSTR lpszCityCode) =
+// // LONG tapiGetLocationInfo(LPSTR lpszCountryCode,	LPSTR lpszCityCode)
+// // {}
+		
+//LONG lineRegisterRequestRecipient (HDRVLINEAPP hdLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD bEnable) =
+//LONG lineRegisterRequestRecipient (HDRVLINEAPP hdLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD bEnable)
+//{
+//    body = special;
+//}
+
+
+/* Other TAPI functions */
+/*
+//   hInstance	= push;
+//   lpfnCallback = push;
+LONG lineInitialize16 (LPHDRVLINEAPP lphdLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, 
+			LPCSTR lpszAppName, LPDWORD lpdwNumDevs) =
+LONG lineInitialize16 (LPHDRVLINEAPP lphdLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, 
+			LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
+{
+//   body = special;
+}
+
+
+LONG lineShutdown16 (HDRVLINEAPP hdLineApp) =
+LONG lineShutdown16 (HDRVLINEAPP hdLineApp)
+{
+//   body = special;
+}
+
+
+//   hInstance	= push;
+//   lpfnCallback = push;
+LONG phoneInitialize16 (LPHDRVPHONEAPP lphdPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback,
+			LPCSTR lpszAppName, LPDWORD lpdwNumDevs) =
+LONG phoneInitialize16 (LPHDRVPHONEAPP lphdPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback,
+			LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
+{
+//    body = special;
+}
+
+LONG phoneShutdown16 (HDRVPHONEAPP hdPhoneApp) =
+LONG phoneShutdown16 (HDRVPHONEAPP hdPhoneApp)
+{
+//    body = special;
+}
+*/
+
+
+
+
+
+
+LONG  TSPI_lineMakeCall (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams) =
+LONG  TSPI_lineMakeCall (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineSetupConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVLINE hdLine, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, 
+                DWORD dwNumParties, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_lineSetupConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVLINE hdLine, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, 
+                DWORD dwNumParties, LPLINECALLPARAMS  lpCallParams)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineForward (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, 
+                        DWORD bAllAddresses, DWORD dwAddressID, 
+                        LPLINEFORWARDLIST  lpForwardList,
+                        DWORD dwNumRingsNoAnswer, HTAPICALL htConsoleCall,
+                        LPHDRVCALL lphdConsultCall,
+                        LPLINECALLPARAMS lpCallParams) =
+LONG  TSPI_lineForward (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, 
+                        DWORD bAllAddresses, DWORD dwAddressID, 
+                        LPLINEFORWARDLIST  lpForwardList,
+                        DWORD dwNumRingsNoAnswer, HTAPICALL htConsoleCall,
+                        LPHDRVCALL lphdConsultCall,
+                        LPLINECALLPARAMS lpCallParams)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineUnpark (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress) =
+LONG  TSPI_lineUnpark (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress)
+{
+//    body = special;
+}
+
+LONG  TSPI_linePickup (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID) =
+LONG  TSPI_linePickup (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineCompleteTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVCALL hdConsultCall, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, DWORD dwTransferMode) =
+LONG  TSPI_lineCompleteTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVCALL hdConsultCall, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, DWORD dwTransferMode)
+{
+//    body = special;
+}
+
+LONG  TSPI_linePrepareAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_linePrepareAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineSetupTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_lineSetupTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineCompleteCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID) =
+LONG  TSPI_lineCompleteCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineDevSpecific (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, LPVOID lpParams, DWORD dwSize) =
+LONG  TSPI_lineDevSpecific (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, LPVOID lpParams, DWORD dwSize)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineDevSpecificFeature (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize) =
+LONG  TSPI_lineDevSpecificFeature (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
+{
+//    body = special;
+}
+
+LONG  TSPI_lineGatherDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, 
+		LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout) =
+LONG  TSPI_lineGatherDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, 
+		LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
+{
+//    body = special;
+}
+
+LONG  TSPI_linePark (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress) =
+LONG  TSPI_linePark (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
+{
+//    body = special;
+}
+
+
+
+
+LONG  TSPI_phoneDevSpecific (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, LPVOID lpParams, DWORD dwSize) =
+LONG  TSPI_phoneDevSpecific (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, LPVOID lpParams, DWORD dwSize)
+{
+//    body = special;
+}
+
+ 
+
+
+
+
+
+
+
+
+
+//*   
+//*   
+//*   /* Private API: TAPI32 must run this thunk to clean up our act.
+//*    *
+//*    * We declare pCB32Tab as DWORD, not POINTER. We want the linear
+//*    * address passed thru untouched.
+//*    */
+//*   VOID TapiThunkInit(DWORD pCB32Tab) =
+//*   VOID TapiThunkInit(DWORD pCB32Tab)
+//*   {
+//*   }
+//*   /* Private API: TAPI32 must run this thunk before any other.
+//*    *
+//*    * We declare pCB32Tab as DWORD, not POINTER. We want the linear
+//*    * address passed thru untouched.
+//*    */
+//*   VOID TapiThunkTerminate(DWORD pCB32Tab) =
+//*   VOID TapiThunkTerminate(DWORD pCB32Tab)
+//*   {
+//*   }
+//*   
+//*   
+
+
+
+
+
+
+/*
+typedef void (CALLBACK * LINECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) =
+typedef void (CALLBACK * LINECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
+{}
+*/
+
+
+/*
+typedef void (CALLBACK * PHONECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) =
+typedef void (CALLBACK * PHONECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
+{}
+*/
diff --git a/private/tapi/dev/sp/tsp1632/script/types.thk b/private/tapi/dev/sp/tsp1632/script/types.thk
new file mode 100644
index 000000000..ed9c77e85
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/script/types.thk
@@ -0,0 +1,102 @@
+typedef unsigned short USHORT;
+typedef          short  SHORT;
+typedef unsigned long  ULONG;
+typedef          long   LONG;
+typedef unsigned int   UINT;
+typedef          int    INT;
+typedef unsigned char  UCHAR;
+
+typedef void    VOID;
+typedef void   *PVOID;
+typedef void   *LPVOID;
+typedef UCHAR   BYTE;
+typedef USHORT  WORD;
+typedef ULONG   DWORD;
+typedef UINT    HANDLE;
+typedef WORD    HANDLE16;
+typedef DWORD   HANDLE32;
+typedef int     BOOL;
+typedef char   *LPSTR;
+typedef BYTE   *PBYTE;
+typedef BYTE   *LPBYTE;
+typedef USHORT  SEL;
+typedef INT    *LPINT;
+typedef UINT   *LPUINT;
+typedef DWORD  *LPDWORD;
+typedef LONG   *LPLONG;
+typedef WORD   *LPWORD;
+
+typedef HANDLE  HWND;
+typedef HANDLE  HDC;
+typedef HANDLE  HBRUSH;
+typedef HANDLE  HBITMAP;
+typedef HANDLE  HRGN;
+typedef HANDLE  HFONT;
+typedef HANDLE  HCURSOR;
+typedef HANDLE  HMENU;
+typedef HANDLE  HPEN;
+typedef HANDLE  HICON;
+typedef HANDLE  HUSER;      /* vanilla user handle */
+typedef HANDLE  HPALETTE;
+typedef HANDLE  HMF;
+typedef HANDLE  HEMF;
+typedef HANDLE	HCOLORSPACE;
+typedef HANDLE  HMEM;
+typedef HANDLE  HGDI;       /* vanilla gdi handle */
+typedef HANDLE  HGLOBAL;
+typedef HANDLE  HRSRC;
+typedef HANDLE  HACCEL;
+
+
+typedef WORD    ATOM;
+
+typedef DWORD   WNDPROC;    /* handled inside USER */
+
+/* HACK! have it as a pointer to type which differes between 16 and 32
+ * so InLine translation of pointers handle it correctly
+ */
+typedef int *   FARPROC;    /* thunk layer handles this one */
+
+
+/**********************************************/
+typedef struct tagRECT {
+    INT         left;
+    INT         top;
+    INT         right;
+    INT         bottom;
+} RECT;
+typedef RECT   *LPRECT;
+
+
+typedef struct tagPOINT {
+    INT         x;
+    INT         y;
+} POINT;
+typedef POINT  *LPPOINT;
+
+
+typedef struct tagPOINTL {
+    LONG        x;
+    LONG        y;
+} POINTL;
+typedef POINTL  *LPPOINTL;
+
+
+typedef struct tagOFSTRUCT {
+    BYTE        cBytes;
+    BYTE        fFixedDisk;
+    WORD        nErrorCode;
+    WORD        reserved1;
+    WORD        reserved2;
+    BYTE        szPathName[128];
+} OFSTRUCT;
+typedef OFSTRUCT *LPOFSTRUCT;
+
+
+typedef struct tagCHARSETINFO {
+    UINT ciCharset;
+    UINT ciACP;
+    DWORD ciSigCP[2];
+    DWORD ciSigU[4];
+} CHARSETINFO;
+typedef CHARSETINFO *LPCHARSETINFO;
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/debug.c b/private/tapi/dev/sp/tsp1632/tsp1632l/debug.c
new file mode 100644
index 000000000..ecaed6d5c
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/debug.c
@@ -0,0 +1,174 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include  <tapi.h>                  
+#include "debug.h"
+
+
+extern const char szINIfilename[];
+
+
+DWORD   gdwDebugLevel;
+
+
+static char szNewBuff[256];
+
+
+DWORD TSP1632lDebugLevel = 0;
+static fTSP1632lDebugLevelValid = FALSE;
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+
+{
+   char    buf[128] = "TSP1632l: ";
+// *** *** ***   static char szFilename[] = filename;
+   if (!fTSP1632lDebugLevelValid)
+   {
+      TSP1632lDebugLevel =   GetPrivateProfileInt( "Debug",
+                                             "TSP1632lDebugLevel",
+                                             0,
+                                             szINIfilename );
+
+      if ( TSP1632lDebugLevel > 0 )
+      {
+         wsprintf(
+                   &buf[10],
+                   "TSP1632lDebugLevel= %d\n\r",
+                   TSP1632lDebugLevel);
+
+         OutputDebugString((LPSTR)buf);
+
+
+      }
+
+      fTSP1632lDebugLevelValid = TRUE;
+   }
+
+
+   //
+   // Is the message otherwise "low" enough to display?
+   //
+    if (dwDbgLevel <= TSP1632lDebugLevel)
+    {
+        char    buf[128] = "TSP1632l: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        vsprintf (&buf[10],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugString(buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+
+
+
+
+
+
+//VOID
+//DbgPrt(
+//    IN DWORD  dwDbgLevel,
+//    IN PUCHAR lpszFormat,
+//    IN ...
+//    )
+///*++
+//
+//Routine Description:
+//
+//    Formats the incoming debug message & calls DbgPrint
+//
+//Arguments:
+//
+//    DbgLevel   - level of message verboseness
+//
+//    DbgMessage - printf-style format string, followed by appropriate
+//                 list of arguments
+//
+//Return Value:
+//
+//
+//--*/
+//{
+//    
+//    static BOOL fAlreadyGotIt = FALSE;
+//    static char    buf[128] = "TAPI CPL: ";
+//#define TEXT_START 10
+//
+//    if (!fAlreadyGotIt)
+//    {
+//
+//        gdwDebugLevel = (DWORD) GetPrivateProfileInt(
+//            "Debug",
+//            "TSP1632l32DebugLevel",
+//            0x0,
+//            "Telephon.ini"
+//            );
+//
+//        fAlreadyGotIt = TRUE;
+//
+//        wsprintf(&buf[TEXT_START], "TSP1632l32DebugLevel=%d \r\n", gdwDebugLevel);
+//        OutputDebugStringA(buf);
+//    }
+//
+//
+//    if (dwDbgLevel <= gdwDebugLevel)
+//    {
+//        va_list ap;
+//
+//
+//        va_start(ap, lpszFormat);
+//
+//        vsprintf (&buf[TEXT_START],
+//                  lpszFormat,
+//                  ap
+//                  );
+//
+//        lstrcat (buf, "\n");
+//
+//        OutputDebugStringA (buf);
+//
+//        va_end(ap);
+//    }
+//}
+//
+
+#endif
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/debug.h b/private/tapi/dev/sp/tsp1632/tsp1632l/debug.h
new file mode 100644
index 000000000..cd9ea2591
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/debug.h
@@ -0,0 +1,25 @@
+#if DBG
+
+
+#if !WIN32
+#define IN
+#define PUCHAR char *
+#endif
+
+
+
+#define DBGOUT(arg) DbgPrt arg
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/depend.mk b/private/tapi/dev/sp/tsp1632/tsp1632l/depend.mk
new file mode 100644
index 000000000..e69626f90
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/depend.mk
@@ -0,0 +1,9 @@
+.\tapi32.obj:   ..\..\script\$(VERDIR)\tapi32.asm
+
+.\tapithk.obj:  ..\..\script\$(VERDIR)\tapithk.asm
+
+.\tapifthk.obj: ..\..\script\$(VERDIR)\tapifthk.asm
+
+.\tsp1632l.obj: ..\tsp1632l.c ..\tsp1632l.h ..\debug.h
+
+.\debug.obj: ..\debug.c ..\debug.h
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/makefile b/private/tapi/dev/sp/tsp1632/tsp1632l/makefile
new file mode 100644
index 000000000..43dc5a869
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tsp3216s.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/makefile.def b/private/tapi/dev/sp/tsp1632/tsp1632l/makefile.def
new file mode 100644
index 000000000..fad78023b
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/makefile.def
@@ -0,0 +1,50 @@
+ROOT=..\..\..\..\..\..\..
+
+IS_OEM=1
+MASM6=1
+IS_32 = TRUE
+WIN32=1
+
+#DEFENTRY=DllEntryPoint
+#DLLENTRY=DllEntryPoint
+DEFENTRY=DllMain
+DLLENTRY=DllMain
+BUILDDLL=1
+
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=tsp1632l
+TARGETS=tsp1632l.dll
+
+SRCDIR=..
+ALTSRCDIR=..\..\script\$(VERDIR)
+
+
+L32EXE=tsp1632l.dll		# Name of exe.
+L32DEF=..\tsp1632l.def              # Our def file.
+L32MAP=tsp1632l.map		# Our map file.
+L32SYM=tsp1632l.sym		# Our sym file.
+#L32RES=server.res	# Resource file.
+L32OBJS = tsp1632l.obj tapi32.obj tapithk.obj tapifthk.obj debug.obj
+L32LIBS= \
+    $(DEVROOT)\tools\c932\lib\crtdll.lib \
+    $(DEVROOT)\lib\user32.lib            \
+    $(DEVROOT)\lib\kernel32.lib
+
+
+!include $(ROOT)\dev\master.mk
+
+
+INCLUDE=$(ROOT)\win\thunk;$(ROOT)\win\core\inc;$(INCLUDE)
+
+
+AFLAGS=$(AFLAGS) /Fl
+
+
+CFLAGS=$(CFLAGS) /Fc
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.c b/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.c
new file mode 100644
index 000000000..74419b9e1
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.c
@@ -0,0 +1,2369 @@
+/*  TSP1632l.C
+    Copyright 1995 (C) Microsoft Corporation
+
+    32-bit TAPI service provider to act as a cover for a system's 16-bit SPs
+
+    16-bit part: TSP1632S.TSP
+    32-bit part: TSP1632L.DLL
+
+
+    TODO:
+    1) allow debug levels
+    2) if OOM in InitializeSPs(), fail
+    3) other OOM errors
+
+ */
+
+#include <windows.h>
+#include <windowsx.h>
+#include <tapi.h>
+
+#define DONT_DECLARE_TSPI_FUNCTIONS 1
+#include <tspi.h>
+
+#include "tsp1632l.h"
+#include "debug.h"
+//#include <wownt16.h>
+
+
+
+BOOL WINAPI TapiThk_ThunkConnect32(LPSTR, LPSTR, DWORD, DWORD);
+BOOL WINAPI TapiFThk_ThunkConnect32(LPSTR, LPSTR, DWORD, DWORD);
+
+
+
+
+#define THUNK_TSPIAPI TSPIAPI __stdcall
+
+
+#if WIN32
+
+#define TSPIAPI
+
+#else
+
+#define TSPIAPI __export __far __pascal
+
+#endif
+
+typedef LONG (TSPIAPI* TSPAPIPROC)(void);
+
+
+#ifdef DEBUG
+#define TSP1632lDebugString(_x_) TSP1632lOutputDebug _x_
+#else
+#define TSP1632lDebugString(_x_)
+#endif
+
+
+#define THIS_FUNCTION_UNDER_CONSTRUCTION (LONG)TRUE
+// a default return value so that the compiler doesn't
+// whine about missing return values in incomplete functions
+
+
+// globals
+
+DWORD FAR PASCAL ghInst32; // handle into TSP1632L.DLL
+HINSTANCE ghThisInst;  //This hinst
+
+int NumProviders = 0;
+DWORD gdwPPID;
+HINSTANCE FAR * hProviders = NULL; // array of handles to providers
+TSPAPIPROC FAR * lpfnProcAddress = NULL;
+DWORD FAR * dwPermanentProviderIDArray;
+DWORD FAR * dwNumLinesArray = NULL; // dwNumLinesArray[1] is how many
+DWORD FAR * dwNumPhonesArray = NULL; // lines are on provider 1
+
+DWORD gdwLineDeviceIDBase;
+DWORD gdwPhoneDeviceIDBase;
+
+FARPROC glpLineEventProc32, glpPhoneEventProc32,
+   glpAsyncCompletionProc32, glpLineCreateProc32, glpPhoneCreateProc32;
+
+
+const char szINIfilename[] = "TELEPHON.sl";
+
+
+// function definitions
+
+#ifdef DEBUG
+VOID TSP1632lOutputDebug(int level, LPSTR errString)
+    {    
+    char outString[1024];
+
+    // if(level <= ???)
+        {
+        wsprintf(outString, "TSP1632l:(%d) %s\r\n", level, errString);
+        OutputDebugString(outString);    
+        }
+    }
+#endif
+
+
+VOID
+InitializeSPs(VOID)
+    {
+    int iProvider;
+    char LibFileName[MAXBUFSIZE];
+    char szBuffer[MAXBUFSIZE];
+
+//    ghInst32 = LoadLibraryEx32("TSP1632L.DLL", NULL, 0);
+//
+//    glpLineEventProc32 = GetProcAddress32(ghInst32, "LineEventProc32");
+//    glpPhoneEventProc32 = GetProcAddress32(ghInst32, "PhoneEventProc32");
+//    glpAsyncCompletionProc32 = GetProcAddress32(
+//        ghInst32,
+//        "AsyncCompletionProc32"
+//        );
+//    glpLineCreateProc32 = GetProcAddress32(ghInst32, "LineCreateProc32");
+//    glpPhoneCreateProc32 = GetProcAddress32(ghInst32, "PhoneCreateProc32");
+
+    NumProviders = GetPrivateProfileInt(
+        "Providers",
+        "NumProviders",
+        0, // default
+        szINIfilename
+        );
+
+    dwPermanentProviderIDArray
+        = (DWORD FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(DWORD));
+
+    dwNumLinesArray
+        = (DWORD FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(DWORD));
+    dwNumPhonesArray
+        = (DWORD FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(DWORD));
+
+    hProviders =
+        (HINSTANCE FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(HINSTANCE));
+
+    lpfnProcAddress = (TSPAPIPROC FAR *)GlobalAllocPtr(
+        GPTR,
+        NumProviders * TSPI_PROC_LAST * sizeof(TSPAPIPROC)
+        );
+
+    if(
+        !dwPermanentProviderIDArray
+        || !dwNumLinesArray
+        || !dwNumPhonesArray
+        || !hProviders
+        || !lpfnProcAddress)
+        ;// out of memory - fail
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        {
+        wsprintf(szBuffer, "ProviderFilename%d", iProvider);
+        GetPrivateProfileString(
+            "Providers",
+            szBuffer,
+            "", // default
+            LibFileName,
+            MAXBUFSIZE,
+            szINIfilename
+            );
+
+        hProviders[iProvider] = LoadLibrary(LibFileName);
+
+DBGOUT((1, "Loading [%s]", LibFileName));
+
+        wsprintf(szBuffer, "ProviderID%d", iProvider);
+        dwPermanentProviderIDArray[iProvider] = GetPrivateProfileInt(
+            "Providers",
+            szBuffer,
+            0, // default
+            szINIfilename
+            );
+        }
+    }
+
+
+VOID
+FreeAllMem(VOID)
+    {
+    int iProvider;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        FreeLibrary(hProviders[iProvider]);
+
+    GlobalFreePtr(dwPermanentProviderIDArray);
+    GlobalFreePtr(dwNumLinesArray);
+    GlobalFreePtr(dwNumPhonesArray);
+    GlobalFreePtr(hProviders);
+    GlobalFreePtr(lpfnProcAddress);
+    
+//    FreeLibrary32(ghInst32);
+    }
+
+
+TSPAPIPROC
+GetProcAddressHashed(int iProvider, DWORD iFunction) // iFunction is 500-based
+    {
+    if(!lpfnProcAddress[(iProvider*TSPI_PROC_LAST)+(iFunction-TSPI_PROC_BASE)])
+        lpfnProcAddress[(iProvider*TSPI_PROC_LAST)+(iFunction-TSPI_PROC_BASE)]
+            = (TSPAPIPROC)GetProcAddress(
+                hProviders[iProvider],
+                (LPCSTR)iFunction
+                );
+
+    return lpfnProcAddress[
+        (iProvider*TSPI_PROC_LAST)+(iFunction-TSPI_PROC_BASE)
+        ];
+    }
+
+
+int iProviderFromDeviceID(DWORD dwDeviceID)
+    {
+    DWORD dwFirstDeviceIDonProvider = gdwLineDeviceIDBase;
+    int iProvider = 0;
+
+    // seeks the correct provider for this line
+    while(dwDeviceID >= dwFirstDeviceIDonProvider + dwNumLinesArray[iProvider])
+        {
+        dwFirstDeviceIDonProvider += dwNumLinesArray[iProvider];
+        ++iProvider;
+        }
+
+    return iProvider;
+    }
+
+
+int iProviderFromPermanentProviderID(DWORD dwPPID)
+    {
+    int iProvider;
+
+    // seeks the correct provider for this line
+    for ( iProvider = 0; iProvider < NumProviders; iProvider++)
+        {
+        if ( dwPPID == dwPermanentProviderIDArray[iProvider] )
+            {
+            return (iProvider);
+            }
+        }
+
+    return iProvider;
+    }
+
+
+//
+// ----------------------- 32-bit callback shells -----------------------------
+//
+
+VOID LineEventProc16(
+    HTAPILINE htLine,
+    HTAPICALL htCall,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+    {
+    (*glpLineEventProc32)(
+        6,
+        0,
+        glpLineEventProc32,
+        htLine,
+        htCall,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+    }
+
+
+VOID PhoneEventProc16(
+    HTAPIPHONE htPhone,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+    {
+    (*glpPhoneEventProc32)(
+        5,
+        0,
+        glpPhoneEventProc32,
+        htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+    }
+
+
+VOID AsyncCompletionProc16(DRV_REQUESTID dwRequestID, LONG lResult)
+    {
+      (*glpAsyncCompletionProc32)(
+            2,
+            0,
+            glpAsyncCompletionProc32,
+            dwRequestID,
+            lResult);
+    }
+
+
+VOID LineCreateProc16(
+    HTAPILINE htLine,
+    HTAPICALL htCall,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+    {
+    (*glpLineEventProc32)(
+        6,
+        0,
+        glpLineEventProc32,
+        htLine,
+        htCall,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+    }
+
+
+VOID PhoneCreateProc16(
+    HTAPIPHONE htPhone,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+    {
+    (*glpPhoneEventProc32)(
+        5,
+        0,
+        glpPhoneEventProc32,
+        htPhone,
+        dwMsg,
+        dwParam1,
+        dwParam2,
+        dwParam3
+        );
+    }
+
+//
+// -------------------- THUNK_TSPIAPI TSPI_line functions ---------------------------
+// -------------------- THUNK_TSPIAPI TSPI_line functions ---------------------------
+// -------------------- THUNK_TSPIAPI TSPI_line functions ---------------------------
+// -------------------- THUNK_TSPIAPI TSPI_line functions ---------------------------
+// -------------------- THUNK_TSPIAPI TSPI_line functions ---------------------------
+//
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineAccept"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEACCEPT))(
+        dwRequestID,
+        REALhdCall,
+        lpsUserUserInfo,
+        dwSize
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HDRVCALL            hdConsultCall
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineAnswer"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEANSWER))(
+        dwRequestID,
+        REALhdCall,
+        lpsUserUserInfo,
+        dwSize
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode)
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineBlindTransfer"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEBLINDTRANSFER))(
+        dwRequestID,
+        REALhdCall,
+        lpszDestAddress,
+        dwCountryCode
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineClose(
+    HDRVLINE            hdLine
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineClose"));
+
+    GlobalFreePtr((LPVOID)lpmLine);
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINECLOSE))(REALhdLine);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL            hdCall
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineCloseCall"));
+
+    GlobalFreePtr((LPVOID)lpmCall);
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINECLOSECALL))(REALhdCall);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVCALL            hdConsultCall,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    DWORD               dwTransferMode
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+    TSPAPIPROC  lpfn;
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+
+    TSP1632lDebugString((2, "Entering TSPI_lineConfigDialog"));
+
+    lpfn = GetProcAddressHashed(iProvider, TSPI_LINECONFIGDIALOG);
+
+    if (lpfn)
+       return (*lpfn)( dwDeviceID, hwndOwner, lpszDeviceClass );
+
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineConfigDialogEdit(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+    {
+    TSPAPIPROC  lpfn;
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+
+
+    lpfn = GetProcAddressHashed(iProvider, TSPI_LINECONFIGDIALOGEDIT);
+
+    if (lpfn)
+       return (*lpfn)( dwDeviceID, hwndOwner, lpszDeviceClass, 
+                       lpDeviceConfigIn, dwSize, lpDeviceConfigOut );
+
+
+    return(LINEERR_OPERATIONUNAVAIL);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+    {
+    TSPAPIPROC  lpfn;
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+#pragma message("*** *** ***BUGBUG --verify this pointer before dereffing")
+    int iProvider = lpmLine->iProvider;
+
+
+    lpfn = GetProcAddressHashed(iProvider, TSPI_LINEDEVSPECIFIC);
+
+    if (lpfn)
+       return (*lpfn)( dwRequestID, hdLine, dwAddressID, hdCall, lpParams, 
+                       dwSize);
+
+
+    return(LINEERR_OPERATIONUNAVAIL);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineDial"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDIAL))(
+        dwRequestID,
+        REALhdCall,
+        lpszDestAddress,
+        dwCountryCode
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineDrop"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDROP))(
+        dwRequestID,
+        REALhdCall,
+        lpsUserUserInfo,
+        dwSize
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineDropOnClose(
+    HDRVCALL            hdCall
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineDropOnClose"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDROPONCLOSE))(
+        REALhdCall
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineDropNoOwner(
+    HDRVCALL            hdCall
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineDropNoOwner"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDROPNOOWNER))(
+        REALhdCall
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGenerateDigits"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGENERATEDIGITS))(
+        REALhdCall,
+        dwEndToEndID,
+        dwDigitMode,
+        lpszDigits,
+        dwDuration
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGenerateTone"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGENERATETONE))(
+        REALhdCall,
+        dwEndToEndID,
+        dwToneMode,
+        dwDuration,
+        dwNumTones
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    DWORD dwFirstDeviceIDonProvider = gdwLineDeviceIDBase;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetAddressCaps"));
+
+    return(* GetProcAddressHashed(iProvider, TSPI_LINEGETADDRESSCAPS))(
+        dwDeviceID,
+        dwAddressID,
+        dwTSPIVersion,
+        dwExtVersion,
+        lpAddressCaps
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    )
+    {
+
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetAddressID"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETADDRESSID))(
+        REALhdLine,
+        lpdwAddressID,
+        dwAddressMode,
+        lpsAddress,
+        dwSize
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+    {
+
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetAddressStatus"));
+
+    return (* GetProcAddressHashed(lpmLine->iProvider, TSPI_LINEGETADDRESSSTATUS))(
+        REALhdLine,
+        dwAddressID,
+        lpAddressStatus
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwAddressID
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetCallAddressID"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETCALLADDRESSID))(
+        REALhdCall,
+        lpdwAddressID
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL            hdCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetCallInfo"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETCALLINFO))(
+        REALhdCall,
+        lpCallInfo
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetCallStatus"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETCALLSTATUS))(
+        REALhdCall,
+        lpCallStatus
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetDevCaps"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETDEVCAPS))(
+        dwDeviceID,
+        dwTSPIVersion,
+        dwExtVersion,
+        lpLineDevCaps
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetDevCaps retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetDevConfig"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETDEVCONFIG))(
+        dwDeviceID,
+        lpDeviceConfig,
+        lpszDeviceClass
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetDevConfig retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+    {
+
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetExtension"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETEXTENSIONID))(
+        dwDeviceID,
+        dwTSPIVersion,
+        lpExtensionID
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetExtensionID retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+    {
+
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetIcon"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETICON))(
+        dwDeviceID,
+        lpszDeviceClass,
+        lphIcon
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetIcon retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetID(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass    
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE            hdLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+    {
+
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetLineDevStatus"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETLINEDEVSTATUS))(
+        REALhdLine,
+        lpLineDevStatus
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwNumAddressIDs
+    )
+    {
+
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineGetNumAddressIDs"));
+
+    return (* GetProcAddressHashed(lpmLine->iProvider, TSPI_LINEGETNUMADDRESSIDS))(
+        REALhdLine,
+        lpdwNumAddressIDs
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineHold"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEHOLD))(
+        dwRequestID,
+        REALhdCall
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineMakeCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    LPMYCALL lpmCall;
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineMakeCall"));
+
+    lpmCall = (MYCALL *)GlobalAllocPtr(GPTR, sizeof(MYCALL));
+    if(!lpmCall)
+        return(LINEERR_NOMEM);
+
+    *lphdCall = (HDRVCALL)lpmCall;
+
+    lpmCall->iProvider = iProvider;
+    lpmCall->dwDeviceID = lpmLine->dwDeviceID;
+
+    return (* GetProcAddressHashed(lpmCall->iProvider, TSPI_LINEMAKECALL))(
+        dwRequestID,
+        REALhdLine,
+        htCall,
+        &(lpmCall->hdCall),
+        lpszDestAddress,
+        dwCountryCode,
+        lpCallParams
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwDigitModes
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaModes
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    )
+    {
+    TSP1632lDebugString((2, "Entering TSPI_lineNegotiateTSPIVersion"));
+
+_asm int 1;
+InitializeSPs();
+
+    *lpdwTSPIVersion = TAPI_CUR_VER;
+    
+    return(0);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineOpen(
+    DWORD               dwDeviceID,
+    HTAPILINE           htLine,
+    LPHDRVLINE          lphdLine,
+    DWORD               dwTSPIVersion,
+    LINEEVENT           lpfnEventProc
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    LPMYLINE lpmLine;
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP1632lDebugString((2, "Entering TSPI_lineOpen"));
+
+    lpmLine = (MYLINE *)GlobalAllocPtr(GPTR, sizeof(MYLINE));
+    if(!lpmLine)
+        return(LINEERR_NOMEM);
+
+    *lphdLine = (HDRVLINE)lpmLine;
+
+    lpmLine->iProvider = iProvider;
+    lpmLine->dwDeviceID = dwDeviceID;
+    lpmLine->htLine = htLine;
+    lpmLine->lpfnEventProc = lpfnEventProc;
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEOPEN))(
+        dwDeviceID,
+        (HTAPILINE)lpmLine, // was htLine
+        &(lpmLine->hdLine),
+        dwTSPIVersion,
+        LineEventProc16
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineOpen retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineSecureCall"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESECURECALL))(
+        dwRequestID,
+        REALhdCall
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE            hdLine,
+    DWORD               dwExtVersion
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineSendUserUserInfo"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESENDUSERUSERINFO))(
+        dwRequestID,
+        REALhdCall,
+        lpsUserUserInfo,
+        dwSize
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL            hdCall,
+    DWORD               dwAppSpecific
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetCurrentLocation(
+    DWORD               dwLocation
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineSetDefaultMediaDetection"));
+
+    return (* GetProcAddressHashed(
+            iProvider,
+            TSPI_LINESETDEFAULTMEDIADETECTION
+            ))(REALhdLine, dwMediaModes);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaMode
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE            hdLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineSetStatusMessages"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESETSTATUSMESSAGES))(
+        REALhdLine,
+        dwLineStates,
+        dwAddressStates
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdActiveCall,
+    HDRVCALL            hdHeldCall
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwCompletionID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP1632lDebugString((2, "Entering TSPI_lineUnhold"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEUNHOLD))(
+        dwRequestID,
+        REALhdCall
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_lineReleaseUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+
+//
+// ----------------------- THUNK_TSPIAPI TSPI_phone functions -----------------------
+//
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE           hdPhone
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDisplay
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetID(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE           hdPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneOpen(
+    DWORD               dwDeviceID,
+    HTAPIPHONE          htPhone,
+    LPHDRVPHONE         lphdPhone,
+    DWORD               dwTSPIVersion,
+    PHONEEVENT          lpfnEventProc
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    LPMYPHONE lpmPhone;
+
+    TSP1632lDebugString((2, "Entering TSPI_phoneOpen"));
+
+    lpmPhone = (MYPHONE *)GlobalAllocPtr(GPTR, sizeof(MYPHONE));
+    if(!lpmPhone)
+        return(PHONEERR_NOMEM);
+
+    *lphdPhone = (HDRVPHONE)lpmPhone;
+
+    lpmPhone->iProvider = iProvider;
+    lpmPhone->dwDeviceID = dwDeviceID;
+    lpmPhone->htPhone = htPhone;
+    lpmPhone->lpfnEventProc = lpfnEventProc;
+
+    return (* GetProcAddressHashed(iProvider, TSPI_PHONEOPEN))(
+        dwDeviceID,
+        (HTAPIPHONE)lpmPhone, // was htPhone
+        &(lpmPhone->hdPhone),
+        dwTSPIVersion,
+        PhoneEventProc16
+        );
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE           hdPhone,
+    DWORD               dwExtVersion
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCSTR              lpsDisplay,
+    DWORD               dwSize
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE           hdPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+
+
+//
+// ----------------------- THUNK_TSPIAPI TSPI_provider functions --------------------
+//
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerConfig(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+    {
+
+    int iProvider = iProviderFromPermanentProviderID(dwPermanentProviderID);
+    BOOL fAllFailed = TRUE;
+
+    TSP1632lDebugString((2, "Entering TSPI_providerConfig"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_PROVIDERCONFIG))(
+                    hwndOwner,
+                    dwPermanentProviderID
+            );
+
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc
+    )
+    {
+    int iProvider;
+    BOOL fAllFailed = TRUE;
+
+    TSP1632lDebugString((2, "Entering TSPI_providerInit"));
+
+    gdwLineDeviceIDBase = dwLineDeviceIDBase;
+    gdwPhoneDeviceIDBase = dwPhoneDeviceIDBase;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        {
+        TSP1632lDebugString((2, "TSPI_providerInit initializing provider"));
+
+        if(!((* GetProcAddressHashed(iProvider, TSPI_PROVIDERINIT))(
+            dwTSPIVersion,
+            dwPermanentProviderIDArray[iProvider],
+            dwLineDeviceIDBase,
+            dwPhoneDeviceIDBase,
+            dwNumLinesArray[iProvider],
+            dwNumPhonesArray[iProvider],
+            AsyncCompletionProc16
+            )))
+            fAllFailed = FALSE; // if one succeeded, they didn't ALL fail
+        
+        dwLineDeviceIDBase += dwNumLinesArray[iProvider];
+        dwPhoneDeviceIDBase += dwNumPhonesArray[iProvider];
+        }
+
+    if(fAllFailed)
+    {
+        DBGOUT((2, "TSPI_providerInit: all 16bit providers failed init!"));
+        return(LINEERR_OPERATIONFAILED);
+    }
+    else
+        return(ERR_NONE);
+
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerInstall(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerRemove(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerShutdown(
+    DWORD               dwTSPIVersion
+    )
+    {
+    int iProvider;
+
+    TSP1632lDebugString((2, "Entering TSPI_providerShutdown"));
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        (* GetProcAddressHashed(iProvider, TSPI_PROVIDERSHUTDOWN))(
+            dwTSPIVersion
+            );
+
+    FreeAllMem();
+
+    return(ERR_NONE);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerEnumDevices(
+    DWORD               dwPermanentProviderID,
+    LPDWORD             lpdwNumLines,
+    LPDWORD             lpdwNumPhones,
+    HPROVIDER           hProvider,
+    LINEEVENT           lpfnLineCreateProc,
+    PHONEEVENT          lpfnPhoneCreateProc
+    )
+    {
+    int iProvider;
+
+    TSP1632lDebugString((2, "Entering TSPI_providerEnumDevices"));
+
+_asm int 1;  
+  
+    gdwPPID = dwPermanentProviderID;
+    
+    *lpdwNumLines = 0;
+    *lpdwNumPhones = 0;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        {
+        TSPAPIPROC  lpfn;
+
+
+        lpfn = GetProcAddressHashed(iProvider, TSPI_PROVIDERENUMDEVICES);
+
+        if (lpfn)
+          (*lpfn)(
+            dwPermanentProviderIDArray[iProvider],
+            &(dwNumLinesArray[iProvider]),
+            &(dwNumPhonesArray[iProvider]),
+            hProvider,
+            LineCreateProc16,
+            PhoneCreateProc16
+            );
+
+        (*lpdwNumLines) += dwNumLinesArray[iProvider];
+        (*lpdwNumPhones) += dwNumPhonesArray[iProvider];
+        }
+
+    DBGOUT((2, " TSPI_providerEnumDevices: #lines= %d  #phones= %d",
+            *lpdwNumLines,
+            *lpdwNumPhones));
+
+    return(ERR_NONE);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerCreateLineDevice(
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+THUNK_TSPIAPI
+TSPI_providerCreatePhoneDevice(
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+BOOL _stdcall
+//LibMain(
+//    HINSTANCE hDllInstance,
+//    WORD wDataSeg,
+//    WORD wHeapSize,
+//    LPSTR lpszCmdLine
+//    )
+DllMain(
+      DWORD hDllInstance,
+      DWORD dwReason,
+      DWORD dwReserved)
+{
+//    static long MyUsageCounter = 0;
+
+
+    DBGOUT((2, "TSP1632l: DllMain entered - %0ld\r\n", dwReason));
+
+    switch (dwReason)
+    {
+       case DLL_PROCESS_ATTACH:
+
+          ghThisInst = hDllInstance;
+
+          TapiThk_ThunkConnect32("TSP1632S.TSP", "TSP1632L.DLL", hDllInstance, dwReason);
+          TapiFThk_ThunkConnect32("TSP1632S.TSP", "TSP1632L.DLL", hDllInstance, dwReason);
+
+          break;
+
+
+       case DLL_PROCESS_DETACH:
+          break;
+
+
+       default:
+           OutputDebugString("TSP1632l: DllMain entered\r\n");
+    }
+
+
+    return(1); // success
+}
+
+
+
+WORD CALLBACK _loadds
+NewData(
+    )
+    {
+    return (ghThisInst); // success
+    }
+
+BOOL TapiCallbackThunk( HLINEAPP hDevice,
+                        DWORD dwMessage,
+                        DWORD dwInstance,
+                        DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3,
+                        DWORD dwcbProc32);
+
+DWORD CALLBACK _loadds
+NewData2(
+    )
+    {
+//    return (DWORD)&TapiCallbackThunk;
+    }
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.def b/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.def
new file mode 100644
index 000000000..3e32b548d
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.def
@@ -0,0 +1,125 @@
+LIBRARY     TSP1632l
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept                        @500
+        TSPI_lineAddToConference               @501
+        TSPI_lineAnswer                        @502
+        TSPI_lineBlindTransfer                 @503
+        TSPI_lineClose                         @504
+        TSPI_lineCloseCall                     @505
+        TSPI_lineCompleteCall                  @506
+        TSPI_lineCompleteTransfer              @507
+        TSPI_lineConditionalMediaDetection     @508
+        TSPI_lineConfigDialog                  @509
+        TSPI_lineDevSpecific                   @510
+        TSPI_lineDevSpecificFeature            @511
+        TSPI_lineDial                          @512
+        TSPI_lineDrop                          @513
+        TSPI_lineForward                       @514
+        TSPI_lineGatherDigits                  @515
+        TSPI_lineGenerateDigits                @516
+        TSPI_lineGenerateTone                  @517
+        TSPI_lineGetAddressCaps                @518
+        TSPI_lineGetAddressID                  @519
+        TSPI_lineGetAddressStatus              @520
+        TSPI_lineGetCallAddressID              @521
+        TSPI_lineGetCallInfo                   @522
+        TSPI_lineGetCallStatus                 @523
+        TSPI_lineGetDevCaps                    @524
+        TSPI_lineGetDevConfig                  @525
+        TSPI_lineGetExtensionID                @526
+        TSPI_lineGetIcon                       @527
+        TSPI_lineGetID                         @528
+        TSPI_lineGetLineDevStatus              @529
+        TSPI_lineGetNumAddressIDs              @530
+        TSPI_lineHold                          @531
+        TSPI_lineMakeCall                      @532
+        TSPI_lineMonitorDigits                 @533
+        TSPI_lineMonitorMedia                  @534
+        TSPI_lineMonitorTones                  @535
+        TSPI_lineNegotiateExtVersion           @536
+        TSPI_lineNegotiateTSPIVersion          @537
+        TSPI_lineOpen                          @538
+        TSPI_linePark                          @539
+        TSPI_linePickup                        @540
+        TSPI_linePrepareAddToConference        @541
+        TSPI_lineRedirect                      @542
+        TSPI_lineRemoveFromConference          @543
+        TSPI_lineSecureCall                    @544
+        TSPI_lineSelectExtVersion              @545
+        TSPI_lineSendUserUserInfo              @546
+        TSPI_lineSetAppSpecific                @547
+        TSPI_lineSetCallParams                 @548
+        TSPI_lineSetDefaultMediaDetection      @549
+        TSPI_lineSetDevConfig                  @550
+        TSPI_lineSetMediaControl               @551
+        TSPI_lineSetMediaMode                  @552
+        TSPI_lineSetStatusMessages             @553
+        TSPI_lineSetTerminal                   @554
+        TSPI_lineSetupConference               @555
+        TSPI_lineSetupTransfer                 @556
+        TSPI_lineSwapHold                      @557
+        TSPI_lineUncompleteCall                @558
+        TSPI_lineUnhold                        @559
+        TSPI_lineUnpark                        @560
+
+        TSPI_phoneClose                        @561
+        TSPI_phoneConfigDialog                 @562
+        TSPI_phoneDevSpecific                  @563
+        TSPI_phoneGetButtonInfo                @564
+        TSPI_phoneGetData                      @565
+        TSPI_phoneGetDevCaps                   @566
+        TSPI_phoneGetDisplay                   @567
+        TSPI_phoneGetExtensionID               @568
+        TSPI_phoneGetGain                      @569
+        TSPI_phoneGetHookSwitch                @570
+        TSPI_phoneGetIcon                      @571
+        TSPI_phoneGetID                        @572
+        TSPI_phoneGetLamp                      @573
+        TSPI_phoneGetRing                      @574
+        TSPI_phoneGetStatus                    @575
+        TSPI_phoneGetVolume                    @576
+        TSPI_phoneNegotiateExtVersion          @577
+        TSPI_phoneNegotiateTSPIVersion         @578
+        TSPI_phoneOpen                         @579
+        TSPI_phoneSelectExtVersion             @580
+        TSPI_phoneSetButtonInfo                @581
+        TSPI_phoneSetData                      @582
+        TSPI_phoneSetDisplay                   @583
+        TSPI_phoneSetGain                      @584
+        TSPI_phoneSetHookSwitch                @585
+        TSPI_phoneSetLamp                      @586
+        TSPI_phoneSetRing                      @587
+        TSPI_phoneSetStatusMessages            @588
+        TSPI_phoneSetVolume                    @589
+
+        TSPI_providerConfig                    @590
+        TSPI_providerInit                      @591
+        TSPI_providerInstall                   @592
+        TSPI_providerRemove                    @593
+        TSPI_providerShutdown                  @594
+
+        TSPI_providerEnumDevices               @595
+        TSPI_lineDropOnClose                   @596
+        TSPI_lineDropNoOwner                   @597
+        TSPI_providerCreateLineDevice          @598
+        TSPI_providerCreatePhoneDevice         @599
+        TSPI_lineSetCurrentLocation            @600
+        TSPI_lineConfigDialogEdit              @601
+        TSPI_lineReleaseUserUserInfo           @602
+
+        WEP @1
+        LibMain @2
+;        DllEntryPoint
+
+; Table of vital pointers for 32-bit half of GDI thunks
+
+;    TAPITHKCONNECTIONDATALS	      ;	@110        ;Internal
+;    FT_TAPIFTHKTHKCONNECTIONDATA      ;	@111	    ;Internal
+;    Tapi32ConnectionDataSL
+
+        TapiThk_ThunkData32
+        TapiFThk_ThunkData32
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.h b/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.h
new file mode 100644
index 000000000..dc5fa151f
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632l/tsp1632l.h
@@ -0,0 +1,53 @@
+/*  TSP3216S.H
+    Copyright 1995 (C) Microsoft Corporation
+
+    32-bit TAPI service provider to act as a cover for a system's 16-bit SPs
+
+    16-bit part: TSP3216S.DLL
+    32-bit part: TSP3216L.DLL
+
+    t-jereh 20-July-1995
+
+    TODO:
+    1) allow debug levels
+    2) if oom in InitializeSPs(), fail
+
+ */
+
+#define MAXBUFSIZE 256 /* maximum buffer size */
+
+#define ERR_NONE 0 /* success return value */
+
+#define TAPI_CUR_VER 0x00010004
+
+#define TSPI_PROC_LAST 103 /* there are TSPI functions from 500 to 602 */
+
+
+// structs
+
+typedef struct tagMYLINE
+    {
+    HDRVLINE hdLine;
+    int iProvider;
+    DWORD dwDeviceID;
+    LINEEVENT lpfnEventProc;
+    HTAPILINE htLine;
+    } MYLINE, *LPMYLINE;
+
+
+typedef struct tagMYPHONE
+    {
+    HDRVPHONE hdPhone;
+    int iProvider;
+    DWORD dwDeviceID;
+    PHONEEVENT lpfnEventProc;
+    HTAPIPHONE htPhone;
+    } MYPHONE, *LPMYPHONE;
+
+
+typedef struct tagMYCALL
+    {
+    HDRVCALL hdCall;
+    int iProvider;
+    DWORD dwDeviceID;
+    } MYCALL, *LPMYCALL;
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632s/depend.mk b/private/tapi/dev/sp/tsp1632/tsp1632s/depend.mk
new file mode 100644
index 000000000..bce4481e3
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632s/depend.mk
@@ -0,0 +1,9 @@
+.\tapi32.obj:   ..\..\script\$(VERDIR)\tapi32.asm
+
+.\tapithk.obj:  ..\..\script\$(VERDIR)\tapithk.asm
+
+.\tapifthk.obj: ..\..\script\$(VERDIR)\tapifthk.asm
+
+.\tpiint32.obj: ..\tpiint32.asm
+
+.\tsp1632s.res: ..\tsp1632s.rc
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632s/makefile b/private/tapi/dev/sp/tsp1632/tsp1632s/makefile
new file mode 100644
index 000000000..274a6cf4b
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632s/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tsp1632s.tsp Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632s/makefile.def b/private/tapi/dev/sp/tsp1632/tsp1632s/makefile.def
new file mode 100644
index 000000000..435aef87a
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632s/makefile.def
@@ -0,0 +1,51 @@
+ROOT=..\..\..\..\..\..\..
+
+IS_OEM=1
+MASM6=1
+IS_16 = 1
+
+
+BUILDDLL=1
+DEFENTRY=DllEntryPoint
+DLLENTRY=DllEntryPoint
+#DLLENTRY=LibMain
+
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=tsp1632s.tsp
+
+
+ALTSRCDIR=..\..\script\$(VERDIR)
+SRCDIR=..
+
+#BUILD_COFF=1
+
+
+
+L16EXE=tsp1632s.tsp		# Name of exe.
+L16DEF=..\tsp1632s.def              # Our def file.
+L16MAP=tsp1632s.map		# Our map file.
+L16SYM=tsp1632s.sym		# Our sym file.
+L16RES=tsp1632s.res	# Resource file.
+L16OBJS = $(DEVROOT)\sdk\lib16\libentry.obj tpiint32.obj tapi32.obj tapithk.obj tapifthk.obj
+
+L16LIBS= \
+    $(DEVROOT)\lib16\libw.lib \
+    $(DEVROOT)\tools\c816\lib\ldllcew.lib \
+    $(DEVROOT)\lib16\kernel.lib 
+
+
+
+RCFLAGS=$(RCFLAGS) -40
+
+
+!include $(ROOT)\dev\master.mk
+#!include $(ROOT)\win\win32\win32.mk
+
+
+AFLAGS=$(AFLAGS) -Fl
+
+INCLUDE=$(ROOT)\win\thunk;$(ROOT)\win\core\inc;$(INCLUDE)
+#INCLUDE=$(ROOT)\win\thunk;$(INCLUDE)
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632s/tpiint32.asm b/private/tapi/dev/sp/tsp1632/tsp1632s/tpiint32.asm
new file mode 100644
index 000000000..9edcffc2d
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632s/tpiint32.asm
@@ -0,0 +1,844 @@
+        page    ,132
+        TITLE   $tapii32.asm
+        .listall
+
+        .386
+        OPTION READONLY
+        option oldstructs
+
+
+;        .model FLAT
+	OPTION SEGMENT:USE16
+	.model LARGE,PASCAL
+
+
+
+;	.fardata callbacks
+;.data
+CALLBACK SEGMENT PARA PUBLIC ''
+
+	public	LineCallbackList
+	public	PhoneCallbackList
+
+LineCallbackList	dd	0
+PhoneCallbackList	dd	0
+
+CALLBACK_NEXT          equ 0
+CALLBACK_CALLBACK      equ 4
+CALLBACK_HAPP          equ 8
+CALLBACK_STRUCT_SIZE   equ 0ch
+
+CALLBACK ENDS
+
+
+
+;GetpWin16Lock			proto APIENTRY :ptr dword
+
+
+;externDef	STDCALL lineInitialize16@20:near32
+;externDef	STDCALL lineShutdown16@4:near32
+;externDef	STDCALL phoneInitialize16@20:near32
+;externDef	STDCALL phoneShutdown16@4:near32
+
+; ; ;IsBadCodePtr	proto APIENTRY       :ptr dword
+; ; ;
+; ; ;GlobalAlloc                  PROTO NEAR APIENTRY   :DWORD, :DWORD
+; ; ;GlobalLock                   PROTO NEAR APIENTRY   :DWORD
+; ; ;GlobalHandle                 PROTO NEAR APIENTRY   :DWORD
+; ; ;GlobalUnlock                 PROTO NEAR APIENTRY   :DWORD
+; ; ;GlobalFree                   PROTO NEAR APIENTRY   :DWORD
+
+;AllocSLCallback              PROTO NEAR APIENTRY   :DWORD, :DWORD
+;FreeSLCallback               PROTO NEAR APIENTRY   :DWORD
+Tapi32ConnectPeerSL          PROTO near           pszDll16:dword, pszDll32:dword
+;
+;
+;externDef InitThkSL                     :near32
+;externDef FdThkCommon                   :near32
+;
+;TapiThunkInit			PROTO near pCB32Tab:dword
+;TapiThunkTerminate		PROTO near pCB32Tab:dword
+
+;TapiThkConnectPeerLS            PROTO near pszDll16:dword, pszDll32:dword
+;FT_TapiFThkConnectToFlatThkPeer	proto near pszDll16:dword, pszDll32:dword
+;NewData			PROTO near
+NewData2			PROTO far
+;FreeLibrary16			PROTO NEAR STDCALL :DWORD
+
+
+
+
+TapiThk_ThunkConnect16	proto far pascal  SpszDll16:word,
+                                               OpszDll16:word,
+                                               SpszDll32:word,
+                                               OpszDll32:word,
+                                               hInst:word,
+                                               dwReason:dword
+
+TapiFThk_ThunkConnect16	proto far pascal  SpszDll16:word,
+                                               OpszDll16:word,
+                                               SpszDll32:word,
+                                               OpszDll32:word,
+                                               hInst:word,
+                                               dwReason:dword
+
+
+
+
+;* externDef TapiCB32BitTable		:near32
+
+
+	.data
+
+
+lp16TapiCallbackThunk	dd	0
+
+
+;
+; Pointer to the Win16 heirarchical critical section.
+;
+;	public	Win16Lock
+;Win16Lock	dd	0
+
+
+
+pszDll16	db	'TSP1632s.TSP',0
+pszDll32	db	'TSP1632l.DLL',0
+
+
+cProcessAttach	dw	0		;Count of processes attached to our lib.
+
+
+;        .code   THUNK32
+        .code
+
+
+
+WEP  proc far pascal
+   ret
+WEP endp
+
+LibMain proc  far pascal  wInst:WORD, uDataSeg:WORD, cbHeapSize:WORD,
+                      lpszCmdLine:DWORD 
+
+    invoke TapiThk_ThunkConnect16, seg pszDll16,
+                                   offset pszDll16,
+                                   seg pszDll32,
+                                   offset pszDll32,
+                                   wInst,
+                                   1
+
+    invoke TapiFThk_ThunkConnect16, seg pszDll16,
+                                   offset pszDll16,
+                                   seg pszDll32,
+                                   offset pszDll32,
+                                   wInst,
+                                   1
+
+
+
+; Initialize the 16->32 thunks.
+;	invoke	Tapi32ConnectPeerSL, ADDR pszDll16, ADDR pszDll32
+;	or	eax,eax
+
+
+mov  ax, 1
+   ret
+LibMain endp
+
+;-----------------------------------------------------------------------;
+; Tapi DLL init routine
+; We expect lReason to be either DLL_PROCESS_ATTACH/DETACH (we take
+; action on these values) or DLL_THREAD_ATTACH/DETACH (we ignore
+; and return success). If there is anything else, we need to check
+; specifically and take appropriate action.
+;-----------------------------------------------------------------------;
+DllEntryPoint proc  far pascal export  lReason:DWORD, wInst:WORD, 
+                            wDS:WORD, wHeapSize:WORD,
+                            dwReserved1:DWORD, wReserved:WORD
+
+
+    invoke TapiThk_ThunkConnect16, seg pszDll16,
+                                   offset pszDll16,
+                                   seg pszDll32,
+                                   offset pszDll32,
+                                   wInst,
+                                   1
+
+    invoke TapiFThk_ThunkConnect16, seg pszDll16,
+                                   offset pszDll16,
+                                   seg pszDll32,
+                                   offset pszDll32,
+                                   wInst,
+                                   1
+
+    invoke NewData2
+    mov    word ptr lp16TapiCallbackThunk+2, dx
+    mov    word ptr lp16TapiCallbackThunk  , ax
+
+	jmp	initok
+
+
+;;;;;09/18/95
+;;;;;09/18/95
+;;;;;09/18/95
+;;;;;09/18/95
+;;;;;09/18/95;****	invoke	GetpWin16Lock, ADDR Win16Lock
+;;;;;09/18/95
+;;;;;09/18/95	mov     eax, lReason
+;;;;;09/18/95	or	eax, eax
+;;;;;09/18/95	jz	dec_cProcess	;DLL_PROCESS_DETACH?
+;;;;;09/18/95    cmp     eax, 1		;DLL_PROCESS_ATTACH?
+;;;;;09/18/95    jne     initok		;DLL_THREAD_ATTACH/DETACH (we don't do anything)
+;;;;;09/18/95
+;;;;;09/18/95
+;;;;;09/18/95	inc	cProcessAttach	;Keep count of how many processes attach to our lib.
+;;;;;09/18/95
+;;;;;09/18/95; Do once-only initialization.
+;;;;;09/18/95;
+;;;;;09/18/95;	mov     al, 0
+;;;;;09/18/95;	xchg    al, fFirstTime
+;;;;;09/18/95;	or      al, al
+;;;;;09/18/95;	jnz     initThunk
+;;;;;09/18/95
+;;;;;09/18/95	cmp	cProcessAttach, 1
+;;;;;09/18/95	jne	initok
+;;;;;09/18/95
+;;;;;09/18/95; This means that we've done our once only initialization before, but
+;;;;;09/18/95; that cProcessAttach went down to zero at some point and is now back
+;;;;;09/18/95; to 1. When cProcessAttach becomes 0, TapiThunkTerminate gets called
+;;;;;09/18/95; which frees up our thunk table (by calling UnRegisterCBClient). So
+;;;;;09/18/95; now we need to do that initialization again by calling TapiThunkInit.
+;;;;;09/18/95;	pushd	offset TapiCB32BitTable
+;;;;;09/18/95;	call    TapiThunkInit
+;;;;;09/18/95;	jmp	initok
+;;;;;09/18/95
+;;;;;09/18/95
+;;;;;09/18/95initThunk:
+;;;;;09/18/95;    invoke  TapiThkConnectPeerLS, ADDR pszDll16, ADDR pszDll32
+;;;;;09/18/95	or	eax,eax
+;;;;;09/18/95	jz	exit
+;;;;;09/18/95
+;;;;;09/18/95; Now call our first thunk to further initialize.
+;;;;;09/18/95;*******************	pushd	offset TapiCB32BitTable
+;;;;;09/18/95;*******************	call    TapiThunkInit
+;;;;;09/18/95
+;;;;;09/18/95; Initialize the flat thunks.
+;;;;;09/18/95;	invoke	FT_TapiFThkConnectToFlatThkPeer, ADDR pszDll16, ADDR pszDll32
+;;;;;09/18/95	or	eax,eax
+;;;;;09/18/95	jz	exit
+;;;;;09/18/95
+;;;;;09/18/95; Initialize the 16->32 thunks.
+;;;;;09/18/95;	invoke	Tapi32ConnectPeerSL, ADDR pszDll16, ADDR pszDll32
+;;;;;09/18/95	or	eax,eax
+;;;;;09/18/95	jz	exit
+;;;;;09/18/95
+;;;;;09/18/95    invoke NewData2
+;;;;;09/18/95    mov    word ptr lp16TapiCallbackThunk+2, dx
+;;;;;09/18/95    mov    word ptr lp16TapiCallbackThunk  , ax
+;;;;;09/18/95
+;;;;;09/18/95	jmp	initok
+;;;;;09/18/95
+;;;;;09/18/95
+;;;;;09/18/95dec_cProcess:
+
+;*	pushd	offset TapiCB32BitTable
+;*	call	TapiThunkTerminate	;needed just for UnRegisterCBClient
+
+
+;
+; Well, we know we have to get rid of all inits and thunk callbacks for
+; this process...
+;
+
+;**********************************      free all the callback thunks
+; ; ;    ;
+; ; ;    ; Run the linked list of callbacks & free 'em all.
+; ; ;    ;
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;
+; ; ;    mov    ebx, LineCallbackList       ; Get the line list anchor
+; ; ;
+; ; ;FreeEmAll:
+; ; ;    or     ebx, ebx                    ; At last entry?
+; ; ;    jz     DoneFreez                   ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Call lineShutdown on this behalf
+; ; ;    ;
+; ; ;    push   ebx                         ; Save this - just in case
+; ; ;    push   [ebx+CALLBACK_HAPP]         ; Push the hLineApp
+; ; ;    call   lineShutdown16@4            ; Shut em down.
+; ; ;    pop    ebx                         ; Get back our value.
+; ; ;
+; ; ;    push   [ebx+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    push   ebx                         ; Use this before freeing it.
+; ; ;
+; ; ;    mov    ebx, [ebx+CALLBACK_NEXT]    ; Get next node in the list.
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the node's memory chunk.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    jmp    FreeEmAll                   ; Do the walk of life.
+; ; ;
+; ; ;DoneFreez:
+; ; ;
+; ; ;    mov    LineCallbackList, 0         ; Just in case...
+; ; ;
+; ; ;
+; ; ;    mov    ebx, PhoneCallbackList      ; Get the phone list anchor
+; ; ;FreeEmAll2:
+; ; ;    or     ebx, ebx                    ; At last entry?
+; ; ;    jz     DoneFreez2                  ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Call phoneShutdown on this behalf
+; ; ;    ;
+; ; ;    push   ebx                         ; Save this - just in case
+; ; ;    push   [ebx+CALLBACK_HAPP]         ; Push the hPhoneApp
+; ; ;    call   phoneShutdown16@4
+; ; ;    pop    ebx                         ; Get back our value.
+; ; ;
+; ; ;    push   [ebx+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    push   ebx                         ; Use this before freeing it.
+; ; ;
+; ; ;    mov    ebx, [ebx+CALLBACK_NEXT]    ; Get next node in the list.
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the node's memory chunk.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    jmp    FreeEmAll2                  ; Do the walk of life.
+; ; ;
+; ; ;DoneFreez2:
+; ; ;
+; ; ;    mov    PhoneCallbackList, 0        ; Just in case...
+; ; ;
+; ; ;    pop    ebx                         ; Get the saved value.
+
+
+
+;;;;;09/18/95	dec	cProcessAttach	;Update count of attached processes.
+;;;;;09/18/95	cmp	cProcessAttach, 0
+;;;;;09/18/95	jne	initok
+;;;;;09/18/95
+
+;**********************************
+
+
+;
+; It would have been really cool to have implemented orthogonal thunks, but
+; that didn't happen in M7 because of time pressure and because of potential
+; destabilizing effects.
+; The load count of tapi.dll at this point is 2 (one each for the two
+; thunk scripts that we have (flat and 16-bit thunks)). So we need to
+; call FreeLibrary16 twice to make sure that tapi.dll gets unloaded after
+; this point.
+; So why does tapi.dll hang around even after the last app. that attached
+; to it is gone? Well, per AtsushiK, that's because it uses the same loading
+; technology as kernel, gdi and user. Those libraries never needed to be
+; freed, so no one ever wrote the code to free them. That means that the
+; following hack will work. What's more, it will always work.
+;					---DeepakA
+;	invoke	GetTapiHInst
+
+
+;	invoke	NewData
+;	push	eax
+;	push	eax
+;	push	eax
+;	call	FreeLibrary16
+;	call	FreeLibrary16
+;	call	FreeLibrary16
+
+
+
+initok:
+        mov     eax, 1         ;return success
+exit:
+        ret
+
+
+
+
+DllEntryPoint endp
+; end DllEntryPoint
+
+
+
+
+
+
+
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;lineInitialize proc    near32   lphApp:DWORD, hInstance:DWORD, lpfnCallback:DWORD, lpsAppName:DWORD, lpdwNumDevs:DWORD
+; ; ;
+; ; ;    ;
+; ; ;    ; First, check the code pointer
+; ; ;    ;
+; ; ;    push   lpfnCallback                ; Push the apps callback address
+; ; ;    call   IsBadCodePtr                ; Is is a valid code pointer?
+; ; ;    or     eax, eax
+; ; ;    jnz    BadCodePointer              ; Nope.  Go away.
+; ; ;
+; ; ;
+; ; ;    push   CALLBACK_STRUCT_SIZE
+; ; ;    push   42h  ;(GMEM_MOVABLE + GMEM_ZEROINIT)
+; ; ;    call   GlobalAlloc                 ; Get some memory for a new node.
+; ; ;    push   eax
+; ; ;    call   GlobalLock
+; ; ;
+; ; ;    or     eax, eax                    ; Did the call fail?
+; ; ;    jz     No_mo_mem                   ; Yerp - go away.
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   eax                         ; We'll need this later (newnode ptr)
+; ; ;    mov    ebx, eax                    ; We'll also be using it very soon.
+; ; ;
+; ; ;    push   lpfnCallback                ; Save 32bit address of callback
+; ; ;    push   lp16TapiCallbackThunk       ; 16bit callback gotten at init time
+; ; ;    call   AllocSLCallback             ; Get a callback
+; ; ;
+; ; ;    ; check return code (0 = failed)
+; ; ;    or     eax, eax                    ; Did we fail?
+; ; ;    jz     No_mo_callbacks             ; Yes, go away.
+; ; ;
+; ; ;    mov    [ebx+CALLBACK_CALLBACK], eax  ;Save the callback address
+; ; ;
+; ; ;    push   lpdwNumDevs                 ; Prepare to call lineInitialize
+; ; ;    push   lpsAppName                  ; Prepare to call lineInitialize
+; ; ;    push   eax                         ; Prepare to call lineInitialize
+; ; ;    push   hInstance                   ; Prepare to call lineInitialize
+; ; ;    push   lphApp                      ; Prepare to call lineInitialize
+; ; ;    call   lineInitialize16@20
+; ; ;
+; ; ;    or     eax, eax                    ; Did lineInit fail?
+; ; ;    jnz    BadReturnCode               ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Now that everything went well, add the new node to the list.
+; ; ;    ;
+; ; ;    pop    ebx                         ; Get the node pointer
+; ; ;
+; ; ;    mov    eax, LineCallbackList       ; Get pointer to first node
+; ; ;    mov    [ebx+CALLBACK_NEXT], eax    ; Fix chain
+; ; ;    mov    LineCallbackList, ebx       ; Insert this new node as first
+; ; ;
+; ; ;    mov    eax, [lphApp]
+; ; ;    mov    eax, [eax]
+; ; ;    mov    [ebx+CALLBACK_HAPP], eax    ; Save the hLineApp
+; ; ;
+; ; ;    xor    eax, eax                    ; Set return code (we got 0 from init).
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadReturnCode:
+; ; ;    xchg   [esp], eax                  ; Get the struct pointer
+; ; ;
+; ; ;    push   eax                         ; We're gonna use this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the callback address
+; ; ;    call   FreeSLCallback              ; Free the thunk callback
+; ; ;
+; ; ;    ;
+; ; ;    ; We've already pushed eax (the newnode pointer) so we don't gotta do
+; ; ;    ; it here.
+; ; ;    ;
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the newnode chunk of mem.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    eax                         ; Get return code.
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadCodePointer:
+; ; ;    mov    eax, 80000035h
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;No_mo_callbacks:
+; ; ;    pop    eax                         ; Get out struct pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;No_mo_mem:
+; ; ;    mov    eax, 80000044h
+; ; ;    ret
+; ; ;
+; ; ;lineInitialize endp
+; ; ;
+; ; ;
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;lineShutdown proc    near32   hApp:DWORD
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;    push   ecx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   hApp
+; ; ;
+; ; ;    call   lineShutdown16@4
+; ; ;
+; ; ;    push   eax                         ; Save the return code.
+; ; ;
+; ; ;    ;
+; ; ;    ; Run the linked list of callbacks looking for this hLineApp
+; ; ;    ;
+; ; ;
+; ; ;    mov    eax, LineCallbackList       ; Get the list anchor
+; ; ;    mov    ebx, offset LineCallbackList ; The previous node.
+; ; ;    mov    ecx, hApp                   ; That which we seek.
+; ; ;
+; ; ;LoopAMundo:
+; ; ;    or     eax, eax                    ; At last entry?
+; ; ;    jz     NotFound                    ; Yup.  Musta not been found.
+; ; ;
+; ; ;    cmp    [eax+CALLBACK_HAPP], ecx    ; Is this that which we seek?
+; ; ;    je     GotIt                       ; Yep - shure is.
+; ; ;
+; ; ;    mov    ebx, eax                    ; Update the "previous" pointer.
+; ; ;    mov    eax, [eax+CALLBACK_NEXT]    ; Get next node in the list
+; ; ;    jmp    LoopAMundo                  ; Do the walk of life.
+; ; ;
+; ; ;GotIt:
+; ; ;    push   eax                         ; We're gonna need this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    ;
+; ; ;    ; Now take it out of the list.
+; ; ;    ;
+; ; ;
+; ; ;    pop    eax                         ; Get back the node pointer.
+; ; ;
+; ; ;    push   [eax+CALLBACK_NEXT]         ; Get this "next" pointer.
+; ; ;    pop    [ebx+CALLBACK_NEXT]         ; and fix the chain.
+; ; ;
+; ; ;    push   eax                         ; Push the trash node pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;
+; ; ;NotFound:
+; ; ;    ;
+; ; ;    ; How is this possible?
+; ; ;    ; Oh well.  We can do nothing here.
+; ; ;    ;
+; ; ;
+; ; ;
+; ; ;    pop    eax                         ; Retrieve the return code.
+; ; ;
+; ; ;    pop    ecx                         ; Get the saved value.
+; ; ;    pop    ebx                         ; Get the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;lineShutdown endp
+; ; ;
+; ; ;
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;phoneInitialize proc    near32   lphApp:DWORD, hInstance:DWORD, lpfnCallback:DWORD, lpsAppName:DWORD, lpdwNumDevs:DWORD
+; ; ;
+; ; ;    ;
+; ; ;    ; First, check the code pointer
+; ; ;    ;
+; ; ;    push   lpfnCallback                ; Push the apps callback address
+; ; ;    call   IsBadCodePtr                ; Is is a valid code pointer?
+; ; ;    or     eax, eax
+; ; ;    jnz    BadCodePointer              ; Nope.  Go away.
+; ; ;
+; ; ;
+; ; ;    push   CALLBACK_STRUCT_SIZE
+; ; ;    push   42h  ;(GMEM_MOVABLE + GMEM_ZEROINIT)
+; ; ;    call   GlobalAlloc                 ; Get some memory for a new node.
+; ; ;    push   eax
+; ; ;    call   GlobalLock
+; ; ;
+; ; ;    or     eax, eax                    ; Did the call fail?
+; ; ;    jz     No_mo_mem                   ; Yerp - go away.
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   eax                         ; We'll need this later (newnode ptr)
+; ; ;    mov    ebx, eax                    ; We'll also be using it very soon.
+; ; ;
+; ; ;    push   lpfnCallback                ; Save 32bit address of callback
+; ; ;    push   lp16TapiCallbackThunk       ; 16bit callback gotten at init time
+; ; ;    call   AllocSLCallback             ; Get a callback
+; ; ;
+; ; ;    ; check return code (0 = failed)
+; ; ;    or     eax, eax                    ; Did we fail?
+; ; ;    jz     No_mo_callbacks             ; Yes, go away.
+; ; ;
+; ; ;    mov    [ebx+CALLBACK_CALLBACK], eax  ;Save the callback address
+; ; ;
+; ; ;    push   lpdwNumDevs                 ; Prepare to call phoneInitialize
+; ; ;    push   lpsAppName                  ; Prepare to call phoneInitialize
+; ; ;    push   eax                         ; Prepare to call phoneInitialize
+; ; ;    push   hInstance                   ; Prepare to call phoneInitialize
+; ; ;    push   lphApp                      ; Prepare to call phoneInitialize
+; ; ;    call   phoneInitialize16@20
+; ; ;
+; ; ;    or     eax, eax                    ; Did phoneInit fail?
+; ; ;    jnz    BadReturnCode               ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Now that everything went well, add the new node to the list.
+; ; ;    ;
+; ; ;    pop    ebx                         ; Get the node pointer
+; ; ;    mov    eax, PhoneCallbackList      ; Get pointer to first node
+; ; ;    mov    [ebx+CALLBACK_NEXT], eax    ; Fix chain
+; ; ;    mov    PhoneCallbackList, ebx      ; Insert this new node as first
+; ; ;
+; ; ;    mov    eax, [lphApp]
+; ; ;    mov    eax, [eax]
+; ; ;    mov    [ebx+CALLBACK_HAPP], eax    ; Save the hPhoneApp
+; ; ;
+; ; ;    xor    eax, eax                    ; Set return code (we got 0 from init).
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadReturnCode:
+; ; ;    xchg   [esp], eax                  ; Get the struct pointer
+; ; ;
+; ; ;    push   eax                         ; We're gonna use this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the callback address
+; ; ;    call   FreeSLCallback              ; Free the thunk callback
+; ; ;
+; ; ;    ;
+; ; ;    ; We've already pushed eax (the newnode pointer) so we don't gotta do
+; ; ;    ; it here.
+; ; ;    ;
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the newnode chunk of mem.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    eax                         ; Get return code.
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadCodePointer:
+; ; ;    mov    eax, 90000035h
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;No_mo_callbacks:
+; ; ;    pop    eax                         ; Get out struct pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;No_mo_mem:
+; ; ;    mov    eax, 90000044h
+; ; ;    ret
+; ; ;
+; ; ;phoneInitialize endp
+; ; ;
+; ; ;
+; ; ;;phoneInitialize proc    near32   lphApp:DWORD, hInstance:DWORD, lpfnCallback:DWORD, lpsAppName:DWORD, lpdwNumDevs:DWORD
+; ; ;;
+; ; ;;    ;
+; ; ;;    ; First, check the code pointer
+; ; ;;    ;
+; ; ;;    push   lpfnCallback
+; ; ;;    call   IsBadCodePtr
+; ; ;;    or     eax, eax
+; ; ;;    jz     GoodPointer
+; ; ;;
+; ; ;;    mov    eax, 90000035h
+; ; ;;    ret
+; ; ;;
+; ; ;;GoodPointer:
+; ; ;;    push   lpdwNumDevs
+; ; ;;    push   lpsAppName
+; ; ;;    
+; ; ;;    push   lpfnCallback
+; ; ;;    push   lp16TapiCallbackThunk
+; ; ;;    call   AllocSLCallback
+; ; ;;
+; ; ;;    ; check return code (0 = failed)
+; ; ;;    or     eax, eax
+; ; ;;    jz     No_mo_callbacks
+; ; ;;
+; ; ;;
+; ; ;;    mov    TapiCallbackThunk, eax
+; ; ;;    push   eax
+; ; ;;
+; ; ;;    push   hInstance
+; ; ;;    push   lphApp
+; ; ;;
+; ; ;;    call   phoneInitialize16@20
+; ; ;;
+; ; ;;    ret
+; ; ;;
+; ; ;;
+; ; ;;No_mo_callbacks:
+; ; ;;    mov    eax, 90000044h
+; ; ;;    ret
+; ; ;;
+; ; ;;phoneInitialize endp
+; ; ;
+; ; ;
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;phoneShutdown proc    near32   hApp:DWORD
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;    push   ecx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   hApp
+; ; ;
+; ; ;    call   phoneShutdown16@4
+; ; ;
+; ; ;    push   eax                         ; Save the return code.
+; ; ;
+; ; ;    ;
+; ; ;    ; Run the linked list of callbacks looking for this hPhoneApp
+; ; ;    ;
+; ; ;
+; ; ;    mov    eax, PhoneCallbackList    ; Get the list anchor
+; ; ;    mov    ebx, offset PhoneCallbackList ; The previous node.
+; ; ;    mov    ecx, hApp                   ; That which we seek.
+; ; ;
+; ; ;LoopAMundo:
+; ; ;    or     eax, eax                    ; At last entry?
+; ; ;    jz     NotFound                    ; Yup.  Musta not been found.
+; ; ;
+; ; ;    cmp    [eax+CALLBACK_HAPP], ecx    ; Is this that which we seek?
+; ; ;    je     GotIt                       ; Yep - shure is.
+; ; ;
+; ; ;    mov    ebx, eax                    ; Update the "previous" pointer.
+; ; ;    mov    eax, [eax+CALLBACK_NEXT]    ; Get next node in the list
+; ; ;    jmp    LoopAMundo                  ; Do the walk of life.
+; ; ;
+; ; ;GotIt:
+; ; ;    push   eax                         ; We're gonna need this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    ;
+; ; ;    ; Now take it out of the list.
+; ; ;    ;
+; ; ;
+; ; ;    pop    eax                         ; Get back the node pointer.
+; ; ;
+; ; ;    push   [eax+CALLBACK_NEXT]         ; Get this "next" pointer.
+; ; ;    pop    [ebx+CALLBACK_NEXT]         ; and fix the chain.
+; ; ;
+; ; ;    push   eax                         ; Push the trash node pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;
+; ; ;NotFound:
+; ; ;    ;
+; ; ;    ; How is this possible?
+; ; ;    ; Oh well.  We can do nothing here.
+; ; ;    ;
+; ; ;
+; ; ;
+; ; ;    pop    eax                         ; Retrieve the return code.
+; ; ;
+; ; ;    pop    ecx                         ; Get the saved value.
+; ; ;    pop    ebx                         ; Get the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;
+; ; ;;    push   hApp
+; ; ;;
+; ; ;;    call   phoneShutdown16@4
+; ; ;;
+; ; ;;    cmp    TapiCallbackThunk, 0
+; ; ;;    je     Dont_free_me
+; ; ;;
+; ; ;;    push   eax                    ; We're gonna need this...
+; ; ;;
+; ; ;;    push   TapiCallbackThunk
+; ; ;;    call   FreeSLCallback
+; ; ;;
+; ; ;;    pop    eax                    ; Get back our _real_ return code...
+; ; ;;
+; ; ;;    mov    TapiCallbackThunk, 0
+; ; ;;
+; ; ;;
+; ; ;;Dont_free_me:
+; ; ;;
+; ; ;;    ret
+; ; ;;
+; ; ;phoneShutdown endp
+; ; ;
+
+
+end
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632s/tsp1632s.def b/private/tapi/dev/sp/tsp1632/tsp1632s/tsp1632s.def
new file mode 100644
index 000000000..d04cb0dd4
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632s/tsp1632s.def
@@ -0,0 +1,125 @@
+LIBRARY     TSP1632s
+EXETYPE     WINDOWS
+PROTMODE
+CODE        PRELOAD MOVEABLE DISCARDABLE
+DATA        PRELOAD FIXED SINGLE
+
+EXPORTS
+        WEP           @1       RESIDENTNAME
+        DllEntryPoint   @2     RESIDENTNAME
+        LibMain        @3      RESIDENTNAME
+        TapiThk_ThunkData16 @5
+        TapiFThk_ThunkData16 @6
+
+        TSPI_lineAccept                        @500
+        TSPI_lineAddToConference               @501
+        TSPI_lineAnswer                        @502
+        TSPI_lineBlindTransfer                 @503
+        TSPI_lineClose                         @504
+        TSPI_lineCloseCall                     @505
+        TSPI_lineCompleteCall                  @506
+        TSPI_lineCompleteTransfer              @507
+        TSPI_lineConditionalMediaDetection     @508
+        TSPI_lineConfigDialog                  @509
+        TSPI_lineDevSpecific                   @510
+        TSPI_lineDevSpecificFeature            @511
+        TSPI_lineDial                          @512
+        TSPI_lineDrop                          @513
+        TSPI_lineForward                       @514
+        TSPI_lineGatherDigits                  @515
+        TSPI_lineGenerateDigits                @516
+        TSPI_lineGenerateTone                  @517
+        TSPI_lineGetAddressCaps                @518
+        TSPI_lineGetAddressID                  @519
+        TSPI_lineGetAddressStatus              @520
+        TSPI_lineGetCallAddressID              @521
+        TSPI_lineGetCallInfo                   @522
+        TSPI_lineGetCallStatus                 @523
+        TSPI_lineGetDevCaps                    @524
+        TSPI_lineGetDevConfig                  @525
+        TSPI_lineGetExtensionID                @526
+        TSPI_lineGetIcon                       @527
+        TSPI_lineGetID                         @528
+        TSPI_lineGetLineDevStatus              @529
+        TSPI_lineGetNumAddressIDs              @530
+        TSPI_lineHold                          @531
+        TSPI_lineMakeCall                      @532
+        TSPI_lineMonitorDigits                 @533
+        TSPI_lineMonitorMedia                  @534
+        TSPI_lineMonitorTones                  @535
+        TSPI_lineNegotiateExtVersion           @536
+        TSPI_lineNegotiateTSPIVersion          @537
+        TSPI_lineOpen                          @538
+        TSPI_linePark                          @539
+        TSPI_linePickup                        @540
+        TSPI_linePrepareAddToConference        @541
+        TSPI_lineRedirect                      @542
+        TSPI_lineRemoveFromConference          @543
+        TSPI_lineSecureCall                    @544
+        TSPI_lineSelectExtVersion              @545
+        TSPI_lineSendUserUserInfo              @546
+        TSPI_lineSetAppSpecific                @547
+        TSPI_lineSetCallParams                 @548
+        TSPI_lineSetDefaultMediaDetection      @549
+        TSPI_lineSetDevConfig                  @550
+        TSPI_lineSetMediaControl               @551
+        TSPI_lineSetMediaMode                  @552
+        TSPI_lineSetStatusMessages             @553
+        TSPI_lineSetTerminal                   @554
+        TSPI_lineSetupConference               @555
+        TSPI_lineSetupTransfer                 @556
+        TSPI_lineSwapHold                      @557
+        TSPI_lineUncompleteCall                @558
+        TSPI_lineUnhold                        @559
+        TSPI_lineUnpark                        @560
+
+        TSPI_phoneClose                        @561
+        TSPI_phoneConfigDialog                 @562
+        TSPI_phoneDevSpecific                  @563
+        TSPI_phoneGetButtonInfo                @564
+        TSPI_phoneGetData                      @565
+        TSPI_phoneGetDevCaps                   @566
+        TSPI_phoneGetDisplay                   @567
+        TSPI_phoneGetExtensionID               @568
+        TSPI_phoneGetGain                      @569
+        TSPI_phoneGetHookSwitch                @570
+        TSPI_phoneGetIcon                      @571
+        TSPI_phoneGetID                        @572
+        TSPI_phoneGetLamp                      @573
+        TSPI_phoneGetRing                      @574
+        TSPI_phoneGetStatus                    @575
+        TSPI_phoneGetVolume                    @576
+        TSPI_phoneNegotiateExtVersion          @577
+        TSPI_phoneNegotiateTSPIVersion         @578
+        TSPI_phoneOpen                         @579
+        TSPI_phoneSelectExtVersion             @580
+        TSPI_phoneSetButtonInfo                @581
+        TSPI_phoneSetData                      @582
+        TSPI_phoneSetDisplay                   @583
+        TSPI_phoneSetGain                      @584
+        TSPI_phoneSetHookSwitch                @585
+        TSPI_phoneSetLamp                      @586
+        TSPI_phoneSetRing                      @587
+        TSPI_phoneSetStatusMessages            @588
+        TSPI_phoneSetVolume                    @589
+
+        TSPI_providerConfig                    @590
+        TSPI_providerInit                      @591
+        TSPI_providerInstall                   @592
+        TSPI_providerRemove                    @593
+        TSPI_providerShutdown                  @594
+
+        TSPI_providerEnumDevices               @595
+        TSPI_lineDropOnClose                   @596
+        TSPI_lineDropNoOwner                   @597
+        TSPI_providerCreateLineDevice          @598
+        TSPI_providerCreatePhoneDevice         @599
+        TSPI_lineSetCurrentLocation            @600
+        TSPI_lineConfigDialogEdit              @601
+        TSPI_lineReleaseUserUserInfo           @602
+
+IMPORTS
+        C16ThkSL01      = KERNEL.631
+        ThunkConnect16  = KERNEL.651
+
+
diff --git a/private/tapi/dev/sp/tsp1632/tsp1632s/tsp1632s.rc b/private/tapi/dev/sp/tsp1632/tsp1632s/tsp1632s.rc
new file mode 100644
index 000000000..000e2cef3
--- /dev/null
+++ b/private/tapi/dev/sp/tsp1632/tsp1632s/tsp1632s.rc
@@ -0,0 +1,24 @@
+//
+// (c) 1995 Microsoft Corporation.  All Rights Reserved.
+//
+/* Version Numbering stuff */
+
+
+#include <windows.h>
+
+// Is the following FLAG good to use for this?
+#ifdef NT_INST
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony 16bit SP support"
+#define VER_INTERNALNAME_STR        "16bit SP support"
+#define VER_ORIGINALFILENAME_STR    "tsp1632s.tsp"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/tsp3216/dirs b/private/tapi/dev/sp/tsp3216/dirs
new file mode 100644
index 000000000..8c36543e2
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/dirs
@@ -0,0 +1,25 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     tsp3216s \
+     tsp3216l
diff --git a/private/tapi/dev/sp/tsp3216/makefile b/private/tapi/dev/sp/tsp3216/makefile
new file mode 100644
index 000000000..ecfd2eb63
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/makefile
@@ -0,0 +1,25 @@
+!if "$(OS)" == "Windows_NT"
+
+!else
+
+##########################################################################
+#
+#       Microsoft Confidential
+#       Copyright (C) Microsoft Corporation 1995
+#       All Rights Reserved.
+#
+##########################################################################
+
+
+ROOT = ..\..\..\..\..
+DIR = tsp3216
+
+IS_OEM=1
+
+DIRLIST = script tsp3216l tsp3216s
+
+!include $(ROOT)\root.mk
+
+NTMAKEENV=.
+
+!endif
diff --git a/private/tapi/dev/sp/tsp3216/script/debug/makefile b/private/tapi/dev/sp/tsp3216/script/debug/makefile
new file mode 100644
index 000000000..13446470b
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/debug/makefile
@@ -0,0 +1,3 @@
+VERDIR=debug
+DEBUG=1
+!include ..\subthk.mk 
diff --git a/private/tapi/dev/sp/tsp3216/script/makefile b/private/tapi/dev/sp/tsp3216/script/makefile
new file mode 100644
index 000000000..335ff8e14
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/makefile
@@ -0,0 +1,14 @@
+#   THUNK Make file
+#
+#
+# Build Environment
+
+ROOT=..\..\..\..\..\..
+IS_OEM=1
+
+VERSIONLIST=debug retail
+DEFAULTVERDIR=debug
+DIR=thunk
+#.SILENT:
+!include $(ROOT)\root.mk
+
diff --git a/private/tapi/dev/sp/tsp3216/script/retail/makefile b/private/tapi/dev/sp/tsp3216/script/retail/makefile
new file mode 100644
index 000000000..b5725e6a2
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/retail/makefile
@@ -0,0 +1,3 @@
+VERDIR=retail
+RETAIL=1
+!include ..\subthk.mk 
diff --git a/private/tapi/dev/sp/tsp3216/script/subthk.mk b/private/tapi/dev/sp/tsp3216/script/subthk.mk
new file mode 100644
index 000000000..421da7105
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/subthk.mk
@@ -0,0 +1,52 @@
+#   THUNK Make file
+#
+#
+
+# Build Environment
+ROOT=..\..\..\..\..\..\..
+IS_OEM=1
+
+# international mode
+
+!ifdef  DBCS
+FDTHK      = FdThkDB
+!else
+FDTHK      = FdThk
+!endif
+
+THKASM   = TapiThk.asm Tapi32.asm TapiFThk.asm
+FTHKASM  = TapiFThk.asm
+
+
+TARGETS= $(THKASM)
+
+
+#DEPENDNAME=..\depend.mk
+
+#!include $(ROOT)\win\core\core.mk
+
+INCLUDE =
+
+#WIN32DEV=..\..\..\..\dev
+#WINCORE=..\..
+
+THUNKCOM   = $(ROOT)\dev\tools\binr\thunk.exe
+
+THUNK      = $(THUNKCOM) $(THUNKOPT)
+
+!IF "$(VERDIR)" == "maxdebug" || "$(VERDIR)" == "debug"
+THUNKOPT   =
+!ELSE
+THUNKOPT   =
+!ENDIF
+
+
+$(THKASM) :  $(THUNKCOM) ..\$(@B).thk
+    $(THUNK) -NC THUNK16B -o $(@B) ..\$(@B).thk
+
+
+TapiThk.asm TapiFThk.asm Tapi32.asm: ..\TapiThk.inc
+
+showenv:
+   set
+
diff --git a/private/tapi/dev/sp/tsp3216/script/tapi32.inc b/private/tapi/dev/sp/tsp3216/script/tapi32.inc
new file mode 100644
index 000000000..ceb07849a
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapi32.inc
@@ -0,0 +1,11 @@
+; Callback24 PROTO NEAR STDCALL :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD
+;Callback24 PROTO NEAR STDCALL :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD
+
+include thkrp.inc
+include cbcheck.inc
+include thkframe.inc
+include public.inc
+include thkmacro.inc
+
+externDef Callback24:far16
+
diff --git a/private/tapi/dev/sp/tsp3216/script/tapi32.thk b/private/tapi/dev/sp/tsp3216/script/tapi32.thk
new file mode 100644
index 000000000..14315255e
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapi32.thk
@@ -0,0 +1,76 @@
+/*
+ * Lzexpand APIs thunks for Win32s
+ */
+//__foldwin32sstuff __foldwin32sstuff;
+//foldstyleinitialization = true;
+
+
+enablemapdirect1632 = true;
+//flatthunks = false;
+
+#include "..\types.thk"
+
+typedef HANDLE	HINSTANCE;
+typedef DWORD	HTAPI;
+typedef HTAPI	*LPHTAPI;
+typedef HTAPI	HAPP;
+typedef HAPP	HLINEAPP;
+typedef HAPP	HPHONEAPP;
+typedef HAPP 	*LPHAPP;	
+typedef HTAPI	HCALL;
+typedef HCALL	*LPHCALL;	
+typedef HTAPI	HLINE;
+typedef HLINE	*LPHLINE;	
+typedef HTAPI	HPHONE;
+typedef HPHONE	*LPHPHONE;	
+typedef HICON	*LPHICON;
+typedef void	LINECALLBACK;
+typedef void	PHONECALLBACK;
+typedef LPSTR	LPCSTR;
+
+typedef HLINEAPP *LPHLINEAPP;
+typedef HPHONEAPP *LPHPHONEAPP;
+typedef LPVOID	LPLINEEXTENSIONID;
+
+typedef WORD	WPARAM;
+
+typedef LPVOID	LPLINETRANSLATEOUTPUT;		/* LP to data structure */
+typedef LPVOID	LPLINETRANSLATECAPS;		/* LP to data structure */
+typedef LPVOID	LPLINEFORWARDLIST;
+typedef LPVOID	LPLINECALLPARAMS;
+typedef LPVOID	LPLINEGENERATETONE;
+typedef LPVOID	LPLINEADDRESSCAPS;
+typedef LPVOID	LPLINEADDRESSSTATUS;
+typedef LPVOID	LPLINECALLINFO;
+typedef LPVOID	LPLINECALLSTATUS;
+typedef LPVOID	LPLINECALLLIST;
+typedef LPVOID	LPLINEDEVCAPS;
+typedef LPVOID	LPLINEDEVSTATUS;
+typedef LPVOID	LPLINEMONITORTONE;
+typedef LPVOID	LPVARSTRING;
+typedef LPVOID	LPLINEDIALPARAMS;
+typedef LPVOID	LPLINEMEDIACONTROLDIGIT;
+typedef LPVOID	LPLINEMEDIACONTROLMEDIA;
+typedef LPVOID	LPLINEMEDIACONTROLTONE;
+typedef LPVOID	LPLINEMEDIACONTROLCALLSTATE;
+typedef	LPVOID	LPPHONEBUTTONINFO;
+typedef	LPVOID	LPPHONECAPS;
+typedef	LPVOID	LPPHONESTATUS;
+typedef	LPVOID	LPPHONEEXTENSIONID;
+typedef	LPVOID	LPLINECOUNTRYLIST;
+typedef LPVOID	LPLINEPROVIDERLIST;
+
+
+// Thunk for callback
+BOOL _TapiCallbackThunk( HLINEAPP hDevice,
+                        DWORD dwMessage,
+                        DWORD dwInstance,
+                        DWORD dwParam1,
+                        DWORD dwParam2,
+                        DWORD dwParam3,
+                        DWORD cbProc32)
+{
+   target = Callback28;
+}
+
+
diff --git a/private/tapi/dev/sp/tsp3216/script/tapicbid.inc b/private/tapi/dev/sp/tsp3216/script/tapicbid.inc
new file mode 100644
index 000000000..f78b6eb64
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapicbid.inc
@@ -0,0 +1,17 @@
+; Callback-type id's for TAPI callbacks. All callback-type id's are
+; 32-bits long and the upper 16-bits must be set to the module's
+; Callback Client id.
+;
+; WARNING -- WARNING -- WARNING
+;
+;   Win32c.dll uses the lower 16 bits of CBID's to index directly into
+;   the tables stored in GDI.EXE (gdicb16.asm) and GDI32.DLL (gdicb32.asm).
+;   Those tables *must* match these id's or callbacks will fail miserably.
+;   Do everyone a big favor and add new id's only at the end, and never
+;   change an existing id.
+;   
+
+; *** 9/29/95 bjm ID_LINEINITIALIZE		equ	0
+; *** 9/29/95 bjm ID_PHONEINITIALIZE		equ	1
+; *** 9/29/95 bjm ID_LINESHUTDOWN			equ	2
+; *** 9/29/95 bjm ID_PHONESHUTDOWN		equ	3
diff --git a/private/tapi/dev/sp/tsp3216/script/tapifthk.inc b/private/tapi/dev/sp/tsp3216/script/tapifthk.inc
new file mode 100644
index 000000000..e2099aa99
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapifthk.inc
@@ -0,0 +1 @@
+; empty file !
diff --git a/private/tapi/dev/sp/tsp3216/script/tapifthk.thk b/private/tapi/dev/sp/tsp3216/script/tapifthk.thk
new file mode 100644
index 000000000..4630115e1
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapifthk.thk
@@ -0,0 +1,563 @@
+/*
+ * Lzexpand APIs thunks for Win32s
+ */
+//__foldwin32sstuff __foldwin32sstuff;
+//foldstyleinitialization = true;
+
+enablemapdirect3216 = true;
+//flatthunks = true;
+//flatthunks = false;
+
+#include "..\types.thk"
+
+typedef DWORD	HTAPI;
+typedef HTAPI	*LPHTAPI;
+typedef HTAPI	HAPP;
+typedef HAPP 	*LPHAPP;	
+typedef HTAPI	HLINEAPP;
+typedef HTAPI	HPHONEAPP;
+typedef HTAPI	HCALL;
+typedef HCALL	*LPHCALL;	
+typedef HTAPI	HLINE;
+typedef HLINE	*LPHLINE;	
+typedef HTAPI	HPHONE;
+typedef HPHONE	*LPHPHONE;	
+typedef HICON	*LPHICON;
+typedef LPSTR	LPCSTR;
+/* LPVOID in types.thk */
+typedef LPVOID	LPLINETRANSLATEOUTPUT;		/* LP to data structure */
+typedef LPVOID	LPLINETRANSLATECAPS;		/* LP to data structure */
+typedef LPVOID	LPLINEFORWARDLIST;
+typedef LPVOID	LPLINECALLPARAMS;
+typedef LPVOID	LPLINEGENERATETONE;
+typedef LPVOID	LPLINEADDRESSCAPS;
+typedef LPVOID	LPLINEADDRESSSTATUS;
+typedef LPVOID	LPLINECALLINFO;
+typedef LPVOID	LPLINECALLSTATUS;
+typedef LPVOID	LPLINECALLLIST;
+typedef LPVOID	LPLINEDEVCAPS;
+typedef LPVOID	LPLINEDEVSTATUS;
+typedef LPVOID	LPLINEMONITORTONE;
+typedef LPVOID	LPLINEEXTENSIONID;
+typedef LPVOID	LPVARSTRING;
+typedef LPVOID	LPLINEDIALPARAMS;
+typedef LPVOID	LPLINEMEDIACONTROLDIGIT;
+typedef LPVOID	LPLINEMEDIACONTROLMEDIA;
+typedef LPVOID	LPLINEMEDIACONTROLTONE;
+typedef LPVOID	LPLINEMEDIACONTROLCALLSTATE;
+typedef	LPVOID	LPPHONEBUTTONINFO;
+typedef	LPVOID	LPPHONECAPS;
+typedef	LPVOID	LPPHONESTATUS;
+typedef	LPVOID	LPPHONEEXTENSIONID;
+typedef	LPVOID	LPLINECOUNTRYLIST;
+typedef LPVOID	LPLINEPROVIDERLIST;
+
+
+//
+//
+typedef DWORD     DRV_REQUESTID;
+typedef DWORD     HDRVLINE;
+typedef DWORD     HDRVPHONE;
+typedef DWORD     HTAPICALL;
+typedef DWORD     HTAPILINE;
+typedef DWORD     HDRVCALL;
+typedef HDRVCALL  * LPHDRVCALL;
+typedef HDRVLINE  * LPHDRVLINE;
+typedef HDRVPHONE * LPHDRVPHONE;
+
+typedef DWORD  HTAPIPHONE;
+
+typedef DWORD	LINEEVENT;
+typedef DWORD	PHONEEVENT;
+
+//typedef LPVOID ASYNC_COMPLETION;
+typedef DWORD ASYNC_COMPLETION;
+
+typedef DWORD  HPROVIDER;
+typedef LPVOID	TUISPIDLLCALLBACK;
+//
+//
+
+
+
+
+//UINT GetTapiHInst(void) =
+//UINT GetTapiHInst(void)
+//{}
+
+
+UINT NewData(void) =
+UINT NewData(void)
+{}
+
+UINT NewData2(void) =
+UINT NewData2(void)
+{}
+
+
+
+
+
+
+
+LONG TSPI_lineDropNoOwner( HDRVCALL            hdCall) =
+LONG TSPI_lineDropNoOwner( HDRVCALL            hdCall)
+{
+}
+
+LONG TSPI_lineDropOnClose( HDRVCALL            hdCall) =
+LONG TSPI_lineDropOnClose( HDRVCALL            hdCall)
+{
+}
+
+LONG TSPI_lineGetCallAddressID( HDRVCALL            hdCall,    LPDWORD             lpdwAddressID) =
+LONG TSPI_lineGetCallAddressID( HDRVCALL            hdCall,    LPDWORD             lpdwAddressID)
+{
+}
+
+LONG TSPI_lineGetExtensionID( DWORD               dwDeviceID,    DWORD               dwTSPIVersion,    LPLINEEXTENSIONID   lpExtensionID) =
+LONG TSPI_lineGetExtensionID( DWORD               dwDeviceID,    DWORD               dwTSPIVersion,    LPLINEEXTENSIONID   lpExtensionID)
+{
+}
+
+LONG TSPI_lineGetNumAddressIDs( HDRVLINE            hdLine,    LPDWORD             lpdwNumAddressIDs) =
+LONG TSPI_lineGetNumAddressIDs( HDRVLINE            hdLine,    LPDWORD             lpdwNumAddressIDs)
+{
+}
+
+LONG TSPI_lineSelectExtVersion( HDRVLINE            hdLine,    DWORD               dwExtVersion) =
+LONG TSPI_lineSelectExtVersion( HDRVLINE            hdLine,    DWORD               dwExtVersion)
+{
+}
+
+LONG TSPI_lineConditionalMediaDetection( HDRVLINE            hdLine,    DWORD               dwMediaModes,    LPLINECALLPARAMS    lpCallParams) =
+LONG TSPI_lineConditionalMediaDetection( HDRVLINE            hdLine,    DWORD               dwMediaModes,    LPLINECALLPARAMS    lpCallParams)
+{
+}
+
+LONG TSPI_lineSetDefaultMediaDetection( HDRVLINE            hdLine,    DWORD               dwMediaModes) =
+LONG TSPI_lineSetDefaultMediaDetection( HDRVLINE            hdLine,    DWORD               dwMediaModes)
+{
+}
+
+LONG TSPI_phoneGetExtensionID( DWORD               dwDeviceID,    DWORD               dwTSPIVersion,    LPPHONEEXTENSIONID  lpExtensionID) =
+LONG TSPI_phoneGetExtensionID( DWORD               dwDeviceID,    DWORD               dwTSPIVersion,    LPPHONEEXTENSIONID  lpExtensionID)
+{
+}
+
+LONG TSPI_phoneSelectExtVersion( HDRVPHONE           hdPhone,    DWORD               dwExtVersion) =
+LONG TSPI_phoneSelectExtVersion( HDRVPHONE           hdPhone,    DWORD               dwExtVersion)
+{
+}
+
+LONG TSPI_providerConfig( HWND hwndOwner, DWORD dwPermanentProviderID) =
+LONG TSPI_providerConfig( HWND hwndOwner, DWORD dwPermanentProviderID)
+{
+}
+
+LONG TSPI_providerCreateLineDevice( DWORD               dwTempID,    DWORD               dwDeviceID) =
+LONG TSPI_providerCreateLineDevice( DWORD               dwTempID,    DWORD               dwDeviceID)
+{
+}
+
+LONG TSPI_providerCreatePhoneDevice( DWORD               dwTempID,    DWORD               dwDeviceID) =
+LONG TSPI_providerCreatePhoneDevice( DWORD               dwTempID,    DWORD               dwDeviceID)
+{
+}
+
+LONG TSPI_providerEnumDevices16( DWORD               dwPermanentProviderID,    LPDWORD             lpdwNumLines,    LPDWORD             lpdwNumPhones,    HPROVIDER           hProvider,    LINEEVENT           lpfnLineCreateProc,    PHONEEVENT          lpfnPhoneCreateProc, HWND hWnd) =
+LONG TSPI_providerEnumDevices16( DWORD               dwPermanentProviderID,    LPDWORD             lpdwNumLines,    LPDWORD             lpdwNumPhones,    HPROVIDER           hProvider,    LINEEVENT           lpfnLineCreateProc,    PHONEEVENT          lpfnPhoneCreateProc, HWND hWnd)
+{
+}
+
+LONG TSPI_providerInit16( DWORD dwTSPIVersion, DWORD dwPermanentProviderID,
+                          DWORD dwLineDeviceIDBase, DWORD dwPhoneDeviceIDBase,
+                          DWORD dwNumLines, DWORD dwNumPhones,
+                          ASYNC_COMPLETION    lpfnCompletionProc) =
+LONG TSPI_providerInit16( DWORD dwTSPIVersion, DWORD dwPermanentProviderID,
+                          DWORD dwLineDeviceIDBase, DWORD dwPhoneDeviceIDBase,
+                          DWORD dwNumLines, DWORD dwNumPhones,
+                          ASYNC_COMPLETION    lpfnCompletionProc)
+{
+}
+
+LONG TSPI_providerInstall( TUISPIDLLCALLBACK   lpfnUIDLLCallback,    HWND                hwndOwner,    DWORD               dwPermanentProviderID) =
+LONG TSPI_providerInstall( TUISPIDLLCALLBACK   lpfnUIDLLCallback,    HWND                hwndOwner,    DWORD               dwPermanentProviderID)
+{
+}
+
+LONG TSPI_providerRemove( TUISPIDLLCALLBACK   lpfnUIDLLCallback,    HWND                hwndOwner,    DWORD               dwPermanentProviderID) =
+LONG TSPI_providerRemove( TUISPIDLLCALLBACK   lpfnUIDLLCallback,    HWND                hwndOwner,    DWORD               dwPermanentProviderID)
+{
+}
+
+LONG TSPI_providerShutdown16( DWORD               dwTSPIVersion) =
+LONG TSPI_providerShutdown16( DWORD               dwTSPIVersion)
+{
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Tapi Address Translation procedures */
+
+LONG TSPI_lineSetCurrentLocation (DWORD dwLocation) =
+LONG TSPI_lineSetCurrentLocation (DWORD dwLocation)
+{}
+
+
+//LONG lineSetTollList (HLINEAPP hLineApp, DWORD dwPermanentLineID, LPCSTR lpszAddressIn, DWORD dwTollListOption) =
+//LONG lineSetTollList (HLINEAPP hLineApp, DWORD dwPermanentLineID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
+//{}
+
+//LONG lineTranslateAddress (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, 
+//                DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput) =
+//LONG lineTranslateAddress (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, 
+//                DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
+//{}
+
+//LONG lineGetTranslateCaps (HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps) =
+//LONG lineGetTranslateCaps (HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
+//{}
+
+
+/* Tapi function prototypes */
+
+LONG  TSPI_lineAccept (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineAccept (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HDRVCALL hdConsultCall) =
+LONG  TSPI_lineAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HDRVCALL hdConsultCall)
+{}
+
+LONG  TSPI_lineAnswer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineAnswer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineBlindTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode) =
+LONG  TSPI_lineBlindTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{}
+
+LONG  TSPI_lineClose (HDRVLINE hdLine) =
+LONG  TSPI_lineClose (HDRVLINE hdLine)
+{}
+
+LONG  TSPI_lineCloseCall(HDRVCALL hdCall) =
+LONG  TSPI_lineCloseCall(HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID  lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut) =
+LONG  TSPI_lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID  lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
+{}
+
+//LONG lineDeallocateCall (HDRVCALL hdCall) =
+//LONG lineDeallocateCall (HDRVCALL hdCall)
+//{}
+
+LONG  TSPI_lineDial (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode) =
+LONG  TSPI_lineDial (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{}
+
+LONG  TSPI_lineDrop (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineDrop (DWORD dwDeviceID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG TSPI_lineGenerateDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitMode, LPCSTR lpszDigits, DWORD dwDuration) =
+LONG TSPI_lineGenerateDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitMode, LPCSTR lpszDigits, DWORD dwDuration)
+{}
+
+LONG  TSPI_lineGenerateTone (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwToneMode, DWORD dwDuration,
+                                 DWORD dwNumTones, LPLINEGENERATETONE lpTones) =
+LONG  TSPI_lineGenerateTone (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwToneMode, DWORD dwDuration,
+                                 DWORD dwNumTones, LPLINEGENERATETONE lpTones)
+{}
+
+LONG  TSPI_lineGetAddressCaps (DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, 
+		DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps) =
+LONG  TSPI_lineGetAddressCaps (DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, 
+		DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
+{}
+
+LONG  TSPI_lineGetAddressID (HDRVLINE hdLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize) =
+LONG  TSPI_lineGetAddressID (HDRVLINE hdLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
+{}
+
+LONG  TSPI_lineGetAddressStatus (HDRVLINE hdLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus) =
+LONG  TSPI_lineGetAddressStatus (HDRVLINE hdLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
+{}
+
+LONG  TSPI_lineGetCallInfo (HDRVCALL hdCall, LPLINECALLINFO lpCallInfo) =
+LONG  TSPI_lineGetCallInfo (HDRVCALL hdCall, LPLINECALLINFO lpCallInfo)
+{}
+
+LONG  TSPI_lineGetCallStatus (HDRVCALL hdCall, LPLINECALLSTATUS lpCallStatus) =
+LONG  TSPI_lineGetCallStatus (HDRVCALL hdCall, LPLINECALLSTATUS lpCallStatus)
+{}
+
+//LONG lineGetConfRelatedCalls (HDRVCALL hdCall, LPLINECALLLIST lpCallList) =
+//LONG lineGetConfRelatedCalls (HDRVCALL hdCall, LPLINECALLLIST lpCallList)
+//{} 
+ 
+LONG  TSPI_lineGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps) =
+LONG  TSPI_lineGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
+{}
+
+LONG  TSPI_lineGetDevConfig (DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineGetDevConfig (DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
+{}
+
+//LONG lineGetNewCalls (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList) =
+//LONG lineGetNewCalls (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
+//{}
+
+LONG  TSPI_lineGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon) =
+LONG  TSPI_lineGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon)
+{} 
+ 
+LONG  TSPI_lineGetID16(HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineGetID16(HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_lineGetLineDevStatus (HDRVLINE hdLine, LPLINEDEVSTATUS lpLineDevStatus) =
+LONG  TSPI_lineGetLineDevStatus (HDRVLINE hdLine, LPLINEDEVSTATUS lpLineDevStatus)
+{}
+
+LONG  TSPI_lineHold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineHold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineReleaseUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineReleaseUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineMonitorDigits (HDRVCALL hdCall, DWORD dwDigitModes) =
+LONG  TSPI_lineMonitorDigits (HDRVCALL hdCall, DWORD dwDigitModes)
+{}
+
+LONG  TSPI_lineMonitorMedia (HDRVCALL hdCall, DWORD dwMediaModes) =
+LONG  TSPI_lineMonitorMedia (HDRVCALL hdCall, DWORD dwMediaModes)
+{}
+
+LONG  TSPI_lineMonitorTones (HDRVCALL hdCall, DWORD dwToneListID, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries) =
+LONG  TSPI_lineMonitorTones (HDRVCALL hdCall, DWORD dwToneListID, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
+{}
+
+LONG  TSPI_lineNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion) =
+LONG  TSPI_lineNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTsPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion)
+{}
+
+LONG  TSPI_lineNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwLowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion) =
+LONG  TSPI_lineNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwLowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion)
+{}
+
+LONG  TSPI_lineOpen (DWORD dwDeviceID, HTAPILINE htLine, LPHDRVLINE lphdLine, DWORD dwTSPIVersion,
+                LINEEVENT lpfnEventProc) =
+LONG  TSPI_lineOpen (DWORD dwDeviceID, HTAPILINE htLine, LPHDRVLINE lphdLine, DWORD dwTSPIVersion,
+                LINEEVENT lpfnEventProc)
+{}
+
+LONG  TSPI_lineRedirect (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode) =
+LONG  TSPI_lineRedirect (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{}
+
+LONG  TSPI_lineRemoveFromConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineRemoveFromConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineSecureCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineSecureCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_lineSendUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize) =
+LONG  TSPI_lineSendUserUserInfo (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{}
+
+LONG  TSPI_lineSetAppSpecific (HDRVCALL hdCall, DWORD dwAppSpecific) =
+LONG  TSPI_lineSetAppSpecific (HDRVCALL hdCall, DWORD dwAppSpecific)
+{}
+
+LONG  TSPI_lineSetCallParams (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS  lpDialParams) =
+LONG  TSPI_lineSetCallParams (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS  lpDialParams)
+{}
+
+//LONG lineSetCallPrivilege (HDRVCALL hdCall, DWORD dwCallPrivilege) =
+//LONG lineSetCallPrivilege (HDRVCALL hdCall, DWORD dwCallPrivilege)
+//{}
+
+LONG  TSPI_lineSetDevConfig (DWORD dwDeviceID, LPVOID  lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass) =
+LONG  TSPI_lineSetDevConfig (DWORD dwDeviceID, LPVOID  lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_lineSetMediaControl (HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPLINEMEDIACONTROLDIGIT  lpDigitList, DWORD dwDigitNumEntries, 
+        LPLINEMEDIACONTROLMEDIA  lpMediaList, DWORD dwMediaNumEntries, LPLINEMEDIACONTROLTONE  lpToneList, DWORD dwToneNumEntries, LPLINEMEDIACONTROLCALLSTATE  lpCallStateList, DWORD dwCallStateNumEntries) =
+LONG  TSPI_lineSetMediaControl (HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, LPLINEMEDIACONTROLDIGIT  lpDigitList, DWORD dwDigitNumEntries, 
+        LPLINEMEDIACONTROLMEDIA  lpMediaList, DWORD dwMediaNumEntries, LPLINEMEDIACONTROLTONE  lpToneList, DWORD dwToneNumEntries, LPLINEMEDIACONTROLCALLSTATE  lpCallStateList, DWORD dwCallStateNumEntries)
+{}
+
+LONG  TSPI_lineSetMediaMode (HDRVCALL hdCall, DWORD dwMediaModes) =
+LONG  TSPI_lineSetMediaMode (HDRVCALL hdCall, DWORD dwMediaModes)
+{}
+
+//LONG lineSetNumRings (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwNumRings) =
+//LONG lineSetNumRings (HDRVLINE hdLine, DWORD dwAddressID, DWORD dwNumRings)
+//{}
+
+LONG  TSPI_lineSetStatusMessages (HDRVLINE hdLine, DWORD dwLineStates, DWORD dwAddressStates) =
+LONG  TSPI_lineSetStatusMessages (HDRVLINE hdLine, DWORD dwLineStates, DWORD dwAddressStates)
+{}
+
+LONG  TSPI_lineSetTerminal (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, 
+		DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable) =
+LONG  TSPI_lineSetTerminal (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, DWORD dwSelect, 
+		DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
+{}
+
+LONG  TSPI_lineSwapHold (DRV_REQUESTID dwRequestID, HDRVCALL hdActiveCall, HDRVCALL hdHeldCall) =
+LONG  TSPI_lineSwapHold (DRV_REQUESTID dwRequestID, HDRVCALL hdActiveCall, HDRVCALL hdHeldCall)
+{}
+
+LONG  TSPI_lineUncompleteCall (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwCompletionID) =
+LONG  TSPI_lineUncompleteCall (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwCompletionID)
+{}
+
+LONG  TSPI_lineUnhold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall) =
+LONG  TSPI_lineUnhold (DRV_REQUESTID dwRequestID, HDRVCALL hdCall)
+{}
+
+LONG  TSPI_phoneClose (HDRVPHONE hdPhone) =
+LONG  TSPI_phoneClose (HDRVPHONE hdPhone)
+{}
+
+LONG  TSPI_phoneConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass) =
+LONG  TSPI_phoneConfigDialog (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_phoneGetButtonInfo (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo) =
+LONG  TSPI_phoneGetButtonInfo (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo)
+{}
+
+LONG  TSPI_phoneGetData (HDRVPHONE hdPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize) =
+LONG  TSPI_phoneGetData (HDRVPHONE hdPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
+{}
+
+LONG  TSPI_phoneGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps) =
+LONG  TSPI_phoneGetDevCaps (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps)
+{}
+
+LONG  TSPI_phoneGetDisplay (HDRVPHONE hdPhone, LPVARSTRING lpDisplay) =
+LONG  TSPI_phoneGetDisplay (HDRVPHONE hdPhone, LPVARSTRING lpDisplay)
+{}
+
+LONG  TSPI_phoneGetGain (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain) =
+LONG  TSPI_phoneGetGain (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain)
+{}
+
+LONG  TSPI_phoneGetHookSwitch (HDRVPHONE hdPhone, LPDWORD lpdwHookSwitchDevs) =
+LONG  TSPI_phoneGetHookSwitch (HDRVPHONE hdPhone, LPDWORD lpdwHookSwitchDevs)
+{}
+
+LONG  TSPI_phoneGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon) =
+LONG  TSPI_phoneGetIcon (DWORD dwDeviceID, LPCSTR lpszDeviceClass, LPHICON lphIcon)
+{}
+
+LONG  TSPI_phoneGetID16(HDRVPHONE hdPhone, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass) =
+LONG  TSPI_phoneGetID16(HDRVPHONE hdPhone, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+{}
+
+LONG  TSPI_phoneGetLamp (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPDWORD lpdwLampMode) =
+LONG  TSPI_phoneGetLamp (HDRVPHONE hdPhone, DWORD dwButtonLampID, LPDWORD lpdwLampMode)
+{}
+
+LONG  TSPI_phoneGetRing (HDRVPHONE hdPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume) =
+LONG  TSPI_phoneGetRing (HDRVPHONE hdPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume)
+{}
+
+LONG  TSPI_phoneGetStatus (HDRVPHONE hdPhone, LPPHONESTATUS lpPhoneStatus) =
+LONG  TSPI_phoneGetStatus (HDRVPHONE hdPhone, LPPHONESTATUS lpPhoneStatus)
+{}
+
+//LONG phoneGetStatusMessages (HDRVPHONE hdPhone, LPDWORD lpdwPhoneStates, LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates) =
+//LONG phoneGetStatusMessages (HDRVPHONE hdPhone, LPDWORD lpdwPhoneStates, LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates)
+//{}
+
+LONG  TSPI_phoneGetVolume (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwVolume) =
+LONG  TSPI_phoneGetVolume (HDRVPHONE hdPhone, DWORD dwHookSwitchDev, LPDWORD lpdwVolume)
+{}
+
+LONG  TSPI_phoneNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion) =
+LONG  TSPI_phoneNegotiateExtVersion (DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwLowVersion, 
+                DWORD dwHighVersion, LPDWORD lpdwExtVersion)
+{}
+
+LONG  TSPI_phoneNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwTSPILowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion) =
+LONG  TSPI_phoneNegotiateTSPIVersion (DWORD dwDeviceID, DWORD dwTSPILowVersion, DWORD dwHighVersion,
+                LPDWORD lpdwTSPIVersion)
+{}
+
+LONG  TSPI_phoneOpen (DWORD dwDeviceID, HTAPIPHONE htPhone, LPHDRVPHONE lphdPhone,
+                DWORD dwTSPIVersion, PHONEEVENT lpfnEventProc) =
+LONG  TSPI_phoneOpen (DWORD dwDeviceID, HTAPIPHONE htPhone, LPHDRVPHONE lphdPhone,
+                DWORD dwTSPIVersion, PHONEEVENT lpfnEventProc)
+{}
+
+LONG  TSPI_phoneSetButtonInfo (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO  lpButtonInfo) =
+LONG  TSPI_phoneSetButtonInfo (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO  lpButtonInfo)
+{}
+
+LONG  TSPI_phoneSetData (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwDataID, LPVOID  lpData, DWORD dwSize) =
+LONG  TSPI_phoneSetData (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwDataID, LPVOID  lpData, DWORD dwSize)
+{}
+
+LONG  TSPI_phoneSetDisplay (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpsDisplay, DWORD dwSize) =
+LONG  TSPI_phoneSetDisplay (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpsDisplay, DWORD dwSize)
+{}
+
+LONG  TSPI_phoneSetGain (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwGain) =
+LONG  TSPI_phoneSetGain (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwGain)
+{}
+
+LONG  TSPI_phoneSetHookSwitch (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode) =
+LONG  TSPI_phoneSetHookSwitch (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode)
+{}
+
+LONG  TSPI_phoneSetLamp (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, DWORD dwLampMode) =
+LONG  TSPI_phoneSetLamp (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwButtonLampID, DWORD dwLampMode)
+{}
+
+LONG  TSPI_phoneSetRing (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRingMode, DWORD dwVolume) =
+LONG  TSPI_phoneSetRing (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwRingMode, DWORD dwVolume)
+{}
+
+LONG  TSPI_phoneSetStatusMessages (HDRVPHONE hdPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates) =
+LONG  TSPI_phoneSetStatusMessages (HDRVPHONE hdPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates)
+{}
+
+LONG  TSPI_phoneSetVolume (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwVolume) =
+LONG  TSPI_phoneSetVolume (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, DWORD dwHookSwitchDev, DWORD dwVolume)
+{}
+
diff --git a/private/tapi/dev/sp/tsp3216/script/tapithk.inc b/private/tapi/dev/sp/tsp3216/script/tapithk.inc
new file mode 100644
index 000000000..63ad5baca
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapithk.inc
@@ -0,0 +1,1234 @@
+
+CodeData equ <THUNK16BCodeData>
+
+include thkrp.inc
+include cbcheck.inc
+include thkframe.inc
+include public.inc
+include thkmacro.inc
+;include struc.inc
+
+include cbcid.inc
+include tapicbid.inc
+
+;externDef IsBadCodePtr:far16
+externDef CALLBACK_BODY_16:far16
+externDef Escape:far16
+externDef AllocCallback:far16
+externDef MapLS:far16
+externDef UnmapLS:far16
+ifdef DEBUG
+externDef _wsprintf:far16
+externDef OutputDebugString:far16
+endif
+
+externDef FreeCallback:far16
+
+
+externDef lineInitialize:far16
+externDef phoneInitialize:far16
+externDef lineShutdown:far16
+externDef phoneShutdown:far16
+
+
+public addrCBLineInit	;Address of callback routine passed in lineInitialize
+public addrCBPhoneInit	;Address of callback routine passed in phoneInitialize
+public cbcidTapi	;Callback ID for client returned by RegisterCBClient
+_DATA	  SEGMENT
+addrCBLineInit		dd 0
+addrCBPhoneInit		dd 0
+cbcidTapi		dd 0
+_DATA ENDS
+
+ifdef DEBUG
+;; Writes message to debug port.
+;;
+;; Usage:
+;;	DPRINT "I'm feeling buggy."
+;;
+DPRINT	macro	string
+	local	mes, skip_mes
+
+	jmp	skip_mes
+mes	db	&string&,13,10,0
+skip_mes:
+	push	eax	;Save all registers not preserved by PASCAL format.
+	push	ebx
+	push	ecx
+	push	edx
+	
+	push	cs	;Arg: OutputDebugString(lpstr)
+	push	offset mes
+	call	OutputDebugString
+
+	pop	edx
+	pop	ecx
+	pop	ebx
+	pop	eax
+endm  ;DPRINT
+endif
+
+
+;-----------------------------------------------------------------------;
+; body_LINEINITIALIZE16
+;-----------------------------------------------------------------------;
+body_LINEINITIALIZE16 macro
+
+;LONG lineInitialize16 (LPHLINEAPP lphLineApp,
+;                     HINSTANCE hInstance,
+;                     LINECALLBACK lpfnCallback,
+;                     LPCSTR lpszAppName,
+;                     LPDWORD lpdwNumDevs)
+;
+bp_lphLineApp  		equ     <bp_top>
+bp_hInstance    	equ	<bp_top+4>
+bp_lpfnCallback		equ	<bp_top+8>
+bp_lpszAppName  	equ	<bp_top+12>
+bp_lpdwNumDevs  	equ	<bp_top+16>
+;
+
+bp_lpszAppNameTmp	equ	<dword ptr [bp-4]>
+bp_lpdwNumDevsTmp	equ	<dword ptr [bp-8]>
+bp_lphLineAppTmp	equ	<dword ptr [bp-12]>
+
+        ;
+        ; First order of business: check the code pointer.  If it's
+        ; bogus, we leave.
+        ;
+
+;        push    dword ptr bp_lpfnCallback
+;        call    IsBadCodePtr
+;        or      eax, eax
+;        jnz     DoNothing
+
+	sub	eax, eax
+	push	eax				;bp_lpszAppNameTmp
+	push	eax				;bp_lpdwNumDevsTmp
+	push	eax				;bp_lphLineAppTmp
+
+	push	dword ptr bp_lphLineApp
+	call	MapLS
+	mov	bp_lphLineAppTmp, eax
+	push	eax
+
+        mov     eax, dword ptr bp_hInstance     ; Get the hInst
+        or	eax, eax                        ; Is it NULL?
+        jz	@f                              ; Yup, and that's ok.
+	MAP_NULL_HINST eax                      ; Needs to be mapped.
+        push    ax
+
+;	mov	ax, seg addrCBLineInit
+;	mov	ds, ax
+;	mov	eax, dword ptr bp_lpfnCallback
+;	mov	addrCBLineInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_LINEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+
+	push	dword ptr bp_lpfnCallback
+
+	push	dword ptr bp_lpszAppName
+	call	MapLS
+	mov	bp_lpszAppNameTmp, eax
+	push	eax
+
+	push	dword ptr bp_lpdwNumDevs
+	call	MapLS
+	mov	bp_lpdwNumDevsTmp, eax
+	push	eax
+
+
+	call	lineInitialize
+
+
+	shl	eax,16                          ; Convert the 16bit retcode...
+	shrd	eax,edx,16                      ; to a 32bit retcode.
+
+	push	eax                             ; Save the retcode for later.
+
+	push	dword ptr bp_lpdwNumDevsTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lpszAppNameTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lphLineAppTmp
+	call	UnMapLS
+
+	pop	eax                             ; Get the retcode
+
+;DoNothing:
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_PHONEINITIALIZE
+;-----------------------------------------------------------------------;
+body_PHONEINITIALIZE16 macro
+
+;LONG phoneInitialize (LPHPHONEAPP lphPhoneApp,
+;                      HINSTANCE hInstance,
+;                      PHONECALLBACK lpfnCallback,
+;                      LPCSTR lpszAppName,
+;                      LPDWORD lpdwNumDevs)
+;
+bp_lphPhoneApp  	equ     <bp_top>
+bp_hInstance    	equ	<bp_top+4>
+bp_lpfnCallback		equ	<bp_top+8>
+bp_lpszAppName  	equ	<bp_top+12>
+bp_lpdwNumDevs  	equ	<bp_top+16>
+;
+
+bp_lpszAppNameTmp	equ	<dword ptr [bp-4]>
+bp_lpdwNumDevsTmp	equ	<dword ptr [bp-8]>
+bp_lphPhoneAppTmp	equ	<dword ptr [bp-12]>
+
+	sub	eax, eax
+	push	eax				;bp_lpszAppNameTmp
+	push	eax				;bp_lpdwNumDevsTmp
+	push	eax				;bp_lphPhoneAppTmp
+
+	push	dword ptr bp_lphPhoneApp
+	call	MapLS
+	mov	bp_lphPhoneAppTmp, eax
+	push	eax
+
+        mov     eax, dword ptr bp_hInstance     ; Get the hInst
+        or	eax, eax                        ; Is it NULL?
+        jz	@f                              ; Yup, and that's ok.
+	MAP_NULL_HINST eax                      ; Needs to be mapped.
+        push    ax
+
+;	mov	ax, seg addrCBPhoneInit
+;	mov	ds, ax
+;	mov	eax, dword ptr bp_lpfnCallback
+;	mov	addrCBPhoneInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_PHONEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+	push    dword ptr bp_lpfnCallback
+
+	push	dword ptr bp_lpszAppName
+	call	MapLS
+	mov	bp_lpszAppNameTmp, eax
+	push	eax
+
+	push	dword ptr bp_lpdwNumDevs
+	call	MapLS
+	mov	bp_lpdwNumDevsTmp, eax
+	push	eax
+
+
+	call	phoneInitialize
+
+
+	shl	eax,16                          ; Convert the 16bit retcode...
+	shrd	eax,edx,16                      ; to a 32bit retcode.
+
+	push	eax                             ; Save the retcode for later.
+
+	push	dword ptr bp_lpdwNumDevsTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lpszAppNameTmp
+	call	UnMapLS
+
+	push	dword ptr bp_lphPhoneAppTmp
+	call	UnMapLS
+
+	pop	eax                             ; Get the retcode
+
+endm
+
+
+;-----------------------------------------------------------------------;
+;-----------------------------------------------------------------------;
+;PUSH__LINEINITIALIZE_hInstance	macro	iOffset, iJunk
+;   local   Null_OK
+;	
+;    mov	eax, [bp+iOffset]	;;Allow NULL to be passed here (for now)
+;    or	eax, eax
+;    jz	Null_OK
+;    MAP_NULL_HINST eax
+;Null_OK:
+;    push    ax
+;
+;endm ;PUSH__LINEINITIALIZE_hInstance
+;
+;
+;-----------------------------------------------------------------------;
+;-----------------------------------------------------------------------;
+;PUSH__PHONEINITIALIZE_hInstance	macro	iOffset, iJunk
+;   local   Null_OK
+;	
+;    mov	eax, [bp+iOffset]	;;Allow NULL to be passed here (for now)
+;    or	eax, eax
+;    jz	Null_OK
+;    MAP_NULL_HINST eax
+;Null_OK:
+;    push    ax
+;
+;endm ;PUSH__PHONEINITIALIZE_hInstance
+;
+;
+;;-----------------------------------------------------------------------;
+;; PUSH__LINEINITIALIZE_lpfnCallback (similar to PUSH_SetAbortProc_pfnAbort)
+;;-----------------------------------------------------------------------;
+;PUSH__LINEINITIALIZE_lpfnCallback    macro iOffset, iTempOffset
+;;	assume	ds:DATA16
+;
+;	mov	ax, seg addrCBLineInit
+;	mov	ds, ax
+;
+;	mov	eax, dword ptr [bp+iOffset]
+;	mov	addrCBLineInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_LINEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+;endm
+;
+;
+;-----------------------------------------------------------------------;
+; PUSH__PHONEINITIALIZE_lpfnCallback
+;-----------------------------------------------------------------------;
+;PUSH__PHONEINITIALIZE_lpfnCallback    macro iOffset, iTempOffset
+;	assume	ds:DATA16
+;	mov	ax, seg addrCBPhoneInit
+;	mov	ds, ax
+;
+;	mov	eax, dword ptr [bp+iOffset]
+;	mov	addrCBPhoneInit, eax
+;	push	eax
+;	mov	eax, cbcidTapi
+;	shl	eax, 16
+;	add	eax, ID_PHONEINITIALIZE
+;	push	eax
+;        call    AllocCallback
+;        push    dx
+;        push    ax
+;endm
+
+
+;==============================================================================
+; local macro, free resources allocated for a call-back function
+; check if it is a NULL pointer before calling FreeCallBack.
+; eax contains the 32-bit address of the mapped call-back function
+; ecx contains the callback ID ((cbcidTapi << 16) + ID[PHONE/LINE]INITIALIZE)
+;==============================================================================
+;FREE_CALLBACK_TAPI  macro
+;        local   done
+;
+;        or      eax,eax
+;        jz      done                            ;don't process NULL pointers
+;
+;        push    bx                              ;save BX
+;        push    es                              ;save ES
+;
+;        push    eax                             ;32-bit callback address
+;        push    ecx
+;        call    FreeCallback
+;
+;        pop     es                              ;restore ES
+;        pop     bx                              ;restore BX
+;done:
+;endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINESHUTDOWN
+; Use FREE_CALLBACK instead of directly calling FreeCallback so that we
+; check for NULL pointers.
+;-----------------------------------------------------------------------;
+body_LINESHUTDOWN16 macro
+bp_hLineApp     equ     <bp_top>
+;	assume	ds:DATA16
+	mov	ax, seg addrCBLineInit
+	mov	ds, ax
+
+	mov	eax, dword ptr bp_hLineApp
+	push	eax
+ifdef DEBUG
+	int	3
+endif
+	call	lineShutdown
+
+; return code long --> long
+	rol	eax,16
+	xchg	ax,dx
+	rol	eax,16
+
+;	push	eax	;; Save
+;	push	ecx	;; Save
+;
+;	mov	eax,  addrCBLineInit
+;
+;	mov	ecx, cbcidTapi
+;	shl	ecx, 16
+;	add	ecx, ID_LINEINITIALIZE
+;
+;	FREE_CALLBACK_TAPI
+;
+;	pop	ecx
+;	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_PHONESHUTDOWN
+;-----------------------------------------------------------------------;
+body_PHONESHUTDOWN16 macro
+bp_hLineApp     equ     <bp_top>
+;	assume	ds:DATA16
+	mov	ax, seg addrCBPhoneInit
+	mov	ds, ax
+
+	mov	eax, dword ptr bp_hLineApp
+	push	eax
+	call	phoneShutdown
+
+; return code long --> long
+	rol	eax,16
+	xchg	ax,dx
+	rol	eax,16
+
+;	push	eax	;; Save it
+;	push	ecx	;; Save it
+;
+;	mov	eax,  addrCBPhoneInit
+;
+;	mov	ecx, cbcidTapi
+;	shl	ecx, 16
+;	add	ecx, ID_PHONEINITIALIZE
+;
+;	FREE_CALLBACK_TAPI
+;
+;	pop	ecx
+;	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEFORWARD
+;-----------------------------------------------------------------------;
+body_LINEFORWARD macro
+
+bp_hLine     		equ     <bp_top>
+bp_bAllAddresses	equ	<bp_top+4>
+bp_dwAddressID		equ	<bp_top+8>
+bp_lpForwardList	equ	<bp_top+12>
+bp_dwNumRingsNoAnswer	equ	<bp_top+16>
+bp_lphConsultCall	equ	<bp_top+20>
+bp_lpCallParams		equ	<bp_top+24>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  bAllAddresses
+; dword ptr [ebp+16]:  dwAddressID
+; dword ptr [ebp+20]:  lpForwardList
+; dword ptr [ebp+24]:  dwNumRingsNoAnswer
+; dword ptr [ebp+28]:  lphConsultCall
+; dword ptr [ebp+32]:  lpCallParams
+;
+
+bp_lpForwardListTmp	equ	<dword ptr [bp-4]>
+bp_lphConsultCallTmp	equ	<dword ptr [bp-8]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-12]>
+
+
+	sub	eax, eax
+	push	eax				;bp_lpForwardListTmp
+	push	eax				;bp_lphConsultCallTmp
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_bAllAddresses	;bAllAddresses: dword->dword
+	push	dword ptr bp_dwAddressID	;dwAddressID: dword->dword
+	push	dword ptr bp_lpForwardList
+	call	MapLS
+	mov	bp_lpForwardListTmp, eax
+	push	eax
+	push	dword ptr bp_dwNumRingsNoAnswer	;dwNumRingsNoAnswer: dword->dword
+	push	dword ptr bp_lphConsultCall
+	call	MapLS
+	mov	bp_lphConsultCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	lineForward
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+	push	dword ptr bp_lpForwardListTmp
+	call	UnMapLS
+;
+; Don't UnMap lphConsultCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphConsultCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEMAKECALL
+;-----------------------------------------------------------------------;
+body_LINEMAKECALL macro
+
+bp_hLine     		equ     <bp_top>
+bp_lphCall		equ	<bp_top+4>
+bp_lpszDestAddress	equ	<bp_top+8>
+bp_dwCountryCode	equ	<bp_top+12>
+bp_lpCallParams		equ	<bp_top+16>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  lphCall
+; dword ptr [ebp+16]:  lpszDestAddress
+; dword ptr [ebp+20]:  dwCountryCode
+; dword ptr [ebp+24]:  lpCallParams
+;
+
+bp_lphCallTmp		equ	<dword ptr [bp-4]>
+bp_lpszDestAddressTmp	equ	<dword ptr [bp-8]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-12]>
+
+
+	sub	eax, eax
+	push	eax				;bp_lphCallTmp
+	push	eax				;bp_lpszDestAddress
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_lphCall
+	call	MapLS
+	mov	bp_lphCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpszDestAddress
+	call	MapLS
+	mov	bp_lpszDestAddressTmp, eax
+	push	eax
+	push	dword ptr bp_dwCountryCode	;dwCountryCode: dword->dword
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+	
+	call	lineMakeCall
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszDestAddressTmp
+	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEUNPARK
+;-----------------------------------------------------------------------;
+body_LINEUNPARK macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwAddressID		equ	<bp_top+4>
+bp_lphCall		equ	<bp_top+8>
+bp_lpszDestAddress	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwAddressID
+; dword ptr [ebp+16]:  lphCall
+; dword ptr [ebp+20]:  lpszDestAddress
+;
+
+bp_lphCallTmp		equ	<dword ptr [bp-4]>
+bp_lpszDestAddressTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lphCallTmp
+	push	eax				;bp_lpszDestAddress
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwCountryCode	;dwCountryCode: dword->dword
+	push	dword ptr bp_lphCall
+	call	MapLS
+	mov	bp_lphCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpszDestAddress
+	call	MapLS
+	mov	bp_lpszDestAddressTmp, eax
+	push	eax
+
+	call	lineUnpark
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszDestAddressTmp
+	call	UnMapLS
+	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEPICKUP
+;-----------------------------------------------------------------------;
+body_LINEPICKUP macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwAddressID		equ	<bp_top+4>
+bp_lphCall		equ	<bp_top+8>
+bp_lpszDestAddress	equ	<bp_top+12>
+bp_lpszGroupID		equ	<bp_top+16>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwAddressID
+; dword ptr [ebp+16]:  lphCall
+; dword ptr [ebp+20]:  lpszDestAddress
+; dword ptr [ebp+24]:  lpszGroupID
+;
+
+bp_lphCallTmp		equ	<dword ptr [bp-4]>
+bp_lpszDestAddressTmp	equ	<dword ptr [bp-8]>
+bp_lpszGroupIDTmp	equ	<dword ptr [bp-12]>
+
+	sub	eax, eax
+	push	eax				;bp_lphCallTmp
+	push	eax				;bp_lpszDestAddressTmp
+	push	eax				;bp_lpszGroupIDTmp
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwAddressID	;dwAddressID: dword->dword
+	push	dword ptr bp_lphCall
+	call	MapLS
+	mov	bp_lphCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpszDestAddress
+	call	MapLS
+	mov	bp_lpszDestAddressTmp, eax
+	push	eax
+	push	dword ptr bp_lpszGroupID
+	call	MapLS
+	mov	bp_lpszGroupIDTmp, eax
+	push	eax
+
+	call	linePickup
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszDestAddressTmp
+	call	UnMapLS
+	push	dword ptr bp_lpszGroupIDTmp
+	call	UnMapLS
+	pop	eax
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINESETUPCONFERENCE
+;-----------------------------------------------------------------------;
+body_LINESETUPCONFERENCE macro
+
+bp_hCall     		equ     <bp_top>
+bp_hLine     		equ     <bp_top+4>
+bp_lphConfCall		equ	<bp_top+8>
+bp_lphConsultCall	equ	<bp_top+12>
+bp_dwNumParties		equ	<bp_top+16>
+bp_lpCallParams		equ	<bp_top+20>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  hLine
+; dword ptr [ebp+16]:  lphConfCall
+; dword ptr [ebp+20]:  lphConsultCall
+; dword ptr [ebp+24]:  dwNumParties
+; dword ptr [ebp+28]:  lpCallParams
+;
+
+bp_lphConfCallTmp	equ	<dword ptr [bp-4]>
+bp_lphConsultCallTmp	equ	<dword ptr [bp-8]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-12]>
+
+	sub	eax, eax
+	push	eax				;bp_lphConfCallTmp
+	push	eax				;bp_lphConsultCallTmp
+	push	eax				;bp_lpCallParamsTmp
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_lphConfCall
+	call	MapLS
+	mov	bp_lphConfCallTmp, eax
+	push	eax
+	push	dword ptr bp_lphConsultCall
+	call	MapLS
+	mov	bp_lphConsultCallTmp, eax
+	push	eax
+	push	dword ptr bp_dwNumParties	;dwNumParties: dword->dword
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	lineSetupConference
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax
+;
+; Don't UnMap lphConfCallTmp and lphConsultCallTmp: Done in tapi.dll
+; due to async read/write.
+;
+;	push	dword ptr bp_lphConfCallTmp
+;	call	UnMapLS
+;	push	dword ptr bp_lphConsultCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINECOMPLETETRANSFER
+;-----------------------------------------------------------------------;
+body_LINECOMPLETETRANSFER macro
+
+bp_hCall     		equ     <bp_top>
+bp_hConsultCall		equ     <bp_top+4>
+bp_lphConfCall		equ	<bp_top+8>
+bp_dwTransferMode	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  hConsultCall
+; dword ptr [ebp+16]:  lphConfCall
+; dword ptr [ebp+20]:  dwTransferMode
+;
+
+bp_lphConfCallTmp	equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lphConfCallTmp
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_hConsultCall	;hConsultCall: dword->dword
+	push	dword ptr bp_lphConfCall
+	call	MapLS
+	mov	bp_lphConfCallTmp, eax
+	push	eax
+	push	dword ptr bp_dwTransferMode	;dwTransferMode: dword->dword
+
+	call	lineCompleteTransfer
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lphConfCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphConfCallTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEPREPAREADDTOCONFERENCE
+;-----------------------------------------------------------------------;
+body_LINEPREPAREADDTOCONFERENCE macro
+
+bp_hConfCall     	equ     <bp_top>
+bp_lphAddCall		equ	<bp_top+4>
+bp_lpCallParams		equ	<bp_top+8>
+;
+; dword ptr [ebp+8]:  hConfCall
+; dword ptr [ebp+12]:  lphAddCall
+; dword ptr [ebp+16]:  lpCallParams
+;
+
+bp_lphAddCallTmp	equ	<dword ptr [bp-4]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lphAddCallTmp
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hConfCall		;hConfCall: dword->dword
+	push	dword ptr bp_lphAddCall
+	call	MapLS
+	mov	bp_lphAddCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	linePrepareAddToConference
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax                             ; Save it
+
+;
+; Don't UnMap lphAddCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphAddCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINESETUPTRANSFER
+;-----------------------------------------------------------------------;
+body_LINESETUPTRANSFER macro
+
+bp_hCall     		equ     <bp_top>
+bp_lphConsultCall	equ	<bp_top+4>
+bp_lpCallParams		equ	<bp_top+8>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  lphConsultCall
+; dword ptr [ebp+16]:  lpCallParams
+;
+
+bp_lphConsultCallTmp	equ	<dword ptr [bp-4]>
+bp_lpCallParamsTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lphConsultCallTmp
+	push	eax				;bp_lpCallParams
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_lphConsultCall
+	call	MapLS
+	mov	bp_lphConsultCallTmp, eax
+	push	eax
+	push	dword ptr bp_lpCallParams
+	call	MapLS
+	mov	bp_lpCallParamsTmp, eax
+	push	eax
+
+	call	lineSetupTransfer
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax                             ; Save it
+
+;
+; Don't UnMap lphConsultCallTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lphConsultCallTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpCallParamsTmp
+	call	UnMapLS
+	pop	eax
+
+endm
+
+
+
+;-----------------------------------------------------------------------;
+; body_LINECOMPLETECALL
+;-----------------------------------------------------------------------;
+body_LINECOMPLETECALL macro
+
+bp_hCall     		equ     <bp_top>
+bp_lpdwCompletionID	equ	<bp_top+4>
+bp_dwCompletionMode	equ	<bp_top+8>
+bp_dwMessageID		equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  lpdwCompletionID
+; dword ptr [ebp+16]:  dwCompletionMode
+; dword ptr [ebp+20]:  dwMessageID
+;
+
+bp_lpdwCompletionIDTmp	equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lpdwCompletionID
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_lpdwCompletionID
+	call	MapLS
+	mov	bp_lpdwCompletionIDTmp, eax
+	push	eax
+	push	dword ptr bp_dwCompletionMode
+	push	dword ptr bp_dwMessageID
+
+	call	lineCompleteCall
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpdwCompletionIDTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpdwCompletionIDTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+        
+;-----------------------------------------------------------------------;
+; body_LINEDEVSPECIFIC
+;-----------------------------------------------------------------------;
+body_LINEDEVSPECIFIC macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwAddressID		equ	<bp_top+4>
+bp_hCall     		equ     <bp_top+8>
+bp_lpParams		equ	<bp_top+12>
+bp_dwSize		equ	<bp_top+16>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwAddressID
+; dword ptr [ebp+16]:  hCall
+; dword ptr [ebp+20]:  lpParams
+; dword ptr [ebp+24]:  dwSize
+;
+
+bp_lpParamsTmp		equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lpParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwAddressID	;dwAddressID: dword->dword
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_lpParams
+	call	MapLS
+	mov	bp_lpParamsTmp, eax
+	push	eax
+	push	dword ptr bp_dwSize		;dwSize: dword->dword
+
+	call	lineDevSpecific
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpParams: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpParamsTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+;-----------------------------------------------------------------------;
+; body_PHONEDEVSPECIFIC
+;-----------------------------------------------------------------------;
+body_PHONEDEVSPECIFIC macro
+
+bp_hPhone     		equ     <bp_top>
+bp_lpParams		equ	<bp_top+4>
+bp_dwSize		equ	<bp_top+8>
+;
+; dword ptr [ebp+8]:  hPhone
+; dword ptr [ebp+12]:  lpParams
+; dword ptr [ebp+16]:  dwSize
+;
+
+;bp_lpParamsTmp		equ	<dword ptr [bp-4]>
+;
+	sub	eax, eax
+	push	eax				;bp_lpParams
+
+	push	dword ptr bp_hPhone		;hPhone: dword->dword
+	push	dword ptr bp_lpParams
+	call	MapLS
+	mov	bp_lpParamsTmp, eax
+	push	eax
+	push	dword ptr bp_dwSize		;dwSize: dword->dword
+
+	call	phoneDevSpecific
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpParams: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpParamsTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINEDEVSPECIFICFEATURE
+;-----------------------------------------------------------------------;
+body_LINEDEVSPECIFICFEATURE macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwFeature		equ	<bp_top+4>
+bp_lpParams		equ	<bp_top+8>
+bp_dwSize		equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwFeature
+; dword ptr [ebp+16]:  lpParams
+; dword ptr [ebp+20]:  dwSize
+;
+
+bp_lpParamsTmp		equ	<dword ptr [bp-4]>
+
+	sub	eax, eax
+	push	eax				;bp_lpParams
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwFeature		;dwFeature: dword->dword
+	push	dword ptr bp_lpParams
+	call	MapLS
+	mov	bp_lpParamsTmp, eax
+	push	eax
+	push	dword ptr bp_dwSize		;dwSize: dword->dword
+
+	call	lineDevSpecificFeature
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+;	push	eax
+;
+; Don't UnMap lpParams: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpParamsTmp
+;	call	UnMapLS
+;	pop	eax
+
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEGATHERDIGITS
+;-----------------------------------------------------------------------;
+body_LINEGATHERDIGITS macro
+
+bp_hCall     		equ     <bp_top>
+bp_dwDigitModes		equ	<bp_top+4>
+bp_lpsDigits		equ	<bp_top+8>
+bp_dwNumDigits		equ	<bp_top+12>
+bp_lpszTermDigits 	equ	<bp_top+16>
+bp_dwFirstDigitTimeout	equ	<bp_top+20>
+bp_dwInterDigitTimeout	equ	<bp_top+24>
+;
+; dword ptr [ebp+8]:  hCall
+; dword ptr [ebp+12]:  dwDigitModes
+; dword ptr [ebp+16]:  lpsDigits
+; dword ptr [ebp+20]:  dwNumDigits
+; dword ptr [ebp+24]:  lpszTerminationDigits
+; dword ptr [ebp+28]:  dwFirstDigitTimeout
+; dword ptr [ebp+32]:  dwInterDigitTimeout
+;
+
+bp_lpsDigitsTmp		equ	<dword ptr [bp-4]>
+bp_lpszTermDigitsTmp 	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lpsDigitsTmp
+	push	eax				;bp_lpszTerminationDigitsTmp
+
+	push	dword ptr bp_hCall		;hCall: dword->dword
+	push	dword ptr bp_dwDigitModes	;dwDigitModes: dword->dword
+	push	dword ptr bp_lpsDigits
+	call	MapLS
+	mov	bp_lpsDigitsTmp, eax
+	push	eax
+	push	dword ptr bp_dwNumDigits	;dwNumDigits: dword->dword
+	push	dword ptr bp_lpszTermDigits
+	call	MapLS
+	mov	bp_lpszTermDigitsTmp, eax
+	push	eax
+	push	dword ptr bp_dwFirstDigitTimeout ;dwFirstDigitTimeout: dword->dword
+	push	dword ptr bp_dwInterDigitTimeout ;dwInterDigitTimeout: dword->dword
+
+	call	lineGatherDigits
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax                             ; Save it
+
+;
+; Don't UnMap lpsDigits: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpsDigitsTmp
+;	call	UnMapLS
+	push	dword ptr bp_lpszTermDigitsTmp
+	call	UnMapLS
+
+	pop	eax
+endm
+
+;-----------------------------------------------------------------------;
+; body_LINEPARK
+;-----------------------------------------------------------------------;
+body_LINEPARK macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwParkMode		equ	<bp_top+4>
+bp_lpszDirAddress	equ	<bp_top+8>
+bp_lpNonDirAddress	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:  hLine
+; dword ptr [ebp+12]:  dwParkMode
+; dword ptr [ebp+16]:  lpszDirAddress
+; dword ptr [ebp+20]:  lpNonDirAddress
+;
+
+bp_lpszDirAddressTmp	equ	<dword ptr [bp-4]>
+bp_lpNonDirAddressTmp	equ	<dword ptr [bp-8]>
+
+	sub	eax, eax
+	push	eax				;bp_lpszDirAddressTmp
+	push	eax				;bp_lpNonDirAddressTmp
+
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwParkMode		;dwParkMode: dworkd->dword
+	push	dword ptr bp_lpszDirAddress
+	call	MapLS
+	mov	bp_lpszDirAddressTmp, eax
+	push	eax
+	push	dword ptr bp_lpNonDirAddress
+	call	MapLS
+	mov	bp_lpNonDirAddressTmp, eax
+	push	eax
+
+	call	linePark
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+	push	eax   ; Save it
+
+	push	dword ptr bp_lpszDirAddressTmp
+	call	UnMapLS
+;
+; Don't UnMap lpNonDirAddressTmp: Done in tapi.dll due to async read/write.
+;
+;	push	dword ptr bp_lpNonDirAddressTmp
+;	call	UnMapLS
+
+	pop	eax
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_TAPIREQUESTMEDIACALL
+;-----------------------------------------------------------------------;
+body_TAPIREQUESTMEDIACALL macro
+        mov     eax, -16
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_TAPIREQUESTDROP
+;-----------------------------------------------------------------------;
+body_TAPIREQUESTDROP macro
+        mov     eax, -16
+endm
+
+
+;-----------------------------------------------------------------------;
+; body_LINEREGISTERREQUESTRECIPIENT
+;-----------------------------------------------------------------------;
+body_LINEREGISTERREQUESTRECIPIENT macro
+
+bp_hLine     		equ     <bp_top>
+bp_dwRegistrationInstance  equ	<bp_top+4>
+bp_dwRequestMode	equ	<bp_top+8>
+bp_dwEnable     	equ	<bp_top+12>
+;
+; dword ptr [ebp+8]:   hLine
+; dword ptr [ebp+12]:  dwRegistrationInstance
+; dword ptr [ebp+16]:  dwRequestMode
+; dword ptr [ebp+20]:  bEnable
+;
+
+;
+;	sub	eax, eax
+;	push	eax				;bp_lpszDirAddressTmp
+;	push	eax				;bp_lpNonDirAddressTmp
+;
+
+;
+;       If this is a 32bit app asking to register for media calls, tell 'em
+;       'e's nuts.
+;
+        test    dword ptr bp_dwRequestMode, 2 ;*** *** ***Or should this be 6?
+        jz     @f
+
+ifdef DEBUG
+	DPRINT "32bit apps aren't allowed to register for Media calls"
+endif
+        mov     eax, 80000038h
+        jmp     Done_LRRR
+
+@@:
+	push	dword ptr bp_hLine		;hLine: dword->dword
+	push	dword ptr bp_dwRegistrationInstance
+	push	dword ptr bp_dwRequestMode
+	push	dword ptr bp_dwEnable
+
+	call	lineRegisterRequestRecipient
+
+	shl	eax,16
+	shrd	eax,edx,16
+
+Done_LRRR:
+
+endm
+
diff --git a/private/tapi/dev/sp/tsp3216/script/tapithk.thk b/private/tapi/dev/sp/tsp3216/script/tapithk.thk
new file mode 100644
index 000000000..ab7b5c3aa
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/tapithk.thk
@@ -0,0 +1,288 @@
+/*
+ * Lzexpand APIs thunks for Win32s
+ */
+//__foldwin32sstuff __foldwin32sstuff;
+//foldstyleinitialization = true; //Want this?
+
+enablemapdirect3216 = true;
+//flatthunks = true;
+//flatthunks = false;
+
+#include "..\types.thk"
+
+typedef HANDLE	HINSTANCE;
+typedef DWORD	HTAPI;
+typedef HTAPI	*LPHTAPI;
+typedef HTAPI	HAPP;
+typedef HAPP    HLINEAPP;
+typedef HAPP    HPHONEAPP;
+typedef HAPP 	*LPHAPP;	
+typedef HTAPI	HCALL;
+typedef HCALL	*LPHCALL;	
+typedef HTAPI   HLINE;
+typedef HLINE   *LPHLINE; 
+typedef HTAPI   HPHONE;
+typedef HPHONE  *LPHPHONE; 
+typedef HICON	*LPHICON;
+typedef void	LINECALLBACK;
+typedef void	PHONECALLBACK;
+typedef LPSTR	LPCSTR;
+
+typedef HLINEAPP *LPHLINEAPP;
+typedef HPHONEAPP *LPHPHONEAPP;
+typedef LPVOID	LPLINEEXTENSIONID;
+
+typedef WORD	WPARAM;
+
+typedef LPVOID	LPLINETRANSLATEOUTPUT;		/* LP to data structure */
+typedef LPVOID	LPLINETRANSLATECAPS;		/* LP to data structure */
+typedef LPVOID	LPLINEFORWARDLIST;
+typedef LPVOID	LPLINECALLPARAMS;
+typedef LPVOID	LPLINEGENERATETONE;
+typedef LPVOID	LPLINEADDRESSCAPS;
+typedef LPVOID	LPLINEADDRESSSTATUS;
+typedef LPVOID	LPLINECALLINFO;
+typedef LPVOID	LPLINECALLSTATUS;
+typedef LPVOID	LPLINECALLLIST;
+typedef LPVOID	LPLINEDEVCAPS;
+typedef LPVOID	LPLINEDEVSTATUS;
+typedef LPVOID	LPLINEMONITORTONE;
+typedef LPVOID	LPVARSTRING;
+typedef LPVOID	LPLINEDIALPARAMS;
+typedef LPVOID	LPLINEMEDIACONTROLDIGIT;
+typedef LPVOID	LPLINEMEDIACONTROLMEDIA;
+typedef LPVOID	LPLINEMEDIACONTROLTONE;
+typedef LPVOID	LPLINEMEDIACONTROLCALLSTATE;
+typedef	LPVOID	LPPHONEBUTTONINFO;
+typedef	LPVOID	LPPHONECAPS;
+typedef	LPVOID	LPPHONESTATUS;
+typedef	LPVOID	LPPHONEEXTENSIONID;
+typedef	LPVOID	LPLINECOUNTRYLIST;
+typedef LPVOID	LPLINEPROVIDERLIST;
+
+
+typedef DWORD HDRV_REQUESTID;
+typedef DWORD     DRV_REQUESTID;
+typedef DWORD     HDRVLINE;
+typedef DWORD     HDRVPHONE;
+typedef DWORD     HTAPICALL;
+typedef DWORD     HTAPILINE;
+typedef DWORD     HDRVCALL;
+typedef HDRVCALL  * LPHDRVCALL;
+typedef HDRVLINE  * LPHDRVLINE;
+typedef HDRVPHONE * LPHDRVPHONE;
+
+typedef DWORD  HTAPIPHONE;
+
+typedef DWORD	LINEEVENT;
+typedef DWORD	PHONEEVENT;
+
+
+//not in the TSPI house!  /* Simple Telephony prototypes */
+//not in the TSPI house!  
+//not in the TSPI house!  LONG tapiRequestMakeCall (LPSTR lpszDestAddress, LPSTR lpszAppName, LPSTR lpszCalledParty, LPSTR lpszComment) =
+//not in the TSPI house!  LONG tapiRequestMakeCall(LPSTR lpszDestAddress, LPSTR lpszAppName, LPSTR lpszCalledParty, LPSTR lpszComment)
+//not in the TSPI house!  {
+//not in the TSPI house!  }
+//not in the TSPI house!  
+//not in the TSPI house!  LONG tapiRequestMediaCall (HWND hWnd, WORD wRequestID, LPCSTR lpszDeviceClass, LPCSTR lpDeviceID, DWORD dwSize, 
+//not in the TSPI house!  		DWORD dwSecure, LPCSTR lpszDestAddress, LPCSTR lpszAppName, LPCSTR lpszCalledParty, LPCSTR lpszComment) =
+//not in the TSPI house!  LONG tapiRequestMediaCall (HWND hWnd, WORD wRequestID, LPCSTR lpszDeviceClass, LPCSTR lpDeviceID, DWORD dwSize, 
+//not in the TSPI house!  		DWORD dwSecure, LPCSTR lpszDestAddress, LPCSTR lpszAppName, LPCSTR lpszCalledParty, LPCSTR lpszComment)
+//not in the TSPI house!  {
+//not in the TSPI house!  //BJM 10/25/95 temporary...    body = special;
+//not in the TSPI house!  }
+//not in the TSPI house!  
+//not in the TSPI house!  LONG tapiRequestDrop (HWND hWnd, WPARAM wRequestID) =
+//not in the TSPI house!  LONG tapiRequestDrop (HWND hWnd, WPARAM wRequestID)
+//not in the TSPI house!  {
+//not in the TSPI house!  //BJM 10/25/95 temporary...    body = special;
+//not in the TSPI house!  }
+//not in the TSPI house!  
+//not in the TSPI house!  //LONG tapiGetLocationInfo(LPSTR lpszCountryCode,	LPSTR lpszCityCode) =
+//not in the TSPI house!  //LONG tapiGetLocationInfo(LPSTR lpszCountryCode,	LPSTR lpszCityCode)
+//not in the TSPI house!  //{}
+//not in the TSPI house!  		
+//not in the TSPI house!  
+//not in the TSPI house!  /* Other TAPI functions */
+//not in the TSPI house!  /*
+//not in the TSPI house!  //   hInstance	= push;
+//not in the TSPI house!  //   lpfnCallback = push;
+//not in the TSPI house!  LONG lineInitialize16 (LPHDRVLINEAPP lphdLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, 
+//not in the TSPI house!  			LPCSTR lpszAppName, LPDWORD lpdwNumDevs) =
+//not in the TSPI house!  LONG lineInitialize16 (LPHDRVLINEAPP lphdLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, 
+//not in the TSPI house!  			LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
+//not in the TSPI house!  {
+//not in the TSPI house!  //BJM 10/25/95 temporary...   body = special;
+//not in the TSPI house!  }
+//not in the TSPI house!  
+//not in the TSPI house!  
+//not in the TSPI house!  LONG lineShutdown16 (HDRVLINEAPP hdLineApp) =
+//not in the TSPI house!  LONG lineShutdown16 (HDRVLINEAPP hdLineApp)
+//not in the TSPI house!  {
+//BJM 10/25/95 temporary...   body = special;
+//not in the TSPI house!  }
+//not in the TSPI house!  
+//not in the TSPI house!  
+//not in the TSPI house!  //   hInstance	= push;
+//not in the TSPI house!  //   lpfnCallback = push;
+//not in the TSPI house!  LONG phoneInitialize16 (LPHDRVPHONEAPP lphdPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback,
+//not in the TSPI house!  			LPCSTR lpszAppName, LPDWORD lpdwNumDevs) =
+//not in the TSPI house!  LONG phoneInitialize16 (LPHDRVPHONEAPP lphdPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback,
+//not in the TSPI house!  			LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
+//not in the TSPI house!  {
+//not in the TSPI house!  //BJM 10/25/95 temporary...    body = special;
+//not in the TSPI house!  }
+//not in the TSPI house!  
+//not in the TSPI house!  LONG phoneShutdown16 (HDRVPHONEAPP hdPhoneApp) =
+//not in the TSPI house!  LONG phoneShutdown16 (HDRVPHONEAPP hdPhoneApp)
+//not in the TSPI house!  {
+//not in the TSPI house!  //BJM 10/25/95 temporary...    body = special;
+//not in the TSPI house!  }
+//not in the TSPI house!  */
+
+
+
+
+
+
+
+LONG  TSPI_lineForward (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD bAllAddresses, DWORD dwAddressID, LPLINEFORWARDLIST  lpForwardList,
+                DWORD dwNumRingsNoAnswer, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_lineForward (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD bAllAddresses, DWORD dwAddressID, LPLINEFORWARDLIST  lpForwardList, 
+                DWORD dwNumRingsNoAnswer, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineMakeCall16 (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_lineMakeCall16 (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS  lpCallParams)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineUnpark (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress) =
+LONG  TSPI_lineUnpark (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_linePickup (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID) =
+LONG  TSPI_linePickup (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HTAPICALL htCall, LPHDRVCALL lphdCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineSetupConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVLINE hdLine, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, 
+                DWORD dwNumParties, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_lineSetupConference (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVLINE hdLine, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, 
+                DWORD dwNumParties, LPLINECALLPARAMS  lpCallParams)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineCompleteTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVCALL hdConsultCall, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, DWORD dwTransferMode) =
+LONG  TSPI_lineCompleteTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HDRVCALL hdConsultCall, HTAPICALL htConfCall, LPHDRVCALL lphdConfCall, DWORD dwTransferMode)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_linePrepareAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_linePrepareAddToConference (DRV_REQUESTID dwRequestID, HDRVCALL hdConfCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineSetupTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams) =
+LONG  TSPI_lineSetupTransfer (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, HTAPICALL htConsultCall, LPHDRVCALL lphdConsultCall, LPLINECALLPARAMS  lpCallParams)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineCompleteCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID) =
+LONG  TSPI_lineCompleteCall (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineDevSpecific (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, LPVOID lpParams, DWORD dwSize) =
+LONG  TSPI_lineDevSpecific (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwAddressID, HDRVCALL hdCall, LPVOID lpParams, DWORD dwSize)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineDevSpecificFeature (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize) =
+LONG  TSPI_lineDevSpecificFeature (DRV_REQUESTID dwRequestID, HDRVLINE hdLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_lineGatherDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, 
+		LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout) =
+LONG  TSPI_lineGatherDigits (HDRVCALL hdCall, DWORD dwEndToEndID, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, 
+		LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+LONG  TSPI_linePark (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress) =
+LONG  TSPI_linePark (DRV_REQUESTID dwRequestID, HDRVCALL hdCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+
+
+
+LONG  TSPI_phoneDevSpecific (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, LPVOID lpParams, DWORD dwSize) =
+LONG  TSPI_phoneDevSpecific (DRV_REQUESTID dwRequestID, HDRVPHONE hdPhone, LPVOID lpParams, DWORD dwSize)
+{
+//BJM 10/25/95 temporary...    body = special;
+}
+
+
+
+//*   
+//*   
+//*   /* Private API: TAPI32 must run this thunk to clean up our act.
+//*    *
+//*    * We declare pCB32Tab as DWORD, not POINTER. We want the linear
+//*    * address passed thru untouched.
+//*    */
+//*   VOID TapiThunkInit(DWORD pCB32Tab) =
+//*   VOID TapiThunkInit(DWORD pCB32Tab)
+//*   {
+//*   }
+//*   /* Private API: TAPI32 must run this thunk before any other.
+//*    *
+//*    * We declare pCB32Tab as DWORD, not POINTER. We want the linear
+//*    * address passed thru untouched.
+//*    */
+//*   VOID TapiThunkTerminate(DWORD pCB32Tab) =
+//*   VOID TapiThunkTerminate(DWORD pCB32Tab)
+//*   {
+//*   }
+//*   
+//*   
+
+
+
+
+
+
+/*
+typedef void (CALLBACK * LINECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) =
+typedef void (CALLBACK * LINECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
+{}
+*/
+
+
+/*
+typedef void (CALLBACK * PHONECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) =
+typedef void (CALLBACK * PHONECALLBACK) (DWORD hDevice, DWORD dwMessage, DWORD dwInstance,
+		DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
+{}
+*/
diff --git a/private/tapi/dev/sp/tsp3216/script/types.thk b/private/tapi/dev/sp/tsp3216/script/types.thk
new file mode 100644
index 000000000..ed9c77e85
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/script/types.thk
@@ -0,0 +1,102 @@
+typedef unsigned short USHORT;
+typedef          short  SHORT;
+typedef unsigned long  ULONG;
+typedef          long   LONG;
+typedef unsigned int   UINT;
+typedef          int    INT;
+typedef unsigned char  UCHAR;
+
+typedef void    VOID;
+typedef void   *PVOID;
+typedef void   *LPVOID;
+typedef UCHAR   BYTE;
+typedef USHORT  WORD;
+typedef ULONG   DWORD;
+typedef UINT    HANDLE;
+typedef WORD    HANDLE16;
+typedef DWORD   HANDLE32;
+typedef int     BOOL;
+typedef char   *LPSTR;
+typedef BYTE   *PBYTE;
+typedef BYTE   *LPBYTE;
+typedef USHORT  SEL;
+typedef INT    *LPINT;
+typedef UINT   *LPUINT;
+typedef DWORD  *LPDWORD;
+typedef LONG   *LPLONG;
+typedef WORD   *LPWORD;
+
+typedef HANDLE  HWND;
+typedef HANDLE  HDC;
+typedef HANDLE  HBRUSH;
+typedef HANDLE  HBITMAP;
+typedef HANDLE  HRGN;
+typedef HANDLE  HFONT;
+typedef HANDLE  HCURSOR;
+typedef HANDLE  HMENU;
+typedef HANDLE  HPEN;
+typedef HANDLE  HICON;
+typedef HANDLE  HUSER;      /* vanilla user handle */
+typedef HANDLE  HPALETTE;
+typedef HANDLE  HMF;
+typedef HANDLE  HEMF;
+typedef HANDLE	HCOLORSPACE;
+typedef HANDLE  HMEM;
+typedef HANDLE  HGDI;       /* vanilla gdi handle */
+typedef HANDLE  HGLOBAL;
+typedef HANDLE  HRSRC;
+typedef HANDLE  HACCEL;
+
+
+typedef WORD    ATOM;
+
+typedef DWORD   WNDPROC;    /* handled inside USER */
+
+/* HACK! have it as a pointer to type which differes between 16 and 32
+ * so InLine translation of pointers handle it correctly
+ */
+typedef int *   FARPROC;    /* thunk layer handles this one */
+
+
+/**********************************************/
+typedef struct tagRECT {
+    INT         left;
+    INT         top;
+    INT         right;
+    INT         bottom;
+} RECT;
+typedef RECT   *LPRECT;
+
+
+typedef struct tagPOINT {
+    INT         x;
+    INT         y;
+} POINT;
+typedef POINT  *LPPOINT;
+
+
+typedef struct tagPOINTL {
+    LONG        x;
+    LONG        y;
+} POINTL;
+typedef POINTL  *LPPOINTL;
+
+
+typedef struct tagOFSTRUCT {
+    BYTE        cBytes;
+    BYTE        fFixedDisk;
+    WORD        nErrorCode;
+    WORD        reserved1;
+    WORD        reserved2;
+    BYTE        szPathName[128];
+} OFSTRUCT;
+typedef OFSTRUCT *LPOFSTRUCT;
+
+
+typedef struct tagCHARSETINFO {
+    UINT ciCharset;
+    UINT ciACP;
+    DWORD ciSigCP[2];
+    DWORD ciSigU[4];
+} CHARSETINFO;
+typedef CHARSETINFO *LPCHARSETINFO;
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/debug.c b/private/tapi/dev/sp/tsp3216/tsp3216l/debug.c
new file mode 100644
index 000000000..595700d07
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/debug.c
@@ -0,0 +1,135 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include  <tapi.h>                  
+#include "debug.h"
+
+
+
+extern TCHAR gszProviderKey[];
+extern DWORD gdwPermanentProviderID;
+
+
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+
+{
+   static fTSP3216lDebugLevelValid = FALSE;
+   static char    buf[128] = "TSP3216l: ";
+   static DWORD TSP3216lDebugLevel = 0;
+
+   if (!fTSP3216lDebugLevelValid)
+   {
+
+      DWORD dwDataSize;
+      DWORD dwDataType;
+      HKEY  hKey;
+      TCHAR  KeyName[128];
+
+
+      //
+      // We determine if we should translate by simply trying to retrive a
+      // value with the name of lpszDeviceClass.  If we succeed, we'll
+      // translate.
+      //
+      wsprintf(KeyName, "%s%d", gszProviderKey, gdwPermanentProviderID);
+
+
+//{
+//  TCHAR buf[500];
+//  wsprintf(buf, "Looking in key [%s] for it", KeyName);
+//  OutputDebugString(buf);
+//}
+
+      RegOpenKeyEx(
+                     HKEY_LOCAL_MACHINE,
+                     KeyName,
+                     0,
+                     KEY_ALL_ACCESS,
+                     &hKey
+                     );
+
+      dwDataSize = sizeof(TSP3216lDebugLevel);
+
+      RegQueryValueEx(
+                       hKey,
+                       "DebugLevel",
+                       0,
+                       &dwDataType,
+                       (LPVOID)&TSP3216lDebugLevel,
+                       &dwDataSize
+                     );
+
+      RegCloseKey( hKey );
+
+
+      if ( TSP3216lDebugLevel > 0 )
+      {
+         wsprintf(
+                   &buf[10],
+                   "TSP3216lDebugLevel= %d\n\r",
+                   TSP3216lDebugLevel);
+
+         OutputDebugString((LPSTR)buf);
+
+         fTSP3216lDebugLevelValid = TRUE;
+      }
+
+   }
+
+
+   //
+   // Is the message otherwise "low" enough to display?
+   //
+   if (dwDbgLevel <= TSP3216lDebugLevel)
+   {
+      char    buf[128] = "TSP3216l: ";
+      va_list ap;
+
+
+      va_start(ap, lpszFormat);
+
+      wvsprintf (&buf[10],
+                 lpszFormat,
+                 ap
+                );
+
+      lstrcat (buf, "\n");
+
+      OutputDebugString(buf);
+
+      va_end(ap);
+   }
+
+   return;
+}
+
+#endif
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/debug.h b/private/tapi/dev/sp/tsp3216/tsp3216l/debug.h
new file mode 100644
index 000000000..11abf22ec
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/debug.h
@@ -0,0 +1,25 @@
+#if DBG
+
+
+#if !WIN32
+#define IN
+#define PUCHAR char *
+#endif
+
+
+
+#define DBGOUT(arg) DbgPrt arg
+
+extern VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/depend.mk b/private/tapi/dev/sp/tsp3216/tsp3216l/depend.mk
new file mode 100644
index 000000000..90679717a
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/depend.mk
@@ -0,0 +1,11 @@
+.\tapi32.obj:   ..\..\script\$(VERDIR)\tapi32.asm
+
+.\tapithk.obj:  ..\..\script\$(VERDIR)\tapithk.asm
+
+.\tapifthk.obj: ..\..\script\$(VERDIR)\tapifthk.asm
+
+.\tsp3216l.obj: ..\tsp3216l.c ..\debug.h
+
+.\debug.obj: ..\debug.c ..\debug.h
+
+.\tsp3216l.res: ..\tsp3216l.rc
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/makefile b/private/tapi/dev/sp/tsp3216/tsp3216l/makefile
new file mode 100644
index 000000000..3ad36ddab
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tsp3216l.tsp Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/makefile.def b/private/tapi/dev/sp/tsp3216/tsp3216l/makefile.def
new file mode 100644
index 000000000..fe108c0cf
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/makefile.def
@@ -0,0 +1,56 @@
+ROOT=..\..\..\..\..\..\..
+
+IS_OEM=1
+MASM6=1
+IS_32 = 1
+WANT_C1032=1
+WIN32=1
+
+
+BUILDDLL=1
+DLLENTRY=DllEntryPoint
+
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=tsp3216l.tsp tsp3216l.sym
+
+
+ALTSRCDIR=..\..\script\$(VERDIR)
+SRCDIR=..
+
+SYMDIR=.
+
+BUILD_COFF=1
+
+
+L32EXE=tsp3216l.tsp      # Name of exe.
+L32DEF=..\tsp3216l.def   # Our def file.
+L32MAP=tsp3216l.map      # Our map file.
+L32SYM=tsp3216l.sym      # Our sym file.
+L32RES=tsp3216l.res      # Resource file.
+
+L32OBJS = tapi32.obj tapithk.obj tapifthk.obj tsp3216l.obj debug.obj
+
+L32LIBS= \
+    $(DEVROOT)\lib\kernel32.lib  \
+    $(DEVROOT)\lib\advapi32.lib  \
+    $(DEVROOT)\lib\wow32.lib  \
+    $(DEVROOT)\lib\user32.lib
+
+
+L32FLAGS=-MAP
+
+!include $(ROOT)\dev\master.mk
+#!include $(ROOT)\win\win32\win32.mk
+
+
+#INCLUDE=..\..\script;$(ROOT)\win\thunk;$(INCLUDE)
+#INCLUDE=$(ROOT)\win\thunk;$(INCLUDE);.;..
+INCLUDE=..\..\tsp3216s;$(INCLUDE)
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100 -Ox
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/sources b/private/tapi/dev/sp/tsp3216/tsp3216l/sources
new file mode 100644
index 000000000..e9568dcca
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/sources
@@ -0,0 +1,47 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tsp3216l
+TARGETPATH=\nt\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=\nt\public\sdk\lib\*\kernel32.lib
+
+INCLUDES=..\..\..\inc;\nt\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400
+
+USE_CRTDLL=1
+
+SOURCES=tsp3216l.c \
+        tsp3216l.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/tpiint32.old b/private/tapi/dev/sp/tsp3216/tsp3216l/tpiint32.old
new file mode 100644
index 000000000..8fbf38a3e
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/tpiint32.old
@@ -0,0 +1,760 @@
+        page    ,132
+        TITLE   $tapii32.asm
+        .listall
+
+        .386
+        OPTION READONLY
+        option oldstructs
+
+
+        .model FLAT
+
+
+
+;	.fardata callbacks
+;.data
+CALLBACK SEGMENT PARA USE32 PUBLIC ''
+
+	public	LineCallbackList
+	public	PhoneCallbackList
+
+LineCallbackList	dd	0
+PhoneCallbackList	dd	0
+
+CALLBACK_NEXT          equ 0
+CALLBACK_CALLBACK      equ 4
+CALLBACK_HAPP          equ 8
+CALLBACK_STRUCT_SIZE   equ 0ch
+
+CALLBACK ENDS
+
+
+
+;GetpWin16Lock			proto APIENTRY :ptr dword
+
+
+externDef	STDCALL lineInitialize16@20:near32
+externDef	STDCALL lineShutdown16@4:near32
+externDef	STDCALL phoneInitialize16@20:near32
+externDef	STDCALL phoneShutdown16@4:near32
+
+; ; ;IsBadCodePtr	proto APIENTRY       :ptr dword
+; ; ;
+; ; ;GlobalAlloc                  PROTO NEAR APIENTRY   :DWORD, :DWORD
+; ; ;GlobalLock                   PROTO NEAR APIENTRY   :DWORD
+; ; ;GlobalHandle                 PROTO NEAR APIENTRY   :DWORD
+; ; ;GlobalUnlock                 PROTO NEAR APIENTRY   :DWORD
+; ; ;GlobalFree                   PROTO NEAR APIENTRY   :DWORD
+
+AllocSLCallback              PROTO NEAR APIENTRY   :DWORD, :DWORD
+FreeSLCallback               PROTO NEAR APIENTRY   :DWORD
+Tapi32ConnectPeerSL          PROTO near           pszDll16:dword, pszDll32:dword
+
+
+externDef InitThkSL                     :near32
+externDef FdThkCommon                   :near32
+
+;TapiThunkInit			PROTO near pCB32Tab:dword
+;TapiThunkTerminate		PROTO near pCB32Tab:dword
+
+TapiThkConnectPeerLS            PROTO near pszDll16:dword, pszDll32:dword
+FT_TapiFThkConnectToFlatThkPeer	proto near pszDll16:dword, pszDll32:dword
+NewData			PROTO near
+NewData2			PROTO near
+FreeLibrary16			PROTO NEAR STDCALL :DWORD
+
+;* externDef TapiCB32BitTable		:near32
+
+
+	.data
+
+
+lp16TapiCallbackThunk	dd	0
+
+
+;
+; Pointer to the Win16 heirarchical critical section.
+;
+;	public	Win16Lock
+;Win16Lock	dd	0
+
+
+
+pszDll16	db	'TSP3216s.DLL',0
+pszDll32	db	'TSP3216l.TSP',0
+
+
+cProcessAttach	dw	0		;Count of processes attached to our lib.
+
+
+        .code   THUNK32
+
+
+
+;-----------------------------------------------------------------------;
+; Tapi DLL init routine
+; We expect lReason to be either DLL_PROCESS_ATTACH/DETACH (we take
+; action on these values) or DLL_THREAD_ATTACH/DETACH (we ignore
+; and return success). If there is anything else, we need to check
+; specifically and take appropriate action.
+;-----------------------------------------------------------------------;
+DllEntryPoint proc    near32   hModule:DWORD, lReason:DWORD, lContext:DWORD
+
+
+;****	invoke	GetpWin16Lock, ADDR Win16Lock
+
+	mov     eax, lReason
+	or	eax, eax
+	jz	dec_cProcess	;DLL_PROCESS_DETACH?
+    cmp     eax, 1		;DLL_PROCESS_ATTACH?
+    jne     initok		;DLL_THREAD_ATTACH/DETACH (we don't do anything)
+
+
+	inc	cProcessAttach	;Keep count of how many processes attach to our lib.
+
+; Do once-only initialization.
+;
+;	mov     al, 0
+;	xchg    al, fFirstTime
+;	or      al, al
+;	jnz     initThunk
+
+	cmp	cProcessAttach, 1
+	jne	initok
+
+; This means that we've done our once only initialization before, but
+; that cProcessAttach went down to zero at some point and is now back
+; to 1. When cProcessAttach becomes 0, TapiThunkTerminate gets called
+; which frees up our thunk table (by calling UnRegisterCBClient). So
+; now we need to do that initialization again by calling TapiThunkInit.
+;	pushd	offset TapiCB32BitTable
+;	call    TapiThunkInit
+;	jmp	initok
+
+
+initThunk:
+    invoke  TapiThkConnectPeerLS, ADDR pszDll16, ADDR pszDll32
+	or	eax,eax
+	jz	exit
+
+; Now call our first thunk to further initialize.
+;*******************	pushd	offset TapiCB32BitTable
+;*******************	call    TapiThunkInit
+
+; Initialize the flat thunks.
+	invoke	FT_TapiFThkConnectToFlatThkPeer, ADDR pszDll16, ADDR pszDll32
+	or	eax,eax
+	jz	exit
+
+; Initialize the 16->32 thunks.
+	invoke	Tapi32ConnectPeerSL, ADDR pszDll16, ADDR pszDll32
+	or	eax,eax
+	jz	exit
+
+    invoke NewData2
+    mov    word ptr lp16TapiCallbackThunk+2, dx
+    mov    word ptr lp16TapiCallbackThunk  , ax
+
+	jmp	initok
+
+
+dec_cProcess:
+
+;*	pushd	offset TapiCB32BitTable
+;*	call	TapiThunkTerminate	;needed just for UnRegisterCBClient
+
+
+;
+; Well, we know we have to get rid of all inits and thunk callbacks for
+; this process...
+;
+
+;**********************************      free all the callback thunks
+; ; ;    ;
+; ; ;    ; Run the linked list of callbacks & free 'em all.
+; ; ;    ;
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;
+; ; ;    mov    ebx, LineCallbackList       ; Get the line list anchor
+; ; ;
+; ; ;FreeEmAll:
+; ; ;    or     ebx, ebx                    ; At last entry?
+; ; ;    jz     DoneFreez                   ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Call lineShutdown on this behalf
+; ; ;    ;
+; ; ;    push   ebx                         ; Save this - just in case
+; ; ;    push   [ebx+CALLBACK_HAPP]         ; Push the hLineApp
+; ; ;    call   lineShutdown16@4            ; Shut em down.
+; ; ;    pop    ebx                         ; Get back our value.
+; ; ;
+; ; ;    push   [ebx+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    push   ebx                         ; Use this before freeing it.
+; ; ;
+; ; ;    mov    ebx, [ebx+CALLBACK_NEXT]    ; Get next node in the list.
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the node's memory chunk.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    jmp    FreeEmAll                   ; Do the walk of life.
+; ; ;
+; ; ;DoneFreez:
+; ; ;
+; ; ;    mov    LineCallbackList, 0         ; Just in case...
+; ; ;
+; ; ;
+; ; ;    mov    ebx, PhoneCallbackList      ; Get the phone list anchor
+; ; ;FreeEmAll2:
+; ; ;    or     ebx, ebx                    ; At last entry?
+; ; ;    jz     DoneFreez2                  ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Call phoneShutdown on this behalf
+; ; ;    ;
+; ; ;    push   ebx                         ; Save this - just in case
+; ; ;    push   [ebx+CALLBACK_HAPP]         ; Push the hPhoneApp
+; ; ;    call   phoneShutdown16@4
+; ; ;    pop    ebx                         ; Get back our value.
+; ; ;
+; ; ;    push   [ebx+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    push   ebx                         ; Use this before freeing it.
+; ; ;
+; ; ;    mov    ebx, [ebx+CALLBACK_NEXT]    ; Get next node in the list.
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the node's memory chunk.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    jmp    FreeEmAll2                  ; Do the walk of life.
+; ; ;
+; ; ;DoneFreez2:
+; ; ;
+; ; ;    mov    PhoneCallbackList, 0        ; Just in case...
+; ; ;
+; ; ;    pop    ebx                         ; Get the saved value.
+
+
+
+	dec	cProcessAttach	;Update count of attached processes.
+	cmp	cProcessAttach, 0
+	jne	initok
+
+
+;**********************************
+
+
+;
+; It would have been really cool to have implemented orthogonal thunks, but
+; that didn't happen in M7 because of time pressure and because of potential
+; destabilizing effects.
+; The load count of tapi.dll at this point is 2 (one each for the two
+; thunk scripts that we have (flat and 16-bit thunks)). So we need to
+; call FreeLibrary16 twice to make sure that tapi.dll gets unloaded after
+; this point.
+; So why does tapi.dll hang around even after the last app. that attached
+; to it is gone? Well, per AtsushiK, that's because it uses the same loading
+; technology as kernel, gdi and user. Those libraries never needed to be
+; freed, so no one ever wrote the code to free them. That means that the
+; following hack will work. What's more, it will always work.
+;					---DeepakA
+;	invoke	GetTapiHInst
+	invoke	NewData
+	push	eax
+	push	eax
+	push	eax
+	call	FreeLibrary16
+	call	FreeLibrary16
+	call	FreeLibrary16
+
+
+
+initok:
+        mov     eax, 1         ;return success
+exit:
+        ret
+
+
+
+
+DllEntryPoint endp
+; end DllEntryPoint
+
+
+
+
+
+
+
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;lineInitialize proc    near32   lphApp:DWORD, hInstance:DWORD, lpfnCallback:DWORD, lpsAppName:DWORD, lpdwNumDevs:DWORD
+; ; ;
+; ; ;    ;
+; ; ;    ; First, check the code pointer
+; ; ;    ;
+; ; ;    push   lpfnCallback                ; Push the apps callback address
+; ; ;    call   IsBadCodePtr                ; Is is a valid code pointer?
+; ; ;    or     eax, eax
+; ; ;    jnz    BadCodePointer              ; Nope.  Go away.
+; ; ;
+; ; ;
+; ; ;    push   CALLBACK_STRUCT_SIZE
+; ; ;    push   42h  ;(GMEM_MOVABLE + GMEM_ZEROINIT)
+; ; ;    call   GlobalAlloc                 ; Get some memory for a new node.
+; ; ;    push   eax
+; ; ;    call   GlobalLock
+; ; ;
+; ; ;    or     eax, eax                    ; Did the call fail?
+; ; ;    jz     No_mo_mem                   ; Yerp - go away.
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   eax                         ; We'll need this later (newnode ptr)
+; ; ;    mov    ebx, eax                    ; We'll also be using it very soon.
+; ; ;
+; ; ;    push   lpfnCallback                ; Save 32bit address of callback
+; ; ;    push   lp16TapiCallbackThunk       ; 16bit callback gotten at init time
+; ; ;    call   AllocSLCallback             ; Get a callback
+; ; ;
+; ; ;    ; check return code (0 = failed)
+; ; ;    or     eax, eax                    ; Did we fail?
+; ; ;    jz     No_mo_callbacks             ; Yes, go away.
+; ; ;
+; ; ;    mov    [ebx+CALLBACK_CALLBACK], eax  ;Save the callback address
+; ; ;
+; ; ;    push   lpdwNumDevs                 ; Prepare to call lineInitialize
+; ; ;    push   lpsAppName                  ; Prepare to call lineInitialize
+; ; ;    push   eax                         ; Prepare to call lineInitialize
+; ; ;    push   hInstance                   ; Prepare to call lineInitialize
+; ; ;    push   lphApp                      ; Prepare to call lineInitialize
+; ; ;    call   lineInitialize16@20
+; ; ;
+; ; ;    or     eax, eax                    ; Did lineInit fail?
+; ; ;    jnz    BadReturnCode               ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Now that everything went well, add the new node to the list.
+; ; ;    ;
+; ; ;    pop    ebx                         ; Get the node pointer
+; ; ;
+; ; ;    mov    eax, LineCallbackList       ; Get pointer to first node
+; ; ;    mov    [ebx+CALLBACK_NEXT], eax    ; Fix chain
+; ; ;    mov    LineCallbackList, ebx       ; Insert this new node as first
+; ; ;
+; ; ;    mov    eax, [lphApp]
+; ; ;    mov    eax, [eax]
+; ; ;    mov    [ebx+CALLBACK_HAPP], eax    ; Save the hLineApp
+; ; ;
+; ; ;    xor    eax, eax                    ; Set return code (we got 0 from init).
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadReturnCode:
+; ; ;    xchg   [esp], eax                  ; Get the struct pointer
+; ; ;
+; ; ;    push   eax                         ; We're gonna use this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the callback address
+; ; ;    call   FreeSLCallback              ; Free the thunk callback
+; ; ;
+; ; ;    ;
+; ; ;    ; We've already pushed eax (the newnode pointer) so we don't gotta do
+; ; ;    ; it here.
+; ; ;    ;
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the newnode chunk of mem.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    eax                         ; Get return code.
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadCodePointer:
+; ; ;    mov    eax, 80000035h
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;No_mo_callbacks:
+; ; ;    pop    eax                         ; Get out struct pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;No_mo_mem:
+; ; ;    mov    eax, 80000044h
+; ; ;    ret
+; ; ;
+; ; ;lineInitialize endp
+; ; ;
+; ; ;
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;lineShutdown proc    near32   hApp:DWORD
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;    push   ecx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   hApp
+; ; ;
+; ; ;    call   lineShutdown16@4
+; ; ;
+; ; ;    push   eax                         ; Save the return code.
+; ; ;
+; ; ;    ;
+; ; ;    ; Run the linked list of callbacks looking for this hLineApp
+; ; ;    ;
+; ; ;
+; ; ;    mov    eax, LineCallbackList       ; Get the list anchor
+; ; ;    mov    ebx, offset LineCallbackList ; The previous node.
+; ; ;    mov    ecx, hApp                   ; That which we seek.
+; ; ;
+; ; ;LoopAMundo:
+; ; ;    or     eax, eax                    ; At last entry?
+; ; ;    jz     NotFound                    ; Yup.  Musta not been found.
+; ; ;
+; ; ;    cmp    [eax+CALLBACK_HAPP], ecx    ; Is this that which we seek?
+; ; ;    je     GotIt                       ; Yep - shure is.
+; ; ;
+; ; ;    mov    ebx, eax                    ; Update the "previous" pointer.
+; ; ;    mov    eax, [eax+CALLBACK_NEXT]    ; Get next node in the list
+; ; ;    jmp    LoopAMundo                  ; Do the walk of life.
+; ; ;
+; ; ;GotIt:
+; ; ;    push   eax                         ; We're gonna need this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    ;
+; ; ;    ; Now take it out of the list.
+; ; ;    ;
+; ; ;
+; ; ;    pop    eax                         ; Get back the node pointer.
+; ; ;
+; ; ;    push   [eax+CALLBACK_NEXT]         ; Get this "next" pointer.
+; ; ;    pop    [ebx+CALLBACK_NEXT]         ; and fix the chain.
+; ; ;
+; ; ;    push   eax                         ; Push the trash node pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;
+; ; ;NotFound:
+; ; ;    ;
+; ; ;    ; How is this possible?
+; ; ;    ; Oh well.  We can do nothing here.
+; ; ;    ;
+; ; ;
+; ; ;
+; ; ;    pop    eax                         ; Retrieve the return code.
+; ; ;
+; ; ;    pop    ecx                         ; Get the saved value.
+; ; ;    pop    ebx                         ; Get the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;lineShutdown endp
+; ; ;
+; ; ;
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;phoneInitialize proc    near32   lphApp:DWORD, hInstance:DWORD, lpfnCallback:DWORD, lpsAppName:DWORD, lpdwNumDevs:DWORD
+; ; ;
+; ; ;    ;
+; ; ;    ; First, check the code pointer
+; ; ;    ;
+; ; ;    push   lpfnCallback                ; Push the apps callback address
+; ; ;    call   IsBadCodePtr                ; Is is a valid code pointer?
+; ; ;    or     eax, eax
+; ; ;    jnz    BadCodePointer              ; Nope.  Go away.
+; ; ;
+; ; ;
+; ; ;    push   CALLBACK_STRUCT_SIZE
+; ; ;    push   42h  ;(GMEM_MOVABLE + GMEM_ZEROINIT)
+; ; ;    call   GlobalAlloc                 ; Get some memory for a new node.
+; ; ;    push   eax
+; ; ;    call   GlobalLock
+; ; ;
+; ; ;    or     eax, eax                    ; Did the call fail?
+; ; ;    jz     No_mo_mem                   ; Yerp - go away.
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   eax                         ; We'll need this later (newnode ptr)
+; ; ;    mov    ebx, eax                    ; We'll also be using it very soon.
+; ; ;
+; ; ;    push   lpfnCallback                ; Save 32bit address of callback
+; ; ;    push   lp16TapiCallbackThunk       ; 16bit callback gotten at init time
+; ; ;    call   AllocSLCallback             ; Get a callback
+; ; ;
+; ; ;    ; check return code (0 = failed)
+; ; ;    or     eax, eax                    ; Did we fail?
+; ; ;    jz     No_mo_callbacks             ; Yes, go away.
+; ; ;
+; ; ;    mov    [ebx+CALLBACK_CALLBACK], eax  ;Save the callback address
+; ; ;
+; ; ;    push   lpdwNumDevs                 ; Prepare to call phoneInitialize
+; ; ;    push   lpsAppName                  ; Prepare to call phoneInitialize
+; ; ;    push   eax                         ; Prepare to call phoneInitialize
+; ; ;    push   hInstance                   ; Prepare to call phoneInitialize
+; ; ;    push   lphApp                      ; Prepare to call phoneInitialize
+; ; ;    call   phoneInitialize16@20
+; ; ;
+; ; ;    or     eax, eax                    ; Did phoneInit fail?
+; ; ;    jnz    BadReturnCode               ; Yup, go away.
+; ; ;
+; ; ;    ;
+; ; ;    ; Now that everything went well, add the new node to the list.
+; ; ;    ;
+; ; ;    pop    ebx                         ; Get the node pointer
+; ; ;    mov    eax, PhoneCallbackList      ; Get pointer to first node
+; ; ;    mov    [ebx+CALLBACK_NEXT], eax    ; Fix chain
+; ; ;    mov    PhoneCallbackList, ebx      ; Insert this new node as first
+; ; ;
+; ; ;    mov    eax, [lphApp]
+; ; ;    mov    eax, [eax]
+; ; ;    mov    [ebx+CALLBACK_HAPP], eax    ; Save the hPhoneApp
+; ; ;
+; ; ;    xor    eax, eax                    ; Set return code (we got 0 from init).
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadReturnCode:
+; ; ;    xchg   [esp], eax                  ; Get the struct pointer
+; ; ;
+; ; ;    push   eax                         ; We're gonna use this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the callback address
+; ; ;    call   FreeSLCallback              ; Free the thunk callback
+; ; ;
+; ; ;    ;
+; ; ;    ; We've already pushed eax (the newnode pointer) so we don't gotta do
+; ; ;    ; it here.
+; ; ;    ;
+; ; ;
+; ; ;    ;
+; ; ;    ; Free the newnode chunk of mem.
+; ; ;    ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    eax                         ; Get return code.
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;BadCodePointer:
+; ; ;    mov    eax, 90000035h
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;No_mo_callbacks:
+; ; ;    pop    eax                         ; Get out struct pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;    pop    ebx                         ; Get back the saved value.
+; ; ;
+; ; ;No_mo_mem:
+; ; ;    mov    eax, 90000044h
+; ; ;    ret
+; ; ;
+; ; ;phoneInitialize endp
+; ; ;
+; ; ;
+; ; ;;phoneInitialize proc    near32   lphApp:DWORD, hInstance:DWORD, lpfnCallback:DWORD, lpsAppName:DWORD, lpdwNumDevs:DWORD
+; ; ;;
+; ; ;;    ;
+; ; ;;    ; First, check the code pointer
+; ; ;;    ;
+; ; ;;    push   lpfnCallback
+; ; ;;    call   IsBadCodePtr
+; ; ;;    or     eax, eax
+; ; ;;    jz     GoodPointer
+; ; ;;
+; ; ;;    mov    eax, 90000035h
+; ; ;;    ret
+; ; ;;
+; ; ;;GoodPointer:
+; ; ;;    push   lpdwNumDevs
+; ; ;;    push   lpsAppName
+; ; ;;    
+; ; ;;    push   lpfnCallback
+; ; ;;    push   lp16TapiCallbackThunk
+; ; ;;    call   AllocSLCallback
+; ; ;;
+; ; ;;    ; check return code (0 = failed)
+; ; ;;    or     eax, eax
+; ; ;;    jz     No_mo_callbacks
+; ; ;;
+; ; ;;
+; ; ;;    mov    TapiCallbackThunk, eax
+; ; ;;    push   eax
+; ; ;;
+; ; ;;    push   hInstance
+; ; ;;    push   lphApp
+; ; ;;
+; ; ;;    call   phoneInitialize16@20
+; ; ;;
+; ; ;;    ret
+; ; ;;
+; ; ;;
+; ; ;;No_mo_callbacks:
+; ; ;;    mov    eax, 90000044h
+; ; ;;    ret
+; ; ;;
+; ; ;;phoneInitialize endp
+; ; ;
+; ; ;
+; ; ;;****************************************************************************
+; ; ;;****************************************************************************
+; ; ;phoneShutdown proc    near32   hApp:DWORD
+; ; ;
+; ; ;    push   ebx                         ; Be polite and save this.
+; ; ;    push   ecx                         ; Be polite and save this.
+; ; ;
+; ; ;    push   hApp
+; ; ;
+; ; ;    call   phoneShutdown16@4
+; ; ;
+; ; ;    push   eax                         ; Save the return code.
+; ; ;
+; ; ;    ;
+; ; ;    ; Run the linked list of callbacks looking for this hPhoneApp
+; ; ;    ;
+; ; ;
+; ; ;    mov    eax, PhoneCallbackList    ; Get the list anchor
+; ; ;    mov    ebx, offset PhoneCallbackList ; The previous node.
+; ; ;    mov    ecx, hApp                   ; That which we seek.
+; ; ;
+; ; ;LoopAMundo:
+; ; ;    or     eax, eax                    ; At last entry?
+; ; ;    jz     NotFound                    ; Yup.  Musta not been found.
+; ; ;
+; ; ;    cmp    [eax+CALLBACK_HAPP], ecx    ; Is this that which we seek?
+; ; ;    je     GotIt                       ; Yep - shure is.
+; ; ;
+; ; ;    mov    ebx, eax                    ; Update the "previous" pointer.
+; ; ;    mov    eax, [eax+CALLBACK_NEXT]    ; Get next node in the list
+; ; ;    jmp    LoopAMundo                  ; Do the walk of life.
+; ; ;
+; ; ;GotIt:
+; ; ;    push   eax                         ; We're gonna need this in a sec...
+; ; ;
+; ; ;    push   [eax+CALLBACK_CALLBACK]     ; Push the thunk thing.
+; ; ;    call   FreeSLCallback              ; Be free...
+; ; ;
+; ; ;    ;
+; ; ;    ; Now take it out of the list.
+; ; ;    ;
+; ; ;
+; ; ;    pop    eax                         ; Get back the node pointer.
+; ; ;
+; ; ;    push   [eax+CALLBACK_NEXT]         ; Get this "next" pointer.
+; ; ;    pop    [ebx+CALLBACK_NEXT]         ; and fix the chain.
+; ; ;
+; ; ;    push   eax                         ; Push the trash node pointer
+; ; ;
+; ; ;    ; Free it.
+; ; ;
+; ; ;    call   GlobalHandle
+; ; ;    push   eax
+; ; ;    push   eax
+; ; ;    call   GlobalUnlock
+; ; ;    call   GlobalFree
+; ; ;
+; ; ;
+; ; ;NotFound:
+; ; ;    ;
+; ; ;    ; How is this possible?
+; ; ;    ; Oh well.  We can do nothing here.
+; ; ;    ;
+; ; ;
+; ; ;
+; ; ;    pop    eax                         ; Retrieve the return code.
+; ; ;
+; ; ;    pop    ecx                         ; Get the saved value.
+; ; ;    pop    ebx                         ; Get the saved value.
+; ; ;
+; ; ;    ret
+; ; ;
+; ; ;
+; ; ;
+; ; ;;    push   hApp
+; ; ;;
+; ; ;;    call   phoneShutdown16@4
+; ; ;;
+; ; ;;    cmp    TapiCallbackThunk, 0
+; ; ;;    je     Dont_free_me
+; ; ;;
+; ; ;;    push   eax                    ; We're gonna need this...
+; ; ;;
+; ; ;;    push   TapiCallbackThunk
+; ; ;;    call   FreeSLCallback
+; ; ;;
+; ; ;;    pop    eax                    ; Get back our _real_ return code...
+; ; ;;
+; ; ;;    mov    TapiCallbackThunk, 0
+; ; ;;
+; ; ;;
+; ; ;;Dont_free_me:
+; ; ;;
+; ; ;;    ret
+; ; ;;
+; ; ;phoneShutdown endp
+; ; ;
+
+
+end
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.c b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.c
new file mode 100644
index 000000000..4180d8114
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.c
@@ -0,0 +1,1282 @@
+#include <windows.h>
+#include <windowsx.h>
+#include <winuser.h>
+#include <wownt32.h>
+
+#include <tapi.h>
+#include <tspi.h>
+
+#include "tsp3216.h"
+#include "debug.h"
+
+
+LONG PASCAL TapiThk_ThunkConnect32 (
+                                 LPSTR pszDll16,
+                                 LPSTR pszDll32,
+                                 DWORD hInstance,
+                                 DWORD lReason
+                               );
+
+LONG PASCAL TapiFThk_ThunkConnect32 (
+                                 LPSTR pszDll16,
+                                 LPSTR pszDll32,
+                                 DWORD hInstance,
+                                 DWORD lReason
+                               );
+
+LONG PASCAL Tapi32_ThunkConnect32 (
+                                 LPSTR pszDll16,
+                                 LPSTR pszDll32,
+                                 DWORD hInstance,
+                                 DWORD lReason
+                               );
+
+const char pszDll16[] = "TSP3216S.DLL";
+const char pszDll32[] = "TSP3216L.TSP";
+
+
+
+//***************************************************************************
+//***************************************************************************
+enum {
+      MYMSG_STARTER = TSP3216L_MESSAGE,
+      MYMSG_PROVIDERINIT,
+      MYMSG_PROVIDERSHUTDOWN,
+      MYMSG_PROVIDERCONFIG,
+      MYMSG_LINECONFIGDIALOG,
+      MYMSG_LINECONFIGDIALOGEDIT,
+      MYMSG_PHONECONFIGDIALOG,
+      MYMSG_LINEMAKECALL
+     };
+
+
+//***************************************************************************
+DWORD cProcessAttach = 0;
+
+
+//***************************************************************************
+HWND ghWnd = NULL;
+CRITICAL_SECTION gcs;
+
+
+//***************************************************************************
+TCHAR gszProviderKey[] = "Software\\Microsoft\\Windows\\CurrentVersion\\"
+                         "Telephony\\Providers\\Provider";
+
+DWORD gdwPermanentProviderID;
+
+
+DWORD gdwThreadParms[2];
+enum {
+       THE_HINST,
+       THE_LREASON
+     };
+
+
+
+//***************************************************************************
+LRESULT CALLBACK MyWndProc( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam );
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LPVOID TspAlloc( UINT nSize )
+{
+   return LocalAlloc( LPTR, nSize );
+}
+
+
+
+LPVOID TspFree( LPVOID p )
+{
+   return LocalFree( p );
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void InitThunks( void )
+{
+            TapiThk_ThunkConnect32( 
+                                    (LPSTR)pszDll16,
+                                    (LPSTR)pszDll32,
+                                    gdwThreadParms[THE_HINST],
+                                    gdwThreadParms[THE_LREASON]
+                                  );
+
+            TapiFThk_ThunkConnect32(
+                                    (LPSTR)pszDll16,
+                                    (LPSTR)pszDll32,
+                                    gdwThreadParms[THE_HINST],
+                                    gdwThreadParms[THE_LREASON]
+                                  );
+
+            Tapi32_ThunkConnect32( 
+                                    (LPSTR)pszDll16,
+                                    (LPSTR)pszDll32,
+                                    gdwThreadParms[THE_HINST],
+                                    gdwThreadParms[THE_LREASON]
+                                  );
+
+            InitializeCriticalSection( &gcs );
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+
+UINT PASCAL NewData( void );
+
+
+void FreeThunks( void )
+{
+   HINSTANCE hInst;
+   hInst = (HINSTANCE)NewData();
+   FreeLibrary16( hInst );
+   FreeLibrary16( hInst );
+   FreeLibrary16( hInst );
+
+
+   DeleteCriticalSection( &gcs );
+
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+DWORD WINAPI TheUIThread( LPVOID lpThreadParameter )
+{
+   MSG msg;
+
+   WNDCLASS wndclass = {
+                  0,
+                  MyWndProc,
+                  0,
+                  0,
+                  (HANDLE)gdwThreadParms[THE_HINST],
+                  0,
+                  0,
+                  0,
+                  0,
+                  "Tsp3216LWindowClass"
+               };
+
+
+DBGOUT((2, "The UI thread"));
+
+
+   //
+   // We need _another_ goddamn window.
+   //
+
+   RegisterClass( &wndclass );
+
+   ghWnd = CreateWindow(
+         "Tsp3216LWindowClass",
+         "Tsp3216LWindow",
+         0,
+         0,
+         0,
+         0,
+         0,
+         0,
+         NULL,
+         (HANDLE)gdwThreadParms[THE_HINST],
+         NULL
+      );
+
+
+DBGOUT((2, "Starting message loop in ui thread"));
+
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+        {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        }
+
+DBGOUT((2, "Done message loop in ui thread"));
+
+    ghWnd = NULL;
+
+    return (msg.wParam);
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG WINAPI DllEntryPoint(
+                      DWORD hModule,
+                      DWORD lReason,
+                      DWORD lContext
+                    )
+{
+
+
+DBGOUT((2, "Entering DllEntryPoint  reason=0x%08lx", lReason));
+
+
+	switch ( lReason )
+   {
+      case 0:
+      {
+#if DBG
+{
+TCHAR cName[MAX_PATH];
+TCHAR buf[256];
+GetModuleFileName( NULL, cName, MAX_PATH);
+wsprintf(buf, "DllEntryPoint - 0 process detach [%s]\r\n", cName);
+OutputDebugString(buf);
+}
+#endif
+
+
+         FreeThunks();
+      }
+      break;
+
+
+
+      case 1:
+      {
+#if DBG
+{
+TCHAR cName[MAX_PATH];
+TCHAR buf[256];
+GetModuleFileName( NULL, cName, MAX_PATH);
+wsprintf(buf, "DllEntryPoint - 1 process attach [%s]\r\n", cName);
+OutputDebugString(buf);
+}
+#endif
+
+
+         //
+         // Yeah, I know it's not threadsafe.  Ask me if I care.
+         //
+         gdwThreadParms[THE_HINST] = (DWORD)hModule;
+         gdwThreadParms[THE_LREASON] = (DWORD)lReason;
+
+
+         InitThunks();
+      }
+      break;
+
+   }
+
+DBGOUT((2, "Leaving DllEntryPoint"));
+
+   return TRUE;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG PASCAL TSPI_lineConfigDialog (
+                                    DWORD dwDeviceID,
+                                    HWND hwndOwner,
+                                    LPCSTR lpszDeviceClass
+                                  );
+
+LONG PASCAL TSPI_lineConfigDialogEdit(
+                                DWORD dwDeviceID,
+                                HWND hwndOwner,
+                                LPCSTR lpszDeviceClass,
+                                LPVOID  lpDeviceConfigIn,
+                                DWORD dwSize,
+                                LPVARSTRING lpDeviceConfigOut
+                              );
+
+
+LONG
+TSPIAPI
+TSPI_providerGenericDialogData(
+                                DWORD dwObjectID,
+                                DWORD dwObjectType,
+                                LPVOID lpParams,
+                                DWORD dwSize
+                              )
+{
+//   LONG lResult = LINEERR_OPERATIONUNAVAIL;
+
+
+   DBGOUT((2, "In TSPI_providerGenericDialogData"));
+
+   DBGOUT((11, "   Msg=0x%08lx", ((LPDWORD)lpParams)[0]));
+
+//   return SendMessage( ghWnd, ((LPDWORD)lpParams)[0], 0, (LPARAM)&(((LPDWORD)lpParams)[1]) );
+//   return 
+            PostMessage( ghWnd, ((LPDWORD)lpParams)[0], 0, (LPARAM)&(((LPDWORD)lpParams)[1]) );
+     return 0;
+
+//   return lResult;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TSPI_providerUIIdentify(
+                         LPSTR pszUIDllName
+                       )
+{
+
+   DBGOUT((2, "In TSPI_providerUIIdentify"));
+
+   lstrcpy( pszUIDllName, "TSP3216L.TSP" );
+
+   return 0;
+
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TUISPI_lineConfigDialog(
+                         TUISPIDLLCALLBACK lpfnUIDLLCallback,
+                         DWORD dwDeviceID,
+                         HWND  hwndOwner,
+                         LPCSTR lpszDeviceClass
+                       )
+{
+   DWORD dwParms[] = {
+                        MYMSG_LINECONFIGDIALOG,
+                        dwDeviceID,
+                        (DWORD)hwndOwner,
+                        (DWORD)lpszDeviceClass
+                      };
+
+
+//BUGBUG: Can't pass strings across a callback
+
+   DBGOUT((2, "In TUISPI_lineConfigDialog"));
+   DBGOUT((11, "  dwDeviceID=0x%08lx", dwDeviceID));
+   DBGOUT((11, "  hwndOwner =0x%08lx", hwndOwner));
+   DBGOUT((11, "  lpszDeviceClass=0x%08lx", lpszDeviceClass));
+
+   (*lpfnUIDLLCallback)(
+                      dwDeviceID,
+                      TUISPIDLL_OBJECT_LINEID,
+                      dwParms,
+                      sizeof(dwParms)
+                    );
+
+//BUGBUG how do we wait and/or return error code?
+   return 0;
+
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TUISPI_lineConfigDialogEdit(
+                             TUISPIDLLCALLBACK lpfnUIDLLCallback,
+                             DWORD dwDeviceID,
+                             HWND  hwndOwner,
+                             LPCSTR lpszDeviceClass,
+                             LPVOID const lpDeviceConfigIn,
+                             DWORD dwSize,
+                             LPVARSTRING lpDeviceConfigOut
+                           )
+{
+   DWORD dwParms[] = {
+                        MYMSG_LINECONFIGDIALOGEDIT,
+                        dwDeviceID,
+                        (DWORD)hwndOwner,
+                        (DWORD)lpszDeviceClass,
+                        (DWORD)lpDeviceConfigIn,
+                        dwSize,
+                        (DWORD)lpDeviceConfigOut
+                      };
+
+
+   DBGOUT((2, "In TUISPI_lineConfigDialogEdit"));
+
+   (*lpfnUIDLLCallback)(
+                      dwDeviceID,
+                      TUISPIDLL_OBJECT_LINEID,
+                      dwParms,
+                      sizeof(dwParms)
+                    );
+
+//BUGBUG how do we wait and/or return error code?
+   return 0;
+
+
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TSPI_phoneConfigDialog(
+                         DWORD dwDeviceID,
+                         HWND  hwndOwner,
+                         LPCSTR lpszDeviceClass
+                       );
+
+LONG
+TSPIAPI
+TUISPI_phoneConfigDialog(
+                         TUISPIDLLCALLBACK lpfnUIDLLCallback,
+                         DWORD dwDeviceID,
+                         HWND  hwndOwner,
+                         LPCSTR lpszDeviceClass
+                       )
+{
+   DWORD dwParms[] = {
+                        MYMSG_PHONECONFIGDIALOG,
+                        dwDeviceID,
+                        (DWORD)hwndOwner,
+                        (DWORD)lpszDeviceClass
+                      };
+
+
+//BUGBUG: Can't pass strings across a callback
+
+   DBGOUT((2, "In TUISPI_phoneConfigDialog"));
+   DBGOUT((11, "  dwDeviceID=0x%08lx", dwDeviceID));
+   DBGOUT((11, "  hwndOwner =0x%08lx", hwndOwner));
+   DBGOUT((11, "  lpszDeviceClass=0x%08lx", lpszDeviceClass));
+
+   (*lpfnUIDLLCallback)(
+                      dwDeviceID,
+                      TUISPIDLL_OBJECT_PHONEID,
+                      dwParms,
+                      sizeof(dwParms)
+                    );
+
+//BUGBUG how do we wait and/or return error code?
+
+   return 0;
+
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TSPI_providerConfig(
+                       HWND  hwndOwner,
+                       DWORD dwPermanentProviderID
+                   );
+
+LONG
+TSPIAPI
+TUISPI_providerConfig(
+                         TUISPIDLLCALLBACK lpfnUIDLLCallback,
+                         HWND  hwndOwner,
+                         DWORD dwPermanentProviderID
+                       )
+{
+   DWORD dwParms[] = {
+                        MYMSG_PROVIDERCONFIG,
+                        (DWORD)hwndOwner,
+                        dwPermanentProviderID
+                      };
+
+
+//BUGBUG: Can't pass strings across a callback
+
+   DBGOUT((2, "In TUISPI_providerConfig"));
+   DBGOUT((11, "  hwndOwner =0x%08lx", hwndOwner));
+   DBGOUT((11, "  dwPermanentProviderID=0x%08lx", dwPermanentProviderID));
+
+   (*lpfnUIDLLCallback)(
+                      0,  //BUGBUG Is this correct?
+                      TUISPIDLL_OBJECT_LINEID,
+                      dwParms,
+                      sizeof(dwParms)
+                    );
+
+//BUGBUG how do we wait and/or return error code?
+
+   return 0;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TUISPI_providerInstall(
+                        TUISPIDLLCALLBACK lpfnUIDLLCallback,
+                        HWND  hwndOwner,
+                        DWORD dwPermanentProviderID
+                      )
+{
+
+   DBGOUT((2, "In TUISPI_providerInstall"));
+
+   return 0;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+TSPIAPI
+TUISPI_providerRemove(
+                        TUISPIDLLCALLBACK lpfnUIDLLCallback,
+                        HWND  hwndOwner,
+                        DWORD dwPermanentProviderID
+                      )
+{
+
+   DBGOUT((2, "In TUISPI_providerRemove"));
+
+   return 0;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+
+
+
+LONG
+PASCAL
+TSPI_providerEnumDevices16(                                       // TSPI v1.4
+    DWORD               dwPermanentProviderID,
+    LPDWORD             lpdwNumLines,
+    LPDWORD             lpdwNumPhones,
+    HPROVIDER           hProvider,
+    LINEEVENT           lpfnLineCreateProc,
+    PHONEEVENT          lpfnPhoneCreateProc,
+    HWND                hSecretWnd
+    );
+
+
+LONG PASCAL TSPI_providerEnumDevices(
+                                      DWORD      dwPermanentProviderID,
+                                      LPDWORD    lpdwNumLines,
+                                      LPDWORD    lpdwNumPhones,
+                                      HPROVIDER  hProvider,
+                                      LINEEVENT  lpfnLineCreateProc,
+                                      PHONEEVENT lpfnPhoneCreateProc
+                                    )
+{
+   DWORD dwThreadID;
+
+
+   DBGOUT((2, "In TSPI_providerEnumDevices"));
+
+   //
+   // BUGBUG There's gotta be a better way to earn a buck...
+   //
+
+   if ( NULL == CreateThread( NULL,
+                              0,
+                              TheUIThread,
+                              (LPVOID)&gdwThreadParms,
+                              0,
+                              &dwThreadID
+                            )
+      )
+   {
+      //
+      // The CreateThread failed!!
+      //
+      DBGOUT((1, "CreateThread() failed!!!!"));
+      return LINEERR_OPERATIONFAILED;
+   }
+
+
+   while ( !ghWnd)
+   {
+      Sleep(0);
+   }
+
+
+   return TSPI_providerEnumDevices16(
+                                      dwPermanentProviderID,
+                                      lpdwNumLines,
+                                      lpdwNumPhones,
+                                      hProvider,
+                                      lpfnLineCreateProc,
+                                      lpfnPhoneCreateProc,
+                                      ghWnd
+                                    );
+
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+
+
+
+LONG
+PASCAL
+TSPI_lineGetID16(
+                  HDRVLINE hdLine,
+                  DWORD dwAddressID,
+                  HDRVCALL hdCall,
+                  DWORD dwSelect,
+                  LPVARSTRING lpDeviceID,
+                  LPCSTR lpszDeviceClass
+                );
+
+
+LONG
+PASCAL
+TSPI_lineGetID(
+                  HDRVLINE hdLine,
+                  DWORD dwAddressID,
+                  HDRVCALL hdCall,
+                  DWORD dwSelect,
+                  LPVARSTRING lpDeviceID,
+                  LPCSTR lpszDeviceClass,
+                  HANDLE hTargetProcess
+
+                )
+{
+   LONG lResult;
+
+   DBGOUT((2, "Entering TSPI_lineGetID"));
+
+
+   DBGOUT((20, "lpszDeviceClass=[%s]", lpszDeviceClass));
+
+   lResult =  TSPI_lineGetID16(
+                                hdLine,
+                                dwAddressID,
+                                hdCall,
+                                dwSelect,
+                                lpDeviceID,
+                                lpszDeviceClass
+                              );
+
+   //
+   // Only continue if the operation was successful
+   //
+   if ( 0 == lResult )
+   {
+
+      //
+      // Is this a handle that we should translate?
+      //
+
+      DWORD dwDataSize;
+      DWORD dwDataType;
+      HKEY  hKey;
+      TCHAR  buf[64];
+      TCHAR  KeyName[128];
+
+
+      //
+      // We determine if we should translate by simply trying to retrive a
+      // value with the name of lpszDeviceClass.  If we succeed, we'll
+      // translate.
+      //
+      // We'll use the value as an offset into the string part (AN OFFSET
+      // FROM THE START OF VAR DATA, NOT FROM THE START OF THE STRUCT!!!)
+      // of where we can find the handle.
+      //
+      wsprintf(KeyName, "%s%d", gszProviderKey, gdwPermanentProviderID);
+
+      RegOpenKeyEx(
+                     HKEY_LOCAL_MACHINE,
+                     KeyName,
+                     0,
+                     KEY_ALL_ACCESS,
+                     &hKey
+                     );
+
+      dwDataSize = sizeof(buf);
+
+
+      DBGOUT((11, "Looking in key [%s] for [%s]", KeyName, lpszDeviceClass));
+
+
+      lResult = RegQueryValueEx(
+                                 hKey,
+                                 lpszDeviceClass,
+                                 0,
+                                 &dwDataType,
+                                 buf,
+                                 &dwDataSize
+                              );
+
+      RegCloseKey( hKey );
+
+
+      if ( 0 == lResult )
+      {
+         HANDLE hTemp;
+#if DBG
+         LONG lRet;
+
+         lRet =
+#endif
+         DuplicateHandle( GetCurrentProcess(),
+                          *(LPHANDLE)((LPBYTE)lpDeviceID +
+                                              lpDeviceID->dwStringOffset +
+                                              *(LPDWORD)buf
+                                     ),
+                          hTargetProcess,
+                          &hTemp,
+                          0,
+                          TRUE,
+                          DUPLICATE_SAME_ACCESS |
+                             DUPLICATE_CLOSE_SOURCE
+                        );
+
+//         CloseHandle( *(LPHANDLE)( (LPBYTE)lpDeviceID +
+//                      lpDeviceID->dwStringOffset +
+//                      *(LPDWORD)buf ) );
+
+
+         *(LPHANDLE)( (LPBYTE)lpDeviceID +
+                      lpDeviceID->dwStringOffset +
+                      *(LPDWORD)buf ) =
+                           hTemp;
+
+         DBGOUT((2, "  Duplicate handle return code=0x%08lx", lRet));
+      }
+#if DBG
+      else
+      {
+         DBGOUT((2, "  We won't dupe this handle. [%s]", lpszDeviceClass));
+      }
+#endif
+
+      lResult = 0;  //What else can we do? Do we fail this if the dupe failed?
+
+   }
+
+
+   DBGOUT((2, "Leaving TSPI_lineGetID - lResult=0x%08lx", lResult));
+
+   return lResult;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG
+PASCAL
+TSPI_phoneGetID16(
+                  HDRVPHONE hdPhone,
+                  LPVARSTRING lpDeviceID,
+                  LPCSTR lpszDeviceClass
+                );
+
+
+LONG
+PASCAL
+TSPI_phoneGetID(
+                  HDRVPHONE hdPhone,
+                  LPVARSTRING lpDeviceID,
+                  LPCSTR lpszDeviceClass,
+                  HANDLE hTargetProcess
+
+                )
+{
+   LONG lResult;
+
+   DBGOUT((2, "Entering TSPI_phoneGetID"));
+
+
+   DBGOUT((20, "lpszDeviceClass=[%s]", lpszDeviceClass));
+
+   lResult =  TSPI_phoneGetID16(
+                                hdPhone,
+                                lpDeviceID,
+                                lpszDeviceClass
+                              );
+
+   //
+   // Only continue if the operation was successful
+   //
+   if ( 0 == lResult )
+   {
+
+      //
+      // Is this a handle that we should translate?
+      //
+
+      DWORD dwDataSize;
+      DWORD dwDataType;
+      HKEY  hKey;
+      TCHAR  buf[64];
+      TCHAR  KeyName[128];
+
+
+      //
+      // We determine if we should translate by simply trying to retrive a
+      // value with the name of lpszDeviceClass.  If we succeed, we'll
+      // translate.
+      //
+      // We'll use the value as an offset into the string part (AN OFFSET
+      // FROM THE START OF VAR DATA, NOT FROM THE START OF THE STRUCT!!!)
+      // of where we can find the handle.
+      //
+      wsprintf(KeyName, "%s%d", gszProviderKey, gdwPermanentProviderID);
+
+      RegOpenKeyEx(
+                     HKEY_LOCAL_MACHINE,
+                     KeyName,
+                     0,
+                     KEY_ALL_ACCESS,
+                     &hKey
+                     );
+
+      dwDataSize = sizeof(buf);
+
+
+      DBGOUT((20, "Looking in key [%s] for [%s]", KeyName, lpszDeviceClass));
+
+
+      lResult = RegQueryValueEx(
+                                 hKey,
+                                 lpszDeviceClass,
+                                 0,
+                                 &dwDataType,
+                                 buf,
+                                 &dwDataSize
+                              );
+
+      RegCloseKey( hKey );
+
+
+      if ( 0 == lResult )
+      {
+         HANDLE hTemp;
+#if DBG
+         LONG lRet;
+
+         lRet =
+#endif
+         DuplicateHandle( GetCurrentProcess(),
+                          *(LPHANDLE)((LPBYTE)lpDeviceID +
+                                              lpDeviceID->dwStringOffset +
+                                              *(LPDWORD)buf
+                                     ),
+                          hTargetProcess,
+                          &hTemp,
+                          0,
+                          TRUE,
+                          DUPLICATE_SAME_ACCESS
+//                          DUPLICATE_CLOSE_SOURCE
+                        );
+
+         CloseHandle( *(LPHANDLE)( (LPBYTE)lpDeviceID +
+                      lpDeviceID->dwStringOffset +
+                      *(LPDWORD)buf ) );
+
+         *(LPHANDLE)( (LPBYTE)lpDeviceID +
+                      lpDeviceID->dwStringOffset +
+                      *(LPDWORD)buf ) =
+                           hTemp;
+
+         DBGOUT((20, "  Duplicate handle return code=0x%08lx", lRet));
+      }
+#if DBG
+      else
+      {
+         DBGOUT((20, "  We won't dupe this handle. [%s]", lpszDeviceClass));
+      }
+#endif
+
+      lResult = 0;  //What else can we do? Do we fail this if the dupe failed?
+
+   }
+
+
+   DBGOUT((2, "Leaving TSPI_phoneGetID - lResult=0x%08lx", lResult));
+
+   return lResult;
+}
+
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+
+LONG
+PASCAL
+TSPI_providerInit16(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceBaseID,
+    DWORD               dwPhoneDeviceBaseID,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc
+                 );
+
+LONG
+TSPIAPI
+TSPI_providerInit(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc,
+    LPDWORD             lpdwTSPIOptions                         // TAPI v2.0
+    )
+{
+   DWORD pParams[7];
+
+   DBGOUT((2,  "In 32-providerinit"));
+   DBGOUT((11, "  dwTSPIVersion        =0x%08lx", dwTSPIVersion));
+   DBGOUT((11, "  dwPermanentProviderID=0x%08lx", dwPermanentProviderID));
+
+
+   gdwPermanentProviderID = dwPermanentProviderID;
+
+   *lpdwTSPIOptions = 0;
+
+   pParams[0] = dwTSPIVersion;
+   pParams[1] = dwPermanentProviderID;
+   pParams[2] = dwLineDeviceIDBase;
+   pParams[3] = dwPhoneDeviceIDBase;
+   pParams[4] = dwNumLines;
+   pParams[5] = dwNumPhones;
+   pParams[6] = (DWORD)lpfnCompletionProc;
+
+   return SendMessage( ghWnd, MYMSG_PROVIDERINIT, 0, (LPARAM)pParams);
+
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+
+LONG
+PASCAL
+TSPI_providerShutdown16(
+    DWORD  dwTSPIVersion
+                 );
+
+LONG
+TSPIAPI
+TSPI_providerShutdown(
+                       DWORD  dwTSPIVersion
+                     )
+{
+   LONG lResult;
+
+   DBGOUT((2, "In 32-providerShutdown"));
+
+
+   lResult = SendMessage( ghWnd, MYMSG_PROVIDERSHUTDOWN, 0, dwTSPIVersion);
+
+   //
+   // Is the UI thread still around?
+   //
+   if ( ghWnd )
+   {
+      SendMessage(ghWnd, WM_CLOSE, 0, 0);
+
+      //
+      // Verify that the other thread has done its work and killed
+      // the window
+      //
+      while ( ghWnd )
+      {
+         Sleep(0);
+      }
+   }
+
+   return lResult;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+
+LONG
+PASCAL
+TSPI_lineMakeCall16(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    );
+
+LONG
+TSPIAPI
+TSPI_lineMakeCall(
+                    DRV_REQUESTID       dwRequestID,
+                    HDRVLINE            hdLine,
+                    HTAPICALL           htCall,
+                    LPHDRVCALL          lphdCall,
+                    LPCSTR              lpszDestAddress,
+                    DWORD               dwCountryCode,
+                    LPLINECALLPARAMS    const lpCallParams
+                 )
+{
+   LONG lResult;
+   DWORD pParams[7];
+
+
+   DBGOUT((2, "In 32-linemakecall"));
+
+   pParams[0] = (DWORD)dwRequestID;
+   pParams[1] = (DWORD)hdLine;
+   pParams[2] = (DWORD)htCall;
+   pParams[3] = (DWORD)lphdCall;
+   pParams[4] = (DWORD)lpszDestAddress;
+   pParams[5] = (DWORD)dwCountryCode;
+   pParams[6] = (DWORD)lpCallParams;
+
+
+   lResult = SendMessage( ghWnd, MYMSG_LINEMAKECALL, 0, (LPARAM)pParams);
+
+
+   return lResult;
+}
+
+
+//****************************************************************************
+//****************************************************************************
+//****************************************************************************
+LONG PASCAL TapiCallbackThunk(    DWORD dwDevice,
+                              DWORD dwMessage,
+                              DWORD dwInstance,
+                              DWORD dwParam1,
+                              DWORD dwParam2,
+                              DWORD dwParam3,
+                              DWORD dwjunk
+                         )
+{
+
+
+   DBGOUT((2, "TapiCallbackThunk  <<<----------------"));
+
+   return 0;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+void HandleCallback( PCOPYDATASTRUCT pCds )
+{
+  DWORD dwCallbackType = ((LPDWORD)pCds->lpData)[0];
+  LPDWORD lpdwCallbackData = (LPDWORD)pCds->lpData;
+
+
+
+  switch ( dwCallbackType )
+  {
+
+     case CALLBACK_ASYNCCOMPLETION:
+        DBGOUT((2, "AsyncCompletion"));
+        (((ASYNC_COMPLETION)(pCds->dwData)))( lpdwCallbackData[1],
+                          lpdwCallbackData[2]
+                        );
+        break;
+
+
+
+     case CALLBACK_LINEEVENT:
+
+        DBGOUT((2, "LineEvent"));
+
+        if ( lpdwCallbackData[3] == LINE_NEWCALL )
+        {
+           lpdwCallbackData[5] = (DWORD)WOWGetVDMPointer(
+                                                   lpdwCallbackData[5],
+                                                   sizeof(DWORD),
+                                                   1
+                                                 );
+        }
+
+        //FALTHROUGH!!!
+
+     case CALLBACK_LINECREATE:
+
+        if ( dwCallbackType == CALLBACK_LINECREATE )
+        {
+           DBGOUT((2, "LineCreate"));
+        }
+
+
+        (((FARPROC)(pCds->dwData)))( lpdwCallbackData[1],
+                          lpdwCallbackData[2],
+                          lpdwCallbackData[3],
+                          lpdwCallbackData[4],
+                          lpdwCallbackData[5],
+                          lpdwCallbackData[6]
+                        );
+
+#if DBG
+        if ( dwCallbackType == CALLBACK_LINEEVENT &&
+             lpdwCallbackData[3] == LINE_NEWCALL )
+           DBGOUT((11, "Returned htCall=0x%08lx", *(LPDWORD)(lpdwCallbackData[5])));
+#endif
+        break;
+
+
+     case CALLBACK_PHONEEVENT:
+        DBGOUT((2, "PhoneEvent"));
+     case CALLBACK_PHONECREATE:
+        DBGOUT((2, "PhoneCreate?"));
+        (((FARPROC)(pCds->dwData)))( lpdwCallbackData[1],
+                          lpdwCallbackData[2],
+                          lpdwCallbackData[3],
+                          lpdwCallbackData[4],
+                          lpdwCallbackData[5]
+                        );
+        break;
+
+
+#if DBG
+     default:
+        DBGOUT((1, "Invalid callback type!!"));
+        // Should rip or assert?
+        break;
+#endif
+  }
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LRESULT CALLBACK _loadds MyWndProc( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
+{
+
+   DBGOUT((91, "msggg"));
+
+   switch( nMsg )
+   {
+
+      case TSP3216L_MESSAGE:
+         if ((wParam == 1) && (lParam == 2) )
+            DBGOUT((0,"  Got a message thingy"));
+         break;
+
+
+      case MYMSG_PROVIDERINIT:
+         DBGOUT((2, "Got a providerInit message"));
+         return TSPI_providerInit16(
+                                     ((LPDWORD)lParam)[0],
+                                     ((LPDWORD)lParam)[1],
+                                     ((LPDWORD)lParam)[2],
+                                     ((LPDWORD)lParam)[3],
+                                     ((LPDWORD)lParam)[4],
+                                     ((LPDWORD)lParam)[5],
+                                     (ASYNC_COMPLETION)((LPDWORD)lParam)[6]
+                                   );
+         break;
+
+
+      case MYMSG_PROVIDERSHUTDOWN:
+         DBGOUT((2, "Got a providerShutdown message"));
+         return TSPI_providerShutdown16(
+                                         lParam
+                                       );
+         break;
+
+
+      case MYMSG_PROVIDERCONFIG:
+         DBGOUT((2, "Got a providerConfig message"));
+         return TSPI_providerConfig(
+                                     (HWND)((LPDWORD)lParam)[0],
+                                     ((LPDWORD)lParam)[1]
+                                  );
+         break;
+
+
+      case MYMSG_LINEMAKECALL:
+         DBGOUT((2, "Got a lineMakeCall message"));
+         return TSPI_lineMakeCall16(
+                                      (DRV_REQUESTID)((LPDWORD)lParam)[0],
+                                      (HDRVLINE)((LPDWORD)lParam)[1],
+                                      (HTAPICALL)((LPDWORD)lParam)[2],
+                                      (LPHDRVCALL)((LPDWORD)lParam)[3],
+                                      (LPCSTR)((LPDWORD)lParam)[4],
+                                      (DWORD)((LPDWORD)lParam)[5],
+                                      (LPLINECALLPARAMS)((LPDWORD)lParam)[6]
+                                   );
+         break;
+
+
+      case MYMSG_LINECONFIGDIALOG:
+         DBGOUT((2, "Got a lineConfigDialog message"));
+         return TSPI_lineConfigDialog(
+                                      ((LPDWORD)lParam)[0],
+                                      (HWND)((LPDWORD)lParam)[1],
+                                      (LPCSTR)((LPDWORD)lParam)[2]
+                                     );
+         break;
+
+
+      case MYMSG_PHONECONFIGDIALOG:
+         DBGOUT((2, "Got a phoneConfigDialog message"));
+         return TSPI_phoneConfigDialog(
+                                      ((LPDWORD)lParam)[0],
+                                      (HWND)((LPDWORD)lParam)[1],
+                                      (LPCSTR)((LPDWORD)lParam)[2]
+                                     );
+         break;
+
+
+      case WM_COPYDATA:
+         DBGOUT((11, "VaHoo!"));
+
+         HandleCallback( (PCOPYDATASTRUCT)lParam );
+
+         break;
+
+
+      case WM_CLOSE:
+         DestroyWindow( hWnd );
+         break;
+
+
+      case WM_DESTROY:
+         PostQuitMessage(0);
+         break;
+
+
+      default:
+         return DefWindowProc( hWnd, nMsg, wParam, lParam);
+   }
+   DBGOUT((2, "msggg done"));
+
+   return(FALSE);
+}
+
+
+
+
+
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.def b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.def
new file mode 100644
index 000000000..5ac7556a6
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.def
@@ -0,0 +1,130 @@
+LIBRARY     TSP3216l
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept                        @500
+        TSPI_lineAddToConference               @501
+        TSPI_lineAnswer                        @502
+        TSPI_lineBlindTransfer                 @503
+        TSPI_lineClose                         @504
+        TSPI_lineCloseCall                     @505
+        TSPI_lineCompleteCall                  @506
+        TSPI_lineCompleteTransfer              @507
+        TSPI_lineConditionalMediaDetection     @508
+        TSPI_lineConfigDialog                  @509
+        TSPI_lineDevSpecific                   @510
+        TSPI_lineDevSpecificFeature            @511
+        TSPI_lineDial                          @512
+        TSPI_lineDrop                          @513
+        TSPI_lineForward                       @514
+        TSPI_lineGatherDigits                  @515
+        TSPI_lineGenerateDigits                @516
+        TSPI_lineGenerateTone                  @517
+        TSPI_lineGetAddressCaps                @518
+        TSPI_lineGetAddressID                  @519
+        TSPI_lineGetAddressStatus              @520
+        TSPI_lineGetCallAddressID              @521
+        TSPI_lineGetCallInfo                   @522
+        TSPI_lineGetCallStatus                 @523
+        TSPI_lineGetDevCaps                    @524
+        TSPI_lineGetDevConfig                  @525
+        TSPI_lineGetExtensionID                @526
+        TSPI_lineGetIcon                       @527
+        TSPI_lineGetID                         @528
+        TSPI_lineGetLineDevStatus              @529
+        TSPI_lineGetNumAddressIDs              @530
+        TSPI_lineHold                          @531
+        TSPI_lineMakeCall                      @532
+        TSPI_lineMonitorDigits                 @533
+        TSPI_lineMonitorMedia                  @534
+        TSPI_lineMonitorTones                  @535
+        TSPI_lineNegotiateExtVersion           @536
+        TSPI_lineNegotiateTSPIVersion          @537
+        TSPI_lineOpen                          @538
+        TSPI_linePark                          @539
+        TSPI_linePickup                        @540
+        TSPI_linePrepareAddToConference        @541
+        TSPI_lineRedirect                      @542
+        TSPI_lineRemoveFromConference          @543
+        TSPI_lineSecureCall                    @544
+        TSPI_lineSelectExtVersion              @545
+        TSPI_lineSendUserUserInfo              @546
+        TSPI_lineSetAppSpecific                @547
+        TSPI_lineSetCallParams                 @548
+        TSPI_lineSetDefaultMediaDetection      @549
+        TSPI_lineSetDevConfig                  @550
+        TSPI_lineSetMediaControl               @551
+        TSPI_lineSetMediaMode                  @552
+        TSPI_lineSetStatusMessages             @553
+        TSPI_lineSetTerminal                   @554
+        TSPI_lineSetupConference               @555
+        TSPI_lineSetupTransfer                 @556
+        TSPI_lineSwapHold                      @557
+        TSPI_lineUncompleteCall                @558
+        TSPI_lineUnhold                        @559
+        TSPI_lineUnpark                        @560
+
+        TSPI_phoneClose                        @561
+        TSPI_phoneConfigDialog                 @562
+        TSPI_phoneDevSpecific                  @563
+        TSPI_phoneGetButtonInfo                @564
+        TSPI_phoneGetData                      @565
+        TSPI_phoneGetDevCaps                   @566
+        TSPI_phoneGetDisplay                   @567
+        TSPI_phoneGetExtensionID               @568
+        TSPI_phoneGetGain                      @569
+        TSPI_phoneGetHookSwitch                @570
+        TSPI_phoneGetIcon                      @571
+        TSPI_phoneGetID                        @572
+        TSPI_phoneGetLamp                      @573
+        TSPI_phoneGetRing                      @574
+        TSPI_phoneGetStatus                    @575
+        TSPI_phoneGetVolume                    @576
+        TSPI_phoneNegotiateExtVersion          @577
+        TSPI_phoneNegotiateTSPIVersion         @578
+        TSPI_phoneOpen                         @579
+        TSPI_phoneSelectExtVersion             @580
+        TSPI_phoneSetButtonInfo                @581
+        TSPI_phoneSetData                      @582
+        TSPI_phoneSetDisplay                   @583
+        TSPI_phoneSetGain                      @584
+        TSPI_phoneSetHookSwitch                @585
+        TSPI_phoneSetLamp                      @586
+        TSPI_phoneSetRing                      @587
+        TSPI_phoneSetStatusMessages            @588
+        TSPI_phoneSetVolume                    @589
+
+        TSPI_providerConfig                    @590
+        TSPI_providerInit                      @591
+        TSPI_providerInstall                   @592
+        TSPI_providerRemove                    @593
+        TSPI_providerShutdown                  @594
+
+        TSPI_providerEnumDevices               @595
+        TSPI_lineDropOnClose                   @596
+        TSPI_lineDropNoOwner                   @597
+        TSPI_providerCreateLineDevice          @598
+        TSPI_providerCreatePhoneDevice         @599
+        TSPI_lineSetCurrentLocation            @600
+        TSPI_lineConfigDialogEdit              @601
+        TSPI_lineReleaseUserUserInfo           @602
+
+        TSPI_providerGenericDialogData         @608
+        TSPI_providerUIIdentify                @609
+
+        TUISPI_lineConfigDialog                @610
+        TUISPI_lineConfigDialogEdit            @611
+        TUISPI_phoneConfigDialog               @612
+        TUISPI_providerConfig                  @613
+        TUISPI_providerInstall                 @616
+        TUISPI_providerRemove                  @617
+
+
+
+
+   TapiThk_ThunkData32
+   TapiFThk_ThunkData32
+
+   Tapi32_ThunkData32
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.h b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.h
new file mode 100644
index 000000000..99744d0ff
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.h
@@ -0,0 +1,49 @@
+/*  TSP3216L.H
+    Copyright 1995 (C) Microsoft Corporation
+
+    32-bit TAPI service provider to act as a cover for a system's 16-bit SPs
+
+    16-bit part: TSP3216S.DLL
+    32-bit part: TSP3216L.DLL
+
+    t-jereh 20-July-1995
+
+    TODO:
+    1) allow debug levels
+    2) if oom in InitializeSPs(), fail
+
+ */
+
+#define ERR_NONE 0 /* success return value */
+
+#define TSPI_PROC_LAST 103 /* there are TSPI functions from 500 to 602 */
+
+
+// structs
+
+typedef struct tagMYLINE
+    {
+    HDRVLINE hdLine;
+    int iProvider;
+    DWORD dwDeviceID;
+    LINEEVENT lpfnEventProc;
+    HTAPILINE htLine;
+    } MYLINE, *LPMYLINE;
+
+
+typedef struct tagMYPHONE
+    {
+    HDRVPHONE hdPhone;
+    int iProvider;
+    DWORD dwDeviceID;
+    PHONEEVENT lpfnEventProc;
+    HTAPIPHONE htPhone;
+    } MYPHONE, *LPMYPHONE;
+
+
+typedef struct tagMYCALL
+    {
+    HDRVCALL hdCall;
+    int iProvider;
+    DWORD dwDeviceID;
+    } MYCALL, *LPMYCALL;
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.mak b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.mak
new file mode 100644
index 000000000..81db3f3af
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.mak
@@ -0,0 +1,177 @@
+# Microsoft Visual C++ Generated NMAKE File, Format Version 2.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+!IF "$(CFG)" == ""
+CFG=Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "Win32 Release" && "$(CFG)" != "Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "tsp3216l.mak" CFG="Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "Win32 Debug"
+MTL=MkTypLib.exe
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "WinRel"
+# PROP BASE Intermediate_Dir "WinRel"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "WinRel"
+# PROP Intermediate_Dir "WinRel"
+OUTDIR=.\WinRel
+INTDIR=.\WinRel
+
+ALL : $(OUTDIR)/tsp3216l.dll $(OUTDIR)/tsp3216l.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+# ADD BASE CPP /nologo /MT /W3 /GX /YX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FR /c
+# ADD CPP /nologo /MT /W3 /GX /YX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "DEBUG" /FR /c
+CPP_PROJ=/nologo /MT /W3 /GX /YX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "DEBUG" /FR$(INTDIR)/ /Fp$(OUTDIR)/"tsp3216l.pch" /Fo$(INTDIR)/ /c 
+CPP_OBJS=.\WinRel/
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"tsp3216l.bsc" 
+BSC32_SBRS= \
+	$(INTDIR)/tsp3216l.sbr
+
+$(OUTDIR)/tsp3216l.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /DLL /MACHINE:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wow32.lib /NOLOGO /SUBSYSTEM:windows /DLL /MACHINE:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib wow32.lib /NOLOGO /SUBSYSTEM:windows /DLL /INCREMENTAL:no\
+ /PDB:$(OUTDIR)/"tsp3216l.pdb" /MACHINE:I386 /DEF:".\TSP3216L.DEF"\
+ /OUT:$(OUTDIR)/"tsp3216l.dll" /IMPLIB:$(OUTDIR)/"tsp3216l.lib" 
+DEF_FILE=.\TSP3216L.DEF
+LINK32_OBJS= \
+	$(INTDIR)/tsp3216l.obj
+
+$(OUTDIR)/tsp3216l.dll : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "WinDebug"
+# PROP BASE Intermediate_Dir "WinDebug"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "WinDebug"
+# PROP Intermediate_Dir "WinDebug"
+OUTDIR=.\WinDebug
+INTDIR=.\WinDebug
+
+ALL : $(OUTDIR)/tsp3216l.dll $(OUTDIR)/tsp3216l.bsc
+
+$(OUTDIR) : 
+    if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+# ADD BASE CPP /nologo /MT /W3 /GX /Zi /YX /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "DEBUG" /FR /c
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /YX /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
+ /D "DEBUG" /FR$(INTDIR)/ /Fp$(OUTDIR)/"tsp3216l.pch" /Fo$(INTDIR)/\
+ /Fd$(OUTDIR)/"tsp3216l.pdb" /c 
+CPP_OBJS=.\WinDebug/
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"tsp3216l.bsc" 
+BSC32_SBRS= \
+	$(INTDIR)/tsp3216l.sbr
+
+$(OUTDIR)/tsp3216l.bsc : $(OUTDIR)  $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:windows /DLL /DEBUG /MACHINE:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wow32.lib /NOLOGO /SUBSYSTEM:windows /DLL /DEBUG /MACHINE:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib wow32.lib /NOLOGO /SUBSYSTEM:windows /DLL /INCREMENTAL:yes\
+ /PDB:$(OUTDIR)/"tsp3216l.pdb" /DEBUG /MACHINE:I386 /DEF:".\TSP3216L.DEF"\
+ /OUT:$(OUTDIR)/"tsp3216l.dll" /IMPLIB:$(OUTDIR)/"tsp3216l.lib" 
+DEF_FILE=.\TSP3216L.DEF
+LINK32_OBJS= \
+	$(INTDIR)/tsp3216l.obj
+
+$(OUTDIR)/tsp3216l.dll : $(OUTDIR)  $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Group "Source Files"
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\tsp3216l.c
+
+$(INTDIR)/tsp3216l.obj :  $(SOURCE)  $(INTDIR)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\TSP3216L.DEF
+# End Source File
+# End Group
+# End Project
+################################################################################
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.rc b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.rc
new file mode 100644
index 000000000..fa099ea3f
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216l/tsp3216l.rc
@@ -0,0 +1,24 @@
+//
+// (c) 1995 Microsoft Corporation.  All Rights Reserved.
+//
+/* Version Numbering stuff */
+
+
+#include <windows.h>
+
+// Is the following FLAG good to use for this?
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony 16bit SP support"
+#define VER_INTERNALNAME_STR        "16bit SP support"
+#define VER_ORIGINALFILENAME_STR    "tsp3216l.tsp"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/debug.c b/private/tapi/dev/sp/tsp3216/tsp3216s/debug.c
new file mode 100644
index 000000000..a2796f5e7
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/debug.c
@@ -0,0 +1,176 @@
+//
+//
+
+#if DBG
+
+
+#include  <windows.h>
+#include  <windowsx.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include  <tapi.h>                  
+#include "debug.h"
+
+
+
+extern const char far szINIfilename[];
+
+DWORD   gdwDebugLevel;
+
+
+static char szNewBuff[256];
+
+
+DWORD TSP3216sDebugLevel = 0;
+static fTSP3216sDebugLevelValid = FALSE;
+
+VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR lpszFormat,
+    IN ...
+    )
+/*++
+
+Routine Description:
+
+    Formats the incoming debug message & calls DbgPrint
+
+Arguments:
+
+    DbgLevel   - level of message verboseness
+
+    DbgMessage - printf-style format string, followed by appropriate
+                 list of arguments
+
+Return Value:
+
+
+--*/
+
+{
+   static char    buf[128] = "TSP3216s: ";
+
+   if (!fTSP3216sDebugLevelValid)
+   {
+//TSP3216sDebugLevel = 0;
+      TSP3216sDebugLevel =   GetPrivateProfileInt( "Debug",
+                                                   "TSP3216sDebugLevel",
+                                                   0,
+                                                   szINIfilename );
+
+      if ( TSP3216sDebugLevel > 0 )
+      {
+         wsprintf(
+                   &buf[10],
+                   "TSP3216sDebugLevel= %d\n\r",
+                   TSP3216sDebugLevel);
+
+         OutputDebugString((LPSTR)buf);
+
+
+         fTSP3216sDebugLevelValid = TRUE;
+      }
+
+   }
+
+
+   //
+   // Is the message otherwise "low" enough to display?
+   //
+    if (dwDbgLevel <= TSP3216sDebugLevel)
+    {
+        char    buf[128] = "TSP3216s: ";
+        va_list ap;
+
+
+        va_start(ap, lpszFormat);
+
+        vsprintf (&buf[10],
+                  lpszFormat,
+                  ap
+                  );
+
+        lstrcat (buf, "\n");
+
+        OutputDebugString(buf);
+
+        va_end(ap);
+    }
+
+    return;
+}
+
+
+
+
+
+
+//VOID
+//DbgPrt(
+//    IN DWORD  dwDbgLevel,
+//    IN PUCHAR lpszFormat,
+//    IN ...
+//    )
+///*++
+//
+//Routine Description:
+//
+//    Formats the incoming debug message & calls DbgPrint
+//
+//Arguments:
+//
+//    DbgLevel   - level of message verboseness
+//
+//    DbgMessage - printf-style format string, followed by appropriate
+//                 list of arguments
+//
+//Return Value:
+//
+//
+//--*/
+//{
+//    
+//    static BOOL fAlreadyGotIt = FALSE;
+//    static char    buf[128] = "TAPI CPL: ";
+//#define TEXT_START 10
+//
+//    if (!fAlreadyGotIt)
+//    {
+//
+//        gdwDebugLevel = (DWORD) GetPrivateProfileInt(
+//            "Debug",
+//            "TSP3216s32DebugLevel",
+//            0x0,
+//            "Telephon.ini"
+//            );
+//
+//        fAlreadyGotIt = TRUE;
+//
+//        wsprintf(&buf[TEXT_START], "TSP3216s32DebugLevel=%d \r\n", gdwDebugLevel);
+//        OutputDebugStringA(buf);
+//    }
+//
+//
+//    if (dwDbgLevel <= gdwDebugLevel)
+//    {
+//        va_list ap;
+//
+//
+//        va_start(ap, lpszFormat);
+//
+//        vsprintf (&buf[TEXT_START],
+//                  lpszFormat,
+//                  ap
+//                  );
+//
+//        lstrcat (buf, "\n");
+//
+//        OutputDebugStringA (buf);
+//
+//        va_end(ap);
+//    }
+//}
+//
+
+#endif
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/debug.h b/private/tapi/dev/sp/tsp3216/tsp3216s/debug.h
new file mode 100644
index 000000000..11abf22ec
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/debug.h
@@ -0,0 +1,25 @@
+#if DBG
+
+
+#if !WIN32
+#define IN
+#define PUCHAR char *
+#endif
+
+
+
+#define DBGOUT(arg) DbgPrt arg
+
+extern VOID
+DbgPrt(
+    IN DWORD  dwDbgLevel,
+    IN PUCHAR DbgMessage,
+    IN ...
+    );
+
+#else
+
+#define DBGOUT(arg)
+
+#endif
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/depend.mk b/private/tapi/dev/sp/tsp3216/tsp3216s/depend.mk
new file mode 100644
index 000000000..13a65e752
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/depend.mk
@@ -0,0 +1,11 @@
+.\tapi32.obj:   ..\..\script\$(VERDIR)\tapi32.asm
+
+.\tapithk.obj:  ..\..\script\$(VERDIR)\tapithk.asm
+
+.\tapifthk.obj: ..\..\script\$(VERDIR)\tapifthk.asm
+
+.\tsp3216s.obj: ..\tsp3216s.c ..\tsp3216s.h ..\debug.h
+
+.\debug.obj: ..\debug.c ..\debug.h
+
+.\tsp3216s.res: ..\tsp3216s.c
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/makefile b/private/tapi/dev/sp/tsp3216/tsp3216s/makefile
new file mode 100644
index 000000000..43dc5a869
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   tsp3216s.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/makefile.def b/private/tapi/dev/sp/tsp3216/tsp3216s/makefile.def
new file mode 100644
index 000000000..6b793cff4
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/makefile.def
@@ -0,0 +1,49 @@
+ROOT=..\..\..\..\..\..\..
+
+IS_OEM=1
+IS_16 = TRUE
+
+DEFENTRY=LibMain
+BUILDDLL=1
+
+
+
+DEPENDNAME=..\depend.mk
+
+DRVNAME=tsp3216s
+TARGETS=tsp3216s.dll tsp3216s.sym
+
+
+SRCDIR=..
+ALTSRCDIR=..\..\script\$(VERDIR)
+
+SYMDIR=.
+
+
+#BUILD_COFF=1
+
+
+
+L16EXE=tsp3216s.dll		# Name of exe.
+L16DEF=..\tsp3216s.def              # Our def file.
+L16MAP=tsp3216s.map		# Our map file.
+L16SYM=tsp3216s.sym		# Our sym file.
+L16RES=tsp3216s.res	# Resource file.
+L16OBJS= $(DEVROOT)\sdk\lib16\libentry.obj tsp3216s.obj tapi32.obj tapithk.obj tapifthk.obj debug.obj
+L16LIBS= \
+    $(DEVROOT)\tools\c816\lib\ldllcew.lib \
+    $(DEVROOT)\lib16\libw.lib             \
+    $(DEVROOT)\lib16\kernel.lib 
+
+!include $(ROOT)\dev\master.mk
+
+
+INCLUDE=..\..\..\..\inc;$(ROOT)\win\thunk;$(ROOT)\win\core\inc;$(INCLUDE)
+
+
+CFLAGS=$(CFLAGS) -AL -DDONT_DECLARE_TSPI_FUNCTIONS=1 -DTAPI_CURRENT_VERSION=0x00010004
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216.h b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216.h
new file mode 100644
index 000000000..4b4959868
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216.h
@@ -0,0 +1,10 @@
+#define TSP3216L_MESSAGE (WM_USER+10)
+
+enum {CALLBACK_ASYNCCOMPLETION,
+                     CALLBACK_LINEEVENT,
+                     CALLBACK_PHONEEVENT,
+                     CALLBACK_LINECREATE,
+                     CALLBACK_PHONECREATE
+                    } CALLBACK_TYPES;
+
+
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.c b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.c
new file mode 100644
index 000000000..7ef04caef
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.c
@@ -0,0 +1,3659 @@
+/*  TSP3216S.C
+    Copyright 1995 (C) Microsoft Corporation
+
+    32-bit TAPI service provider to act as a cover for a system's 16-bit SPs
+
+    16-bit part: TSP3216S.DLL
+    32-bit part: TSP3216L.DLL
+
+    t-jereh 20-July-1995
+
+    TODO:
+    1) allow debug levels
+    2) if OOM in InitializeSPs(), fail
+    3) other OOM errors
+
+ */
+
+#include <windows.h>
+#include <windowsx.h>
+#include <tapi.h>
+#include <tspi.h>
+
+#include "tsp3216.h"
+#include "tsp3216s.h"
+#include "debug.h"
+//#include <wownt16.h>
+
+
+#undef TSPIAPI
+#define TSPIAPI PASCAL __loadds
+
+
+#define TSPAPI _export _far _pascal __loadds
+typedef LONG (TSPAPI* TSPAPIPROC)(void);
+
+#if DBG
+#define TSP3216SDebugString(_x_) DbgPrt _x_
+//#define TSP3216SDebugString(_x_) TSP3216SOutputDebug _x_
+#else
+#define TSP3216SDebugString(_x_)
+#endif
+
+#define THIS_FUNCTION_UNDER_CONSTRUCTION (LONG)LINEERR_OPERATIONUNAVAIL
+#define THIS_PHONEFUNCTION_UNDER_CONSTRUCTION (LONG)PHONEERR_OPERATIONUNAVAIL
+// a default return value so that the compiler doesn't
+// whine about missing return values in incomplete functions
+
+
+// globals
+
+DWORD FAR PASCAL ghInst32; // handle into TSP3216L.DLL
+HINSTANCE ghThisInst;  //This hinst
+
+HWND ghWnd = NULL;  //hWnd of TSP3216L's window.
+
+//***************************************************************************
+int NumProviders = 0;
+DWORD gdwPPID;
+HINSTANCE FAR * hProviders = NULL; // array of handles to providers
+TSPAPIPROC FAR * lpfnProcAddress = NULL;
+
+DWORD FAR * dwPermanentProviderIDArray;
+DWORD FAR * dwNumLinesArray = NULL; // dwNumLinesArray[1] is how many
+DWORD FAR * dwNumPhonesArray = NULL; // lines are on provider 1
+DWORD gdwLineDeviceIDBase;
+DWORD gdwPhoneDeviceIDBase;
+
+
+
+FARPROC glpLineEventProc32, glpPhoneEventProc32;
+FARPROC glpLineCreateProc32, glpPhoneCreateProc32;
+
+FARPROC glpAsyncCompletionProc32 = NULL;
+
+
+const char far szINIfilename[] = "TELEPHON.INI";
+
+
+#define BOGUS_REQUEST_ID (0xfffffffd)
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank1(
+            DWORD dwBlank1
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank1 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank2(
+            DWORD dwBlank1,
+            DWORD dwBlank2
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank2 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank3(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank3 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank4(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank4 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank5(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5 
+            )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank5 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank6(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank6 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_LineBlank7(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_LineBlank7 - lResult=LINEERR_OPERATIONUNAVAIL"));
+    return LINEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank1(
+            DWORD dwBlank1
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank1 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank2(
+            DWORD dwBlank1,
+            DWORD dwBlank2
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank2 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank3(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank3 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank4(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank4 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank5(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5 
+            )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank5 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank6(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank6 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_PhoneBlank7(
+            DWORD dwBlank1,
+            DWORD dwBlank2,
+            DWORD dwBlank3,
+            DWORD dwBlank4,
+            DWORD dwBlank5,
+            DWORD dwBlank6,
+            DWORD dwBlank7
+           )
+{
+    TSP3216SDebugString((2, "Entering/leaving TSPI_PhoneBlank7 - lResult=PHONEERR_OPERATIONUNAVAIL"));
+    return PHONEERR_OPERATIONUNAVAIL;
+}   
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+// function definitions
+
+#ifdef DEBUG
+VOID TSP3216SOutputDebug(int level, LPSTR errString)
+    {    
+    char outString[1024];
+
+    // if(level <= ???)
+        {
+        wsprintf(outString, "TSP3216S:(%d) %s\r\n", level, errString);
+        OutputDebugString(outString);    
+        }
+    }
+#endif
+
+
+VOID
+InitializeSPs(VOID)
+    {
+    int iProvider;
+    int iCurProvider;
+    char LibFileName[MAXBUFSIZE];
+    char szBuffer[MAXBUFSIZE];
+
+//    ghInst32 = LoadLibraryEx32("TSP3216L.DLL", NULL, 0);
+//
+//    glpLineEventProc32 = GetProcAddress32(ghInst32, "LineEventProc32");
+//    glpPhoneEventProc32 = GetProcAddress32(ghInst32, "PhoneEventProc32");
+//    glpAsyncCompletionProc32 = GetProcAddress32(
+//        ghInst32,
+//        "AsyncCompletionProc32"
+//        );
+//    glpLineCreateProc32 = GetProcAddress32(ghInst32, "LineCreateProc32");
+//    glpPhoneCreateProc32 = GetProcAddress32(ghInst32, "PhoneCreateProc32");
+
+
+    NumProviders = GetPrivateProfileInt(
+        "Providers",
+        "NumProviders",
+        0, // default
+        &szINIfilename[0]
+        );
+
+    dwPermanentProviderIDArray
+        = (DWORD FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(DWORD));
+
+    dwNumLinesArray
+        = (DWORD FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(DWORD));
+    dwNumPhonesArray
+        = (DWORD FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(DWORD));
+
+    hProviders =
+        (HINSTANCE FAR *)GlobalAllocPtr(GPTR, NumProviders * sizeof(HINSTANCE));
+
+    lpfnProcAddress = (TSPAPIPROC FAR *)GlobalAllocPtr(
+        GPTR,
+        NumProviders * TSPI_PROC_LAST * sizeof(TSPAPIPROC)
+        );
+
+    if(
+        !dwPermanentProviderIDArray
+        || !dwNumLinesArray
+        || !dwNumPhonesArray
+        || !hProviders
+        || !lpfnProcAddress)
+        ;// out of memory - fail
+
+
+    iCurProvider = 0;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        {
+        wsprintf(szBuffer, "ProviderFilename%d", iProvider);
+        GetPrivateProfileString(
+            "Providers",
+            szBuffer,
+            "", // default
+            LibFileName,
+            MAXBUFSIZE,
+            szINIfilename
+            );
+
+DBGOUT((1, "Loading [%s] - provider # %d", LibFileName, iProvider));
+
+        hProviders[iCurProvider] = LoadLibrary(LibFileName);
+
+        //
+        // Only add it to the list if it's real.
+        //
+        if ( hProviders[iCurProvider] > 32 )
+           {
+
+           wsprintf(szBuffer, "ProviderID%d", iProvider);
+           dwPermanentProviderIDArray[iCurProvider] = GetPrivateProfileInt(
+               "Providers",
+               szBuffer,
+               0, // default
+               szINIfilename
+               );
+
+           iCurProvider++;
+           }
+#if DBG
+        else
+          {
+DBGOUT((1, "    %s provider # %d FAILED TO LOAD!", LibFileName, iProvider));
+          }
+#endif
+
+        }
+
+    //
+    // Adjust the global for how many SPs actually loaded.
+    //
+    NumProviders = iCurProvider;
+
+    }
+
+
+VOID
+FreeAllMem(VOID)
+    {
+    int iProvider;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        FreeLibrary(hProviders[iProvider]);
+
+    GlobalFreePtr(dwPermanentProviderIDArray);
+    GlobalFreePtr(dwNumLinesArray);
+    GlobalFreePtr(dwNumPhonesArray);
+    GlobalFreePtr(hProviders);
+    GlobalFreePtr(lpfnProcAddress);
+    
+//    FreeLibrary32(ghInst32);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+TSPAPIPROC
+GetProcAddressHashed(int iProvider, DWORD iFunction, UINT nNumParms) // iFunction is 500-based
+    {
+
+    static  TSPAPIPROC DefaultLineTable[] = {
+                                   (TSPAPIPROC)TSPI_LineBlank1,
+                                   (TSPAPIPROC)TSPI_LineBlank2,
+                                   (TSPAPIPROC)TSPI_LineBlank3,
+                                   (TSPAPIPROC)TSPI_LineBlank4,
+                                   (TSPAPIPROC)TSPI_LineBlank5,
+                                   (TSPAPIPROC)TSPI_LineBlank6,
+                                   (TSPAPIPROC)TSPI_LineBlank7
+                                 };
+
+    static  TSPAPIPROC DefaultPhoneTable[] = {
+                                   (TSPAPIPROC)TSPI_PhoneBlank1,
+                                   (TSPAPIPROC)TSPI_PhoneBlank2,
+                                   (TSPAPIPROC)TSPI_PhoneBlank3,
+                                   (TSPAPIPROC)TSPI_PhoneBlank4,
+                                   (TSPAPIPROC)TSPI_PhoneBlank5,
+                                   (TSPAPIPROC)TSPI_PhoneBlank6,
+                                   (TSPAPIPROC)TSPI_PhoneBlank7
+                                 };
+
+    TSPAPIPROC *pfn;
+    TSPAPIPROC *FunctionTable;
+
+
+    //
+    // Find out if it's a phone function or a line function
+    //
+    if (
+          (iFunction >= TSPI_PHONECLOSE)
+        &&
+          (iFunction <= TSPI_PHONESETVOLUME)
+       )
+    {
+       //
+       // It's a phone function
+       //
+       FunctionTable = DefaultPhoneTable;
+    }
+    else
+    {
+       //
+       // It's a line function
+       //
+       FunctionTable = DefaultLineTable;
+    }
+
+    if ( nNumParms > (sizeof(DefaultLineTable)/sizeof(TSPAPIPROC)) )
+    {
+       DBGOUT((1, ">Num funcs function was requested!"));
+       return 0;
+    }
+
+    pfn = &lpfnProcAddress[(iProvider*TSPI_PROC_LAST)+(iFunction-TSPI_PROC_BASE)];
+
+    if( NULL == *pfn )
+    {
+        *pfn = (TSPAPIPROC)GetProcAddress(
+                                           hProviders[iProvider],
+                                           (LPCSTR)iFunction
+                                         );
+
+        //
+        // Did it fail?
+        //
+        if( NULL == *pfn )
+        {
+           *pfn = FunctionTable[ nNumParms - 1 ];
+        }
+    }
+
+    return *pfn;
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+int iProviderFromDeviceID(DWORD dwDeviceID)
+    {
+    DWORD dwFirstDeviceIDonProvider = gdwLineDeviceIDBase;
+    int iProvider = 0;
+
+    // seeks the correct provider for this line
+    while(dwDeviceID >= dwFirstDeviceIDonProvider + dwNumLinesArray[iProvider])
+        {
+        dwFirstDeviceIDonProvider += dwNumLinesArray[iProvider];
+        ++iProvider;
+        }
+
+    return iProvider;
+    }
+
+
+//
+// ----------------------- 32-bit callback shells -----------------------------
+//
+
+
+//
+// We load up dwData with the 32bit callback address.
+//
+
+/* LPARAM of WM_COPYDATA */                  /* ;Internal NT */
+typedef struct tagCOPYDATASTRUCT             /* ;Internal NT */
+{                                            /* ;Internal NT */
+   DWORD   dwData;                           /* ;Internal NT */
+   DWORD   cbData;                           /* ;Internal NT */
+   LPSTR   lpData;                           /* ;Internal NT */
+} COPYDATASTRUCT, FAR *LPCOPYDATASTRUCT;     /* ;Internal NT */
+
+
+
+LINEEVENT PASCAL __loadds __export LineEventProc16(
+    HTAPILINE htLine,
+    HTAPICALL htCall,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+   DWORD LineEventStruct[6+1];
+
+   COPYDATASTRUCT cds = { 0,
+                          sizeof(LineEventStruct),
+                          (LPSTR)&LineEventStruct
+                        };
+
+
+DBGOUT((1,  "Line event callback"));
+DBGOUT((11, "  htLine  =0x%08lx", (DWORD)htLine));
+DBGOUT((11, "    (Mapping htLine to 0x%08lx)", LineEventStruct[1]));
+DBGOUT((11, "  htCall  =0x%08lx", (DWORD)htCall));
+DBGOUT((11, "  dwMsg   =0x%08lx", dwMsg));
+DBGOUT((11, "  dwParam1=0x%08lx", dwParam1));
+DBGOUT((11, "  dwParam2=0x%08lx", dwParam2));
+DBGOUT((11, "  dwParam3=0x%08lx", dwParam3));
+
+   cds.dwData = (DWORD)glpLineEventProc32;
+
+   LineEventStruct[0] = CALLBACK_LINEEVENT;
+   LineEventStruct[1] = (DWORD)htLine;
+   LineEventStruct[2] = (DWORD)htCall;
+   LineEventStruct[3] = dwMsg;
+   LineEventStruct[4] = dwParam1;
+   LineEventStruct[5] = dwParam2;
+   LineEventStruct[6] = dwParam3;
+
+
+   if (!IsBadReadPtr(htLine, sizeof(MYLINE)) )
+   {
+      LineEventStruct[1] = (DWORD)((LPMYLINE)htLine)->htLine;
+   }
+#if DBG
+   else
+   {
+      TSP3216SDebugString((1, "But the htLine was BAD!!!!"));
+      //return (LINEERR_INVALPARAM);
+      return LINEERR_INVALPOINTER;
+   }
+#endif
+
+
+
+   switch (dwMsg)
+   {
+      case LINE_LINEDEVSTATE:
+      {
+         TSP3216SDebugString((2, "Got a LINE_LINEDEVSTATE msg"));
+      }
+      break;
+
+
+      case LINE_NEWCALL:
+      {
+         LPMYCALL lpmCall;
+         LPMYLINE lpmLine;
+         int iProvider;
+         HDRVLINE REALhdLine;
+
+         TSP3216SDebugString((2, "Got a LINE_NEWCALL"));
+
+
+         lpmLine = (MYLINE *)htLine;
+         iProvider = lpmLine->iProvider;
+         REALhdLine = lpmLine->hdLine;
+
+
+         lpmCall = (MYCALL *)GlobalAllocPtr(GPTR, sizeof(MYCALL));
+
+         if(!lpmCall)
+         {
+            TSP3216SDebugString((1, "GlobalAlloc failed for hCall!"));
+            return LINEERR_NOMEM;
+
+         }
+
+         lpmCall->iProvider  = iProvider;
+         lpmCall->dwDeviceID = lpmLine->dwDeviceID;
+
+
+         //
+         // Tell TAPI that _our_ hCall is the real one...
+         // (and save the one from the SP)
+         //
+         lpmCall->hdCall    = (HDRVCALL)dwParam1;
+         LineEventStruct[4] = (DWORD)lpmCall;
+
+//         //
+//         // Give TAPI a pointer to _our_ mem to write _it's_ handle
+//         //
+//         *(LPHTAPICALL)dwParam2 = lpmCall;
+//         LineEventStruct[5] = &(lpmCall->htCall);
+
+      }
+      break;
+
+   }
+
+
+
+
+   SendMessage( ghWnd, WM_COPYDATA, NULL, (LPARAM)&cds );
+
+#if DBG
+   if ( LINE_NEWCALL == dwMsg )
+   {
+      DBGOUT((11, "Returned htCall=0x%08lx", *((LPDWORD)dwParam2) ));
+   }
+#endif
+
+}
+
+
+PHONEEVENT PASCAL __loadds __export PhoneEventProc16(
+    HTAPIPHONE htPhone,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+   DWORD PhoneEventStruct[5+1];
+
+   COPYDATASTRUCT cds = { 0,
+                          sizeof(PhoneEventStruct),
+                          (LPSTR)&PhoneEventStruct
+                        };
+
+
+DBGOUT((1, "Phone event callback"));
+DBGOUT((11, "  htPhone =0x%08lx", (DWORD)htPhone));
+DBGOUT((11, "  dwMsg   =0x%08lx", dwMsg));
+DBGOUT((11, "  dwParam1=0x%08lx", dwParam1));
+DBGOUT((11, "  dwParam2=0x%08lx", dwParam2));
+DBGOUT((11, "  dwParam3=0x%08lx", dwParam3));
+
+
+   cds.dwData = (DWORD)glpPhoneEventProc32;
+
+   PhoneEventStruct[0] = CALLBACK_PHONEEVENT;
+   PhoneEventStruct[1] = (DWORD)htPhone;
+   PhoneEventStruct[2] = dwMsg;
+   PhoneEventStruct[3] = dwParam1;
+   PhoneEventStruct[4] = dwParam2;
+   PhoneEventStruct[5] = dwParam3;
+
+   SendMessage( ghWnd, WM_COPYDATA, NULL, (LPARAM)&cds );
+
+   return 0;
+}
+
+
+
+
+
+ASYNC_COMPLETION PASCAL __export __loadds AsyncCompletionProc16(DRV_REQUESTID dwRequestID,
+                                             LONG lResult)
+{
+   DWORD AsyncCompletionStruct[2+1];
+
+   COPYDATASTRUCT cds = { 0,
+                          sizeof(AsyncCompletionStruct),
+                          (LPSTR)&AsyncCompletionStruct
+                        };
+
+
+DBGOUT((1, "Async completion callback"));
+DBGOUT((11, "  dwRequestID=0x%08lx", dwRequestID));
+DBGOUT((11, "  lResult    =0x%08lx", lResult));
+
+
+   if ( BOGUS_REQUEST_ID == dwRequestID )
+   {
+      DBGOUT((2, "   This is a reply we should ignore"));
+      //BUGBUG: maybe: If there's an error returned, should we return that?
+      return 0;
+   }
+
+   cds.dwData = (DWORD)glpAsyncCompletionProc32;
+
+   AsyncCompletionStruct[0] = CALLBACK_ASYNCCOMPLETION;
+   AsyncCompletionStruct[1] = dwRequestID;
+   AsyncCompletionStruct[2] = lResult;
+
+
+   SendMessage( ghWnd, WM_COPYDATA, NULL, (LPARAM)&cds );
+}
+
+
+
+LINEEVENT PASCAL __loadds __export LineCreateProc16(
+    HTAPILINE htLine,
+    HTAPICALL htCall,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+   DWORD LineCreateStruct[6+1];
+
+   COPYDATASTRUCT cds = { 0,
+                          sizeof(LineCreateStruct),
+                          (LPSTR)&LineCreateStruct
+                        };
+
+
+DBGOUT((1, "Line Create callback"));
+
+   cds.dwData = (DWORD)glpLineCreateProc32;
+
+   LineCreateStruct[0] = CALLBACK_LINECREATE;
+   LineCreateStruct[1] = (DWORD)htLine;
+   LineCreateStruct[2] = (DWORD)htCall;
+   LineCreateStruct[3] = dwMsg;
+   LineCreateStruct[4] = dwParam1;
+   LineCreateStruct[5] = dwParam2;
+   LineCreateStruct[6] = dwParam3;
+
+
+   SendMessage( ghWnd, WM_COPYDATA, NULL, (LPARAM)&cds );
+
+   return 0;
+}
+
+
+
+PHONEEVENT PASCAL __loadds __export PhoneCreateProc16(
+    HTAPIPHONE htPhone,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3
+    )
+{
+
+   DWORD PhoneCreateStruct[5 + 1];
+
+   COPYDATASTRUCT cds = { 0,
+                          sizeof(PhoneCreateStruct),
+                          (LPSTR)&PhoneCreateStruct
+                        };
+
+
+DBGOUT((1, "Phone Create callback"));
+
+   cds.dwData = (DWORD)glpPhoneCreateProc32;
+
+   PhoneCreateStruct[0] = CALLBACK_PHONECREATE;
+   PhoneCreateStruct[1] = (DWORD)htPhone;
+   PhoneCreateStruct[2] = dwMsg;
+   PhoneCreateStruct[3] = dwParam1;
+   PhoneCreateStruct[4] = dwParam2;
+   PhoneCreateStruct[5] = dwParam3;
+
+
+   SendMessage( ghWnd, WM_COPYDATA, NULL, (LPARAM)&cds );
+
+   return 0;
+}
+
+
+
+//
+// -------------------- TSPIAPI TSPI_line functions ---------------------------
+//
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineAccept(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+{
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineAccept"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEACCEPT, 4))(
+                  dwRequestID,
+                  REALhdCall,
+                  lpsUserUserInfo,
+                  dwSize);
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HDRVCALL            hdConsultCall
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdConfCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    LPMYCALL lpmConsultCall = (MYCALL *)hdConsultCall;
+    HDRVCALL REALhdConsultCall = lpmConsultCall->hdCall;
+
+
+    TSP3216SDebugString((2, "Entering TSPI_lineAddToConference"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEADDTOCONFERENCE,3))(
+                  dwRequestID,
+                  REALhdCall,
+                  REALhdConsultCall);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineAnswer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineAnswer"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEANSWER, 4))(
+                           dwRequestID,
+                           REALhdCall,
+                           lpsUserUserInfo,
+                           dwSize);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineBlindTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode)
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineBlindTransfer"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEBLINDTRANSFER, 4))(
+                           dwRequestID,
+                           REALhdCall,
+                           lpszDestAddress,
+                           dwCountryCode
+                           );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineClose(
+    HDRVLINE            hdLine
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineClose"));
+
+    GlobalFreePtr((LPVOID)lpmLine);
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINECLOSE, 1))(REALhdLine);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineCloseCall(
+    HDRVCALL            hdCall
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineCloseCall"));
+
+    GlobalFreePtr((LPVOID)lpmCall);
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINECLOSECALL, 1))(REALhdCall);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineCompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwCompletionID,
+    DWORD               dwCompletionMode,
+    DWORD               dwMessageID
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineCompleteCall"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINECOMPLETECALL, 5))(
+                   dwRequestID,
+                   REALhdCall,
+                   lpdwCompletionID,
+                   dwCompletionMode,
+                   REALhdCall
+                 );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineCompleteTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVCALL            hdConsultCall,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    DWORD               dwTransferMode
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    LPMYCALL lpmConsultCall = (MYCALL *)hdConsultCall;
+    HDRVCALL REALhdConsultCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineCompleteTransfer"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+
+// NEED TO DO the work for lphdConfCall
+//
+//    return (* GetProcAddressHashed(iProvider, TSPI_LINECOMPLETETRANSFER, 5))(
+//                   dwRequestID,
+//                   REALhdCall,
+//                   lpdwCompletionID,
+//                   dwCompletionMode,
+//                   REALhdCall
+//                 );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineConditionalMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineConditionalMediaDetection"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_LINECONDITIONALMEDIADETECTION, 3))(
+                       REALhdLine,
+                       dwMediaModes,
+                       lpCallParams);
+
+    TSP3216SDebugString((2, "Leaving TSPI_lineConditionalMediaDetection"));
+    return lResult;
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+
+    int iProvider;
+
+#if DBG
+    LONG lResult = 0;
+#endif
+
+
+    TSP3216SDebugString((2, "Entering TSPI_lineConfigDialog"));
+    TSP3216SDebugString((11, "  dwDeviceID=0x%08lx", dwDeviceID));
+    TSP3216SDebugString((11, "  hwndOwner=0x%08lx", (DWORD)hwndOwner));
+    TSP3216SDebugString((11, "  lpszDeviceClass=0x%08lx", lpszDeviceClass));
+#if DBG
+    if ( !IsBadStringPtr(lpszDeviceClass, 1) )
+       TSP3216SDebugString((11, "    *lpszDeviceClass=[%s]", lpszDeviceClass));
+#endif
+
+_asm int 1;
+
+    iProvider = iProviderFromDeviceID(dwDeviceID);
+
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+           (* GetProcAddressHashed(iProvider, TSPI_LINECONFIGDIALOG, 3))(
+                     dwDeviceID,
+                     hwndOwner,
+                     lpszDeviceClass
+                     );
+
+#if DBG
+    return lResult;
+#endif
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineConfigDialogEdit(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass,
+    LPVOID              const lpDeviceConfigIn,
+    DWORD               dwSize,
+    LPVARSTRING         lpDeviceConfigOut
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineConfigDialogEdit"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineDevSpecific"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineDevSpecificFeature(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwFeature,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineDevSpecificFeature"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineDial(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineDial"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDIAL, 4))(
+        dwRequestID,
+        REALhdCall,
+        lpszDestAddress,
+        dwCountryCode
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineDrop(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineDrop"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDROP, 4))(
+        dwRequestID,
+        REALhdCall,
+        lpsUserUserInfo,
+        dwSize
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineDropOnClose(
+    HDRVCALL            hdCall
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineDropOnClose"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEDROPONCLOSE, 1))(
+        REALhdCall
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineDropNoOwner(
+    HDRVCALL            hdCall
+    )
+{
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSPAPIPROC *pfn;
+    LONG lResult;
+
+
+    TSP3216SDebugString((2, "Entering TSPI_lineDropNoOwner"));
+
+
+    pfn = (TSPAPIPROC)GetProcAddressHashed(iProvider, TSPI_LINEDROPNOOWNER, 1);
+
+    if (pfn == (TSPAPIPROC)TSPI_LineBlank1)
+    {
+       lResult = (*pfn)( REALhdCall );
+    }
+    else
+    {
+      TSP3216SDebugString((4, "  This SP does not export DROPNOOWNER, so we'll call LINEDROP"));
+
+      lResult = (* GetProcAddressHashed(iProvider, TSPI_LINEDROP, 4))( 
+                  (DWORD) BOGUS_REQUEST_ID,
+                  (DWORD) REALhdCall,
+                  (DWORD) NULL,
+                  (DWORD) 0
+               );
+
+      //
+      // Did we get an error back sync?
+      //
+      if ( 
+            (lResult < 0)
+          &&
+            (lResult != BOGUS_REQUEST_ID)
+         )
+      {
+         //
+         // Yup. Return it.
+         //
+      }
+      else
+      {
+         //
+         // No, we got back the req id.  Return success.
+         //
+         lResult = 0;
+      }
+    }
+
+    TSP3216SDebugString((3, "Leaving TSPI_lineDropNoOwner,  return code=0x%08lx", lResult));
+    return lResult;
+}
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineForward(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               bAllAddresses,
+    DWORD               dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD               dwNumRingsNoAnswer,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineForward"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGatherDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitModes,
+    LPSTR               lpsDigits,
+    DWORD               dwNumDigits,
+    LPCSTR              lpszTerminationDigits,
+    DWORD               dwFirstDigitTimeout,
+    DWORD               dwInterDigitTimeout
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineGatherDigits"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGenerateDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwDigitMode,
+    LPCSTR              lpszDigits,
+    DWORD               dwDuration
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2,  "Entering TSPI_lineGenerateDigits"));
+    TSP3216SDebugString((11, "  hdCall      =0x%08lx", hdCall));
+    TSP3216SDebugString((11, "  dwEndToEndID=0x%08lx", dwEndToEndID));
+    TSP3216SDebugString((11, "  lpszDigits  =0x%08lx", lpszDigits));
+    TSP3216SDebugString((12, "    *lpszDigits  =%s", lpszDigits));
+    TSP3216SDebugString((11, "  dwDuration  =0x%08lx", dwDuration));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGENERATEDIGITS, 5))(
+        REALhdCall,
+        dwEndToEndID,
+        dwDigitMode,
+        lpszDigits,
+        dwDuration );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGenerateTone(
+    HDRVCALL            hdCall,
+    DWORD               dwEndToEndID,
+    DWORD               dwToneMode,
+    DWORD               dwDuration,
+    DWORD               dwNumTones,
+    LPLINEGENERATETONE  const lpTones
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGenerateTone"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGENERATETONE, 6))(
+        REALhdCall,
+        dwEndToEndID,
+        dwToneMode,
+        dwDuration,
+        dwNumTones,
+        lpTones );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetAddressCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwAddressID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    DWORD dwFirstDeviceIDonProvider = gdwLineDeviceIDBase;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetAddressCaps"));
+
+    return(* GetProcAddressHashed(iProvider, TSPI_LINEGETADDRESSCAPS, 5))(
+        dwDeviceID,
+        dwAddressID,
+        dwTSPIVersion,
+        dwExtVersion,
+        lpAddressCaps
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetAddressID(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwAddressID,
+    DWORD               dwAddressMode,
+    LPCSTR              lpsAddress,
+    DWORD               dwSize
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetAddressID"));
+
+#if DBG
+    lResult =
+#else
+    return
+#endif
+               (* GetProcAddressHashed(iProvider, TSPI_LINEGETADDRESSID, 5))(
+                           REALhdLine,
+                           lpdwAddressID,
+                           dwAddressMode,
+                           lpsAddress,
+                           dwSize
+                           );
+
+#if DBG
+    TSP3216SDebugString((2, "Leaving TSPI_lineGetAddressID"));
+    return lResult;
+#endif
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetAddressStatus(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetAddressStatus"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_LINEGETADDRESSSTATUS, 3))(
+                          REALhdLine,
+                          dwAddressID,
+                          lpAddressStatus);
+
+    TSP3216SDebugString((2, "Leaving TSPI_lineGetAddressStatus"));
+    return lResult;
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetCallAddressID(
+    HDRVCALL            hdCall,
+    LPDWORD             lpdwAddressID
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetCallAddressID"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETCALLADDRESSID, 2))(
+                 REALhdCall,
+                 lpdwAddressID
+                 );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetCallInfo(
+    HDRVCALL            hdCall,
+    LPLINECALLINFO      lpCallInfo
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetCallInfo"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETCALLINFO, 2))(
+        REALhdCall,
+        lpCallInfo
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetCallStatus(
+    HDRVCALL            hdCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+    {
+
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetCallStatus"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEGETCALLSTATUS, 2))(
+        REALhdCall,
+        lpCallStatus
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPLINEDEVCAPS       lpLineDevCaps
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+    TSP3216SDebugString((2, "...debugmode..."));
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetDevCaps"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETDEVCAPS, 4))(
+        dwDeviceID,
+        dwTSPIVersion,
+        dwExtVersion,
+        lpLineDevCaps
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetDevCaps retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetDevConfig(
+    DWORD               dwDeviceID,
+    LPVARSTRING         lpDeviceConfig,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetDevConfig"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETDEVCONFIG, 3))(
+        dwDeviceID,
+        lpDeviceConfig,
+        lpszDeviceClass
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetDevConfig retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    TSPAPIPROC lpfn;
+#if DBG
+    LONG lResult = 0;
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetExtensionID"));
+
+    lpfn = (TSPAPIPROC)GetProcAddressHashed(iProvider, TSPI_LINEGETEXTENSIONID, 3);
+
+    if (lpfn != TSPI_LineBlank3)
+    {
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (*lpfn)(
+        dwDeviceID,
+        dwTSPIVersion,
+        lpExtensionID
+        );
+    }
+    else
+    {
+       TSP3216SDebugString((2, "  SP# %d does not support TSPI_lineGetExtensionID. (We'll fill in zeros.)", iProvider));
+
+       lpExtensionID->dwExtensionID0 = 0;
+       lpExtensionID->dwExtensionID1 = 0;
+       lpExtensionID->dwExtensionID2 = 0;
+       lpExtensionID->dwExtensionID3 = 0;
+    }
+
+
+
+#if DBG
+    TSP3216SDebugString((2, "Leaving TSPI_lineGetExtensionID retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+}
+
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetIcon"));
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+       (* GetProcAddressHashed(iProvider, TSPI_LINEGETICON, 3))(
+        dwDeviceID,
+        lpszDeviceClass,
+        lphIcon
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineGetIcon retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetID16(
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass    
+    )
+    {
+    LPMYLINE lpmLine = 0;
+    int iProvider = 0;
+    HDRVLINE REALhdLine = 0;
+
+    LONG lResult;
+
+    LPMYCALL lpmCall = 0;
+    HDRVCALL REALhdCall = 0;
+
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetID"));
+
+
+    switch ( dwSelect )
+    {
+       case LINECALLSELECT_LINE:
+       {
+          lpmLine = (MYLINE *)hdLine;
+          iProvider = lpmLine->iProvider;
+          REALhdLine = lpmLine->hdLine;
+       }
+       break;
+
+
+       case LINECALLSELECT_ADDRESS:
+       {
+          lpmLine = (MYLINE *)hdLine;
+          iProvider = lpmLine->iProvider;
+          REALhdLine = lpmLine->hdLine;
+       }
+       break;
+
+
+       case LINECALLSELECT_CALL:
+       {
+          lpmCall = (MYCALL *)hdCall;
+          REALhdCall = lpmCall->hdCall;
+       }
+       break;
+
+
+       default:
+          TSP3216SDebugString((2, "Leaving TSPI_lineGetID - 2lResult=0x%08lx", lResult));
+          return LINEERR_INVALPARAM;
+    }
+
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_LINEGETID, 6))(
+                          REALhdLine,
+                          dwAddressID,
+                          REALhdCall,
+                          dwSelect,
+                          lpDeviceID,
+                          lpszDeviceClass );
+
+    TSP3216SDebugString((2, "Leaving TSPI_lineGetID - lResult=0x%08lx", lResult));
+    return lResult;
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetLineDevStatus(
+    HDRVLINE            hdLine,
+    LPLINEDEVSTATUS     lpLineDevStatus
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetLineDevStatus"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_LINEGETLINEDEVSTATUS, 2))(
+                      REALhdLine,
+                      lpLineDevStatus);
+
+    TSP3216SDebugString((2, "Leaving TSPI_lineGetLineDevStatus"));
+    return lResult;
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineGetNumAddressIDs(
+    HDRVLINE            hdLine,
+    LPDWORD             lpdwNumAddressIDs
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+    LONG lResult;
+
+
+    TSP3216SDebugString((2, "Entering TSPI_lineGetNumAddressIDs"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_LINEGETNUMADDRESSIDS, 2))(
+                          REALhdLine,
+                          lpdwNumAddressIDs );
+
+    TSP3216SDebugString((2, "Leaving TSPI_lineGetNumAddressIDs - returning 0x%08lx", lResult));
+    return lResult;
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineHold"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEHOLD, 2))(
+        dwRequestID,
+        REALhdCall
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineMakeCall16(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    LPMYCALL lpmCall;
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineMakeCall16"));
+    DBGOUT((11, "  dwRequestID      = 0x%08lx", dwRequestID));
+    DBGOUT((11, "  *lpszDestAddress = [%s]", lpszDestAddress));
+    DBGOUT((11, "  dwCountryCode    = 0x%08lx", dwCountryCode));
+
+    lpmCall = (MYCALL *)GlobalAllocPtr(GPTR, sizeof(MYCALL));
+    if(!lpmCall)
+        return(LINEERR_NOMEM);
+
+    *lphdCall = (HDRVCALL)lpmCall;
+
+    lpmCall->htCall     = htCall;
+    lpmCall->iProvider  = iProvider;
+    lpmCall->dwDeviceID = lpmLine->dwDeviceID;
+
+    lResult = (* GetProcAddressHashed(lpmCall->iProvider, TSPI_LINEMAKECALL, 7))(
+        dwRequestID,
+        REALhdLine,
+        htCall, // WAS SECONDLY (HTAPICALL)lpmCall,  // Was htCall,
+        &(lpmCall->hdCall),
+        lpszDestAddress,
+        dwCountryCode,
+        lpCallParams
+        );
+
+    TSP3216SDebugString((2, "Leaving TSPI_lineMakeCall16 - returning 0x%08lx", lResult));
+    return lResult;
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineMonitorDigits(
+    HDRVCALL            hdCall,
+    DWORD               dwDigitModes
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineMonitorDigits"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEMONITORDIGITS, 2))(
+        REALhdCall,
+        dwDigitModes
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineMonitorMedia(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaModes
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineMonitorMedia"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEMONITORMEDIA, 2))(
+        REALhdCall,
+        dwMediaModes
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineMonitorTones(
+    HDRVCALL            hdCall,
+    DWORD               dwToneListID,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD               dwNumEntries
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineMonitorTones"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINEMONITORTONES, 4))(
+        REALhdCall,
+        dwToneListID,
+        lpToneList,
+        dwNumEntries
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+    {
+
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_lineNegotiateExtVersion"));
+
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+        (* GetProcAddressHashed(iProvider, TSPI_LINENEGOTIATEEXTVERSION, 5))(
+        dwDeviceID,
+        dwTSPIVersion,
+        dwLowVersion,
+        dwHighVersion,
+        lpdwExtVersion
+        );
+
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineNegotiateExeVersion retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineNegotiateTSPIVersion"));
+
+//BUGBUG Need to call to service providers and keep track of their
+//       versions, no?
+
+    *lpdwTSPIVersion = TAPI_CUR_VER;
+    
+    return(0);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineOpen(
+    DWORD               dwDeviceID,
+    HTAPILINE           htLine,
+    LPHDRVLINE          lphdLine,
+    DWORD               dwTSPIVersion,
+    LINEEVENT           lpfnEventProc
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    LPMYLINE lpmLine;
+#if DBG
+    LONG lResult;
+#endif
+
+    TSP3216SDebugString((2,  "Entering TSPI_lineOpen"));
+    TSP3216SDebugString((11, "  dwDeviceID   =0x%08lx", dwDeviceID));
+    TSP3216SDebugString((11, "  htLine       =0x%08lx", htLine));
+    TSP3216SDebugString((11, "  lphdLine     =0x%08lx", lphdLine));
+    TSP3216SDebugString((11, "  dwTSPIVersion=0x%08lx", dwTSPIVersion));
+    TSP3216SDebugString((11, "  lpfnEventProc=0x%08lx", lpfnEventProc));
+
+
+    glpLineEventProc32 = lpfnEventProc;
+
+
+    lpmLine = (MYLINE *)GlobalAllocPtr(GPTR, sizeof(MYLINE));
+    if(!lpmLine)
+        return(LINEERR_NOMEM);
+
+    *lphdLine = (HDRVLINE)lpmLine;
+
+    lpmLine->iProvider = iProvider;
+    lpmLine->dwDeviceID = dwDeviceID;
+    lpmLine->htLine = htLine;
+    lpmLine->lpfnEventProc = lpfnEventProc;
+
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+
+       (* GetProcAddressHashed(iProvider, TSPI_LINEOPEN, 5))(
+        dwDeviceID,
+        (HTAPILINE)lpmLine, // was htLine
+        &(lpmLine->hdLine),
+        dwTSPIVersion,
+        LineEventProc16
+        );
+
+#if DBG
+    DBGOUT((2, "Leaving TSPI_lineOpen retcode=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_linePark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwParkMode,
+    LPCSTR              lpszDirAddress,
+    LPVARSTRING         lpNonDirAddress
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_linePark"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_linePickup(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress,
+    LPCSTR              lpszGroupID
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_linePickup"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_linePrepareAddToConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_linePrepareAddToConference"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineRedirect(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpszDestAddress,
+    DWORD               dwCountryCode
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineRedirect"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineRemoveFromConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineRemoveFromConference"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSecureCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSecureCall"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSelectExtVersion(
+    HDRVLINE            hdLine,
+    DWORD               dwExtVersion
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSelectExtVersion"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSendUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    LPCSTR              lpsUserUserInfo,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSendUserUserInfo"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetAppSpecific(
+    HDRVCALL            hdCall,
+    DWORD               dwAppSpecific
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineSetAppSpecific"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESETAPPSPECIFIC, 2))(
+        REALhdCall,
+        dwAppSpecific
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetCallParams(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    DWORD               dwBearerMode,
+    DWORD               dwMinRate,
+    DWORD               dwMaxRate,
+    LPLINEDIALPARAMS    const lpDialParams
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineSetCallParams"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESETCALLPARAMS, 6))(
+        dwRequestID,
+        REALhdCall,
+        dwBearerMode,
+        dwMinRate,
+        dwMaxRate,
+        lpDialParams
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetCurrentLocation(
+    DWORD               dwLocation
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSetCurrentLocation"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetDefaultMediaDetection(
+    HDRVLINE            hdLine,
+    DWORD               dwMediaModes
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineSetDefaultMediaDetection"));
+
+    return (* GetProcAddressHashed(
+            iProvider,
+            TSPI_LINESETDEFAULTMEDIADETECTION,
+            2
+            ))(REALhdLine, dwMediaModes);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetDevConfig(
+    DWORD               dwDeviceID,
+    LPVOID              const lpDeviceConfig,
+    DWORD               dwSize,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    DWORD dwFirstDeviceIDonProvider = gdwLineDeviceIDBase;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineSetDevConfig"));
+
+    return(* GetProcAddressHashed(iProvider, TSPI_LINESETDEVCONFIG, 4))(
+        dwDeviceID,
+        lpDeviceConfig,
+        dwSize,
+        lpszDeviceClass
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetMediaControl(
+    HDRVLINE                    hdLine,
+    DWORD                       dwAddressID,
+    HDRVCALL                    hdCall,
+    DWORD                       dwSelect,
+    LPLINEMEDIACONTROLDIGIT     const lpDigitList,
+    DWORD                       dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA     const lpMediaList,
+    DWORD                       dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE      const lpToneList,
+    DWORD                       dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD                       dwCallStateNumEntries
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSetMediaControl"));
+
+
+    // dwSelect!!!
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetMediaMode(
+    HDRVCALL            hdCall,
+    DWORD               dwMediaMode
+    )
+    {
+    LPMYCALL lpmCall = (MYCALL *)hdCall;
+    int iProvider = lpmCall->iProvider;
+    HDRVCALL REALhdCall = lpmCall->hdCall;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineSetMediaMode"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESETMEDIAMODE, 2))(
+        REALhdCall,
+        dwMediaMode
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetStatusMessages(
+    HDRVLINE            hdLine,
+    DWORD               dwLineStates,
+    DWORD               dwAddressStates
+    )
+    {
+    LPMYLINE lpmLine = (MYLINE *)hdLine;
+    int iProvider = lpmLine->iProvider;
+    HDRVLINE REALhdLine = lpmLine->hdLine;
+
+    TSP3216SDebugString((2, "Entering TSPI_lineSetStatusMessages"));
+
+    return (* GetProcAddressHashed(iProvider, TSPI_LINESETSTATUSMESSAGES, 3))(
+        REALhdLine,
+        dwLineStates,
+        dwAddressStates
+        );
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetTerminal(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HDRVCALL            hdCall,
+    DWORD               dwSelect,
+    DWORD               dwTerminalModes,
+    DWORD               dwTerminalID,
+    DWORD               bEnable
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSetTerminal"));
+
+    // dwSelect!!!
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetupConference(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HDRVLINE            hdLine,
+    HTAPICALL           htConfCall,
+    LPHDRVCALL          lphdConfCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    DWORD               dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSetupConference"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSetupTransfer(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall,
+    HTAPICALL           htConsultCall,
+    LPHDRVCALL          lphdConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSetupTransfer"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineSwapHold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdActiveCall,
+    HDRVCALL            hdHeldCall
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineSwapHold"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineUncompleteCall(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwCompletionID
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineUncompleteCall"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineUnhold(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineUnhold"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineUnpark(
+    DRV_REQUESTID       dwRequestID,
+    HDRVLINE            hdLine,
+    DWORD               dwAddressID,
+    HTAPICALL           htCall,
+    LPHDRVCALL          lphdCall,
+    LPCSTR              lpszDestAddress
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineUnpark"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+LONG
+TSPIAPI
+TSPI_lineReleaseUserUserInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVCALL            hdCall
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_lineReleaseUserUserInfo"));
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+
+//
+// ----------------------- TSPIAPI TSPI_phone functions -----------------------
+//
+
+LONG
+TSPIAPI
+TSPI_phoneClose(
+    HDRVPHONE           hdPhone
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneClose"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONECLOSE, 1))(
+                           REALhdPhone
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneClose - lResult=0x%08lx", lResult));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneConfigDialog(
+    DWORD               dwDeviceID,
+    HWND                hwndOwner,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneDevSpecific(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    LPVOID              lpParams,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneDevSpecific"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetButtonInfo(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetButtonInfo"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetData(
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              lpData,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetData"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDevCaps(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwExtVersion,
+    LPPHONECAPS         lpPhoneCaps
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetDevCaps"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETDEVCAPS, 4))(
+                           dwDeviceID,
+                       //BUGBUG What version to send down here?
+                           dwTSPIVersion,
+                       //BUGBUG What version to send down here?
+                           dwExtVersion,
+                           lpPhoneCaps
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetDevCaps"));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetDisplay(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDisplay
+    )
+    {
+       TSP3216SDebugString((2, "Entering TSPI_phoneGetDisplay"));
+
+       return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetExtensionID(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    LONG lResult;
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    FARPROC lpfn;
+
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetExtensionID"));
+
+
+    lpfn = GetProcAddressHashed(iProvider, TSPI_PHONEGETEXTENSIONID, 3);
+
+    //
+    // Does this service provider export this function?
+    //
+    if (lpfn != TSPI_PhoneBlank3)
+    {
+        lResult =  (* lpfn)(
+                           dwDeviceID,
+                           dwTSPIVersion,
+                           lpExtensionID
+                           );
+    }
+    else
+    {
+       //
+       // Nope. Fill it fulla rocks.
+       //
+       TSP3216SDebugString((2, "  SP# %ld does not support TSPI_phoneGetExtensionID. (We'll zero it)", (DWORD)iProvider));
+
+       lpExtensionID->dwExtensionID0 = 0;
+       lpExtensionID->dwExtensionID1 = 0;
+       lpExtensionID->dwExtensionID2 = 0;
+       lpExtensionID->dwExtensionID3 = 0;
+
+       lResult = 0;
+    }
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetExtensionID - lResult=0x%08lx",lResult));
+    return lResult;
+}
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetGain(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwGain
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetGain"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETGAIN, 3))(
+                           REALhdPhone,
+                           dwHookSwitchDev,
+                           lpdwGain
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetGain"));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetHookSwitch(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwHookSwitchDevs
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetHookSwitch"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETHOOKSWITCH, 2))(
+                           REALhdPhone,
+                           lpdwHookSwitchDevs
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetHoosSwitch"));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetIcon(
+    DWORD               dwDeviceID,
+    LPCSTR              lpszDeviceClass,
+    LPHICON             lphIcon
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetIcon"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETICON, 3))(
+                           dwDeviceID,
+                           lpszDeviceClass,
+                           lphIcon
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetIcon"));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetID16(
+    HDRVPHONE           hdPhone,
+    LPVARSTRING         lpDeviceID,
+    LPCSTR              lpszDeviceClass
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetID"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETID, 3))(
+                           REALhdPhone,
+                           lpDeviceID,
+                           lpszDeviceClass
+                           );
+
+//BUGBUG - Do we have to dupe the handle like on lineGetID?
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetID - lResult=0x%08lx",
+                            lResult));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetLamp(
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPDWORD             lpdwLampMode
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetLamp"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetRing(
+    HDRVPHONE           hdPhone,
+    LPDWORD             lpdwRingMode,
+    LPDWORD             lpdwVolume
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetRing"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetStatus(
+    HDRVPHONE           hdPhone,
+    LPPHONESTATUS       lpPhoneStatus
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetStatus"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETSTATUS, 2))(
+                           REALhdPhone,
+                           lpPhoneStatus
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetStatus - lResult=0x%08lx",
+                            lResult));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneGetVolume(
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    LPDWORD             lpdwVolume
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneGetVolume"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONEGETVOLUME, 3))(
+                           REALhdPhone,
+                           dwHookSwitchDev,
+                           lpdwVolume
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneGetVolume - lResult=0x%08lx",
+                            lResult));
+
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateExtVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwTSPIVersion,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwExtVersion
+    )
+    {
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneNegotiateExtVersion"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneNegotiateTSPIVersion(
+    DWORD               dwDeviceID,
+    DWORD               dwLowVersion,
+    DWORD               dwHighVersion,
+    LPDWORD             lpdwTSPIVersion
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneNegotiateTSPIVersion"));
+
+    *lpdwTSPIVersion = TAPI_CUR_VER;
+    
+    return(0);
+//    return (* GetProcAddressHashed(iProvider, TSPI_PHONEOPEN, 4))(
+//        dwDeviceID,
+//        dwLowVersion,
+//        dwHighVersion,
+//        lpdwTSPIVersion
+//        );
+//
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneOpen(
+    DWORD               dwDeviceID,
+    HTAPIPHONE          htPhone,
+    LPHDRVPHONE         lphdPhone,
+    DWORD               dwTSPIVersion,
+    PHONEEVENT          lpfnEventProc
+    )
+    {
+    int iProvider = iProviderFromDeviceID(dwDeviceID);
+    LPMYPHONE lpmPhone;
+#if DBG
+    LONG  lResult;
+#endif
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneOpen"));
+
+    glpPhoneEventProc32 = lpfnEventProc;
+
+    lpmPhone = (MYPHONE *)GlobalAllocPtr(GPTR, sizeof(MYPHONE));
+    if(!lpmPhone)
+        return(PHONEERR_NOMEM);
+
+    *lphdPhone = (HDRVPHONE)lpmPhone;
+
+    lpmPhone->iProvider = iProvider;
+    lpmPhone->dwDeviceID = dwDeviceID;
+    lpmPhone->htPhone = htPhone;
+    lpmPhone->lpfnEventProc = lpfnEventProc;
+
+#if DBG
+    lResult =
+#else
+    return 
+#endif
+    (* GetProcAddressHashed(iProvider, TSPI_PHONEOPEN, 5))(
+        dwDeviceID,
+        htPhone, //WAS SECONDLY  (HTAPIPHONE)lpmPhone, // was htPhone
+        &(lpmPhone->hdPhone),
+        dwTSPIVersion,
+        PhoneEventProc16
+        );
+
+#if DBG
+    TSP3216SDebugString((2, "Leaving TSPI_phoneOpen - lResult=0x%08lx", lResult));
+    return lResult;
+#endif
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSelectExtVersion(
+    HDRVPHONE           hdPhone,
+    DWORD               dwExtVersion
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneSelectExtVersion"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetButtonInfo(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    LPPHONEBUTTONINFO   const lpButtonInfo
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetButtonInfo"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetData(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwDataID,
+    LPVOID              const lpData,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetData"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetDisplay(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRow,
+    DWORD               dwColumn,
+    LPCSTR              lpsDisplay,
+    DWORD               dwSize
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetDisplay"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetGain(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwGain
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetGain"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONESETGAIN, 4))(
+                           dwRequestID,
+                           REALhdPhone,
+                           dwHookSwitchDev,
+                           dwGain
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneSetGain - lResult=0x%08lx",
+                            lResult));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetHookSwitch(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDevs,
+    DWORD               dwHookSwitchMode
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetHookSwitch"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONESETHOOKSWITCH, 4))(
+                           dwRequestID,
+                           REALhdPhone,
+                           dwHookSwitchDevs,
+                           dwHookSwitchMode
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneSetHookSwitch - lResult=0x%08lx",
+                            lResult));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetLamp(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwButtonLampID,
+    DWORD               dwLampMode
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetLamp"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetRing(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwRingMode,
+    DWORD               dwVolume
+    )
+    {
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetRing"));
+
+    return(THIS_PHONEFUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetStatusMessages(
+    HDRVPHONE           hdPhone,
+    DWORD               dwPhoneStates,
+    DWORD               dwButtonModes,
+    DWORD               dwButtonStates
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetStatusMessages"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONESETSTATUSMESSAGES, 4))(
+                           REALhdPhone,
+                           dwPhoneStates,
+                           dwButtonModes,
+                           dwButtonStates
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneSetStatusMessages"));
+    return lResult;
+    }
+
+
+LONG
+TSPIAPI
+TSPI_phoneSetVolume(
+    DRV_REQUESTID       dwRequestID,
+    HDRVPHONE           hdPhone,
+    DWORD               dwHookSwitchDev,
+    DWORD               dwVolume
+    )
+    {
+    LPMYPHONE lpmPhone = (MYPHONE *)hdPhone;
+    int iProvider = lpmPhone->iProvider;
+    HDRVPHONE REALhdPhone = lpmPhone->hdPhone;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_phoneSetVolume"));
+
+    lResult =  (* GetProcAddressHashed(iProvider, TSPI_PHONESETVOLUME, 4))(
+                           dwRequestID,
+                           REALhdPhone,
+                           dwHookSwitchDev,
+                           dwVolume
+                           );
+
+    TSP3216SDebugString((2, "Leaving TSPI_phoneSetVolume - lResult=0x%08lx",
+                            lResult));
+    return lResult;
+    }
+
+
+
+
+//
+// ----------------------- TSPIAPI TSPI_provider functions --------------------
+//
+
+LONG
+TSPIAPI
+TSPI_providerConfig(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerInit16(
+    DWORD               dwTSPIVersion,
+    DWORD               dwPermanentProviderID,
+    DWORD               dwLineDeviceIDBase,
+    DWORD               dwPhoneDeviceIDBase,
+    DWORD               dwNumLines,
+    DWORD               dwNumPhones,
+    ASYNC_COMPLETION    lpfnCompletionProc
+    )
+    {
+    int iProvider;
+    BOOL fAllFailed = TRUE;
+    LONG lResult;
+
+    TSP3216SDebugString((2, "Entering TSPI_providerInit"));
+DBGOUT((1, " Completion addr=0x%08lx", (DWORD)lpfnCompletionProc));
+
+    gdwLineDeviceIDBase = dwLineDeviceIDBase;
+    gdwPhoneDeviceIDBase = dwPhoneDeviceIDBase;
+
+    glpAsyncCompletionProc32 = lpfnCompletionProc;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        {
+        DBGOUT((2, "TSPI_providerInit initializing provider #%d", iProvider));
+
+        if(!(lResult = (* GetProcAddressHashed(iProvider, TSPI_PROVIDERINIT, 7))(
+            dwTSPIVersion,
+            dwPermanentProviderIDArray[iProvider],
+            dwLineDeviceIDBase,
+            dwPhoneDeviceIDBase,
+            dwNumLinesArray[iProvider],
+            dwNumPhonesArray[iProvider],
+            AsyncCompletionProc16
+            )))
+        {
+            fAllFailed = FALSE; // if one succeeded, they didn't ALL fail
+        }
+#if DBG
+        else
+        {
+           DBGOUT((1, " provider # %d failed TSPI_PROVIDERINIT err=0x%08lx",
+                   iProvider, lResult));
+        }
+#endif
+        
+        dwLineDeviceIDBase += dwNumLinesArray[iProvider];
+        dwPhoneDeviceIDBase += dwNumPhonesArray[iProvider];
+        }
+
+    if(fAllFailed)
+    {
+        DBGOUT((2, "TSPI_providerInit: all 16bit providers failed init!"));
+        return(LINEERR_OPERATIONFAILED);
+    }
+    else
+        return(ERR_NONE);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerInstall(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerRemove(
+    HWND                hwndOwner,
+    DWORD               dwPermanentProviderID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerShutdown16(
+    DWORD               dwTSPIVersion
+    )
+    {
+    int iProvider;
+
+    TSP3216SDebugString((2, "Entering TSPI_providerShutdown"));
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        (* GetProcAddressHashed(iProvider, TSPI_PROVIDERSHUTDOWN, 1))(
+            dwTSPIVersion
+            );
+
+    FreeAllMem();
+
+    return(ERR_NONE);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerEnumDevices16(
+    DWORD               dwPermanentProviderID,
+    LPDWORD             lpdwNumLines,
+    LPDWORD             lpdwNumPhones,
+    HPROVIDER           hProvider,
+    LINEEVENT           lpfnLineCreateProc,
+    PHONEEVENT          lpfnPhoneCreateProc,
+    HWND                hSecretWnd
+    )
+    {
+    int iProvider;
+
+    TSP3216SDebugString((2, "Entering TSPI_providerEnumDevices"));
+
+
+    ghWnd = hSecretWnd;
+
+    glpLineCreateProc32 = lpfnLineCreateProc;
+    glpPhoneCreateProc32 = lpfnPhoneCreateProc;
+
+
+    PostMessage( ghWnd, TSP3216L_MESSAGE, 1,2);
+
+    InitializeSPs();
+    gdwPPID = dwPermanentProviderID;
+    
+    *lpdwNumLines = 0;
+    *lpdwNumPhones = 0;
+
+    for(iProvider = 0; iProvider < NumProviders; ++iProvider)
+        {
+        TSPAPIPROC  lpfn;
+
+
+        lpfn = GetProcAddressHashed(iProvider, TSPI_PROVIDERENUMDEVICES, 6);
+
+DBGOUT((1, " TSPI_providerEnumDevices: provider #%d - lpfn=0x%08lx",
+                          iProvider, (DWORD)lpfn));
+
+        if (lpfn != TSPI_LineBlank6)
+           {
+              (*lpfn)(
+               dwPermanentProviderIDArray[iProvider],
+               &(dwNumLinesArray[iProvider]),
+               &(dwNumPhonesArray[iProvider]),
+               hProvider,
+               LineCreateProc16,
+               PhoneCreateProc16
+               );
+
+DBGOUT((1, "  provider=%d #lines= %ld  #phones= %ld",
+                   iProvider,
+                   dwNumLinesArray[iProvider],
+                   dwNumPhonesArray[iProvider] ));
+
+
+           (*lpdwNumLines) += dwNumLinesArray[iProvider];
+           (*lpdwNumPhones) += dwNumPhonesArray[iProvider];
+           }
+
+        }
+
+    DBGOUT((2, " TSPI_providerEnumDevices: #providers=%d #lines= %d  #phones= %d",
+            NumProviders,
+            *lpdwNumLines,
+            *lpdwNumPhones));
+
+    return(ERR_NONE);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerCreateLineDevice(
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+LONG
+TSPIAPI
+TSPI_providerCreatePhoneDevice(
+    DWORD               dwTempID,
+    DWORD               dwDeviceID
+    )
+    {
+
+    return(THIS_FUNCTION_UNDER_CONSTRUCTION);
+    }
+
+
+int CALLBACK
+LibMain(
+    HINSTANCE hDllInstance,
+    WORD wDataSeg,
+    WORD wHeapSize,
+    LPSTR lpszCmdLine
+    )
+    {
+
+#if DBG
+    OutputDebugString("TSP3216s: Libmain entered\r\n");
+#endif
+
+    ghThisInst = hDllInstance;
+
+    return(1); // success
+    }
+
+
+//int 
+//DllEntryPoint(
+//    HINSTANCE hDllInstance,
+//    WORD wDataSeg,
+//    WORD wHeapSize,
+//    LPSTR lpszCmdLine
+//    )
+
+
+BOOL FAR PASCAL __export  TapiThk_ThunkConnect16( LPSTR, LPSTR, WORD, DWORD);
+BOOL FAR PASCAL __export  TapiFThk_ThunkConnect16( LPSTR, LPSTR, WORD, DWORD);
+
+BOOL FAR PASCAL __export  Tapi32_ThunkConnect16( LPSTR, LPSTR, WORD, DWORD);
+
+
+BOOL FAR PASCAL __export DllEntryPoint(
+    DWORD dwReason,
+    WORD hInst,
+    WORD wDS,
+    WORD wHeapSize,
+    DWORD dwReserved1,
+    WORD dwReserved2
+    )
+    {
+//    static UINT nUseCount = 0;
+//    UINT n;
+
+
+    DBGOUT((1, "DllEntryPoint entered reason=%lx\r\n", dwReason));
+
+
+//    if ( dwReason == 0 )
+//       nUseCount--;
+
+    if ( dwReason == 1 )
+    {
+       TapiThk_ThunkConnect16( "TSP3216S.DLL", "TSP3216L.TSP", hInst, dwReason);
+       TapiFThk_ThunkConnect16( "TSP3216S.DLL", "TSP3216L.TSP", hInst, dwReason);
+
+       Tapi32_ThunkConnect16( "TSP3216S.DLL", "TSP3216L.TSP", hInst, dwReason);
+
+
+//       nUseCount++;
+    }
+
+//    if (dwReason == 0)
+//    {
+//       for ( n=0; n<NumProviders; n++)
+//       {
+//          FreeLibrary(hProviders[n]);
+//       }
+//    }
+
+
+    return(1); // success
+    }
+
+WORD CALLBACK _loadds
+NewData(
+    )
+    {
+    return (ghThisInst); // success
+    }
+
+DWORD CALLBACK _loadds
+NewData2(
+    )
+    {
+//    return (DWORD)&_TapiCallbackThunk;
+      return 0;
+    }
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.def b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.def
new file mode 100644
index 000000000..e4da6dac0
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.def
@@ -0,0 +1,132 @@
+LIBRARY     TSP3216s
+PROTMODE
+CODE        MOVEABLE DISCARDABLE
+DATA        PRELOAD
+
+EXPORTS
+        TSPI_lineAccept
+        TSPI_lineAddToConference
+        TSPI_lineAnswer
+        TSPI_lineBlindTransfer
+        TSPI_lineClose
+        TSPI_lineCloseCall
+        TSPI_lineCompleteCall
+        TSPI_lineCompleteTransfer
+        TSPI_lineConditionalMediaDetection
+        TSPI_lineConfigDialog
+        TSPI_lineDevSpecific
+        TSPI_lineDevSpecificFeature
+        TSPI_lineDial
+        TSPI_lineDrop
+        TSPI_lineForward
+        TSPI_lineGatherDigits
+        TSPI_lineGenerateDigits
+        TSPI_lineGenerateTone
+        TSPI_lineGetAddressCaps
+        TSPI_lineGetAddressID
+        TSPI_lineGetAddressStatus
+        TSPI_lineGetCallAddressID
+        TSPI_lineGetCallInfo
+        TSPI_lineGetCallStatus
+        TSPI_lineGetDevCaps
+        TSPI_lineGetDevConfig
+        TSPI_lineGetExtensionID
+        TSPI_lineGetIcon
+        TSPI_lineGetID16
+        TSPI_lineGetLineDevStatus
+        TSPI_lineGetNumAddressIDs
+        TSPI_lineHold
+        TSPI_lineMakeCall16
+        TSPI_lineMonitorDigits
+        TSPI_lineMonitorMedia
+        TSPI_lineMonitorTones
+        TSPI_lineNegotiateExtVersion
+        TSPI_lineNegotiateTSPIVersion
+        TSPI_lineOpen
+        TSPI_linePark
+        TSPI_linePickup
+        TSPI_linePrepareAddToConference
+        TSPI_lineRedirect
+        TSPI_lineRemoveFromConference
+        TSPI_lineSecureCall
+        TSPI_lineSelectExtVersion
+        TSPI_lineSendUserUserInfo
+        TSPI_lineSetAppSpecific
+        TSPI_lineSetCallParams
+        TSPI_lineSetDefaultMediaDetection
+        TSPI_lineSetDevConfig
+        TSPI_lineSetMediaControl
+        TSPI_lineSetMediaMode
+        TSPI_lineSetStatusMessages
+        TSPI_lineSetTerminal
+        TSPI_lineSetupConference
+        TSPI_lineSetupTransfer
+        TSPI_lineSwapHold
+        TSPI_lineUncompleteCall
+        TSPI_lineUnhold
+        TSPI_lineUnpark
+
+        TSPI_phoneClose
+        TSPI_phoneConfigDialog
+        TSPI_phoneDevSpecific
+        TSPI_phoneGetButtonInfo
+        TSPI_phoneGetData
+        TSPI_phoneGetDevCaps
+        TSPI_phoneGetDisplay
+        TSPI_phoneGetExtensionID
+        TSPI_phoneGetGain
+        TSPI_phoneGetHookSwitch
+        TSPI_phoneGetIcon
+        TSPI_phoneGetID16
+        TSPI_phoneGetLamp
+        TSPI_phoneGetRing
+        TSPI_phoneGetStatus 
+        TSPI_phoneGetVolume 
+        TSPI_phoneNegotiateExtVersion 
+        TSPI_phoneNegotiateTSPIVersion
+        TSPI_phoneOpen                
+        TSPI_phoneSelectExtVersion    
+        TSPI_phoneSetButtonInfo       
+        TSPI_phoneSetData             
+        TSPI_phoneSetDisplay          
+        TSPI_phoneSetGain             
+        TSPI_phoneSetHookSwitch       
+        TSPI_phoneSetLamp             
+        TSPI_phoneSetRing             
+        TSPI_phoneSetStatusMessages   
+        TSPI_phoneSetVolume           
+
+        TSPI_providerConfig           
+        TSPI_providerInit16           
+        TSPI_providerInstall          
+        TSPI_providerRemove           
+        TSPI_providerShutdown16
+
+        TSPI_providerEnumDevices16    
+        TSPI_lineDropOnClose          
+        TSPI_lineDropNoOwner          
+        TSPI_providerCreateLineDevice 
+        TSPI_providerCreatePhoneDevice
+        TSPI_lineSetCurrentLocation   
+        TSPI_lineConfigDialogEdit     
+        TSPI_lineReleaseUserUserInfo  
+
+        WEP @1 RESIDENTNAME
+        LibMain @2
+        DllEntryPoint @3 RESIDENTNAME
+
+; Table of vital pointers for 32-bit half of GDI thunks
+
+    NewData
+
+    TapiThk_ThunkData16
+    TapifThk_ThunkData16
+    Tapi32_ThunkData16
+
+;    TAPITHKCONNECTIONDATALS	      ;	@110        ;Internal
+;    FT_TAPIFTHKTHKCONNECTIONDATA      ;	@111	    ;Internal
+;    Tapi32ConnectionDataSL
+
+IMPORTS
+        C16ThkSL01 = KERNEL.631
+        ThunkConnect16 = KERNEL.651
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.h b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.h
new file mode 100644
index 000000000..92e2a786b
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.h
@@ -0,0 +1,55 @@
+/*  TSP3216S.H
+    Copyright 1995 (C) Microsoft Corporation
+
+    32-bit TAPI service provider to act as a cover for a system's 16-bit SPs
+
+    16-bit part: TSP3216S.DLL
+    32-bit part: TSP3216L.DLL
+
+    t-jereh 20-July-1995
+
+    TODO:
+    1) allow debug levels
+    2) if oom in InitializeSPs(), fail
+
+ */
+
+#define MAXBUFSIZE 256 /* maximum buffer size */
+
+#define ERR_NONE 0 /* success return value */
+
+#define TAPI_CUR_VER 0x00010004
+
+#define TSPI_PROC_LAST 103 /* there are TSPI functions from 500 to 602 */
+
+
+// structs
+
+typedef struct tagMYLINE
+    {
+    HDRVLINE hdLine;
+    int iProvider;
+    DWORD dwDeviceID;
+    LINEEVENT lpfnEventProc;
+    HTAPILINE htLine;
+    } MYLINE, FAR *LPMYLINE;
+
+
+typedef struct tagMYPHONE
+    {
+    HDRVPHONE hdPhone;
+    int iProvider;
+    DWORD dwDeviceID;
+    PHONEEVENT lpfnEventProc;
+    HTAPIPHONE htPhone;
+    } MYPHONE, FAR *LPMYPHONE;
+
+
+typedef struct tagMYCALL
+    {
+    HDRVCALL   hdCall;
+    int        iProvider;
+    DWORD      dwDeviceID;
+    HTAPICALL  htCall;
+
+    } MYCALL, FAR *LPMYCALL;
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.mak b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.mak
new file mode 100644
index 000000000..1eb4d9618
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.mak
@@ -0,0 +1,89 @@
+# Microsoft Visual C++ generated build script - Do not modify
+
+PROJ = TSP3216S
+DEBUG = 1
+PROGTYPE = 1
+CALLER = \WINDOWS\DIALER.EXE
+ARGS = 
+DLLS = \WINDOWS\SYSTEM\TAPI.DLL
+D_RCDEFINES = -d_DEBUG
+R_RCDEFINES = -dNDEBUG
+ORIGIN = MSVC
+ORIGIN_VER = 1.00
+PROJPATH = C:\ROOT\TELECOM\TAPI\DEV\SP\TSP3216\TSP3216S\
+USEMFC = 0
+CC = cl
+CPP = cl
+CXX = cl
+CCREATEPCHFLAG = 
+CPPCREATEPCHFLAG = 
+CUSEPCHFLAG = 
+CPPUSEPCHFLAG = 
+FIRSTC = TSP3216.C   
+FIRSTCPP =             
+RC = rc
+CFLAGS_D_WDLL = /nologo /G2 /W3 /Zi /ALw /Od /D "_DEBUG" /D "DEBUG" /D "DEBUG" /Fc /FR /GD /Fd"TSP3216.PDB"
+CFLAGS_R_WDLL = /nologo /W3 /ALw /O1 /D "NDEBUG" /FR /GD 
+LFLAGS_D_WDLL = /NOLOGO /ONERROR:NOEXE /NOD /PACKC:61440 /CO /NOE /ALIGN:16 /MAP:FULL
+LFLAGS_R_WDLL = /NOLOGO /ONERROR:NOEXE /NOD /PACKC:61440 /NOE /ALIGN:16 /MAP:FULL
+LIBS_D_WDLL = oldnames libw commdlg shell olecli olesvr ldllcew
+LIBS_R_WDLL = oldnames libw commdlg shell olecli olesvr ldllcew
+RCFLAGS = /nologo
+RESFLAGS = /nologo
+RUNFLAGS = 
+DEFFILE = TSP3216S.DEF
+OBJS_EXT = 
+LIBS_EXT = 
+!if "$(DEBUG)" == "1"
+CFLAGS = $(CFLAGS_D_WDLL)
+LFLAGS = $(LFLAGS_D_WDLL)
+LIBS = $(LIBS_D_WDLL)
+MAPFILE = nul
+RCDEFINES = $(D_RCDEFINES)
+!else
+CFLAGS = $(CFLAGS_R_WDLL)
+LFLAGS = $(LFLAGS_R_WDLL)
+LIBS = $(LIBS_R_WDLL)
+MAPFILE = nul
+RCDEFINES = $(R_RCDEFINES)
+!endif
+!if [if exist MSVC.BND del MSVC.BND]
+!endif
+SBRS = TSP3216S.SBR
+
+
+TSP3216S_DEP = c:\root\telecom\tapi\dev\inc\tapi.h \
+	c:\root\telecom\tapi\dev\inc\tspi.h \
+	c:\root\telecom\tapi\dev\sp\tsp3216\tsp3216s\tsp3216s.h \
+	\mstools\include\wownt16.h
+
+
+all:	$(PROJ).DLL $(PROJ).BSC
+
+TSP3216S.OBJ:	TSP3216S.C $(TSP3216S_DEP)
+	$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c TSP3216S.C
+
+
+$(PROJ).DLL::	TSP3216S.OBJ $(OBJS_EXT) $(DEFFILE)
+	echo >NUL @<<$(PROJ).CRF
+TSP3216S.OBJ +
+$(OBJS_EXT)
+$(PROJ).DLL
+$(MAPFILE)
+c:\msvc\lib\+
+$(LIBS)
+$(DEFFILE);
+<<
+	link $(LFLAGS) @$(PROJ).CRF
+	$(RC) $(RESFLAGS) $@
+	implib /nowep $(PROJ).LIB $(PROJ).DLL
+
+
+run: $(PROJ).DLL
+	$(PROJ) $(RUNFLAGS)
+
+
+$(PROJ).BSC: $(SBRS)
+	bscmake @<<
+/o$@ $(SBRS)
+<<
diff --git a/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.rc b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.rc
new file mode 100644
index 000000000..cde1aa013
--- /dev/null
+++ b/private/tapi/dev/sp/tsp3216/tsp3216s/tsp3216s.rc
@@ -0,0 +1,19 @@
+#include "windows.h"
+
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony API Thunk-o-matic"
+#define VER_INTERNALNAME_STR        "TSP3216S"
+#define VER_ORIGINALFILENAME_STR    "TSP3216S.DLL"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_DLL
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
diff --git a/private/tapi/dev/tapsrv.acf b/private/tapi/dev/tapsrv.acf
new file mode 100644
index 000000000..a85713d0a
--- /dev/null
+++ b/private/tapi/dev/tapsrv.acf
@@ -0,0 +1,5 @@
+[implicit_handle(handle_t hTapSrv)]
+interface tapsrv
+{
+
+}
diff --git a/private/tapi/dev/tapsrv.idl b/private/tapi/dev/tapsrv.idl
new file mode 100644
index 000000000..0a9d800a4
--- /dev/null
+++ b/private/tapi/dev/tapsrv.idl
@@ -0,0 +1,37 @@
+[ uuid(2F5F6520-CA46-1067-B319-00DD010662DA),
+  version(1.0),
+#ifdef __midl
+        ms_union,
+#endif // __midl
+  pointer_default(unique)
+]
+
+interface tapsrv
+
+{
+
+typedef [context_handle] void * PCONTEXT_HANDLE_TYPE;
+
+long
+ClientAttach(
+    [out]   PCONTEXT_HANDLE_TYPE *pphContext,
+    [in]    long    lProcessID,
+    [out]   long   *phAsyncEventsEvent,
+    [in, string]    wchar_t *pszDomainUser,
+    [in, string]    wchar_t *pszMachine
+    );
+
+void
+ClientRequest(
+    [in] PCONTEXT_HANDLE_TYPE phContext,
+    [in, out, length_is(*plUsedSize), size_is(lNeededSize)] char pBuffer[],
+    [in]        long    lNeededSize,
+    [in, out]   long   *plUsedSize
+    );
+
+void
+ClientDetach(
+    [in, out]   PCONTEXT_HANDLE_TYPE *pphContext
+    );
+
+}
diff --git a/private/tapi/dev/thunk/depend.mk b/private/tapi/dev/thunk/depend.mk
new file mode 100644
index 000000000..74a0d8f95
--- /dev/null
+++ b/private/tapi/dev/thunk/depend.mk
@@ -0,0 +1,3 @@
+.\thunk.obj: ..\thunk.c ..\thunk.h ..\..\inc\tapi.x
+
+.\tapi.res: ..\tapi.rc
diff --git a/private/tapi/dev/thunk/dirs b/private/tapi/dev/thunk/dirs
new file mode 100644
index 000000000..139597f9c
--- /dev/null
+++ b/private/tapi/dev/thunk/dirs
@@ -0,0 +1,2 @@
+
+
diff --git a/private/tapi/dev/thunk/makefil0 b/private/tapi/dev/thunk/makefil0
new file mode 100644
index 000000000..808bfc0fb
--- /dev/null
+++ b/private/tapi/dev/thunk/makefil0
@@ -0,0 +1,126 @@
+
+# TAPI.DLL thunk makefile
+#
+# Copyright (c) 1995, Microsoft Corporation
+#
+# History:
+#   Created.
+#
+
+
+!INCLUDE $(NTMAKEENV)\makefile.plt
+
+
+!IFDEF USEBUILD
+
+# If using BUILD.EXE, edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!ELSE
+
+.SUFFIXES:
+.SUFFIXES: .c   .asm .h   .inc .obj .lst .sys .exe .com .map .sym .def .lib .rc .res
+
+
+#!ifdef INCLUDE
+#INCS    =
+#!else
+INCS    = -I..\inc -I$(_NTDRIVE)$(_NTROOT)\private\mvdm\wow16\inc -I$(BASEDIR)\public\sdk\inc
+#!endif
+
+########## Path definition so we find 16 bit tools ##########
+# Also works around stupid bug in RC 3.1 that doesn't allow rcpp.err to be
+# in a directory that is greater than 128 chars down the path, even if
+# rc 3.1 is running as an OS/2 app.
+
+#PATH    = $(BASEDIR)\private\mvdm\tools16;$(PATH)
+PATH=..\tools16;$(PATH)
+
+# DEFINES = -DWOW -DDEBUG $(MVDMFLAGS)
+# DEFINES = -DWOW $(MVDMFLAGS)
+
+AOBJ    = -t $(DEFINES) $(INCS)
+
+CW16    = -ALw -G2sw -Os -W3 -Zd -Zp $(DEFINES) $(INCS)
+CW16B   = $(CW16) -B1 c1l.exe -B2 c2l.exe -B3 c3l.exe
+
+LINK    = /map /align:16
+
+!if "$(NTDEBUG)"!="" && "$(NTDEBUG)"!="retail" && "$(NTDEBUG)" != "ntsdnodbg"
+AOBJ    = $(AOBJ) -Zd
+CW16    = $(CW16) /Od /Oi
+LINK    = $(LINK) /LI
+!endif
+
+#!ifdef LIB
+#W16LIBS = snocrtd
+#!else
+#W16LIBS = ..\..\lib\snocrtd.lib
+#!endif
+
+
+.asm.obj:
+    masm $(AOBJ) $*;
+
+.asm.lst:
+    masm $(AOBJ) -l $*,nul,$*.lst;
+
+
+.c.obj:
+    ..\tools16\cl16 -c $(CW16) $*.c
+
+.c.lst:
+    ..\tools16\cl16 -c $(CW16) -Fonul -Fc$*.lst $*.c
+
+
+.def.lib:
+    implib $*.lib $*.def
+
+.map.sym:
+    mapsym $*
+
+.rc.res:
+    rc16 -r $(INCS) -fo $@ $*.rc
+
+
+all: tapi.dll tapi.sym
+    binplace tapi.dll tapi.sym
+
+clean: cleanup all
+
+cleanup:
+    if exist *.lrf del *.lrf
+    if exist *.obj del *.obj
+    if exist *.exe del *.exe
+    if exist *.map del *.map
+    if exist *.sym del *.sym
+    if exist *.drv del *.drv
+    if exist *.res del *.res
+
+
+thunk.obj thunk.lst: thunk.c thunk.h
+
+tapi.res: $*.rc
+
+tapi.lrf: makefil0
+    echo $(BASEDIR)\private\mvdm\wow16\lib\libentry.obj thunk >$@
+    echo $*.dll/align:16>>$@
+    echo $* $(LINK)>>$@
+#    echo $(BASEDIR)\private\mvdm\wow16\lib\libw.lib ..\..\lib\snocrtd.lib /map /nod>>$@
+#    echo $(BASEDIR)\private\mvdm\wow16\lib\ldllcew.lib 
+    echo $(BASEDIR)\private\mvdm\wow16\lib\ldllcew.lib libw.lib /map /nod>>$@
+    echo $*;>>$@
+
+tapi.dll tapi.map: thunk.obj \
+      $*.def $*.res $*.lrf
+    link16 @$*.lrf;
+    rc16 -t $*.res $*.dll
+#    if exist *.drv del *.drv
+#    ren $*.dll $@
+
+tapi.sym: $*.map
+    mapsym $*
+!ENDIF
diff --git a/private/tapi/dev/thunk/makefile b/private/tapi/dev/thunk/makefile
new file mode 100644
index 000000000..eb7bad4a7
--- /dev/null
+++ b/private/tapi/dev/thunk/makefile
@@ -0,0 +1,30 @@
+!if "$(OS)" == "Windows_NT"
+
+clean:
+  echo "Clean target null in this directory"
+
+!else
+
+##############################################################################
+#
+#   TAPI THUNK Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+#IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/dev/thunk/makefile.def b/private/tapi/dev/thunk/makefile.def
new file mode 100644
index 000000000..ceabc7744
--- /dev/null
+++ b/private/tapi/dev/thunk/makefile.def
@@ -0,0 +1,68 @@
+##############################################################################
+#
+#   tapi.dll Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+PATH=..\tools16;$(PATH)
+
+IS_OEM=TRUE
+MASM6=1
+IS_16 = TRUE
+C16ONLY=1
+
+BUILDDLL=1
+
+DEPENDNAME=..\depend.mk
+
+TARGETS=tapi.dll tapi.sym
+
+SRCDIR=..
+
+CLEANLIST=*.dll *.pdb
+
+#BUILD_COFF=1
+
+
+L16EXE=tapi.dll		# Name of exe.
+L16DEF=..\tapi.def              # Our def file.
+L16MAP=tapi.map		# Our map file.
+L16SYM=tapi.sym		# Our sym file.
+L16LIBSNODEP= \
+          ldllcew.lib \
+          libw.lib \
+          ..\w32sut16.lib
+
+L16RES=tapi.res	# Resource file.
+
+
+#C16SRCS=..\thunk.c
+#RCSRCS=..\tapi.rc
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L16OBJS=thunk.obj
+
+
+
+!include $(ROOT)\dev\master.mk
+
+
+CFLAGS=$(CFLAGS) -DCHICOBUILD=1 -Og -ALw /G3sw /Ow /W3 /Zi -DTAPI_CURRENT_VERSION=0x00010004
+#CFLAGS=$(CFLAGS) -ALw /G3sw /Ow /W3 /Zi -DCHICOBUILD=1
+#   cl /c /ALw /G2sw -Ow -W3 -Zp /Od /Oi /Zi thunk.c
+
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
+
+
+#   link thunk,$(TARGET).dll,nul,/NOE /COD /NOD:llibce ldllcew libw.lib w32sut16.lib,tapi.def
+#LFLAGS= /NOD /NOE /ALIGN:8 /NONULLS /PACKD /PACKF @tapi.crf
+
diff --git a/private/tapi/dev/thunk/tapi.def b/private/tapi/dev/thunk/tapi.def
new file mode 100644
index 000000000..2a13fefd9
--- /dev/null
+++ b/private/tapi/dev/thunk/tapi.def
@@ -0,0 +1,140 @@
+LIBRARY tapi
+
+EXETYPE WINDOWS
+
+CODE PRELOAD MOVEABLE DISCARDABLE
+DATA PRELOAD MOVEABLE
+
+HEAPSIZE 2048
+
+IMPORTS
+    kernel.LoadLibraryEx32W
+    kernel.FreeLibrary32W
+    kernel.GetProcAddress32W
+    kernel.CallProc32W
+
+EXPORTS
+    WEP @1 RESIDENTNAME
+    LibMain
+    Tapi16HiddenWndProc
+
+    lineAccept                      @82
+    lineAddToConference             @47
+    lineAnswer                      @103
+    lineBlindTransfer               @25
+    lineClose                       @78
+    lineCompleteCall                @76
+    lineCompleteTransfer            @73
+    lineConfigDialog                @12
+    lineDeallocateCall              @111
+    lineDevSpecific                 @21
+    lineDevSpecificFeature          @22
+    lineDial                        @29
+    lineDrop                        @23
+    lineForward                     @87
+    lineGatherDigits                @52
+    lineGenerateDigits              @105
+    lineGenerateTone                @80
+    lineGetAddressCaps              @71
+    lineGetAddressID                @104
+    lineGetAddressStatus            @60
+    lineGetCallInfo                 @97
+    lineGetCallStatus               @94
+    lineGetConfRelatedCalls         @72
+    lineGetDevCaps                  @116
+    lineGetDevConfig                @79
+    lineGetIcon                     @53
+    lineGetID                       @40
+    lineGetLineDevStatus            @49
+    lineGetNewCalls                 @34
+    lineGetNumRings                 @62
+    lineGetStatusMessages           @45
+    lineHandoff                     @11
+    lineHold                        @6
+    lineInitialize                  @33
+    lineMakeCall                    @32
+    lineMonitorDigits               @24
+    lineMonitorMedia                @15
+    lineMonitorTones                @31
+    lineNegotiateAPIVersion         @64
+    lineNegotiateExtVersion         @17
+    lineOpen                        @46
+    linePark                        @5
+    linePickup                      @102
+    linePrepareAddToConference      @50
+    lineRedirect                    @38
+    lineRemoveFromConference        @43
+    lineSecureCall                  @57
+    lineSendUserUserInfo            @63
+    lineSetAppSpecific              @88
+    lineSetCallParams               @2
+    lineSetCallPrivilege            @95
+    lineSetDevConfig                @107
+    lineSetMediaControl             @37
+    lineSetMediaMode                @115
+    lineSetNumRings                 @61
+    lineSetStatusMessages           @44
+    lineSetTerminal                 @108
+    lineSetupConference             @48
+    lineSetupTransfer               @65
+    lineShutdown                    @8
+    lineSwapHold                    @109
+    lineUncompleteCall              @41
+    lineUnhold                      @113
+    lineUnpark                      @77
+    phoneClose                      @119
+    phoneConfigDialog               @16
+    phoneDevSpecific                @9
+    phoneGetButtonInfo              @4
+    phoneGetData                    @93
+    phoneGetDevCaps                 @114
+    phoneGetDisplay                 @83
+    phoneGetGain                    @68
+    phoneGetHookSwitch              @27
+    phoneGetID                      @106
+    phoneGetIcon                    @74
+    phoneGetLamp                    @117
+    phoneGetRing                    @70
+    phoneGetStatus                  @39
+    phoneGetStatusMessages          @55
+    phoneGetVolume                  @59
+    phoneInitialize                 @35
+    phoneOpen                       @89
+    phoneNegotiateAPIVersion        @7
+    phoneNegotiateExtVersion        @14
+    phoneSetButtonInfo              @42
+    phoneSetData                    @92
+    phoneSetDisplay                 @98
+    phoneSetGain                    @67
+    phoneSetHookSwitch              @51
+    phoneSetLamp                    @118
+    phoneSetRing                    @69
+    phoneSetStatusMessages          @56
+    phoneSetVolume                  @54
+    phoneShutdown                   @26
+    tapiRequestMakeCall             @28
+    tapiRequestMediaCall            @101
+    tapiRequestDrop                 @112
+    tapiGetLocationInfo             @85
+    lineRegisterRequestRecipient    @10
+    lineGetRequest                  @86
+    lineSetCurrentLocation          @81
+    lineSetTollList                 @3
+    lineTranslateAddress            @19
+    lineGetTranslateCaps            @100
+
+; Tapi 1.1 extensions
+
+    lineTranslateDialog
+    lineGetCountry
+    lineGetAppPriority
+    lineSetAppPriority
+    lineAddProvider
+    lineConfigProvider
+    lineRemoveProvider
+    lineGetProviderList
+    lineReleaseUserUserInfo
+
+; Misc
+    LOpenDialAsst
+    LAddrParamsInited
diff --git a/private/tapi/dev/thunk/tapi.rc b/private/tapi/dev/thunk/tapi.rc
new file mode 100644
index 000000000..7f262b32c
--- /dev/null
+++ b/private/tapi/dev/thunk/tapi.rc
@@ -0,0 +1,25 @@
+#include "windows.h"
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+#if WINNT
+#include <ntverp.h>
+#else
+#include <version.h>
+#endif
+
+#define VER_FILEDESCRIPTION_STR     "Microsoft\256 Windows(TM) Telephony Server"
+#define VER_INTERNALNAME_STR        "tapi"
+#define VER_ORIGINALFILENAME_STR    "TAPI.DLL"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright \251 Microsoft Corporation 1995.  All Rights Reserved."
+
+#define VER_FILETYPE     VFT_APP
+#define VER_FILESUBTYPE  VFT2_UNKNOWN
+
+#include <common.ver>
+
+// /////////////////////////////////////////////////////////////////////////
+// /////////////////////////////////////////////////////////////////////////
+
+
diff --git a/private/tapi/dev/thunk/thunk.c b/private/tapi/dev/thunk/thunk.c
new file mode 100644
index 000000000..0e0a56434
--- /dev/null
+++ b/private/tapi/dev/thunk/thunk.c
@@ -0,0 +1,3771 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    thunk.c
+
+Abstract:
+
+    This module contains
+
+Author:
+
+    Dan Knudson (DanKn)    dd-Mmm-1995
+
+Revision History:
+
+--*/
+
+
+// BUGBUG? do we need a notifyregister proc in here to clean up after bad apps
+// BUGBUG how to clean up after apps that've closed w/o do a shutdown?
+
+
+#include <windows.h>
+
+#include <stdlib.h>
+//#include <malloc.h>
+
+#include <string.h>
+
+
+#define TAPI_CURRENT_VERSION 0x00010004
+
+//#include "..\inc\tapi.h"
+#include <tapi.h>
+
+#include "thunk.h"
+
+char gszWndClass[] = "TapiClient16Class";
+
+// BUGBUG
+
+//#define DBG
+
+#if DBG
+
+DWORD gdwDebugLevel;
+
+#define DBGOUT OutputDebugString
+#else
+
+#define DBGOUT //
+
+#endif
+
+int
+FAR
+PASCAL
+LibMain(
+    HINSTANCE hInst,
+    WORD wDataSeg,
+    WORD cbHeapSize,
+    LPSTR lpszCmdLine
+    )
+{
+    int     i;
+    WNDCLASS    wc;
+
+    DBGOUT ("Libmain entered\n");
+
+    //
+    //
+    //
+
+#if DBG
+
+    gdwDebugLevel = (DWORD) GetPrivateProfileInt(
+        "Debug",
+        "TapiDebugLevel",
+        0x0,
+        "Telephon.ini"
+        );
+
+#endif
+
+
+    //
+    // Save the hInst in a global
+    //
+
+    ghInst = hInst;
+
+
+    //
+    // Register a window class for windows used for signaling async
+    // completions & unsolicited events
+    //
+
+    wc.style         = 0;
+    wc.lpfnWndProc   = (WNDPROC) Tapi16HiddenWndProc;
+    wc.cbClsExtra    = 0;
+    wc.cbWndExtra    = 2 * sizeof(DWORD);
+    wc.hInstance     = hInst;
+    wc.hIcon         = NULL;
+    wc.hCursor       = NULL;
+    wc.hbrBackground = NULL;
+    wc.lpszMenuName  = NULL;
+    wc.lpszClassName = gszWndClass;
+
+    if (!RegisterClass (&wc))
+    {
+        DBGOUT ("RegisterClass() failed\n");
+    }
+
+
+    //
+    // Load tapi32.dll & Get all the proc pointers
+    //
+
+    ghLib = LoadLibraryEx32W ("tapi32.dll", NULL, 0);
+
+    for (i = 0; i < NUM_TAPI32_PROCS; i++)
+    {
+        gaProcs[i] = (MYPROC) GetProcAddress32W(
+                                                ghLib,
+                                                (LPCSTR)gaFuncNames[i]
+                                               );
+    }
+
+    // set the error mode.
+    // this has no effect on x86 platforms
+    // on RISC platforms, NT will fix
+    // alignment faults (at a cost of time)
+    {
+#define SEM_NOALIGNMENTFAULTEXCEPT  0x0004
+
+        DWORD   dwModule;
+        DWORD   dwFunc;
+
+        if ((dwModule = LoadLibraryEx32W("kernel32.dll",
+                                         NULL,
+                                         0)) == NULL)
+        {
+            DBGOUT("LoadLibraryEx32W on kernel32.dll failed\n");
+        }
+        else
+        {
+            if ((dwFunc = GetProcAddress32W(dwModule,
+                                            "SetErrorMode")) == NULL)
+            {
+                DBGOUT("GetProcAddress32W on SetErrorMode failed\n");
+            }
+            else
+            {
+                DBGOUT("Calling CallProcEx32W\n");
+
+                CallProcEx32W(1,
+                              0,
+                              dwFunc,
+                              (DWORD)SEM_NOALIGNMENTFAULTEXCEPT);
+            }
+
+            FreeLibrary32W(dwModule);
+        }
+    }
+
+    return TRUE;
+}
+
+
+int
+FAR
+PASCAL
+WEP(
+    int nParam
+    )
+{
+    FreeLibrary32W (ghLib);
+
+    return TRUE;
+}
+
+
+LRESULT
+CALLBACK
+Tapi16HiddenWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_ASYNCEVENT:
+    {
+        //
+        // This msg gets posted to us by tapi32.dll to alert us that
+        // there's a new callback msg available for the app instance
+        // associated with this window. "lParam" is an app instance
+        // context tapi32.dll-space.
+        //
+
+        LPTAPI_APP_DATA     pAppData = (LPTAPI_APP_DATA)
+                                GetWindowLong (hwnd, GWL_APPDATA);
+        TAPI16_CALLBACKMSG  msg;
+
+
+        pAppData->bPendingAsyncEventMsg = FALSE;
+
+        while ((*pfnCallProc2)(
+                    (DWORD) lParam,
+                    (DWORD) ((LPVOID)&msg),
+                    (LPVOID)gaProcs[GetTapi16CallbkMsg],
+                    0x1,
+                    2
+                    ))
+        {
+            if (pAppData->bPendingAsyncEventMsg == FALSE)
+            {
+                pAppData->bPendingAsyncEventMsg = TRUE;
+                PostMessage (hwnd, WM_ASYNCEVENT, wParam, lParam);
+
+// BUGBUG Tapi16HiddenWndProc: need to verify pAppData in case app calls
+//                             shutdown from callback?
+            }
+
+            (*(pAppData->lpfnCallback))(
+                msg.hDevice,
+                msg.dwMsg,
+                msg.dwCallbackInstance,
+                msg.dwParam1,
+                msg.dwParam2,
+                msg.dwParam3
+                );
+        }
+
+        break;
+    }
+    default:
+    {
+        return (DefWindowProc (hwnd, msg, wParam, lParam));
+    }
+    } // switch
+
+    return 0;
+}
+
+
+//
+// The following are the routines to thunk TAPI calls from 16-bit apps to
+// the 32-bit tapi32.dll. In general, this is done as follows:
+//
+//     CallProc32W(
+//         arg1,        // TAPI proc args
+//         ...,
+//         argN,
+//
+//         pfnTapi32,   // Pointer to the function in tapi32.dll
+//
+//         0x???,       // Bit mask indicating which args are pointers
+//                      //   that need to be mapped from a 16:16 address
+//                      //   to a 0:32 address. The least significant
+//                      //   bit corresponds to argN, and the Nth bit
+//                      //   corresponds to arg1.
+//                      //
+//                      //   For example, if arg1 & arg2 are pointers, and
+//                      //   arg3 is a DWORD, the the mask would be 0x6
+//                      //   (110 in binary, indicating arg1 & arg2 need to
+//                      //   be mapped)
+//
+//         N            // Number of TAPI proc args
+//         );
+//
+//
+// Since callbacks to 16-bit procs cannot be done directly by a 32-bit
+// module, we create a hidden window for each successful call to
+// lineInitialize and phoneInitialize, and tapi32.dll posts msgs to this
+// window when LINE_XXX & PHONE_XXX msgs become available for the client
+// process. The window then retrieves all the msgs parameters and calls
+// the 16-bit proc's callback function.
+//
+// Note that we swap the hLineApp & hPhoneApp returned by tapi32.dll with
+// the hidden window handle on the client proc side, and substitute the
+// window handle for the pointer to the callback function on the tapi32.dll
+// side. The former is done to make it easier to reference which window
+// belongs to which hLine/PhoneApp, and the latter is done to provide
+// tapi32.dll with a means of alerting us of callback msgs. (Tapi32.dll
+// distinguishes whether the lpfnCallback it is passed in
+// line/phoneInitialize is a pointer to a function of a window handle by
+// checking the high WORD- if it is 0xffff then it assumes lpfnCallback
+// is really a 16-bit proc's window handle.
+//
+
+#if DBG
+
+void
+LineResult(
+    char   *pszFuncName,
+    LONG    lResult
+    )
+{
+    if (gdwDebugLevel > 3)
+    {
+        char buf[80];
+
+        wsprintf (buf, "TAPI: line%s result=x%lx\n", pszFuncName, lResult);
+        DBGOUT (buf);
+    }
+}
+
+void
+PhoneResult(
+    char   *pszFuncName,
+    LONG    lResult
+    )
+{
+    if (gdwDebugLevel > 3)
+    {
+        char buf[80];
+
+        wsprintf (buf, "TAPI: phone%s result=x%lx\n", pszFuncName, lResult);
+        DBGOUT (buf);
+    }
+}
+
+void
+TapiResult(
+    char   *pszFuncName,
+    LONG    lResult
+    )
+{
+    if (gdwDebugLevel > 3)
+    {
+        char buf[80];
+
+        wsprintf (buf, "TAPI: tapi%s result=x%lx\n", pszFuncName, lResult);
+        DBGOUT (buf);
+    }
+}
+
+#else
+
+#define LineResult(arg1,arg2)
+#define PhoneResult(arg1,arg2)
+#define TapiResult(arg1,arg2)
+
+#endif
+
+
+LONG
+WINAPI
+xxxInitialize(
+    BOOL            bLine,
+    LPHLINEAPP      lphXxxApp,
+    HINSTANCE       hInstance,
+    LINECALLBACK    lpfnCallback,
+    LPCSTR          lpszAppName,
+    LPDWORD         lpdwNumDevs
+    )
+{
+    HWND            hwnd = NULL;
+    LONG            lResult;
+    char far       *lpszModuleNamePath = NULL;
+    char far       *lpszModuleName;
+    char far       *lpszFriendlyAndModuleName = NULL;
+    LPTAPI_APP_DATA pAppData = (LPTAPI_APP_DATA) NULL;
+
+#if DBG
+
+    if (bLine)
+    {
+        DBGOUT ("lineInitialize: enter\n");
+    }
+    else
+    {
+        DBGOUT ("phoneInitialize: enter\n");
+    }
+
+#endif
+
+    //
+    // Verify the ptrs
+    //
+
+    if (IsBadWritePtr (lphXxxApp, sizeof(HLINEAPP)) ||
+        IsBadCodePtr ((FARPROC) lpfnCallback) ||
+        (lpszAppName && IsBadStringPtr (lpszAppName,(UINT)TAPIMAXAPPNAMESIZE)))
+    {
+        lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER);
+        goto xxxInitialize_showResult;
+    }
+
+
+    //
+    // Create a string that looks like: "<friendly name>\0<module name>\0"
+    // (because i don't know if i can work with a 16-bit hInstance in tapi32)
+    //
+
+    if ((lpszModuleNamePath = (char far *) malloc (260)))
+    {
+        if (GetModuleFileName (hInstance, lpszModuleNamePath, 260))
+        {
+            lpszModuleName = 1 + _fstrrchr (lpszModuleNamePath, '\\');
+
+            if ((lpszFriendlyAndModuleName = (char far *) malloc (260)))
+            {
+                int length;
+
+
+                strncpy(
+                    lpszFriendlyAndModuleName,
+                    (lpszAppName ? lpszAppName : lpszModuleName),
+                    (UINT)TAPIMAXAPPNAMESIZE
+                    );
+
+                lpszFriendlyAndModuleName[TAPIMAXAPPNAMESIZE] = 0;
+
+                length = strlen (lpszFriendlyAndModuleName);
+
+                strcpy(
+                    lpszFriendlyAndModuleName + length + 1,
+                    lpszModuleName
+                    );
+            }
+            else
+            {
+                lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM);
+                goto xxxInitialize_done;
+            }
+        }
+        else
+        {
+            DBGOUT ("GetModuleFileName() failed\n");
+
+            lResult =
+                (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+            goto xxxInitialize_done;
+        }
+    }
+    else
+    {
+        lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM);
+        goto xxxInitialize_done;
+    }
+
+
+    //
+    // Create a window that we can use for signaling async completions
+    // & unsolicited events
+    //
+
+    if (!(hwnd = CreateWindow(
+            gszWndClass,
+            "",
+            WS_POPUP,
+            CW_USEDEFAULT,
+            CW_USEDEFAULT,
+            CW_USEDEFAULT,
+            CW_USEDEFAULT,
+            NULL,
+            NULL,
+            ghInst,
+            NULL
+            )))
+    {
+        lResult = (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED);
+
+        DBGOUT ("CreateWindow failed\n");
+
+        goto xxxInitialize_done;
+    }
+
+
+    //
+    //
+    //
+
+    if (!(pAppData = (LPTAPI_APP_DATA) malloc (sizeof (TAPI_APP_DATA))))
+    {
+        lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM);
+
+        DBGOUT ("malloc failed\n");
+
+        goto xxxInitialize_done;
+    }
+
+    pAppData->dwKey                 = TAPI_APP_DATA_KEY;
+    pAppData->hwnd                  = hwnd;
+    pAppData->bPendingAsyncEventMsg = FALSE;
+    pAppData->lpfnCallback          = lpfnCallback;
+
+    SetWindowLong (hwnd, GWL_APPDATA, (LONG) pAppData);
+
+
+    //
+    // Call tapi32.dll
+    //
+
+    lResult = (LONG) (*pfnCallProc5)(
+       (DWORD) ((LPVOID)&pAppData->hXxxApp),
+       (DWORD) hInstance,
+       (DWORD) (0xffff0000 | hwnd), // lpfnCallback
+       (DWORD) lpszFriendlyAndModuleName,
+       (DWORD) lpdwNumDevs,
+       (LPVOID)gaProcs[(bLine ? lInitialize : pInitialize)],
+       0x13,
+       5
+       );
+
+xxxInitialize_done:
+
+    if (lpszModuleNamePath)
+    {
+        free (lpszModuleNamePath);
+
+        if (lpszFriendlyAndModuleName)
+        {
+            free (lpszFriendlyAndModuleName);
+        }
+    }
+
+    if (lResult == 0)
+    {
+        //
+        // Set the app's hLineApp to be the hwnd rather than the real
+        // hLineApp, making it easier to locate the window
+        //
+
+        *lphXxxApp = (HLINEAPP) pAppData;
+    }
+    else if (hwnd)
+    {
+        DestroyWindow (hwnd);
+
+        if (pAppData)
+        {
+            free (pAppData);
+        }
+    }
+
+xxxInitialize_showResult:
+
+#if DBG
+
+    if (bLine)
+    {
+        LineResult ("Initialize", lResult);
+    }
+    else
+    {
+        PhoneResult ("Initialize", lResult);
+    }
+
+#endif
+
+    return lResult;
+}
+
+
+LPTAPI_APP_DATA
+FAR
+PASCAL
+IsValidXxxApp(
+    HLINEAPP    hXxxApp
+    )
+{
+    if (IsBadReadPtr ((LPVOID) hXxxApp, sizeof (TAPI_APP_DATA)) ||
+        ((LPTAPI_APP_DATA) hXxxApp)->dwKey != TAPI_APP_DATA_KEY)
+    {
+        return (LPTAPI_APP_DATA) NULL;
+    }
+
+    return (LPTAPI_APP_DATA) hXxxApp;
+}
+
+
+LONG
+WINAPI
+lineAccept(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[lAccept],
+        0x2,
+        3
+        );
+
+    LineResult ("Accept", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineAddProvider(
+    LPCSTR  lpszProviderFilename,
+    HWND    hwndOwner,
+    LPDWORD lpdwPermanentProviderID
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) lpszProviderFilename,
+        (DWORD) (0xffff0000 | hwndOwner),
+        (DWORD) lpdwPermanentProviderID,
+        (LPVOID)gaProcs[lAddProvider],
+        0x5,
+        3
+        );
+
+    LineResult ("AddProvider", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineAddToConference(
+    HCALL   hConfCall,
+    HCALL   hConsultCall
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hConfCall,
+        (DWORD) hConsultCall,
+        (LPVOID)gaProcs[lAddToConference],
+        0x0,
+        2
+        );
+
+    LineResult ("AddToConference", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineAnswer(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[lAnswer],
+        0x2,
+        3
+        );
+
+    LineResult ("Answer", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineBlindTransfer(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode,
+        (LPVOID)gaProcs[lBlindTransfer],
+        0x2,
+        3
+        );
+
+    LineResult ("BlindTransfer", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineClose(
+    HLINE   hLine
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hLine,
+        (LPVOID)gaProcs[lClose],
+        0x0,
+        1
+        );
+
+    LineResult ("Close", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineCompleteCall(
+    HCALL   hCall,
+    LPDWORD lpdwCompletionID,
+    DWORD   dwCompletionMode,
+    DWORD   dwMessageID
+    )
+{
+    LONG    lResult;
+
+
+    if (IsBadWritePtr (lpdwCompletionID, sizeof (DWORD)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc4)(
+            (DWORD) hCall,
+            (DWORD) lpdwCompletionID,   // let tapi32.dll map this
+            (DWORD) dwCompletionMode,
+            (DWORD) dwMessageID,
+            (LPVOID)gaProcs[lCompleteCall],
+            0x0,
+            4
+            );
+    }
+    LineResult ("CompleteCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineCompleteTransfer(
+    HCALL   hCall,
+    HCALL   hConsultCall,
+    LPHCALL lphConfCall,
+    DWORD   dwTransferMode
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphConfCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if ( 
+          ( dwTransferMode & LINETRANSFERMODE_CONFERENCE )
+        &&  
+          IsBadWritePtr ((void FAR *) lphConfCall, sizeof(HCALL))
+       )
+    {
+        DBGOUT ("Bad lphConfCall with TRANSFERMODE_CONFERENCE");
+        lResult = LINEERR_INVALPOINTER;
+        goto CompleteTransfer_cleanup;
+    }
+    
+    lResult = (*pfnCallProc4)(
+            (DWORD) hCall,
+            (DWORD) hConsultCall,
+            (DWORD) lphConfCall,
+            (DWORD) dwTransferMode,
+            (LPVOID)gaProcs[lCompleteTransfer],
+            0x0,
+            4
+            );
+
+CompleteTransfer_cleanup:
+    LineResult ("CompleteTransfer", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) dwDeviceID,
+        (DWORD) (0xffff0000 | hwndOwner),
+        (DWORD) lpszDeviceClass,
+        (LPVOID)gaProcs[lConfigDialog],
+        0x1,
+        3
+        );
+
+    LineResult ("ConfigDialog", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigDialogEdit(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass,
+    LPVOID  lpDeviceConfigIn,
+    DWORD   dwSize,
+    LPVARSTRING lpDeviceConfigOut
+    )
+{
+    LONG    lResult = (*pfnCallProc6)(
+        (DWORD) dwDeviceID,
+        (DWORD) (0xffff0000 | hwndOwner),
+        (DWORD) lpszDeviceClass,
+        (DWORD) lpDeviceConfigIn,
+        (DWORD) dwSize,
+        (DWORD) lpDeviceConfigOut,
+        (LPVOID)gaProcs[lConfigDialogEdit],
+        0xd,
+        6
+        );
+
+    LineResult ("ConfigDialogEdit", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineConfigProvider(
+    HWND    hwndOwner,
+    DWORD   dwPermanentProviderID
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) (0xffff0000 | hwndOwner),
+        (DWORD) dwPermanentProviderID,
+        (LPVOID)gaProcs[lConfigProvider],
+        0x0,
+        2
+        );
+
+    LineResult ("ConfigProvider", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineDeallocateCall(
+    HCALL   hCall
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hCall,
+        (LPVOID)gaProcs[lDeallocateCall],
+        0x0,
+        1
+        );
+
+    LineResult ("DeallocateCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineDevSpecific(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult;
+
+
+    if (IsBadWritePtr (lpParams, (UINT) dwSize))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc5)(
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) hCall,
+            (DWORD) lpParams,   // let tapi32.dll map this
+            (DWORD) dwSize,
+            (LPVOID)gaProcs[lDevSpecific],
+            0x0,
+            5
+            );
+    }
+
+    LineResult ("DevSpecific", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineDevSpecificFeature(
+    HLINE   hLine,
+    DWORD   dwFeature,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult;
+
+
+    if (IsBadWritePtr (lpParams, (UINT) dwSize))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc4)(
+            (DWORD) hLine,
+            (DWORD) dwFeature,
+            (DWORD) lpParams,   // let tapi32.dll map this
+            (DWORD) dwSize,
+            (LPVOID)gaProcs[lDevSpecificFeature],
+            0x0,
+            4
+            );
+    }
+
+    LineResult ("DevSpecificFeature", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineDial(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode,
+        (LPVOID)gaProcs[lDial],
+        0x2,
+        3
+        );
+
+    LineResult ("Dial", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineDrop(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[lDrop],
+        0x2,
+        3
+        );
+
+    LineResult ("Drop", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineForward(
+    HLINE   hLine,
+    DWORD   bAllAddresses,
+    DWORD   dwAddressID,
+    LPLINEFORWARDLIST   const lpForwardList,
+    DWORD   dwNumRingsNoAnswer,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphConsultCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc7)(
+            (DWORD) hLine,
+            (DWORD) bAllAddresses,
+            (DWORD) dwAddressID,
+            (DWORD) lpForwardList,
+            (DWORD) dwNumRingsNoAnswer,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (LPVOID)gaProcs[lForward],
+            0x9,
+            7
+            );
+    }
+
+    LineResult ("Forward", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGatherDigits(
+    HCALL   hCall,
+    DWORD   dwDigitModes,
+    LPSTR   lpsDigits,
+    DWORD   dwNumDigits,
+    LPCSTR  lpszTerminationDigits,
+    DWORD   dwFirstDigitTimeout,
+    DWORD   dwInterDigitTimeout
+    )
+{
+    LONG    lResult;
+
+
+    if (lpsDigits  &&  IsBadWritePtr (lpsDigits, dwNumDigits))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc7)(
+            (DWORD) hCall,
+            (DWORD) dwDigitModes,
+            (DWORD) lpsDigits,      // let tapi32.dll map this
+            (DWORD) dwNumDigits,
+            (DWORD) lpszTerminationDigits,
+            (DWORD) dwFirstDigitTimeout,
+            (DWORD) dwInterDigitTimeout,
+            (LPVOID)gaProcs[lGatherDigits],
+            0x4,
+            7
+            );
+    }
+
+    LineResult ("GatherDigits", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGenerateDigits(
+    HCALL   hCall,
+    DWORD   dwDigitMode,
+    LPCSTR  lpsDigits,
+    DWORD   dwDuration
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hCall,
+        (DWORD) dwDigitMode,
+        (DWORD) lpsDigits,
+        (DWORD) dwDuration,
+        (LPVOID)gaProcs[lGenerateDigits],
+        0x2,
+        4
+        );
+
+    LineResult ("GenerateDigits", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGenerateTone(
+    HCALL   hCall,
+    DWORD   dwToneMode,
+    DWORD   dwDuration,
+    DWORD   dwNumTones,
+    LPLINEGENERATETONE const lpTones
+    )
+{
+    LONG    lResult = (*pfnCallProc5)(
+        (DWORD) hCall,
+        (DWORD) dwToneMode,
+        (DWORD) dwDuration,
+        (DWORD) dwNumTones,
+        (DWORD) lpTones,
+        (LPVOID)gaProcs[lGenerateTone],
+        0x1,
+        5
+        );
+
+    LineResult ("GenerateTone", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAddressCaps(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAddressID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    LPLINEADDRESSCAPS   lpAddressCaps
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc6)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAddressID,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) lpAddressCaps,
+            (LPVOID)gaProcs[lGetAddressCaps],
+            0x1,
+            6
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("GetAddressCaps", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAddressID(
+    HLINE   hLine,
+    LPDWORD lpdwAddressID,
+    DWORD   dwAddressMode,
+    LPCSTR  lpsAddress,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc5)(
+        (DWORD) hLine,
+        (DWORD) lpdwAddressID,
+        (DWORD) dwAddressMode,
+        (DWORD) lpsAddress,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[lGetAddressID],
+        0xa,
+        5
+        );
+
+    LineResult ("GetAddressID", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAddressStatus(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPLINEADDRESSSTATUS lpAddressStatus
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) lpAddressStatus,
+        (LPVOID)gaProcs[lGetAddressStatus],
+        0x1,
+        3
+        );
+
+    LineResult ("GetAddressStatus", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetAppPriority(
+    LPCSTR  lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPVARSTRING lpExtensionName,
+    LPDWORD lpdwPriority
+    )
+{
+    LONG    lResult = (*pfnCallProc6)(
+        (DWORD) lpszAppName,
+        (DWORD) dwMediaMode,
+        (DWORD) lpExtensionID,
+        (DWORD) dwRequestMode,
+        (DWORD) lpExtensionName,
+        (DWORD) lpdwPriority,
+        (LPVOID)gaProcs[lGetAppPriority],
+        0x2b,
+        6
+        );
+
+    LineResult ("GetAppPriority", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetCallInfo(
+    HCALL   hCall,
+    LPLINECALLINFO  lpCallInfo
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) lpCallInfo,
+        (LPVOID)gaProcs[lGetCallInfo],
+        0x1,
+        2
+        );
+
+    LineResult ("GetCallInfo", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetCallStatus(
+    HCALL   hCall,
+    LPLINECALLSTATUS    lpCallStatus
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) lpCallStatus,
+        (LPVOID)gaProcs[lGetCallStatus],
+        0x1,
+        2
+        );
+
+    LineResult ("GetCallStatus", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetConfRelatedCalls(
+    HCALL   hCall,
+    LPLINECALLLIST  lpCallList
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) lpCallList,
+        (LPVOID)gaProcs[lGetConfRelatedCalls],
+        0x1,
+        2
+        );
+
+    LineResult ("GetConfRelatedCalls", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetCountry(
+    DWORD   dwCountryID,
+    DWORD   dwAPIVersion,
+    LPLINECOUNTRYLIST   lpLineCountryList
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        dwCountryID,
+        dwAPIVersion,
+        (DWORD) lpLineCountryList,
+        (LPVOID)gaProcs[lGetCountry],
+        0x1,
+        3
+        );
+
+    LineResult ("GetCountry", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetDevCaps(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    LPLINEDEVCAPS   lpLineDevCaps
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc5)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) lpLineDevCaps,
+            (LPVOID)gaProcs[lGetDevCaps],
+            0x1,
+            5
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("GetDevCaps", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetDevConfig(
+    DWORD       dwDeviceID,
+    LPVARSTRING lpDeviceConfig,
+    LPCSTR      lpszDeviceClass
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) dwDeviceID,
+        (DWORD) lpDeviceConfig,
+        (DWORD) lpszDeviceClass,
+        (LPVOID)gaProcs[lGetDevConfig],
+        0x3,
+        3
+        );
+
+    LineResult ("GetDevConfig", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetIcon(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) dwDeviceID,
+        (DWORD) lpszDeviceClass,
+        (DWORD) lphIcon,
+        (LPVOID)gaProcs[lGetIcon],
+        0x3,
+        3
+        );
+
+    LineResult ("GetIcon", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetID(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    LPVARSTRING lpDeviceID,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG    lResult = (*pfnCallProc6)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) hCall,
+        (DWORD) dwSelect,
+        (DWORD) lpDeviceID,
+        (DWORD) lpszDeviceClass,
+        (LPVOID)gaProcs[lGetID],
+        0x3,
+        6
+        );
+
+    LineResult ("GetID", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetLineDevStatus(
+    HLINE   hLine,
+    LPLINEDEVSTATUS lpLineDevStatus
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hLine,
+        (DWORD) lpLineDevStatus,
+        (LPVOID)gaProcs[lGetLineDevStatus],
+        0x1,
+        2
+        );
+
+    LineResult ("GetLineDevStatus", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetNewCalls(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    DWORD   dwSelect,
+    LPLINECALLLIST  lpCallList
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) dwSelect,
+        (DWORD) lpCallList,
+        (LPVOID)gaProcs[lGetNewCalls],
+        0x1,
+        4
+        );
+
+    LineResult ("GetNewCalls", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetNumRings(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPDWORD lpdwNumRings
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) lpdwNumRings,
+        (LPVOID)gaProcs[lGetNumRings],
+        0x1,
+        3
+        );
+
+    LineResult ("GetNumRings", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetProviderList(
+    DWORD   dwAPIVersion,
+    LPLINEPROVIDERLIST  lpProviderList
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        dwAPIVersion,
+        (DWORD) lpProviderList,
+        (LPVOID)gaProcs[lGetProviderList],
+        0x1,
+        2
+        );
+
+    LineResult ("GetProviderList", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetRequest(
+    HLINEAPP    hLineApp,
+    DWORD   dwRequestMode,
+    LPVOID  lpRequestBuffer
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc3)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwRequestMode,
+            (DWORD) lpRequestBuffer,
+            (LPVOID)gaProcs[lGetRequest],
+            0x1,
+            3
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("GetRequest", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetStatusMessages(
+    HLINE   hLine,
+    LPDWORD lpdwLineStates,
+    LPDWORD lpdwAddressStates
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hLine,
+        (DWORD) lpdwLineStates,
+        (DWORD) lpdwAddressStates,
+        (LPVOID)gaProcs[lGetStatusMessages],
+        0x3,
+        3
+        );
+
+    LineResult ("GetStatusMessages", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineGetTranslateCaps(
+    HLINEAPP            hLineApp,
+    DWORD               dwAPIVersion,
+    LPLINETRANSLATECAPS lpTranslateCaps
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if (hLineApp == NULL || (pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc3)(
+            (hLineApp == NULL ? (DWORD) 0 : pAppData->hXxxApp),
+            (DWORD) dwAPIVersion,
+            (DWORD) lpTranslateCaps,
+            (LPVOID)gaProcs[lGetTranslateCaps],
+            0x1,
+            3
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("GetTranslateCaps", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineHandoff(
+    HCALL   hCall,
+    LPCSTR  lpszFileName,
+    DWORD   dwMediaMode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpszFileName,
+        (DWORD) dwMediaMode,
+        (LPVOID)gaProcs[lHandoff],
+        0x2,
+        3
+        );
+
+    LineResult ("Handoff", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineHold(
+    HCALL   hCall
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hCall,
+        (LPVOID)gaProcs[lHold],
+        0x0,
+        1
+        );
+
+    LineResult ("Hold", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineInitialize(
+    LPHLINEAPP      lphLineApp,
+    HINSTANCE       hInstance,
+    LINECALLBACK    lpfnCallback,
+    LPCSTR          lpszAppName,
+    LPDWORD         lpdwNumDevs
+    )
+{
+    return (xxxInitialize(
+        TRUE,
+        lphLineApp,
+        hInstance,
+        lpfnCallback,
+        lpszAppName,
+        lpdwNumDevs
+        ));
+}
+
+
+LONG
+WINAPI
+lineMakeCall(
+    HLINE   hLine,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode,
+    LPLINECALLPARAMS const lpCallParams
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc5)(
+            (DWORD) hLine,
+            (DWORD) lphCall,
+            (DWORD) lpszDestAddress,
+            (DWORD) dwCountryCode,
+            (DWORD) lpCallParams,
+            (LPVOID)gaProcs[lMakeCall],
+            0x5,
+            5
+            );
+    }
+
+    LineResult ("MakeCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineMonitorDigits(
+    HCALL   hCall,
+    DWORD   dwDigitModes
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) dwDigitModes,
+        (LPVOID)gaProcs[lMonitorDigits],
+        0x0,
+        2
+        );
+
+    LineResult ("MonitorDigits", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineMonitorMedia(
+    HCALL   hCall,
+    DWORD   dwMediaModes
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) dwMediaModes,
+        (LPVOID)gaProcs[lMonitorMedia],
+        0x0,
+        2
+        );
+
+    LineResult ("MonitorMedia", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineMonitorTones(
+    HCALL   hCall,
+    LPLINEMONITORTONE   const lpToneList,
+    DWORD   dwNumEntries
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpToneList,
+        (DWORD) dwNumEntries,
+        (LPVOID)gaProcs[lMonitorTones],
+        0x2,
+        3
+        );
+
+    LineResult ("MonitorTones", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineNegotiateAPIVersion(
+    HLINEAPP            hLineApp,
+    DWORD               dwDeviceID,
+    DWORD               dwAPILowVersion,
+    DWORD               dwAPIHighVersion,
+    LPDWORD             lpdwAPIVersion,
+    LPLINEEXTENSIONID   lpExtensionID
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc6)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPILowVersion,
+            (DWORD) dwAPIHighVersion,
+            (DWORD) lpdwAPIVersion,
+            (DWORD) lpExtensionID,
+            (LPVOID)gaProcs[lNegotiateAPIVersion],
+            0x3,
+            6
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("NegotiateAPIVersion", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineNegotiateExtVersion(
+    HLINEAPP    hLineApp,
+    DWORD   dwDeviceID,
+    DWORD   dwAPIVersion,
+    DWORD   dwExtLowVersion,
+    DWORD   dwExtHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc6)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtLowVersion,
+            (DWORD) dwExtHighVersion,
+            (DWORD) lpdwExtVersion,
+            (LPVOID)gaProcs[lNegotiateExtVersion],
+            0x1,
+            6
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("NegotiateExtVersion", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineOpen(
+    HLINEAPP    hLineApp,
+    DWORD   dwDeviceID,
+    LPHLINE lphLine,
+    DWORD   dwAPIVersion,
+    DWORD   dwExtVersion,
+    DWORD   dwCallbackInstance,
+    DWORD   dwPrivileges,
+    DWORD   dwMediaModes,
+    LPLINECALLPARAMS const lpCallParams
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc9)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) lphLine,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) dwCallbackInstance,
+            (DWORD) dwPrivileges,
+            (DWORD) dwMediaModes,
+            (DWORD) lpCallParams,
+            (LPVOID)gaProcs[lOpen],
+            0x41,
+            9
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("Open", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+linePark(
+    HCALL   hCall,
+    DWORD   dwParkMode,
+    LPCSTR  lpszDirAddress,
+    LPVARSTRING lpNonDirAddress
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hCall,
+        (DWORD) dwParkMode,
+        (DWORD) lpszDirAddress,
+        (DWORD) lpNonDirAddress,    // let tapi32.dll map this
+        (LPVOID)gaProcs[lPark],
+        0x2,
+        4
+        );
+
+    LineResult ("Park", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+linePickup(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszGroupID
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc5)(
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lphCall,
+            (DWORD) lpszDestAddress,
+            (DWORD) lpszGroupID,
+            (LPVOID)gaProcs[lPickup],
+            0x3,
+            5
+            );
+    }
+
+    LineResult ("Pickup", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+linePrepareAddToConference(
+    HCALL   hConfCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphConsultCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc3)(
+            (DWORD) hConfCall,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (LPVOID)gaProcs[lPrepareAddToConference],
+            0x1,
+            3
+            );
+    }
+
+    LineResult ("PrepareAddToConference", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineRedirect(
+    HCALL   hCall,
+    LPCSTR  lpszDestAddress,
+    DWORD   dwCountryCode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpszDestAddress,
+        (DWORD) dwCountryCode,
+        (LPVOID)gaProcs[lRedirect],
+        0x2,
+        3
+        );
+
+    LineResult ("Redirect", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineRegisterRequestRecipient(
+    HLINEAPP    hLineApp,
+    DWORD   dwRegistrationInstance,
+    DWORD   dwRequestMode,
+    DWORD   bEnable
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc4)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwRegistrationInstance,
+            (DWORD) dwRequestMode,
+            (DWORD) bEnable,
+            (LPVOID)gaProcs[lRegisterRequestRecipient],
+            0x0,
+            4
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("RegisterRequestRecipient", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineReleaseUserUserInfo(
+    HCALL   hCall
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hCall,
+        (LPVOID)gaProcs[lReleaseUserUserInfo],
+        0x0,
+        1
+        );
+
+    LineResult ("ReleaseUserUserInfo", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineRemoveFromConference(
+    HCALL   hCall
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hCall,
+        (LPVOID)gaProcs[lRemoveFromConference],
+        0x0,
+        1
+        );
+
+    LineResult ("RemoveFromConference", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineRemoveProvider(
+    DWORD   dwPermanentProviderID,
+    HWND    hwndOwner
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) dwPermanentProviderID,
+        (DWORD) (0xffff0000 | hwndOwner),
+        (LPVOID)gaProcs[lRemoveProvider],
+        0x0,
+        2
+        );
+
+    LineResult ("RemoveProvider", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSecureCall(
+    HCALL hCall
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hCall,
+        (LPVOID)gaProcs[lSecureCall],
+        0x0,
+        1
+        );
+
+    LineResult ("SecureCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSendUserUserInfo(
+    HCALL   hCall,
+    LPCSTR  lpsUserUserInfo,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hCall,
+        (DWORD) lpsUserUserInfo,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[lSendUserUserInfo],
+        0x2,
+        3
+        );
+
+    LineResult ("SendUserUserInfo", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetAppPriority(
+    LPCSTR  lpszAppName,
+    DWORD   dwMediaMode,
+    LPLINEEXTENSIONID   lpExtensionID,
+    DWORD   dwRequestMode,
+    LPCSTR  lpszExtensionName,
+    DWORD   dwPriority
+    )
+{
+    LONG    lResult = (*pfnCallProc6)(
+        (DWORD) lpszAppName,
+        (DWORD) dwMediaMode,
+        (DWORD) lpExtensionID,
+        (DWORD) dwRequestMode,
+        (DWORD) lpszExtensionName,
+        (DWORD) dwPriority,
+        (LPVOID)gaProcs[lSetAppPriority],
+        0x2a,
+        6
+        );
+
+    LineResult ("SetAppPriority", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetAppSpecific(
+    HCALL   hCall,
+    DWORD   dwAppSpecific
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) dwAppSpecific,
+        (LPVOID)gaProcs[lSetAppSpecific],
+        0x0,
+        2
+        );
+
+    LineResult ("SetAppSpecific", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetCallParams(
+    HCALL   hCall,
+    DWORD   dwBearerMode,
+    DWORD   dwMinRate,
+    DWORD   dwMaxRate,
+    LPLINEDIALPARAMS const lpDialParams
+    )
+{
+    LONG    lResult = (*pfnCallProc5)(
+        (DWORD) hCall,
+        (DWORD) dwBearerMode,
+        (DWORD) dwMinRate,
+        (DWORD) dwMaxRate,
+        (DWORD) lpDialParams,
+        (LPVOID)gaProcs[lSetCallParams],
+        0x1,
+        5
+        );
+
+    LineResult ("SetCallParams", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetCallPrivilege(
+    HCALL   hCall,
+    DWORD   dwCallPrivilege
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) dwCallPrivilege,
+        (LPVOID)gaProcs[lSetCallPrivilege],
+        0x0,
+        2
+        );
+
+    LineResult ("SetCallPrivilege", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetCurrentLocation(
+    HLINEAPP    hLineApp,
+    DWORD       dwLocation
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc2)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwLocation,
+            (LPVOID)gaProcs[lSetCurrentLocation],
+            0x0,
+            2
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("SetCurrentLocation", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetDevConfig(
+    DWORD   dwDeviceID,
+    LPVOID  const lpDeviceConfig,
+    DWORD   dwSize,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) dwDeviceID,
+        (DWORD) lpDeviceConfig,
+        (DWORD) dwSize,
+        (DWORD) lpszDeviceClass,
+        (LPVOID)gaProcs[lSetDevConfig],
+        0x5,
+        4
+        );
+
+    LineResult ("SetDevConfig", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetMediaControl(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    LPLINEMEDIACONTROLDIGIT const lpDigitList,
+    DWORD   dwDigitNumEntries,
+    LPLINEMEDIACONTROLMEDIA const lpMediaList,
+    DWORD   dwMediaNumEntries,
+    LPLINEMEDIACONTROLTONE  const lpToneList,
+    DWORD   dwToneNumEntries,
+    LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+    DWORD   dwCallStateNumEntries
+    )
+{
+    LONG    lResult = (*pfnCallProc12)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) hCall,
+        (DWORD) dwSelect,
+        (DWORD) lpDigitList,
+        (DWORD) dwDigitNumEntries,
+        (DWORD) lpMediaList,
+        (DWORD) dwMediaNumEntries,
+        (DWORD) lpToneList,
+        (DWORD) dwToneNumEntries,
+        (DWORD) lpCallStateList,
+        (DWORD) dwCallStateNumEntries,
+        (LPVOID)gaProcs[lSetMediaControl],
+        0xaa,
+        12
+        );
+
+    LineResult ("SetMediaControl", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetMediaMode(
+    HCALL   hCall,
+    DWORD   dwMediaModes
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hCall,
+        (DWORD) dwMediaModes,
+        (LPVOID)gaProcs[lSetMediaMode],
+        0x0,
+        2
+        );
+
+    LineResult ("lineSetMediaMode", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetNumRings(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    DWORD   dwNumRings
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) dwNumRings,
+        (LPVOID)gaProcs[lSetNumRings],
+        0x0,
+        3
+        );
+
+    LineResult ("SetNumRings", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetStatusMessages(
+    HLINE hLine,
+    DWORD dwLineStates,
+    DWORD dwAddressStates
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hLine,
+        (DWORD) dwLineStates,
+        (DWORD) dwAddressStates,
+        (LPVOID)gaProcs[lSetStatusMessages],
+        0x0,
+        3
+        );
+
+    LineResult ("SetStatusMessages", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetTerminal(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    HCALL   hCall,
+    DWORD   dwSelect,
+    DWORD   dwTerminalModes,
+    DWORD   dwTerminalID,
+    DWORD   bEnable
+    )
+{
+    LONG    lResult = (*pfnCallProc7)(
+        (DWORD) hLine,
+        (DWORD) dwAddressID,
+        (DWORD) hCall,
+        (DWORD) dwSelect,
+        (DWORD) dwTerminalModes,
+        (DWORD) dwTerminalID,
+        (DWORD) bEnable,
+        (LPVOID)gaProcs[lSetTerminal],
+        0x0,
+        7
+        );
+
+    LineResult ("SetTerminal", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetTollList(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    LPCSTR      lpszAddressIn,
+    DWORD       dwTollListOption
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc4)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) lpszAddressIn,
+            (DWORD) dwTollListOption,
+            (LPVOID)gaProcs[lSetTollList],
+            0x2,
+            4
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("SetTollList", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetupConference(
+    HCALL   hCall,
+    HLINE   hLine,
+    LPHCALL lphConfCall,
+    LPHCALL lphConsultCall,
+    DWORD   dwNumParties,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphXxxCall's if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphConfCall, sizeof(HCALL)) ||
+        IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc6)(
+            (DWORD) hCall,
+            (DWORD) hLine,
+            (DWORD) lphConfCall,
+            (DWORD) lphConsultCall,
+            (DWORD) dwNumParties,
+            (DWORD) lpCallParams,
+            (LPVOID)gaProcs[lSetupConference],
+            0x1,
+            6
+            );
+    }
+
+    LineResult ("SetupConference", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSetupTransfer(
+    HCALL   hCall,
+    LPHCALL lphConsultCall,
+    LPLINECALLPARAMS    const lpCallParams
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphConsultCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc3)(
+            (DWORD) hCall,
+            (DWORD) lphConsultCall,
+            (DWORD) lpCallParams,
+            (LPVOID)gaProcs[lSetupTransfer],
+            0x1,
+            3
+            );
+    }
+
+    LineResult ("SetupTransfer", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineShutdown(
+    HLINEAPP    hLineApp
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        if ((lResult = (LONG) (*pfnCallProc1)(
+               (DWORD) pAppData->hXxxApp,
+               (LPVOID)gaProcs[lShutdown],
+               0x0,
+               1
+
+               )) == 0)
+        {
+            //
+            // Destroy the associated window & free the app data instance
+            //
+
+            DestroyWindow (pAppData->hwnd);
+            pAppData->dwKey = 0xefefefef;
+            free (pAppData);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("Shutdown", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineSwapHold(
+    HCALL   hActiveCall,
+    HCALL   hHeldCall
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hActiveCall,
+        (DWORD) hHeldCall,
+        (LPVOID)gaProcs[lSwapHold],
+        0x0,
+        2
+        );
+
+    LineResult ("SwapHold", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineTranslateAddress(
+    HLINEAPP    hLineApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    LPCSTR      lpszAddressIn,
+    DWORD       dwCard,
+    DWORD       dwTranslateOptions,
+    LPLINETRANSLATEOUTPUT   lpTranslateOutput
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc7)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPIVersion,
+            (DWORD) lpszAddressIn,
+            (DWORD) dwCard,
+            (DWORD) dwTranslateOptions,
+            (DWORD) lpTranslateOutput,
+            (LPVOID)gaProcs[lTranslateAddress],
+            0x9,
+            7
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("TranslateAddress", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineTranslateDialog(
+    HLINEAPP    hLineApp,
+    DWORD   dwDeviceID,
+    DWORD   dwAPIVersion,
+    HWND    hwndOwner,
+    LPCSTR  lpszAddressIn
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp (hLineApp)))
+    {
+        lResult = (*pfnCallProc5)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPIVersion,
+            (DWORD) (0xffff0000 | hwndOwner),
+            (DWORD) lpszAddressIn,
+            (LPVOID)gaProcs[lTranslateDialog],
+            0x1,
+            5
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    LineResult ("TranslateDialog", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineUncompleteCall(
+    HLINE   hLine,
+    DWORD   dwCompletionID
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hLine,
+        (DWORD) dwCompletionID,
+        (LPVOID)gaProcs[lUncompleteCall],
+        0x0,
+        2
+        );
+
+    LineResult ("UncompleteCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineUnhold(
+    HCALL   hCall
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hCall,
+        (LPVOID)gaProcs[lUnhold],
+        0x0,
+        1
+        );
+
+    LineResult ("Unhold", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+lineUnpark(
+    HLINE   hLine,
+    DWORD   dwAddressID,
+    LPHCALL lphCall,
+    LPCSTR  lpszDestAddress
+    )
+{
+    //
+    // Tapi32.dll will take care of mapping lphCall if/when the
+    // request completes successfully, so we don't set the mapping
+    // bit down below; do check to see if pointer is valid though.
+    //
+
+    LONG    lResult;
+
+
+    if (IsBadWritePtr ((void FAR *) lphCall, sizeof(HCALL)))
+    {
+        lResult = LINEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc4)(
+            (DWORD) hLine,
+            (DWORD) dwAddressID,
+            (DWORD) lphCall,
+            (DWORD) lpszDestAddress,
+            (LPVOID)gaProcs[lUnpark],
+            0x1,
+            4
+            );
+    }
+
+    LineResult ("Unpark", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneClose(
+    HPHONE  hPhone
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD) hPhone,
+        (LPVOID)gaProcs[pClose],
+        0x0,
+        1
+        );
+
+    PhoneResult ("Close", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneConfigDialog(
+    DWORD   dwDeviceID,
+    HWND    hwndOwner,
+    LPCSTR  lpszDeviceClass
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) dwDeviceID,
+        (DWORD) (0xffff0000 | hwndOwner),
+        (DWORD) lpszDeviceClass,
+        (LPVOID)gaProcs[pConfigDialog],
+        0x1,
+        3
+        );
+
+    PhoneResult ("ConfigDialog", lResult);
+
+    return lResult;
+}
+
+
+
+LONG
+WINAPI
+phoneDevSpecific(
+    HPHONE  hPhone,
+    LPVOID  lpParams,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult;
+
+
+    if (IsBadWritePtr (lpParams, (UINT) dwSize))
+    {
+        lResult = PHONEERR_INVALPOINTER;
+    }
+    else
+    {
+        lResult = (*pfnCallProc3)(
+            (DWORD) hPhone,
+            (DWORD) lpParams,   // let tapi32.dll map this
+            (DWORD) dwSize,
+            (LPVOID)gaProcs[pDevSpecific],
+            0x0,
+            3
+            );
+    }
+
+    PhoneResult ("DevSpecific", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetButtonInfo(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    LPPHONEBUTTONINFO   lpButtonInfo
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) lpButtonInfo,
+        (LPVOID)gaProcs[pGetButtonInfo],
+        0x1,
+        3
+        );
+
+    PhoneResult ("GetButtonInfo", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetData(
+    HPHONE  hPhone,
+    DWORD   dwDataID,
+    LPVOID  lpData,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hPhone,
+        (DWORD) dwDataID,
+        (DWORD) lpData,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[pGetData],
+        0x2,
+        4
+        );
+
+    PhoneResult ("GetData", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetDevCaps(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    LPPHONECAPS lpPhoneCaps
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp)))
+    {
+        lResult = (*pfnCallProc5)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) lpPhoneCaps,
+            (LPVOID)gaProcs[pGetDevCaps],
+            0x1,
+            5
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    PhoneResult ("GetDevCaps", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetDisplay(
+    HPHONE  hPhone,
+    LPVARSTRING lpDisplay
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hPhone,
+        (DWORD) lpDisplay,
+        (LPVOID)gaProcs[pGetDisplay],
+        0x1,
+        2
+        );
+
+    PhoneResult ("GetDisplay", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetGain(
+    HPHONE  hPhone,
+    DWORD   dwHookSwitchDev,
+    LPDWORD lpdwGain
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) lpdwGain,
+        (LPVOID)gaProcs[pGetGain],
+        0x1,
+        3
+        );
+
+    PhoneResult ("GetGain", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetHookSwitch(
+    HPHONE  hPhone,
+    LPDWORD lpdwHookSwitchDevs
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hPhone,
+        (DWORD) lpdwHookSwitchDevs,
+        (LPVOID)gaProcs[pGetHookSwitch],
+        0x1,
+        2
+        );
+
+    PhoneResult ("GetHookSwitch", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetIcon(
+    DWORD   dwDeviceID,
+    LPCSTR  lpszDeviceClass,
+    LPHICON lphIcon
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) dwDeviceID,
+        (DWORD) lpszDeviceClass,
+        (DWORD) lphIcon,
+        (LPVOID)gaProcs[pGetIcon],
+        0x3,
+        3
+        );
+
+    PhoneResult ("GetIcon", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetID(
+    HPHONE      hPhone,
+    LPVARSTRING lpDeviceID,
+    LPCSTR      lpszDeviceClass
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) lpDeviceID,
+        (DWORD) lpszDeviceClass,
+        (LPVOID)gaProcs[pGetID],
+        0x3,
+        3
+        );
+
+    PhoneResult ("GetID", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetLamp(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    LPDWORD lpdwLampMode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) lpdwLampMode,
+        (LPVOID)gaProcs[pGetLamp],
+        0x1,
+        3
+        );
+
+    PhoneResult ("GetLamp", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetRing(
+    HPHONE  hPhone,
+    LPDWORD lpdwRingMode,
+    LPDWORD lpdwVolume
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) lpdwRingMode,
+        (DWORD) lpdwVolume,
+        (LPVOID)gaProcs[pGetRing],
+        0x3,
+        3
+        );
+
+    PhoneResult ("GetRing", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetStatus(
+    HPHONE          hPhone,
+    LPPHONESTATUS   lpPhoneStatus
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hPhone,
+        (DWORD) lpPhoneStatus,
+        (LPVOID)gaProcs[pGetStatus],
+        0x1,
+        2
+        );
+
+    PhoneResult ("GetStatus", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetStatusMessages(
+    HPHONE  hPhone,
+    LPDWORD lpdwPhoneStates,
+    LPDWORD lpdwButtonModes,
+    LPDWORD lpdwButtonStates
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hPhone,
+        (DWORD) lpdwPhoneStates,
+        (DWORD) lpdwButtonModes,
+        (DWORD) lpdwButtonStates,
+        (LPVOID)gaProcs[pGetStatusMessages],
+        0x7,
+        4
+        );
+
+    PhoneResult ("GetStatusMessages", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneGetVolume(
+    HPHONE  hPhone,
+    DWORD   dwHookSwitchDev,
+    LPDWORD lpdwVolume
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) lpdwVolume,
+        (LPVOID)gaProcs[pGetVolume],
+        0x1,
+        3
+        );
+
+    PhoneResult ("GetVolume", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneInitialize(
+    LPHPHONEAPP     lphPhoneApp,
+    HINSTANCE       hInstance,
+    PHONECALLBACK   lpfnCallback,
+    LPCSTR          lpszAppName,
+    LPDWORD         lpdwNumDevs
+    )
+{
+    return (xxxInitialize(
+        FALSE,
+        (LPHLINEAPP) lphPhoneApp,
+        hInstance,
+        lpfnCallback,
+        lpszAppName,
+        lpdwNumDevs
+        ));
+}
+
+
+LONG
+WINAPI
+phoneNegotiateAPIVersion(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    DWORD       dwAPILowVersion,
+    DWORD       dwAPIHighVersion,
+    LPDWORD     lpdwAPIVersion,
+    LPPHONEEXTENSIONID  lpExtensionID
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp)))
+    {
+        lResult = (*pfnCallProc6)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPILowVersion,
+            (DWORD) dwAPIHighVersion,
+            (DWORD) lpdwAPIVersion,
+            (DWORD) lpExtensionID,
+            (LPVOID)gaProcs[pNegotiateAPIVersion],
+            0x3,
+            6
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    PhoneResult ("NegotiateAPIVersion", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneNegotiateExtVersion(
+    HPHONEAPP hPhoneApp,
+    DWORD dwDeviceID,
+    DWORD dwAPIVersion,
+    DWORD dwExtLowVersion,
+    DWORD dwExtHighVersion,
+    LPDWORD lpdwExtVersion
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp)))
+    {
+        lResult = (*pfnCallProc6)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtLowVersion,
+            (DWORD) dwExtHighVersion,
+            (DWORD) lpdwExtVersion,
+            (LPVOID)gaProcs[pNegotiateExtVersion],
+            0x1,
+            6
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    PhoneResult ("NegotiateExtVersion", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneOpen(
+    HPHONEAPP   hPhoneApp,
+    DWORD       dwDeviceID,
+    LPHPHONE    lphPhone,
+    DWORD       dwAPIVersion,
+    DWORD       dwExtVersion,
+    DWORD       dwCallbackInstance,
+    DWORD       dwPrivilege
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp)))
+    {
+        lResult = (*pfnCallProc7)(
+            (DWORD) pAppData->hXxxApp,
+            (DWORD) dwDeviceID,
+            (DWORD) lphPhone,
+            (DWORD) dwAPIVersion,
+            (DWORD) dwExtVersion,
+            (DWORD) dwCallbackInstance,
+            (DWORD) dwPrivilege,
+            (LPVOID)gaProcs[pOpen],
+            0x10,
+            7
+            );
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    PhoneResult ("Open", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetButtonInfo(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    LPPHONEBUTTONINFO const lpButtonInfo
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) lpButtonInfo,
+        (LPVOID)gaProcs[pSetButtonInfo],
+        0x1,
+        3
+        );
+
+    PhoneResult ("SetButtonInfo", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetData(
+    HPHONE          hPhone,
+    DWORD           dwDataID,
+    LPVOID const    lpData,
+    DWORD           dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hPhone,
+        (DWORD) dwDataID,
+        (DWORD) lpData,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[pSetData],
+        0x2,
+        4
+        );
+
+    PhoneResult ("SetData", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetDisplay(
+    HPHONE  hPhone,
+    DWORD   dwRow,
+    DWORD   dwColumn,
+    LPCSTR  lpsDisplay,
+    DWORD   dwSize
+    )
+{
+    LONG    lResult = (*pfnCallProc5)(
+        (DWORD) hPhone,
+        (DWORD) dwRow,
+        (DWORD) dwColumn,
+        (DWORD) lpsDisplay,
+        (DWORD) dwSize,
+        (LPVOID)gaProcs[pSetDisplay],
+        0x2,
+        5
+        );
+
+    PhoneResult ("SetDisplay", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetGain(
+    HPHONE  hPhone,
+    DWORD   dwHookSwitchDev,
+    DWORD   dwGain
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) dwGain,
+        (LPVOID)gaProcs[pSetGain],
+        0x0,
+        3
+        );
+
+    PhoneResult ("SetGain", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetHookSwitch(
+    HPHONE  hPhone,
+    DWORD   dwHookSwitchDevs,
+    DWORD   dwHookSwitchMode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwHookSwitchDevs,
+        (DWORD) dwHookSwitchMode,
+        (LPVOID)gaProcs[pSetHookSwitch],
+        0x0,
+        3
+        );
+
+    PhoneResult ("SetHookSwitch", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetLamp(
+    HPHONE  hPhone,
+    DWORD   dwButtonLampID,
+    DWORD   dwLampMode
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwButtonLampID,
+        (DWORD) dwLampMode,
+        (LPVOID)gaProcs[pSetLamp],
+        0x0,
+        3
+        );
+
+    PhoneResult ("SetLamp", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetRing(
+    HPHONE  hPhone,
+    DWORD   dwRingMode,
+    DWORD   dwVolume
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwRingMode,
+        (DWORD) dwVolume,
+        (LPVOID)gaProcs[pSetRing],
+        0x0,
+        3
+        );
+
+    PhoneResult ("SetRing", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetStatusMessages(
+    HPHONE  hPhone,
+    DWORD   dwPhoneStates,
+    DWORD   dwButtonModes,
+    DWORD   dwButtonStates
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) hPhone,
+        (DWORD) dwPhoneStates,
+        (DWORD) dwButtonModes,
+        (DWORD) dwButtonStates,
+        (LPVOID)gaProcs[pSetStatusMessages],
+        0x0,
+        4
+        );
+
+    PhoneResult ("SetStatusMessages", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneSetVolume(
+    HPHONE  hPhone,
+    DWORD   dwHookSwitchDev,
+    DWORD   dwVolume
+    )
+{
+    LONG    lResult = (*pfnCallProc3)(
+        (DWORD) hPhone,
+        (DWORD) dwHookSwitchDev,
+        (DWORD) dwVolume,
+        (LPVOID)gaProcs[pSetVolume],
+        0x0,
+        3
+        );
+
+    PhoneResult ("SetVolume", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+phoneShutdown(
+    HPHONEAPP hPhoneApp
+    )
+{
+    LONG            lResult;
+    LPTAPI_APP_DATA pAppData;
+
+
+    if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp)))
+    {
+        if ((lResult = (*pfnCallProc1)(
+               (DWORD) pAppData->hXxxApp,
+               (LPVOID)gaProcs[pShutdown],
+               0x0,
+               1
+
+               )) == 0)
+        {
+            //
+            // Destroy the associated window & free the app data instance
+            //
+
+            DestroyWindow (pAppData->hwnd);
+            pAppData->dwKey = 0xefefefef;
+            free (pAppData);
+        }
+    }
+    else
+    {
+        lResult = LINEERR_INVALAPPHANDLE;
+    }
+
+    PhoneResult ("Shutdown", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiRequestMakeCall(
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszAppName,
+    LPCSTR  lpszCalledParty,
+    LPCSTR  lpszComment
+    )
+{
+    LONG    lResult = (*pfnCallProc4)(
+        (DWORD) lpszDestAddress,
+        (DWORD) lpszAppName,
+        (DWORD) lpszCalledParty,
+        (DWORD) lpszComment,
+        (LPVOID)gaProcs[tRequestMakeCall],
+        0xf,
+        4
+        );
+
+    TapiResult ("RequestMakeCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiRequestMediaCall(
+    HWND    hWnd,
+    WPARAM  wRequestID,
+    LPCSTR  lpszDeviceClass,
+    LPCSTR  lpDeviceID,
+    DWORD   dwSize,
+    DWORD   dwSecure,
+    LPCSTR  lpszDestAddress,
+    LPCSTR  lpszAppName,
+    LPCSTR  lpszCalledParty,
+    LPCSTR  lpszComment
+    )
+{
+    LONG    lResult = (*pfnCallProc10)(
+        (DWORD) hWnd,
+        (DWORD) wRequestID,
+        (DWORD) lpszDeviceClass,
+        (DWORD) lpDeviceID,
+        (DWORD) dwSize,
+        (DWORD) dwSecure,
+        (DWORD) lpszDestAddress,
+        (DWORD) lpszAppName,
+        (DWORD) lpszCalledParty,
+        (DWORD) lpszComment,
+        (LPVOID)gaProcs[tRequestMediaCall],
+        0xcf,
+        10
+        );
+
+    TapiResult ("RequestMediaCall", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiRequestDrop(
+    HWND    hWnd,
+    WPARAM  wRequestID
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) hWnd,
+        (DWORD) wRequestID,
+        (LPVOID)gaProcs[tRequestDrop],
+        0x0,
+        2
+        );
+
+    TapiResult ("Drop", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+tapiGetLocationInfo(
+    LPSTR   lpszCountryCode,
+    LPSTR   lpszCityCode
+    )
+{
+    LONG    lResult = (*pfnCallProc2)(
+        (DWORD) lpszCountryCode,
+        (DWORD) lpszCityCode,
+        (LPVOID)gaProcs[tGetLocationInfo],
+        0x3,
+        2
+        );
+
+    TapiResult ("GetLocationInfo", lResult);
+
+    return lResult;
+}
+
+
+
+
+LONG
+WINAPI
+LAddrParamsInited(
+    LPDWORD lpdwInited
+    )
+{
+    LONG    lResult = (*pfnCallProc1)(
+        (DWORD)lpdwInited,
+        (LPVOID)gaProcs[LAddrParamsInitedVAL],
+        0x1,
+        1
+        );
+
+    LineResult ("LAddrParamsInited", lResult);
+
+    return lResult;
+}
+
+
+LONG
+WINAPI
+LOpenDialAsst(
+    HWND    hwnd,
+    LPCSTR  lpszAddressIn,
+    BOOL    fSimple,
+    BOOL    fSilentInstall)
+{
+    LONG    lResult = (*pfnCallProc4)(
+        hwnd,
+        (DWORD)lpszAddressIn,
+        fSimple,
+        fSilentInstall,
+        (LPVOID)gaProcs[LOpenDialAsstVAL],
+        0x0,
+        4
+        );
+
+    LineResult ("LOpenDialAsst", lResult);
+
+    return lResult;
+}
diff --git a/private/tapi/dev/thunk/thunk.h b/private/tapi/dev/thunk/thunk.h
new file mode 100644
index 000000000..d3f9c4bbc
--- /dev/null
+++ b/private/tapi/dev/thunk/thunk.h
@@ -0,0 +1,369 @@
+#define WF_WINNT 0x4000
+
+#define TAPI_APP_DATA_KEY      0x44415441
+#define GWL_APPDATA            0
+#define WM_ASYNCEVENT          (WM_USER+111)
+#define NUM_TAPI32_PROCS       117
+
+typedef void (FAR PASCAL *MYPROC)();
+//typedef MYPROC NEAR * PMYPROC;
+
+
+typedef LONG (FAR PASCAL *PFNCALLPROC1)(DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC2)(DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC3)(DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC4)(DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC5)(DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC6)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC7)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC8)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC9)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC10)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC11)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+typedef LONG (FAR PASCAL *PFNCALLPROC12)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD);
+
+typedef enum
+{
+    lAccept,
+    lAddProvider,
+    lAddToConference,
+    lAnswer,
+    lBlindTransfer,
+    lClose,
+    lCompleteCall,
+    lCompleteTransfer,
+    lConfigDialog,
+    lConfigDialogEdit,
+    lConfigProvider,
+    lDeallocateCall,
+    lDevSpecific,
+    lDevSpecificFeature,
+    lDial,
+    lDrop,
+    lForward,
+    lGatherDigits,
+    lGenerateDigits,
+    lGenerateTone,
+    lGetAddressCaps,
+    lGetAddressID,
+    lGetAddressStatus,
+    lGetAppPriority,
+    lGetCallInfo,
+    lGetCallStatus,
+    lGetConfRelatedCalls,
+    lGetCountry,
+    lGetDevCaps,
+    lGetDevConfig,
+    lGetIcon,
+    lGetID,
+    lGetLineDevStatus,
+    lGetNewCalls,
+    lGetNumRings,
+    lGetProviderList,
+    lGetRequest,
+    lGetStatusMessages,
+    lGetTranslateCaps,
+    lHandoff,
+    lHold,
+    lInitialize,
+    lMakeCall,
+    lMonitorDigits,
+    lMonitorMedia,
+    lMonitorTones,
+    lNegotiateAPIVersion,
+    lNegotiateExtVersion,
+    lOpen,
+    lPark,
+    lPickup,
+    lPrepareAddToConference,
+    lRedirect,
+    lRegisterRequestRecipient,
+    lReleaseUserUserInfo,
+    lRemoveFromConference,
+    lRemoveProvider,
+    lSecureCall,
+    lSendUserUserInfo,
+    lSetAppPriority,
+    lSetAppSpecific,
+    lSetCallParams,
+    lSetCallPrivilege,
+    lSetCurrentLocation,
+    lSetDevConfig,
+    lSetMediaControl,
+    lSetMediaMode,
+    lSetNumRings,
+    lSetStatusMessages,
+    lSetTerminal,
+    lSetTollList,
+    lSetupConference,
+    lSetupTransfer,
+    lShutdown,
+    lSwapHold,
+    lTranslateAddress,
+    lTranslateDialog,
+    lUncompleteCall,
+    lUnhold,
+    lUnpark,
+
+    pClose,
+    pConfigDialog,
+    pDevSpecific,
+    pGetButtonInfo,
+    pGetData,
+    pGetDevCaps,
+    pGetDisplay,
+    pGetGain,
+    pGetHookSwitch,
+    pGetID,
+    pGetIcon,
+    pGetLamp,
+    pGetRing,
+    pGetStatus,
+    pGetStatusMessages,
+    pGetVolume,
+    pInitialize,
+    pOpen,
+    pNegotiateAPIVersion,
+    pNegotiateExtVersion,
+    pSetButtonInfo,
+    pSetData,
+    pSetDisplay,
+    pSetGain,
+    pSetHookSwitch,
+    pSetLamp,
+    pSetRing,
+    pSetStatusMessages,
+    pSetVolume,
+    pShutdown,
+
+    tGetLocationInfo,
+    tRequestDrop,
+    tRequestMakeCall,
+    tRequestMediaCall,
+
+    GetTapi16CallbkMsg,
+    LOpenDialAsstVAL,
+    LAddrParamsInitedVAL
+
+} PROC_INDICES;
+
+
+typedef struct _TAPI16_CALLBACKMSG
+{
+    DWORD   hDevice;
+
+    DWORD   dwMsg;
+
+    DWORD   dwCallbackInstance;
+
+    DWORD   dwParam1;
+
+    DWORD   dwParam2;
+
+    DWORD   dwParam3;
+
+} TAPI16_CALLBACKMSG, FAR *LPTAPI16_CALLBACKMSG;
+
+
+typedef struct _TAPI_APP_DATA
+{
+    DWORD           dwKey;
+
+    HWND            hwnd;
+
+    LINECALLBACK    lpfnCallback;
+
+    BOOL            bPendingAsyncEventMsg;
+
+    DWORD           hXxxApp;
+
+} TAPI_APP_DATA, FAR *LPTAPI_APP_DATA;
+
+
+char far *gaFuncNames[] =
+{
+    "lineAccept",
+    "lineAddProvider",
+    "lineAddToConference",
+    "lineAnswer",
+    "lineBlindTransfer",
+    "lineClose",
+    "lineCompleteCall",
+    "lineCompleteTransfer",
+    "lineConfigDialog",
+    "lineConfigDialogEdit",
+    "lineConfigProvider",
+    "lineDeallocateCall",
+    "lineDevSpecific",
+    "lineDevSpecificFeature",
+    "lineDial",
+    "lineDrop",
+    "lineForward",
+    "lineGatherDigits",
+    "lineGenerateDigits",
+    "lineGenerateTone",
+    "lineGetAddressCaps",
+    "lineGetAddressID",
+    "lineGetAddressStatus",
+    "lineGetAppPriority",
+    "lineGetCallInfo",
+    "lineGetCallStatus",
+    "lineGetConfRelatedCalls",
+    "lineGetCountry",
+    "lineGetDevCaps",
+    "lineGetDevConfig",
+    "lineGetIcon",
+    "lineGetID",
+    "lineGetLineDevStatus",
+    "lineGetNewCalls",
+    "lineGetNumRings",
+    "lineGetProviderList",
+    "lineGetRequest",
+    "lineGetStatusMessages",
+    "lineGetTranslateCaps",
+    "lineHandoff",
+    "lineHold",
+    "lineInitialize",
+    "lineMakeCall",
+    "lineMonitorDigits",
+    "lineMonitorMedia",
+    "lineMonitorTones",
+    "lineNegotiateAPIVersion",
+    "lineNegotiateExtVersion",
+    "lineOpen",
+    "linePark",
+    "linePickup",
+    "linePrepareAddToConference",
+    "lineRedirect",
+    "lineRegisterRequestRecipient",
+    "lineReleaseUserUserInfo",
+    "lineRemoveFromConference",
+    "lineRemoveProvider",
+    "lineSecureCall",
+    "lineSendUserUserInfo",
+    "lineSetAppPriority",
+    "lineSetAppSpecific",
+    "lineSetCallParams",
+    "lineSetCallPrivilege",
+    "lineSetCurrentLocation",
+    "lineSetDevConfig",
+    "lineSetMediaControl",
+    "lineSetMediaMode",
+    "lineSetNumRings",
+    "lineSetStatusMessages",
+    "lineSetTerminal",
+    "lineSetTollList",
+    "lineSetupConference",
+    "lineSetupTransfer",
+    "lineShutdown",
+    "lineSwapHold",
+    "lineTranslateAddress",
+    "lineTranslateDialog",
+    "lineUncompleteCall",
+    "lineUnhold",
+    "lineUnpark",
+
+    "phoneClose",
+    "phoneConfigDialog",
+    "phoneDevSpecific",
+    "phoneGetButtonInfo",
+    "phoneGetData",
+    "phoneGetDevCaps",
+    "phoneGetDisplay",
+    "phoneGetGain",
+    "phoneGetHookSwitch",
+    "phoneGetID",
+    "phoneGetIcon",
+    "phoneGetLamp",
+    "phoneGetRing",
+    "phoneGetStatus",
+    "phoneGetStatusMessages",
+    "phoneGetVolume",
+    "phoneInitialize",
+    "phoneOpen",
+    "phoneNegotiateAPIVersion",
+    "phoneNegotiateExtVersion",
+    "phoneSetButtonInfo",
+    "phoneSetData",
+    "phoneSetDisplay",
+    "phoneSetGain",
+    "phoneSetHookSwitch",
+    "phoneSetLamp",
+    "phoneSetRing",
+    "phoneSetStatusMessages",
+    "phoneSetVolume",
+    "phoneShutdown",
+
+    "tapiGetLocationInfo",
+    "tapiRequestDrop",
+    "tapiRequestMakeCall",
+    "tapiRequestMediaCall",
+
+    "GetTapi16CallbackMsg",
+    "LOpenDialAsst",
+    "LAddrParamsInited"
+};
+
+
+DWORD     ghLib;
+HINSTANCE ghInst;
+MYPROC    gaProcs[NUM_TAPI32_PROCS];
+
+LRESULT
+CALLBACK
+Tapi16HiddenWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+#if CHICOBUILD
+DWORD
+FAR
+PASCAL
+LoadLibraryEx32W(
+    LPCSTR,
+    DWORD,
+    DWORD
+    );
+
+BOOL
+FAR
+PASCAL
+FreeLibrary32W(
+    DWORD
+    );
+
+DWORD
+FAR
+PASCAL
+GetProcAddress32W(
+    DWORD,
+    LPCSTR
+    );
+
+DWORD
+FAR
+PASCAL
+CallProc32W(
+    DWORD,
+    LPVOID,
+    DWORD,
+    DWORD
+    );
+#endif
+
+
+PFNCALLPROC1  pfnCallProc1  = (PFNCALLPROC1)  CallProc32W;
+PFNCALLPROC2  pfnCallProc2  = (PFNCALLPROC2)  CallProc32W;
+PFNCALLPROC3  pfnCallProc3  = (PFNCALLPROC3)  CallProc32W;
+PFNCALLPROC4  pfnCallProc4  = (PFNCALLPROC4)  CallProc32W;
+PFNCALLPROC5  pfnCallProc5  = (PFNCALLPROC5)  CallProc32W;
+PFNCALLPROC6  pfnCallProc6  = (PFNCALLPROC6)  CallProc32W;
+PFNCALLPROC7  pfnCallProc7  = (PFNCALLPROC7)  CallProc32W;
+PFNCALLPROC8  pfnCallProc8  = (PFNCALLPROC8)  CallProc32W;
+PFNCALLPROC9  pfnCallProc9  = (PFNCALLPROC9)  CallProc32W;
+PFNCALLPROC10 pfnCallProc10 = (PFNCALLPROC10) CallProc32W;
+PFNCALLPROC11 pfnCallProc11 = (PFNCALLPROC11) CallProc32W;
+PFNCALLPROC12 pfnCallProc12 = (PFNCALLPROC12) CallProc32W;
diff --git a/private/tapi/dev/tools16/c1.err b/private/tapi/dev/tools16/c1.err
new file mode 100644
index 000000000..e085e3c94
--- /dev/null
+++ b/private/tapi/dev/tools16/c1.err
@@ -0,0 +1,429 @@
+/* SCCSWHAT( "@(#)c1.err	3.69 90/02/01 12:58:41	" ) */
+						/* warnings */
+	
+4001	"nonstandard extension used - '%Fs'"
+4002	"too many actual parameters for macro '%s'"
+4003	"not enough actual parameters for macro '%s'"
+4004	"missing ')' after 'defined'"
+4005	"'%s' : macro redefinition"
+4006	"#undef expected an identifier"
+4007	"'%Fs' : must be '%Fs'"
+4008	"'%Fs' : '%Fs' attribute on data ignored"
+4009	"string too big, trailing characters truncated"
+4011	"identifier truncated to '%Fs'"
+4012	"float constant in a cross compilation" /* XC */
+4014	"'%Fs' : type of bit field must be unsigned"	/* QC2 */
+4015	"'%Fs' : type of bit field must be integral"
+4016	"'%s' : no function return type, using int as default"
+4017	"cast of int expression to far pointer"
+4018	"'%Fs' : signed/unsigned mismatch"
+4020	"'%Fs' : too many actual parameters"
+4021	"'%Fs' : too few actual parameters"
+4022	"'%Fs' : pointer mismatch : parameter %d"
+4023	"'%Fs' : _based pointer passed to unprototyped function : parameter %d"
+4024	"'%Fs' : different types : parameter %d"
+4026	"function declared with formal argument list"
+4027	"function declared without formal argument list"
+4028	"parameter %d declaration different"
+4029	"declared parameter list different from definition"
+4030	"first parameter list longer than the second"
+4031	"second parameter list longer than the first"
+4032	"unnamed struct/union as parameter"
+4033	"function must return a value"
+4034	"sizeof returns 0"
+4035	"'%Fs' : no return value"
+4037	"'%Fs' : formal parameters ignored" /* QC2 */
+4038	"'%Fs' : formal parameter has bad storage class"	/* QC2 */
+4040	"memory attribute on '%Fs' ignored"
+4042	"'%Fs' : has bad storage class"
+4044	"_huge on '%Fs' ignored, must be an array"
+4045	"'%s' : array bounds overflow"
+4046	"'&' on function/array, ignored"	/* QC2 */
+4047	"'%s' : different levels of indirection"
+4048	"array's declared subscripts different"
+4049	"'%s' : indirection to different types"
+4050	"'%s' : different code attributes"
+4051	"type conversion - possible loss of data"
+4053	"at least one void operand"
+4056	"overflow in constant arithmetic"	/* QC2, c1, c23 */
+4058	"address of automatic (local) variable taken, DS != SS" /* QC, c23 */
+4059	"segment lost in conversion"	/* QC, c23 */
+4060	"conversion of long address to short address"	/* QC2 */
+4061	"long/short mismatch in argument : conversion supplied"	/* QC, c23 */
+4062	"near/far mismatch in argument : conversion supplied"	/* QC, c23 */
+4067	"unexpected characters following '%s' directive - newline expected"
+4068	"unknown pragma"
+4069	"conversion of near pointer to long integer"	/* QC, c23 */
+4071	"'%Fs' : no function prototype given"
+4072	"'%Fs' : no function prototype on _fastcall function"
+4074	"nonstandard extension used - '%s'" /* QC2 */
+4075	"size of switch expression or case constant too large - converted to int" /* QC2 */
+4076	"'%s' : may be used on integral types only"
+4077	"unknown check_stack option"
+4078	"case constant '%ld' too big for the type of switch expression"
+4079	"unexpected token '%s'"
+4080	"expected identifier for segment name, found '%s'"
+4081	"expected a comma, found '%s'"
+4082	"expected an identifier, found '%s'"
+4083	"expected '(', found '%s'"
+4084	"expected a pragma directive, found '%s'"
+4085	"expected [on | off]"
+4086	"expected [1 | 2 | 4]"
+4087	"'%Fs' : declared with void parameter list"
+4088	"'%Fs' : pointer mismatch : parameter %d, parameter list %d"
+4089	"'%Fs' : different types : parameter %d, parameter list %d"
+4090	"different 'const/volatile' qualifiers"
+4091	"no symbols were declared"
+4092	"untagged enum/struct/union declared no symbols"
+4093	"unescaped newline in character constant in inactive code"
+4095	"expected ')', found '%s'"
+4096	"'%Fs' must be used with '%Fs'"
+4098	"void function returning a value"
+4100	"'%Fs' : unreferenced formal parameter"
+4101	"'%Fs' : unreferenced local variable"
+4102	"'%Fs' : unreferenced label"
+4104	"'%s' : near data in same_seg pragma, ignored"
+4105	"'%Fs' : code modifiers only on function or pointer to function"
+4106	"pragma requires integer between 1 and 127"
+4107	"pragma requires integer between 15 and 255"
+4108	"pragma requires integer between 79 and 132"
+4109	"unexpected identifier '%s'"
+4110	"unexpected token 'int constant'"
+4111	"unexpected token 'string'"
+4112	"macro name '%s' is reserved, '%s' ignored"
+4113	"function parameter lists differed"
+4114	"same type qualifier used more than once"
+4115	"'%Fs' : type definition in formal parameter list"
+4116	"(no tag) : type definition in formal parameter list"
+4118	"pragma not supported"
+4119	"different bases '%Fs' and '%Fs' specified"
+4120	"_based/unbased mismatch"
+4123	"different base expressions specified"
+4124	"_fastcall with stack checking is inefficient"
+4125	"decimal digit terminates octal escape sequence"
+4126	"'%c' : unknown memory model flag"
+4127	"conditional expression is constant"
+4128	"storage-class specifier after type"
+4129	"'%c' : unrecognized character escape sequence"
+4130	"'%Fs' : logical operation on address of string constant"
+4131	"'%Fs' : uses old-style declarator"
+4132	"'%Fs' : const object should be initialized"
+4135	"conversion between different integral types"
+4136	"conversion between different floating types"
+4137	"'%Fs' : no return value from floating-point function"
+4138	"'*/' found outside of comment"
+4139	"'0x%x' : hex escape sequence is out of range"
+4140	"'%Fs' : redefined, preceding references may be invalid"  /* QC */
+4185	"near call to '%Fs' in different segment" /* QC, c23 */
+4206	"assignment within conditional expression" /* QC, c23 */
+4401	"'%s' : member is bit field"
+4402	"must use PTR operator"
+4403	"illegal PTR operator"
+4404	"period on directive ignored"
+4405	"'%s' : identifier is reserved word"
+4406	"operand on directive ignored"
+4407	"operand size conflict"
+4408	"'%s' : ambiguous label"	/* QC2 */
+4409	"illegal instruction size"
+4410	"illegal size for operand"
+4411	"'%s' : symbol resolves to displacement register"
+4412	"'%s' : identifier is also assembler mnemonic"
+4413	"'%Fs' : redefined, preceding references may be invalid"  /* QC2 */
+4414	"'%Fs' : short jump to function converted to near"
+4000	"UNKNOWN WARNING\n\t\tContact Microsoft Product Support Services"
+						/* errors */
+	
+2001	"newline in constant"
+2003	"expected 'defined id'"
+2004	"expected 'defined(id)'"
+2005	"#line expected a line number, found '%s'"
+2006	"#include expected a file name, found '%s'"
+2007	"#define syntax"
+2008	"'%c' : unexpected in macro definition"
+2009	"reuse of macro formal '%Fs'"
+2010	"'%c' : unexpected in macro formal-parameter list"
+2012	"missing name following '<'"
+2013	"missing '>'"
+2014	"preprocessor command must start as first non-white-space"
+2015	"too many characters in constant"
+2016	"no closing single quotation mark"
+2017	"illegal escape sequence"
+2018	"unknown character '0x%x'"
+2019	"expected preprocessor directive, found '%c'"
+2021	"expected exponent value, not '%c'"
+2022	"'%ld' : too big for character"
+2023	"divide by 0"
+2024	"mod by 0"
+2025	"'%s' : enum/struct/union type redefinition"
+2026	"'%s' : member of enum redefinition"
+2027	"use of undefined enum/struct/union '%Fs'"
+2028	"struct/union member needs to be inside a struct/union"
+2030	"'%Fs' : struct/union member redefinition"
+2031	"'%Fs' : function cannot be struct/union member"
+2033	"'%Fs' : bit field cannot have indirection"
+2034	"'%Fs' : type of bit field too small for number of bits"
+2035	"struct/union '%Fs' : unknown size"
+2036	"left of '%s%s' must have a struct/union base type"	/* QC2 */
+2037	"left of '%s' specifies undefined struct/union '%Fs'"
+2038	"'%s' : not struct/union member"
+2039	"'->' : left operand must point to struct/union"	/* QC2 */
+2040	"'.' : left operand must have struct/union type"	/* QC2 */
+2041	"illegal digit '%c' for base %d"
+2042	"signed/unsigned keywords mutually exclusive"
+2043	"illegal break"
+2044	"illegal continue"
+2045	"'%s' : label redefined"
+2046	"illegal case"
+2047	"illegal default"
+2048	"more than one default"
+2049	"case value '%ld' already used"
+2050	"nonintegral switch expression"
+2051	"case expression not constant"
+2052	"case expression not integral"
+2053	"case value %d already used"	/* QC2 */
+2054	"expected '(' to follow '%Fs'"
+2055	"expected formal-parameter list, not a type list"
+2056	"illegal expression"
+2057	"expected constant expression"
+2058	"constant expression is not integral"
+2059	"syntax error : '%s'"
+2060	"syntax error : end-of-file found"
+2061	"syntax error : identifier '%s'"
+2062	"type '%s' unexpected"
+2063	"'%s' : not a function"
+2064	"term does not evaluate to a function"
+2065	"'%s' : undefined"
+2066	"cast to function type is illegal"
+2067	"cast to array type is illegal"
+2068	"illegal cast"
+2069	"cast of void term to nonvoid"
+2070	"illegal sizeof operand"
+2071	"'%Fs' : illegal storage class"
+2072	"'%Fs' : initialization of a function"
+2075	"'%Fs' : array initialization needs curly braces"
+2076	"'%Fs' : struct/union initialization needs curly braces"
+2077	"nonscalar field initializer '%Fs'"
+2078	"too many initializers"
+2079	"'%Fs' uses undefined struct/union '%Fs'"
+2080	"illegal far _fastcall function"
+2081	"'%Fs' : illegal memory attribute"	/* QC2 */
+2082	"redefinition of formal parameter '%Fs'"
+2084	"function '%Fs' already has a body"
+2085	"'%Fs' : not in formal-parameter list"
+2086	"'%Fs' : redefinition"
+2087	"'%Fs' : missing subscript"
+2090	"function returns array"
+2091	"function returns function"
+2092	"array element type cannot be function"
+2093	"cannot use address of automatic variable as static initializer"
+2094	"label '%Fs' was undefined"
+2095	"'%Fs' : actual has type void : parameter %d"
+2096	"struct/union comparison illegal"
+2097	"illegal initialization"
+2098	"nonaddress expression"
+2099	"nonconstant initializer"
+2100	"illegal indirection"
+2101	"'&' on constant"
+2102	"'&' requires lvalue"
+2103	"'&' on register variable"
+2104	"'&' on bit field ignored"
+2105	"'%s' needs lvalue"
+2106	"'%s' : left operand must be lvalue"
+2107	"illegal index, indirection not allowed"
+2108	"nonintegral index"
+2109	"subscript on nonarray"
+2110	"pointer + pointer"
+2111	"pointer + nonintegral value"
+2112	"illegal pointer subtraction"
+2113	"pointer subtracted from nonpointer"
+2114	"'%s' : pointer on left; needs integral right"
+2115	"'%s' : incompatible types"
+2116	"'%s' : illegal %s operand" /* QC2 */
+2117	"'%s' : illegal for struct/union"
+2118	"negative subscript"
+2119	"typedef types both define indirection"
+2120	"void illegal with all types"
+2121	"'%s' : bad %Fs operand"
+2124	"divide or mod by zero"
+2125	"'%Fs' : allocation exceeds 64K"	  /* QC, c23 */
+2127	"parameter allocation exceeds 32K"	/* QC, c23 */
+2130	"#line expected a string containing the file name, found '%s'"
+2131	"more than one memory attribute"
+2132	"syntax error : unexpected identifier"
+2133	"'%Fs' : unknown size"
+2134	"'%Fs' : struct/union too large"
+2136	"'%Fs' : prototype must have parameter types"
+2137	"empty character constant"
+2138	"unmatched close comment '*/'"	/* QC2 */
+2139	"type following '%s' is illegal"
+2140	"argument cannot be function type"
+2141	"value out of range for enum constant"
+2142	"ellipsis requires three periods"	/* QC2 */
+2143	"syntax error : missing '%s' before '%s'"
+2144	"syntax error : missing '%s' before type '%Fs'"
+2145	"syntax error : missing '%s' before identifier"
+2146	"syntax error : missing '%s' before identifier '%s'"
+2147	"unknown size"
+2148	"array too large"
+2149	"'%Fs' : named bit field cannot have 0 width"
+2150	"'%Fs' : bit field must have type int, signed int, or unsigned int"
+2151	"more than one language attribute"
+2152	"'%s' : pointers to functions with different attributes"
+2153	"hex constants must have at least 1 hex digit"
+2154	"'%Fs' : does not refer to a segment name"
+2156	"pragma must be outside function"
+2157	"'%s' : must be declared before use in pragma list"
+2158	"'%s' : is a function"
+2159	"more than one storage class specified"
+2160	"## cannot occur at the beginning of a macro definition"
+2161	"## cannot occur at the end of a macro definition"
+2162	"expected macro formal parameter"
+2163	"'%s' : not available as an intrinsic function"
+2164	"'%s' : intrinsic function not declared"
+2165	"'%s' : cannot modify pointers to data"
+2166	"lvalue specifies const object"
+2167	"'%Fs' : too many actual parameters for intrinsic"
+2168	"'%Fs' : too few actual parameters for intrinsic"
+2169	"'%Fs' : intrinsic function, cannot be defined"
+2170	"'%s' : not declared as a function, cannot be intrinsic"
+2171	"'%s' : illegal operand"
+2172	"'%Fs' : actual is not a pointer : parameter %d"
+2173	"'%Fs' : actual is not a pointer : parameter %d, parameter list %d"
+2174	"'%Fs' : actual has type void : parameter %d, parameter list %d"
+2175	"'%Fs' : unresolved external"	/* QC */
+2176	"static huge data not supported by /qc"	/* QC */
+2177	"constant too big"
+2178	"'%s' : storage class for same_seg variables must be extern"
+2179	"'%Fs' : was used in same_seg, but storage class is no longer extern"
+2180	"controlling expression has type void"
+2181	"pragma requires command line option '%s'"	/* QC2 */
+2182	"'%Fs' : has type void"
+2183	"pragma requires command line option '%Fs'"	/* QC */
+2185	"'%Fs' : illegal _based allocation"
+2187	"cast of near function pointer to far function pointer"
+2188	"#error : %s"	/* QC2 */
+2189	"#error : %Fs"
+2193	"'%Fs' : already in a segment"
+2194	"'%Fs' : is a text segment"
+2195	"'%Fs' : is a data segment"
+2196	"/ML cannot be used with floating point"	/* QC */
+2198	"'%Fs' : tried to be allocated in code segment '%Fs'"	/* QC2 */
+2199	"'%Fs' : tried to be allocated in data segment '%Fs'"	/* QC2 */
+2200	"'%Fs' : function has already been defined"
+2201	"'%Fs' : storage class must be extern"
+2202	"'interrupt' function must be 'far'"	/* QC2 */
+2203	"'%s' function must be 'cdecl'"	/* QC2 */
+2204	"'saveregs/interrupt' modifiers mutually exclusive"	/* QC2 */
+2205	"'%Fs' : cannot initialize extern block-scoped variables"
+2206	"'%Fs' : typedef cannot be used for function definition"
+2207	"'%Fs' in struct/union '%Fs' has a zero-sized array"
+2208	"no members defined using this type"
+2209	"type cast in _based construct must be (_segment)"
+2210	"'%Fs' : must be near/far data pointer"
+2211	"(_segment) applied to function identifier '%s'"
+2212	"'%Fs' : _based not available for functions/pointers to functions"
+2213	"'%s' : illegal argument to _based"
+2214	"pointers based on void require the use of :>"
+2215	":> operator only for objects based on void"
+2216	"'%Fs' may not be used with '%Fs'"
+2217	"'%Fs' must be used with '%Fs'"
+2218	"type in _based construct must be void"
+2219	"syntax error : type qualifier must be after '*'"
+2220	"warning treated as error - no object file generated"
+2221	"'.' : left operand points to struct/union, use '->'"
+2222	"'->' : left operand has struct/union type, use '.'"
+2223	"left of '->%Fs' must point to struct/union"
+2224	"left of '.%Fs' must have struct/union type"
+2225	"'%Fs' : first member of struct is unnamed"
+2400	"in-line syntax error in '%s', found '%Fs'"
+2401	"'%s' : register must be base in '%s'"
+2402	"'%s' : register must be index in '%s'"
+2403	"'%s' : register must be base/index in '%s'"
+2404	"'%s' : illegal register in '%s'"
+2405	"illegal short forward reference with offset"
+2406	"'%s' : name undefined in '%s'"
+2407	"illegal float register in '%s'"
+2408	"illegal type on PTR operator in '%s'"
+2409	"illegal type used as operator in '%s'"
+2410	"'%s' : ambiguous member name in '%s'"
+2411	"'%s' : illegal struct/union member in '%s'"
+2412	"'%Fs' : case insensitive label redefined"
+2413	"'%s' : illegal align size"
+2414	"illegal number of operands"
+2415	"improper operand type"
+2416	"'%s' : illegal opcode for processor"
+2417	"divide by zero in '%s'"
+2418	"'%Fs' : not in a register"
+2419	"mod by zero in '%s'"
+2420	"'%s' : illegal symbol in %s"
+2421	"PTR operator used with register in '%s'"
+2422	"illegal segment override in '%s'"
+2424	"'%Fs' : improper expression in '%s'"
+2425	"'%Fs' : nonconstant expression in '%s'"
+2426	"'%Fs' : illegal operator in '%s'"
+2427	"'%Fs' : jump referencing label is out of range"			/* QC */
+2428	"'%Fs' : segment redefinition"	/* QC2 */
+2429	"'%Fs' : illegal far label reference"
+2000	"UNKNOWN ERROR\n\t\tContact Microsoft Product Support Services"
+
+						/* fatals */
+
+1001	"Internal Compiler Error\n\t\t(compiler file '%s', line %d)\n\t\tContact Microsoft Product Support Services"
+1003	"error count exceeds %d; stopping compilation"
+1004	"unexpected end-of-file found"
+1005	"string too big for buffer"
+1006	"write error on compiler-generated file"
+1007	"unrecognized flag '%s' in '%s'"
+1008	"no input file specified"
+1009	"compiler limit : macros nested too deeply"
+1010	"compiler limit : macro expansion too big"
+1011	"compiler limit : '%s': macro definition too big"
+1012	"unmatched parenthesis - missing '%c'"
+1013	"cannot open source file '%s'"	/* QC2 */
+1014	"too many include files"
+1015	"cannot open include file '%s'"	/* QC2 */
+1016	"#if[n]def expected an identifier"
+1017	"invalid integer constant expression"
+1018	"unexpected '#elif'"
+1019	"unexpected '#else'"
+1020	"unexpected '#endif'"
+1021	"invalid preprocessor command '%s'"
+1022	"expected '#endif'"
+1023	"cannot open source file '%Fs'"
+1024	"cannot open include file '%Fs'"
+1025	"compiler terminated by user"	/* QC */
+1026	"parser stack overflow, please simplify your program"
+1027	"DGROUP data allocation exceeds 64K"	/* QC, c23 */
+1028	"'%s' : segment allocation exceeds 64K" /* QC */
+1031	"compiler limit : function calls nested too deeply"	/* QC, c23 */
+1032	"cannot open object listing file '%s'"	/* QC, c23 */
+1035	"expression too complex, please simplify"	/* QC, c23 */
+1037	"cannot open object file '%s'"	/* QC, c23 */
+1041	"cannot open compiler intermediate file - no more files"
+1042	"cannot open compiler intermediate file - no such file or directory"
+1043	"cannot open compiler intermediate file"
+1044	"out of disk space for compiler intermediate file"
+1045	"floating-point overflow"	/* QC2 */
+1047	"limit of %s exceeded at '%s'"
+1048	"unknown option '%c' in '%s'"
+1049	"invalid numerical argument '%s'"
+1052	"compiler limit : #if/#ifdef blocks nested too deeply"
+1053	"compiler limit : struct/union nested too deeply"
+1054	"compiler limit : initializers nested too deeply"
+1055	"compiler limit : out of keys"
+1056	"compiler limit : out of macro expansion space"
+1057	"unexpected end-of-file in macro expansion (missing ')'?)"
+1059	"compiler is out of near heap space"
+1060	"compiler is out of far heap space"
+1061	"compiler limit : blocks nested too deeply"	/* QC */
+1062	"error writing to preprocessor output file"
+1063	"compiler limit : compiler stack overflow"	/* QC */
+1064	"compiler limit : token overflowed internal buffer"
+1068	"cannot open file '%s'"
+1069	"write error on file '%s'"	/* QC */
+1070	"mismatched #if/#endif pair in file '%Fs'"
+1071	"unexpected end-of-file found in comment"
+1072	"'%Fs' : cannot read file"
+1126	"'%Fs' : automatic allocation exceeds %s" /* QC, c23 */
+1127	"'%Fs' : segment redefinition"
+1000	"UNKNOWN FATAL ERROR\n\t\tContact Microsoft Product Support Services"
diff --git a/private/tapi/dev/tools16/c23.err b/private/tapi/dev/tools16/c23.err
new file mode 100644
index 000000000..573839c68
--- /dev/null
+++ b/private/tapi/dev/tools16/c23.err
@@ -0,0 +1,78 @@
+						/* fatals */
+
+1001	"Internal Compiler Error\n\t\t(compiler file '%s', line %d)\n\t\tContact Microsoft Product Support Services"
+1002	"compiler is out of heap space in Pass 2"
+1003	"error count exceeds %d; stopping compilation"
+1004	"unexpected end-of-file found"
+1005	"string too big for buffer"
+1006	"write error on compiler intermediate file"
+1007	"unrecognized flag '%s' in '%s'"
+1013	"cannot open source file '%s'"
+1027	"DGROUP data allocation exceeds 64K"
+1029	"there are > 512 bytes of arguments"
+1030	"there are > 512 bytes of local variables"
+1032	"cannot open object listing file '%s'"
+1033	"cannot open assembly language output file '%s'"
+1035	"expression too complex, please simplify"
+1036	"cannot open source listing file '%s'"
+1037	"cannot open object file '%s'"
+1039	"unrecoverable heap overflow in Pass 3"
+1040	"unexpected end-of-file in source file '%s'"
+1041	"cannot open compiler intermediate file - no more files"
+1042	"cannot open compiler intermediate file - no such file or directory"
+1043	"cannot open compiler intermediate file"
+1044	"out of disk space for compiler intermediate file"
+1045	"floating-point overflow"
+1046	"bad '%s' flag, would overwrite '%s' with '%s'"
+1047	"too many '%s' flags, '%s'"
+1048	"unknown option '%c' in '%s'"
+1049	"invalid numerical argument '%s'"
+1050	"'%s' : code segment too large"
+1066	"intrinsic not implemented"
+1090	"'%s' data allocation exceeds 64K"
+1126	"'%s' : automatic allocation exceeds %s"
+1127	"'%s': segment redefinition"
+1000	"UNKNOWN FATAL ERROR\n\t\tContact Microsoft Product Support Services"
+						/* errors */
+	
+2125	"'%s' : allocation exceeds 64K"
+2127	"parameter allocation exceeds 32K"
+2128	"'%s' : huge array cannot be aligned to segment boundary"
+2129	"static function '%s' not found"
+2418	"'%s' : not in a register"
+2220	"warning treated as error - no object file generated"
+2427	"'%s' : jump referencing label is out of range"
+2000	"UNKNOWN ERROR\n\t\tContact Microsoft Product Support Services"
+
+						/* warnings */
+	
+4056	"overflow in constant arithmetic"
+4057	"overflow in constant multiplication"
+4058	"address of automatic (local) variable taken, DS != SS"
+4059	"segment lost in conversion"
+4061	"long/short mismatch in argument : conversion supplied"
+4062	"near/far mismatch in argument : conversion supplied"
+4063	"'%s' : function too large for post-optimizer"
+4065	"recoverable heap overflow in post-optimizer - some optimizations may be missed"
+4066	"local symbol table overflow - some local symbols may be missing in listings"
+4069	"conversion of near pointer to long integer"
+4073	"scoping too deep, deepest scoping merged when debugging"
+4127	"conditional expression is constant"
+4185	"near call to '%s' in different segment"
+4186	"string too long - truncated to %d characters"
+4200	"local variable '%s' used without having been initialized"
+4201	"local variable '%s' may be used without having been initialized"
+4202	"unreachable code"
+4203	"'%s' : function too large for global optimizations"
+4204	"'%s' : in-line assembler precludes global optimizations"
+4205	"statement has no effect"
+4206	"assignment within conditional expression"
+4207	"'%s' : function too large for global optimizations (%s)"  /*
+internal use */
+4208    "Ran out of heap at: %s"  /* internal use */
+4209	"comma operator within array index expression"
+4300	"insufficient memory to process debugging information"
+4301	"loss of debugging information caused by optimization"
+4323	"potential divide by 0"
+4324	"potential mod by 0"
+4000	"UNKNOWN WARNING\n\t\tContact Microsoft Product Support Services"
diff --git a/private/tapi/dev/tools16/cl.err b/private/tapi/dev/tools16/cl.err
new file mode 100644
index 000000000..d51b85520
--- /dev/null
+++ b/private/tapi/dev/tools16/cl.err
@@ -0,0 +1,36 @@
+				/* error messages */
+
+2001	"too many symbols predefined with /D"
+2002	"conflict in memory-model specification"
+2003	"missing source file name"
+2008	"limit of %s exceeded at '%s'"
+2011	"only one floating-point option allowed"
+2012	"too many linker flags on command line"
+2013	"incomplete model specification"
+2016	"'%s' and '%s' are incompatible"
+2018	"cannot open linker response file"
+2019	"cannot overwrite the source/object file, '%s'"
+2020	"%s option requires extended keywords to be enabled (/Ze)"
+2021	"invalid numerical argument '%s'"
+2022	"cannot open help file, '%s'"
+2027	"could not execute '%s'"
+2028	"too many open files, cannot redirect '%s'"
+2030	"INTERNAL COMPILER ERROR in '%s'\n\t\tContact Microsoft Product Support Services"
+2031	"too many flags/files on command line"
+2000	"UNKNOWN COMMAND LINE ERROR\n\t\tContact Microsoft Product Support Services"
+
+				/* warning messages */
+
+4001	"listing overrides assembly output"
+4002	"ignoring unknown flag '%s'"
+4003	"different processors selected for code generation"
+4005	"could not locate '%s';\nPlease enter new file name (full path) or Ctrl-C to quit: "
+4007	"/C ignored (must also specify /P or /E or /EP)"
+4009	"threshold only for far/huge data, ignored"
+4011	"preprocessing overrides source listing"
+4012	"function declarations override source listing"
+4013	"combined listing overrides object listing"
+4014	"invalid value '%d' for '%s'; default '%d' is used"
+4018	".DEF files supported in protected mode only"
+4019	"string too long; truncated to '%d' characters"
+4000	"UNKNOWN COMMAND LINE WARNING\n\t\tContact Microsoft Product Support Services"
diff --git a/private/tapi/dev/tools16/cl.msg b/private/tapi/dev/tools16/cl.msg
new file mode 100644
index 000000000..3da879b17
--- /dev/null
+++ b/private/tapi/dev/tools16/cl.msg
@@ -0,0 +1,96 @@
+C COMPILER OPTIONS
+-MEMORY MODEL-
+/AS small model (default)
+/AC compact model
+/AM medium model
+/AL large model
+/AH huge model
+/AT tiny model (.COM files)
+-OPTIMIZATION-
+/O enable optimization (same as /Ot)
+/Oa ignore aliasing
+/Od disable optimizations
+/Oe enable registers allocations
+/Og enable global optimization
+/Oi enable intrinsic functions
+/Ol enable loop optimizations
+/On disable "unsafe" optimizations
+/Op enable precision optimizations
+/Or disable in_line return
+/Os optimize for space
+/Ot optimize for speed (default)
+/Ow assume aliasing in function calls
+/Ox max. optimization (/Oegilt /Gs)
+-CODE GENERATION-
+/G0 8086 instructions (default)
+/G1  186 instructions
+/G2  286 instructions
+/Gm put strings in constant segment
+/Gc Pascal style function calls
+/Gr _fastcall type calls
+/Gs no stack checking
+/Gt[number] data size threshold
+/Gw Windows entry sequence
+-OUTPUT FILES-
+/Fa[assembly listing file]
+/Fb[bound executable file]
+/Fc[mixed source/object listing file]
+/Fe<executable file>
+/Fl[object listing file]
+/Fm[map file]
+/Fo<object file>
+/Fr[source browser info file]
+/FR[extended source browser info file]
+/Fs[source listing file]
+-PREPROCESSOR-
+/C don't strip comments
+/D<name>[=text] define macro
+/E preprocess to stdout
+/EP same as /E but no #line
+/I<name> add #include path
+/P preprocess to file
+/U<name> remove predefined macro
+/u remove all predefined macros
+/X ignore "standard places"
+-LANGUAGE-
+/Za disable extensions
+/Zd line number information
+/Ze enable extensions (default)
+/Zg generate declarations
+/Zi symbolic debugging information
+/Zl remove default library info
+/Zp[n] pack structs on n-byte boundary
+/Zs syntax check only
+-FLOATING POINT-
+/FPa calls with altmath
+/FPc calls with emulator
+/FPc87 calls with 8087 library
+/FPi inline with emulator (default)
+/FPi87 inline with 8087
+-SOURCE LISTING-
+/Sl<columns> set line width
+/Sp<lines> set page length
+/St<string> set title string
+/Ss<string> set subtitle string
+-MISCELLANEOUS-
+/B[123]<pass> to invoke different C[123]
+/c compile only, no link
+/H<number> external name length
+/J default char type is unsigned
+/qc use quick compile feature
+/Tc<file> compile file without .c
+/V<string> set version string
+/W<number> warning level
+-MASM SUPPORT-
+/MA<MASM switch>
+/Ta<file> assemble file without .asm
+/Fx[MASM's cross-reference file] 
+-LINKING-
+/F <hex_number> stack size (hex. bytes)
+/Lc link compatibility mode executable
+/Lr link compatibility mode executable
+/Lp link protect mode executable
+/link [linker_options_and_libraries]
+/ML link C runtime as part of DLL
+/MD use C runtime as DLL
+/MT support multi-thread
diff --git a/private/tapi/dev/tools16/rcqq.err b/private/tapi/dev/tools16/rcqq.err
new file mode 100644
index 000000000..d26c8494d
--- /dev/null
+++ b/private/tapi/dev/tools16/rcqq.err
@@ -0,0 +1,334 @@
+/* SCCSWHAT( "@(#)c1.err	2.29 88/02/25 18:18:00	" ) */
+						/* fatals */
+
+1001	"Internal Compiler Error\n\t\t(compiler file '%s', line %d)\n\t\tContact Microsoft Technical Support"
+1002	"out of heap space"
+1003	"error count exceeds %d; stopping compilation"
+1004	"unexpected EOF"
+1005	"string too big for buffer"
+1006	"write error on compiler intermediate file"
+1007	"unrecognized flag '%s' in '%s'"
+1008	"no input file specified"
+1009	"compiler limit : macros too deeply nested"
+1010	"compiler limit : macro expansion too big"
+1012	"bad parenthesis nesting - missing '%c'"
+1013	"cannot open source file '%s'"
+1014	"too many include files"
+1015	"cannot open include file '%s'"
+1016	"#if[n]def expected an identifier"
+1017	"invalid integer constant expression"
+1018	"unexpected '#elif'"
+1019	"unexpected '#else'"
+1020	"unexpected '#endif'"
+1021	"bad preprocessor command '%s'"
+1022	"expected '#endif'"
+1023	"no int size specified"
+1024	"no ptr size specified"
+1025	"no function size specified"
+1026	"parser stack overflow, please simplify your program"
+1027	"DGROUP data allocation exceeds 64K"	/* QC, c23 */
+1028	"%s segment allocation exceeds 64K"	/* QC */
+1031	"compiler limit : function calls too deeply nested"	/* QC, c23 */
+1032	"cannot open object listing file '%s'"			/* QC, c23 */
+1035	"expression too complex, please simplify"		/* QC, c23 */
+1037	"cannot open object file '%s'"					/* QC, c23 */
+1041	"cannot open compiler intermediate file - no more files"
+1042	"cannot open compiler intermediate file - no such file or directory"
+1043	"cannot open compiler intermediate file"
+1044	"out of disk space for compiler intermediate file"
+1045	"floating point overflow"
+1047	"too many %s flags, '%s'"
+1048	"unknown option '%c' in '%s'"
+1049	"invalid numerical argument '%s'"
+1052	"too many #if/#ifdef's"
+1053	"compiler limit : struct/union nesting"
+1054	"compiler limit : initializers too deeply nested"
+1055	"compiler limit : out of keys"
+1056	"compiler limit : out of macro expansion space"
+1057	"unexpected EOF in macro expansion (missing ')'?)"
+1059	"out of near heap space"
+1060	"out of far heap space"
+1061	"compiler limit : blocks too deeply nested"	/* QC */
+1062	"error writing to preprocessor output file"
+1063	"compiler limit : compiler stack overflow"	/* QC */
+1064	"compiler limit : identifier overflowed internal buffer"
+1065	"compiler limit : declarator too complex"
+1000	"UNKNOWN FATAL ERROR\n\t\tContact Microsoft Technical Support"
+
+						/* errors */
+	
+2001	"newline in constant"
+2002	"out of macro actual parameter space"
+2003	"expected 'defined id'"
+2004	"expected 'defined(id)'"
+2005	"#line expected a line number, found '%s'"
+2006	"#include expected a file name, found '%s'"
+2007	"#define syntax"
+2008	"'%c' : unexpected in macro definition"
+2009	"reuse of macro formal '%s'"
+2010	"'%c' : unexpected in formal list"
+2011	"'%s' : definition too big"
+2012	"missing name following '<'"
+2013	"missing '>'"
+2014	"preprocessor command must start as first non-whitespace"
+2015	"too many chars in constant"
+2016	"no closing single quote"
+2017	"illegal escape sequence"
+2018	"unknown character '0x%x'"
+2019	"expected preprocessor command, found '%c'"
+2020	"bad octal number '%c'"
+2021	"expected exponent value, not '%c'"
+2022	"'%ld' : too big for char"
+2023	"divide by 0"
+2024	"mod by 0"
+2025	"'%s' : enum/struct/union type redefinition"
+2026	"'%s' : member of enum redefinition"
+2028	"struct/union member needs to be inside a struct/union"
+2029	"'%Fs' : bit-fields only allowed in structs"
+2030	"'%Fs' : struct/union member redefinition"
+2031	"'%Fs' : function cannot be struct/union member"
+2032	"'%Fs' : base type with near/far/huge not allowed"
+2033	"'%Fs' : bit-field cannot have indirection"
+2034	"'%Fs' : bit-field type too small for number of bits"
+2035	"enum/struct/union '%Fs' : unknown size"
+2036	"left of '%s%s' must have a struct/union type"
+2037	"left of '%s' specifies undefined struct/union '%Fs'"
+2038	"'%s' : not struct/union member"
+2039	"'->' requires struct/union pointer"
+2040	"'.' requires struct/union name"
+2042	"signed/unsigned keywords mutually exclusive"
+2043	"illegal break"
+2044	"illegal continue"
+2045	"'%s' : label redefined"
+2046	"illegal case"
+2047	"illegal default"
+2048	"more than one default"
+2050	"non-integral switch expression"
+2051	"case expression not constant"
+2052	"case expression not integral"
+2053	"case value %d already used"
+2054	"expected '(' to follow '%Fs'"
+2055	"expected formal parameter list, not a type list"
+2056	"illegal expression"
+2057	"expected constant expression"
+2058	"constant expression is not integral"
+2059	"syntax error : '%s'"
+2060	"syntax error : EOF"
+2061	"syntax error : identifier '%s'"
+2062	"type '%s' unexpected"
+2063	"'%s' : not a function"
+2064	"term does not evaluate to a function"
+2065	"'%s' : undefined"
+2066	"cast to function returning . . . is illegal"
+2067	"cast to array type is illegal"
+2068	"illegal cast"
+2069	"cast of 'void' term to non-void"
+2070	"illegal sizeof operand"
+2071	"'%Fs' : bad storage class"
+2072	"'%Fs' : initialization of a function"
+2073	"'%Fs' : cannot initialize array in function"
+2074	"'%Fs' : cannot initialize struct/union in function"
+2075	"'%Fs' : array initialization needs curly braces"
+2076	"'%Fs' : struct/union initialization needs curly braces"
+2077	"non-integral field initializer '%Fs'"
+2078	"too many initializers"
+2079	"'%Fs' uses undefined struct/union '%Fs'"
+2082	"redefinition of formal parameter '%Fs'"
+2083	"array '%Fs' already has a size"
+2084	"function '%Fs' already has a body"
+2085	"'%Fs' : not in formal parameter list"
+2086	"'%Fs' : redefinition"
+2087	"'%Fs' : missing subscript"
+2088	"use of undefined enum/struct/union '%s'"
+2089	"typedef specifies a near/far function"
+2090	"function returns array"
+2091	"function returns function"
+2092	"array element type cannot be function"
+2093	"cannot initialize a static or struct with address of automatic vars"
+2094	"label '%Fs' was undefined"
+2095	"'%Fs' : actual has type void : parameter %d"
+2096	"struct/union comparison illegal"
+2097	"illegal initialization"
+2098	"non-address expression"
+2099	"non-constant offset"
+2100	"illegal indirection"
+2101	"'&' on constant"
+2102	"'&' requires lvalue"
+2103	"'&' on register variable"
+2104	"'&' on bit-field ignored"
+2105	"'%s' needs lvalue"
+2106	"'%s' : left operand must be lvalue"
+2107	"illegal index, indirection not allowed"
+2108	"non-integral index"
+2109	"subscript on non-array"
+2110	"'+' : 2 pointers"
+2111	"pointer + non-integral value"
+2112	"illegal pointer subtraction"
+2113	"'-' : right operand pointer"
+2114	"'%s' : pointer on left; needs integral right"
+2115	"'%s' : incompatible types"
+2116	"'%s' : bad %s operand"
+2117	"'%s' : illegal for struct/union"
+2118	"negative subscript"
+2119	"'typedefs' both define indirection"
+2120	"'void' illegal with all types"
+2121	"typedef specifies different enum"
+2122	"typedef specifies different struct"
+2123	"typedef specifies different union"
+2125	"%Fs : allocation exceeds 64K"		/* QC, c23 */
+2126	"%Fs : auto allocation exceeds %s"	/* QC, c23 */
+2127	"parameter allocation exceeds 32K"	/* QC, c23 */
+2130	"#line expected a string containing the file name, found '%s'"
+2131	"attributes specify more than one near/far/huge"
+2132	"syntax error : unexpected identifier"
+2133	"array '%Fs' : unknown size"
+2134	"'%Fs' : struct/union too large"
+2135	"missing ')' in macro expansion"
+2137	"empty character constant"
+2138	"unmatched close comment '*/'"
+2139	"type following '%s' is illegal"
+2140	"argument type cannot be function returning . . ."
+2141	"value out of range for enum constant"
+2142	"ellipsis requires three periods"
+2143	"syntax error : missing '%s' before '%s'"
+2144	"syntax error : missing '%s' before type '%Fs'"
+2145	"syntax error : missing '%s' before identifier"
+2146	"syntax error : missing '%s' before identifier '%s'"
+2147	"unknown size"
+2148	"array too large"
+2149	"'%Fs' : named bit-field cannot have 0 width"
+2150	"'%Fs' : bit-field must have type int, signed int, or unsigned int"
+2151	"more than one cdecl/fortran/pascal attribute specified"
+2152	"'%s' : pointers to functions with different attributes"
+2153	"hex constants must have at least 1 hex digit"
+2154	"'%s' : does not refer to a segment"
+2155	"'%s' : already in a segment"
+2156	"pragma must be at outer level"
+2157	"'%s' : must be declared before use in pragma list"
+2158	"'%s' : is a function"
+2159	"more than one storage class specified"
+2160	"## cannot occur at the beginning of a macro definition"
+2161	"## cannot occur at the end of a macro definition"
+2162	"expected macro formal parameter"
+2163	"'%s' : not available as an intrinsic"
+2164	"'%s' : intrinsic was not declared"
+2165	"'%s' : cannot modify pointers to data"
+2166	"lval specifies 'const' object"
+2167	"'%Fs' : too many actual parameters for intrinsic"
+2168	"'%Fs' : too few actual parameters for intrinsic"
+2169	"'%Fs' : is an intrinsic, it cannot be defined"
+2170	"'%s' : intrinsic not declared as a function"
+2171	"'%s' : bad operand"
+2172	"'%Fs' : actual is not a pointer : parameter %d"
+2173	"'%Fs' : actual is not a pointer : parameter %d, parameter list %d"
+2174	"'%Fs' : actual has type void : parameter %d, parameter list %d"
+2175	"'%Fs' : unresolved external"	/* QC */
+2176	"static far data not supported"	/* QC */
+2177	"constant too big"
+2178	"'%s' : storage class for same_seg variables must be 'extern'"
+2179	"'%Fs' : was used in same_seg, but storage class is no longer 'extern'"
+2180	"controlling expression has type 'void'"
+2181	"pragma requires command line option '%s'"	/* QC */
+2182	"'%Fs' : 'void' on variable"
+2183	"'%Fs' : 'interrupt' function must be 'far'"
+2184	"'%Fs' : '%s' function cannot be 'pascal/fortran'"
+2186	"'%Fs' : 'saveregs/interrupt' modifiers mutually exclusive"
+2187	"cast of near function pointer to far function pointer"
+2188	"#error : %s"
+2190	"'%s' : is a text segment"
+2191	"'%s' : is a data segment"
+2192	"'%s' : function has already been defined"
+2000	"UNKNOWN ERROR\n\t\tContact Microsoft Technical Support"
+
+						/* warnings */
+	
+4001	"macro '%s' requires parameters"
+4002	"too many actual parameters for macro '%s'"
+4003	"not enough actual parameters for macro '%s'"
+4004	"missing close parenthesis after 'defined'"
+4005	"'%s' : redefinition"
+4006	"#undef expected an identifier"
+4009	"string too big, trailing chars truncated"
+4011	"identifier truncated to '%s'"
+4012	"float constant in a cross compilation"
+4013	"constant too big"
+4014	"'%Fs' : bit-field type must be unsigned"
+4015	"'%Fs' : bit-field type must be integral"
+4016	"'%s' : no function return type, using 'int' as default"
+4017	"cast of int expression to far pointer"
+4020	"'%Fs' : too many actual parameters"
+4021	"'%Fs' : too few actual parameters"
+4022	"'%Fs' : pointer mismatch : parameter %d"
+4024	"'%Fs' : different types : parameter %d"
+4025	"function declaration specified variable argument list"
+4026	"function was declared with formal argument list"
+4027	"function was declared without formal argument list"
+4028	"parameter %d declaration different"
+4029	"declared parameter list different from definition"
+4030	"first parameter list is longer than the second"
+4031	"second parameter list is longer than the first"
+4032	"unnamed struct/union as parameter"
+4033	"function must return a value"
+4034	"sizeof returns 0"
+4035	"'%Fs' : no return value"
+4036	"unexpected formal parameter list"
+4037	"'%Fs' : formal parameters ignored"
+4038	"'%Fs' : formal parameter has bad storage class"
+4039	"'%Fs' : function used as an argument"
+4040	"near/far/huge on '%Fs' ignored"
+4041	"formal parameter '%s' is redefined"
+4042	"'%Fs' : has bad storage class"
+4044	"huge on '%Fs' ignored, must be an array"
+4045	"'%s' : array bounds overflow"
+4046	"'&' on function/array, ignored"
+4047	"'%s' : different levels of indirection"
+4048	"array's declared subscripts different"
+4049	"'%s' : indirection to different types"
+4051	"data conversion"
+4052	"different enum types"
+4053	"at least one void operand"
+4060	"conversion of long address to short address"	/* QC, c23 */
+4061	"long/short mismatch in argument : conversion supplied"	/* QC, c23 */
+4062	"near/far mismatch in argument : conversion supplied"	/* QC, c23 */
+4067	"unexpected characters following '%s' directive - newline expected"
+4068	"unknown pragma"
+4071	"'%Fs' : no function prototype given"
+4074	"non standard extension used - '%s'"
+4075	"size of switch expression or case constant too large - converted to int"
+4076	"'%s' : may be used on integral types only"
+4077	"unknown check_stack option"
+4079	"unexpected token '%s'"
+4080	"expected 'identifier' for segment name, found '%s'"
+4081	"expected a comma, found '%s'"
+4082	"expected an identifier, found '%s'"
+4083	"expected '(', found '%s'"
+4084	"expected a pragma keyword, found '%s'"
+4085	"expected [on | off]"
+4086	"expected [1 | 2 | 4]"
+4087	"'%Fs' : declared with 'void' parameter list"
+4088	"'%Fs' : pointer mismatch : parameter %d, parameter list %d"
+4089	"'%Fs' : different types : parameter %d, parameter list %d"
+4090	"different 'const' attributes"
+4091	"no symbols were declared"
+4092	"untagged enum/struct/union declared no symbols"
+4093	"unescaped newline in character constant in non-active code"
+4094	"unexpected newline"
+4095	"expected ')', found '%s'"
+4096	"huge treated as far"		/* QC */
+4098	"void function returning a value"
+4099	"expected ')', (too many arguments?)"
+4100	"'%Fs' : unreferenced formal parameter"
+4101	"'%Fs' : unreferenced local variable"
+4102	"'%Fs' : unreferenced label"
+4103	"'%Fs' : function definition used as prototype"
+4104	"'%s' : near data in same_seg pragma, ignored"
+4105	"'%Fs' : code modifiers only on function or pointer to function"
+4106	"pragma requires integer between 1 and 127"
+4107	"pragma requires integer between 15 and 255"
+4108	"pragma requires integer between 79 and 132"
+4109	"unexpected identifier '%s'"
+4110	"unexpected token 'int constant'"
+4111	"unexpected token 'string'"
+4112	"macro name '%s' is reserved, %s ignored"
+4113	"function parameter lists differed"
+4000	"UNKNOWN WARNING\n\t\tContact Microsoft Technical Support"
diff --git a/private/tapi/dirs b/private/tapi/dirs
new file mode 100644
index 000000000..38a55f7ce
--- /dev/null
+++ b/private/tapi/dirs
@@ -0,0 +1,24 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     dev
diff --git a/private/tapi/docs/areas.xls b/private/tapi/docs/areas.xls
new file mode 100644
index 000000000..e1f48cf3c
--- /dev/null
+++ b/private/tapi/docs/areas.xls
diff --git a/private/tapi/docs/files.xls b/private/tapi/docs/files.xls
new file mode 100644
index 000000000..4d3bf8574
--- /dev/null
+++ b/private/tapi/docs/files.xls
diff --git a/private/tapi/docs/testplan.doc b/private/tapi/docs/testplan.doc
new file mode 100644
index 000000000..42f477670
--- /dev/null
+++ b/private/tapi/docs/testplan.doc
diff --git a/private/tapi/docs/testschd.xls b/private/tapi/docs/testschd.xls
new file mode 100644
index 000000000..3de18d7c7
--- /dev/null
+++ b/private/tapi/docs/testschd.xls
diff --git a/private/tapi/qa/apps/addbook/ab.inc b/private/tapi/qa/apps/addbook/ab.inc
new file mode 100644
index 000000000..980ed92a2
--- /dev/null
+++ b/private/tapi/qa/apps/addbook/ab.inc
@@ -0,0 +1,747 @@
+
+'******************************************************************************
+
+' Hyper_Term.inc												 
+' Created May, 22 1996
+' By Ron Rohr
+
+' This include file contains all the Functions used by the
+' HyperTrm.MST test Script
+
+'******************************************************************************
+
+' Note: This file uses the Object Naming convention defined in the Visual Basic
+' 4.0 Programmers Guide to name variables and contants associated with a control.
+
+'$IFNDEF Address_Book_INC
+'$DEFINE Address_Book_INC
+ 
+'******************** Begin Procedure Declarations ****************************
+
+Declare Sub      EndTest ()
+Declare Sub		  BoundsChkHandler (vtNotifyData as variant)
+Declare Sub		  SetWndTimeout ()
+Declare Function DetectModem() as long
+Declare Function Call_Dialing_Prop (hTabCtrl as long, hMLTab as long, hTDTab as long) as long
+Declare sub      GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+Declare sub      EditLocationInfo (NewLocal as location, hML_Child() as long)
+Declare Function StartAddBook( hAB as long ) as long
+Declare Function DialNumber( hAB as long, ML_ChildID() as long  ) as long
+
+'******************** Begin Procedure *****************************************
+
+'******************************************************************************
+'Name   : EndTest
+'Desc   : On End cleanup procedure.
+' 
+'Parms  : None
+'
+'Return : None. 
+'
+'History: 05/22/96 : a-rrohr: Created
+'*****************************************************************************
+Sub EndTest ()
+
+CloseCase (TEST_SCRIPT_TITLE)
+
+CloseLog ()
+
+Statusbox "The Address Book/TAPI Test is now Complete" + CRLF + _
+			 "Test Case Number " + ltrim$(str$(TC_ID)), 0,0,0,0, TRUE, TRUE 
+Sleep 4
+ 
+End Sub 'EndTest
+
+'*****************************************************************************
+'Name   : BoundsChkHandler
+'Desc   : This routine is called whenever BoundsChecker uncovers a failure.
+'		    The failure is then written ton the log and reports to the user via
+'			 a message box. 
+'			 The routine is called with the On BoundsCheckerNotify (NULL) Call
+'			 BoundsChkHandler statement in DP32.mst.
+'
+'Parms  : None. 
+'
+'Return : None. Writes failure data directly to  the log.
+'
+'History: 02/26/96 : a-rrohr: Created
+'*****************************************************************************
+sub BoundsChkHandler (vtNotifyData as variant)
+
+dim ErrorMessage as string, SizeofString as long, count as short, lastchar as short
+
+ErrorMessage = "Unexpected BoundsChecker error in Dialing Properties Test"  + CRLF
+
+' Since the size of the string BoundsChecker returns is unknown the routine must be
+' capable of formatting a large string into a paragraph whose lines are not greater
+' than 72 characters.
+
+While (len(vtNotifyData) >= 72)
+	SizeofString = len(vtNotifyData)
+	count = 1
+	do
+		lastchar = count
+		count = instr(lastchar + 1,vtNotifyData, " ")
+	' instr(lastchar + 1,vtNotifyData, " ") will return zero on the last word of
+	' the string so break the do loop when count = 0
+	loop while count < 72 and count <> 0
+
+	ErrorMessage = ErrorMessage + rtrim$(left$(vtNotifyData, lastchar)) + CRLF
+	vtNotifyData = right$(vtNotifyData, (SizeofString - lastchar))
+Wend
+
+If (len(vtNotifyData) >= 1) then 
+		ErrorMessage = ErrorMessage + vtNotifyData + CRLF
+end if
+
+
+'$IFDEF DEBUG_TEST_SCRIPT
+if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+   resume next
+else
+   Stop
+endif
+'$ENDIF 'DEBUG_TEST_SCRIPT
+
+end sub 'BoundsChkHandler
+'******************************************************************************
+'Name   : SetWndTimeout
+'Desc   : Sets the timeout variable used by the WFndWnd function.
+'			 Some of the platforms tested on are very slow and if the timeout isn't
+'			 long enough then	the test continues with out finding the Window and its
+'			 handle, dooming all subsequent test (that are dependent on this handle)
+'			 to complete and utter failure.
+' 
+'Parms  : None
+'
+'Return : None. Sets the Global String variables WTIMEOUT
+'
+'History: 02/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+ Sub SetWndTimeout ()
+
+ dim tempstring as string									' Generic string variable
+
+ SetActiveTimeout	(150)
+ SetDefaultWaitTimeout (2)
+
+ tempstring = space(40)
+ tempstring = environ$("PROCESSOR_ARCHITECTURE")
+
+ select case tempstring
+
+	case "x86", "MIPS"
+		WTIMEOUT = 5		
+	case "PPC", "Alpha"
+		WTIMEOUT = 20		
+	case else
+		WTIMEOUT = 30		
+	   WritelogItem ("" ,"SetWndTimeout Subroutine - TAPI_BVT.inc")
+	   WritelogItem ("" ,"Unable to set WTIMEOUT: Unknown Processor Architecture")
+	   WritelogItem ("" ,"Processor Architecture	environment variable = " +  tempstring)
+	   WritelogItem ("" ," ")
+end select
+
+'$IFDEF NUMEGA
+		WTIMEOUT = WTIMEOUT + 5 'If using BoundsChecker then add a few more seconds
+'$ENDIF
+
+end Sub  'SetWndTimeout ()
+
+'******************************************************************************
+'Name   : DetectModem
+'Desc   : Runs Modem.cpl and determines if a modem is installed by which modem
+'		  dialog appears
+'			 
+'Parms  : None
+'
+'Return : True  if a Modem is set up on this computer
+'		  False if not.
+'
+'History: 04/15/96 : a-rrohr: Created
+'******************************************************************************
+
+Function DetectModem() as long
+
+dim w_Flags as long
+dim handle  as long, hCtrl as long
+dim Close_cmdID as long
+dim SysDirPath as string
+dim rtn as long
+
+'Initialize variables
+
+Close_cmdID = &h01&	'Close Command button ID on Modem Properties dialog
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+SysDirPath = string$(168, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + MODEM_APPLET, BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + MODEM_APPLET, nowait
+'$endif 'NUMEGA
+
+DetectModem = FALSE	 'Set default return value
+
+'if the Modems Properties dialog appears then a modem is set up on the computer
+
+handle =  WFndWndC (MODEM_PROP_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'a Modem is set up on this computer
+	hCtrl = GetDlgItem (handle, Close_cmdID)
+	WButtonClick (_hwnd(hCtrl))
+   WritelogItem ("" , "Modem Connected")
+	DetectModem = TRUE
+	Goto EndOFFunction
+endif
+
+'if the Install New Modem dialog appears then a modem is not set up on the 
+'computer and will need to be before the test can continue.
+
+handle =  WFndWndC (INSTALL_MODEM_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'No Modems are set up on this computer
+   WritelogItem ("" , INSTALL_MODEM_CAPTION + " dialog Found")
+   WritelogItem ("" , "There are no Modems Setup on this computer")
+   WritelogItem ("" , " ")
+endif
+
+EndOFFunction:
+end Function 'DetectModem
+
+'*****************************************************************************
+'Name   : Call_Dialing_Prop
+'Desc   : Invokes the Dialing Properties window and returns the handle to the
+'         Dialing Properties dialog, the SysTabControl32, the My Location Tab, 
+'			 and the Telephony Drivers Tab. 
+'
+'Parms  : Passed 3 variables to store the handles to the Tab Control, 
+'			 My Location Tab and the Telephony Drivers Tab
+'
+'Return : Returns the Handle to the Dialing Properties dialog
+'
+'History: 01/12/96: a-rrohr: Created
+'Modified 02/16/96: a-rrohr: deleted the Location Information code 
+'									  (now in subroutine SetLocationInfo)
+'*****************************************************************************
+
+Function Call_Dialing_Prop (hTabCtrl as long, hMLTab as long, hTDTab as long) as long
+
+   dim handle as long				'Generic window handle
+   dim hdialog as long				'Handle of Dialing Properties dialog, function rtns this value
+   dim hctrl as long					'Generic Handle to Control
+   dim teststring as casestruct	'Test Log Info
+   dim SysDirPath as string		'Path to system32 directory
+   dim rtn as long					'Generic return variable
+   dim SysTabCtrlID as integer	'ID of SysTabCtrl32 control
+   dim OK_cmdID as long				'ID of Dialing Properties OK button
+   dim failcount as short
+   dim StaticID as long
+   dim messagestr as string
+
+   SysTabCtrlID = &h03020&
+	OK_cmdID		 = &h0001&
+
+	SysDirPath = space$(168)
+	rtn = GetSystemDirectory (SysDirPath, 168)
+
+' If a pre-existing instance of dialing properties exists close it with an OK button click
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+	if hdialog <> 0 then
+		hctrl = GetDlgItem (hdialog, OK_cmdID)
+		WButtonClick (_hwnd(hctrl))				'Click the Dialing Properties OK button
+		sleep 1
+	end if
+
+' Invoke Dialing Properties
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", nowait
+'$endif 'NUMEGA
+
+' Get and validate Dialing Properties window handle
+
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  1
+   teststring.Expect_Res = "Valid Properties Handle"
+   teststring.Actual_Res = "Properties Handle =" + Str$(hdialog)
+
+   if hdialog = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+   else
+      teststring.Apprase    = "Pass"
+   endif
+   LogCase (teststring)
+
+   WSetWndPos  (hdialog, 1, 1)
+   Call_Dialing_Prop =  hdialog
+
+' End - Get and validate Dialing Properties window handle
+' Get and validate SysTabControl32 handle
+
+	hTabCtrl = GetDlgItem (hdialog, SysTabCtrlID)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num = teststring.TC_Num + 1
+   teststring.Expect_Res = "Valid SysTab Control Handle"
+   teststring.Actual_Res = "Sys Tab Handle =" + Str$(hTabCtrl)
+
+   if hTabCtrl = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+   else
+      teststring.Apprase    = "Pass"
+   endif
+   LogCase (teststring)
+
+' End - Get and validate SysTabControl32 handle
+' Get and validate My Location Tab handle
+
+	hMLTab  =  WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num = teststring.TC_Num + 1
+   teststring.Expect_Res = "Valid My Location Handle"
+   teststring.Actual_Res = "Tab Handle =" + Str$(hMLTab)
+
+   if hMLTab = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+   LogCase (teststring)
+
+end function
+
+'*****************************************************************************
+'Name   : GetChildhandles 
+'Desc   : Fills the hChild array with the handles to the child controls of hParent 
+'         
+'Parms  : hTab = handle to My Location Tab
+'			 hChild = array of My Location child control handles.  
+'			 ChildID = array of child control IDs
+' 
+'Return : Void:   Subroutine fills in the hChild array parameter
+'
+'History: 02/10/96 : a-rrohr: Created
+'*****************************************************************************
+sub GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+
+dim count	  as short
+dim beginning as short
+dim ending    as short
+
+beginning = lbound(hChild)
+ending    = ubound(hChild)
+
+for count = beginning to ending
+	hChild(count) = GetDlgItem (hParent, ChildID(count))
+next	
+end sub
+
+'*****************************************************************************
+'Name   : EditLocationInfo 
+'Desc   : Enters data from location variable into My Location controls
+'			 Called by SetLocationsZero, AddLocation and ModifyLocation.
+'
+'Parms  : Location structure containing new location info 
+'			 Array of My Location child control handles
+'Return : None
+'
+'History: 02/15/96 : a-rrohr: Created
+'*****************************************************************************
+sub EditLocationInfo (NewLocal as location, hML_Child() as long)
+	
+	dim rtn as long
+
+	WComboSetText (_hwnd(hML_Child(LOCATION_cbo)), NewLocal.Location)
+	WComboItemClk (_hwnd(hML_Child(COUNTRY_cbo)), NewLocal.Country)
+	
+	WEditSetText  (_hwnd(hML_Child(AREA_txt)), NewLocal.AreaCode)
+	WEditSetText  (_hwnd(hML_Child(LOCAL_txt)), NewLocal.LocalAccess)
+	WEditSetText  (_hwnd(hML_Child(LONG_txt)), NewLocal.LongAccess)
+			
+
+	if (NewLocal.CardSet = Checked) then
+		WCheckSetFocus  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+		WCheckCheck  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+	else
+		WCheckSetFocus  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+		WCheckUnCheck  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+	endif
+	
+	sleep .1
+
+	if (NewLocal.WaitSet = Checked) then
+		WCheckSetFocus  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+		WCheckCheck  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+'print "NewLocal.WaitSet = Checked is true"
+'print "Handle to Call waiting check box = ";hML_Child(WAIT_chk)	
+	else
+'print "NewLocal.WaitSet = Checked is False"
+'print "NewLocal.WaitSet = ";NewLocal.WaitSet
+		WCheckSetFocus  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+		WCheckUnCheck  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+	endif
+	
+	rtn = WOptionState (_hwnd(hML_Child(TONE_opt)))
+	if  rtn <> NewLocal.ToneSet then
+		WOptionClick  (_hwnd(hML_Child(TONE_opt)), TIMEOUT)
+	endif
+
+end sub 'EditLocationInfo
+
+'******************************************************************************
+'Name   : StartAddBook
+'Desc   : Starts Address Book 
+'			 
+'Parms  : hAB:		Handle to Address Book window
+'
+'Return : True if Address Book is started otherwise False
+'
+'History: 06/12/96 : a-rrohr: Created
+'******************************************************************************
+Function StartAddBook( hAB as long ) as long
+
+dim w_flags		as long			 'used with WFndWnd function
+dim AB_Path		as string
+dim rtn			as long			 'generic return variable
+'Initialize variables
+
+StartAddBook = False 'Set default return value
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE OR FW_PART 
+
+AB_Path = string$(MAX_PATH, chr$(0))
+AB_Path = Command$
+
+if exists (AB_Path + "\" + AB_APP) then
+	'$ifdef NUMEGA
+		run AB_Path + "\" + AB_APP, BoundsChecker
+	'$else
+		run AB_Path + "\" + AB_APP, nowait
+	'$endif 'NUMEGA
+	StartAddBook = TRUE 
+else
+   WritelogItem ("StartAddBook Function" , "")
+   WritelogItem ( AB_Path + "\" + AB_APP, " Does not exist")
+endif
+
+hAB = WFndWndC (AB_CAPTION, ADDBOOK_CLASS, w_flags, WTimeout)
+
+End Function 'StartAddBook
+
+'******************************************************************************
+'Name   : CreatePhoneEntry
+'Desc   : Creates Phone Number Entry 
+'			 
+'Parms  : hAB:		Handle to Address Book window
+'
+'Return : True if ***???*** otherwise False
+'
+'History: 06/12/96 : a-rrohr: Created
+'******************************************************************************
+Function CreatePhoneEntry( hAB as long ) as long
+
+dim w_flags		as long			 'used with WFndWnd function
+dim hDlg			as long			 'Generic dialog handle
+dim hCtrl		as long			 'Generic Control handle
+dim hParent    as long
+dim NameEB_ID  as long			 'ID to Name Edit Box, New Address Book dialog
+dim FirstCB_ID as long			 'Add Address Control ID's
+dim FirstEB_ID	as long			 
+dim LastEB_ID	as long
+dim OrgEB_ID	as long
+dim LastP_ID	as long, OrgP_ID as long
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE OR FW_PART 
+NameEB_ID	= &h03E9&
+FirstCB_ID	= &h0072&
+FirstEB_ID	= &h0067&
+LastP_ID 	= &h0071&
+LastEB_ID	= &h0076&
+OrgP_ID 		= &h0073&
+OrgEB_ID		= &h0078&
+
+WSetActWnd (hAB)
+WMenuSelect (MFILE + "\" + MNEW)
+
+'Start a New Address Book
+hDlg = WFndWndC (NEW_AB_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = "New Address Book dlg handle"
+teststring.Actual_Res = hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+hCtrl = GetDlgItem (hDlg, NameEB_ID)
+WEditSetText (_hwnd(hCtrl), AB_NAME)
+hCtrl = GetDlgItem (hDlg, OK_ID)
+WButtonClick (_hwnd(hCtrl))
+
+'Look for Address Book for Windows Message Box 
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'OR FW_PART 
+
+hDlg = WFndWndC (AB_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+'if the window is found then close it
+If hDlg > 0 then
+	hCtrl = GetDlgItem (hDlg, YES_ID)
+	WButtonClick (_hwnd(hCtrl))
+endif
+
+'Add the Test Address
+WSetActWnd (hAB)
+WMenuSelect (MADDRESS + "\" + MADD)
+
+hDlg = WFndWndC (ADD_ADDRESS_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = "Add Address dlg handle"
+teststring.Actual_Res = hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hAB > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+hCtrl = GetDlgItem (hDlg, FirstCB_ID)
+hCtrl = GetDlgItem (hCtrl, FirstEB_ID)
+WEditSetText (_hwnd(hCtrl), FirstName)
+hCtrl = GetDlgItem (hDlg, LastP_ID)
+hCtrl = GetDlgItem (hCtrl, LastEB_ID)
+WEditSetText (_hwnd(hCtrl), LastName)
+hCtrl = GetDlgItem (hDlg, OrgP_ID)
+hCtrl = GetDlgItem (hCtrl, OrgEB_ID)
+WEditSetText (_hwnd(hCtrl), Company)
+
+
+'Unable to get the handle to the following controls So Text Identifiers are used
+WEditSetText ("Ho&me Phone", PhoneNumber)
+WEditSetText ("Countr&y", Country)
+WButtonClick ("OK")
+
+End Function 'CreatePhoneEntry
+
+'******************************************************************************
+'Name   : DialNumber
+'Desc   : Dials Phone Number 
+'			 
+'Parms  : hAB:		Handle to Address Book window
+'
+'Return : True if ***???*** otherwise False
+'
+'History: 06/13/96 : a-rrohr: Created
+'******************************************************************************
+Function DialNumber( hAB as long, ML_ChildID() as long ) as long
+
+dim w_flags			as long			 'used with WFndWnd function
+dim tempstr       as string
+dim rtn				as long
+dim hDial			as long			 'handle to Dial dialog
+dim hDlg				as long			 'Generic dialog handle
+dim hMLTab			as long
+dim ML_hChild (15) as long			' Array of handles to the My Location Tab child controls
+dim hCtrl			as long
+dim DialCaption	as string
+dim PhoneStaticID as long
+dim DialSetupID	as long
+dim Dial_ID			as long
+dim DialStringID  as long
+dim HangUp_ID     as long
+ 
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE OR FW_PART 
+
+PhoneStaticID = &h0478&
+DialSetupID   = &h0003&
+Dial_ID  	  = &h0001&
+DialStringID  = &h047A&
+HangUp_ID     = &h0515&
+
+'Select Dial from menu
+WMenuSelect (MADDRESS + "\" + MDIAL)
+
+DialCaption = DIAL + " " + FirstName +" " + LastName
+hDial = WFndWndC (DialCaption, DIALOG_CLASS, w_flags, WTimeout)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = "Dial dialog handle"
+teststring.Actual_Res = hex$(hDial)
+TotalTestCases = TotalTestCases + 1
+
+if hDial > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Verify Phone Number
+tempstr = Space$ (64)
+rtn = GetDlgItemText (hDial, PhoneStaticID, tempstr, len(tempstr))
+
+teststring.TC_Num =  1
+teststring.Expect_Res = PhoneNumber
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Expect_Res = teststring.Actual_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Verify Dial Setup brings up Dialing Properties dialog
+hCtrl = GetDlgItem (hDial, DialSetupID)
+WButtonClick (_hwnd(hCtrl))
+hDlg = WFndWndC (DIAL_PROP_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = DIAL_PROP_CAPTION + " handle"
+teststring.Actual_Res = hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+'************************************************************************
+
+hMLTab  =  WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+GetChildhandles (hMLTab, ML_hChild, ML_ChildID)
+
+WEditSetText (_hwnd(ML_hChild(AREA_txt)), LocalAreaCode)
+WEditSetText (_hwnd(ML_hChild(Local_txt)), LocalAccessCode)
+
+'Close dialing Properties
+hCtrl = GetDlgItem (hDlg, OK_ID)
+WButtonClick (_hwnd(hCtrl))
+
+'Verify Dial String
+tempstr = Space$ (64)
+sleep 2
+rtn = GetDlgItemText (hDial, DialStringID, tempstr, len(tempstr))
+
+teststring.TC_Num =  1
+teststring.Expect_Res = LocalAccessCode + " 789-1234"  
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Expect_Res = teststring.Actual_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+'************************************************************************
+
+'******************************************************************************
+hCtrl = GetDlgItem (hDial, DialSetupID)
+WButtonClick (_hwnd(hCtrl))
+
+hDlg = WFndWndC (DIAL_PROP_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+hMLTab  =  WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+GetChildhandles (hMLTab, ML_hChild, ML_ChildID)
+
+WEditSetText (_hwnd(ML_hChild(AREA_txt)), LongAreaCode)
+WEditSetText (_hwnd(ML_hChild(Local_txt)), LongAccessCode)
+
+'Close dialing Properties
+hCtrl = GetDlgItem (hDlg, OK_ID)
+WButtonClick (_hwnd(hCtrl))
+
+'Verify Dial String
+sleep 2
+tempstr = Space$ (64)
+rtn = GetDlgItemText (hDial, DialStringID, tempstr, len(tempstr))
+
+teststring.TC_Num =  1
+teststring.Expect_Res = LongAccessCode + " 1 " + LocalAreaCode +" 789-1234"  
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Expect_Res = teststring.Actual_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'******************************************************************************
+'Start dialing & verify Call Status dialog
+hCtrl = GetDlgItem (hDial, Dial_ID)
+WButtonClick (_hwnd(hCtrl))
+
+hDlg = WFndWndC (CALL_STATUS_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = CALL_STATUS_CAPTION + " handle"
+teststring.Actual_Res = hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Hang Up
+hCtrl = GetDlgItem (hDlg, HangUp_ID)
+WButtonClick (_hwnd(hCtrl))
+
+'Close ENTER_CALL_CAPTION dialog
+
+hDlg = WFndWndC (ENTER_CALL_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = ENTER_CALL_CAPTION + " handle"
+teststring.Actual_Res = hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+hCtrl = GetDlgItem (hDlg, OK_ID)
+WButtonClick (_hwnd(hCtrl))
+
+End Function 'DialNumber
+'$ENDIF 'Address_Book_INC
+
diff --git a/private/tapi/qa/apps/addbook/ab_api.inc b/private/tapi/qa/apps/addbook/ab_api.inc
new file mode 100644
index 000000000..ec98156f0
--- /dev/null
+++ b/private/tapi/qa/apps/addbook/ab_api.inc
@@ -0,0 +1,119 @@
+'******************************************************************************
+
+' HT_API.inc												 
+' Created May 16, 1996
+' By Ron Rohr
+
+' 
+'This file holds all type definitions, constants and global declarations
+'used in the Hyper Terminal/TAPI test script
+'******************************************************************************
+
+'$IFNDEF HT_API_INC
+'$DEFINE	HT_API_INC
+
+Type Location
+	Location		as string
+	AreaCode		as string
+	Country		as string
+	LocalAccess as string
+	LongAccess	as string
+	CardSet		as short
+	WaitSet		as short
+	ToneSet		as short
+	PulseSet		as short
+end type
+
+'------------------------------------------------------------------------------
+' Begin Global declarations and definitions
+ 
+Global WTIMEOUT AS LONG           'Timeout value for WFndWnd
+Global teststring as CaseStruct   'Holds test case info for logging by logcase routine
+Global TC_ID as short				 'Holds Test Case ID
+
+'------------------------------------------------------------------------------
+'Begin Constant definitions
+
+' WINDOW CLASSES
+
+Const DIALOG_CLASS  = "#32770"
+Const ADDBOOK_CLASS = "AfxFrameOrView"
+' Menu 
+
+Const MFILE		 = "&File"
+Const MEXIT		 = "E&xit"
+Const MNEW		 = "&New"
+Const MADDRESS  = "&Address"
+Const MADD	    = "&Add..."
+Const MDELETE	 = "De&lete"
+Const MDIAL	    = "&Dial"
+
+' Captions for Address Book and it's dialogs
+
+Const AB_APP					= "adbook.exe"
+Const AB_CAPTION				= "Address Book for Windows"
+Const NEW_AB_CAPTION			= "New Address Book"
+Const ADD_ADDRESS_CAPTION	= "Add Address"
+Const DIAL						= "Dial"
+Const DIAL_PROP_CAPTION		= "Dialing Properties"
+Const CALL_STATUS_CAPTION  = "Call Status"
+Const ENTER_CALL_CAPTION   = "Enter Call"
+Const PROPERTIES				= "Properties"
+Const AB_NAME					= "VTest"
+
+'Add Address Constants
+
+Const FirstName	= "Yahoo"
+Const LastName		= "Wahoo"
+Const Company		= "YoyoDyne"
+Const PhoneNumber	= "(206) 789-1234"
+Const Country		= "United States of America"
+
+' End Other Constant definitions
+
+Const OK_ID					 = &h01&
+Const CANCEL_ID			 = &h02&
+Const YES_ID				 = &h06&
+
+Const USA					 = "United States of America"
+Const	tab_MY_LOCATION    = "My Locations"
+Const LocalAreaCode		 = "206"
+Const LongAreaCode		 = "312"
+Const LocalAccessCode	 = "9"
+Const LongAccessCode		 = "8"
+
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Modem Properties Constant definitions 
+
+Const MODEM_APPLET		    = "\MODEM.CPL"
+Const MODEM_PROP_CAPTION	 =	"Modems Properties"
+Const INSTALL_MODEM_CAPTION = "Install New Modem"
+
+' End Modem Properties Constant definitions 
+'------------------------------------------------------------------------------
+
+Const PROPERTIES_CAPTION   = "Dialing Properties"
+
+Const DP_OKcmd		 = 0
+Const DP_CANCELcmd = 1
+Const DP_APPLYcmd	 = 2
+
+Const NEW_cmd      = 0
+Const REMOVE_cmd   = 1
+Const CHANGE_cmd   = 2
+Const LOCATION_cbo = 3
+Const COUNTRY_cbo  = 4
+Const AREA_txt     = 5
+Const LOCAL_txt    = 6
+Const LONG_txt     = 7
+Const CARD_chk     = 8
+Const WAIT_chk     = 9
+Const WaitStr_cbo	 = 10
+Const TONE_opt     = 11
+Const PULSE_opt    = 12
+Const ADDRESS_lbl	 = 13
+Const NUMBER_lbl	 = 14
+Const DIAL_AS_chk	 = 15
+
+'$ENDIF 'HT_API_INC
diff --git a/private/tapi/qa/apps/addbook/addbook.mst b/private/tapi/qa/apps/addbook/addbook.mst
new file mode 100644
index 000000000..3abf5caa7
--- /dev/null
+++ b/private/tapi/qa/apps/addbook/addbook.mst
@@ -0,0 +1,230 @@
+'******************************************************************************
+
+' AddBook.mst
+
+' Ronald Rohr
+' June 11, 1996
+
+' Status = Pre-Test Design Review, Pre-Code Review
+' Version = 0.1
+
+' This test verifies the TAPI components of Parsons Technology Address Book 3.0
+'
+' A description of the Test Cases Can be found in TCM, Server: lostpup,
+' Database: TAPICASES, Tree: Applications\AddressBook.
+' Logon with ID & Password = Tapicase (read only privlages)
+
+' Parsons Technology Address Book 3.0 is required to run this test.
+'******************************************************************************
+
+'$INCLUDE 'declares.inc'
+
+option base 0
+
+   Const TEST_SCRIPT_TITLE = "Parsons Technology Address Book 3.0 / TAPI Test"   'Test Script Name
+   Const TEST_SCRIPT_VERSION = "6/11/96"                    'Test Script Version
+   Const TIMEOUT = 3                                        'Timeout value for MSTest APIs
+
+   Global Test_Logfile as string    'Results Log File Name
+	Global w_flags as long            'used with WFndWnd function
+
+	w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 
+
+   '$include 'Tapilog.inc'          'required for all common file I/O procedures
+   '$include 'AB_API.INC'           'Constants, Globals and Type declarations
+   '$include 'AB.inc'		         'Functions and Constants used by TAPI_BVT.MST
+   ''$include 'HT_TEMP.INC'            'location of functions under construction
+
+   dim rtn as long                  'Generic long return
+   dim count as short					'Generic count variable
+	dim tempstr as string            'Generic string
+   dim hDlg as long                 'Generic dialog handle
+   dim hCtrl as long						'Generic control handle
+	dim ErrorMessage   as string     'Error Message string for On Error Procedure
+   dim ModemName		 as string     'Name of Modem currently installed
+   dim hAB as long                  'Handle to Address Book window
+	dim Prop_hCtrl(2)	  as long		' Array of handles to the Dialing Properties child controls 
+	dim Prop_CtrlID (2) as long		' Array My Location Tab child controls IDs
+	dim ML_hCtrl (15)  as long			' Array of handles to the My Location Tab child controls
+	dim ML_CtrlID (15) as long			' Array My Location Tab child controls IDs
+	dim hProperties	 as long
+	dim Duvall			 as location
+	dim hParentTab as long, hMyLocTab as long, hTelDrvTab as long
+
+'Dialing Properties child control IDs
+
+Prop_CtrlID(DP_OKcmd)     = &h00000001&
+Prop_CtrlID(DP_CANCELcmd) = &h00000002&
+Prop_CtrlID(DP_APPLYcmd)  = &h00003021&
+
+'My Location Tab child control IDs
+
+ML_CtrlID(NEW_cmd)		= &h00001389&
+ML_CtrlID(REMOVE_cmd)	= &h0000138B&
+ML_CtrlID(CHANGE_cmd)	= &h0000138C&
+ML_CtrlID(LOCATION_cbo)	= &h00001388&
+ML_CtrlID(COUNTRY_cbo)	= &h0000040F&
+ML_CtrlID(AREA_txt)		= &h0000040E&
+ML_CtrlID(LOCAL_txt)		= &h0000040C&
+ML_CtrlID(LONG_txt)		= &h0000040D&
+ML_CtrlID(CARD_chk)		= &h0000138D&
+ML_CtrlID(DIAL_AS_chk)	= &h0000138A&
+ML_CtrlID(WAIT_chk)		= &h0000138E&
+ML_CtrlID(WAITStr_cbo)	= &h00001390&
+ML_CtrlID(TONE_opt)		= &h000017A3&
+ML_CtrlID(PULSE_opt)		= &h000017A2&
+ML_CtrlID(ADDRESS_lbl)	= &h00002329&
+ML_CtrlID(NUMBER_lbl)	= &h00002328&
+
+    on error goto ErrorHandler
+    on end        EndTest
+
+' Bounds Checker can only be run from a system that has Visual Test installed
+' otherwise a run time error will occur.
+' The Bounds Checker binaries cannot be redistributed.
+' NUMEGA should only be defined when running in the VT environment.
+
+'$ifdef NUMEGA
+   on BoundsCheckerNotify (NULL) Call BoundsChkHandler
+'$endif 'NUMEGA
+
+'$ifdef DEBUG_TEST_SCRIPT
+   viewport on
+   viewport clear
+'$endif 'DEBUG_TEST_SCRIPT
+
+'*** Test Initialization
+
+SetDefaultWaitTimeout (5)
+TotalScenarios = 0
+Test_Logfile = TESTMODE$
+CurrentLoggingLevel = DetailCase
+SetLogFileName
+rtn = StartLog (DELETE_LOGFILE, TEST_SCRIPT_TITLE)
+SetWndTimeout ()                                   'Set timeouts for all platforms
+
+'***************************************************************************************
+' Verify Modem set otherwise stop test
+'***************************************************************************************
+'$ifdef  AlreadyValidated
+
+rtn = DetectModem
+if rtn = FALSE then
+   tempstr = "This Test Will Terminate" + CRLF +  CRLF + _
+             "Please Set up Modem on this computer" + CRLF + _
+             "prior to running the TAPI BVT"
+   WritelogItem ("" , tempstr )
+   Statusbox tempstr, 0,0,0,0, TRUE, TRUE
+   Sleep 6
+   Stop          'Stop the test
+endif
+
+'***************************************************************************************
+' Set Dialing Properties locaton
+'***************************************************************************************
+
+hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+
+GetChildhandles (hProperties, Prop_hCtrl, Prop_CtrlID)
+GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	Duvall.Location		= "Duvall"
+	Duvall.AreaCode		= "206"
+	Duvall.Country		= "United States of America"
+	Duvall.LocalAccess  = "9"
+	Duvall.LongAccess   = "8"
+	Duvall.CardSet		= UNCHECKED
+	Duvall.WaitSet		= UNCHECKED
+	Duvall.ToneSet		= TRUE
+	Duvall.PulseSet		= FALSE
+
+EditLocationInfo ( Duvall, (ML_hCtrl))
+
+'Close Dialing Properties
+WButtonClick (_hwnd(Prop_hCtrl(DP_OKcmd)))
+
+'$endif 'AlreadyValidated
+
+'***************************************************************************************
+' Start Address Book
+'***************************************************************************************
+
+rtn = StartAddBook (hAB)
+
+teststring.TC_Num =  1
+teststring.Expect_Res = "Address Book handle"
+teststring.Actual_Res = hex$(hAB)
+TotalTestCases = TotalTestCases + 1
+
+if hAB > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+   WritelogItem ("Invalid Address Book handle" , CRLF + "The test will terminate ")
+	end
+endif
+LogCase (teststring)
+
+'***************************************************************************************
+' Create Entry
+'***************************************************************************************
+
+rtn = CreatePhoneEntry (hAB)
+
+
+'***************************************************************************************
+' Dial Entry
+'***************************************************************************************
+
+rtn = DialNumber( hAB, (ML_CtrlID) )
+
+'$ifdef  NotyetValidated
+'$endif 'NotyetValidated
+
+'******************************************************************************
+'*** END OF TEST                                                              *
+'******************************************************************************
+
+WSetActWnd (hAB)
+WMenuSelect (MADDRESS + "\" + MDELETE)
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'OR FW_PART 
+
+hDlg = WFndWndC (AB_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+'if the window is found then close it
+If hDlg > 0 then
+	hCtrl = GetDlgItem (hDlg, YES_ID)
+	WButtonClick (_hwnd(hCtrl))
+endif
+
+WMenuSelect (MFILE + "\" + MEXIT)
+
+END 'Hyper Term Test
+
+'****************************** On Error Routine ******************************
+
+ErrorHandler:
+    ErrorMessage = "Unexpected error in the Address Book/TAPI Test: "  + CRLF + CRLF + _
+                   "Error:   " + error$                               + CRLF + _
+                   "Error #:"  + str$(Err)                            + CRLF + _
+                   "Line #: "  + str$(Erl)                            + CRLF + _
+                   "File: "    + Erf                                  + CRLF + CRLF + _
+                   "Attempt to continue?"
+
+'$IFDEF DEBUG_TEST_SCRIPT
+   if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+      resume next
+   else
+      Stop
+   endif
+'$ELSE
+   Statusbox "Run Time error detected, Test will terminate", _
+             0,0,0,0, TRUE, TRUE
+   Sleep 4
+   WritelogItem ("" , ErrorMessage)
+   Stop
+'$ENDIF 'DEBUG_TEST_SCRIPT
+'******************************************************************************
diff --git a/private/tapi/qa/apps/hypertrm/ht.inc b/private/tapi/qa/apps/hypertrm/ht.inc
new file mode 100644
index 000000000..0cf3c28b4
--- /dev/null
+++ b/private/tapi/qa/apps/hypertrm/ht.inc
@@ -0,0 +1,754 @@
+
+'******************************************************************************
+
+' Hyper_Term.inc												 
+' Created May, 22 1996
+' By Ron Rohr
+
+' This include file contains all the Functions used by the
+' HyperTrm.MST test Script
+
+'******************************************************************************
+
+' Note: This file uses the Object Naming convention defined in the Visual Basic
+' 4.0 Programmers Guide to name variables and contants associated with a control.
+
+'$IFNDEF HYPER_TERM_INC
+'$DEFINE HYPER_TERM_INC
+ 
+'******************** Begin Procedure Declarations ****************************
+
+Declare Sub      EndTest ()
+Declare Sub		  BoundsChkHandler (vtNotifyData as variant)
+Declare Sub		  SetWndTimeout ()
+Declare Function DetectModem() as long
+Declare Function Call_Dialing_Prop (hTabCtrl as long, hMLTab as long, hTDTab as long) as long
+Declare sub      GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+Declare sub      EditLocationInfo (NewLocal as location, hML_Child() as long)
+Declare Function StartHyperTerm( hHT as long ) as long
+Declare Function ConnectDescript (hCDdlg as long) as long
+Declare Function Connect (hConnectdlg as long, CurrentLoc as location, ModemName as string) as long
+
+'******************** Begin Procedure *****************************************
+
+'******************************************************************************
+'Name   : EndTest
+'Desc   : On End cleanup procedure.
+' 
+'Parms  : None
+'
+'Return : None. 
+'
+'History: 05/22/96 : a-rrohr: Created
+'*****************************************************************************
+Sub EndTest ()
+
+CloseCase (TEST_SCRIPT_TITLE)
+
+CloseLog ()
+
+Statusbox "The Hyper Terminal/TAPI Test is now Complete" + CRLF + _
+			 "Test Case Number " + ltrim$(str$(TC_ID)), 0,0,0,0, TRUE, TRUE 
+Sleep 4
+ 
+End Sub 'EndTest
+
+'*****************************************************************************
+'Name   : BoundsChkHandler
+'Desc   : This routine is called whenever BoundsChecker uncovers a failure.
+'		    The failure is then written ton the log and reports to the user via
+'			 a message box. 
+'			 The routine is called with the On BoundsCheckerNotify (NULL) Call
+'			 BoundsChkHandler statement in DP32.mst.
+'
+'Parms  : None. 
+'
+'Return : None. Writes failure data directly to  the log.
+'
+'History: 02/26/96 : a-rrohr: Created
+'*****************************************************************************
+sub BoundsChkHandler (vtNotifyData as variant)
+
+dim ErrorMessage as string, SizeofString as long, count as short, lastchar as short
+
+ErrorMessage = "Unexpected BoundsChecker error in Dialing Properties Test"  + CRLF
+
+' Since the size of the string BoundsChecker returns is unknown the routine must be
+' capable of formatting a large string into a paragraph whose lines are not greater
+' than 72 characters.
+
+While (len(vtNotifyData) >= 72)
+	SizeofString = len(vtNotifyData)
+	count = 1
+	do
+		lastchar = count
+		count = instr(lastchar + 1,vtNotifyData, " ")
+	' instr(lastchar + 1,vtNotifyData, " ") will return zero on the last word of
+	' the string so break the do loop when count = 0
+	loop while count < 72 and count <> 0
+
+	ErrorMessage = ErrorMessage + rtrim$(left$(vtNotifyData, lastchar)) + CRLF
+	vtNotifyData = right$(vtNotifyData, (SizeofString - lastchar))
+Wend
+
+If (len(vtNotifyData) >= 1) then 
+		ErrorMessage = ErrorMessage + vtNotifyData + CRLF
+end if
+
+
+'$IFDEF DEBUG_TEST_SCRIPT
+if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+   resume next
+else
+   Stop
+endif
+'$ENDIF 'DEBUG_TEST_SCRIPT
+
+end sub 'BoundsChkHandler
+'******************************************************************************
+'Name   : SetWndTimeout
+'Desc   : Sets the timeout variable used by the WFndWnd function.
+'			 Some of the platforms tested on are very slow and if the timeout isn't
+'			 long enough then	the test continues with out finding the Window and its
+'			 handle, dooming all subsequent test (that are dependent on this handle)
+'			 to complete and utter failure.
+' 
+'Parms  : None
+'
+'Return : None. Sets the Global String variables WTIMEOUT
+'
+'History: 02/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+ Sub SetWndTimeout ()
+
+ dim tempstring as string									' Generic string variable
+
+ SetActiveTimeout	(150)
+ SetDefaultWaitTimeout (2)
+
+ tempstring = space(40)
+ tempstring = environ$("PROCESSOR_ARCHITECTURE")
+
+ select case tempstring
+
+	case "x86", "MIPS"
+
+		IF environ$("PROCESSOR_LEVEL") = "4" then
+		   SetActiveTimeout	(1000)
+			SetDefaultWaitTimeout (10)
+			WTIMEOUT = 10		
+		else
+			WTIMEOUT = 4		
+		endif
+
+	case "PPC", "Alpha"
+
+		WTIMEOUT = 20		
+	   SetActiveTimeout	(500)
+		SetDefaultWaitTimeout (10)
+
+	case else
+
+		WTIMEOUT = 30		
+		SetDefaultWaitTimeout (10)
+	   WritelogItem ("" ,"SetWndTimeout Subroutine - TAPI_BVT.inc")
+	   WritelogItem ("" ,"Unable to set WTIMEOUT: Unknown Processor Architecture")
+	   WritelogItem ("" ,"Processor Architecture	environment variable = " +  tempstring)
+	   WritelogItem ("" ," ")
+end select
+
+'$IFDEF NUMEGA
+		WTIMEOUT = WTIMEOUT + 5 'If using BoundsChecker then add a few more seconds
+'$ENDIF
+
+end Sub  'SetWndTimeout ()
+
+'******************************************************************************
+'Name   : DetectModem
+'Desc   : Runs Modem.cpl and determines if a modem is installed by which modem
+'		  dialog appears
+'			 
+'Parms  : None
+'
+'Return : True  if a Modem is set up on this computer
+'		  False if not.
+'
+'History: 04/15/96 : a-rrohr: Created
+'******************************************************************************
+
+Function DetectModem() as long
+
+dim w_Flags as long
+dim handle  as long, hCtrl as long
+dim Close_cmdID as long
+dim SysDirPath as string
+dim rtn as long
+
+'Initialize variables
+
+Close_cmdID = &h01&	'Close Command button ID on Modem Properties dialog
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+SysDirPath = string$(168, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + MODEM_APPLET, BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + MODEM_APPLET, nowait
+'$endif 'NUMEGA
+
+DetectModem = FALSE	 'Set default return value
+
+'if the Modems Properties dialog appears then a modem is set up on the computer
+
+handle =  WFndWndC (MODEM_PROP_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'a Modem is set up on this computer
+	hCtrl = GetDlgItem (handle, Close_cmdID)
+	WButtonClick (_hwnd(hCtrl))
+   WritelogItem ("" , "Modem Connected")
+	DetectModem = TRUE
+	Goto EndOFFunction
+endif
+
+'if the Install New Modem dialog appears then a modem is not set up on the 
+'computer and will need to be before the test can continue.
+
+handle =  WFndWndC (INSTALL_MODEM_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'No Modems are set up on this computer
+   WritelogItem ("" , INSTALL_MODEM_CAPTION + " dialog Found")
+   WritelogItem ("" , "There are no Modems Setup on this computer")
+   WritelogItem ("" , " ")
+endif
+
+EndOFFunction:
+end Function 'DetectModem
+
+'*****************************************************************************
+'Name   : Call_Dialing_Prop
+'Desc   : Invokes the Dialing Properties window and returns the handle to the
+'         Dialing Properties dialog, the SysTabControl32, the My Location Tab, 
+'			 and the Telephony Drivers Tab. 
+'
+'Parms  : Passed 3 variables to store the handles to the Tab Control, 
+'			 My Location Tab and the Telephony Drivers Tab
+'
+'Return : Returns the Handle to the Dialing Properties dialog
+'
+'History: 01/12/96: a-rrohr: Created
+'Modified 02/16/96: a-rrohr: deleted the Location Information code 
+'									  (now in subroutine SetLocationInfo)
+'*****************************************************************************
+
+Function Call_Dialing_Prop (hTabCtrl as long, hMLTab as long, hTDTab as long) as long
+
+   dim handle as long				'Generic window handle
+   dim hdialog as long				'Handle of Dialing Properties dialog, function rtns this value
+   dim hctrl as long					'Generic Handle to Control
+   dim teststring as casestruct	'Test Log Info
+   dim SysDirPath as string		'Path to system32 directory
+   dim rtn as long					'Generic return variable
+   dim SysTabCtrlID as integer	'ID of SysTabCtrl32 control
+   dim OK_cmdID as long				'ID of Dialing Properties OK button
+   dim failcount as short
+   dim StaticID as long
+   dim messagestr as string
+
+   SysTabCtrlID = &h03020&
+	OK_cmdID		 = &h0001&
+
+	SysDirPath = space$(168)
+	rtn = GetSystemDirectory (SysDirPath, 168)
+
+' If a pre-existing instance of dialing properties exists close it with an OK button click
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+	if hdialog <> 0 then
+		hctrl = GetDlgItem (hdialog, OK_cmdID)
+		WButtonClick (_hwnd(hctrl))				'Click the Dialing Properties OK button
+		sleep 1
+	end if
+
+' Invoke Dialing Properties
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", nowait
+'$endif 'NUMEGA
+
+' Get and validate Dialing Properties window handle
+
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  1
+   teststring.Expect_Res = "Valid Properties Handle"
+   teststring.Actual_Res = "Properties Handle =" + Str$(hdialog)
+
+   if hdialog = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+   WSetWndPos  (hdialog, 1, 1)
+   Call_Dialing_Prop =  hdialog
+
+' End - Get and validate Dialing Properties window handle
+' Get and validate SysTabControl32 handle
+
+	hTabCtrl = GetDlgItem (hdialog, SysTabCtrlID)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num = teststring.TC_Num + 1
+   teststring.Expect_Res = "Valid SysTab Control Handle"
+   teststring.Actual_Res = "Sys Tab Handle =" + Str$(hTabCtrl)
+
+   if hTabCtrl = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+' End - Get and validate SysTabControl32 handle
+' Get and validate My Location Tab handle
+
+	hMLTab  =  WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num = teststring.TC_Num + 1
+   teststring.Expect_Res = "Valid My Location Handle"
+   teststring.Actual_Res = "Tab Handle =" + Str$(hMLTab)
+
+   if hMLTab = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+end function
+
+'*****************************************************************************
+'Name   : GetChildhandles 
+'Desc   : Fills the hChild array with the handles to the child controls of hParent 
+'         
+'Parms  : hTab = handle to My Location Tab
+'			 hChild = array of My Location child control handles.  
+'			 ChildID = array of child control IDs
+' 
+'Return : Void:   Subroutine fills in the hChild array parameter
+'
+'History: 02/10/96 : a-rrohr: Created
+'*****************************************************************************
+sub GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+
+dim count	  as short
+dim beginning as short
+dim ending    as short
+
+beginning = lbound(hChild)
+ending    = ubound(hChild)
+
+for count = beginning to ending
+	hChild(count) = GetDlgItem (hParent, ChildID(count))
+next	
+end sub
+
+'*****************************************************************************
+'Name   : EditLocationInfo 
+'Desc   : Enters data from location variable into My Location controls
+'			 Called by SetLocationsZero, AddLocation and ModifyLocation.
+'
+'Parms  : Location structure containing new location info 
+'			 Array of My Location child control handles
+'Return : None
+'
+'History: 02/15/96 : a-rrohr: Created
+'*****************************************************************************
+sub EditLocationInfo (NewLocal as location, hML_Child() as long)
+	
+	dim rtn as long
+
+	WComboSetText (_hwnd(hML_Child(LOCATION_cbo)), NewLocal.Location)
+	WComboItemClk (_hwnd(hML_Child(COUNTRY_cbo)), NewLocal.Country)
+	
+	WEditSetText  (_hwnd(hML_Child(AREA_txt)), NewLocal.AreaCode)
+	WEditSetText  (_hwnd(hML_Child(LOCAL_txt)), NewLocal.LocalAccess)
+	WEditSetText  (_hwnd(hML_Child(LONG_txt)), NewLocal.LongAccess)
+			
+
+	if (NewLocal.CardSet = Checked) then
+		WCheckSetFocus  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+		WCheckCheck  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+	else
+		WCheckSetFocus  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+		WCheckUnCheck  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+	endif
+	
+	sleep .1
+
+	if (NewLocal.WaitSet = Checked) then
+		WCheckSetFocus  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+		WCheckCheck  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+'print "NewLocal.WaitSet = Checked is true"
+'print "Handle to Call waiting check box = ";hML_Child(WAIT_chk)	
+	else
+'print "NewLocal.WaitSet = Checked is False"
+'print "NewLocal.WaitSet = ";NewLocal.WaitSet
+		WCheckSetFocus  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+		WCheckUnCheck  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+	endif
+	
+	rtn = WOptionState (_hwnd(hML_Child(TONE_opt)))
+	if  rtn <> NewLocal.ToneSet then
+		WOptionClick  (_hwnd(hML_Child(TONE_opt)), TIMEOUT)
+	endif
+
+end sub 'EditLocationInfo
+
+'******************************************************************************
+'Name   : StartHyperTerm
+'Desc   : Starts Hyper Terminal 
+'			 
+'Parms  : hHT:		Handle to Hyper Terminal window
+'
+'Return : Handle to Connection Description dialog otherwise 0
+'
+'History: 05/22/96 : a-rrohr: Created
+'******************************************************************************
+Function StartHyperTerm( hHT as long ) as long
+
+dim w_flags		as long			 'used with WFndWnd function
+dim SysDirPath as string		 'holds path to windows system directory
+dim HT_Path		as string
+dim rtn			as long			 'generic return variable
+dim hDlg			as long			 'holds handle to Connection Description dialog
+'Initialize variables
+
+StartHyperTerm = 0'Set default return value
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+HT_Path	  = string$(MAX_PATH, chr$(0))
+SysDirPath = string$(MAX_PATH, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+if exists ("C:\program files\Windows NT" + HT_APPLET) then
+	HT_Path = "C:\program files\Windows NT"
+elseif  exists ("D:\program files\Windows NT" + HT_APPLET) then
+	HT_Path = "D:\program files\Windows NT" 
+elseif  exists (SysDirPath + HT_APPLET) then
+	HT_Path = SysDirPath 
+endif
+
+'$ifdef NUMEGA
+	run HT_Path + HT_APPLET, BoundsChecker
+'$else
+	run HT_Path + HT_APPLET, nowait
+'$endif 'NUMEGA
+
+hDlg = WFndWndC (CD_CAPTION, DIALOG_CLASS, w_flags, WTimeout)
+
+if hDlg > 0 then
+	StartHyperTerm = hDlg
+	hHT = GetParent (hDlg)
+endif
+
+End Function 'StartHyperTerm
+
+'******************************************************************************
+'Name   : ConnectDescript
+'Desc   : Enters name in Connection Description dialog, clicks OK and 
+'			 returns handle to Phone Number dialog 
+'			 
+'Parms  : hDescript: handle to Connection Description dialog
+'
+'Return : Handle to Phone Number dialog otherwise 0
+'
+'History: 06/04/96 : a-rrohr: Created
+'******************************************************************************
+Function ConnectDescript (hCDdlg as long) as long
+
+dim w_flags		as long			 'used with WFndWnd function
+dim rtn			as long			 'generic return variable
+dim NametxtID  as long			 'Name Edit Box ID
+dim hCtrl		as long
+
+'Initialize variables
+
+ConnectDescript = 0'Set default return value
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+NametxtID = &h006A&
+
+hCtrl = GetDlgItem ( hCDdlg, NametxtID )
+WEditSetText ( _hwnd(hCtrl), CONN1_NAME)
+hCtrl = GetDlgItem ( hCDdlg, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+ConnectDescript = WFndWndC (PN_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+End Function 'ConnectDescript
+
+'******************************************************************************
+'Name   : PhoneNumber
+'Desc   : Enters name in Connection Description dialog, clicks OK and 
+'			 returns handle to Phone Number dialog 
+'			 
+'Parms  : hDescript: handle to Connection Description dialog
+'
+'Return : Handle to Phone Number dialog otherwise 0
+'
+'History: 06/04/96 : a-rrohr: Created
+'******************************************************************************
+Function PhoneNumber (hDlgPhoneNo as long, ModemName as string) as long
+
+dim w_flags		as long			 'used with WFndWnd function
+dim rtn			as long			 'generic return variable
+dim CountryID  as long			 'Country ComboBox ID
+dim AreaCodeID as long			 'Area Code Edit Box ID
+dim PN_ID	   as long			 'Phone Number Edit Box ID
+dim ModemID    as long			 'Modem combobox
+dim hCtrl		as long
+
+'Initialize variables
+
+PhoneNumber = 0'Set default return value
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+CountryID  = &h0072&
+AreaCodeID = &h006B&
+PN_ID		  = &h006D&
+ModemID	  = &h006F&
+
+hctrl = GetDlgItem (hDlgPhoneNo, CountryID)
+WComboItemClk (_hwnd(hctrl), USA)
+hCtrl = GetDlgItem ( hDlgPhoneNo, AreaCodeID )
+WEditSetText ( _hwnd(hCtrl), AREACODE_NO)
+hCtrl = GetDlgItem ( hDlgPhoneNo, PN_ID )
+WEditSetText ( _hwnd(hCtrl), COMP_SERVE_NO)
+hCtrl = GetDlgItem ( hDlgPhoneNo, ModemID )
+ModemName = ComboText (_hwnd(hCtrl))
+
+hCtrl = GetDlgItem ( hDlgPhoneNo, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+PhoneNumber = WFndWndC (CONNECT_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+End Function 'PhoneNumber
+
+'******************************************************************************
+'Name   : Connect
+'Desc   : Enters name in Connection Description dialog, clicks OK and 
+'			 returns handle to Phone Number dialog 
+'			 
+'Parms  : hDescript: handle to Connection Description dialog
+'
+'Return : none
+'
+'History: 06/04/96 : a-rrohr: Created
+'******************************************************************************
+Function Connect (hDlgConnect as long, CurrentLoc as location, ModemName as string) as long
+
+dim tempstr    as string
+dim w_flags		as long			 'used with WFndWnd function
+dim rtn			as long			 'generic return variable
+dim ModifyID   as long			 'Connect Dialog Control IDs
+dim DialPropID as long
+dim Dial_ID	   as long			 
+dim PhoneNoID  as long
+dim CountryID  as long			 'Properties Dialog Control IDs
+dim AreaID		as long
+dim PhoneID	   as long			 
+dim ModemID    as long
+dim ConfigID    as long
+dim UseCodeID  as long
+
+dim hCtrl		as long
+dim handle		as long			 'Generic handle
+dim hProperties as long
+dim hConnectTab as long
+'Initialize variables
+
+Connect = 0'Set default return value
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+ModifyID   = &h006A&
+DialPropID = &h006D&
+Dial_ID	  = &h0001&
+PhoneNoID  = &h0069&
+
+CountryID  = &h0072&
+AreaID	  = &h006B&
+PhoneID	  = &h006D&		 
+ModemID    = &h006F&
+ConfigID   = &h0073&
+UseCodeID  = &h0074&
+
+'Click modify button
+hCtrl = GetDlgItem ( hDlgConnect, ModifyID )
+WButtonClick (_hwnd(hCtrl))
+
+hProperties = WFndWndC (CONN1_NAME + " " + PROPERTIES, DIALOG_CLASS, w_flags, WTimeOut)
+
+teststring.TC_Num = teststring.TC_Num + 1  
+teststring.Expect_Res = "Properties dlg handle"
+teststring.Actual_Res = Hex$(hProperties)
+TotalTestCases = TotalTestCases + 1
+
+if hProperties > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Get handle to Connect To tab
+handle = WFndWndC (PN_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+hCtrl = GetDlgItem ( handle, UseCodeID )
+WCheckSetState (_hwnd(hCtrl), UNCHECKED)
+
+'Close Properties dialog
+hCtrl = GetDlgItem ( hProperties, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+'Get Phone Number. Note although the control looks like a static it's class is edit
+hCtrl = GetDlgItem ( hDlgConnect, PhoneNoID )
+tempStr = EditText (_hwnd(hCtrl))
+
+teststring.TC_Num = teststring.TC_Num + 1  
+teststring.Expect_Res = COMP_SERVE_NO
+teststring.Actual_Res = TempStr
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Expect_Res = teststring.Actual_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+hCtrl = GetDlgItem ( hDlgConnect, DialPropID )
+WButtonClick (_hwnd(hCtrl))
+
+handle = WFndWndC (DIAL_PROP_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+teststring.TC_Num = teststring.TC_Num + 1 
+teststring.Expect_Res = "Dial Prop handle"
+teststring.Actual_Res = hex$(handle)
+TotalTestCases = TotalTestCases + 1
+
+if handle > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Close Properties dialog
+hCtrl = GetDlgItem ( handle, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+'Click modify button
+hCtrl = GetDlgItem ( hDlgConnect, ModifyID )
+WButtonClick (_hwnd(hCtrl))
+
+hProperties = WFndWndC (CONN1_NAME + " " + PROPERTIES, DIALOG_CLASS, w_flags, WTimeOut)
+
+'Get handle to Connect To tab
+handle = WFndWndC (PN_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+hCtrl = GetDlgItem ( handle, UseCodeID )
+WCheckSetState (_hwnd(hCtrl), CHECKED)
+
+'Close Properties dialog
+hCtrl = GetDlgItem ( hProperties, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+'Get Phone Number
+hCtrl = GetDlgItem ( hDlgConnect, PhoneNoID )
+tempStr = EditText (_hwnd(hCtrl))
+
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = CurrentLoc.LocalAccess + " " + COMP_SERVE_NO
+teststring.Actual_Res = TempStr
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Expect_Res = teststring.Actual_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Click Modify
+hCtrl = GetDlgItem ( hDlgConnect, ModifyID )
+WButtonClick (_hwnd(hCtrl))
+
+hProperties = WFndWndC (CONN1_NAME + " " + PROPERTIES, DIALOG_CLASS, w_flags, WTimeOut)
+
+'Get handle to Connect To tab
+handle = WFndWndC (PN_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+'Click on Configure button (lineConfigDialog)
+hCtrl = GetDlgItem ( handle, ConfigID )
+WButtonClick (_hwnd(hCtrl))
+
+handle = WFndWndC ( ModemName + " " + PROPERTIES, DIALOG_CLASS, w_flags, WTimeOut)
+
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = ModemName + " " + PROPERTIES + "handle"
+teststring.Actual_Res = hex$(handle)
+TotalTestCases = TotalTestCases + 1
+
+if handle > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'Close Modem Properties dialog
+hCtrl = GetDlgItem ( handle, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+'Close Properties dialog
+hCtrl = GetDlgItem ( hProperties, OK_ID )
+WButtonClick (_hwnd(hCtrl))
+
+'Click on Dial and return handle to 2nd Connect window 
+hCtrl = GetDlgItem ( hDlgConnect, Dial_ID )
+WButtonClick (_hwnd(hCtrl))
+
+Connect = WFndWndC (CONNECT_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+End Function 'PhoneNumber
+
+'ModifyID   = &h006A&
+'DialPropID = &h006D&
+'Dial_ID	  = &h0001&
+'PhoneNoID  = &h0069&
+
+'CountryID  = &h0072&
+'AreaID	  = &h006B&
+'PhoneID	  = &h006D&		 
+'ModemID    = &h006F&
+'ConfigID   = &h0073&
+'UseCodeID  = &h0074&
+
+'$ENDIF 'HYPER_TERM_INC
diff --git a/private/tapi/qa/apps/hypertrm/ht_api.inc b/private/tapi/qa/apps/hypertrm/ht_api.inc
new file mode 100644
index 000000000..773a382d3
--- /dev/null
+++ b/private/tapi/qa/apps/hypertrm/ht_api.inc
@@ -0,0 +1,105 @@
+'******************************************************************************
+
+' HT_API.inc												 
+' Created May 16, 1996
+' By Ron Rohr
+
+' 
+'This file holds all type definitions, constants and global declarations
+'used in the Hyper Terminal/TAPI test script
+'******************************************************************************
+
+'$IFNDEF HT_API_INC
+'$DEFINE	HT_API_INC
+
+Type Location
+	Location		as string
+	AreaCode		as string
+	Country		as string
+	LocalAccess as string
+	LongAccess	as string
+	CardSet		as short
+	WaitSet		as short
+	ToneSet		as short
+	PulseSet		as short
+end type
+
+'------------------------------------------------------------------------------
+' Begin Global declarations and definitions
+ 
+Global WTIMEOUT AS LONG           'Timeout value for WFndWnd
+Global teststring as CaseStruct   'Holds test case info for logging by logcase routine
+Global TC_ID as short				 'Holds Test Case ID
+
+'------------------------------------------------------------------------------
+'Begin Constant definitions
+
+' WINDOW CLASSES
+
+Const DIALOG_CLASS = "#32770"
+Const HT_CLASS     = "SESSION_WINDOW"
+
+' Program Accessories
+
+Const HT_APPLET		    = "\Hypertrm.exe"
+
+' Menu 
+
+Const MFILE  = "&File"
+Const MEXIT  = "E&xit"
+
+' Captions for Hyper Terminal and it's dialogs
+
+Const HT_CAPTION			 = "HyperTerminal"
+Const CD_CAPTION			 = "Connection Description"
+Const PN_CAPTION         = "Connect To" '"Phone Number" some days it's phone number some days it's connect to
+Const CONNECT_CAPTION	 = "Connect"
+Const DIAL_PROP_CAPTION  = "Dialing Properties"
+Const PROPERTIES			 = "Properties"
+
+' End Other Constant definitions
+
+Const CONN1_NAME			 = "TAPI_TEST"
+
+Const OK_ID					 = &h01&
+Const CANCEL_ID			 = &h02&
+Const NO_ID					 = &h07&
+
+Const AREACODE_NO			 = "206"
+Const COMP_SERVE_NO		 = "242-9992"
+Const USA					 = "United States of America (1)"
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Modem Properties Constant definitions 
+
+Const MODEM_APPLET		    = "\MODEM.CPL"
+Const MODEM_PROP_CAPTION	 =	"Modems Properties"
+Const INSTALL_MODEM_CAPTION = "Install New Modem"
+
+' End Modem Properties Constant definitions 
+'------------------------------------------------------------------------------
+
+Const PROPERTIES_CAPTION   = "Dialing Properties"
+
+Const DP_OKcmd		 = 0
+Const DP_CANCELcmd = 1
+Const DP_APPLYcmd	 = 2
+
+Const NEW_cmd      = 0
+Const REMOVE_cmd   = 1
+Const CHANGE_cmd   = 2
+Const LOCATION_cbo = 3
+Const COUNTRY_cbo  = 4
+Const AREA_txt     = 5
+Const LOCAL_txt    = 6
+Const LONG_txt     = 7
+Const CARD_chk     = 8
+Const WAIT_chk     = 9
+Const WaitStr_cbo	 = 10
+Const TONE_opt     = 11
+Const PULSE_opt    = 12
+Const ADDRESS_lbl	 = 13
+Const NUMBER_lbl	 = 14
+Const DIAL_AS_chk	 = 15
+
+'$ENDIF 'HT_API_INC
diff --git a/private/tapi/qa/apps/hypertrm/hypertrm.mst b/private/tapi/qa/apps/hypertrm/hypertrm.mst
new file mode 100644
index 000000000..6758f0e51
--- /dev/null
+++ b/private/tapi/qa/apps/hypertrm/hypertrm.mst
@@ -0,0 +1,295 @@
+'******************************************************************************
+
+' Hypertrm.mst
+
+' Ronald Rohr
+' May 22, 1996
+
+' Status = Pre-Test Design Review, Pre-Code Review
+' Version = 0.1
+
+' This test verifies the TAPI components of Hyper Terminal
+'
+' A description of the Test Cases Can be found in TCM, Server: lostpup,
+' Database: TAPICASES, Tree: Applications\HyperTerm.
+' Logon with ID & Password = Tapicase (read only privlages)
+
+' Hyper Terminal is required to run this test.
+'******************************************************************************
+
+'$INCLUDE 'declares.inc'
+
+option base 0
+
+   Const TEST_SCRIPT_TITLE = "Hyper Terminal / TAPI Test"   'Test Script Name
+   Const TEST_SCRIPT_VERSION = "5/22/96"                    'Test Script Version
+   Const TIMEOUT = 3                                        'Timeout value for MSTest APIs
+
+   Global Test_Logfile as string    'Results Log File Name
+	Global tab_MY_LOCATION as string
+	Global w_flags as long            'used with WFndWnd function
+
+	tab_MY_LOCATION = "My Locations"
+	w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 
+
+   '$include 'Tapilog.inc'          'required for all common file I/O procedures
+   '$include 'HT_API.INC'           'Constants, Globals and Type declarations
+   '$include 'HT.inc'		         'Functions and Constants used by TAPI_BVT.MST
+   ''$include 'HT_TEMP.INC'            'location of functions under construction
+
+   dim rtn as long                  'Generic long return
+   dim count as short					'Generic count variable
+	dim tempstr as string            'Generic string
+   dim hDlg as long                 'Generic dialog handle
+   dim hCtrl as long						'Generic control handle
+	dim ErrorMessage  as string      'Error Message string for On Error Procedure
+   dim ModemName as string          'Name of Modem currently installed
+   dim hHT as long                  'Handle to HyperTerminal window
+	dim Prop_hCtrl(2)	as long			' Array of handles to the Dialing Properties child controls 
+	dim Prop_CtrlID (2) as long		' Array My Location Tab child controls IDs
+	dim ML_hCtrl (15) as long			' Array of handles to the My Location Tab child controls
+	dim ML_CtrlID (15) as long			' Array My Location Tab child controls IDs
+	dim hProperties as long
+	dim Duvall      as location
+	dim hParentTab as long, hMyLocTab as long, hTelDrvTab as long
+
+'Dialing Properties child control IDs
+
+Prop_CtrlID(DP_OKcmd)     = &h00000001&
+Prop_CtrlID(DP_CANCELcmd) = &h00000002&
+Prop_CtrlID(DP_APPLYcmd)  = &h00003021&
+
+'My Location Tab child control IDs
+
+ML_CtrlID(NEW_cmd)		= &h00001389&
+ML_CtrlID(REMOVE_cmd)	= &h0000138B&
+ML_CtrlID(CHANGE_cmd)	= &h0000138C&
+ML_CtrlID(LOCATION_cbo)	= &h00001388&
+ML_CtrlID(COUNTRY_cbo)	= &h0000040F&
+ML_CtrlID(AREA_txt)		= &h0000040E&
+ML_CtrlID(LOCAL_txt)		= &h0000040C&
+ML_CtrlID(LONG_txt)		= &h0000040D&
+ML_CtrlID(CARD_chk)		= &h0000138D&
+ML_CtrlID(DIAL_AS_chk)	= &h0000138A&
+ML_CtrlID(WAIT_chk)		= &h0000138E&
+ML_CtrlID(WAITStr_cbo)	= &h00001390&
+ML_CtrlID(TONE_opt)		= &h000017A3&
+ML_CtrlID(PULSE_opt)		= &h000017A2&
+ML_CtrlID(ADDRESS_lbl)	= &h00002329&
+ML_CtrlID(NUMBER_lbl)	= &h00002328&
+
+    on error goto ErrorHandler
+    on end        EndTest
+
+' Bounds Checker can only be run from a system that has Visual Test installed
+' otherwise a run time error will occur.
+' The Bounds Checker binaries cannot be redistributed.
+' NUMEGA should only be defined when running in the VT environment.
+
+'$ifdef NUMEGA
+   on BoundsCheckerNotify (NULL) Call BoundsChkHandler
+'$endif 'NUMEGA
+
+'$ifdef DEBUG_TEST_SCRIPT
+   viewport on
+   viewport clear
+'$endif 'DEBUG_TEST_SCRIPT
+
+viewport off
+'*** Test Initialization
+
+TotalScenarios = 0
+Test_Logfile = TESTMODE$
+CurrentLoggingLevel = DetailCase
+SetLogFileName
+rtn = StartLog (DELETE_LOGFILE, TEST_SCRIPT_TITLE)
+SetWndTimeout ()                                   'Set timeouts for all platforms
+
+'***************************************************************************************
+' Verify Modem set otherwise stop test
+'***************************************************************************************
+
+rtn = DetectModem
+if rtn = FALSE then
+   tempstr = "This Test Will Terminate" + CRLF +  CRLF + _
+             "Please Set up Modem on this computer" + CRLF + _
+             "prior to running the TAPI BVT"
+   WritelogItem ("" , tempstr )
+   Statusbox tempstr, 0,0,0,0, TRUE, TRUE
+   Sleep 6
+   Stop          'Stop the test
+endif
+
+'***************************************************************************************
+' Set Dialing Properties locaton
+'***************************************************************************************
+
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+
+   GetChildhandles (hProperties, Prop_hCtrl, Prop_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	Duvall.Location		= "Duvall"
+	Duvall.AreaCode		= "206"
+	Duvall.Country		= "United States of America"
+	Duvall.LocalAccess  = "9"
+	Duvall.LongAccess   = "8"
+	Duvall.CardSet		= UNCHECKED
+	Duvall.WaitSet		= UNCHECKED
+	Duvall.ToneSet		= TRUE
+	Duvall.PulseSet		= FALSE
+
+EditLocationInfo ( Duvall, (ML_hCtrl))
+
+'Close Dialing Properties
+WButtonClick (_hwnd(Prop_hCtrl(DP_OKcmd)))
+
+'***************************************************************************************
+' Start Hyper Term and Get Handle to Connection Description dialog
+'***************************************************************************************
+hDlg = StartHyperTerm (hHT)
+
+'Verify handle to Connection Description dialog is valid (ie > 0)
+teststring.TC_Num =  teststring.TC_Num + 1
+teststring.Expect_Res = "Conn Descript dlg handle"
+teststring.Actual_Res = Hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'***************************************************************************************
+' Enter Name in Connection Description dialog and click OK
+'***************************************************************************************
+hDlg = ConnectDescript (hDlg)
+
+'Verify handle to Phone Number dialog is valid (ie > 0)
+teststring.TC_Num =  teststring.TC_Num + 1
+teststring.Expect_Res = "Phone number dlg handle"
+teststring.Actual_Res = Hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'***************************************************************************************
+' Enter Phone Data in Phone Number dialog and click OK
+'***************************************************************************************
+ModemName = Space$ (64)
+hDlg = PhoneNumber (hDlg, ModemName)
+
+'Verify handle to Connect dialog is valid (ie > 0)
+teststring.TC_Num =  teststring.TC_Num + 1
+teststring.Expect_Res = "Connect dlg handle"
+teststring.Actual_Res = Hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'***************************************************************************************
+' Dial
+'***************************************************************************************
+hDlg = Connect (hDlg, Duvall, ModemName)
+
+teststring.TC_Num =  teststring.TC_Num + 1
+teststring.Expect_Res = "Connect (2nd) dlg handle"
+teststring.Actual_Res = hex$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+count = 0
+
+do
+sleep .1
+
+tempstr = space$ (64)
+rtn = GetDlgItemText (hDlg, &h006E&, tempstr, len(tempstr))
+
+loop until (tempstr = "Dialing") OR (count = 20)
+
+teststring.TC_Num =  teststring.TC_Num + 1
+teststring.Expect_Res = "Dialing"
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+hCtrl = GetDlgItem ( hDlg, CANCEL_ID )
+WButtonClick (_hwnd(hCtrl))
+
+'******************************************************************************
+' Close Hyper Term                                                              *
+'******************************************************************************
+
+WSetActWnd (hHT)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+hDlg = WFndWndC (HT_CAPTION, DIALOG_CLASS, w_flags, WTimeOut)
+
+hCtrl = GetDlgItem ( hDlg, NO_ID)
+WButtonClick (_hwnd(hCtrl))
+
+'$ifdef  NotyetValidated
+'$endif 'NotyetValidated
+
+
+'******************************************************************************
+'*** END OF TEST                                                              *
+'******************************************************************************
+
+END 'Hyper Term Test
+
+'****************************** On Error Routine ******************************
+
+ErrorHandler:
+    ErrorMessage = "Unexpected error in the Hyper Terminal/TAPI Test: "  + CRLF + CRLF + _
+                   "Error:   " + error$                               + CRLF + _
+                   "Error #:"  + str$(Err)                            + CRLF + _
+                   "Line #: "  + str$(Erl)                            + CRLF + _
+                   "File: "    + Erf                                  + CRLF + CRLF + _
+                   "Attempt to continue?"
+
+'$IFDEF DEBUG_TEST_SCRIPT
+   if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+      resume next
+   else
+      Stop
+   endif
+'$ELSE
+   Statusbox "Run Time error detected, Test will terminate", _
+             0,0,0,0, TRUE, TRUE
+   Sleep 4
+   WritelogItem ("" , ErrorMessage)
+   Stop
+'$ENDIF 'DEBUG_TEST_SCRIPT
+'******************************************************************************
+
diff --git a/private/tapi/qa/bvt/current/tapibvt.mst b/private/tapi/qa/bvt/current/tapibvt.mst
new file mode 100644
index 000000000..97dd6dba1
--- /dev/null
+++ b/private/tapi/qa/bvt/current/tapibvt.mst
@@ -0,0 +1,1675 @@
+'TB BVT
+'
+
+' WARNING:  This is a piece of junk.  No warrantee implied.
+'spaghetti, not authored by me, just scribbled by me, (ajohnh, some time in '95)
+'$INCLUDE 'c:\msdev\include\RECORDER.INC'
+'$include 'c:\msdev\include\winapi.inc'
+'$INCLUDE 'c:\MSDEV\INCLUDE\TBPOKE.H'
+
+'//////////////////////////////////////////
+'////// borrowed from my in-work TBPoke:
+'logging
+global sOutLogName			as string
+global sScriptName			as string
+global sComment				as string
+
+global hwndViewport			as long
+global lCountSpace			as long
+global lCountFunc			as long
+global lCountTab			as long
+global MAX_BLANK			as long
+global sFuncString			as string
+
+'end reporting
+global sEndingMessage		as string
+global sEndTitle			as string
+
+'checkbox function
+global sCheckbox			as string
+global lState				as long
+
+'system metrics
+global ScreenX				as long
+global ScreenY				as long
+
+'time value
+global MY_TIMEOUT			as long
+global PACER				as long
+
+global PARAMS				as long
+global NOPARAMS				as long
+
+global hwndTapiControl		as hwndTAPI_CONTROL
+global ScenarioLog			as LOGINITSTRUCT
+
+global sdwPrivileges		as array of string
+global sPrivileges			as string
+global sdwMediaModes		as array of string
+global sMediaModes			as string
+
+'
+global hLineApp				as array of string
+global hLine				as array of string
+global hCall				as array of string
+
+redim sdwPrivileges(1 to 3)		as string
+redim sdwMediaModes(1 to 14)	as string
+
+global sdwNumRings				as string
+
+redim hLineApp(1 to 5)			as string   'limit 5 for now
+redim hLine(1 to 5)				as string
+redim hCall(1 to 5)				as string
+'redim hCall(5)				as string
+
+global hLineAppIndex			as pointer to string
+
+global slpszDestAddress			as string
+
+'counts
+global	ldwPrivilegesBitFlag		as long 
+global	ldwMediaModesBitFlag		as long
+global	ldwPrivilegesBitFlagChaos	as long
+global	ldwMediaModesBitFlagChaos	as long
+
+global	lLineApp					as long
+global	lLine						as long
+global	lCall						as long
+
+global	GenCount					as long
+global  lCountLineApp				as long		
+global  GenCount2					as long
+
+global	OutCount					as long		'benchmarker
+
+'coverage statistics
+'not yet implemented
+global	TapiStatistic				as TAPI_STATISTIC
+
+global  Tracelevel					as long		'debug output
+
+global	Benchmark					as long		'benchmarker
+
+'duh
+hwndTapiControl.TapiHandle			= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+hwndTapiControl.ParamsCheckbox			=&h000003f9
+hwndTapiControl.LineAppPlusButton		=&h000003ee
+hwndTapiControl.LineAppMinusButton		=&h000003ef
+hwndTapiControl.LinePlusButton			=&h000003f0
+hwndTapiControl.LineMinusButton			=&h000003f1
+hwndTapiControl.CallPlusButton			=&h000003f2
+hwndTapiControl.CallMinusButton			=&h000003f3
+hwndTapiControl.PhoneAppPlusButton		=&h000003f4
+hwndTapiControl.PhoneAppMinusButton		=&h000003f5
+hwndTapiControl.PhoneOpenPlusButton		=&h000003f6
+hwndTapiControl.PhoneOpenMinusButton	=&h000003f7
+hwndTapiControl.ClearEditButton			=&h000003f8
+hwndTapiControl.BlankButton0			=&h000003fa
+hwndTapiControl.BlankButton1			=&h000003fb
+hwndTapiControl.BlankButton2			=&h000003fc
+hwndTapiControl.BlankButton3			=&h000003fd
+hwndTapiControl.BlankButton4			=&h000003fe
+hwndTapiControl.BlankButton5			=&h000003ff
+hwndTapiControl.Listbox0				=&h000003e8		'middle box
+hwndTapiControl.Listbox1				=&h000003e9		'left box
+hwndTapiControl.Editbox					=&h000003eb		'right box
+
+'// assign
+sOutLogName=curdir$ + "\tapibvt.log"
+lCountSpace=0
+lCountFunc=0
+lCountTab=1
+MAX_BLANK=20				'static
+'const MY_TIMOUT=2*Benchmark '//THIS IS DEFINED AFTER BENCHMARK//
+PACER = 1
+PARAMS=1
+NOPARAMS=0
+const BUSYLINE="9,5569440"						'ISDN, switch will report busy
+const ANSWERLINE="9,9366991"						'ITG dial-up modem pool
+const NOLINE=" "
+
+const sOutBenchName="benchmrk.txt"				'benchmarker
+
+'debug; 0=no debug; 3 low, 2 med, 1 high --I know it is backward
+Tracelevel=0
+
+ScreenX=GetSystemMetrics(SM_CXSCREEN)
+ScreenY=GetSystemMetrics (SM_CYSCREEN)
+
+ScenarioLog.LogOutputType = LogTypeFile
+ScenarioLog.MinDetailLevel = 3
+ScenarioLog.ProductVersion = "4"
+ScenarioLog.MachineName = "Undefined"
+ScenarioLog.LogLocation = "tapibvt.log"
+ScenarioLog.Language = "US English"
+
+'WATCH IT
+'dwPrivileges string in the form of sdwPrivileges
+
+			'change these to pointers ASAP
+global NONE as long, MONITOR as long, OWNER as long
+			sdwPrivileges(1)="NONE"
+			NONE=1
+			sdwPrivileges(2)="MONITOR"
+			MONITOR=2
+			sdwPrivileges(3)="OWNER"
+			OWNER=3
+
+'dwMediaModes string in the form of sdwMediaModes
+'edit this, this is bulky & hacked:
+
+global UNKNOWN as long, INTERACTIVEVOICE as long, AUTOMATEDVOICE as long
+global DATAMODEM as long, G3FAX as long, TDD as long, G4FAX as long
+global DIGITALDATA as long, TELETEX as long, VIDEOTEX as long
+global TELEX as long, MIXED as long, ADSI as long, VOICEVIEW as long
+
+			sdwMediaModes(1)="UNKNOWN"
+			UNKNOWN=1
+			sdwMediaModes(2)="INTERACTIVEVOICE"
+			INTERACTIVEVOICE=2
+			sdwMediaModes(3)="AUTOMATEDVOICE"
+			AUTOMATEDVOICE=3
+			sdwMediaModes(4)="DATAMODEM"
+			DATAMODEM=4
+			sdwMediaModes(5)="G3FAX"
+			G3FAX=5
+			sdwMediaModes(6)="TDD"
+			TDD=6
+			sdwMediaModes(7)="G4FAX"
+			G4FAX=7
+			sdwMediaModes(8)="DIGITALDATA"
+			DIGITALDATA=8
+			sdwMediaModes(9)="TELETEX"
+			TELETEX=9
+			sdwMediaModes(10)="VIDEOTEX"
+			VIDEOTEX=10
+			sdwMediaModes(11)="TELEX"
+			TELEX=11
+			sdwMediaModes(12)="MIXED"
+			MIXED=12
+			sdwMediaModes(13)="ADSI"
+			ADSI=13
+			sdwMediaModes(14)="VOICEVIEW"
+			VOICEVIEW=14
+
+dim StartTime as long		'for benchmarker
+dim EndTime as long
+
+'/////////////////////////////////
+'///////  END HEADER /////////////
+'/////////////////////////////////
+
+'prototypes
+'lineInitialze()
+'lineShutdown(hLineApp)
+'lineOpen(hLineApp, dwDeviceID, lphLine, APIVersion, dwExtVersion, dwCallbackInstance, dwPrivileges, dwMediaModes, lpCallParams)
+'
+'BENCHMARKER      'hack hack hack
+'delete benchmark file
+	if exists(sOutLogName) then
+		kill sOutLogName
+	end if
+
+'timer is double precision
+	if exists(sOutBenchName) then
+		kill sOutBenchName
+	end if
+
+	StartTime=timer
+
+	for OutCount=1 to 100
+		PerfBox(str$(OutCount))
+		GenTimeOut(str$(OutCount))
+	next OutCount
+
+	EndTime=timer
+	Benchmark=Endtime-StartTime
+	
+	GenTimeOut("Benchmark: " + str$(Benchmark))
+	
+	StatusBox Close
+
+	if Benchmark > 3 then
+		msgbox "YOUR SYSTEM REALLY SUCKS." + chr$(010) + chr$(010) + "Please use a faster system.", MB_OK OR MB_ICONEXCLAMATION, "Slow Bench Warning"
+	end if
+
+	function GenTimeOut(OutCount as string) 'generate/generic file-i/o
+		Open sOutBenchName for append as #1
+			print #1, OutCount + chr$(009)     ' + time 
+		Close #1
+	end function
+
+	function PerfBox(OutCount as string)
+		StatusBox "Profiling System Performance..." + chr$(010) + OutCount,0,0,300,100,TRUE,TRUE,"Courier",8,400
+	end function
+
+'// set timout, now that we have benched
+MY_TIMEOUT = 2 + (2 * Benchmark)
+'//END BENCHMARKER
+
+viewport on
+viewport clear
+
+on KeyPress (27,FSHIFT) call KeyPressHandler
+sub KeyPressHandler (notification_data AS VARIANT)
+	statusbox close
+	'idyes:6 & idno:7
+	msgbox "Stop tests?", MB_YESNO OR MB_ICONQUESTION OR MB_DEFBUTTON2, "Interruption"
+	if idyes then 
+		statusbox close
+		EndMsg()
+		End
+	end if
+end sub
+
+' // Run things
+
+StartApps()
+if WMenuExists ("&Options\Log &structures\by n&one", MY_TIMEOUT) then
+	WMenuSelect("&Options\Log &structures\by n&one", MY_TIMEOUT)
+endif
+
+'do these after apps are running, duh
+hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT)
+GenOut("Getting Some")
+
+hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+'maximize window so button clicks work
+'WMaxWnd (hwndTapiControl.TapiHandle)
+
+GenOut("Logfile= " + chr$(009) + curdir$+sOutLogName)
+if Tracelevel > 2 then
+	GenOut("TAPI Browser handle= " + hex$(hwndTapiControl.TapiHandle))
+	GenOut("GetProcessHeap(): " + hex$(GetProcessHeap()))
+	GenOut("GetCurrentProcess(): " + hex$(GetCurrentProcess()))
+	GenOut("GetCurrentProcessID(): " + hex$(GetCurrentProcessID()))
+	GenOut("GetThread(): " + chr$(009) + hex$(GetCurrentThread()))
+	GenOut("GetCurrentThreadID(): " + hex$(GetCurrentThreadID()))
+end if
+GenOut(chr$(010)+chr$(010)+chr$(010))
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+
+'ensure edit box is clean
+WButtonClick( _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT ) 'do not uncheck this
+
+'********************
+'START YOUR ENGINES
+
+'lineGetProviderList()
+WSetActWnd (hwndTapiControl.TapiHandle)   'scatter a few of these since ESP steals focus
+'End Scenario
+
+'********************
+'********************
+
+FUNKY:
+
+Scenario "lineMakeCall (stuff)"
+Box("lineMakeCall (verify busy)")
+GenOut("Scenario:" + chr$(009) + "lineMakeCall (verify busy)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineMakeCall(lLine, lCall, BUSYLINE)		'doing this stranglely for now
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+'lineClose(lLine)
+'lineShutdown(lLineApp)
+
+Box("lineMakeCall, (status)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (status)")
+
+'line should be open from earlier routine
+'lineInitialize(lLineApp)
+'lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineMakeCall(lLine, lCall, ANSWERLINE)		'doing this stranglely for now
+
+	lineGetNewCalls(lLine)
+	lineGetAddressStatus(lLine)
+	lineGetCallInfo(lCall)
+	lineGetCallStatus(lCall)
+	lineSetAppSpecific(lCall)
+
+lineDrop(lCall)
+	lineGetCallInfo(lCall)
+	lineGetCallStatus(lCall)
+
+lineDeallocateCall(lCall)
+
+Box("lineMakeCall, (lineGetAppSpecific)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (lineGetAppSpecific)")
+
+lineMakeCall(lLine, lCall, ANSWERLINE)
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+
+Box("lineMakeCall, (Null lpszDestAddress)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (Null lpszDestAddress)")
+
+lineMakeCall(lLine, lCall, NOLINE)
+lineDial(lCall, ANSWERLINE)
+
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+lineClose(lLine)
+lineShutdown(lLineApp)
+
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetAddressCaps (default)"
+Box("lineGetAddressCaps (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressCaps (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetAddressCaps(lLineApp)
+lineShutdown(lLineApp)
+
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetAddressID (default)"
+Box("lineGetAddressID (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressID (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetAddressID(lLine)
+lineClose(lLine)
+lineShutdown(lLineApp)
+
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetAddressStatus (default)"
+Box("lineGetAddressStatus (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressStatus (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetAddressStatus(lLine)
+lineClose(lLine)
+lineShutdown(lLineApp)
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetDevConfig (default)"
+Box("lineGetDevConfig (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetDevConfig (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetDevConfig() 'no arguments, yet
+lineShutdown(lLineApp)
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetDevCaps (default)"
+Box("lineGetDevCaps (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetDevCaps (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetDevCaps(lLineApp)
+lineShutdown(lLineApp)
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetID (default)"
+Box("lineGetID (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetID (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetID(lLine)
+lineShutdown(lLineApp) 'will close too
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetLineDevStatus (default)"
+Box("lineGetLineDevStatus (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetLineDevStatus (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetLineDevStatus(lLine)
+lineShutdown(lLineApp) 'will close too
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetNewCalls (default)"
+Box("lineGetNewCalls (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetNewCalls (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetNewCalls(lLine)
+lineShutdown(lLineApp) 'will close too
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetNumRings (default)"
+Box("lineGetNumRings (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetNumRings (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetNumRings(lLine)
+lineShutdown(lLineApp) 'will close too
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineGetStatusMessages (default)"
+Box("lineGetStatusMessages (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetStatusMessages (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineGetStatusMessages(lLine)
+lineShutdown(lLineApp) 'will close too
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineHold (default)"
+Box("lineHold (default)")
+GenOut("Scenario:" + chr$(009) + "lineHold (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineMakeCall(lLine, lCall, ANSWERLINE)		'doing this stranglely for now
+lineHold(lCall)
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+lineClose(lLine)
+lineShutdown(lLineApp)
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineSetNumRings (default)"
+Box("lineSetNumRings (default)")
+GenOut("Scenario:" + chr$(009) + "lineSetNumRings (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+sdwNumRings="9"
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineSetNumRings(lLine, sdwNumRings)
+lineShutdown(lLineApp) 'will close too
+End Scenario
+
+'********************
+'********************
+
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+ENDME:
+
+
+'END 'END 'END
+
+'********************
+'********************
+'lineInitialize with one good pass, then individual null params
+Scenario "lineInitialize (many)"
+Box("lineInitialize (many)")
+WSetActWnd (hwndTapiControl.TapiHandle) 'freshen
+
+for lLineApp= 0 to 4
+	CallAPI("lineInitialize",0)
+next lLineApp
+
+End Scenario
+
+'********************
+'********************
+'Scenario "lineGetTranslateCaps"
+'Box("lineGetTranslate")
+' lineGetTranslateCaps()
+'End Scenario
+
+'********************
+'********************
+Scenario "lineShutdown (many)"
+Box("lineShutdown (many)")
+
+for lLineApp= 0 to 4  'note # of lineInitializes, I was too lazy to set a constant for limit
+	MiddleSelect()
+	CallAPI("lineShutdown",0)
+next lLineApp
+
+End Scenario
+
+'********************
+'********************
+Scenario "lineNegotiateAPIVersion (valid)"
+Box("lineNegotiateAPIVersion (valid)")
+'*** disable params, lineInitialize, lineNegotiateAPIVersion with valids, lineShutdown
+'disable params child
+
+CallAPI("lineInitialize",0)
+
+MiddleSelect()
+CallAPI("lineNegotiateAPIVersion",0)
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+Scenario "lineNegotiateAPIVersion (invallow_valhi)"
+Box("lineNegotiateAPIVersion (invallow_valhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invallow and valhi
+'*** disable params, lineShutdown
+'no params
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineNegotiateAPIVersion",1)
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Valid")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+Scenario "lineNegotiateAPIVersion (vallow_invalhi)"
+Box("lineNegotiateAPIVersion (vallow_invalhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with vallow and invalhi
+'*** disable params, lineShutdown
+'need params
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineNegotiateAPIVersion",1)
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Valid")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineNegotiateAPIVersion (invallow_invalhi)"
+Box("lineNegotiateAPIVersion (invallow_invalhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invallow and invalhi
+'*** disable params, lineShutdown
+'no params
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineNegotiateAPIVersion",1)
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Invalid")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineNegotiateAPIVersion_invaldev"
+Box("lineNegotiateAPIVersion (invaldev)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invalid device
+'*** disable params, lineShutdown
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineNegotiateAPIVersion",1)
+
+SelectParam("dwDeviceID")
+SetParamValue("Invalid")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+
+Scenario "lineNegotiateExtVersion"
+Box("lineNegotiateExtVersion")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateExtVersion
+'*** disable params, lineShutdown
+'no params
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineNegotiateExtVersion",0)
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+Scenario "linOpen_privileges (none)"
+Box("linOpen_privileges (none)")
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("None")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+Scenario "linOpen_privileges (monitor)"
+Box("linOpen_privileges (monitor)")
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Monitor")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+Scenario "linOpen_privileges (owner)"
+Box("linOpen_privileges (owner)")
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+
+'********************
+'********************
+Scenario "linOpen_privileges (multi)"
+Box("linOpen_privileges (multi)")
+
+CallAPI("lineInitialize",0)
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("None")
+HitOK()
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Monitor")
+HitOK()
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+End Scenario
+
+'********************
+'********************
+'*** BEGIN dwPrivileges, dwMediaModes strobing
+'*** WATCH THIS: LOOP 
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with defaults
+'*** disable params, lineShutdown
+
+'five times
+for lLineApp = 0 to 4
+Scenario "lineOpen_MediaModes, sdwPrivileges, dwMediaModes.DATAMODEM (TB default)"
+Box("lineOpen_MediaModes, dwPrivileges.NONE, dwMediaModes.DATAMODEM (TB default)")
+
+CallAPI("lineInitialize",0)
+CallAPI("lineOpen",0) 'defaults are dwPrivileges.NONE, dwMediaModes.DATAMODEM
+CallAPI("lineShutdown",0)
+End Scenario
+next lLineApp
+
+'********************
+'********************
+'***  matrix privileges and MediaModes (STRAIGHT THROUGH)
+'***  dwMediaModes strobing
+'***  [attemts most combos]
+
+for ldwPrivilegesBitFlag = 1 to 3
+'dwPrivileges string in the form of sdwPrivileges
+
+	for ldwMediaModesBitFlag = 1 to 14
+
+	'one day, change this to a cleaner array
+	'********************
+	Scenario "lineOpen_MediaModes, (STRAIGHT THROUGH) " + sdwPrivileges(ldwPrivilegesBitFlag) + ", " + sdwMediaModes(ldwMediaModesBitFlag)
+	Box("lineOpen_MediaModes, (STRAIGHT THROUGH) " + sdwPrivileges(ldwPrivilegesBitFlag) + ", " + sdwMediaModes(ldwMediaModesBitFlag))
+	
+	'This is a workaround to bypass the TAPI for NT hanging problem.
+	
+
+
+	CallAPI("lineInitialize",0)
+
+	CallAPI("lineOpen",1)
+	SelectParam("dwPrivileges")
+	SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+	SelectBitFlag(sdwPrivileges(ldwPrivilegesBitFlag)) 'set Bit flag
+	SelectParam("dwMediaModes")
+	SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+	SelectBitFlag(sdwMediaModes(ldwMediaModesBitFlag))
+	HitOK()
+	
+	MiddleSelect() 'just select anything in the list box
+	CallAPI("lineShutdown",0)
+
+	End Scenario
+
+	next ldwMediaModesBitFlag
+next ldwPrivilegesBitFlag
+
+'********************
+'********************
+'*** END dwMediaModes (STRAIGHT THROUGH)
+'********************
+'********************
+'********************
+'********************
+
+goto SKIPCHAOS
+
+'********************
+'********************
+'***  matrix privileges and MediaModes (CHAOTIC)
+'***  dwMediaModes strobing
+'***  [try simultaneous operations]
+CHAOS:
+for GenCount=1 to 200
+	'not used: randomize TIMER	 'for "bound-ed" chaos
+	'********************
+	Scenario ("lineOpen_MediaModes, (CHAOTIC)")
+	
+	Box("lineOpen_MediaModes, (CHAOTIC)")
+	'do 5
+	for lLineApp= 0 to 4
+	LineInitialize(lLineApp) 'returns hLineApp(lLineApp)
+	next lLineApp
+	
+	'begin Chaos translation here so I may retain my pretty matrix blocks & to increase hits
+	
+	for lLineApp=0 to 4
+	GenChaos()						'all globals
+	SelectLineApp(lLineApp)
+	CallAPI("lineOpen",1)
+	SelectParam("dwPrivileges")
+	SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+	SelectBitFlag(sdwPrivileges(ldwPrivilegesBitFlagChaos)) 'set Bit flag
+	SelectParam("dwMediaModes")
+	SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+	SelectBitFlag(sdwMediaModes(ldwMediaModesBitFlagChaos))
+	HitOK()
+	next lLineApp
+
+	'cleanup, do 5
+	'WILL NOT WORK WITHOUT HANDLES
+	for lLineApp= 0 to 4
+	LineShutdown(lLineApp)
+	next lLineApp
+
+	End Scenario
+next GenCount
+
+'********************
+'********************
+'*** END dwMediaModes (CHAOTIC)
+'********************
+'********************
+'********************
+'********************
+
+SKIPCHAOS:
+
+
+'********************
+'********************
+'********************
+'********************
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+Scenario "linOpen_MediaModes (privileges_multi)"
+Box("linOpen_MediaModes (privileges_multi)")
+
+CallAPI("lineInitialize",0)
+
+
+'as owner
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("DATAMODEM")
+HitOK()
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("TELETEX")
+HitOK()
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("TELEX")
+HitOK()
+
+CallAPI("lineOpen",1)
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("INTERACTIVEVOICE")
+HitOK()
+
+MiddleSelect()
+CallAPI("lineShutdown",0)
+
+End Scenario
+'///////////////
+
+' *************************
+' ***** END TEST CASE *****
+' *************************
+
+
+'///////
+'///////
+'///////
+
+
+'*****  END   END   END   END   END   END  *****
+
+StatusBox Close
+EndMsg()
+End
+
+'********************
+'********************
+
+JUNKY:
+
+Scenario "Call Unimplemented APIs"
+Box("Call Unimplemented APIs")
+GenOut("Scenario:" + chr$(009) + "Call Unimplemented APIs")
+
+'CallAPI("lineAddToConference",0)				'requires two calls on one line
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))	'doing this stranglely for now
+lineMakeCall(lLine, lCall, BUSYLINE)		'doing this stranglely for now
+
+
+CallAPI("lineBlindTransfer",0)					'requires call
+CallAPI("lineCompleteCall",0)					'requires call
+'CallAPI("lineCompleteTransfer",0)				'requires two calls on one line
+CallAPI("lineDevSpecific",0)					'requires line
+CallAPI("lineDevSpecificFeature",0)				'requires line
+CallAPI("lineForward",0)						'requires line
+CallAPI("lineGatherDigits",0)					'requires call
+CallAPI("lineGenerateDigits",0)					'requires call
+CallAPI("lineGenerateTone",0)					'requires call
+
+
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+
+
+CallAPI("lineGetConfRelatedCalls",0)
+CallAPI("lineGetRequest",0)
+CallAPI("lineMonitorDigits",0)
+CallAPI("lineMonitorMedia",0)
+CallAPI("lineMonitorTones",0)
+CallAPI("lineNegotiateExtVersion",0)
+CallAPI("linePark",0)
+CallAPI("linePickup",0)
+CallAPI("linePrepareAddToConference",0)
+CallAPI("lineRedirect",0)
+CallAPI("lineRegisterRequestRecipient",0)
+CallAPI("lineRemoveFromConference",0)
+CallAPI("lineSecureCall",0)
+CallAPI("lineSendUserUserInfo",0)
+CallAPI("lineSetAppSpecific",0)
+CallAPI("lineSetTerminal",0)
+CallAPI("lineSetTollList",0)
+CallAPI("lineSetupConference",0)
+CallAPI("lineSetupTransfer",0)
+CallAPI("lineSwapHold",0)
+CallAPI("lineUncompleteCall",0)
+CallAPI("lineUnhold",0)
+CallAPI("lineUnpark",0)
+
+End Scenario
+
+'********************
+'********************
+
+
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+
+'********************
+'********************
+
+'Scenario "lineClose"
+'
+'do not need params
+'SetCheckboxControl(_id(hwndTapiControl.ParamsCheckbox),0)
+'MiddleSelect()
+'SelectParam("lineClose")
+'play "{ENTER}"
+'
+'CaptureEdit()
+'
+'End Scenario
+
+
+
+
+
+
+'
+'/**************************************************/
+'FUNCTIONS
+
+'Outputs, identical until global architecture change
+function GenOut(sFuncString as string) 'generate/generic file-i/o
+' // open logging file
+	box("Calling:  " + sFuncString)
+	Open sOutLogName for append as #1
+		print #1, sFuncString + chr$(009)     ' + time 
+		print hwndViewport, sFuncString + chr$(009)     '+ time
+	Close #1
+end function
+
+function GenOutFunc(sFuncString as string) 'generate file-i/o of current function
+' // open logging file
+	box ("Calling:  " + sFuncString)
+	Open sOutLogName for append as #1
+		print #1, sFuncString + chr$(009) + time 
+		print hwndViewport, sFuncString + chr$(009) + time
+	Close #1
+end function
+
+
+'for TBPoke only: GetFunc runs the state core, remember to trim tabs
+' this was from TBPoke, but it has been modified not to look for script file
+function GetFunc (sFuncString as string)
+		sFuncString=""
+		'count the entries
+		lCountFunc=lCountFunc+1
+		sFuncString=trim$(sFuncString,009)		'trim tabs
+		sFuncString=trim$(sFuncString," ")		'whatever MST calls a space
+		sFuncString=trim$(sFuncString,255)		'trim truespace
+		if sFuncString=chr$(000) then sFuncString="COMMENT"	'ASCII null
+end function
+
+'Check for runaway file i/o read; consider it "IsCarriageReturn"
+function IsRunaway(sFuncString as string) as string	
+	if sFuncString="" then
+		lCountSpace=lCountSpace+1				'begin counting blank entries
+		if lCountSpace=MAX_BLANK then sFuncString="END"
+	else
+		lCountSpace=0
+	end if
+end function
+
+'Find comments
+function IsComment(sFuncString as string) as string
+	select case(ucase$(left$(sFuncString,1)))
+		case ";"
+			sFuncString="COMMENT"
+		case "#"
+			sFuncString="COMMENT"
+		case "'"
+			sFuncString="COMMENT"
+		case ""							
+			sFuncString="COMMENT"
+			'IsRunaway(sFuncString)				'count blanks to prevent infinite loop
+			'GenOut(sFuncString, hwndViewport)
+	end select
+
+	'find other comments
+	select case(left$(sFuncString,2))
+		case "//"
+			sFuncString="COMMENT"
+	end select
+
+	'find more comments, I know it is not model code, shut up
+	select case(left$(sFuncString,4))
+		case "REM "							'with space
+			sFuncString="COMMENT"
+	end select
+
+end function 'IsComment
+
+
+'toggle checkbox state, will leave focus on sCheckbox
+function SetCheckboxControl(sCheckbox as string, lState as long) as long
+	select case(lState)
+		case 0
+			If WCheckState(sCheckbox) = CHECKED then
+				WCheckUnCheck(sCheckbox,MY_TIMEOUT)
+				if Tracelevel>=3 then GenOut ("Unchecking checkbox "+sCheckbox)
+			else 
+				if Tracelevel>=2 then GenOut ("Error: Attempt to WCheckUnCheck() unchecked checkbox "+sCheckbox)
+			end if
+		case 1
+			If WCheckState(sCheckbox) = UNCHECKED then
+				WCheckCheck(sCheckbox,MY_TIMEOUT)
+				if Tracelevel>=3 then GenOut ("Checking checkbox "+sCheckbox)
+			else 
+				if Tracelevel>=2 then GenOut ("Error: Attempt to WCheckCheck() checked checkbox "+sCheckbox)
+			end if
+	end select
+end function
+
+function HitOK() 'hits the OK button
+	WButtonClick( "OK", MY_TIMEOUT)
+	CaptureEdit()
+	
+end function
+
+function CallAPI(sFuncString as string, lState as long)
+	if lState > 1 then GenOut("Error:  lState is exceeds value of 1.")
+	GenOut("API:" + chr$(009) + sFuncString)
+	SetCheckboxControl(_id(hwndTapiControl.ParamsCheckbox),lState)
+	WListItemClk(_id(hwndTapiControl.Listbox1), sFuncString, MY_TIMEOUT)
+	play "{ENTER}"
+	if lState=0 then CaptureEdit()  'so calling the API w/ default params gens output & HitOK gens output (see HitOK())
+end function
+
+function SelectParam(sFuncString as string)
+	GenOut("Parameter:" + chr$(009) + sFuncString)
+	WListFind ("Parameters:", MY_TIMEOUT)
+	WListItemDblClk("Parameters:", sFuncString, MY_TIMEOUT)
+end function
+
+function SetParamValue(sFuncString as string)
+		GenOut("Parameter Value:" + chr$(009) + sFuncString)
+		WEditSetFocus("Value:", MY_TIMEOUT)
+		select case(ucase$(sFuncString))
+			case ucase$("Null")
+				play "00000000"
+			case ucase$("Valid")  'WATCH THIS:  dankn often displays English here
+				'leave it alone, default is VALID or valid value
+				'play "{DOWN}"
+				'play "{DOWN}"
+			case ucase$("Invalid")
+				play "ffffffff"
+			case else
+				GenOut("Error:  Bad SetParamValue() parameter:  " + sFuncstring)
+		end select
+end function
+
+'global ParamValue as string 'put this at front
+'function SetParamValue(sFuncString as string,ParamValue as string)
+'	SelectParam(sFuncString as string)
+
+function SelectBitFlag(sFuncString as string)
+	GenOut("Select Bit Flag: " + sFuncString)
+	'lineOpen has defaults: dwPrivileges.NONE, dwMediaModes.DATAMODEM
+	WListFind ("Bit flags:", MY_TIMEOUT)
+	WListItemDblClk("Bit flags:", sFuncString, MY_TIMEOUT)
+	'BitFlag[] sFuncString  ;;;; soon add cleanup structure
+end function
+
+function EndMsg()
+	sEndingMessage="TB BVT ended."
+	sEndTitle="Completed"
+	msgbox sEndingMessage, MB_OK, sEndTitle
+end function
+
+function CaptureEdit()
+		'play "{ENTER}" 'assuming child window is in focus and OK button is selected
+		'GenOut("********************  TAPI Report  ********************")
+		'GenOut(ListText(_id(hwndTapiControl.Listbox0), MY_TIMEOUT))
+		sleep 0.1								'take an i/o break
+		GenOut("TAPI Browser reports: ")
+		GenOut(EditText(_id(hwndTapiControl.Editbox) + chr$(010), MY_TIMEOUT))
+		'GenOut("********************  END REPORT  *********************" + chr$(010) + chr$(010))
+		WButtonClick(_id(hwndTapiControl.ClearEditButton), MY_TIMEOUT)
+end function
+
+'>>++++
+function MiddleSelect() 'not yet:  sFuncString as string      'selects last item in .Listbox0
+		WListSetFocus(_id(hwndTapiControl.Listbox0), MY_TIMEOUT)
+		'not yet:  WListItemDblClk(_id(hwndTapiControl.Listbox0), sFuncString, MY_TIMEOUT)
+		play "{PGDN}"
+end function
+
+function lineGetProviderList()
+	CallAPI("lineGetProviderList",0)
+end function
+
+function lineGetTranslateCaps()
+	CallAPI("lineGetTranslateCaps",0)
+	Box("Dumping buffer")
+	sleep 1
+	Box("Dumping buffer")
+	sleep 1
+end function
+
+function Box(sFuncString as string)
+	'disabled, bug in statusbox is stealing focus
+	'StatusBox sFuncString + chr$(009),ScreenX-300,ScreenY-75,300,75,FALSE,FALSE,"Courier",8,400
+end function
+
+'function SelectLineApp(lLineApp as long) 'machine
+'	'later revise to allow real-time monitor of handles
+'	'select valid lineApp lLineApp, searching top to bottom, exit out having made selection
+'	'It does look bad.  If dankn's conventions stray too far, this will fail
+'	MiddleSelect()
+'	if lLineApp > WListCount(_id(hwndTapiControl.Listbox0), MY_TIMEOUT) then 
+'		GenOut("Error: BAD ONE, lLineApp of " + str$(lLineApp) + " exceeding WListCount of " + str$(WListCount(_id(hwndTapiControl.Listbox0), MY_TIMEOUT)))
+'		beep
+'		beep
+'		beep
+'		goto SKIPSelectLineApp
+'	end if
+'	play "{PGUP}"
+'	lCountLineApp=WListCount(_id(hwndTapiControl.Listbox0), MY_TIMEOUT)
+'	for GenCount = 1 to lCountLineApp
+'		'do not down-arrow yet since first item is selected
+'		sLineApp=ListItemText(_id(hwndTapiControl.Listbox0), WListIndex(_id(hwndTapiControl.Listbox0),MY_TIMEOUT),MY_TIMEOUT)
+'		select case (left$(ucase$(sLineApp),9))
+'			case ucase$("LineApp=x")	'first half matches (this may happen with invalids too, so look on
+'				select case (val(right$(sLineApp,8)))
+'					case 0				'is an invalid, so index
+'						play "{DOWN}"
+'					case else			'hex value is non-zero, let us use it
+'						select case (WListIndex(_id(hwndTapiControl.Listbox0),MY_TIMEOUT))
+'							case (lLineApp) 'is this the index requested?
+'								GenCount=lCountLineApp  'return	'get out, leaving it focused
+'							case else		'is not lLineApp, so index
+'							play "{DOWN}"	
+'						end select
+'				end select
+'			case else						'is not "LineApp=x", so index
+'				play "{DOWN}"				
+'		end select 'THIS MESS DONE SINCE this shitty beta has horrible if-then nesting errors (not me!)
+'	next GenCount
+'	SKIPSelectLineApp:	'skip if lLineApp is bogus value
+'end function
+
+function StartApps()
+	run "MTVIEW.EXE", nowait, SW_NORMAL
+    hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT,5) 'find Visual Test Viewport
+	if hwndViewport = 0 then
+        fail "MTVIEW.EXE application failed to start"
+    end if
+
+	run "TB20.EXE" , nowait , SW_MAXIMIZE						'NOWAIT SW_NORMAL
+	sleep 2
+	hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT,5) 'find TAPI32 BROWSER
+	if hwndTapiControl.TapiHandle= 0 then
+        fail "TB20.EXE application failed to start"
+    end if
+end function
+
+'not used:
+function StopApps()
+    hwndViewport = WFndWnd("Visual Test Viewport", FW_DEFAULT or FW_FOCUS)
+    if hwndViewport <> 0 then
+        Play "%{F4}" 'alt f4
+    end if
+
+    hwndTapiControl.TapiHandle = WFndWnd("TAPI32 Browser", FW_DEFAULT or FW_FOCUS)
+    if hwndTapiControl.TapiHandle <> 0 then
+        Play "%{F4}" 'alt f4
+    end if
+end function
+
+function GenChaos() 'all globals
+	ldwPrivilegesBitFlagChaos=(int(rnd*3)+1)
+	ldwMediaModesBitFlagChaos=(int(rnd*14)+1)
+	Box("lineOpen_MediaModes, (CHAOS) LineApp "  + str$(lLineApp) + ", " + sdwPrivileges(ldwPrivilegesBitFlagChaos) + ", " + sdwMediaModes(ldwMediaModesBitFlagChaos))
+	GenOut("lineOpen_MediaModes, (CHAOS)" + str$(ldwPrivilegesBitFlagChaos) +","+ str$(ldwMediaModesBitFlagChaos) + " LineApp " + str$(lLineApp) + ", " + sdwPrivileges(ldwPrivilegesBitFlagChaos) + ", " + sdwMediaModes(ldwMediaModesBitFlagChaos))
+end function
+
+function lineInitialize(lLineApp as long) 'all globals; stipulate lLineApp for ease of array; for ex: lineInitialize(lLineApp); lLineApp being long
+	CallAPI("lineInitialize",0)	'create a LineApp
+
+	'lineApp is now open...
+	CallAPI("lineOpen",1)		'cheat, use TB to provide clean handle
+	SelectParam("hLineApp")		'select the hLineApp of Params:
+	WEditSetFocus("Value:", MY_TIMEOUT) 'set focus, no real reason
+	hLineApp(lLineApp)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+	if Tracelevel >= 1 then GenOut("New hLineApp=" + chr$(009) + hLineApp(lLineApp))
+	Abort()
+end function
+
+function LineShutdown(lLineApp as long) 'all globals
+	CallAPI("lineShutdown",1)
+	SelectParam("hLineApp")
+	WEditSetFocus("Value:", MY_TIMEOUT) 'ready to enter handle
+	play hLineApp(lLineApp)
+	HitOK()
+end function
+
+function SelectLineApp(lLineApp as long) 'all globals
+	MiddleSelect()
+	WListItemClk(_id(hwndTapiControl.Listbox0), "LineApp=x" + (hLineApp(lLineApp)), MY_TIMEOUT)
+end function
+
+'not implemented
+function SelectLine(lLine as long) 'all globals; prep for lineMakeCall
+	MiddleSelect()
+	' (_id(hwndTapiControl.Listbox0), "Line=x" + (hLineApp(lLineApp)), MY_TIMEOUT)
+end function
+
+function lineOpen(lLineApp as long, lLine as long, sPrivileges as string, sMediaModes as string)		
+	CallAPI("lineOpen",1)		'child window is open and focused
+	SelectParam("hLineApp")
+	WEditSetFocus("Value:", MY_TIMEOUT)
+	play hLineApp(lLineApp)		'handle of LineApp
+
+	SelectParam("dwPrivileges")
+	GenOut("Clearing default on following line:")
+	SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+	SelectBitFlag(sPrivileges) 'set Bit flag
+	SelectParam("dwMediaModes")
+	GenOut("Clearing default on following line:")
+	SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+	SelectBitFlag(sMediaModes)
+
+	HitOK()
+
+	CallAPI("lineMakeCall",1)  'cheat, use to get hLine value
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)			'set focus, no real reason
+	hLine(lLine)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+	if Tracelevel >= 1 then GenOut("New hLine=" + chr$(009) + hLine(lLine))
+	Abort()									'abort child
+end function
+
+function lineMakeCall(lLine as long, lCall as long, slpszDestAddress as string) 
+	CallAPI("lineMakeCall",1)				'child window is open and focused
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus, no real reason
+	play hLine(lLine)						'specify the handle
+
+	SelectParam("lpszDestAddress")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play slpszDestAddress
+	WButtonClick( "OK", MY_TIMEOUT)
+	sleep 10
+
+	'hide dialog
+	if slpszDestAddress <> " " then
+		WButtonFind ( "&Talk", 15)		'use a way to wait for dialog
+		WSetActWnd (hwndTapiControl.TapiHandle)	'refocus TB
+		sleep 3	
+	end if
+		
+	'if slpszDestAddress <> " " then
+	'	WSetWndPos ( WFndWnd("Call Status", FW_DEFAULT), ScreenX, ScreenY) 'find Call Status window
+	'	sleep 15
+	'end if
+
+	'if slpszDestAddress <> " " then			'being caution of Talk/Hangup dialog
+	'   sleep 12
+	'	WButtonClick( "&Talk", MY_TIMEOUT + 10)
+	'end if
+	'
+	
+	CallAPI("lineDrop",1)					'cheat, use to get hCall value
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)
+	hCall(lCall)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+	if Tracelevel >= 1 then GenOut("New hCall=" + chr$(009) + hCall(lCall))
+	Abort()
+end function
+
+function lineDrop(lCall as long)
+	CallAPI("lineDrop",1)
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hCall(lCall)						'specify the handle
+	HitOK()
+end function
+
+function lineDeallocateCall(lCall as long)
+	CallAPI("lineDeallocateCall",1)
+	Selectparam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hCall(lCall)						'specify handle
+	HitOK()
+end function
+
+'not implemented; in-work
+function lineAddToConference(lLine as long)
+	CallAPI("lineAddToConference",1)
+	Selectparam("hLine")
+	'blah
+end function
+
+function lineAnswer()
+end function
+
+function Abort()
+	play "{ESC}" 'abort child
+	GenOut("Aborted child window:  OK, probably getting handle here." + chr$(010))
+end function
+
+'not implemented
+function CheckErr(TAPIErr as string)
+'lineAddProvider returned LINEERR_INVALPOINTER
+end function
+
+function lineClose(lLine)
+	CallAPI("lineClose",1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus, no real reason
+	play hLine(lLine)						'specify the handle
+	HitOK()
+end function
+
+function lineGetNewCalls(lLine as long)
+	CallAPI("lineGetNewCalls",1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus, no real reason
+	play hLine(lLine)						'specify the handle
+	HitOK()
+end function
+
+function lineGetAddressStatus(lLine as long)
+	CallAPI("lineGetAddressStatus",1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus, no real reason
+	play hLine(lLine)						'specify the handle
+	HitOK()
+end function	
+
+function lineGetCallInfo(lCall as long)
+	CallAPI("lineGetCallInfo", 1)
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus, no real reason
+	play hCall(lCall)						'specify the handle
+	HitOK()
+end function
+
+function lineGetCallStatus(lCall as long)
+	CallAPI("lineGetCallStatus", 1)	
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus, no real reason
+	play hCall(lCall)						'specify the handle
+	HitOK()
+end function
+
+function lineSetAppSpecific(lCall as long)
+	CallAPI("lineSetAppSpecific", 1)	
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hCall(lCall)						'specify the handle
+	HitOK()
+end function
+
+function lineDial(lCall as long, slpszDestAddress as string)
+	CallAPI("lineDial", 1)
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hCall(lCall)						'specify the handle
+
+	SelectParam("lpszDestAddress")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play slpszDestAddress					
+	
+	WButtonClick( "OK", MY_TIMEOUT)			
+	sleep 5
+
+	'hide dialog
+	WButtonFind ( "&Talk", 15)		'use a way to wait for &Talk dialog
+	WSetActWnd (hwndTapiControl.TapiHandle)	'refocus TB
+	sleep 1	
+	
+	'WButtonClick( "&Talk", MY_TIMEOUT + 10)
+end function
+
+function lineGetAddressCaps(lLineApp as long)
+	CallAPI("lineGetAddressCaps", 1)
+	SelectParam("hLineApp")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLineApp(lLineApp)
+	HitOK()
+end function
+
+function lineGetAddressID(lLine as long)
+	CallAPI("lineGetAddressID", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+	HitOK()
+end function
+
+function lineGetDevConfig()
+	'ensure a LineApp is open when calling lineGetDevConfig
+	CallAPI("lineGetDevConfig", 0)
+end function
+
+function lineGetDevCaps(lLineApp as long)
+	Box("Dumping buffer")
+	CallAPI("lineGetDevCaps", 1)
+	SelectParam("hLineApp")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLineApp(lLineApp)
+	HitOK()
+end function
+
+function lineGetID(lLine as long)		'consider parameter Bit flags here
+	CallAPI("lineGetID", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+	HitOK()
+end function	
+
+function lineGetLineDevStatus(lLine as long)
+	CallAPI("lineGetLineDevStatus", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+	HitOK()
+end function	
+	
+function lineGetNumRings(lLine as long)
+	CallAPI("lineGetNumRings", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+	HitOK()
+end function	
+
+function lineGetStatusMessages(lLine as long)
+	CallAPI("lineGetStatusMessages", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+	HitOK()
+end function	
+
+function lineHold(lCall as long)
+	CallAPI("lineHold", 1)
+	SelectParam("hCall")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hCall(lCall)
+	HitOK()
+end function
+
+function lineSetNumRings(lLine as long, sdwNumRings as string)
+	CallAPI("lineSetNumRings", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+
+	SelectParam("dwNumRings")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play sdwNumRings
+
+	HitOK()
+end function	
+
+function lineSetStatusMessages(lLine as long)
+	CallAPI("lineSetStatusMessages", 1)
+	SelectParam("hLine")
+	WEditSetFocus("Value:", MY_TIMEOUT)		'set focus
+	play hLine(lLine)
+	HitOK()
+end function	
+
+
+
+
+
+
+
+'truly the end
diff --git a/private/tapi/qa/bvt/current/tapibvt3.mst b/private/tapi/qa/bvt/current/tapibvt3.mst
new file mode 100644
index 000000000..36fe363d0
--- /dev/null
+++ b/private/tapi/qa/bvt/current/tapibvt3.mst
@@ -0,0 +1,1962 @@
+'TB BVT
+'
+
+
+' WARNING:  This is a piece of junk.  No warrantee implied.
+'spaghetti, not authored by me, just scribbled by me, (ajohnh, some time in '95)
+'
+'$DEFINE MSTEST32
+'$IFDEF  MSTEST32
+    '$INCLUDE 'd:\mt32\inc\declares.inc'
+    '$INCLUDE 'd:\mt32\inc\tbpoke.h'
+'$ELSE
+    '$INCLUDE 'D:\msdev\include\RECORDER.INC'
+    '$include 'D:\msdev\include\winapi.inc'
+    '$INCLUDE 'D:\MSDEV\INCLUDE\TBPOKE.H'
+'$ENDIF
+'//////////////////////////////////////////
+'////// borrowed from my in-work TBPoke:
+'logging
+global sOutLogName          as string
+global sScriptName          as string
+global sComment             as string
+
+global hwndViewport         as long
+global lCountSpace          as long
+global lCountFunc           as long
+global lCountTab            as long
+global MAX_BLANK            as long
+global sFuncString          as string
+
+'end reporting
+global sEndingMessage       as string
+global sEndTitle            as string
+
+'checkbox function
+global sCheckbox            as string
+global lState               as long
+
+'system metrics
+global ScreenX              as long
+global ScreenY              as long
+
+'time value
+global MY_TIMEOUT           as long
+global PACER                as long
+
+global PARAMS               as long
+global NOPARAMS             as long
+
+global hwndTapiControl      as hwndTAPI_CONTROL
+global ScenarioLog          as LOGINITSTRUCT
+
+'$IFDEF MSTEST32
+    global sdwPrivileges(1 to 10)        as string
+    global sdwMediaModes(1 to 30)        as string
+'$ELSE
+    global sdwPrivileges        as array of string
+    global sdwMediaModes        as array of string
+'$ENDIF
+
+global sPrivileges          as string
+global sMediaModes          as string
+
+'$IFDEF MSTEST32
+    global hLineApp(1 to 10)    as  string
+    global hLine(1 to 10)       as  string
+    global hCall(1 to 10)       as  string
+'$ELSE
+    global hLineApp             as array of string
+    global hLine                as array of string
+    global hCall                as array of string
+'$ENDIF
+
+redim sdwPrivileges(1 to 3)     as string
+redim sdwMediaModes(1 to 14)    as string
+
+global sdwNumRings              as string
+
+redim hLineApp(1 to 5)          as string   'limit 5 for now
+redim hLine(1 to 5)             as string
+redim hCall(1 to 5)             as string
+'redim hCall(5)             as string
+
+'$IFDEF MSTEST32
+     global hLineAppIndex            as  string*10
+'$ELSE
+    global hLineAppIndex            as pointer to string
+'$ENDIF
+
+global slpszDestAddress         as string
+
+'counts
+global  ldwPrivilegesBitFlag        as long
+global  ldwMediaModesBitFlag        as long
+global  ldwPrivilegesBitFlagChaos   as long
+global  ldwMediaModesBitFlagChaos   as long
+
+global  lLineApp                    as long
+global  lLine                       as long
+global  lCall                       as long
+
+global  GenCount                    as long
+global  lCountLineApp               as long
+global  GenCount2                   as long
+
+global  OutCount                    as long     'benchmarker
+
+'coverage statistics
+'not yet implemented
+global  TapiStatistic               as TAPI_STATISTIC
+
+global  Tracelevel                  as long     'debug output
+
+global  Benchmark                   as long     'benchmarker
+
+'duh
+hwndTapiControl.TapiHandle          = WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+hwndTapiControl.ParamsCheckbox          =&h000003f9
+hwndTapiControl.LineAppPlusButton       =&h000003ee
+hwndTapiControl.LineAppMinusButton      =&h000003ef
+hwndTapiControl.LinePlusButton          =&h000003f0
+hwndTapiControl.LineMinusButton         =&h000003f1
+hwndTapiControl.CallPlusButton          =&h000003f2
+hwndTapiControl.CallMinusButton         =&h000003f3
+hwndTapiControl.PhoneAppPlusButton      =&h000003f4
+hwndTapiControl.PhoneAppMinusButton     =&h000003f5
+hwndTapiControl.PhoneOpenPlusButton     =&h000003f6
+hwndTapiControl.PhoneOpenMinusButton    =&h000003f7
+hwndTapiControl.ClearEditButton         =&h000003f8
+hwndTapiControl.BlankButton0            =&h000003fa
+hwndTapiControl.BlankButton1            =&h000003fb
+hwndTapiControl.BlankButton2            =&h000003fc
+hwndTapiControl.BlankButton3            =&h000003fd
+hwndTapiControl.BlankButton4            =&h000003fe
+hwndTapiControl.BlankButton5            =&h000003ff
+hwndTapiControl.Listbox0                =&h000003e8     'middle box
+hwndTapiControl.Listbox1                =&h000003e9     'left box
+hwndTapiControl.Editbox                 =&h000003eb     'right box
+
+'// assign
+sOutLogName=curdir$ + "\tapibvt.log"
+lCountSpace=0
+lCountFunc=0
+lCountTab=1
+MAX_BLANK=20                'static
+'const MY_TIMOUT=2*Benchmark '//THIS IS DEFINED AFTER BENCHMARK//
+PACER = 1
+PARAMS=1
+NOPARAMS=0
+const BUSYLINE="9,5569440"                      'ISDN, switch will report busy
+const ANSWERLINE="9,9366991"                        'ITG dial-up modem pool
+const NOLINE=" "
+
+const sOutBenchName="benchmrk.txt"              'benchmarker
+
+'$IFDEF MSTEST32
+    const LogTypeFile=1 '1 is for log to file
+'$ENDIF
+
+'debug; 0=no debug; 3 low, 2 med, 1 high --I know it is backward
+Tracelevel=0
+
+ScreenX=GetSystemMetrics(SM_CXSCREEN)
+ScreenY=GetSystemMetrics (SM_CYSCREEN)
+
+ScenarioLog.LogOutputType = LogTypeFile
+ScenarioLog.MinDetailLevel = 3
+ScenarioLog.ProductVersion = "4"
+ScenarioLog.MachineName = "Undefined"
+ScenarioLog.LogLocation = "tapibvt.log"
+ScenarioLog.Language = "US English"
+
+'WATCH IT
+'dwPrivileges string in the form of sdwPrivileges
+
+            'change these to pointers ASAP
+global NONE as long, MONITOR as long, OWNER as long
+            sdwPrivileges(1)="NONE"
+            NONE=1
+            sdwPrivileges(2)="MONITOR"
+            MONITOR=2
+            sdwPrivileges(3)="OWNER"
+            OWNER=3
+
+'dwMediaModes string in the form of sdwMediaModes
+'edit this, this is bulky & hacked:
+
+global UNKNOWN as long, INTERACTIVEVOICE as long, AUTOMATEDVOICE as long
+global DATAMODEM as long, G3FAX as long, TDD as long, G4FAX as long
+global DIGITALDATA as long, TELETEX as long, VIDEOTEX as long
+global TELEX as long, MIXED as long, ADSI as long, VOICEVIEW as long
+
+            sdwMediaModes(1)="UNKNOWN"
+            UNKNOWN=1
+            sdwMediaModes(2)="INTERACTIVEVOICE"
+            INTERACTIVEVOICE=2
+            sdwMediaModes(3)="AUTOMATEDVOICE"
+            AUTOMATEDVOICE=3
+            sdwMediaModes(4)="DATAMODEM"
+            DATAMODEM=4
+            sdwMediaModes(5)="G3FAX"
+            G3FAX=5
+            sdwMediaModes(6)="TDD"
+            TDD=6
+            sdwMediaModes(7)="G4FAX"
+            G4FAX=7
+            sdwMediaModes(8)="DIGITALDATA"
+            DIGITALDATA=8
+            sdwMediaModes(9)="TELETEX"
+            TELETEX=9
+            sdwMediaModes(10)="VIDEOTEX"
+            VIDEOTEX=10
+            sdwMediaModes(11)="TELEX"
+            TELEX=11
+            sdwMediaModes(12)="MIXED"
+            MIXED=12
+            sdwMediaModes(13)="ADSI"
+            ADSI=13
+            sdwMediaModes(14)="VOICEVIEW"
+            VOICEVIEW=14
+
+dim StartTime as long       'for benchmarker
+dim EndTime as long
+
+'$IFDEF MSTEST32
+    declare function GenTimeOut(OutCount as string) 'generate/generic file-i/o
+    declare function PerfBox(OutCount as string)
+    declare function GenOut(sFuncString as string) 'generate/generic file-i/o
+    declare function GenOutFunc(sFuncString as string) 'generate file-i/o of current declare function
+    declare function GetFunc (sFuncString as string)
+    declare function IsRunaway(sFuncString as string) as string
+    declare function IsComment(sFuncString as string) as string
+    declare function SetCheckboxControl(sCheckbox as string, lState as long) as long
+    declare function HitOK() 'hits the OK button
+    declare function CallAPI(sFuncString as string, lState as long)
+    declare function SelectParam(sFuncString as string)
+    declare function SetParamValue(sFuncString as string)
+    'declare function SetParamValue(sFuncString as string,ParamValue as string)
+    declare function SelectBitFlag(sFuncString as string)
+    declare function EndMsg()
+    declare function CaptureEdit()
+    declare function MiddleSelect() 'not yet:  sFuncString as string      'selects last item in .Listbox0
+    declare function lineGetProviderList()
+    declare function lineGetTranslateCaps()
+    declare function Box(sFuncString as string)
+    'declare function SelectLineApp(lLineApp as long) 'machine
+    declare function StartApps()
+    declare function StopApps()
+    declare function GenChaos() 'all globals
+    declare function lineInitialize(lLineApp as long) 'all globals; stipulate lLineApp for ease of array; for ex: lineInitialize(lLineApp); lLineApp being long
+    declare function LineShutdown(lLineApp as long) 'all globals
+    declare function SelectLineApp(lLineApp as long) 'all globals
+    declare function SelectLine(lLine as long) 'all globals; prep for lineMakeCall
+    declare function lineOpen(lLineApp as long, lLine as long, sPrivileges as string, sMediaModes as string)
+    declare function lineMakeCall(lLine as long, lCall as long, slpszDestAddress as string)
+    declare function lineDrop(lCall as long)
+    declare function lineDeallocateCall(lCall as long)
+    declare function lineAddToConference(lLine as long)
+    declare function lineAnswer()
+    declare function Abort()
+    declare function CheckErr(TAPIErr as string)
+    declare function lineClose(lLine)
+    declare function lineGetNewCalls(lLine as long)
+    declare function lineGetAddressStatus(lLine as long)
+    declare function lineGetCallInfo(lCall as long)
+    declare function lineGetCallStatus(lCall as long)
+    declare function lineSetAppSpecific(lCall as long)
+    declare function lineDial(lCall as long, slpszDestAddress as string)
+    declare function lineGetAddressCaps(lLineApp as long)
+    declare function lineGetAddressID(lLine as long)
+    declare function lineGetDevConfig()
+    declare function lineGetDevCaps(lLineApp as long)
+    declare function lineGetID(lLine as long)		'consider parameter Bit flags here
+    declare function lineGetLineDevStatus(lLine as long)
+    declare function lineGetNumRings(lLine as long)
+    declare function lineGetStatusMessages(lLine as long)
+    declare function lineHold(lCall as long)
+    declare function lineSetNumRings(lLine as long, sdwNumRings as string)
+    declare function lineSetStatusMessages(lLine as long)
+    declare sub      play(text as string)
+'$ENDIF
+'/////////////////////////////////
+'///////  END HEADER /////////////
+'/////////////////////////////////
+
+'prototypes
+'lineInitialze()
+'lineShutdown(hLineApp)
+'lineOpen(hLineApp, dwDeviceID, lphLine, APIVersion, dwExtVersion, dwCallbackInstance, dwPrivileges, dwMediaModes, lpCallParams)
+'
+'BENCHMARKER      'hack hack hack
+'delete benchmark file
+    if exists(sOutLogName) then
+        kill sOutLogName
+    end if
+
+'timer is double precision
+    if exists(sOutBenchName) then
+        kill sOutBenchName
+    end if
+
+    StartTime=timer
+
+    for OutCount=1 to 100
+'        PerfBox(str$(OutCount))
+        GenTimeOut(str$(OutCount))
+    next OutCount
+
+    EndTime=timer
+    Benchmark=Endtime-StartTime
+
+    GenTimeOut("Benchmark: " + str$(Benchmark))
+
+    StatusBox Close
+
+    if Benchmark > 3 then
+        msgbox "YOUR SYSTEM REALLY SUCKS." + chr$(010) + chr$(010) + "Please use a faster system.", MB_OK OR MB_ICONEXCLAMATION, "Slow Bench Warning"
+    end if
+
+    function GenTimeOut(OutCount as string) 'generate/generic file-i/o
+        Open sOutBenchName for append as #1
+            print #1, OutCount + chr$(009)     ' + time
+        Close #1
+    end function
+
+    function PerfBox(OutCount as string)
+        StatusBox "Profiling System Performance..." + chr$(010) + OutCount,0,0,300,100,TRUE,TRUE,"Courier",8,400
+    end function
+
+'// set timout, now that we have benched
+MY_TIMEOUT = 2 + (2 * Benchmark)
+'//END BENCHMARKER
+
+viewport on
+viewport clear
+
+'#if
+'$IFDEF MSTEST32
+        'SET UP TRAP ROUTINE
+        TRAP KeyTrap FROM "T3Trap32.DLL" ALIAS "KeyTrap"  'or T3Trap16.DLL
+             Beep
+             STATUSBOX "HOT KEY PRESSED, ABORTING SCRIPT " + Time$
+             SLEEP 4
+             END    'ABORT SCRIPT
+        END TRAP
+
+        'MAIN SCRIPT
+        SetHotKey ASC("C"),  1	'TRAP Ctrl+c
+        Beep
+        STATUSBOX "Press CTRL+C to see this script ABORT"
+        Sleep  5'SLEEP FOREVER
+        STATUSBOX "This won't display, unless you BREAK and single step"
+
+'$ELSE
+        on KeyPress (27,FSHIFT) call KeyPressHandler
+        sub KeyPressHandler (notification_data AS VARIANT)
+            statusbox close
+            'idyes:6 & idno:7
+            msgbox "Stop tests?", MB_YESNO OR MB_ICONQUESTION OR MB_DEFBUTTON2, "Interruption"
+            if idyes then
+                statusbox close
+                EndMsg()
+                End
+            end if
+        end sub
+
+'$ENDIF
+
+
+' // Run things
+
+StartApps
+
+'do these after apps are running, duh
+hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT)
+GenOut("Getting Some")
+
+hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+'maximize window so button clicks work
+'WMaxWnd (hwndTapiControl.TapiHandle)
+
+GenOut("Logfile= " + chr$(009) + curdir$+sOutLogName)
+if Tracelevel > 2 then
+    GenOut("TAPI Browser handle= " + hex$(hwndTapiControl.TapiHandle))
+    GenOut("GetProcessHeap(): " + hex$(GetProcessHeap()))
+    GenOut("GetCurrentProcess(): " + hex$(GetCurrentProcess()))
+    GenOut("GetCurrentProcessID(): " + hex$(GetCurrentProcessID()))
+    GenOut("GetThread(): " + chr$(009) + hex$(GetCurrentThread()))
+    GenOut("GetCurrentThreadID(): " + hex$(GetCurrentThreadID()))
+end if
+GenOut(chr$(010)+chr$(010)+chr$(010))
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+
+'ensure edit box is clean
+'$IFDEF MSTEST32
+    WButtonClick _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT 'do not uncheck this
+'$ELSE
+    WButtonClick( _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT ) 'do not uncheck this
+'$ENDIF
+
+'********************
+'START YOUR ENGINES
+
+'lineGetProviderList()
+WSetActWnd (hwndTapiControl.TapiHandle)   'scatter a few of these since ESP steals focus
+'End Scenario
+
+'********************
+'********************
+
+FUNKY:
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineMakeCall (stuff)"
+'$ENDIF
+Box("lineMakeCall (verify busy)")
+GenOut("Scenario:" + chr$(009) + "lineMakeCall (verify busy)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineMakeCall lLine, lCall, BUSYLINE        'doing this stranglely for now
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+'lineClose(lLine)
+'lineShutdown(lLineApp)
+
+Box("lineMakeCall, (status)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (status)")
+
+'line should be open from earlier routine
+'lineInitialize(lLineApp)
+'lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))  'doing this stranglely for now
+lineMakeCall lLine, lCall, ANSWERLINE      'doing this stranglely for now
+
+    lineGetNewCalls(lLine)
+    lineGetAddressStatus(lLine)
+    lineGetCallInfo(lCall)
+    lineGetCallStatus(lCall)
+    lineSetAppSpecific(lCall)
+
+lineDrop(lCall)
+    lineGetCallInfo(lCall)
+    lineGetCallStatus(lCall)
+
+lineDeallocateCall(lCall)
+
+Box("lineMakeCall, (lineGetAppSpecific)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (lineGetAppSpecific)")
+
+lineMakeCall lLine, lCall, ANSWERLINE
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+
+Box("lineMakeCall, (Null lpszDestAddress)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (Null lpszDestAddress)")
+
+lineMakeCall lLine, lCall, NOLINE
+lineDial lCall, ANSWERLINE
+
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+lineClose(lLine)
+lineShutdown(lLineApp)
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetAddressCaps (default)"
+'$ENDIF
+Box("lineGetAddressCaps (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressCaps (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetAddressCaps(lLineApp)
+lineShutdown(lLineApp)
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetAddressID (default)"
+'$ENDIF
+Box("lineGetAddressID (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressID (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetAddressID(lLine)
+lineClose(lLine)
+lineShutdown(lLineApp)
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetAddressStatus (default)"
+'$ENDIF
+Box("lineGetAddressStatus (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressStatus (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetAddressStatus(lLine)
+lineClose(lLine)
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetDevConfig (default)"
+'$ENDIF
+Box("lineGetDevConfig (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetDevConfig (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetDevConfig 'no arguments, yet
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetDevCaps (default)"
+'$ENDIF
+Box("lineGetDevCaps (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetDevCaps (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetDevCaps(lLineApp)
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetID (default)"
+'$ENDIF
+Box("lineGetID (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetID (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetID(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetLineDevStatus (default)"
+'$ENDIF
+Box("lineGetLineDevStatus (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetLineDevStatus (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetLineDevStatus(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetNewCalls (default)"
+'$ENDIF
+Box("lineGetNewCalls (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetNewCalls (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetNewCalls(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetNumRings (default)"
+'$ENDIF
+Box("lineGetNumRings (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetNumRings (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetNumRings(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetStatusMessages (default)"
+'$ENDIF
+Box("lineGetStatusMessages (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetStatusMessages (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetStatusMessages(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineHold (default)"
+'$ENDIF
+Box("lineHold (default)")
+GenOut("Scenario:" + chr$(009) + "lineHold (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineMakeCall lLine, lCall, ANSWERLINE      'doing this stranglely for now
+lineHold(lCall)
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+lineClose(lLine)
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineSetNumRings (default)"
+'$ENDIF
+Box("lineSetNumRings (default)")
+GenOut("Scenario:" + chr$(009) + "lineSetNumRings (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+sdwNumRings="9"
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineSetNumRings lLine, sdwNumRings
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+ENDME:
+
+
+'END 'END 'END
+
+'********************
+'********************
+'lineInitialize with one good pass, then individual null params
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineInitialize (many)"
+'$ENDIF
+Box("lineInitialize (many)")
+WSetActWnd (hwndTapiControl.TapiHandle) 'freshen
+
+for lLineApp= 0 to 4
+    CallAPI "lineInitialize",0
+next lLineApp
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'Scenario "lineGetTranslateCaps"
+'Box("lineGetTranslate")
+' lineGetTranslateCaps()
+'End Scenario
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineShutdown (many)"
+'$ENDIF
+Box("lineShutdown (many)")
+
+for lLineApp= 0 to 4  'note # of lineInitializes, I was too lazy to set a constant for limit
+    MiddleSelect
+    CallAPI "lineShutdown",0
+next lLineApp
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (valid)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (valid)")
+'*** disable params, lineInitialize, lineNegotiateAPIVersion with valids, lineShutdown
+'disable params child
+
+CallAPI "lineInitialize",0
+
+MiddleSelect
+CallAPI "lineNegotiateAPIVersion",0
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (invallow_valhi)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (invallow_valhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invallow and valhi
+'*** disable params, lineShutdown
+'no params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Valid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (vallow_invalhi)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (vallow_invalhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with vallow and invalhi
+'*** disable params, lineShutdown
+'need params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Valid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (invallow_invalhi)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (invallow_invalhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invallow and invalhi
+'*** disable params, lineShutdown
+'no params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Invalid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion_invaldev"
+'$ENDIF
+Box("lineNegotiateAPIVersion (invaldev)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invalid device
+'*** disable params, lineShutdown
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwDeviceID")
+SetParamValue("Invalid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateExtVersion"
+'$ENDIF
+Box("lineNegotiateExtVersion")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateExtVersion
+'*** disable params, lineShutdown
+'no params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateExtVersion",0
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (none)"
+'$ENDIF
+Box("linOpen_privileges (none)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("None")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (monitor)"
+'$ENDIF
+Box("linOpen_privileges (monitor)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Monitor")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (owner)"
+'$ENDIF
+Box("linOpen_privileges (owner)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (multi)"
+'$ENDIF
+Box("linOpen_privileges (multi)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("None")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Monitor")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** BEGIN dwPrivileges, dwMediaModes strobing
+'*** WATCH THIS: LOOP
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with defaults
+'*** disable params, lineShutdown
+
+'five times
+for lLineApp = 0 to 4
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineOpen_MediaModes, sdwPrivileges, dwMediaModes.DATAMODEM (TB default)"
+'$ENDIF
+Box("lineOpen_MediaModes, dwPrivileges.NONE, dwMediaModes.DATAMODEM (TB default)")
+
+CallAPI "lineInitialize",0
+CallAPI "lineOpen",0 'defaults are dwPrivileges.NONE, dwMediaModes.DATAMODEM
+CallAPI "lineShutdown",0
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+next lLineApp
+
+'********************
+'********************
+'***  matrix privileges and MediaModes (STRAIGHT THROUGH)
+'***  dwMediaModes strobing
+'***  [attemts most combos]
+
+for ldwPrivilegesBitFlag = 1 to 3
+'dwPrivileges string in the form of sdwPrivileges
+
+    for ldwMediaModesBitFlag = 1 to 14
+
+    'one day, change this to a cleaner array
+    '********************
+'$IFDEF MSTEST32
+'$ELSE
+    Scenario "lineOpen_MediaModes, (STRAIGHT THROUGH) " + sdwPrivileges(ldwPrivilegesBitFlag) + ", " + sdwMediaModes(ldwMediaModesBitFlag)
+'$ENDIF
+    Box("lineOpen_MediaModes, (STRAIGHT THROUGH) " + sdwPrivileges(ldwPrivilegesBitFlag) + ", " + sdwMediaModes(ldwMediaModesBitFlag))
+
+    CallAPI "lineInitialize",0
+
+    CallAPI "lineOpen",1
+    SelectParam("dwPrivileges")
+    SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+    SelectBitFlag(sdwPrivileges(ldwPrivilegesBitFlag)) 'set Bit flag
+    SelectParam("dwMediaModes")
+    SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+    SelectBitFlag(sdwMediaModes(ldwMediaModesBitFlag))
+    HitOK
+
+    MiddleSelect 'just select anything in the list box
+    CallAPI "lineShutdown",0
+
+    '$IFDEF MSTEST32
+    '$ELSE
+    End Scenario
+    '$ENDIF
+
+    next ldwMediaModesBitFlag
+next ldwPrivilegesBitFlag
+
+'********************
+'********************
+'*** END dwMediaModes (STRAIGHT THROUGH)
+'********************
+'********************
+'********************
+'********************
+
+goto SKIPCHAOS
+
+'********************
+'********************
+'***  matrix privileges and MediaModes (CHAOTIC)
+'***  dwMediaModes strobing
+'***  [try simultaneous operations]
+CHAOS:
+for GenCount=1 to 200
+    'not used: randomize TIMER   'for "bound-ed" chaos
+    '********************
+'$IFDEF MSTEST32
+'$ELSE
+    Scenario ("lineOpen_MediaModes, (CHAOTIC)")
+'$ENDIF
+    Box("lineOpen_MediaModes, (CHAOTIC)")
+    'do 5
+    for lLineApp= 0 to 4
+    LineInitialize(lLineApp) 'returns hLineApp(lLineApp)
+    next lLineApp
+
+    'begin Chaos translation here so I may retain my pretty matrix blocks & to increase hits
+
+    for lLineApp=0 to 4
+    GenChaos                      'all globals
+    SelectLineApp(lLineApp)
+    CallAPI "lineOpen",1
+    SelectParam("dwPrivileges")
+    SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+    SelectBitFlag(sdwPrivileges(ldwPrivilegesBitFlagChaos)) 'set Bit flag
+    SelectParam("dwMediaModes")
+    SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+    SelectBitFlag(sdwMediaModes(ldwMediaModesBitFlagChaos))
+    HitOK
+    next lLineApp
+
+    'cleanup, do 5
+    'WILL NOT WORK WITHOUT HANDLES
+    for lLineApp= 0 to 4
+    LineShutdown(lLineApp)
+    next lLineApp
+
+    '$IFDEF MSTEST32
+    '$ELSE
+    End Scenario
+    '$ENDIF
+next GenCount
+
+'********************
+'********************
+'*** END dwMediaModes (CHAOTIC)
+'********************
+'********************
+'********************
+'********************
+
+SKIPCHAOS:
+
+
+'********************
+'********************
+'********************
+'********************
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_MediaModes (privileges_multi)"
+'$ENDIF
+Box("linOpen_MediaModes (privileges_multi)")
+
+CallAPI "lineInitialize",0
+
+
+'as owner
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("DATAMODEM")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("TELETEX")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("TELEX")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("INTERACTIVEVOICE")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+'///////////////
+
+' *************************
+' ***** END TEST CASE *****
+' *************************
+
+
+'///////
+'///////
+'///////
+
+
+'*****  END   END   END   END   END   END  *****
+
+StatusBox Close
+EndMsg
+End
+
+'********************
+'********************
+
+JUNKY:
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "Call Unimplemented APIs"
+'$ENDIF
+Box("Call Unimplemented APIs")
+GenOut("Scenario:" + chr$(009) + "Call Unimplemented APIs")
+
+'CallAPI "lineAddToConference",0               'requires two calls on one line
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineMakeCall lLine, lCall, BUSYLINE        'doing this stranglely for now
+
+
+CallAPI "lineBlindTransfer",0                  'requires call
+CallAPI "lineCompleteCall",0                   'requires call
+'CallAPI "lineCompleteTransfer",0              'requires two calls on one line
+CallAPI "lineDevSpecific",0                    'requires line
+CallAPI "lineDevSpecificFeature",0             'requires line
+CallAPI "lineForward",0                        'requires line
+CallAPI "lineGatherDigits",0                   'requires call
+CallAPI "lineGenerateDigits",0                 'requires call
+CallAPI "lineGenerateTone",0                   'requires call
+
+
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+
+
+CallAPI "lineGetConfRelatedCalls",0
+CallAPI "lineGetRequest",0
+CallAPI "lineMonitorDigits",0
+CallAPI "lineMonitorMedia",0
+CallAPI "lineMonitorTones",0
+CallAPI "lineNegotiateExtVersion",0
+CallAPI "linePark",0
+CallAPI "linePickup",0
+CallAPI "linePrepareAddToConference",0
+CallAPI "lineRedirect",0
+CallAPI "lineRegisterRequestRecipient",0
+CallAPI "lineRemoveFromConference",0
+CallAPI "lineSecureCall",0
+CallAPI "lineSendUserUserInfo",0
+CallAPI "lineSetAppSpecific",0
+CallAPI "lineSetTerminal",0
+CallAPI "lineSetTollList",0
+CallAPI "lineSetupConference",0
+CallAPI "lineSetupTransfer",0
+CallAPI "lineSwapHold",0
+CallAPI "lineUncompleteCall",0
+CallAPI "lineUnhold",0
+CallAPI "lineUnpark",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+
+'********************
+'********************
+
+'Scenario "lineClose"
+'
+'do not need params
+'SetCheckboxControl(_id(hwndTapiControl.ParamsCheckbox),0
+'MiddleSelect
+'SelectParam("lineClose")
+'play "{ENTER}"
+'
+'CaptureEdit
+'
+'End Scenario
+
+
+
+
+
+
+'
+'/**************************************************/
+'FUNCTIONS
+
+'Outputs, identical until global architecture change
+function GenOut(sFuncString as string) 'generate/generic file-i/o
+' // open logging file
+    box("Calling:  " + sFuncString)
+    Open sOutLogName for append as #1
+        print #1, sFuncString + chr$(009)     ' + time
+        print hwndViewport, sFuncString + chr$(009)     '+ time
+    Close #1
+end function
+
+function GenOutFunc(sFuncString as string) 'generate file-i/o of current function
+' // open logging file
+    box ("Calling:  " + sFuncString)
+    Open sOutLogName for append as #1
+        print #1, sFuncString + chr$(009) + time$
+        print hwndViewport, sFuncString + chr$(009) + time$
+    Close #1
+end function
+
+
+'for TBPoke only: GetFunc runs the state core, remember to trim tabs
+' this was from TBPoke, but it has been modified not to look for script file
+function GetFunc (sFuncString as string)
+        sFuncString=""
+        'count the entries
+        lCountFunc=lCountFunc+1
+        sFuncString=trim$(sFuncString,009)      'trim tabs
+        sFuncString=trim$(sFuncString," ")      'whatever MST calls a space
+        sFuncString=trim$(sFuncString,255)      'trim truespace
+        if sFuncString=chr$(000) then sFuncString="COMMENT" 'ASCII null
+end function
+
+'Check for runaway file i/o read; consider it "IsCarriageReturn"
+function IsRunaway(sFuncString as string) as string
+    if sFuncString="" then
+        lCountSpace=lCountSpace+1               'begin counting blank entries
+        if lCountSpace=MAX_BLANK then sFuncString="END"
+    else
+        lCountSpace=0
+    end if
+end function
+
+'Find comments
+function IsComment(sFuncString as string) as string
+    select case(ucase$(left$(sFuncString,1)))
+        case ";"
+            sFuncString="COMMENT"
+        case "#"
+            sFuncString="COMMENT"
+        case "'"
+            sFuncString="COMMENT"
+        case ""
+            sFuncString="COMMENT"
+            'IsRunaway(sFuncString)             'count blanks to prevent infinite loop
+            'GenOut(sFuncString, hwndViewport)
+    end select
+
+    'find other comments
+    select case(left$(sFuncString,2))
+        case "//"
+            sFuncString="COMMENT"
+    end select
+
+    'find more comments, I know it is not model code, shut up
+    select case(left$(sFuncString,4))
+        case "REM "                         'with space
+            sFuncString="COMMENT"
+    end select
+
+end function 'IsComment
+
+
+'toggle checkbox state, will leave focus on sCheckbox
+function SetCheckboxControl(sCheckbox as string, lState as long) as long
+    select case(lState)
+        case 0
+            If WCheckState(sCheckbox) = CHECKED then
+                WCheckUnCheck sCheckbox,MY_TIMEOUT
+                if Tracelevel>=3 then GenOut ("Unchecking checkbox "+sCheckbox)
+            else
+                if Tracelevel>=2 then GenOut ("Error: Attempt to WCheckUnCheck unchecked checkbox "+sCheckbox)
+            end if
+        case 1
+            If WCheckState(sCheckbox) = UNCHECKED then
+                WCheckCheck sCheckbox,MY_TIMEOUT
+                if Tracelevel>=3 then GenOut ("Checking checkbox "+sCheckbox)
+            else
+                if Tracelevel>=2 then GenOut ("Error: Attempt to WCheckCheck checked checkbox "+sCheckbox)
+            end if
+    end select
+end function
+
+function HitOK 'hits the OK button
+    WButtonClick "OK", MY_TIMEOUT
+    CaptureEdit
+
+end function
+
+function CallAPI(sFuncString as string, lState as long)
+    if lState > 1 then GenOut("Error:  lState is exceeds value of 1.")
+    GenOut("API:" + chr$(009) + sFuncString)
+    SetCheckboxControl _id(hwndTapiControl.ParamsCheckbox),lState
+    WListItemDblClk _id(hwndTapiControl.Listbox1), sFuncString, MY_TIMEOUT
+    if lState=0 then CaptureEdit  'so calling the API w/ default params gens output & HitOK gens output (see HitOK)
+end function
+
+function SelectParam(sFuncString as string)
+    GenOut("Parameter:" + chr$(009) + sFuncString)
+    WListFind "Parameters:", MY_TIMEOUT
+    WListItemDblClk "Parameters:", sFuncString, MY_TIMEOUT
+end function
+
+function SetParamValue(sFuncString as string)
+        GenOut("Parameter Value:" + chr$(009) + sFuncString)
+        WEditSetFocus "Value:", MY_TIMEOUT
+        select case(ucase$(sFuncString))
+            case ucase$("Null")
+                play "00000000"
+            case ucase$("Valid")  'WATCH THIS:  dankn often displays English here
+                'leave it alone, default is VALID or valid value
+                'play "{DOWN}"
+                'play "{DOWN}"
+            case ucase$("Invalid")
+                play "ffffffff"
+            case else
+                GenOut("Error:  Bad SetParamValue parameter:  " + sFuncstring)
+        end select
+end function
+
+'global ParamValue as string 'put this at front
+'function SetParamValue(sFuncString as string,ParamValue as string)
+'   SelectParam(sFuncString as string)
+
+function SelectBitFlag(sFuncString as string)
+    GenOut("Select Bit Flag: " + sFuncString)
+    'lineOpen has defaults: dwPrivileges.NONE, dwMediaModes.DATAMODEM
+    WListFind "Bit flags:", MY_TIMEOUT
+    WListItemDblClk "Bit flags:", sFuncString, MY_TIMEOUT
+    'BitFlag[] sFuncString  ;;;; soon add cleanup structure
+end function
+
+function EndMsg
+    sEndingMessage="TB BVT ended."
+    sEndTitle="Completed"
+    msgbox sEndingMessage, MB_OK, sEndTitle
+end function
+
+function CaptureEdit
+        'play "{ENTER}" 'assuming child window is in focus and OK button is selected
+        'GenOut("********************  TAPI Report  ********************")
+        'GenOut(ListText(_id(hwndTapiControl.Listbox0, MY_TIMEOUT))
+        sleep 0.1                               'take an i/o break
+        GenOut("TAPI Browser reports: ")
+        GenOut(EditText(_id(hwndTapiControl.Editbox) + chr$(010), MY_TIMEOUT))
+        'GenOut("********************  END REPORT  *********************" + chr$(010 + chr$(010)
+        WButtonClick _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT
+end function
+
+'>>++++
+function MiddleSelect 'not yet:  sFuncString as string      'selects last item in .Listbox0
+        WListSetFocus _id(hwndTapiControl.Listbox0), MY_TIMEOUT
+        'not yet:  WListItemDblClk(_id(hwndTapiControl.Listbox0, sFuncString, MY_TIMEOUT)
+        play "{PGDN}"
+end function
+
+function lineGetProviderList
+    CallAPI "lineGetProviderList",0
+end function
+
+function lineGetTranslateCaps
+    CallAPI "lineGetTranslateCaps",0
+    Box("Dumping buffer")
+    sleep 1
+    Box("Dumping buffer")
+    sleep 1
+end function
+
+function Box(sFuncString as string)
+    'disabled, bug in statusbox is stealing focus
+    'StatusBox sFuncString + chr$(009),ScreenX-300,ScreenY-75,300,75,FALSE,FALSE,"Courier",8,400
+end function
+
+'function SelectLineApp(lLineApp as long) 'machine
+'   'later revise to allow real-time monitor of handles
+'   'select valid lineApp lLineApp, searching top to bottom, exit out having made selection
+'   'It does look bad.  If dankn's conventions stray too far, this will fail
+'   MiddleSelect
+'   if lLineApp > WListCount(_id(hwndTapiControl.Listbox0, MY_TIMEOUT) then
+'       GenOut("Error: BAD ONE, lLineApp of " + str$(lLineApp) + " exceeding WListCount of " + str$(WListCount(_id(hwndTapiControl.Listbox0, MY_TIMEOUT)))
+'       beep
+'       beep
+'       beep
+'       goto SKIPSelectLineApp
+'   end if
+'   play "{PGUP}"
+'   lCountLineApp=WListCount(_id(hwndTapiControl.Listbox0, MY_TIMEOUT)
+'   for GenCount = 1 to lCountLineApp
+'       'do not down-arrow yet since first item is selected
+'       sLineApp=ListItemText(_id(hwndTapiControl.Listbox0, WListIndex(_id(hwndTapiControl.Listbox0,MY_TIMEOUT),MY_TIMEOUT)
+'       select case (left$(ucase$(sLineApp),9))
+'           case ucase$("LineApp=x")    'first half matches (this may happen with invalids too, so look on
+'               select case (val(right$(sLineApp,8)))
+'                   case 0              'is an invalid, so index
+'                       play "{DOWN}"
+'                   case else           'hex value is non-zero, let us use it
+'                       select case (WListIndex(_id(hwndTapiControl.Listbox0,MY_TIMEOUT))
+'                           case (lLineApp) 'is this the index requested?
+'                               GenCount=lCountLineApp  'return 'get out, leaving it focused
+'                           case else       'is not lLineApp, so index
+'                           play "{DOWN}"
+'                       end select
+'               end select
+'           case else                       'is not "LineApp=x", so index
+'               play "{DOWN}"
+'       end select 'THIS MESS DONE SINCE this shitty beta has horrible if-then nesting errors (not me!)
+'   next GenCount
+'   SKIPSelectLineApp:  'skip if lLineApp is bogus value
+'end function
+
+function StartApps
+    run "MTVIEW.EXE", nowait, SW_NORMAL
+    hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT,5) 'find Visual Test Viewport
+    if hwndViewport = 0 then
+'$IFDEF MSTEST32
+        GenOut("MTVIEW.EXE application failed to start")
+'$ELSE
+        fail "MTVIEW.EXE application failed to start"
+'$ENDIF
+    end if
+
+    run "TB14.EXE" , nowait , SW_MAXIMIZE                       'NOWAIT SW_NORMAL
+    sleep 2
+    hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT,5) 'find TAPI32 BROWSER
+    if hwndTapiControl.TapiHandle= 0 then
+'$IFDEF MSTEST32
+        GenOut("TB14.EXE TAPI Brower failed to start")
+'$ELSE
+        fail "TB14.EXE TAPI Brower failed to start"
+'$ENDIF
+    end if
+end function
+
+'not used:
+function StopApps
+    hwndViewport = WFndWnd("Visual Test Viewport", FW_DEFAULT or FW_FOCUS)
+    if hwndViewport <> 0 then
+        Play "%{F4}" 'alt f4
+    end if
+
+    hwndTapiControl.TapiHandle = WFndWnd("TAPI32 Browser", FW_DEFAULT or FW_FOCUS)
+    if hwndTapiControl.TapiHandle <> 0 then
+        Play "%{F4}" 'alt f4
+    end if
+end function
+
+function GenChaos 'all globals
+    ldwPrivilegesBitFlagChaos=(int(rnd*3)+1)
+    ldwMediaModesBitFlagChaos=(int(rnd*14)+1)
+    Box("lineOpen_MediaModes, (CHAOS) LineApp "  + str$(lLineApp) + ", " + sdwPrivileges(ldwPrivilegesBitFlagChaos) + ", " + sdwMediaModes(ldwMediaModesBitFlagChaos))
+    GenOut("lineOpen_MediaModes, (CHAOS)" + str$(ldwPrivilegesBitFlagChaos) +","+ str$(ldwMediaModesBitFlagChaos) + " LineApp " + str$(lLineApp) + ", " + sdwPrivileges(ldwPrivilegesBitFlagChaos) + ", " + sdwMediaModes(ldwMediaModesBitFlagChaos))
+end function
+
+function lineInitialize(lLineApp as long) 'all globals; stipulate lLineApp for ease of array; for ex: lineInitialize(lLineApp); lLineApp being long
+    CallAPI "lineInitialize",0 'create a LineApp
+
+    'lineApp is now open...
+    CallAPI "lineOpen",1       'cheat, use TB to provide clean handle
+    SelectParam("hLineApp")     'select the hLineApp of Params:
+    WEditSetFocus "Value:", MY_TIMEOUT 'set focus, no real reason
+    hLineApp(lLineApp)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+    if Tracelevel >= 1 then GenOut("New hLineApp=" + chr$(009) + hLineApp(lLineApp))
+    Abort
+end function
+
+function LineShutdown(lLineApp as long) 'all globals
+    CallAPI "lineShutdown",1
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT 'ready to enter handle
+    play hLineApp(lLineApp)
+    HitOK
+end function
+
+function SelectLineApp(lLineApp as long) 'all globals
+    MiddleSelect
+    WListItemClk _id(hwndTapiControl.Listbox0), "LineApp=x" + (hLineApp(lLineApp)), MY_TIMEOUT
+end function
+
+'not implemented
+function SelectLine(lLine as long) 'all globals; prep for lineMakeCall
+    MiddleSelect
+    ' (_id(hwndTapiControl.Listbox0, "Line=x" + (hLineApp(lLineApp)), MY_TIMEOUT)
+end function
+
+function lineOpen(lLineApp as long, lLine as long, sPrivileges as string, sMediaModes as string)
+    CallAPI "lineOpen",1       'child window is open and focused
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT
+    play hLineApp(lLineApp)     'handle of LineApp
+
+    SelectParam("dwPrivileges")
+    GenOut("Clearing default on following line:")
+    SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+    SelectBitFlag(sPrivileges) 'set Bit flag
+    SelectParam("dwMediaModes")
+    GenOut("Clearing default on following line:")
+    SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+    SelectBitFlag(sMediaModes)
+
+    HitOK
+
+    CallAPI "lineMakeCall",1  'cheat, use to get hLine value
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT         'set focus, no real reason
+    hLine(lLine)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+    if Tracelevel >= 1 then GenOut("New hLine=" + chr$(009) + hLine(lLine))
+    Abort                                 'abort child
+end function
+
+function lineMakeCall(lLine as long, lCall as long, slpszDestAddress as string)
+    CallAPI "lineMakeCall",1               'child window is open and focused
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+
+    SelectParam("lpszDestAddress")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play slpszDestAddress
+    WButtonClick  "OK", MY_TIMEOUT
+    sleep 5
+
+    'hide dialog
+    if slpszDestAddress <> " " then
+        WButtonFind "&Talk", 15      'use a way to wait for dialog
+        WSetActWnd (hwndTapiControl.TapiHandle) 'refocus TB
+        sleep 1
+    end if
+
+    'if slpszDestAddress <> " " then
+    '   WSetWndPos ( WFndWnd("Call Status", FW_DEFAULT), ScreenX, ScreenY) 'find Call Status window
+    '   sleep 15
+    'end if
+
+    'if slpszDestAddress <> " " then            'being caution of Talk/Hangup dialog
+    '   sleep 12
+    '   WButtonClick( "&Talk", MY_TIMEOUT + 10
+    'end if
+    '
+
+    CallAPI "lineDrop",1                   'cheat, use to get hCall value
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT
+    hCall(lCall)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+    if Tracelevel >= 1 then GenOut("New hCall=" + chr$(009) + hCall(lCall))
+    Abort
+end function
+
+function lineDrop(lCall as long)
+    CallAPI "lineDrop",1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineDeallocateCall(lCall as long)
+    CallAPI "lineDeallocateCall",1
+    Selectparam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify handle
+    HitOK
+end function
+
+'not implemented; in-work
+function lineAddToConference(lLine as long)
+    CallAPI "lineAddToConference",1
+    Selectparam("hLine")
+    'blah
+end function
+
+function lineAnswer
+end function
+
+function Abort
+    play "{ESC}" 'abort child
+    GenOut("Aborted child window:  OK, probably getting handle here." + chr$(010))
+end function
+
+'not implemented
+function CheckErr(TAPIErr as string)
+'lineAddProvider returned LINEERR_INVALPOINTER
+end function
+
+function lineClose(lLine)
+    CallAPI "lineClose",1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+    HitOK
+end function
+
+function lineGetNewCalls(lLine as long)
+    CallAPI "lineGetNewCalls",1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+    HitOK
+end function
+
+function lineGetAddressStatus(lLine as long)
+    CallAPI "lineGetAddressStatus",1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+    HitOK
+end function
+
+function lineGetCallInfo(lCall as long)
+    CallAPI "lineGetCallInfo", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineGetCallStatus(lCall as long)
+    CallAPI "lineGetCallStatus", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineSetAppSpecific(lCall as long)
+    CallAPI "lineSetAppSpecific", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineDial(lCall as long, slpszDestAddress as string)
+    CallAPI "lineDial", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify the handle
+
+    SelectParam("lpszDestAddress")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play slpszDestAddress
+
+    WButtonClick  "OK", MY_TIMEOUT
+    sleep 5
+
+    'hide dialog
+    WButtonFind "&Talk", 15      'use a way to wait for &Talk dialog
+    WSetActWnd (hwndTapiControl.TapiHandle) 'refocus TB
+    sleep 1
+
+    'WButtonClick( "&Talk", MY_TIMEOUT + 10
+end function
+
+function lineGetAddressCaps(lLineApp as long)
+    CallAPI "lineGetAddressCaps", 1
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLineApp(lLineApp)
+    HitOK
+end function
+
+function lineGetAddressID(lLine as long)
+    CallAPI "lineGetAddressID", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetDevConfig
+    'ensure a LineApp is open when calling lineGetDevConfig
+    CallAPI "lineGetDevConfig", 0
+end function
+
+function lineGetDevCaps(lLineApp as long)
+    Box("Dumping buffer")
+    CallAPI "lineGetDevCaps", 1
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLineApp(lLineApp)
+    HitOK
+end function
+
+function lineGetID(lLine as long)       'consider parameter Bit flags here
+    CallAPI "lineGetID", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetLineDevStatus(lLine as long)
+    CallAPI "lineGetLineDevStatus", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetNumRings(lLine as long)
+    CallAPI "lineGetNumRings", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetStatusMessages(lLine as long)
+    CallAPI "lineGetStatusMessages", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineHold(lCall as long)
+    CallAPI "lineHold", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)
+    HitOK
+end function
+
+function lineSetNumRings(lLine as long, sdwNumRings as string)
+    CallAPI "lineSetNumRings", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+
+    SelectParam("dwNumRings")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play sdwNumRings
+
+    HitOK
+end function
+
+function lineSetStatusMessages(lLine as long)
+    CallAPI "lineSetStatusMessages", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+sub play(text as string)
+    dokeys text
+end sub
+
+
+
+
+'truly the end
diff --git a/private/tapi/qa/bvt/current/tbglobal.h b/private/tapi/qa/bvt/current/tbglobal.h
new file mode 100644
index 000000000..f5bf2dd81
--- /dev/null
+++ b/private/tapi/qa/bvt/current/tbglobal.h
@@ -0,0 +1,187 @@
+'TAPI BVT HEADER
+
+' WARNING:  This is a piece of junk.  No warrantee implied.
+'spaghetti, not authored by me, just scribbled by me, (ajohnh, some time in '95)
+'$INCLUDE 'd:\msdev\include\RECORDER.INC'
+'$include 'd:\msdev\include\winapi.inc'
+'$INCLUDE 'D:\MSDEV\INCLUDE\TBPOKE.H'
+
+'//////////////////////////////////////////
+'////// borrowed from my in-work TBPoke:
+'logging
+global sOutLogName			as string
+global sScriptName			as string
+global sComment				as string
+
+global hwndViewport			as long
+global lCountSpace			as long
+global lCountFunc			as long
+global lCountTab			as long
+global MAX_BLANK			as long
+global sFuncString			as string
+
+'end reporting
+global sEndingMessage		as string
+global sEndTitle			as string
+
+'checkbox function
+global sCheckbox			as string
+global lState				as long
+
+'system metrics
+global ScreenX				as long
+global ScreenY				as long
+
+'time value
+global MY_TIMEOUT			as long
+global PACER				as long
+
+global PARAMS				as long
+global NOPARAMS				as long
+
+global hwndTapiControl		as hwndTAPI_CONTROL
+global ScenarioLog			as LOGINITSTRUCT
+
+global sdwPrivileges		as array of string
+global sPrivileges			as string
+global sdwMediaModes		as array of string
+global sMediaModes			as string
+'
+global hLineApp				as array of string
+global hLine				as array of string
+global hCall				as array of string
+
+redim sdwPrivileges(1 to 3)		as string
+redim sdwMediaModes(1 to 14)	as string
+
+redim hLineApp(1 to 5)			as string   'limit 5 for now
+redim hLine(1 to 5)				as string
+redim hCall(1 to 5)				as string
+'redim hCall(5)				as string
+
+global hLineAppIndex			as pointer to string
+'global hLineIndex				as pointer to string
+'VARPTR(hLineApp(0))        'WATCH IT
+'VARPTR(hLine(0))
+
+'counts
+global	ldwPrivilegesBitFlag		as long 
+global	ldwMediaModesBitFlag		as long
+global	ldwPrivilegesBitFlagChaos	as long
+global	ldwMediaModesBitFlagChaos	as long
+
+global	lLineApp					as long
+global	lLine						as long
+global	lCall						as long
+
+global	GenCount					as long
+global  lCountLineApp				as long		
+global  GenCount2					as long
+
+'coverage statistics
+'not yet implemented
+global	TapiStatistic				as TAPI_STATISTIC
+
+global  Tracelevel					as long 'debug output
+
+'duh
+hwndTapiControl.TapiHandle			= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+hwndTapiControl.ParamsCheckbox			=&h000003f9
+hwndTapiControl.LineAppPlusButton		=&h000003ee
+hwndTapiControl.LineAppMinusButton		=&h000003ef
+hwndTapiControl.LinePlusButton			=&h000003f0
+hwndTapiControl.LineMinusButton			=&h000003f1
+hwndTapiControl.CallPlusButton			=&h000003f2
+hwndTapiControl.CallMinusButton			=&h000003f3
+hwndTapiControl.PhoneAppPlusButton		=&h000003f4
+hwndTapiControl.PhoneAppMinusButton		=&h000003f5
+hwndTapiControl.PhoneOpenPlusButton		=&h000003f6
+hwndTapiControl.PhoneOpenMinusButton	=&h000003f7
+hwndTapiControl.ClearEditButton			=&h000003f8
+hwndTapiControl.BlankButton0			=&h000003fa
+hwndTapiControl.BlankButton1			=&h000003fb
+hwndTapiControl.BlankButton2			=&h000003fc
+hwndTapiControl.BlankButton3			=&h000003fd
+hwndTapiControl.BlankButton4			=&h000003fe
+hwndTapiControl.BlankButton5			=&h000003ff
+hwndTapiControl.Listbox0				=&h000003e8		'middle box
+hwndTapiControl.Listbox1				=&h000003e9		'left box
+hwndTapiControl.Editbox					=&h000003eb		'right box
+
+'// assign
+sOutLogName=curdir$+"\tapibvt.log"
+lCountSpace=0
+lCountFunc=0
+lCountTab=1
+MAX_BLANK=20				'static
+MY_TIMEOUT=2
+PACER = 1
+PARAMS=1
+NOPARAMS=0
+
+'debug; 0=no debug; 3 low, 2 med, 1 high --I know it is backward
+Tracelevel=0
+
+ScreenX=GetSystemMetrics(SM_CXSCREEN)
+ScreenY=GetSystemMetrics (SM_CYSCREEN)
+
+ScenarioLog.LogOutputType = LogTypeFile
+ScenarioLog.MinDetailLevel = 3
+ScenarioLog.ProductVersion = "4"
+ScenarioLog.MachineName = "Undefined"
+ScenarioLog.LogLocation = "tapibvt.log"
+ScenarioLog.Language = "US English"
+
+'WATCH IT
+'dwPrivileges string in the form of sdwPrivileges
+
+			'change these to pointers ASAP
+global NONE as long, MONITOR as long, OWNER as long
+			sdwPrivileges(1)="NONE"
+			NONE=1
+			sdwPrivileges(2)="MONITOR"
+			MONITOR=2
+			sdwPrivileges(3)="OWNER"
+			OWNER=3
+
+'dwMediaModes string in the form of sdwMediaModes
+'edit this, this is bulky & hacked:
+
+global UNKNOWN as long, INTERACTIVEVOICE as long, AUTOMATEDVOICE as long
+global DATAMODEM as long, G3FAX as long, TDD as long, G4FAX as long
+global DIGITALDATA as long, TELETEX as long, VIDEOTEX as long
+global TELEX as long, MIXED as long, ADSI as long, VOICEVIEW as long
+
+			sdwMediaModes(1)="UNKNOWN"
+			UNKNOWN=1
+			sdwMediaModes(2)="INTERACTIVEVOICE"
+			INTERACTIVEVOICE=2
+			sdwMediaModes(3)="AUTOMATEDVOICE"
+			AUTOMATEDVOICE=3
+			sdwMediaModes(4)="DATAMODEM"
+			DATAMODEM=4
+			sdwMediaModes(5)="G3FAX"
+			G3FAX=5
+			sdwMediaModes(6)="TDD"
+			TDD=6
+			sdwMediaModes(7)="G4FAX"
+			G4FAX=7
+			sdwMediaModes(8)="DIGITALDATA"
+			DIGITALDATA=8
+			sdwMediaModes(9)="TELETEX"
+			TELETEX=9
+			sdwMediaModes(10)="VIDEOTEX"
+			VIDEOTEX=10
+			sdwMediaModes(11)="TELEX"
+			TELEX=11
+			sdwMediaModes(12)="MIXED"
+			MIXED=12
+			sdwMediaModes(13)="ADSI"
+			ADSI=13
+			sdwMediaModes(14)="VOICEVIEW"
+			VOICEVIEW=14
+
+'/////////////////////////////////
+'///////  END HEADER /////////////
+'/////////////////////////////////
diff --git a/private/tapi/qa/bvt/current/tbpoke.h b/private/tapi/qa/bvt/current/tbpoke.h
new file mode 100644
index 000000000..bd3d90261
--- /dev/null
+++ b/private/tapi/qa/bvt/current/tbpoke.h
@@ -0,0 +1,68 @@
+'control handles for TAPI Browser UI
+type hwndTAPI_CONTROL
+	TapiHandle				as long
+	ParamsCheckbox			as long
+	LineAppPlusButton		as long
+	LineAppMinusButton		as long
+	LinePlusButton			as long
+	LineMinusButton			as long
+	CallPlusButton			as long
+	CallMinusButton			as long
+	PhoneAppPlusButton		as long
+	PhoneAppMinusButton		as long
+	PhoneOpenPlusButton		as long
+	PhoneOpenMinusButton	as long
+	ClearEditButton			as long
+	BlankButton0			as long
+	BlankButton1			as long
+	BlankButton2			as long
+	BlankButton3			as long
+	BlankButton4			as long
+	BlankButton5			as long
+	Listbox0				as long 'middle box
+	Listbox1				as long 'left box
+	Editbox					as long 'right box
+end type
+
+
+'TYPE ORDERS
+'	company AS STRING *30
+'	ordernum AS ARRAY OF LONG
+'	billed AS DOUBLE
+'END TYPE
+'
+'  
+'You must not only explicitly declare any variable of this type using the DIM statement, you must then use the REDIM statement to dimension the array within it:
+'  
+'DIM MyOrders AS ORDERS
+'REDIM (MyOrders.ordernum)(1 TO 30) AS LONG
+
+
+'from RECORDER.INC ???
+'$IFDEF MSTEST32
+TYPE LOGINITSTRUCT
+    LogOutputType AS LONG
+    MinDetailLevel AS LONG
+    ProductVersion AS STRING
+    MachineName AS STRING
+    Language AS STRING
+    LogLocation AS STRING
+'    NotificationProc AS POINTER TO SUB(Action&, Text$)
+END TYPE
+'$ENDIF 
+
+type TAPI_STATISTIC
+	CountlineInitialze				as long
+	CountlineShutdown				as long
+	CountlineOpen					as long
+	CountlineClose					as long
+	CountlineMakeCall				as long
+	CountlineDrop					as long
+	CountlineDeallocateCall			as long
+	CountlineAnswer					as long
+	CountlineGetNumRings			as long
+	CountlineDial					as long
+	CountlineGetTranslateCaps		as long
+	CountlineNegotiateAPIVersion	as long
+	CountlineNegotiateExtVersion	as long
+end type 'more to come
diff --git a/private/tapi/qa/bvt/tapi_api.inc b/private/tapi/qa/bvt/tapi_api.inc
new file mode 100644
index 000000000..abb4922cf
--- /dev/null
+++ b/private/tapi/qa/bvt/tapi_api.inc
@@ -0,0 +1,480 @@
+'******************************************************************************
+
+' TAPI_API.inc												 
+' Created April 16, 1996
+' By Ron Rohr
+
+' 
+' This file was created in part using TAPI_API.mst which copies the api listing from 
+' TAPI Browser and converts the api's to constant declarations.
+
+'******************************************************************************
+
+
+'$IFNDEF TAPI_API_INC
+'$DEFINE	TAPI_API_INC
+
+'**************************** BEGIN DECLARATIONS ******************************
+'------------------------------------------------------------------------------
+' Begin Type declarations 
+
+type ParamAttributes
+
+	Param			as string
+	BitFlagList as string
+	ValueEdit	as string
+	ValueList	as string
+
+end type
+
+type LOpenParam		  'lineOpen return parameters
+
+	hLine as long		  'handle to open line device
+	DevID as short
+	Priv  as string	  'Application Call Privalege
+
+end type
+
+type lNegAPIV				'lineNegotiateAPIVersion return parameters
+
+	API_Ver as string
+	ID      as array of string
+
+end type
+
+type TAPIMSG
+
+	Msg as string
+	device as string
+	cbInst as string
+	param1 as string
+	param2 as string
+	param3 as string
+ 	errorstr as string
+
+ end type
+
+Type ParamInfo			'Registry 
+	VName as string
+	DType as string
+	Value as String
+end type
+
+'------------------------------------------------------------------------------
+' Begin TAPI Browser API variable declarations 
+
+'lineInitialize
+dim hLineApp as long	  'Application usage handle
+dim Num_Dev  as short  'Number of devices returned by lineInitialize
+
+'lineOpen
+dim lOpenRtn as LOpenParam
+
+'lineNegotiateAPIVer
+dim lNegVerRtn as lNegAPIV
+redim	(lNegVerRtn.ID)(3) as string
+
+'lineMakeCall
+dim ReceiveState as TAPIMSG
+
+' End TAPI Browser API variable declarations 
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin Global declarations and definitions
+ 
+Global WTIMEOUT AS LONG           'Timeout value for WFndWnd
+Global teststring as CaseStruct   'Holds test case info for logging by logcase routine
+Global ParamTraits as array of ParamAttributes	'TB20 Parameter info
+Global TC_ID as short				 'Holds Test Case ID
+'Global ParamArray as array of ParamAttributes	'use when multiple API parameters must be set
+
+'------------------------------------------------------------------------------
+' Begin Constants, declarations and definitions for TAPI Browser
+
+dim hTB20         as long	  ' handle to TAPI Browser
+dim hTB_Ctrl(2)   as long	  ' Array TB child controls handles
+dim hTB_CtrlID(2) as long	  ' Array TB child controls IDs
+
+Const TB_APIList = 0
+Const TB_ResList = 1
+Const TB_ResEdit = 2
+
+hTB_CtrlID( TB_APIList ) = &h03E9&
+hTB_CtrlID( TB_ResList ) = &h03E8&
+hTB_CtrlID( TB_ResEdit ) = &h03EB&
+
+Const TB20_CAPTION     = "TAPI32 Browser"
+Const USING_TB_CAPTION = "Using the TAPI Browser"
+Const DEFAULT_VALUES_CAPTION = "Default values"
+Const MOPTIONS         = "&Options"
+Const MDEFAULT         = "&Default values..."
+Const TAPI_BROWSER     = "\TB20.exe"
+ 
+'------------------------------------------------------------------------------
+' Begin Registry Editor Constant definitions
+
+Const KEY_FILENAME		= "\Providers.key"
+Const REGEDIT_CAPTION   = "Registry Editor"
+Const REGEDIT_CLASS     = "RegEdt32"
+
+Const MREG				   = "&Registry"
+Const MEDIT					= "&Edit"
+Const MView					= "&View"
+Const MSAVE_KEY			= "Sa&ve Key..."
+Const MRESTORE				= "R&estore..."
+Const MExit				   = "E&xit"
+Const MADDKEY				= "Add &Key..."
+Const MADDVAL				= "Add &Value..."
+Const MDEL					= "&Delete"
+Const MFKey					= "&Find Key..."
+		
+Const LOC_MACH_CAPTION  = "HKEY_LOCAL_MACHINE on Local Machine"
+Const FIND_CAPTION		= "Find"
+Const WARNING_CAPTION	= "Warning"
+Const SAVEKEY_CAPTION	= "Save Key"
+Const FINDKEY_CAPTION	= "Find Key"
+Const ADDKEY_CAPTION		= "Add Key"
+Const RESKEY_CAPTION		= "Restore Key"
+Const ADDVALUE_CAPTION  = "Add Value"
+Const DWORD_CAPTION		= "DWord Editor"
+Const RSTR_CAPTION		= "String Editor"
+
+Const REGWIN_CLASS		= "REGISTRY_WINDOW"
+Const DIALOG_CLASS		= "#32770"
+
+Const REG_lOC_PATH		= "Software\Microsoft\Windows\CurrentVersion\Telephony\Providers"
+
+' End Registry Editor Constant definitions
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Other Constant definitions 
+
+' Window Classes
+
+Const DIALOG_CLASS = "#32770"
+
+' Menu 
+
+Const MFILE  = "&File"
+Const MEXIT  = "E&xit"
+Const MCLEAR = "&Clear"
+
+' Other
+
+Const CALL_STATUS_CAPTION = "Call Status"
+Const TB_EDIT_FILE = "\TB_EDIT_FILE.txt"
+
+' Used by TC 31
+Const MODEM_PROP_CAPTION = "Modems Properties"
+Const MODEM					 = "Modem"
+Const GEN_TAB				 = "General"
+Const PROPERTIES			 = "Properties"
+
+' Used by TC 32
+Const LOC_INFO_CAPTION   = "Location Information"
+Const DIALOG_CLASS		 = "#32770"
+Const PROPERTIES_CAPTION = "Dialing Properties"
+
+' End Other Constant definitions 
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Modem Properties Constant definitions 
+
+Const MODEM_APPLET		    = "\MODEM.CPL"
+Const MODEM_PROP_CAPTION	 =	"Modems Properties"
+Const INSTALL_MODEM_CAPTION = "Install New Modem"
+
+' End Modem Properties Constant definitions 
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin TC 178 Constant definitions 
+
+Const SET_RINGS = "9"
+
+' End TC 178 Constant definitions 
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin TAPI API Function constant definitions
+
+Const LAPI_Accept = "lineAccept"
+Const LAPI_AddProvider = "lineAddProvider"
+Const LAPI_AddProviderW = "lineAddProviderW"
+Const LAPI_AddToConference = "lineAddToConference"
+Const LAPI_AgentSpecific = "lineAgentSpecific"
+Const LAPI_Answer = "lineAnswer"
+Const LAPI_BlindTransfer = "lineBlindTransfer"
+Const LAPI_BlindTransferW = "lineBlindTransferW"
+Const LAPI_Close = "lineClose"
+Const LAPI_CompleteCall = "lineCompleteCall"
+Const LAPI_CompleteTransfer = "lineCompleteTransfer"
+Const LAPI_ConfigDialog = "lineConfigDialog"
+Const LAPI_ConfigDialogW = "lineConfigDialogW"
+Const LAPI_ConfigDialogEdit = "lineConfigDialogEdit"
+Const LAPI_ConfigDialogEditW = "lineConfigDialogEditW"
+Const LAPI_ConfigProvider = "lineConfigProvider"
+Const LAPI_DeallocateCall = "lineDeallocateCall"
+Const LAPI_DevSpecific = "lineDevSpecific"
+Const LAPI_DevSpecificFeature = "lineDevSpecificFeature"
+Const LAPI_Dial = "lineDial"
+Const LAPI_DialW = "lineDialW"
+Const LAPI_Drop = "lineDrop"
+Const LAPI_Forward = "lineForward"
+Const LAPI_ForwardW = "lineForwardW"
+Const LAPI_GatherDigits = "lineGatherDigits"
+Const LAPI_GatherDigitsW = "lineGatherDigitsW"
+Const LAPI_GenerateDigits = "lineGenerateDigits"
+Const LAPI_GenerateDigitsW = "lineGenerateDigitsW"
+Const LAPI_GenerateTone = "lineGenerateTone"
+Const LAPI_GetAddressCaps = "lineGetAddressCaps"
+Const LAPI_GetAddressCapsW = "lineGetAddressCapsW"
+Const LAPI_GetAddressID = "lineGetAddressID"
+Const LAPI_GetAddressIDW = "lineGetAddressIDW"
+Const LAPI_GetAddressStatus = "lineGetAddressStatus"
+Const LAPI_GetAddressStatusW = "lineGetAddressStatusW"
+Const LAPI_GetAgentActivityList = "lineGetAgentActivityList"
+Const LAPI_GetAgentActivityListW = "lineGetAgentActivityListW"
+Const LAPI_GetAgentCaps = "lineGetAgentCaps"
+Const LAPI_GetAgentGroupList = "lineGetAgentGroupList"
+Const LAPI_GetAgentStatus = "lineGetAgentStatus"
+Const LAPI_GetAppPriority = "lineGetAppPriority"
+Const LAPI_GetAppPriorityW = "lineGetAppPriorityW"
+Const LAPI_GetCallInfo = "lineGetCallInfo"
+Const LAPI_GetCallInfoW = "lineGetCallInfoW"
+Const LAPI_GetCallStatus = "lineGetCallStatus"
+Const LAPI_GetConfRelatedCalls = "lineGetConfRelatedCalls"
+Const LAPI_GetCountry = "lineGetCountry"
+Const LAPI_GetCountryW = "lineGetCountryW"
+Const LAPI_GetDevCaps = "lineGetDevCaps"
+Const LAPI_GetDevCapsW = "lineGetDevCapsW"
+Const LAPI_GetDevConfig = "lineGetDevConfig"
+Const LAPI_GetDevConfigW = "lineGetDevConfigW"
+Const LAPI_GetIcon = "lineGetIcon"
+Const LAPI_GetIconW = "lineGetIconW"
+Const LAPI_GetID = "lineGetID"
+Const LAPI_GetIDW = "lineGetIDW"
+Const LAPI_GetLineDevStatus = "lineGetLineDevStatus"
+Const LAPI_GetMessage = "lineGetMessage"
+Const LAPI_GetNewCalls = "lineGetNewCalls"
+Const LAPI_GetNumRings = "lineGetNumRings"
+Const LAPI_GetProviderList = "lineGetProviderList"
+Const LAPI_GetProviderListW = "lineGetProviderListW"
+Const LAPI_GetRequest = "lineGetRequest"
+Const LAPI_GetRequestW = "lineGetRequestW"
+Const LAPI_GetStatusMessages = "lineGetStatusMessages"
+Const LAPI_GetTranslateCaps = "lineGetTranslateCaps"
+Const LAPI_GetTranslateCapsW = "lineGetTranslateCapsW"
+Const LAPI_Handoff = "lineHandoff"
+Const LAPI_HandoffW = "lineHandoffW"
+Const LAPI_Hold = "lineHold"
+Const LAPI_Initialize = "lineInitialize"
+Const LAPI_IniitializeW = "lineIniitializeW"
+Const LAPI_InitializeEx = "lineInitializeEx"
+Const LAPI_InitializeExW = "lineInitializeExW"
+Const LAPI_MakeCall = "lineMakeCall"
+Const LAPI_MakeCallW = "lineMakeCallW"
+Const LAPI_MonitorDigits = "lineMonitorDigits"
+Const LAPI_MonitorMedia = "lineMonitorMedia"
+Const LAPI_MonitorTones = "lineMonitorTones"
+Const LAPI_NegotiateAPIVersion = "lineNegotiateAPIVersion"
+Const LAPI_NegotiateExtVersion = "lineNegotiateExtVersion"
+Const LAPI_Open = "lineOpen"
+Const LAPI_OpenW = "lineOpenW"
+Const LAPI_Park = "linePark"
+Const LAPI_ParkW = "lineParkW"
+Const LAPI_Pickup = "linePickup"
+Const LAPI_PickupW = "linePickupW"
+Const LAPI_PrepareAddToConference = "linePrepareAddToConference"
+Const LAPI_PrepareAddToConferenceW = "linePrepareAddToConferenceW"
+Const LAPI_ProxyMessage = "lineProxyMessage"
+Const LAPI_ProxyResponse = "lineProxyResponse"
+Const LAPI_Redirect = "lineRedirect"
+Const LAPI_RedirectW = "lineRedirectW"
+Const LAPI_RegisterRequestRecipient = "lineRegisterRequestRecipient"
+Const LAPI_ReleaseUserUserInfo = "lineReleaseUserUserInfo"
+Const LAPI_RemoveFromConference = "lineRemoveFromConference"
+Const LAPI_RemoveProvider = "lineRemoveProvider"
+Const LAPI_SecureCall = "lineSecureCall"
+Const LAPI_SendUserUserInfo = "lineSendUserUserInfo"
+Const LAPI_SetAgentActivity = "lineSetAgentActivity"
+Const LAPI_SetAgentGroup = "lineSetAgentGroup"
+Const LAPI_SetAgentState = "lineSetAgentState"
+Const LAPI_SetAppPriority = "lineSetAppPriority"
+Const LAPI_SetAppPriorityW = "lineSetAppPriorityW"
+Const LAPI_SetAppSpecific = "lineSetAppSpecific"
+Const LAPI_SetCallData = "lineSetCallData"
+Const LAPI_SetCallParams = "lineSetCallParams"
+Const LAPI_SetCallPrivilege = "lineSetCallPrivilege"
+Const LAPI_SetCallQualityOfService = "lineSetCallQualityOfService"
+Const LAPI_SetCallTreatment = "lineSetCallTreatment"
+Const LAPI_SetCurrentLocation = "lineSetCurrentLocation"
+Const LAPI_SetDevConfig = "lineSetDevConfig"
+Const LAPI_SetDevConfigW = "lineSetDevConfigW"
+Const LAPI_SetLineDevStatus = "lineSetLineDevStatus"
+Const LAPI_SetMediaControl = "lineSetMediaControl"
+Const LAPI_SetMediaMode = "lineSetMediaMode"
+Const LAPI_SetNumRings = "lineSetNumRings"
+Const LAPI_SetStatusMessages = "lineSetStatusMessages"
+Const LAPI_SetTerminal = "lineSetTerminal"
+Const LAPI_SetTollList = "lineSetTollList"
+Const LAPI_SetTollListW = "lineSetTollListW"
+Const LAPI_SetupConference = "lineSetupConference"
+Const LAPI_SetupConferenceW = "lineSetupConferenceW"
+Const LAPI_SetupTransfer = "lineSetupTransfer"
+Const LAPI_SetupTransferW = "lineSetupTransferW"
+Const LAPI_Shutdown = "lineShutdown"
+Const LAPI_SwapHold = "lineSwapHold"
+Const LAPI_TranslateAddress = "lineTranslateAddress"
+Const LAPI_TranslateAddressW = "lineTranslateAddressW"
+Const LAPI_TranslateDialog = "lineTranslateDialog"
+Const LAPI_TranslateDialogW = "lineTranslateDialogW"
+Const LAPI_UncompleteCall = "lineUncompleteCall"
+Const LAPI_Unhold = "lineUnhold"
+Const LAPI_Unpark = "lineUnpark"
+Const LAPI_UnparkW = "lineUnparkW"
+Const PAPI_Close = "phoneClose"
+Const PAPI_ConfigDialog = "phoneConfigDialog"
+Const PAPI_ConfigDialogW = "phoneConfigDialogW"
+Const PAPI_DevSpecific = "phoneDevSpecific"
+Const PAPI_GetButtonInfo = "phoneGetButtonInfo"
+Const PAPI_GetButtonInfoW = "phoneGetButtonInfoW"
+Const PAPI_GetData = "phoneGetData"
+Const PAPI_GetDevCaps = "phoneGetDevCaps"
+Const PAPI_GetDevCapsW = "phoneGetDevCapsW"
+Const PAPI_GetDisplay = "phoneGetDisplay"
+Const PAPI_GetGain = "phoneGetGain"
+Const PAPI_GetHookSwitch = "phoneGetHookSwitch"
+Const PAPI_GetIcon = "phoneGetIcon"
+Const PAPI_GetIconW = "phoneGetIconW"
+Const PAPI_GetID = "phoneGetID"
+Const PAPI_GetIDW = "phoneGetIDW"
+Const PAPI_GetLamp = "phoneGetLamp"
+Const PAPI_GetMessage = "phoneGetMessage"
+Const PAPI_GetRing = "phoneGetRing"
+Const PAPI_GetStatus = "phoneGetStatus"
+Const PAPI_GetStatusW = "phoneGetStatusW"
+Const PAPI_GetStatusMessages = "phoneGetStatusMessages"
+Const PAPI_GetVolume = "phoneGetVolume"
+Const PAPI_Initialize = "phoneInitialize"
+Const PAPI_InitializeW = "phoneInitializeW"
+Const PAPI_InitializeEx = "phoneInitializeEx"
+Const PAPI_InitializeExW = "phoneInitializeExW"
+Const PAPI_Open = "phoneOpen"
+Const PAPI_NegotiateAPIVersion = "phoneNegotiateAPIVersion"
+Const PAPI_NegotiateExtVersion = "phoneNegotiateExtVersion"
+Const PAPI_SetButtonInfo = "phoneSetButtonInfo"
+Const PAPI_SetButtonInfoW = "phoneSetButtonInfoW"
+Const PAPI_SetData = "phoneSetData"
+Const PAPI_SetDisplay = "phoneSetDisplay"
+Const PAPI_SetGain = "phoneSetGain"
+Const PAPI_SetHookSwitch = "phoneSetHookSwitch"
+Const PAPI_SetLamp = "phoneSetLamp"
+Const PAPI_SetRing = "phoneSetRing"
+Const PAPI_SetStatusMessages = "phoneSetStatusMessages"
+Const PAPI_SetVolume = "phoneSetVolume"
+Const PAPI_Shutdown = "phoneShutdown"
+Const TAPI_GetLocationInfo = "tapiGetLocationInfo"
+Const TAPI_GetLocationInfoW = "tapiGetLocationInfoW"
+Const TAPI_RequestDrop = "tapiRequestDrop"
+Const TAPI_RequestMakeCall = "tapiRequestMakeCall"
+Const TAPI_RequestMakeCallW = "tapiRequestMakeCallW"
+Const TAPI_RequestMediaCall = "tapiRequestMediaCall"
+Const TAPI_RequestMediaCallW = "tapiRequestMediaCallW"
+Const CLOSE_HANDLE = "Close handle (comm, etc)"
+
+' End TAPI API Function constant definitions
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+'  TAPI API Error constant definitions	  from TAPI.h
+
+Const LINEERR_ALLOCATED                   = &h80000001
+Const LINEERR_BADDEVICEID                 = &h80000002
+Const LINEERR_BEARERMODEUNAVAIL           = &h80000003
+Const LINEERR_CALLUNAVAIL                 = &h80000005
+Const LINEERR_COMPLETIONOVERRUN           = &h80000006
+Const LINEERR_CONFERENCEFULL              = &h80000007
+Const LINEERR_DIALBILLING                 = &h80000008
+Const LINEERR_DIALDIALTONE                = &h80000009
+Const LINEERR_DIALPROMPT                  = &h8000000A
+Const LINEERR_DIALQUIET                   = &h8000000B
+Const LINEERR_INCOMPATIBLEAPIVERSION      = &h8000000C
+Const LINEERR_INCOMPATIBLEEXTVERSION      = &h8000000D
+Const LINEERR_INIFILECORRUPT              = &h8000000E
+Const LINEERR_INUSE                       = &h8000000F
+Const LINEERR_INVALADDRESS                = &h80000010
+Const LINEERR_INVALADDRESSID              = &h80000011
+Const LINEERR_INVALADDRESSMODE            = &h80000012
+Const LINEERR_INVALADDRESSSTATE           = &h80000013
+Const LINEERR_INVALAPPHANDLE              = &h80000014
+Const LINEERR_INVALAPPNAME                = &h80000015
+Const LINEERR_INVALBEARERMODE             = &h80000016
+Const LINEERR_INVALCALLCOMPLMODE          = &h80000017
+Const LINEERR_INVALCALLHANDLE             = &h80000018
+Const LINEERR_INVALCALLPARAMS             = &h80000019
+Const LINEERR_INVALCALLPRIVILEGE          = &h8000001A
+Const LINEERR_INVALCALLSELECT             = &h8000001B
+Const LINEERR_INVALCALLSTATE              = &h8000001C
+Const LINEERR_INVALCALLSTATELIST          = &h8000001D
+Const LINEERR_INVALCARD                   = &h8000001E
+Const LINEERR_INVALCOMPLETIONID           = &h8000001F
+Const LINEERR_INVALCONFCALLHANDLE         = &h80000020
+Const LINEERR_INVALCONSULTCALLHANDLE      = &h80000021
+Const LINEERR_INVALCOUNTRYCODE            = &h80000022
+Const LINEERR_INVALDEVICECLASS            = &h80000023
+Const LINEERR_INVALDEVICEHANDLE           = &h80000024
+Const LINEERR_INVALDIALPARAMS             = &h80000025
+Const LINEERR_INVALDIGITLIST              = &h80000026
+Const LINEERR_INVALDIGITMODE              = &h80000027
+Const LINEERR_INVALDIGITS                 = &h80000028
+Const LINEERR_INVALEXTVERSION             = &h80000029
+Const LINEERR_INVALGROUPID                = &h8000002A
+Const LINEERR_INVALLINEHANDLE             = &h8000002B
+Const LINEERR_INVALLINESTATE              = &h8000002C
+Const LINEERR_INVALLOCATION               = &h8000002D
+Const LINEERR_INVALMEDIALIST              = &h8000002E
+Const LINEERR_INVALMEDIAMODE              = &h8000002F
+Const LINEERR_INVALMESSAGEID              = &h80000030
+Const LINEERR_INVALPARAM                  = &h80000032
+Const LINEERR_INVALPARKID                 = &h80000033
+Const LINEERR_INVALPARKMODE               = &h80000034
+Const LINEERR_INVALPOINTER                = &h80000035
+Const LINEERR_INVALPRIVSELECT             = &h80000036
+Const LINEERR_INVALRATE                   = &h80000037
+Const LINEERR_INVALREQUESTMODE            = &h80000038
+Const LINEERR_INVALTERMINALID             = &h80000039
+Const LINEERR_INVALTERMINALMODE           = &h8000003A
+Const LINEERR_INVALTIMEOUT                = &h8000003B 
+Const LINEERR_INVALTONE                   = &h8000003C
+Const LINEERR_INVALTONELIST               = &h8000003D
+Const LINEERR_INVALTONEMODE               = &h8000003E
+Const LINEERR_INVALTRANSFERMODE           = &h8000003F
+Const LINEERR_LINEMAPPERFAILED            = &h80000040
+Const LINEERR_NOCONFERENCE                = &h80000041
+Const LINEERR_NODEVICE                    = &h80000042
+Const LINEERR_NODRIVER                    = &h80000043
+Const LINEERR_NOMEM                       = &h80000044
+Const LINEERR_NOREQUEST                   = &h80000045
+Const LINEERR_NOTOWNER                    = &h80000046
+Const LINEERR_NOTREGISTERED               = &h80000047
+Const LINEERR_OPERATIONFAILED             = &h80000048
+Const LINEERR_OPERATIONUNAVAIL            = &h80000049
+Const LINEERR_RATEUNAVAIL                 = &h8000004A
+Const LINEERR_RESOURCEUNAVAIL             = &h8000004B
+Const LINEERR_REQUESTOVERRUN              = &h8000004C
+Const LINEERR_STRUCTURETOOSMALL           = &h8000004D
+Const LINEERR_TARGETNOTFOUND              = &h8000004E
+Const LINEERR_TARGETSELF                  = &h8000004F
+Const LINEERR_UNINITIALIZED               = &h80000050
+Const LINEERR_USERUSERINFOTOOBIG          = &h80000051
+Const LINEERR_REINIT                      = &h80000052
+Const LINEERR_ADDRESSBLOCKED              = &h80000053
+Const LINEERR_BILLINGREJECTED             = &h80000054
+Const LINEERR_INVALFEATURE                = &h80000055
+Const LINEERR_NOMULTIPLEINSTANCE          = &h80000056
+
+'  End TAPI API Error constant definitions
+'------------------------------------------------------------------------------
+
+'$ENDIF 'TAPI_API_INC
diff --git a/private/tapi/qa/bvt/tapi_bvt.inc b/private/tapi/qa/bvt/tapi_bvt.inc
new file mode 100644
index 000000000..3e72e0f9a
--- /dev/null
+++ b/private/tapi/qa/bvt/tapi_bvt.inc
@@ -0,0 +1,2788 @@
+
+'******************************************************************************
+
+' TAPI_BVT.inc												 
+' Created April, 1996
+' By Ron Rohr
+
+' This include file contains all the Functions used by the
+' TAPI_BVT.MST test Script
+
+'******************************************************************************
+
+' Note: This file uses the Object Naming convention defined in the Visual Basic
+' 4.0 Programmers Guide to name variables and contants associated with a control.
+
+'$IFNDEF TAPI_BVT_INC
+'$DEFINE TAPI_BVT_INC
+ 
+'******************** Begin Procedure Declarations ****************************
+
+Declare Sub      EndTest ()
+Declare Sub		  SetWndTimeout ()
+Declare Function DetectModem() as long
+Declare Function StartTAPIBrowser(hTB20 as long, hTB_Child() as long, hTB_ChildID() as long) as long
+Declare Sub	 	  GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+Declare Function Call_LClose ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LConfigDialog ( hTB20 as long, hTB_Child() as long, _
+												  ParamSet as long, HDlg as long, ModemName as string ) as long
+Declare Function Call_LDeallocateCall ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LDial ( hTB20 as long, hTB_Child() as long, ParamSet as long, hDlg as long  ) as long
+Declare Function Call_LDrop (hTB20 as long, hTB_Child() as long, _ 
+					  ParamSet as long,  CallState as TAPIMSG) as long
+Declare Function Call_LGetCountry (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									        Returnstr as string ) as long
+Declare Function Call_LGetDevCaps ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LGetID (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  Returnstr as string ) as long
+Declare Function Call_LGetMessage (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+					  returnstr as string) as long
+Declare Function Call_LGetStatusMessages ( hTB20 as long, hTB_Child() as long, _
+					  ParamSet as long  ) as long
+Declare Function Call_LGetTranslateCaps (hTB20 as long, hTB_Child() as long, _
+					  ParamSet as long, Returnstr as string ) as long
+Declare Function Call_LInitialize (hTB20 as long, hTB_Child() as long, _
+					  ParamSet as long, hLine as long, Num_Dev as short ) as long
+Declare Function Call_LInitializeEx (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  hLine as long, Num_Dev as short, Returnstr as string ) as long
+Declare Function Call_LMakeCall (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+					  CallState as TAPIMSG, returnstr as string) as long
+Declare Function Call_LNegotiateAPIVer (hTB20 as long, hTB_Ctrl() as long, _
+					  ParamSet as long, lNegVerRtn as lNegAPIV) as  long
+Declare Function Call_LOpen ( hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  RtnlOpen as LOpenParam ) as long
+Declare Function Call_LSetCurrentLocation ( hTB20 as long, hTB_Child() as long, _
+                 ParamSet as long, CurCountryID as string, Returnstr as string ) as long  
+Declare Function Call_LSetNumRings ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LShutDown ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LTranslateAddress (hTB20 as long, hTB_Child() as long, _
+		           Paramset as long, Returnstr as string ) as long
+Declare Function Call_LTranslateDialog ( hTB20 as long, hTB_Child() as long, _
+					  hDlg as long, ParamSet as long ) as long
+Declare Function TCloseHandle (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  returnstr as string) as long
+
+Declare Function GetEditResults (hTB20 as long,hTBEdit as long, API_CALL as string) as string
+Declare Function GetModemName ( Returnstr as string, strhObject as string) as string
+Declare Function SetParamState (hTB20 as long, State as long)	as long
+Declare Function SetParamAttrib (API_CALL as string)	as long
+Declare Function MsgSplitter (Returntxt as string, MsgStruct as TAPIMSG) as long
+Declare Function DeleteESPtsp () as short
+Declare Sub      RestoreProviders ()
+Declare Sub      SetupProviders ()
+Declare Function LineCallState (CALLSTATEMSG as TAPIMSG, Editstr as string) as long 
+Declare Function LineReturnValue  (ErrorStr as string) as long
+Declare Function LineReturnString (ErrorVal as long) as string
+
+
+'******************** Begin Procedure Definitions *****************************
+
+'******************************************************************************
+'Name   : EndTest
+'Desc   : On End cleanup procedure.
+' 
+'Parms  : None
+'
+'Return : None. 
+'
+'History: 04/22/96 : a-rrohr: Created
+'*****************************************************************************
+Sub EndTest ()
+
+'$IFDEF Already_Validated
+'$ENDIF 'Already_Validated
+
+RestoreProviders ()
+
+CloseCase (TEST_SCRIPT_TITLE)
+
+CloseLog ()
+
+Statusbox "The TAPI Build Verification Test is now Complete" + CRLF + _
+			 "Test Case Number " + ltrim$(str$(TC_ID)), 0,0,0,0, TRUE, TRUE 
+Sleep 4
+ 
+End Sub 'EndTest
+
+'******************************************************************************
+'Name   : SetWndTimeout
+'Desc   : Sets the timeout variable used by the WFndWnd function.
+'			 Some of the platforms tested on are very slow and if the timeout isn't
+'			 long enough then	the test continues with out finding the Window and its
+'			 handle, dooming all subsequent test (that are dependent on this handle)
+'			 to complete and utter failure.
+' 
+'Parms  : None
+'
+'Return : None. Sets the Global String variables WTIMEOUT
+'
+'History: 02/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+ Sub SetWndTimeout ()
+
+ dim ProcArch as string									' Generic string variable
+ dim ProcLevel as string
+
+ SetActiveTimeout	(150)
+ SetDefaultWaitTimeout (2)
+
+ ProcArch = space(40)
+ ProcArch = environ$("PROCESSOR_ARCHITECTURE")
+ ProcLevel = space(40)
+ ProcLevel = environ$("PROCESSOR_LEVEL")
+
+ select case ProcArch
+
+	case "MIPS", "PPC"
+		WTIMEOUT = 5		
+		SlowPC = FALSE
+	case "x86"
+		select case ProcLevel
+			case "5"					'Pentium class PCs
+				WTIMEOUT = 5		
+				SlowPC = FALSE
+			case "4"					'486 class PCs
+				WTIMEOUT = 10		
+				SlowPC = TRUE
+		end select
+	case  "Alpha"
+		WTIMEOUT = 20		
+		SlowPC = TRUE
+	case else
+		WTIMEOUT = 30		
+	   WritelogItem ("" ,"SetWndTimeout Subroutine - TAPI_BVT.inc")
+	   WritelogItem ("" ,"Unable to set WTIMEOUT: Unknown Processor Architecture")
+	   WritelogItem ("" ,"Processor Architecture	environment variable = " +  ProcArch)
+	   WritelogItem ("" ," ")
+end select
+
+'$IFDEF NUMEGA
+		WTIMEOUT = WTIMEOUT + 5 'If using BoundsChecker then add a few more seconds
+'$ENDIF
+
+end Sub  'SetWndTimeout ()
+
+'******************************************************************************
+'Name   : DetectModem
+'Desc   : Runs Modem.cpl and determines if a modem is installed by which modem
+'			 dialog appears
+'			 
+'Parms  : None
+'
+'Return : True  if a Modem is set up on this computer
+'			 False if not.
+'
+'History: 04/15/96 : a-rrohr: Created
+'******************************************************************************
+
+Function DetectModem() as long
+
+dim w_Flags as long
+dim handle  as long, hCtrl as long
+dim Close_cmdID as long
+dim SysDirPath as string
+dim rtn as long
+
+'Initialize variables
+
+Close_cmdID = &h01&	'Close Command button ID on Modem Properties dialog
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+SysDirPath = string$(168, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + MODEM_APPLET, BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + MODEM_APPLET, nowait
+'$endif 'NUMEGA
+
+DetectModem = FALSE	 'Set default return value
+
+'if the Modems Properties dialog appears then a modem is set up on the computer
+
+handle =  WFndWndC (MODEM_PROP_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'a Modem is set up on this computer
+	hCtrl = GetDlgItem (handle, Close_cmdID)
+	WButtonClick (_hwnd(hCtrl))
+   WritelogItem ("" , "Modem Connected")
+	DetectModem = TRUE
+	Goto EndOFFunction
+endif
+
+'if the Install New Modem dialog appears then a modem is not set up on the 
+'computer and will need to be before the test can continue.
+
+handle =  WFndWndC (INSTALL_MODEM_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'No Modems are set up on this computer
+   WritelogItem ("" , INSTALL_MODEM_CAPTION + " dialog Found")
+   WritelogItem ("" , "There are no Modems Setup on this computer")
+   WritelogItem ("" , " ")
+endif
+
+EndOFFunction:
+end Function 'DetectModem
+
+
+'******************************************************************************
+'Name   : StartTAPIBrowser
+'Desc   : Starts TAPI Browser and retrives all handles
+'			 
+'Parms  : hTB20 handle to TAPI Browser
+'			 hChild_TB() array of child handles 
+'			 all params are sent by reference and filled by this function 
+'
+'Return : True  if a TAPI Browser is started successfully
+'			 False if not.
+'
+'History: 04/16/96 : a-rrohr: Created
+'*****************************************************************************
+Function StartTAPIBrowser(hTB20 as long, hTB_Child() as long, hTB_ChildID() as long) as long
+
+static TBCalledCount as short  'Number of times TAPI Browser has been started
+dim w_flags		as long			 'used with WFndWnd function
+dim hDlg			as long			 'Generic dialog handle
+dim hCtrl		as long			 'Generic control handle
+dim OKcmd_ID	as long			 'hold ID to Using the TAPI Browser OK button
+dim SysDirPath as string		 'holds path to windows system directory
+dim rtn			as long			 'generic return variable
+
+'Initialize variables
+
+StartTAPIBrowser = FALSE 'Set default return value
+OKcmd_ID = &h01&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+'Look for the "Using the TAPI Browser" dialog. This dialog appears automatically
+'the first time TB is invoked and never again. it must be closed before the test
+'can proceed.
+
+SysDirPath = string$(168, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+if exists (SysDirPath + TAPI_BROWSER) then
+
+	'$ifdef NUMEGA
+		run SysDirPath + TAPI_BROWSER, BoundsChecker
+	'$else
+		run SysDirPath + TAPI_BROWSER, nowait
+	'$endif 'NUMEGA
+else
+   WritelogItem ("Unable to run ", SysDirPath + TAPI_BROWSER)
+   WritelogItem ("This Test Will Terminate ", "")
+   WritelogItem ("Please install Tapi Browser 2.0 prior to running this test", "")
+	end
+end if
+
+if TBCalledCount = 0 then
+	hDlg = WFndWndC (USING_TB_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+	if hDlg > 0 then
+		'Get handle to Using the TAPI Browser OK button and close dialog
+		hCtrl	= GetDlgItem(hDlg, OKcmd_ID)	 
+		WButtonClick  (_hwnd(hCtrl), TIMEOUT)
+	end if
+end if
+
+TBCalledCount = TBCalledCount + 1
+
+hTB20 = WFndWndC (TB20_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+'if valid TB handle then get child handles and return true
+if hTB20 > 0 then
+	GetChildHandles((hTB20), hTB_Child, (hTB_ChildID))
+	StartTAPIBrowser = TRUE
+endif
+
+end Function 'StartTAPIBrowser
+
+'*****************************************************************************
+'Name   : GetChildhandles 
+'Desc   : Fills the hChild array with the handles to the child controls of hParent 
+'         
+'Parms  : hTab = handle to My Location Tab
+'			 hChild = array of My Location child control handles.  
+'			 ChildID = array of child control IDs
+' 
+'Return : Void:   Subroutine fills in the hChild array parameter
+'
+'History: 02/10/96 : a-rrohr: Created
+'*****************************************************************************
+sub GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+
+dim count	  as short
+dim beginning as short
+dim ending    as short
+
+beginning = lbound(hChild)
+ending    = ubound(hChild)
+
+for count = beginning to ending
+	hChild(count) = GetDlgItem (hParent, ChildID(count))
+next	
+end sub
+
+'******************************************************************************
+'Name   : Call_LClose
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 04/19/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LClose ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Close, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Close)
+	if rtn = FALSE then
+		Call_LClose = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Close )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LClose = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LClose 
+
+'******************************************************************************
+'Name   : Call_LConfigDialog
+'Desc   : Invokes the lineConfigureDialog function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineConfigDialog return value
+'			 
+'History: 05/09/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LConfigDialog ( hTB20 as long, hTB_Child() as long, ParamSet as long, _
+											HDlg as long, ModemName as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim w_flags as long           'used with WFndWnd function
+dim ViewListID as long		   'IDs
+dim hctrl as long					'Generic control handle
+dim cmdOKID as long				'IDs
+dim cmdCloseID as long
+dim hTab as long					'Handle to Modems Properties General Tab
+dim SysDirPath as string		'Path to Windows\System32 directory
+dim ModemCaption as string		'Holds caption to Config dialog 
+
+cmdOKID			 = &h00000001&
+cmdCloseID		 = &h00000001&
+ViewListID		 = &h00000071&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_ConfigDialog)
+	if rtn = FALSE then
+		Call_LConfigDialog = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Start the control panel Modem applet
+SysDirPath = space$(168)
+rtn = GetSystemDirectory (SysDirPath, 168)
+run "control.exe " + SysDirPath + "\Modem.CPL", NoWait
+
+' Find Modems Properties dialog and retrieve Modem name
+hDlg = WFndWndC (MODEM_PROP_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if hDlg <> 0 then
+	hTab =  WFndWndC ("General", DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+	if hTab <> 0 then
+		hctrl = GetDlgItem (hTab, ViewListID)
+		if hctrl <> 0 then
+			ModemName = " "
+			ModemName = ViewItemText (_hwnd(hctrl), "@1", "Modem", WTimeout)
+			ModemCaption = ModemName + " " + PROPERTIES
+		endif
+	endif
+	'Close Modems Properties
+	hctrl = GetDlgItem (hDlg, cmdCloseID)
+	WButtonClick (_hwnd(hctrl))
+endif
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_ConfigDialog, TimeOut)
+sleep .1
+
+' Find Config dialog, save the handle and close and close it
+hDlg = 0
+hDlg = WFndWndC (ModemCaption, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if hDlg <> 0 then
+	cmdOKID = &h00000001&
+	hctrl = GetDlgItem (hdlg, cmdOKID)
+	WButtonClick (_hwnd(hctrl))
+else
+	WritelogItem ("Unable to Find Dialing Properties dialog " , "")
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_ConfigDialog )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LConfigDialog = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LConfigureDialog 
+
+'******************************************************************************
+'Name   : Call_LDeallocateCall
+'Desc   : Invokes the lineDeallocateCall function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 04/25/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LDeallocateCall ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+Call_LDeallocateCall = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_DeallocateCall, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_DeallocateCall)
+	if rtn = FALSE then
+		Call_LDeallocateCall = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_DeallocateCall )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LDeallocateCall = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LDeallocateCall 
+
+'******************************************************************************
+'Name   : Call_LDial
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet:  state of param checkbox
+'			 hDlg:      handle to Call Status dialog
+'
+'Return : lineDial return value
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LDial ( hTB20 as long, hTB_Child() as long, ParamSet as long, hDlg as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hCtrl as long
+dim w_flags  as long
+dim TalkID	 as long				'ID for Call Status Talk button
+dim HangUpID as long				'ID for Call Status Hang Up button
+
+TalkID	= &h0514&
+HangUpID = &h0515&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+Call_LDial = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Dial, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Dial)
+	if rtn = FALSE then
+		Call_LDial = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+hDlg = WFndWndC (CALL_STATUS_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+if hDlg > 0 then
+	WSetActWnd (hTB20) 'Make TB the active window and get result string
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Dial )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+if hDlg > 0 then 'Hangup
+	WSetActWnd (hDlg)     'Make Call Status the active window and hangup
+	sleep .1
+	hCtrl = GetDlgItem (hDlg, HangUpID)
+	WButtonClick (_hwnd(hctrl))	
+	Call_LDial = TRUE
+endif
+
+EndOfFunction:
+End Function 'Call_LDial 
+
+'******************************************************************************
+'Name   : Call_LDrop
+'Desc   : Invokes the lineMakeCall function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineGetCallStatus return value and CALLSTATE structure
+'			 
+'History: 04/25/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LDrop (hTB20 as long, hTB_Child() as long, _ 
+					  ParamSet as long,  CallState as TAPIMSG) as long
+
+dim Count as long					'Generic counter
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim tempstr  as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Drop, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Drop)
+	if rtn = FALSE then
+		Call_LDrop = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+count = 0
+tempstr = space$ (1)
+'Wait until LineGetCallStatus appears in text before proceeding (text takes time to appear completely)
+do
+	tempstr = edittext(_hwnd(hTB_Child(TB_ResEdit)), 1)
+	if len(tempstr) > 0 then
+		rtn = instr(1, tempstr, "lineGetCallStatus")
+	endif
+	count = count + 1
+	sleep .5
+loop until rtn > 1 or count > 10
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Drop )
+
+Call_LDrop = LineCallState (CallState, (tempstr))
+
+EndOfFunction:
+end Function 'Call_LDrop
+
+'******************************************************************************
+'Name   : Call_LGetCountry
+'Desc   : Invokes the lineGetCountry function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineGetCountry return and Edit box text
+'			 
+'History: 05/08/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetCountry (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetCountry, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetCountry)
+	if rtn = FALSE then
+		Call_LGetCountry = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetCountry )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LGetCountry = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LGetCountry
+
+'******************************************************************************
+'Name   : Call_LGetDevCaps
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineGetDevCaps return value
+'			 
+'History: 04/26/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetDevCaps ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetDevCaps, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetDevCaps)
+	if rtn = FALSE then
+		Call_LGetDevCaps = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetDevCaps )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LGetDevCaps = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LGetDevCaps 
+
+'******************************************************************************
+'Name   : Call_LGetID
+'Desc   : Invokes the lineTranslateAddress function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineTranslateAddress return and Edit box text
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetID (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+							 Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetID, TimeOut) 
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetID)
+	if rtn = FALSE then
+		Call_LGetID = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetID )
+
+'Retieve lineGetID return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar , CRLFrtn - Startchar))
+
+Call_LGetID = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LGetID
+
+'******************************************************************************
+'Name   : Call_LGetMessage
+'Desc   : Invokes the lineGetMessage function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineMakeCall return value	 or CALL STATUS
+'			 
+'History: 05/29/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetMessage (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+					    returnstr as string) as long
+
+dim Count as long					
+dim rtn as long 
+dim CRLFrtn as long	
+dim tempstr as string
+dim startchar as long
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetMessage, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetMessage)
+	if rtn = FALSE then
+		Call_LGetMessage = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+count = 0
+do
+	returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetMessage )
+	count = count + 1
+	sleep .5
+loop until len(returnstr) > 1 or count > 10
+
+'Retieve lineGetMessage return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LGetMessage = LineReturnValue (tempstr)
+
+EndOfFunction:
+end Function 'Call_LGetMessage
+
+'******************************************************************************
+'Name   : Call_LGetNumRings
+'Desc   : Invokes the lineGetNumRings function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineGetNumRings return value
+'			 
+'History: 05/30/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetNumRings ( hTB20 as long, hTB_Child() as long, ParamSet as long, NumRings as string) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+dim returnstr as string			'String returned by TAPI API call
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetNumRings, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetNumRings)
+	if rtn = FALSE then
+		Call_LGetNumRings = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetNumRings )
+rtn = instr(1, returnstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (returnstr, rtn -1)
+endif
+
+'Retrieve lineGetNumRings return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LGetNumRings = LineReturnValue (tempstr)
+
+rtn = instr(1, returnstr, "num rings")
+
+if rtn > 0 then
+	rtn = instr(rtn, returnstr, "x")
+	CRLFrtn = instr(rtn, returnstr, CRLF)
+	NumRings = ltrim$(rtrim$(Mid$(returnstr, rtn + 1, CRLFrtn - (rtn + 1))))
+else
+	NumRings = ""
+endif
+
+EndOfFunction:
+End Function 'Call_LGetNumRings 
+
+'******************************************************************************
+'Name   : Call_LGetStatusMessages
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 05/29/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetStatusMessages ( hTB20 as long, hTB_Child() as long, ParamSet as long  ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+Call_LGetStatusMessages = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetStatusMessages, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetStatusMessages)
+	if rtn = FALSE then
+		Call_LGetStatusMessages = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetStatusMessages )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LGetStatusMessages = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LGetStatusMessages 
+
+'******************************************************************************
+'Name   : Call_LGetTranslateCaps
+'Desc   : Invokes the lineGetTranslateCaps function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineGetTranslateCaps return and Edit box texe
+'			 
+'History: 05/03/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetTranslateCaps (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									      Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetTranslateCaps, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetTranslateCaps)
+	if rtn = FALSE then
+		Call_LGetTranslateCaps = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetTranslateCaps )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LGetTranslateCaps = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LGetTranslateCaps
+
+'******************************************************************************
+'Name   : Call_LInitialize
+'Desc   : Invokes the lineInitialize function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'
+'Return : lineInitialize return value
+'			 
+'History: 04/17/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LInitialize (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									hLine as long, Num_Dev as short ) as long
+
+dim listItemCount as long		'holds number of items in results list box
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim firststr as string			'First Edit box string	(function return)
+dim secstr as string				'Second Edit box string (Number of devices)
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Initialize, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Initialize)
+	if rtn = FALSE then
+		Call_LInitialize = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get hListApp item number, should be last item
+listItemCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+'Retrieve Usage handle from Results list box
+
+tempstr = ListItemText (_hwnd(hTB_Child(TB_ResList)), listItemCount, Timeout)
+rtn = instr(1, tempstr, "=x")
+if rtn > 0 then
+	tempstr = "&h" + ltrim$(right$(tempstr, len(tempstr) - rtn -1))
+	hLine =  val(tempstr)
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Initialize )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	firststr	= left$ (tempstr, rtn -1)
+	secstr   = right$(tempstr, len(tempstr) - rtn -1)
+endif
+
+'Retieve lineInitiate return
+rtn = instr(1, firststr, "returned")
+tempstr = ltrim$(right$(firststr, len(firststr) - rtn - len("returned")))
+
+Call_LInitialize = LineReturnValue (tempstr)
+
+'remove CRLF from second string
+rtn = instr(1, secstr, CRLF)
+
+if rtn > 0 then
+	secstr = left$(secstr, rtn -1)
+endif
+
+'retrieve number of devices from second string
+rtn = instr(1, secstr, "=")
+if rtn > 0 then
+	tempstr = right$(secstr, len(secstr) - rtn)
+	Num_Dev = val(tempstr)
+else
+	Num_Dev = 0
+endif
+ 
+EndOfFunction:
+End Function 'Call_LInitialize
+
+'******************************************************************************
+'Name   : Call_LInitializeEx
+'Desc   : Invokes the lineInitializeEx function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'
+'Return : lineInitializeEx return value
+'			 
+'History: 05/28/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LInitializeEx (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									hLine as long, Num_Dev as short, Returnstr as string ) as long
+
+dim listItemCount as long		'holds number of items in results list box
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim firststr as string			'First Edit box string	(function return)
+dim secstr as string				'Second Edit box string (Number of devices)
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_InitializeEx, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_InitializeEx)
+	if rtn = FALSE then
+		Call_LInitializeEx = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get hListApp item number, should be last item
+listItemCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+'Retrieve Usage handle from Results list box
+
+tempstr = ListItemText (_hwnd(hTB_Child(TB_ResList)), listItemCount, Timeout)
+rtn = instr(1, tempstr, "=x")
+if rtn > 0 then
+	tempstr = "&h" + ltrim$(right$(tempstr, len(tempstr) - rtn -1))
+	hLine =  val(tempstr)
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_InitializeEx )
+rtn = instr(1, Returnstr, CRLF)
+if rtn > 0 then
+	firststr	= left$ (Returnstr, rtn -1)
+	secstr   = right$(Returnstr, len(Returnstr) - rtn -1)
+endif
+
+'Retieve lineInitiate return
+rtn = instr(1, firststr, "returned")
+tempstr = ltrim$(right$(firststr, len(firststr) - rtn - len("returned")))
+
+Call_LInitializeEx = LineReturnValue (tempstr)
+
+'remove CRLF from second string
+rtn = instr(1, secstr, CRLF)
+
+if rtn > 0 then
+	secstr = left$(secstr, rtn -1)
+endif
+
+'retrieve number of devices from second string
+rtn = instr(1, secstr, "=")
+if rtn > 0 then
+	tempstr = right$(secstr, len(secstr) - rtn)
+	Num_Dev = val(tempstr)
+else
+	Num_Dev = 0
+endif
+ 
+EndOfFunction:
+End Function 'Call_LInitializeEx
+
+'******************************************************************************
+'Name   : Call_LMakeCall
+'Desc   : Invokes the lineMakeCall function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineMakeCall return value	 or CALL STATUS
+'			 
+'History: 04/24/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LMakeCall (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+					   CallState as TAPIMSG, returnstr as string) as long
+
+dim Count as long					'Generic counter
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim w_flags  as long
+dim hDlg     as long
+dim TalkID	 as long				'ID for Call Status Talk button
+dim HangUpID as long				'ID for Call Status Hang Up button
+
+TalkID	= &h0514&
+HangUpID = &h0515&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_MakeCall, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_MakeCall)
+	if rtn = FALSE then
+		Call_LMakeCall = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+hDlg = WFndWndC (CALL_STATUS_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+if hDlg > 0 then
+	WSetActWnd (hTB20)
+endif
+
+
+'Get Edit box strings
+count = 0
+do
+	returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_MakeCall )
+	count = count + 1
+	sleep .5
+loop until len(returnstr) > 1 or count > 10
+
+'Get the params of CallState only if there is a callstate msg specified
+if len(CallState.msg) > 0 then
+	Call_LMakeCall = LineCallState (CallState, (returnstr))
+endif
+
+EndOfFunction:
+end Function 'Call_LMakeCall
+
+'******************************************************************************
+'Name   : Call_LNegotiateAPIVer
+'Desc   : Invokes the lineNegotiateAPIVersion function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineNegotiateAPIVersion return value
+'			 
+'History: 04/22/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LNegotiateAPIVer (hTB20 as long, hTB_Child() as long, _ 
+					  ParamSet as long, lNegVerRtn as lNegAPIV) as long
+
+dim Count as long					'Generic counter
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim returnstr as string			'Holds Return String
+dim Versionstr as string		'holds API Version
+dim IDstr		as string		'holds ID strings
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_NegotiateAPIVersion, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_NegotiateAPIVersion)
+	if rtn = FALSE then
+		Call_LNegotiateAPIVer = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+count = 0
+tempstr = space$ (1)
+do
+	tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_NegotiateAPIVersion )
+	count = count + 1
+	sleep .5
+loop until len(tempstr) > 1 or count > 10
+
+'Separate the Function return from the rest of the string
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	returnstr	= left$ (tempstr, rtn -1)
+endif
+
+if len (tempstr) > rtn + 1 then 'if text has more than return then
+  
+'save string minus return in versionstr (lines 2&3)
+	tempstr  = right$(tempstr, len(tempstr) - rtn -1)
+
+'Separate the API Version From the ID numbers
+	rtn = instr(1, tempstr, CRLF)
+	if rtn > 0 then
+		Versionstr	= left$ (tempstr, rtn -1)
+		IDstr       = right$(tempstr, len(tempstr) - rtn -1)
+	endif
+
+'Retrieve API Version
+	rtn = instr(1, Versionstr, "=x")
+	if rtn > 0 then
+		lNegVerRtn.API_Ver = right$(Versionstr, len(Versionstr) - rtn)
+	else
+		lNegVerRtn.API_Ver = "x0"
+	endif
+
+'remove CRLF from ID string
+	rtn = instr(1, IDstr, CRLF)
+
+	if rtn > 0 then
+		IDstr = left$(IDstr, rtn -1)
+	endif
+
+'retrieve ID number of devices from ID string
+	for count = 0 to 3
+		rtn  = instr(1, IDstr, "=")
+		rtn2 = instr(1, IDstr, ",")
+		lNegVerRtn.ID(count) = mid$(IDstr, rtn +1, (rtn2) - (rtn + 1))
+		idstr = right$ (idstr, len (idstr) - rtn2 - 1)
+	next
+else
+	lNegVerRtn.API_Ver	= "x0"
+	lNegVerRtn.ID(0)		= ""
+	lNegVerRtn.ID(1)		= ""
+	lNegVerRtn.ID(2)		= ""
+	lNegVerRtn.ID(3)		= ""
+endif
+
+'Retieve lineNegotiateAPIVersion return
+rtn = instr(1, returnstr, "returned")
+if rtn > 0 then 
+	tempstr = ltrim$(right$(returnstr, len(returnstr) - rtn - len("returned")))
+end if
+
+Call_LNegotiateAPIVer = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LNegotiateAPIVer
+
+'******************************************************************************
+'Name   : Call_LOpen
+'Desc   : Invokes the lineOpen function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'			 ID - holds value of id returned by lineOpen
+'
+'Return : lineOpen return value
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LOpen ( hTB20 as long, hTB_Child() as long, ParamSet as long, RtnlOpen as LOpenParam ) as long
+
+dim listItemCount as long		'holds number of items in results list box
+dim BeginCount						'Number of Item before lineOpen is double clicked
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim firststr as string			'First Edit box string	(function return)
+dim hDlg as long					'handle to parameter dialog
+
+
+BeginCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Open, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Open)
+	if rtn = FALSE then
+		Call_LOpen = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get listbox return values
+listItemCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+if listItemCount > BeginCount then
+
+	tempstr = ListItemText (_hwnd(hTB_Child(TB_ResList)), listItemCount, Timeout)
+	rtn = instr(1, tempstr, "=x")
+	if rtn > 0 then
+		tempstr = right$(tempstr, len(tempstr) - rtn -1)
+		rtn = instr(1, tempstr, "id")
+		firststr	= "&h" + ltrim$(left$( tempstr, rtn -1))
+		RtnlOpen.hLine =  val(firststr)
+
+		tempstr = right$(tempstr, len(tempstr) - rtn -1)
+		rtn = instr(1, tempstr, "=")
+		rtn2 = instr(rtn, tempstr, " ")
+		firststr = mid$(tempstr, rtn + 1, (rtn2-1) - (rtn + 1))
+		RtnlOpen.DevID = val(firststr)	
+	
+		RtnlOpen.Priv = Space$(1)
+		RtnlOpen.Priv = ltrim$(right$(tempstr, len(tempstr) - rtn -1))
+	endif
+
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Open )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	firststr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineOpen return
+rtn = instr(1, firststr, "returned")
+tempstr = ltrim$(right$(firststr, len(firststr) - rtn - len("returned")))
+
+Call_LOpen = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LOpen 
+
+'******************************************************************************
+'Name   : Call_LSetCurrentLocation
+'Desc   : Invokes the lineGetTranslateCaps function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineGetTranslateCaps return and Edit box texe
+'			 
+'History: 05/03/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LSetCurrentLocation (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									      CurCountryID as string, Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_SetCurrentLocation, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_SetCurrentLocation)
+	if rtn = FALSE then
+		Call_LSetCurrentLocation = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_SetCurrentLocation )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LSetCurrentLocation = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LSetCurrentLocation
+
+'******************************************************************************
+'Name   : Call_LSetNumRings
+'Desc   : Invokes the lineSetNumRings function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineSetNumRings return value
+'			 
+'History: 05/30/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LSetNumRings ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_SetNumRings, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_SetNumRings)
+	if rtn = FALSE then
+		Call_LSetNumRings = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_SetNumRings )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retrieve lineSetNumRings return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LSetNumRings = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LSetNumRings 
+
+'******************************************************************************
+'Name   : Call_LShutDown
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 04/19/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LShutDown ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+Call_LShutDown = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_ShutDown, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_ShutDown)
+	if rtn = FALSE then
+		Call_LShutDown = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_ShutDown )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LShutDown = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LShutDown 
+
+'******************************************************************************
+'Name   : Call_LTranslateAddress
+'Desc   : Invokes the lineTranslateAddress function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineTranslateAddress return and Edit box text
+'			 
+'History: 05/08/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LTranslateAddress (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									      Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_TranslateAddress, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_TranslateAddress)
+	if rtn = FALSE then
+		Call_LTranslateAddress = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_TranslateAddress )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LTranslateAddress = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LTranslateAddress
+
+'******************************************************************************
+'Name   : Call_LTranslateDialog
+'Desc   : Invokes the lineTranslateDialog function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineTranslateDialog return value
+'			 
+'History: 05/08/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LTranslateDialog ( hTB20 as long, hTB_Child() as long, HDlg as long, _
+											ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim w_flags as long           'used with WFndWnd function
+dim txtAreaCodeID as long		'IDs
+dim txtAccessCodeID as long
+dim cmdCloseID as long
+dim cmdOKID as long
+dim hctrl as long					'Generic control handle
+dim handle as long				'Generic handle
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_TranslateDialog, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_TranslateDialog)
+	if rtn = FALSE then
+		Call_LTranslateDialog = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'FW_PART OR 
+
+' Find Location Information window and if it exists close it
+handle =  WFndWndC (LOC_INFO_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if handle <> 0 then
+   txtAreaCodeID   = &h0000040E&
+   txtAccessCodeID = &h0000040C&
+	cmdCloseID		 = &h00000001&
+	WSetActWnd (handle)
+
+	hctrl = GetDlgItem (handle, txtAreaCodeID)
+	if hctrl <> 0 then
+		WEditSetText  (_hwnd(hctrl), "333")
+	end if
+
+	hctrl = GetDlgItem (handle, txtAccessCodeID)
+   if hctrl <> 0 then
+      WEditSetText  (_hwnd(hctrl), "7")
+	end if
+
+	hctrl = GetDlgItem (handle, cmdCloseID)
+	WButtonClick (_hwnd(hctrl))
+
+endif
+
+' Find Dialing Properties window and close it
+hDlg = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if hDlg <> 0 then
+	cmdOKID = &h00000001&
+	hctrl = GetDlgItem (hdlg, cmdOKID)
+	WButtonClick (_hwnd(hctrl))
+else
+	WritelogItem ("Unable to Find Dialing Properties dialog " , "")
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_TranslateDialog )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LTranslateDialog = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LTranslateDialog 
+
+'******************************************************************************
+'Name   : TCloseHandle
+'Desc   : Invokes the CloseHandle function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : Close Handle return and Edit box text
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function TCloseHandle (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+							  returnstr as string) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), CLOSE_HANDLE, TimeOut) 
+TCloseHandle = FALSE
+
+if ParamSet then
+	rtn = SetParamAttrib (CLOSE_HANDLE)
+	if rtn = FALSE then
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), CLOSE_HANDLE )
+
+rtn = instr(1, Returnstr, "err")
+if rtn = 0 then 
+	TCloseHandle = True
+endif 
+EndOfFunction:
+
+End Function 'CloseHandle
+
+ '******************************************************************************
+'Name   : GetEditResults
+'Desc   : Retrives text from TB20 edit box, saves it to a file and then clears
+'			 the edit box 
+'			 
+'Parms  : hTB20: handle to TB20
+'			 hTBEdit: handle to TB20 editbox
+'			 API_CALL: TAPI call that generated the text in the edit field
+'
+'Return : TAPI API Call results value
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function GetEditResults (hTB20 as long, hTBEdit as long, API_CALL as string) as string
+
+dim tempstr as string
+dim LogFilename as string
+dim rtn as long
+dim FileNum as short
+Static FileOutputCount as short
+
+if SlowPC then
+	sleep .5
+end if
+
+tempstr = space$(1)
+tempstr = edittext(_hwnd(hTBEdit), 1)
+
+LogFilename = Space$(168)
+rtn = GetWindowsDirectory (LogFilename, len(LogFilename))
+LogFilename = LogFilename + TB_EDIT_FILE
+
+if FileOutputCount = 0 then
+	FileNum = FreeFile
+	Open  LogFilename for Output as FileNum
+	Print #FileNum,"TEST CASE " + ltrim$(str$(TC_ID)) + " " + API_CALL
+	Print #FileNum, tempstr
+	Close FileNum
+else
+	FileNum = FreeFile
+	Open  LogFilename for Append as FileNum
+	Print #FileNum,"TEST CASE " + ltrim$(str$(TC_ID)) + " " + API_CALL
+	Print #FileNum, tempstr
+	Close FileNum
+endif
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MCLEAR, TIMEOUT)
+
+GetEditResults = tempstr
+
+FileOutputCount = FileOutputCount + 1
+
+end function 'GetEditResults
+
+'******************************************************************************
+'Name   : GetModemName
+'Desc   : Retrives Modem name hObject (as string) from returnstr.  
+'			 
+'Parms  : Returnstr: string containg return text from lineDial function call
+'
+'Return : Modem Name, Also hObject is modified by the function
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function GetModemName ( Returnstr as string, strhObject as string) as string
+
+dim tempstr as string
+dim rtn as long
+dim CRLFrtn as long
+dim periodrtn as long
+dim count as short
+
+GetModemName = ""
+
+'Get hObject
+rtn = instr(1, returnstr, "dwStringOffset")
+CRLFrtn = instr(rtn, returnstr, CRLF)
+strhObject = ltrim$(mid$(returnstr, CRLFrtn + 2, 12))
+
+'Get ModemName
+periodrtn = instr(CRLFrtn, returnstr, "."+ CRLF)
+tempstr = " "
+count = 0
+while (Periodrtn > CRLFrtn AND count < 10)
+	TempStr = TempStr + Mid$(returnstr, CRLFrtn + 2 + 41, 16)
+	CRLFrtn = instr(CRLFrtn + 2, returnstr, CRLF)
+	count = count + 1
+wend
+
+tempstr = Ltrim$(Rtrim$(tempstr))
+rtn = instr(1, tempstr, ("." + CRLF))
+if rtn > 0 then
+	tempstr = left$(tempstr, len(tempstr) - (len(tempstr) - rtn + 1))
+	GetModemName = left$(tempstr, len(tempstr) - (len(tempstr) - rtn + 1))
+endif
+
+End Function 'GetModemName 
+
+'******************************************************************************
+'Name   : SetParamState
+'Desc   : Set the Param checkbox to the desired state 
+'			 
+'Parms  : hTB20 handle to TAPI Browser
+'			 State state to set Param checkbox
+'
+'Return : TRUE if Param checkbox is set
+'			 FALSE if Param checkbox is reset
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function SetParamState (hTB20 as long, State as long)	as long
+
+dim ParamID as long
+dim hParam	as long
+
+ParamID = &h03F9&
+
+hParam = GetDlgItem (hTB20, ParamID)
+
+select case State
+
+	case CHECKED
+		WCheckCheck (_hwnd(hParam), TIMEOUT)
+		SetParamState = TRUE
+	case UNCHECKED
+		WCheckUnCheck (_hwnd(hParam), TIMEOUT)
+		SetParamState = FALSE
+
+end select
+
+end Function 'SetParamState 
+
+'******************************************************************************
+'Name   : SetParamAttrib
+'Desc   : Set the Parameters of the TAPI call 
+'			 
+'Parms  : API_CALL: Title of the dialog caption
+'			 Uses Global array ParamTraits
+'
+'Return : TRUE if Parameters as set correctly
+'			 otherwise FALSE 
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function SetParamAttrib (API_CALL as string)	as long
+
+dim w_flags       as long	'flags for WFndWndC
+dim Param_lstID   as long	'Parameter list box id
+dim Value_cboID   as long	'Value combobox id
+dim BitFlag_lstID as long	'BitFlag list box id
+dim OK_cmdID      as long
+dim Cancel_cmdID  as long
+dim cbo_EditID    as long	'Value combobox editbox id
+dim cbo_ListID    as long	'Value combobox listbox id
+dim hDlg				as long  'handle to Parameter dialog
+dim hParam			as long	'handle to Parameter listbox
+dim hValue			as long	'handle to Value Combobox
+dim hBitFlag		as long	'handle to BitFlag listbox
+dim hValueEdit		as long	'handle to Value Combobox Edit box
+dim hValueList		as long	'handle to Value Combobox List box
+dim hOK_cmd 		as long	'handle to OK Button
+Dim NumSelections As short
+Dim Item				As short
+Dim intarray		As Pointer To LONG
+dim count as long, lArrayLimit as long, uArrayLimit as long
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+
+Param_lstID	  =&h03E8&
+Value_cboID	  =&h03EA&
+BitFlag_lstID =&h03E9&
+OK_cmdID		  =&h01&
+Cancel_cmdID  =&h02&
+cbo_EditID	  =&h03E9&
+cbo_ListID	  =&h03E8&
+
+SetParamAttrib = TRUE
+
+'Get handle to Parameter dialog or exit
+hDlg = WFndWndC (API_CALL, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if hDlg = 0 then
+	SetParamAttrib = FALSE
+   WritelogItem ("Unable to locate Parameter dialog for", API_CALL)
+	GoTo EndOfFunction
+endif
+
+'Get handles to dialog controls
+hParam	= GetDlgItem (hDlg, Param_lstID)
+hValue	= GetDlgItem (hDlg, Value_cboID)
+	hValueEdit	= GetDlgItem (hValue, cbo_EditID)
+	hValueList	= GetDlgItem (hValue, cbo_ListID)
+hBitFlag = GetDlgItem (hDlg, BitFlag_lstID)
+hOK_cmd  = GetDlgItem (hDlg, OK_cmdID)
+
+lArrayLimit = lbound(ParamTraits)
+uArrayLimit = ubound(ParamTraits)
+
+'Set Parameters of dialog
+for count = lArrayLimit to uArrayLimit
+
+	if ParamTraits(count).Param <> "" then
+		WListItemClk (_hwnd(hParam), ParamTraits(count).Param, TIMEOUT) 
+	endif
+
+	if ParamTraits(count).BitFlagList <> "" then
+		if count = 0 then 
+			'if any items in the bitflag list are selected prior to setting the first bitflag
+			'then deselect them 
+			NumSelections = WListSelCount(_hwnd(hBitFlag))
+
+			If (NumSelections > 0) Then
+				Allocate intarray, NumSelections
+				WListSelItems (_hwnd(hBitFlag), intarray)
+				For item = 1 to NumSelections
+					WListItemClk(_hwnd(hBitFlag), _ord(intarray[item-1]))
+				Next item
+				DeAllocate intarray
+			endif
+		endif
+		WListItemClk (_hwnd(hBitFlag), ParamTraits(count).BitFlagList, TIMEOUT) 
+
+	endif
+
+	if ParamTraits(count).ValueEdit <> "" then	
+		WEditSetText (_hwnd(hValueEdit), ParamTraits(count).ValueEdit, TIMEOUT)
+	endif
+
+	if ParamTraits(count).ValueList <> "" then
+		WComboItemClk (_hwnd(hValue), ParamTraits(count).ValueList, TIMEOUT) 
+	endif
+next 'count
+'Close dialog
+WButtonClick(_hwnd(hOK_cmd), TIMEOUT)	 
+
+EndOfFunction:
+end function 'SetParamAttrib
+
+'******************************************************************************
+'Name   : MsgSplitter
+'Desc   : Takes the Returntxt and looks for the given message (MsgStruct.Msg).
+'			 If found then the removes the message (and all proceeding text from
+'			 the tesxt string and copies the message parameters into MsgStruct.
+'			 The MsgStruct and revised text string is then returned along with 
+'			 Function = True
+'			 else The function returns False.
+'			 
+'Parms  : Retundtxt: Text in TAPI Browser edit box returned by TAPI call
+'			 MsgStruct: Message structure with parameter
+'
+'Return : True is Message is found otherwis False
+'			 
+'History: 05/02/96 : a-rrohr: Created
+'*****************************************************************************
+Function MsgSplitter (Returntxt as string, MsgStruct as TAPIMSG) as long
+
+dim tempstr as string, editstr as string, fieldstr as string
+dim rtn as long, CRLFrtn as long, paramrtn as long
+dim count as short
+
+tempstr = space$(1)
+
+rtn = instr (1, Returntxt, MsgStruct.Msg)
+if rtn > 0 then
+
+	'remove LINE_CALLSTATE 
+	CRLFrtn = instr(rtn, Returntxt, CRLF)
+	editstr = right$(Returntxt, len(Returntxt) - CRLFrtn -1)
+	'Fill CALLSTATEMSG structure
+	for count = 1 to 5
+		paramrtn = instr(1, editstr, "=") 
+		CRLFrtn = instr(paramrtn, editstr, CRLF)
+		if paramrtn > 0 AND CRLFrtn > 0 then
+			fieldstr = mid$(editstr, paramrtn + 1, CRLFrtn - paramrtn -1)
+			editstr = right$(editstr, len(editstr) - CRLFrtn -1)
+			select case count
+				case 1
+					MsgStruct.device = fieldstr 
+				case 2 
+					MsgStruct.cbInst = fieldstr 
+				case 3 
+					MsgStruct.param1 = fieldstr 
+				case 4 
+					MsgStruct.param2 = fieldstr 
+				case 5 
+					MsgStruct.param3 = fieldstr 
+			end select
+		end if  'paramrtn > 0 AND CRLFrtn > 0
+	next 'count
+else
+	MsgSplitter = FALSE
+endif
+
+end function 'MsgSplitter
+
+'*****************************************************************************
+'Name   : DeleteESPtsp 
+'Desc   : Calls the Registry editor and sets Telephony locations 
+'			 NumEntries value equal to zero 
+'         
+'Parms  : None 
+'			 
+'Return : TRUE if successful in setting NumEntries equal to zero, 
+'			 otherwise false
+'
+'History: 02/14/96 : a-rrohr: Created
+'*****************************************************************************
+
+Function DeleteESPtsp () as short
+
+dim handle as long, hTree as long, hList as long		'handles for regedit
+dim hdialog as long, hEdit as long, hOKcmd as long		'handles for Edit dialog
+dim hButton as long, w_flags as long, exitdoloop as long
+dim treepath as string
+dim Windowpath as string
+dim Viewitem   as string
+dim providername as string
+dim rtn as long, count as short
+dim Value_txtID as long, OK_cmdID as long					'Edit dialog control IDs
+
+Value_txtID = &h03E9&
+OK_cmdID =&h0001&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+
+WindowPath = space$(64)
+GetWindowsDirectory (WindowPath, len(WindowPath))
+
+Run (WindowPath + "\Regedit.exe"), NOWAIT
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, WTIMEOUT)
+
+if handle = 0 then
+	DeleteESPtsp = FALSE
+   WritelogItem ("", "Invailid handle to Registry Editor")
+	goto End_Of_Sub 
+end if
+
+hTree = GetDlgItem (handle, &h00000001)
+if hTree = 0 then
+	DeleteESPtsp = FALSE
+   WritelogItem ("", "Invailid handle to Registry Editor Tree")
+	goto End_Of_Sub 
+end if
+
+hList = GetDlgItem (handle, &h00000002)
+if hList = 0 then
+	DeleteESPtsp = FALSE
+   WritelogItem ("", "Invailid handle to Registry Editor List")
+	goto End_Of_Sub 
+end if
+
+WTreeItemExpand (_hwnd(hTree), REG_lOC_PATH, TIMEOUT)
+WTreeItemClk (_hwnd(hTree), REG_lOC_PATH, VK_LBUTTON, TIMEOUT)
+sleep 1
+
+' The first time dialing properties is invoked the NumEntries dword may not exist.
+
+viewitem = Space$(1)
+count = 0
+do
+  exitdoloop = TRUE
+  viewitem = "ProviderFilename" + ltrim$(str$(count))
+  if WViewItemExists (_hwnd(hList), viewitem, TIMEOUT) then
+    exitdoloop = FALSE
+	WViewItemDblClk (_hwnd(hList), viewitem, VK_LBUTTON, TIMEOUT)
+	hDialog = WFndWndC ("Edit String", DIALOG_CLASS , w_flags, WTIMEOUT)
+	if hDialog = 0 then
+		DeleteESPtsp = FALSE
+		WritelogItem ("", "Invailid handle to Edit dialog")
+		goto End_Of_Sub 
+	end if
+	hEdit = GetDlgItem (hDialog, Value_txtID) 
+	if hEdit = 0 then
+		DeleteESPtsp = FALSE
+		WritelogItem ("", "Invailid handle to Edit dialog Value data edit box")
+		goto End_Of_Sub 
+	end if
+	hOKcmd = GetDlgItem (hDialog, OK_cmdID)
+	if hOKcmd = 0 then
+		DeleteESPtsp = FALSE
+		WritelogItem ("", "Invailid handle to Edit dialog OK button")
+		goto End_Of_Sub 
+	end if
+	providername = editText (_hwnd(hEdit), Timeout)
+	WButtonClick (_hwnd(hOKcmd), Timeout)
+	if providername = "esp32.tsp" then
+        exitdoloop = TRUE
+		WMenuSelect ("&Edit\Delete")
+		hDialog = WFndWndC ("Confirm Value Delete", DIALOG_CLASS , w_flags, WTIMEOUT)
+		hButton = GetDlgItem (hDialog, &h6&)
+		WButtonClick (_hwnd(hButton), Timeout)
+	endif
+  endif
+  count = count + 1
+
+loop until exitdoloop
+
+DONE:' if numentries doesn't exist then jump here
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, WTIMEOUT)
+
+WSetActWnd (handle)
+WMenuSelect ("&Registry\E&xit", TIMEOUT)
+
+End_Of_Sub:  'line lable
+
+end Sub 'DeleteESPtsp
+
+'*****************************************************************************
+'Name   : RestoreProviders 
+'Desc   : Restores Telephony Providers information saved with function
+'			 SetupProviders
+'         
+'Parms  : None 
+'			 
+'Return : None 
+'
+'History: 05/16/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub RestoreProviders ()
+
+dim handle as long, hReg as long, hLocal as long		'handles for regedit
+dim Windowpath as string, SystemPath as string
+dim FindWhatID as long, FindNextID as long, count as long					'Find dialog control IDs
+dim OKID as long, YesID as long, KeyNameID as long
+dim FileNameID as long, CancelID as long
+dim hCtrl as long, w_flags as long, hDlg as long					
+dim RegPath(5) as string
+
+RegPath(0) = "Software"
+RegPath(1) = "Microsoft"
+RegPath(2) = "Windows"
+RegPath(3) = "CurrentVersion"
+RegPath(4) = "Telephony"
+RegPath(5) = "Providers"
+
+'Find dialog IDs
+FindWhatID = &h0480&
+FindNextID = &h0001&
+CancelID   = &h0002&
+
+'Other IDs
+OKID		  = &h0001& 
+YesID		  = &h0006& 
+KeyNameID  = &h0068&
+FileNameID = &h0480&
+
+	'Open Registry Editor 32 and put the focus on the Telephony\Provider key
+	WindowPath = space$(64)
+	GetWindowsDirectory (WindowPath, len(WindowPath))
+	SystemPath = space$(64)
+	GetSystemDirectory (SystemPath, len(SystemPath))
+
+	Run (SystemPath + "\Regedt32.exe"), NOWAIT
+
+	handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, TIMEOUT)
+
+	hReg = WFndWndC (LOC_MACH_CAPTION, REGWIN_CLASS , w_flags, TIMEOUT)
+	WMaxWnd (hReg)
+
+	'Go to Providers key
+	For count = lbound(RegPath) to ubound(RegPath)
+		WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+		hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+		hctrl = GetDlgItem (hDlg, FindWhatID ) 
+		WEditSetText (_hwnd(hCtrl), RegPath(Count), Timeout )
+		hctrl = GetDlgItem (hDlg, FindNextID) 
+	 	WButtonClick(_hwnd(hCtrl), Timeout )
+	next
+	'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	'Select Registry, Restore Key Menu and complete dialog 
+	WMenuSelect (MREG + "\" + MRESTORE, TIMEOUT)
+	hDlg = WFndWndC (RESKEY_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, FileNameID)
+	WEditSetText (_hwnd(hCtrl), Windowpath + KEY_FILENAME, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID)
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	'Close Warning Dialog
+	hDlg = WFndWndC (WARNING_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, YesID)
+  	WButtonClick(_hwnd(hCtrl), Timeout )
+
+
+	'Delete file %windir%\Providers.key
+	if exists (Windowpath + KEY_FILENAME) then
+		Kill (Windowpath + KEY_FILENAME)
+	endif
+
+	'Close Registry Editor 32
+	WResWnd (hReg)
+	WSetActWnd (handle)
+	WMenuSelect (MREG + "\" + MExit, TIMEOUT)
+ 
+End Sub 'RestoreProviders
+
+'*****************************************************************************
+'Name   : SetupProviders 
+'Desc   : Calls the Registry editor, saves Telephony\Providers in a file 
+'			 and configures the providers to kmddsptsp and unimdm.tsp 
+'         
+'Parms  : None 
+'			 
+'Return : None 
+'
+'History: 05/15/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub SetupProviders ()
+
+dim handle as long, hReg as long, hLocal as long		'handles for regedit
+dim Windowpath as string, SystemPath as string
+dim rtn as long, count as short
+dim FindWhatID as long, FindNextID as long					'Find dialog control IDs
+dim CancelID as long, UpID as long, DownID as long
+dim OKID as long, YesID as long, KeyNameID as long
+dim FileNameID as long
+dim hCtrl as long, w_flags as long, hDlg as long					
+dim RegPath(5) as string
+dim ProviderParam(5) as ParamInfo
+dim ValueNameID as long, DataTypeID as long, DataEditID as long
+
+RegPath(0) = "Software"
+RegPath(1) = "Microsoft"
+RegPath(2) = "Windows"
+RegPath(3) = "CurrentVersion"
+RegPath(4) = "Telephony"
+RegPath(5) = "Providers"
+
+ProviderParam(0).VName = "NextProviderID"
+ProviderParam(0).DType = "REG_DWORD"
+ProviderParam(0).Value = "3"
+ProviderParam(1).VName = "NumProviders"
+ProviderParam(1).DType = "REG_DWORD"
+ProviderParam(1).Value =  "2"
+ProviderParam(2).VName = "ProviderFilename0"
+ProviderParam(2).DType = "REG_SZ"
+ProviderParam(2).Value = "kmddsp.tsp"
+ProviderParam(3).VName = "ProviderFilename1"
+ProviderParam(3).DType = "REG_SZ"
+ProviderParam(3).Value = "unimdm.tsp"
+ProviderParam(4).VName = "ProviderID0"
+ProviderParam(4).DType = "REG_DWORD"
+ProviderParam(4).Value = "1"
+ProviderParam(5).VName = "ProviderID1"
+ProviderParam(5).DType = "REG_DWORD"
+ProviderParam(5).Value = "2"
+
+'Find dialog IDs
+FindWhatID = &h0480&
+FindNextID = &h0001&
+CancelID   = &h0002&
+UpID		  = &h0420&
+DownID	  = &h0421&
+
+'Other IDs
+OKID		  = &h0001& 
+YesID		  = &h0006& 
+KeyNameID  = &h0068&
+FileNameID = &h0480&
+
+ValueNameID = &h012E& 
+DataTypeID  = &h012D&
+DataEditID  = &h02C1&
+
+TIMEOUT = 3
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+
+WindowPath = space$(64)
+GetWindowsDirectory (WindowPath, len(WindowPath))
+SystemPath = space$(64)
+GetSystemDirectory (SystemPath, len(SystemPath))
+
+Run (SystemPath + "\Regedt32.exe"), NOWAIT
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, TIMEOUT)
+
+hReg = WFndWndC (LOC_MACH_CAPTION, REGWIN_CLASS , w_flags, TIMEOUT)
+WMaxWnd (hReg)
+
+'Go to Providers key
+For count = lbound(RegPath) to ubound(RegPath)
+	WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+	hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, FindWhatID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(Count), Timeout )
+	hctrl = GetDlgItem (hDlg, FindNextID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+next
+'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Save Providers key in Windows directory
+	if exists (Windowpath + KEY_FILENAME) then
+		Kill (Windowpath + KEY_FILENAME)
+	endif
+	WMenuSelect (MREG + "\" + MSAVE_KEY, TIMEOUT)
+	hDlg = WFndWndC (SAVEKEY_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, FileNameID)
+	WEditSetText (_hwnd(hCtrl), Windowpath + KEY_FILENAME, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID)
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Delete Providers Key
+   WMenuSelect (MEDIT + "\" + MDEL, TIMEOUT)
+	hDlg = WFndWndC (WARNING_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, YesID)
+  	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Make way back to Telphony key
+	WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+	hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	'Set Up Option Button
+	hctrl = GetDlgItem (hDlg, UpID ) 
+	WOptionClick (_Hwnd(hctrl), TIMEOUT)
+	'Set key to Telephony
+	hctrl = GetDlgItem (hDlg, FindWhatID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(4), Timeout )
+	hctrl = GetDlgItem (hDlg, FindNextID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+   'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Add new Providers key
+	WSetActWnd (handle)
+	WMenuSelect (MEDIT + "\" + MADDKEY, TIMEOUT)	
+	hDlg = WFndWndC (ADDKEY_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, KeyNameID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(5), Timeout )
+	hctrl = GetDlgItem (hDlg, OKID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	'Put focus back on Providers
+	WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+	hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	'Set Up Option Button
+	hctrl = GetDlgItem (hDlg, DownID ) 
+	WOptionClick (_Hwnd(hctrl), TIMEOUT)
+	'Set key to Telephony
+	hctrl = GetDlgItem (hDlg, FindWhatID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(5), Timeout )
+	hctrl = GetDlgItem (hDlg, FindNextID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+   'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Add Providers key parameters
+
+For count = lbound(ProviderParam) to ubound(ProviderParam)
+	WMenuSelect (MEDIT +"\"+ MADDVAL, TIMEOUT)	
+	hDlg = WFndWndC (ADDVALUE_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, ValueNameID ) 
+	WEditSetText (_hwnd(hCtrl), ProviderParam(Count).VName, Timeout )
+	hctrl = GetDlgItem (hDlg, DataTypeID) 
+ 	WComboItemClk(_hwnd(hCtrl), ProviderParam(Count).DType, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	if ProviderParam(Count).DType = "REG_SZ" then
+		hDlg = WFndWndC (RSTR_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	else
+		hDlg = WFndWndC (DWORD_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	endif
+	hctrl = GetDlgItem (hDlg, DataEditID ) 
+	WEditSetText (_hwnd(hCtrl), ProviderParam(Count).Value, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+	Sleep 1
+next
+
+WResWnd (hReg)
+WSetActWnd (handle)
+WMenuSelect (MREG + "\" + MExit, TIMEOUT)
+
+End Sub 'SetupProviders
+
+'******************************************************************************
+'Name   : LineCallState
+'Desc   : Checks the TAPI call for LINE_CALLSTATE, and verifies param1
+'			 
+'Parms  : CallStateMsg 
+'			 EditString
+'
+'Return : True if LINE_CALLSTATE param1 is expected value, otherwise false
+'			 also fills CallStateMsg with data returned by call
+'
+'History: 04/25/96 : a-rrohr: Created
+'*****************************************************************************
+Function LineCallState (CALLSTATEMSG as TAPIMSG, Editstr as string) as long 
+
+dim tempstr as string
+dim rtn as long, paramrtn as long, CRLFrtn as long, count as long, functstate as long
+dim param1str as string, fieldstr as string
+
+LineCallState = FALSE
+functstate    = FALSE
+param1str	  = CALLSTATEMSG.param1
+
+
+rtn = instr (1, EditStr, CALLSTATEMSG.Errorstr)
+if rtn = 0 then
+	CALLSTATEMSG.Errorstr = ""
+endif
+do
+	'Find LINE_CALLSTATE in return text
+	rtn = instr (1, EditStr, "LINE_CALLSTATE")
+	if rtn > 0 then   'Fill CallStateMsg with LINE_CALLSTATE parameters
+		
+		'remove LINE_CALLSTATE 
+		CRLFrtn = instr(rtn, editstr, CRLF)
+		editstr = right$(editstr, len(editstr) - CRLFrtn -1)
+		'Fill CALLSTATEMSG structure
+		for count = 1 to 5
+			paramrtn = instr(1, editstr, "=") 
+			CRLFrtn = instr(paramrtn, editstr, CRLF)
+			if paramrtn > 0 AND CRLFrtn > 0 then
+				fieldstr = mid$(editstr, paramrtn + 1, CRLFrtn - paramrtn -1)
+				editstr = right$(editstr, len(editstr) - CRLFrtn -1)
+				select case count
+					case 1
+						CALLSTATEMSG.device = fieldstr 
+					case 2 
+						CALLSTATEMSG.cbInst = fieldstr 
+					case 3 
+						CALLSTATEMSG.param1 = fieldstr 
+					case 4 
+						CALLSTATEMSG.param2 = fieldstr 
+					case 5 
+						CALLSTATEMSG.param3 = fieldstr 
+				end select
+			end if  'paramrtn > 0 AND CRLFrtn > 0
+		next 'count
+		'test for param1
+
+		paramrtn = instr(1, CALLSTATEMSG.param1, ",")
+		tempstr = ltrim$(rtrim$(right$(CALLSTATEMSG.param1, len(CALLSTATEMSG.param1) - paramrtn -1)))
+
+		if tempstr = param1str then
+			LineCallState = TRUE
+			functstate	  = TRUE
+		else
+			LineCallState = FALSE
+			functstate	  = FALSE
+		endif	'CALLSTATEMSG.param1 = param1str
+		
+	endif	'rtn > 0
+
+loop until (rtn = 0) or (functstate = TRUE)
+
+end Function 'LineCallState 
+
+'******************************************************************************
+'Name   : LineReturnValue
+'Desc   : Returns the numeric error code associated with the line error string 
+'			 
+'Parms  : Line Error String
+'
+'Return : Error code
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'******************************************************************************
+Function LineReturnValue  (ErrorStr as string) as long
+
+select case ErrorStr
+
+   case "SUCCESS"
+		LineReturnValue = &h0&
+	case "LINEERR_ALLOCATED"                   
+	   LineReturnValue = &h80000001
+   case "LINEERR_BADDEVICEID"
+      LineReturnValue = &h80000002
+   case "LINEERR_BEARERMODEUNAVAIL"           
+	   LineReturnValue = &h80000003
+   case "LINEERR_CALLUNAVAIL"                 
+	   LineReturnValue = &h80000005
+   case "LINEERR_COMPLETIONOVERRUN"           
+	   LineReturnValue = &h80000006
+   case "LINEERR_CONFERENCEFULL"              
+	   LineReturnValue = &h80000007
+   case "LINEERR_DIALBILLING"                 
+	   LineReturnValue = &h80000008
+   case "LINEERR_DIALDIALTONE"                
+	   LineReturnValue = &h80000009
+   case "LINEERR_DIALPROMPT"                  
+	   LineReturnValue = &h8000000A
+   case "LINEERR_DIALQUIET"
+	   LineReturnValue = &h8000000B
+   case "LINEERR_INCOMPATIBLEAPIVERSION"      
+	   LineReturnValue = &h8000000C
+   case "LINEERR_INCOMPATIBLEEXTVERSION"      
+	   LineReturnValue = &h8000000D
+   case "LINEERR_INIFILECORRUPT"              
+	   LineReturnValue = &h8000000E
+   case "LINEERR_INUSE"                       
+	   LineReturnValue = &h8000000F
+   case "LINEERR_INVALADDRESS"                
+	   LineReturnValue = &h80000010
+   case "LINEERR_INVALADDRESSID"              
+	   LineReturnValue = &h80000011
+   case "LINEERR_INVALADDRESSMODE"            
+	   LineReturnValue = &h80000012
+   case "LINEERR_INVALADDRESSSTATE"           
+	   LineReturnValue = &h80000013
+   case "LINEERR_INVALAPPHANDLE"              
+	   LineReturnValue = &h80000014
+   case "LINEERR_INVALAPPNAME"                
+	   LineReturnValue = &h80000015
+   case "LINEERR_INVALBEARERMODE"             
+	   LineReturnValue = &h80000016
+   case "LINEERR_INVALCALLCOMPLMODE"          
+	   LineReturnValue = &h80000017
+   case "LINEERR_INVALCALLHANDLE"             
+	   LineReturnValue = &h80000018
+   case "LINEERR_INVALCALLPARAMS"             
+	   LineReturnValue = &h80000019
+   case "LINEERR_INVALCALLPRIVILEGE"          
+	   LineReturnValue = &h8000001A
+   case "LINEERR_INVALCALLSELECT"             
+	   LineReturnValue = &h8000001B
+   case "LINEERR_INVALCALLSTATE"              
+	   LineReturnValue = &h8000001C
+   case "LINEERR_INVALCALLSTATELIST"          
+	   LineReturnValue = &h8000001D
+   case "LINEERR_INVALCARD"                   
+	   LineReturnValue = &h8000001E
+   case "LINEERR_INVALCOMPLETIONID"           
+	   LineReturnValue = &h8000001F
+   case "LINEERR_INVALCONFCALLHANDLE"         
+	   LineReturnValue = &h80000020
+   case "LINEERR_INVALCONSULTCALLHANDLE"      
+	   LineReturnValue = &h80000021
+   case "LINEERR_INVALCOUNTRYCODE"            
+	   LineReturnValue = &h80000022
+   case "LINEERR_INVALDEVICECLASS"            
+	   LineReturnValue = &h80000023
+   case "LINEERR_INVALDEVICEHANDLE"           
+	   LineReturnValue = &h80000024
+   case "LINEERR_INVALDIALPARAMS"             
+	   LineReturnValue = &h80000025
+   case "LINEERR_INVALDIGITLIST"              
+	   LineReturnValue = &h80000026
+   case "LINEERR_INVALDIGITMODE"              
+	   LineReturnValue = &h80000027
+   case "LINEERR_INVALDIGITS"                 
+	   LineReturnValue = &h80000028
+   case "LINEERR_INVALEXTVERSION"             
+	   LineReturnValue = &h80000029
+   case "LINEERR_INVALGROUPID"                
+	   LineReturnValue = &h8000002A
+   case "LINEERR_INVALLINEHANDLE"             
+	   LineReturnValue = &h8000002B
+   case "LINEERR_INVALLINESTATE"             
+	   LineReturnValue = &h8000002C
+   case "LINEERR_INVALLOCATION"               
+	   LineReturnValue = &h8000002D
+   case "LINEERR_INVALMEDIALIST"              
+	   LineReturnValue = &h8000002E
+   case "LINEERR_INVALMEDIAMODE"              
+	   LineReturnValue = &h8000002F
+   case "LINEERR_INVALMESSAGEID"              
+	   LineReturnValue = &h80000030
+   case "LINEERR_INVALPARAM"                  
+	   LineReturnValue = &h80000032
+   case "LINEERR_INVALPARKID"                 
+	   LineReturnValue = &h80000033
+   case "LINEERR_INVALPARKMODE"               
+	   LineReturnValue = &h80000034
+   case "LINEERR_INVALPOINTER"                
+	   LineReturnValue = &h80000035
+   case "LINEERR_INVALPRIVSELECT"             
+	   LineReturnValue = &h80000036
+   case "LINEERR_INVALRATE"           
+	   LineReturnValue = &h80000037
+   case "LINEERR_INVALREQUESTMODE"            
+	   LineReturnValue = &h80000038
+   case "LINEERR_INVALTERMINALID"             
+	   LineReturnValue = &h80000039
+   case "LINEERR_INVALTERMINALMODE"           
+	   LineReturnValue = &h8000003A
+   case "LINEERR_INVALTIMEOUT"                
+	   LineReturnValue = &h8000003B 
+   case "LINEERR_INVALTONE"                   
+	   LineReturnValue = &h8000003C
+   case "LINEERR_INVALTONELIST"               
+	   LineReturnValue = &h8000003D
+   case "LINEERR_INVALTONEMODE"               
+	   LineReturnValue = &h8000003E
+   case "LINEERR_INVALTRANSFERMODE"           
+	   LineReturnValue = &h8000003F
+   case "LINEERR_LINEMAPPERFAILED"            
+	   LineReturnValue = &h80000040
+   case "LINEERR_NOCONFERENCE"                
+	   LineReturnValue = &h80000041
+   case "LINEERR_NODEVICE"                    
+	   LineReturnValue = &h80000042
+   case "LINEERR_NODRIVER"                    
+	   LineReturnValue = &h80000043
+   case "LINEERR_NOMEM"                       
+	   LineReturnValue = &h80000044
+   case "LINEERR_NOREQUEST"                   
+	   LineReturnValue = &h80000045
+   case "LINEERR_NOTOWNER"                    
+	   LineReturnValue = &h80000046
+   case "LINEERR_NOTREGISTERED"               
+	   LineReturnValue = &h80000047
+   case "LINEERR_OPERATIONFAILED"             
+	   LineReturnValue = &h80000048
+   case "LINEERR_OPERATIONUNAVAIL"            
+	   LineReturnValue = &h80000049
+   case "LINEERR_RATEUNAVAIL"                 
+	   LineReturnValue = &h8000004A
+   case "LINEERR_RESOURCEUNAVAIL"             
+	   LineReturnValue = &h8000004B
+   case "LINEERR_REQUESTOVERRUN"              
+	   LineReturnValue = &h8000004C
+   case "LINEERR_STRUCTURETOOSMALL"           
+	   LineReturnValue = &h8000004D
+   case "LINEERR_TARGETNOTFOUND"              
+	   LineReturnValue = &h8000004E
+   case "LINEERR_TARGETSELF"                  
+	   LineReturnValue = &h8000004F
+   case "LINEERR_UNINITIALIZED"               
+	   LineReturnValue = &h80000050
+   case "LINEERR_USERUSERINFOTOOBIG"          
+	   LineReturnValue = &h80000051
+   case "LINEERR_REINIT"                      
+	   LineReturnValue = &h80000052
+   case "LINEERR_ADDRESSBLOCKED"              
+	   LineReturnValue = &h80000053
+   case "LINEERR_BILLINGREJECTED"             
+	   LineReturnValue = &h80000054
+   case "LINEERR_INVALFEATURE"
+	   LineReturnValue = &h80000055
+   case "LINEERR_NOMULTIPLEINSTANCE"          
+	   LineReturnValue = &h80000056
+
+end select
+
+End Function 'LineReturnValue
+
+'******************************************************************************
+'Name   : LineReturnString
+'Desc   : Returns the numeric error code associated with the line error string 
+'			 
+'Parms  : Line Error String
+'
+'Return : Error code
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'******************************************************************************
+Function LineReturnString  (ErrorVal as long) as string
+
+select case ErrorVal
+
+case &h0&
+   LineReturnString = "SUCCESS"
+case &h80000001
+	LineReturnString = "LINEERR_ALLOCATED"                   
+case &h80000002
+   LineReturnString = "LINEERR_BADDEVICEID"
+case &h80000003
+   LineReturnString = "LINEERR_BEARERMODEUNAVAIL"           
+case &h80000005
+   LineReturnString = "LINEERR_CALLUNAVAIL"                 
+case &h80000006
+   LineReturnString = "LINEERR_COMPLETIONOVERRUN"           
+case &h80000007
+   LineReturnString = "LINEERR_CONFERENCEFULL"              
+case &h80000008
+   LineReturnString = "LINEERR_DIALBILLING"                 
+case &h80000009
+   LineReturnString = "LINEERR_DIALDIALTONE"                
+case &h8000000A
+   LineReturnString = "LINEERR_DIALPROMPT"                  
+case &h8000000B
+   LineReturnString = "LINEERR_DIALQUIET"
+case &h8000000C
+   LineReturnString = "LINEERR_INCOMPATIBLEAPIVERSION"      
+case &h8000000D
+   LineReturnString = "LINEERR_INCOMPATIBLEEXTVERSION"      
+case &h8000000E
+   LineReturnString = "LINEERR_INIFILECORRUPT"              
+case &h8000000F
+   LineReturnString = "LINEERR_INUSE"                       
+case &h80000010
+   LineReturnString = "LINEERR_INVALADDRESS"                
+case &h80000011
+   LineReturnString = "LINEERR_INVALADDRESSID"              
+case &h80000012
+   LineReturnString = "LINEERR_INVALADDRESSMODE"            
+case &h80000013
+   LineReturnString = "LINEERR_INVALADDRESSSTATE"           
+case &h80000014
+   LineReturnString = "LINEERR_INVALAPPHANDLE"              
+case &h80000015
+   LineReturnString = "LINEERR_INVALAPPNAME"                
+case &h80000016
+   LineReturnString = "LINEERR_INVALBEARERMODE"             
+case &h80000017
+   LineReturnString = "LINEERR_INVALCALLCOMPLMODE"          
+case &h80000018
+   LineReturnString = "LINEERR_INVALCALLHANDLE"             
+case &h80000019
+   LineReturnString = "LINEERR_INVALCALLPARAMS"             
+case &h8000001A
+   LineReturnString = "LINEERR_INVALCALLPRIVILEGE"          
+case &h8000001B
+   LineReturnString = "LINEERR_INVALCALLSELECT"             
+case &h8000001C
+   LineReturnString = "LINEERR_INVALCALLSTATE"              
+case &h8000001D
+   LineReturnString = "LINEERR_INVALCALLSTATELIST"          
+case &h8000001E
+   LineReturnString = "LINEERR_INVALCARD"                   
+case &h8000001F
+   LineReturnString = "LINEERR_INVALCOMPLETIONID"           
+case &h80000020
+   LineReturnString = "LINEERR_INVALCONFCALLHANDLE"         
+case &h80000021
+   LineReturnString = "LINEERR_INVALCONSULTCALLHANDLE"      
+case &h80000022
+   LineReturnString = "LINEERR_INVALCOUNTRYCODE"            
+case &h80000023
+   LineReturnString = "LINEERR_INVALDEVICECLASS"            
+case &h80000024
+   LineReturnString = "LINEERR_INVALDEVICEHANDLE"           
+case &h80000025
+   LineReturnString = "LINEERR_INVALDIALPARAMS"             
+case &h80000026
+   LineReturnString = "LINEERR_INVALDIGITLIST"              
+case &h80000027
+   LineReturnString = "LINEERR_INVALDIGITMODE"              
+case &h80000028
+   LineReturnString = "LINEERR_INVALDIGITS"                 
+case &h80000029
+   LineReturnString = "LINEERR_INVALEXTVERSION"             
+case &h8000002A
+   LineReturnString = "LINEERR_INVALGROUPID"                
+case &h8000002B
+   LineReturnString = "LINEERR_INVALLINEHANDLE"             
+case &h8000002C
+   LineReturnString = "LINEERR_INVALLINESTATE"             
+case &h8000002D
+   LineReturnString = "LINEERR_INVALLOCATION"               
+case &h8000002E
+   LineReturnString = "LINEERR_INVALMEDIALIST"              
+case &h8000002F
+   LineReturnString = "LINEERR_INVALMEDIAMODE"              
+case &h80000030
+   LineReturnString = "LINEERR_INVALMESSAGEID"              
+case &h80000032
+   LineReturnString = "LINEERR_INVALPARAM"                  
+case &h80000033
+   LineReturnString = "LINEERR_INVALPARKID"                 
+case &h80000034
+   LineReturnString = "LINEERR_INVALPARKMODE"               
+case &h80000035
+   LineReturnString = "LINEERR_INVALPOINTER"                
+case &h80000036
+   LineReturnString = "LINEERR_INVALPRIVSELECT"             
+case &h80000037
+   LineReturnString = "LINEERR_INVALRATE"           
+case &h80000038
+   LineReturnString = "LINEERR_INVALREQUESTMODE"            
+case &h80000039
+   LineReturnString = "LINEERR_INVALTERMINALID"             
+case &h8000003A
+   LineReturnString = "LINEERR_INVALTERMINALMODE"           
+case &h8000003B 
+   LineReturnString = "LINEERR_INVALTIMEOUT"                
+case &h8000003C
+   LineReturnString = "LINEERR_INVALTONE"                   
+case &h8000003D
+   LineReturnString = "LINEERR_INVALTONELIST"               
+case &h8000003E
+   LineReturnString = "LINEERR_INVALTONEMODE"               
+case &h8000003F
+   LineReturnString = "LINEERR_INVALTRANSFERMODE"           
+case &h80000040
+   LineReturnString = "LINEERR_LINEMAPPERFAILED"            
+case &h80000041
+   LineReturnString = "LINEERR_NOCONFERENCE"                
+case &h80000042
+   LineReturnString = "LINEERR_NODEVICE"                    
+case &h80000043
+   LineReturnString = "LINEERR_NODRIVER"                    
+case &h80000044
+   LineReturnString = "LINEERR_NOMEM"                       
+case &h80000045
+   LineReturnString = "LINEERR_NOREQUEST"                   
+case &h80000046
+   LineReturnString = "LINEERR_NOTOWNER"                    
+case &h80000047
+   LineReturnString = "LINEERR_NOTREGISTERED"               
+case &h80000048
+   LineReturnString = "LINEERR_OPERATIONFAILED"             
+case &h80000049
+   LineReturnString = "LINEERR_OPERATIONUNAVAIL"            
+case &h8000004A
+   LineReturnString = "LINEERR_RATEUNAVAIL"                 
+case &h8000004B
+   LineReturnString = "LINEERR_RESOURCEUNAVAIL"             
+case &h8000004C
+   LineReturnString = "LINEERR_REQUESTOVERRUN"              
+case &h8000004D
+   LineReturnString = "LINEERR_STRUCTURETOOSMALL"           
+case &h8000004E
+   LineReturnString = "LINEERR_TARGETNOTFOUND"              
+case &h8000004F
+   LineReturnString = "LINEERR_TARGETSELF"                  
+case &h80000050
+   LineReturnString = "LINEERR_UNINITIALIZED"               
+case &h80000051
+   LineReturnString = "LINEERR_USERUSERINFOTOOBIG"          
+case &h80000052
+   LineReturnString = "LINEERR_REINIT"                      
+case &h80000053
+   LineReturnString = "LINEERR_ADDRESSBLOCKED"              
+case &h80000054
+   LineReturnString = "LINEERR_BILLINGREJECTED"             
+case &h80000055
+   LineReturnString = "LINEERR_INVALFEATURE"
+case &h80000056
+   LineReturnString = "LINEERR_NOMULTIPLEINSTANCE"          
+
+end select
+
+End Function 'LineReturnString
+
+'$ENDIF TAPI_BVT_INC
diff --git a/private/tapi/qa/bvt/tapi_bvt.mst b/private/tapi/qa/bvt/tapi_bvt.mst
new file mode 100644
index 000000000..cd7abfc39
--- /dev/null
+++ b/private/tapi/qa/bvt/tapi_bvt.mst
@@ -0,0 +1,2872 @@
+'******************************************************************************
+
+' TAPI_BVT.mst  TAPI API Build Verification Test
+
+' Ronald Rohr
+' April 15, 1996
+
+' Status = Pre-Test Design Review, Pre-Code Review
+' Version = 0.1
+
+' This test Performs the Build Verification Test of the TAPI API 
+' 
+' A description of the Test Cases Can be found in TCM, Server: lostpup,
+' Database: TAPICASES, Tree: BVT.
+' Logon with ID & Password = Tapicase (read only privlages) 
+
+' TAPI Browser 2.0 (TB20.exe) is required to run this test.
+'******************************************************************************
+
+'******************************************************************************
+
+'                    TEST CASE LIST  (in order of execution)
+
+'*  TC -   4 lineOpen and lineClose with all privileges
+'*  TC -   5 lineNegotiateAPIVersion / 1.4
+'*  TC -   8 lineGetDevCaps 
+'*  TC -   9 lineMakeCall - privileges = none, monitor, owner
+'*  TC -  10 lineMakeCall - line unavalable
+'-  TC -  11 lineMakeCall - to a busy number
+'*  TC -  13 lineDrop  - with active call  
+'*  TC -  14 lineDeallocate - w/ active call	
+'*  TC -  15 lineShutDown - with active call  
+'*  TC -  16 lineClose - with active call  
+'*  TC -  21 lineSetCurrentLocation - with valid and invalid Location IDs
+'*  TC -  22 lineGetCountry
+'*  TC -  26 lineGetTranslateCaps - determine SUCCESS and validity of
+'*  TC -  27 lineTranslateAddress - valid and invalid addresses
+'*  TC -  28 lineTranslateAddress - valid and invalid credit cards
+'*  TC -  29 lineTranslateAddress - valid and invalid translate options
+'*  TC -  31 lineConfigDialog 
+'*  TC -  32 lineTranslateDialog 
+'  TC -  78 lineAnswer 
+'  TC -  79 lineAccept 
+'*  TC -  80 lineDial 
+'*  TC -  81 lineGetID - comm & comm/datamodem 	
+'*  TC -  83 lineReply & lineCallState
+'*  TC - 175 lineNegotiateAPIVersion / 2.0
+'*  TC - 176 lineGetMessage
+'*  TC - 177 lineGetStatusMessage
+'*  TC - 178 lineGetNumRings & lineSetNumRings
+
+'$INCLUDE 'declares.inc'
+
+option base 0
+
+	Const TEST_SCRIPT_TITLE = "TAPI Build Verification Test" 'Test Script Name
+	Const TEST_SCRIPT_VERSION = "5/17/96"                    'Test Script Version
+	Const TIMEOUT = 3                                        'Timeout value for MSTest APIs
+
+	Global Test_Logfile as string		'Results Log File Name
+	Global SlowPC		  as long		'Set to TRUE if Alpha or 486
+
+	dim rtn as long						'Generic long return
+	dim CRLFrtn as long					'location of CRLF in string
+	dim ErrorMessage  as string		'Error Message string for On Error Procedure
+	dim ParamSet as long					'State of TB20 Param checkbox
+	dim LOpen_ID  as string				'ID returned by lineOpen
+	dim CurCountryID as string			'Hold Current Country ID   TC - 26
+	dim CreditCardID as string			'Hold Credit Card ID			TC - 26
+	dim count as short					'Generic counter
+	dim tempstr as string				'Generic string
+	dim Returnstr as string				'Holds TB20 EditBox text
+	dim hDlg as long						'Generic handle 
+   dim ModemName as string				'Modem Name for TC - 81, found in TC - 31
+	dim strhObject as string			'Used in TC - 81
+	dim NumRings as string				'Number of rings rtn by lineGetNumRings
+
+	'$include 'Tapilog.inc'          'required for all common file I/O procedures
+	'$include 'TAPI_API.inc'			'API Constant declarations used in TAPI Browser
+	'$include 'TAPI_BVT.inc'         'Functions and Constants used by TAPI_BVT.MST
+   ''$include 'TAPI_TEMP.INC'			'location of functions under construction
+
+    on error goto ErrorHandler
+	 on end        EndTest
+
+' Bounds Checker can only be run from a system that has Visual Test installed 
+' otherwise a run time error will occur.
+' The Bounds Checker binaries cannot be redistributed.
+' NUMEGA should only be defined when running in the VT environment.
+
+'$ifdef NUMEGA
+   on BoundsCheckerNotify (NULL) Call BoundsChkHandler
+'$endif 'NUMEGA
+
+'$ifdef DEBUG_TEST_SCRIPT
+   viewport on
+   viewport clear
+'$endif 'DEBUG_TEST_SCRIPT
+
+viewport off
+	
+'*** Test Initialization
+
+redim (ParamTraits) (0) as ParamAttributes
+SetDefaultWaitTimeout (5)
+TotalScenarios = 0
+Test_Logfile = TESTMODE$
+CurrentLoggingLevel = DetailCase
+SetLogFileName
+rtn = StartLog (DELETE_LOGFILE, TEST_SCRIPT_TITLE)
+SetWndTimeout ()												'Set timeouts for all platforms
+
+'*** Verify Modem set otherwise stop test
+
+rtn = DetectModem
+if rtn = FALSE then
+   tempstr = "This Test Will Terminate" + CRLF +  CRLF + _
+				 "Please Set up Modem on this computer" + CRLF + _ 
+				 "prior to running the TAPI BVT"
+	WritelogItem ("" , tempstr )
+	Statusbox tempstr, 0,0,0,0, TRUE, TRUE 
+	Sleep 6
+	Stop          'Stop the test
+endif
+	
+'*** Set Service Provider in RegEdit to unimdm.tsp
+
+'$IFDEF Already_Validated
+'$ENDIF 'Already_Validated
+
+SetupProviders ()
+
+
+'******************************************************************************
+'*** TC - 4 lineOpen and lineClose with all privileges                        *
+'******************************************************************************
+
+
+'*** Start TAPI Browser
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem ("Test Case 4" , "")
+TC_ID = 4
+TotalScenarios = TotalScenarios + 1
+
+redim (ParamTraits) (0) as ParamAttributes
+
+'--- Step 2
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if Num_Dev = 0 then
+   WritelogItem ("lineInitialize Returned 0 devices ", "")
+   WritelogItem ("Configure Telephony to use Unimodem Service Provider before starting the test ", "")
+   WritelogItem ("This Test Will Terminate", "")
+	end
+endif
+	
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+'--- Step 4, 5 , 6, 7
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "NONE"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Results 1
+
+teststring.TC_Num =  1
+teststring.Expect_Res = "LineOpen Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+
+teststring.TC_Num =  2
+teststring.Expect_Res = "LineOpen DialOut Privilege"
+teststring.Actual_Res =  lOpenRtn.priv
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "DialOut" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 8 through 17
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "MONITOR"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Results 3
+
+teststring.TC_Num =  3
+teststring.Expect_Res = "LineOpen Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 4
+
+teststring.TC_Num =  4
+teststring.Expect_Res = "LineOpen Monitor Privilege"
+teststring.Actual_Res =  lOpenRtn.priv
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "Monitor" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 18 through 27
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "OWNER"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Results 5
+
+teststring.TC_Num = 5
+teststring.Expect_Res = "LineOpen Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 6
+
+teststring.TC_Num =  6
+teststring.Expect_Res = "LineOpen DialInOut Privilege"
+teststring.Actual_Res =  lOpenRtn.priv
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "DialInOut" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 28 through 32
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  5 lineNegotiateAPIVersion / 1.4						 						   *
+'******************************************************************************
+
+'--- Step 1 through 6
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 5" , "")
+TC_ID = 5
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 1
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineNegotiateAPIVersion Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- API Version Results
+
+teststring.Expect_Res = "x10004"
+teststring.Actual_Res =  lNegVerRtn.API_Ver
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.Expect_Res = "ID's = x0"
+TotalTestCases = TotalTestCases + 1
+rtn = 0
+for count = 0 to 3
+	if lNegVerRtn.ID(count) <> "x0" then
+		rtn = rtn + 1							 'rtn is used as a fail counter
+	end if
+next
+
+if rtn = 0 then
+	teststring.Actual_Res =  "ID's = x0"
+   teststring.Apprase    = "Pass"
+else
+	teststring.Actual_Res =  "ID's <> x0"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+ParamTraits(0).Param			= "dwAPILowVersion"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "00030000"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 2
+
+teststring.TC_Num = 2
+teststring.Expect_Res = "INCOMPATIBLEAPIVERSION"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = LineReturnString (LINEERR_INCOMPATIBLEAPIVERSION) then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 14
+
+ParamTraits(0).Param			= "dwAPILowVersion"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "00010003"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 3
+
+teststring.TC_Num = 3
+teststring.Expect_Res = "LineNegotiateAPIVersion Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- API Version Results
+
+teststring.Expect_Res = "x10004"
+teststring.Actual_Res =  lNegVerRtn.API_Ver
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.Expect_Res = "ID's = x0"
+TotalTestCases = TotalTestCases + 1
+rtn = 0
+for count = 0 to 3
+	if lNegVerRtn.ID(count) <> "x0" then
+		rtn = rtn + 1							 'rtn is used as a fail counter
+	end if
+next
+
+if rtn = 0 then
+	teststring.Actual_Res =  "ID's = x0"
+   teststring.Apprase    = "Pass"
+else
+	teststring.Actual_Res =  "ID's <> x0"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC - 13 lineDrop with active call  														*
+'******************************************************************************
+
+'--- Step 1 through 5
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 13" , "")
+TC_ID = 13
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		 = "LINE_CALLSTATE"
+ReceiveState.device	 = ""
+ReceiveState.cbInst	 = ""
+ReceiveState.param1	 = "PROCEEDING"
+ReceiveState.param2	 = ""
+ReceiveState.param3	 = ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+'if rtn <= 0 then
+'   WritelogItem ("lineMakeCall failed error = " , ReceiveState.param1)
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Step 6
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState ) 
+					  
+'--- Results 1
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "IDLE"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+'******************************************************************************
+'  TC - 14 lineDeallocate w/ active call													*
+'******************************************************************************
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+'rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+'Step 7 of TC 13 is in reality TC 14
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 14" , "")
+TC_ID = 14
+TotalScenarios = TotalScenarios + 1
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineDeallocateCall Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 15 lineShutDown with active call  												*
+'******************************************************************************
+
+'--- Step 1 through 4
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 15" , "")
+TC_ID = 15
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'if rtn = FALSE then
+'   WritelogItem ("lineMakeCall failed error = " ,ReceiveState.param1)
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Results 1
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineShutDown Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC - 16 lineClose with active call  													*
+'******************************************************************************
+
+'--- Step 1 through 4
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 16" , "")
+TC_ID = 16
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+'if rtn <= 0 then
+'   WritelogItem ("lineMakeCall failed error = " ,ReceiveState.param1)
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Step 5
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Result 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineClose Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 6, 7
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  8 lineGetDevCaps 																		*
+'******************************************************************************
+
+'--- Step 1, 2
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 8" , "")
+TC_ID = 8
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3
+rtn = Call_LGetDevCaps ( (hTB20), (hTB_Ctrl), Paramset)
+
+'--- Result 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineGetDevCaps Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 4
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param			= "dwDeviceID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "ffffffff"
+
+'--- Step 5 through 8
+rtn = Call_LGetDevCaps ( (hTB20), (hTB_Ctrl), Paramset)
+
+'--- Result 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "BADDEVICEID"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_BADDEVICEID then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 9, 10 
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  9 lineMakeCall - Privileges = none, monitor, owner							*
+'******************************************************************************
+
+'--- Step 1, 2
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 9" , "")
+TC_ID = 9
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3, 4, 5, 6
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "NONE"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 7, 8
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "PROCEEDING"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 9, 10
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 11, 12
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 13 through 15
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "MONITOR"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Steps 16, 17
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "PROCEEDING"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 18 through 21
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 22 through 24
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "OWNER"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+'--- Steps 25, 26
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "PROCEEDING"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 27 through 28
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC - 10 lineMakeCall - Line unavalable													*
+'******************************************************************************
+
+ '--- Step 1, 2
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 10" , "")
+TC_ID = 10
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 3 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 4
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+'if rtn > 0 then
+'   WritelogItem ("Step 4 - lineMakeCall failed error = " , ltrim$(hex$(rtn)))
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Step 5
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 6
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 7
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = "LINEERR_CALLUNAVAIL"
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LINEERR_CALLUNAVAIL"
+teststring.Actual_Res =ReceiveState.ErrorStr
+TotalTestCases = TotalTestCases + 1
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 8, 9
+count = WListCount(_hwnd(hTB_Ctrl(TB_ResList)), TIMEOUT)
+WListItemClk (_hwnd(hTB_Ctrl(TB_ResList)), "@" + ltrim$(str$(count)), TIMEOUT)
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 10, 11
+count = WListCount(_hwnd(hTB_Ctrl(TB_ResList)), TIMEOUT)
+WListItemClk (_hwnd(hTB_Ctrl(TB_ResList)), "@" + ltrim$(str$(count)), TIMEOUT)
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 12 through 15
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 26 lineGetTranslateCaps - determine SUCCESS and validity of
+'  RUN TC-26 BEFORE TC-21 TO GET THE CURRENT LOCATION ID
+'******************************************************************************
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 26" , "")
+WritelogItem ("RUN TC-26 BEFORE TC-21 TO", " GET THE CURRENT LOCATION ID")
+TC_ID = 26
+TotalScenarios = TotalScenarios + 1
+Returnstr = space$(1)
+
+rtn = Call_LGetTranslateCaps ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineGetTranslateCaps Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn > 0 then
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+else
+   teststring.Apprase    = "Pass"
+	rtn = instr(1, Returnstr, "dwPermanentLocationID")
+	if rtn > 0 then				' Get the first location ID
+		rtn = instr(rtn, Returnstr, "=x")
+		CurCountryID = mid$(Returnstr, rtn + 2, instr(rtn, Returnstr, CRLF) - (rtn + 2) )
+	endif
+		rtn = instr(1, Returnstr, "dwPermanentCardID")
+	if rtn > 0 then				' Get the first Credit Card ID
+		rtn = instr(rtn, Returnstr, "=x")
+		CreditCardID = mid$(Returnstr, rtn + 2, instr(rtn, Returnstr, CRLF) - (rtn + 2) )
+	endif
+
+endif
+LogCase (teststring)
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+	
+'******************************************************************************
+'  TC - 21 lineSetCurrentLocation With valid and invalid Location IDs			*
+'******************************************************************************
+
+'Note: This test requires a valid Country ID which is returned by TC 26
+ 
+'--- Step 1
+
+if Val( CurCountryID) > 0 then  'continue with test
+
+	StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+	WritelogItem (" " , "")
+	WritelogItem ("Test Case 21" , "")
+	TC_ID = 21
+	TotalScenarios = TotalScenarios + 1
+
+	'--- Steps 2, 3
+	ParamSet = SetParamState (hTB20, UNCHECKED)
+
+	rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+	if rtn > 0 then
+		WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+		WritelogItem ("" , "This Test Will Terminate")
+		end
+	endif
+
+	ParamSet = SetParamState (hTB20, CHECKED)
+
+	ParamTraits(0).Param			= "dwLocation"
+	ParamTraits(0).BitFlagList	= ""
+	ParamTraits(0).ValueEdit	= CurCountryID	
+	ParamTraits(0).ValueList   = ""
+
+	Returnstr = " "
+
+	rtn = Call_LSetCurrentLocation ( (hTB20), (hTB_Ctrl), Paramset, CurCountryID, Returnstr ) 
+
+	'--- Results 1
+	teststring.TC_Num = 1
+	teststring.Expect_Res = "LineSetCurrentLoc Rtn SUCCESS"
+	teststring.Actual_Res = LineReturnString ( rtn )
+	TotalTestCases = TotalTestCases + 1
+
+	if rtn > 0 then
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	else
+		teststring.Apprase    = "Pass"
+		rtn = instr(1, Returnstr, "dwPermanentLocationID")
+		if rtn > 0 then
+			rtn = instr(rtn, Returnstr, "=x")
+			CurCountryID = mid$(Returnstr, rtn + 2, instr(rtn, Returnstr, CRLF) - (rtn + 2) )
+		endif
+	endif
+	LogCase (teststring)
+	
+	'--- Results 2
+	ReceiveState.Msg	= "LINE_LINEDEVSTATE"
+	ReceiveState.device	= ""
+	ReceiveState.cbInst	= ""
+	ReceiveState.param1	= ""
+	ReceiveState.param2	= ""
+	ReceiveState.param3	= ""
+
+	do 
+		rtn = instr(1, Returnstr, ReceiveState.Msg)
+		if rtn > 0 then
+			rtn = MsgSplitter (Returnstr, ReceiveState) 
+		endif
+	loop until rtn = 0 OR ReceiveState.param1 = "REINIT"
+
+	teststring.TC_Num = 2
+	teststring.Expect_Res = "LINE_LINEDEVSTATE = REINIT"
+	teststring.Actual_Res = ReceiveState.param1
+	TotalTestCases = TotalTestCases + 1
+
+	if instr(1, ReceiveState.param1, "REINIT") > 0 then
+		teststring.Apprase    = "Pass"
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	endif
+	LogCase (teststring)
+
+endif
+
+'--- Steps 8 through 11
+
+ParamTraits(0).Param		= "dwLocation"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ffffffff"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LSetCurrentLocation ( (hTB20), (hTB_Ctrl), Paramset, CurCountryID, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "Rtn LINEERR_INVALLOCATION"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALLOCATION then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+	
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC -  22 lineGetCountry																		*
+'******************************************************************************
+
+'--- Steps 1 through 6
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 22" , "")
+TC_ID = 22
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param		= "dwCountryID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "0"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LGetCountry ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineGetCountry Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+ParamTraits(0).Param		= "dwCountryID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "161"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LGetCountry ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 14
+ParamTraits(0).Param		= "dwCountryID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ffffffff"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LGetCountry ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "LINEERR_INVALCOUNTRYCODE"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALCOUNTRYCODE then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 15
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  27 lineTranslateAddress - valid and invalid addresses						*
+'******************************************************************************
+
+'--- Steps 1 
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 27" , "")
+TC_ID = 27
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Steps 3 through 9 Canonical format address
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+redim (ParamTraits) (0 to 1) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+1(206)543-9876"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 16 Dialable Format Address 
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "206 777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+
+'--- Steps 17 through 22 Invalid Address
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= ""	
+ParamTraits(1).ValueList   = "Invalid string pointer"
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "LINEERR_INVALPOINTER"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALPOINTER then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'******************* Added to Regress Failure 49XXX ******************************
+'--- Steps 11 through 16 Canonacal Format International Address with no city code 
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+'--- Test 1
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+852()777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Test 2
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+852 ()777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Test 3
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+852() 777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Test 4
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+852 () 777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Test 5
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+852 777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'*********************************************************************************
+
+
+'--- Steps 23 through 25 Test Case shutdown
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC -  28 lineTranslateAddress - valid and invalid credit cards					*
+'******************************************************************************
+'Note: Tis test requires a valid Credit Card ID which is returned by TC - 26
+'--- Steps 1 through 
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 28" , "")
+TC_ID = 28
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Steps 3 through 7
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param		= "dwCard"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= CreditCardID	
+ParamTraits(0).ValueList   = ""
+
+redim (ParamTraits) (0) as ParamAttributes
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 8 through 11
+ParamTraits(0).Param		= "dwCard"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ffffffff"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "LINEERR_INVALCARD"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALCARD then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 12 through 14
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  29 lineTranslateAddress - valid and invalid translate options			*
+'******************************************************************************
+
+'--- Steps 1 through 6
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 29" , "")
+TC_ID = 29
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Steps 3 through 7
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 8 through 12
+redim (ParamTraits) (0 to 1) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "CARDOVERRIDE"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ParamTraits(1).Param		= ""
+ParamTraits(1).BitFlagList	= "CANCELCALLWAITING"
+ParamTraits(1).ValueEdit	= ""	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 13 through 17
+redim (ParamTraits) (0) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "FORCELOCAL"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 18 through 22
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "FORCELD"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = 4
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 23 through 28
+redim (ParamTraits) (0 TO 1) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "FORCELOCAL"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ParamTraits(1).Param		= ""
+ParamTraits(1).BitFlagList	= "FORCELD"
+ParamTraits(1).ValueEdit	= ""	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddress ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 5
+teststring.TC_Num = 5
+teststring.Expect_Res = "LINEERR_INVALPARAM"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALPARAM then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 29 through 31
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  31 lineConfigDialog  verify popup                     			      *
+'******************************************************************************
+
+'--- Step 1
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 31" , "")
+TC_ID = 31
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+'--- Step 3, 4
+hDlg = 0
+rtn = Call_LConfigDialog ( (hTB20), (hTB_Ctrl),  Paramset, hDlg, ModemName ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "Valid Modem Prop. Handle"
+teststring.Actual_Res = ltrim$(hex$(hDlg))
+TotalTestCases = TotalTestCases + 1
+
+if hDlg <> 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 5, 6
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 32 lineTranslateDialog verify popup											   *
+'******************************************************************************
+
+'--- Step 1 through 3
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 32" , "")
+TC_ID = 32
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+hDlg = 0
+rtn = Call_LTranslateDialog ( (hTB20), (hTB_Ctrl), hDlg, Paramset ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "Valid Dialing Prop. Handle"
+teststring.Actual_Res = ltrim$(hex$(hDlg))
+TotalTestCases = TotalTestCases + 1
+
+if hDlg <> 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 5 through 7
+'--- Results 3
+
+'--- Step 8
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  80 lineDial																			   *
+'******************************************************************************
+
+'--- Step 1 through 2
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 80" , "")
+TC_ID = 80
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+'--- Step 3
+redim (ParamTraits) (0) as ParamAttributes
+
+ParamTraits(0).Param		= "lpszDestAddress"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "NULL pointer"
+
+ReceiveState.Msg		= ""
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= ""
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+ParamTraits(0).Param		= "lpszDestAddress"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "55555"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LDial ( (hTB20), (hTB_Ctrl), ParamSet, hDlg )
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "Valid Call Status Handle"
+teststring.Actual_Res = ltrim$(hex$(hDlg))
+TotalTestCases = TotalTestCases + 1
+
+if hDlg <> 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 5 through 7
+
+sleep .1   'param checkbox will not change if covered by the call 
+			  'status box. The delay allows the dialog to disappear
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  81 lineGetID - comm & comm/datamodem											* 
+'******************************************************************************
+'Note: This test case is dependent on TC 31 returning a valid modem name
+'		 The test cannot run without it
+
+'--- Step 1 through 2
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 81" , "")
+TC_ID = 81
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+redim (ParamTraits) (0) as ParamAttributes
+
+ParamTraits(0).Param		= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "OWNER"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamTraits(0).Param		= "lpszDeviceClass"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "comm"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetID ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 1
+teststring.TC_Num = 2
+teststring.Expect_Res = "dwStringFormat = ASCII"
+
+rtn = instr(1, Returnstr, "dwStringFormat")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+rtn = instr(rtn, Returnstr, ",")
+tempstr = ltrim$(mid$(Returnstr , rtn + 1, CRLFrtn - (rtn + 1)))
+ 
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if tempstr = "ASCII" then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 1
+teststring.TC_Num = 3
+teststring.Expect_Res = ModemName	' Returned in TC 31
+teststring.Actual_Res = GetModemName ( Returnstr, strhObject)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = ModemName then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'*************************************************************************************
+
+ParamTraits(0).Param		= "lpszDeviceClass"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ndis"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetID ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "dwStringFormat = BINARY"
+
+rtn = instr(1, Returnstr, "dwStringFormat")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+rtn = instr(rtn, Returnstr, ",")
+tempstr = ltrim$(mid$(Returnstr , rtn + 1, CRLFrtn - (rtn + 1)))
+ 
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if tempstr = "BINARY" then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'*************************************************************************************
+
+'--- Test 3
+ParamTraits(0).Param		= "lpszDeviceClass"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "comm/datamodem"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetID ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 3
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "dwStringFormat = BINARY"
+
+rtn = instr(1, Returnstr, "dwStringFormat")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+rtn = instr(rtn, Returnstr, ",")
+tempstr = ltrim$(mid$(Returnstr , rtn + 1, CRLfrtn - (rtn + 1)))
+ 
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if tempstr = "BINARY" then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = ModemName	' Returned in TC 31
+teststring.Actual_Res = GetModemName ( Returnstr, strhObject)
+teststring.Actual_Res = right$(teststring.Actual_Res, len(teststring.Actual_Res) -4)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = ModemName then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 5
+
+'Delete leading zeros from strhObject
+strhObject = ltrim$(Hex$(Val("&h"+ strhObject)))
+
+ParamTraits(0).Param		= "hObject"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= strhObject	
+ParamTraits(0).ValueList    = ""
+
+rtn = TCloseHandle ((hTB20), (hTB_Ctrl), ParamSet, returnstr)
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "Handle " + strhObject + " Closed"
+CRLFrtn = instr(1, returnstr, CRLF) 
+if	CRLFrtn = 0 then
+	teststring.Actual_Res = returnstr
+else
+	teststring.Actual_Res = left$(returnstr, len(returnstr) - (len(returnstr) - CRLFrtn - 1))
+endif
+TotalTestCases = TotalTestCases + 1
+
+if rtn = True then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 6, 7
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  83 lineReply & lineCallState														*
+'******************************************************************************
+
+'--- Step 1
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 83" , "")
+TC_ID = 83
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+'--- Steps 2 through 4
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Steps 5 and 6
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		= ""
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= ""
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LINE_REPLY or LINE_CALLSTATE"
+TotalTestCases = TotalTestCases + 1
+
+rtn = 0
+rtn = instr (1, returnstr, "LINE_REPLY")
+if rtn > 0 then
+	teststring.Actual_Res = "LINE_REPLY"
+	teststring.Apprase    = "Pass"
+else
+	rtn = instr (1, returnstr, "LINE_CALLSTATE")
+	if rtn > 0 then
+		teststring.Actual_Res = "LINE_CALLSTATE"
+		teststring.Apprase    = "Pass"
+	else
+		teststring.Actual_Res = ""
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	endif
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  175 lineNegotiateAPIVersion / 2.0						 						*
+'******************************************************************************
+
+'--- Step 1 through 5
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 175" , "")
+TC_ID = 175
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeEx ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitializeEx failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+
+if Num_Dev = 0 then
+   WritelogItem ("lineInitializeEx returned 0 devices = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 1
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineNegotiateAPIVersion Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- API Version Results
+
+teststring.Expect_Res = "x20000"
+teststring.Actual_Res =  lNegVerRtn.API_Ver
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.Expect_Res = "ID's = x0"
+TotalTestCases = TotalTestCases + 1
+rtn = 0
+for count = 0 to 3
+	if lNegVerRtn.ID(count) <> "x0" then
+		rtn = rtn + 1							 'rtn is used as a fail counter
+	end if
+next
+
+if rtn = 0 then
+	teststring.Actual_Res =  "ID's = x0"
+   teststring.Apprase    = "Pass"
+else
+	teststring.Actual_Res =  "ID's <> x0"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+'--- Steps 6 through 9
+ParamTraits(0).Param			= "dwAPILowVersion"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "00030000"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 2
+
+teststring.TC_Num = 2
+teststring.Expect_Res = "INCOMPATIBLEAPIVERSION"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = LineReturnString (LINEERR_INCOMPATIBLEAPIVERSION) then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 14
+
+ParamTraits(0).Param			= "dwAPILowVersion"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "00010003"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 3
+
+teststring.TC_Num = 3
+teststring.Expect_Res = "LineNegotiateAPIVersion Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- API Version Results
+
+teststring.Expect_Res = "x20000"
+teststring.Actual_Res =  lNegVerRtn.API_Ver
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.Expect_Res = "ID's = x0"
+TotalTestCases = TotalTestCases + 1
+rtn = 0
+for count = 0 to 3
+	if lNegVerRtn.ID(count) <> "x0" then
+		rtn = rtn + 1							 'rtn is used as a fail counter
+	end if
+next
+
+if rtn = 0 then
+	teststring.Actual_Res =  "ID's = x0"
+   teststring.Apprase    = "Pass"
+else
+	teststring.Actual_Res =  "ID's <> x0"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  176 lineGetMessage      									 						*
+'******************************************************************************
+
+'--- Step 1 through 10
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 176" , "")
+TC_ID = 176
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param			= "  ->dwOptions"
+ParamTraits(0).BitFlagList	= "USEEVENT"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LInitializeEx ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ReceiveState.Msg		= ""
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= ""
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCall ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "MakeCall Request ID"
+TotalTestCases = TotalTestCases + 1
+
+rtn = instr(1, returnstr, "x")
+if rtn > 0 then
+	CRLFrtn = instr(rtn, returnstr, CRLF)
+	if CRLFrtn > rtn then
+		teststring.Actual_Res = mid$ (returnstr , rtn + 1, CRLFrtn - (rtn+1))
+   else
+		teststring.Actual_Res = "0"
+	endif
+else
+	teststring.Actual_Res = "0"
+endif
+
+if Val(teststring.Actual_Res) > 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 12
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetMessage ((hTB20), (hTB_Ctrl), ParamSet, returnstr)
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "LineGetMessage Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "LINE_REPLY"
+TotalTestCases = TotalTestCases + 1
+
+'Look for 2nd CRLF in returnstr
+teststring.Actual_Res = "No Message"
+rtn = instr(1, returnstr, CRLF)
+CRLFrtn = instr(rtn+1,  returnstr, CRLF)
+if CRLFrtn > 0 then
+	rtn = instr(rtn, returnstr, "received")
+	if rtn > 0 then
+		teststring.Actual_Res = ltrim$(rtrim$(mid$(returnstr, rtn + 9, CRLFrtn - (rtn + 9))))
+	endif
+endif
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 13 through 18
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC -  177 lineGetStatusMessage									 						*
+'******************************************************************************
+
+'--- Step 1 through 4
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 177" , "")
+TC_ID = 177
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LGetStatusMessages ((hTB20), (hTB_Ctrl), ParamSet )
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "GetStatusMessage Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 5 through 7
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  178 lineGetNumRings & lineSetNumRings					 						*
+'******************************************************************************
+
+'--- Step 1 through 4
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 178" , "")
+TC_ID = 178
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitialize ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpen ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LGetNumRings  ( (hTB20), (hTB_Ctrl), Paramset, NumRings )
+
+'--- Results 1 and 2
+teststring.TC_Num = 1
+teststring.Expect_Res = "GetNumRings Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.TC_Num = 2
+teststring.Expect_Res = "Num Rings = ffffffff"
+teststring.Actual_Res = NumRings
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "ffffffff" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 5 through 9
+ParamSet = SetParamState (hTB20, CHECKED)
+ParamTraits(0).Param			= "dwNumRings"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= SET_RINGS	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LSetNumRings  ( (hTB20), (hTB_Ctrl), Paramset )
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "SetNumRings Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 10 through 11
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LGetNumRings  ( (hTB20), (hTB_Ctrl), Paramset, NumRings )
+
+'--- Results 4 and 5
+teststring.TC_Num = 4
+teststring.Expect_Res = "GetNumRings Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.TC_Num = 5
+teststring.Expect_Res = "Num Rings = " + SET_RINGS
+teststring.Actual_Res = NumRings
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = SET_RINGS then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 12 through 14
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'$ifdef  NotyetValidated
+'$endif 'NotyetValidated
+'******************************************************************************
+'*** END OF TEST																					*
+'******************************************************************************
+
+END 'TAPI_BVT Test
+
+'****************************** On Error Routine ******************************
+
+ErrorHandler:
+    ErrorMessage = "Unexpected error in the TAPI Build Verification Test: "  + CRLF + CRLF + _
+                   "Error:   " + error$										 + CRLF + _
+                   "Error #:"  + str$(Err)									 + CRLF + _
+                   "Line #: "  + str$(Erl)									 + CRLF + _
+                   "File: "    + Erf												+ CRLF + CRLF + _
+                   "Attempt to continue?"
+
+'$IFDEF DEBUG_TEST_SCRIPT
+   if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+      resume next
+   else
+      Stop
+   endif
+'$ELSE
+   Statusbox "Run Time error detected, Test will terminate", _
+				 0,0,0,0, TRUE, TRUE 
+   Sleep 4
+   WritelogItem ("" , ErrorMessage)
+   Stop
+'$ENDIF 'DEBUG_TEST_SCRIPT
+'******************************************************************************
diff --git a/private/tapi/qa/bvt/tapibvt.mst b/private/tapi/qa/bvt/tapibvt.mst
new file mode 100644
index 000000000..4d1a9a16a
--- /dev/null
+++ b/private/tapi/qa/bvt/tapibvt.mst
@@ -0,0 +1,114 @@
+'TB BVT
+'
+''$INCLUDE 'RECORDER.INC'
+'$INCLUDE 'WINAPI.inc'
+'$include 'vars.inc' 'All the global and const declares
+'$INCLUDE 'function.inc'
+'$INCLUDE 'General.INC'
+'$INCLUDE 'Scenario.inc'
+'$INCLUDE 'TBPOKE.H'
+
+
+
+
+'/////////////////////////////////
+'///////  END HEADER /////////////
+'/////////////////////////////////
+
+'prototypes
+'lineInitialze()
+'lineShutdown(hLineApp)
+'lineOpen(hLineApp, dwDeviceID, lphLine, APIVersion, dwExtVersion, dwCallbackInstance, dwPrivileges, dwMediaModes, lpCallParams)
+'
+
+viewport on
+viewport clear
+AssignGlobalVars 'This is a temp. work around. This should be broken up into better functions.
+on KeyPress (27,FSHIFT) call KeyPressHandler
+
+' // Run things
+
+StartApps()
+if WMenuExists ("&Options\Log &structures\by n&one", MY_TIMEOUT) then
+	WMenuSelect("&Options\Log &structures\by n&one", MY_TIMEOUT)
+endif
+
+'do these after apps are running, duh
+hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT)
+GenOut("Getting Some")
+
+hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+'maximize window so button clicks work
+'WMaxWnd (hwndTapiControl.TapiHandle)
+
+GenOut("Logfile= " + chr$(009) + curdir$+sOutLogName)
+if Tracelevel > 2 then
+	GenOut("TAPI Browser handle= " + hex$(hwndTapiControl.TapiHandle))
+	GenOut("GetProcessHeap(): " + hex$(GetProcessHeap()))
+	GenOut("GetCurrentProcess(): " + hex$(GetCurrentProcess()))
+	GenOut("GetCurrentProcessID(): " + hex$(GetCurrentProcessID()))
+	GenOut("GetThread(): " + chr$(009) + hex$(GetCurrentThread()))
+	GenOut("GetCurrentThreadID(): " + hex$(GetCurrentThreadID()))
+end if
+GenOut(chr$(010)+chr$(010)+chr$(010))
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+
+'ensure edit box is clean
+WButtonClick( _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT ) 'do not uncheck this
+
+'********************
+'START YOUR ENGINES
+
+'lineGetProviderList()
+WSetActWnd (hwndTapiControl.TapiHandle)   'scatter a few of these since ESP steals focus
+'End Scenario
+
+'These are all the scenarios. The functions need to be renamed to more
+' descriptive names, this was just a quick way to get them as functions.
+s1
+s2
+s3
+s4
+s5
+s6
+s7
+s8
+s9
+s10
+s11
+s12
+s13
+s14
+s15
+s16
+s17
+s18
+s19
+s20
+s21
+s22
+s23
+s24
+s25
+s26
+s27
+'s28
+s29
+'s30
+
+
+StatusBox Close
+EndMsg()
+End
+
+
+
+
+
+
+
+
diff --git a/private/tapi/qa/bvt/tapibvt3.mst b/private/tapi/qa/bvt/tapibvt3.mst
new file mode 100644
index 000000000..36fe363d0
--- /dev/null
+++ b/private/tapi/qa/bvt/tapibvt3.mst
@@ -0,0 +1,1962 @@
+'TB BVT
+'
+
+
+' WARNING:  This is a piece of junk.  No warrantee implied.
+'spaghetti, not authored by me, just scribbled by me, (ajohnh, some time in '95)
+'
+'$DEFINE MSTEST32
+'$IFDEF  MSTEST32
+    '$INCLUDE 'd:\mt32\inc\declares.inc'
+    '$INCLUDE 'd:\mt32\inc\tbpoke.h'
+'$ELSE
+    '$INCLUDE 'D:\msdev\include\RECORDER.INC'
+    '$include 'D:\msdev\include\winapi.inc'
+    '$INCLUDE 'D:\MSDEV\INCLUDE\TBPOKE.H'
+'$ENDIF
+'//////////////////////////////////////////
+'////// borrowed from my in-work TBPoke:
+'logging
+global sOutLogName          as string
+global sScriptName          as string
+global sComment             as string
+
+global hwndViewport         as long
+global lCountSpace          as long
+global lCountFunc           as long
+global lCountTab            as long
+global MAX_BLANK            as long
+global sFuncString          as string
+
+'end reporting
+global sEndingMessage       as string
+global sEndTitle            as string
+
+'checkbox function
+global sCheckbox            as string
+global lState               as long
+
+'system metrics
+global ScreenX              as long
+global ScreenY              as long
+
+'time value
+global MY_TIMEOUT           as long
+global PACER                as long
+
+global PARAMS               as long
+global NOPARAMS             as long
+
+global hwndTapiControl      as hwndTAPI_CONTROL
+global ScenarioLog          as LOGINITSTRUCT
+
+'$IFDEF MSTEST32
+    global sdwPrivileges(1 to 10)        as string
+    global sdwMediaModes(1 to 30)        as string
+'$ELSE
+    global sdwPrivileges        as array of string
+    global sdwMediaModes        as array of string
+'$ENDIF
+
+global sPrivileges          as string
+global sMediaModes          as string
+
+'$IFDEF MSTEST32
+    global hLineApp(1 to 10)    as  string
+    global hLine(1 to 10)       as  string
+    global hCall(1 to 10)       as  string
+'$ELSE
+    global hLineApp             as array of string
+    global hLine                as array of string
+    global hCall                as array of string
+'$ENDIF
+
+redim sdwPrivileges(1 to 3)     as string
+redim sdwMediaModes(1 to 14)    as string
+
+global sdwNumRings              as string
+
+redim hLineApp(1 to 5)          as string   'limit 5 for now
+redim hLine(1 to 5)             as string
+redim hCall(1 to 5)             as string
+'redim hCall(5)             as string
+
+'$IFDEF MSTEST32
+     global hLineAppIndex            as  string*10
+'$ELSE
+    global hLineAppIndex            as pointer to string
+'$ENDIF
+
+global slpszDestAddress         as string
+
+'counts
+global  ldwPrivilegesBitFlag        as long
+global  ldwMediaModesBitFlag        as long
+global  ldwPrivilegesBitFlagChaos   as long
+global  ldwMediaModesBitFlagChaos   as long
+
+global  lLineApp                    as long
+global  lLine                       as long
+global  lCall                       as long
+
+global  GenCount                    as long
+global  lCountLineApp               as long
+global  GenCount2                   as long
+
+global  OutCount                    as long     'benchmarker
+
+'coverage statistics
+'not yet implemented
+global  TapiStatistic               as TAPI_STATISTIC
+
+global  Tracelevel                  as long     'debug output
+
+global  Benchmark                   as long     'benchmarker
+
+'duh
+hwndTapiControl.TapiHandle          = WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+hwndTapiControl.ParamsCheckbox          =&h000003f9
+hwndTapiControl.LineAppPlusButton       =&h000003ee
+hwndTapiControl.LineAppMinusButton      =&h000003ef
+hwndTapiControl.LinePlusButton          =&h000003f0
+hwndTapiControl.LineMinusButton         =&h000003f1
+hwndTapiControl.CallPlusButton          =&h000003f2
+hwndTapiControl.CallMinusButton         =&h000003f3
+hwndTapiControl.PhoneAppPlusButton      =&h000003f4
+hwndTapiControl.PhoneAppMinusButton     =&h000003f5
+hwndTapiControl.PhoneOpenPlusButton     =&h000003f6
+hwndTapiControl.PhoneOpenMinusButton    =&h000003f7
+hwndTapiControl.ClearEditButton         =&h000003f8
+hwndTapiControl.BlankButton0            =&h000003fa
+hwndTapiControl.BlankButton1            =&h000003fb
+hwndTapiControl.BlankButton2            =&h000003fc
+hwndTapiControl.BlankButton3            =&h000003fd
+hwndTapiControl.BlankButton4            =&h000003fe
+hwndTapiControl.BlankButton5            =&h000003ff
+hwndTapiControl.Listbox0                =&h000003e8     'middle box
+hwndTapiControl.Listbox1                =&h000003e9     'left box
+hwndTapiControl.Editbox                 =&h000003eb     'right box
+
+'// assign
+sOutLogName=curdir$ + "\tapibvt.log"
+lCountSpace=0
+lCountFunc=0
+lCountTab=1
+MAX_BLANK=20                'static
+'const MY_TIMOUT=2*Benchmark '//THIS IS DEFINED AFTER BENCHMARK//
+PACER = 1
+PARAMS=1
+NOPARAMS=0
+const BUSYLINE="9,5569440"                      'ISDN, switch will report busy
+const ANSWERLINE="9,9366991"                        'ITG dial-up modem pool
+const NOLINE=" "
+
+const sOutBenchName="benchmrk.txt"              'benchmarker
+
+'$IFDEF MSTEST32
+    const LogTypeFile=1 '1 is for log to file
+'$ENDIF
+
+'debug; 0=no debug; 3 low, 2 med, 1 high --I know it is backward
+Tracelevel=0
+
+ScreenX=GetSystemMetrics(SM_CXSCREEN)
+ScreenY=GetSystemMetrics (SM_CYSCREEN)
+
+ScenarioLog.LogOutputType = LogTypeFile
+ScenarioLog.MinDetailLevel = 3
+ScenarioLog.ProductVersion = "4"
+ScenarioLog.MachineName = "Undefined"
+ScenarioLog.LogLocation = "tapibvt.log"
+ScenarioLog.Language = "US English"
+
+'WATCH IT
+'dwPrivileges string in the form of sdwPrivileges
+
+            'change these to pointers ASAP
+global NONE as long, MONITOR as long, OWNER as long
+            sdwPrivileges(1)="NONE"
+            NONE=1
+            sdwPrivileges(2)="MONITOR"
+            MONITOR=2
+            sdwPrivileges(3)="OWNER"
+            OWNER=3
+
+'dwMediaModes string in the form of sdwMediaModes
+'edit this, this is bulky & hacked:
+
+global UNKNOWN as long, INTERACTIVEVOICE as long, AUTOMATEDVOICE as long
+global DATAMODEM as long, G3FAX as long, TDD as long, G4FAX as long
+global DIGITALDATA as long, TELETEX as long, VIDEOTEX as long
+global TELEX as long, MIXED as long, ADSI as long, VOICEVIEW as long
+
+            sdwMediaModes(1)="UNKNOWN"
+            UNKNOWN=1
+            sdwMediaModes(2)="INTERACTIVEVOICE"
+            INTERACTIVEVOICE=2
+            sdwMediaModes(3)="AUTOMATEDVOICE"
+            AUTOMATEDVOICE=3
+            sdwMediaModes(4)="DATAMODEM"
+            DATAMODEM=4
+            sdwMediaModes(5)="G3FAX"
+            G3FAX=5
+            sdwMediaModes(6)="TDD"
+            TDD=6
+            sdwMediaModes(7)="G4FAX"
+            G4FAX=7
+            sdwMediaModes(8)="DIGITALDATA"
+            DIGITALDATA=8
+            sdwMediaModes(9)="TELETEX"
+            TELETEX=9
+            sdwMediaModes(10)="VIDEOTEX"
+            VIDEOTEX=10
+            sdwMediaModes(11)="TELEX"
+            TELEX=11
+            sdwMediaModes(12)="MIXED"
+            MIXED=12
+            sdwMediaModes(13)="ADSI"
+            ADSI=13
+            sdwMediaModes(14)="VOICEVIEW"
+            VOICEVIEW=14
+
+dim StartTime as long       'for benchmarker
+dim EndTime as long
+
+'$IFDEF MSTEST32
+    declare function GenTimeOut(OutCount as string) 'generate/generic file-i/o
+    declare function PerfBox(OutCount as string)
+    declare function GenOut(sFuncString as string) 'generate/generic file-i/o
+    declare function GenOutFunc(sFuncString as string) 'generate file-i/o of current declare function
+    declare function GetFunc (sFuncString as string)
+    declare function IsRunaway(sFuncString as string) as string
+    declare function IsComment(sFuncString as string) as string
+    declare function SetCheckboxControl(sCheckbox as string, lState as long) as long
+    declare function HitOK() 'hits the OK button
+    declare function CallAPI(sFuncString as string, lState as long)
+    declare function SelectParam(sFuncString as string)
+    declare function SetParamValue(sFuncString as string)
+    'declare function SetParamValue(sFuncString as string,ParamValue as string)
+    declare function SelectBitFlag(sFuncString as string)
+    declare function EndMsg()
+    declare function CaptureEdit()
+    declare function MiddleSelect() 'not yet:  sFuncString as string      'selects last item in .Listbox0
+    declare function lineGetProviderList()
+    declare function lineGetTranslateCaps()
+    declare function Box(sFuncString as string)
+    'declare function SelectLineApp(lLineApp as long) 'machine
+    declare function StartApps()
+    declare function StopApps()
+    declare function GenChaos() 'all globals
+    declare function lineInitialize(lLineApp as long) 'all globals; stipulate lLineApp for ease of array; for ex: lineInitialize(lLineApp); lLineApp being long
+    declare function LineShutdown(lLineApp as long) 'all globals
+    declare function SelectLineApp(lLineApp as long) 'all globals
+    declare function SelectLine(lLine as long) 'all globals; prep for lineMakeCall
+    declare function lineOpen(lLineApp as long, lLine as long, sPrivileges as string, sMediaModes as string)
+    declare function lineMakeCall(lLine as long, lCall as long, slpszDestAddress as string)
+    declare function lineDrop(lCall as long)
+    declare function lineDeallocateCall(lCall as long)
+    declare function lineAddToConference(lLine as long)
+    declare function lineAnswer()
+    declare function Abort()
+    declare function CheckErr(TAPIErr as string)
+    declare function lineClose(lLine)
+    declare function lineGetNewCalls(lLine as long)
+    declare function lineGetAddressStatus(lLine as long)
+    declare function lineGetCallInfo(lCall as long)
+    declare function lineGetCallStatus(lCall as long)
+    declare function lineSetAppSpecific(lCall as long)
+    declare function lineDial(lCall as long, slpszDestAddress as string)
+    declare function lineGetAddressCaps(lLineApp as long)
+    declare function lineGetAddressID(lLine as long)
+    declare function lineGetDevConfig()
+    declare function lineGetDevCaps(lLineApp as long)
+    declare function lineGetID(lLine as long)		'consider parameter Bit flags here
+    declare function lineGetLineDevStatus(lLine as long)
+    declare function lineGetNumRings(lLine as long)
+    declare function lineGetStatusMessages(lLine as long)
+    declare function lineHold(lCall as long)
+    declare function lineSetNumRings(lLine as long, sdwNumRings as string)
+    declare function lineSetStatusMessages(lLine as long)
+    declare sub      play(text as string)
+'$ENDIF
+'/////////////////////////////////
+'///////  END HEADER /////////////
+'/////////////////////////////////
+
+'prototypes
+'lineInitialze()
+'lineShutdown(hLineApp)
+'lineOpen(hLineApp, dwDeviceID, lphLine, APIVersion, dwExtVersion, dwCallbackInstance, dwPrivileges, dwMediaModes, lpCallParams)
+'
+'BENCHMARKER      'hack hack hack
+'delete benchmark file
+    if exists(sOutLogName) then
+        kill sOutLogName
+    end if
+
+'timer is double precision
+    if exists(sOutBenchName) then
+        kill sOutBenchName
+    end if
+
+    StartTime=timer
+
+    for OutCount=1 to 100
+'        PerfBox(str$(OutCount))
+        GenTimeOut(str$(OutCount))
+    next OutCount
+
+    EndTime=timer
+    Benchmark=Endtime-StartTime
+
+    GenTimeOut("Benchmark: " + str$(Benchmark))
+
+    StatusBox Close
+
+    if Benchmark > 3 then
+        msgbox "YOUR SYSTEM REALLY SUCKS." + chr$(010) + chr$(010) + "Please use a faster system.", MB_OK OR MB_ICONEXCLAMATION, "Slow Bench Warning"
+    end if
+
+    function GenTimeOut(OutCount as string) 'generate/generic file-i/o
+        Open sOutBenchName for append as #1
+            print #1, OutCount + chr$(009)     ' + time
+        Close #1
+    end function
+
+    function PerfBox(OutCount as string)
+        StatusBox "Profiling System Performance..." + chr$(010) + OutCount,0,0,300,100,TRUE,TRUE,"Courier",8,400
+    end function
+
+'// set timout, now that we have benched
+MY_TIMEOUT = 2 + (2 * Benchmark)
+'//END BENCHMARKER
+
+viewport on
+viewport clear
+
+'#if
+'$IFDEF MSTEST32
+        'SET UP TRAP ROUTINE
+        TRAP KeyTrap FROM "T3Trap32.DLL" ALIAS "KeyTrap"  'or T3Trap16.DLL
+             Beep
+             STATUSBOX "HOT KEY PRESSED, ABORTING SCRIPT " + Time$
+             SLEEP 4
+             END    'ABORT SCRIPT
+        END TRAP
+
+        'MAIN SCRIPT
+        SetHotKey ASC("C"),  1	'TRAP Ctrl+c
+        Beep
+        STATUSBOX "Press CTRL+C to see this script ABORT"
+        Sleep  5'SLEEP FOREVER
+        STATUSBOX "This won't display, unless you BREAK and single step"
+
+'$ELSE
+        on KeyPress (27,FSHIFT) call KeyPressHandler
+        sub KeyPressHandler (notification_data AS VARIANT)
+            statusbox close
+            'idyes:6 & idno:7
+            msgbox "Stop tests?", MB_YESNO OR MB_ICONQUESTION OR MB_DEFBUTTON2, "Interruption"
+            if idyes then
+                statusbox close
+                EndMsg()
+                End
+            end if
+        end sub
+
+'$ENDIF
+
+
+' // Run things
+
+StartApps
+
+'do these after apps are running, duh
+hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT)
+GenOut("Getting Some")
+
+hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+'maximize window so button clicks work
+'WMaxWnd (hwndTapiControl.TapiHandle)
+
+GenOut("Logfile= " + chr$(009) + curdir$+sOutLogName)
+if Tracelevel > 2 then
+    GenOut("TAPI Browser handle= " + hex$(hwndTapiControl.TapiHandle))
+    GenOut("GetProcessHeap(): " + hex$(GetProcessHeap()))
+    GenOut("GetCurrentProcess(): " + hex$(GetCurrentProcess()))
+    GenOut("GetCurrentProcessID(): " + hex$(GetCurrentProcessID()))
+    GenOut("GetThread(): " + chr$(009) + hex$(GetCurrentThread()))
+    GenOut("GetCurrentThreadID(): " + hex$(GetCurrentThreadID()))
+end if
+GenOut(chr$(010)+chr$(010)+chr$(010))
+
+WSetActWnd (hwndTapiControl.TapiHandle)
+
+'ensure edit box is clean
+'$IFDEF MSTEST32
+    WButtonClick _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT 'do not uncheck this
+'$ELSE
+    WButtonClick( _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT ) 'do not uncheck this
+'$ENDIF
+
+'********************
+'START YOUR ENGINES
+
+'lineGetProviderList()
+WSetActWnd (hwndTapiControl.TapiHandle)   'scatter a few of these since ESP steals focus
+'End Scenario
+
+'********************
+'********************
+
+FUNKY:
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineMakeCall (stuff)"
+'$ENDIF
+Box("lineMakeCall (verify busy)")
+GenOut("Scenario:" + chr$(009) + "lineMakeCall (verify busy)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineMakeCall lLine, lCall, BUSYLINE        'doing this stranglely for now
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+'lineClose(lLine)
+'lineShutdown(lLineApp)
+
+Box("lineMakeCall, (status)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (status)")
+
+'line should be open from earlier routine
+'lineInitialize(lLineApp)
+'lineOpen(lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM))  'doing this stranglely for now
+lineMakeCall lLine, lCall, ANSWERLINE      'doing this stranglely for now
+
+    lineGetNewCalls(lLine)
+    lineGetAddressStatus(lLine)
+    lineGetCallInfo(lCall)
+    lineGetCallStatus(lCall)
+    lineSetAppSpecific(lCall)
+
+lineDrop(lCall)
+    lineGetCallInfo(lCall)
+    lineGetCallStatus(lCall)
+
+lineDeallocateCall(lCall)
+
+Box("lineMakeCall, (lineGetAppSpecific)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (lineGetAppSpecific)")
+
+lineMakeCall lLine, lCall, ANSWERLINE
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+
+Box("lineMakeCall, (Null lpszDestAddress)")
+GenOut ("Scenario:" + chr$(009) + "lineMakeCall, (Null lpszDestAddress)")
+
+lineMakeCall lLine, lCall, NOLINE
+lineDial lCall, ANSWERLINE
+
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+lineClose(lLine)
+lineShutdown(lLineApp)
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetAddressCaps (default)"
+'$ENDIF
+Box("lineGetAddressCaps (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressCaps (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetAddressCaps(lLineApp)
+lineShutdown(lLineApp)
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetAddressID (default)"
+'$ENDIF
+Box("lineGetAddressID (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressID (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetAddressID(lLine)
+lineClose(lLine)
+lineShutdown(lLineApp)
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetAddressStatus (default)"
+'$ENDIF
+Box("lineGetAddressStatus (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetAddressStatus (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetAddressStatus(lLine)
+lineClose(lLine)
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetDevConfig (default)"
+'$ENDIF
+Box("lineGetDevConfig (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetDevConfig (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetDevConfig 'no arguments, yet
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetDevCaps (default)"
+'$ENDIF
+Box("lineGetDevCaps (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetDevCaps (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineGetDevCaps(lLineApp)
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetID (default)"
+'$ENDIF
+Box("lineGetID (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetID (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetID(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetLineDevStatus (default)"
+'$ENDIF
+Box("lineGetLineDevStatus (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetLineDevStatus (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetLineDevStatus(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetNewCalls (default)"
+'$ENDIF
+Box("lineGetNewCalls (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetNewCalls (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetNewCalls(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetNumRings (default)"
+'$ENDIF
+Box("lineGetNumRings (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetNumRings (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetNumRings(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineGetStatusMessages (default)"
+'$ENDIF
+Box("lineGetStatusMessages (default)")
+GenOut("Scenario:" + chr$(009) + "lineGetStatusMessages (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineGetStatusMessages(lLine)
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineHold (default)"
+'$ENDIF
+Box("lineHold (default)")
+GenOut("Scenario:" + chr$(009) + "lineHold (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineMakeCall lLine, lCall, ANSWERLINE      'doing this stranglely for now
+lineHold(lCall)
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+lineClose(lLine)
+lineShutdown(lLineApp)
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineSetNumRings (default)"
+'$ENDIF
+Box("lineSetNumRings (default)")
+GenOut("Scenario:" + chr$(009) + "lineSetNumRings (default)")
+
+lLineApp=1
+lLine=1
+lCall=1
+sdwNumRings="9"
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineSetNumRings lLine, sdwNumRings
+lineShutdown(lLineApp) 'will close too
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+ENDME:
+
+
+'END 'END 'END
+
+'********************
+'********************
+'lineInitialize with one good pass, then individual null params
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineInitialize (many)"
+'$ENDIF
+Box("lineInitialize (many)")
+WSetActWnd (hwndTapiControl.TapiHandle) 'freshen
+
+for lLineApp= 0 to 4
+    CallAPI "lineInitialize",0
+next lLineApp
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'Scenario "lineGetTranslateCaps"
+'Box("lineGetTranslate")
+' lineGetTranslateCaps()
+'End Scenario
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineShutdown (many)"
+'$ENDIF
+Box("lineShutdown (many)")
+
+for lLineApp= 0 to 4  'note # of lineInitializes, I was too lazy to set a constant for limit
+    MiddleSelect
+    CallAPI "lineShutdown",0
+next lLineApp
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (valid)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (valid)")
+'*** disable params, lineInitialize, lineNegotiateAPIVersion with valids, lineShutdown
+'disable params child
+
+CallAPI "lineInitialize",0
+
+MiddleSelect
+CallAPI "lineNegotiateAPIVersion",0
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (invallow_valhi)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (invallow_valhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invallow and valhi
+'*** disable params, lineShutdown
+'no params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Valid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (vallow_invalhi)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (vallow_invalhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with vallow and invalhi
+'*** disable params, lineShutdown
+'need params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Valid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion (invallow_invalhi)"
+'$ENDIF
+Box("lineNegotiateAPIVersion (invallow_invalhi)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invallow and invalhi
+'*** disable params, lineShutdown
+'no params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwAPILowVersion")
+SetParamValue("Invalid")
+SelectParam("dwAPIHighVersion")
+SetParamValue("Invalid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateAPIVersion_invaldev"
+'$ENDIF
+Box("lineNegotiateAPIVersion (invaldev)")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateAPIVersion with invalid device
+'*** disable params, lineShutdown
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateAPIVersion",1
+
+SelectParam("dwDeviceID")
+SetParamValue("Invalid")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineNegotiateExtVersion"
+'$ENDIF
+Box("lineNegotiateExtVersion")
+'*** disable params, lineInitialize
+'*** enable params, lineNegotiateExtVersion
+'*** disable params, lineShutdown
+'no params
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineNegotiateExtVersion",0
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (none)"
+'$ENDIF
+Box("linOpen_privileges (none)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("None")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (monitor)"
+'$ENDIF
+Box("linOpen_privileges (monitor)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Monitor")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (owner)"
+'$ENDIF
+Box("linOpen_privileges (owner)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_privileges (multi)"
+'$ENDIF
+Box("linOpen_privileges (multi)")
+
+CallAPI "lineInitialize",0
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("None")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Monitor")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+'*** BEGIN dwPrivileges, dwMediaModes strobing
+'*** WATCH THIS: LOOP
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with defaults
+'*** disable params, lineShutdown
+
+'five times
+for lLineApp = 0 to 4
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "lineOpen_MediaModes, sdwPrivileges, dwMediaModes.DATAMODEM (TB default)"
+'$ENDIF
+Box("lineOpen_MediaModes, dwPrivileges.NONE, dwMediaModes.DATAMODEM (TB default)")
+
+CallAPI "lineInitialize",0
+CallAPI "lineOpen",0 'defaults are dwPrivileges.NONE, dwMediaModes.DATAMODEM
+CallAPI "lineShutdown",0
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+next lLineApp
+
+'********************
+'********************
+'***  matrix privileges and MediaModes (STRAIGHT THROUGH)
+'***  dwMediaModes strobing
+'***  [attemts most combos]
+
+for ldwPrivilegesBitFlag = 1 to 3
+'dwPrivileges string in the form of sdwPrivileges
+
+    for ldwMediaModesBitFlag = 1 to 14
+
+    'one day, change this to a cleaner array
+    '********************
+'$IFDEF MSTEST32
+'$ELSE
+    Scenario "lineOpen_MediaModes, (STRAIGHT THROUGH) " + sdwPrivileges(ldwPrivilegesBitFlag) + ", " + sdwMediaModes(ldwMediaModesBitFlag)
+'$ENDIF
+    Box("lineOpen_MediaModes, (STRAIGHT THROUGH) " + sdwPrivileges(ldwPrivilegesBitFlag) + ", " + sdwMediaModes(ldwMediaModesBitFlag))
+
+    CallAPI "lineInitialize",0
+
+    CallAPI "lineOpen",1
+    SelectParam("dwPrivileges")
+    SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+    SelectBitFlag(sdwPrivileges(ldwPrivilegesBitFlag)) 'set Bit flag
+    SelectParam("dwMediaModes")
+    SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+    SelectBitFlag(sdwMediaModes(ldwMediaModesBitFlag))
+    HitOK
+
+    MiddleSelect 'just select anything in the list box
+    CallAPI "lineShutdown",0
+
+    '$IFDEF MSTEST32
+    '$ELSE
+    End Scenario
+    '$ENDIF
+
+    next ldwMediaModesBitFlag
+next ldwPrivilegesBitFlag
+
+'********************
+'********************
+'*** END dwMediaModes (STRAIGHT THROUGH)
+'********************
+'********************
+'********************
+'********************
+
+goto SKIPCHAOS
+
+'********************
+'********************
+'***  matrix privileges and MediaModes (CHAOTIC)
+'***  dwMediaModes strobing
+'***  [try simultaneous operations]
+CHAOS:
+for GenCount=1 to 200
+    'not used: randomize TIMER   'for "bound-ed" chaos
+    '********************
+'$IFDEF MSTEST32
+'$ELSE
+    Scenario ("lineOpen_MediaModes, (CHAOTIC)")
+'$ENDIF
+    Box("lineOpen_MediaModes, (CHAOTIC)")
+    'do 5
+    for lLineApp= 0 to 4
+    LineInitialize(lLineApp) 'returns hLineApp(lLineApp)
+    next lLineApp
+
+    'begin Chaos translation here so I may retain my pretty matrix blocks & to increase hits
+
+    for lLineApp=0 to 4
+    GenChaos                      'all globals
+    SelectLineApp(lLineApp)
+    CallAPI "lineOpen",1
+    SelectParam("dwPrivileges")
+    SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+    SelectBitFlag(sdwPrivileges(ldwPrivilegesBitFlagChaos)) 'set Bit flag
+    SelectParam("dwMediaModes")
+    SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+    SelectBitFlag(sdwMediaModes(ldwMediaModesBitFlagChaos))
+    HitOK
+    next lLineApp
+
+    'cleanup, do 5
+    'WILL NOT WORK WITHOUT HANDLES
+    for lLineApp= 0 to 4
+    LineShutdown(lLineApp)
+    next lLineApp
+
+    '$IFDEF MSTEST32
+    '$ELSE
+    End Scenario
+    '$ENDIF
+next GenCount
+
+'********************
+'********************
+'*** END dwMediaModes (CHAOTIC)
+'********************
+'********************
+'********************
+'********************
+
+SKIPCHAOS:
+
+
+'********************
+'********************
+'********************
+'********************
+
+'********************
+'********************
+'*** disable params, lineInitialize
+'*** enable params, lineOpen with privilege
+'*** disable params, lineShutdown
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "linOpen_MediaModes (privileges_multi)"
+'$ENDIF
+Box("linOpen_MediaModes (privileges_multi)")
+
+CallAPI "lineInitialize",0
+
+
+'as owner
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("DATAMODEM")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("TELETEX")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("TELEX")
+HitOK
+
+CallAPI "lineOpen",1
+SelectParam("dwPrivileges")
+SelectBitFlag("Owner")
+SelectParam("dwMediaModes")
+SelectBitFlag("INTERACTIVEVOICE")
+HitOK
+
+MiddleSelect
+CallAPI "lineShutdown",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+'///////////////
+
+' *************************
+' ***** END TEST CASE *****
+' *************************
+
+
+'///////
+'///////
+'///////
+
+
+'*****  END   END   END   END   END   END  *****
+
+StatusBox Close
+EndMsg
+End
+
+'********************
+'********************
+
+JUNKY:
+
+'$IFDEF MSTEST32
+'$ELSE
+Scenario "Call Unimplemented APIs"
+'$ENDIF
+Box("Call Unimplemented APIs")
+GenOut("Scenario:" + chr$(009) + "Call Unimplemented APIs")
+
+'CallAPI "lineAddToConference",0               'requires two calls on one line
+
+lLineApp=1
+lLine=1
+lCall=1
+lineInitialize(lLineApp)
+lineOpen lLineApp, lLine, sdwPrivileges(OWNER), sdwMediaModes(DATAMODEM)   'doing this stranglely for now
+lineMakeCall lLine, lCall, BUSYLINE        'doing this stranglely for now
+
+
+CallAPI "lineBlindTransfer",0                  'requires call
+CallAPI "lineCompleteCall",0                   'requires call
+'CallAPI "lineCompleteTransfer",0              'requires two calls on one line
+CallAPI "lineDevSpecific",0                    'requires line
+CallAPI "lineDevSpecificFeature",0             'requires line
+CallAPI "lineForward",0                        'requires line
+CallAPI "lineGatherDigits",0                   'requires call
+CallAPI "lineGenerateDigits",0                 'requires call
+CallAPI "lineGenerateTone",0                   'requires call
+
+
+lineDrop(lCall)
+lineDeallocateCall(lCall)
+
+
+CallAPI "lineGetConfRelatedCalls",0
+CallAPI "lineGetRequest",0
+CallAPI "lineMonitorDigits",0
+CallAPI "lineMonitorMedia",0
+CallAPI "lineMonitorTones",0
+CallAPI "lineNegotiateExtVersion",0
+CallAPI "linePark",0
+CallAPI "linePickup",0
+CallAPI "linePrepareAddToConference",0
+CallAPI "lineRedirect",0
+CallAPI "lineRegisterRequestRecipient",0
+CallAPI "lineRemoveFromConference",0
+CallAPI "lineSecureCall",0
+CallAPI "lineSendUserUserInfo",0
+CallAPI "lineSetAppSpecific",0
+CallAPI "lineSetTerminal",0
+CallAPI "lineSetTollList",0
+CallAPI "lineSetupConference",0
+CallAPI "lineSetupTransfer",0
+CallAPI "lineSwapHold",0
+CallAPI "lineUncompleteCall",0
+CallAPI "lineUnhold",0
+CallAPI "lineUnpark",0
+
+'$IFDEF MSTEST32
+'$ELSE
+End Scenario
+'$ENDIF
+
+'********************
+'********************
+
+
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+'********************
+'********************
+
+
+
+'********************
+'********************
+
+'Scenario "lineClose"
+'
+'do not need params
+'SetCheckboxControl(_id(hwndTapiControl.ParamsCheckbox),0
+'MiddleSelect
+'SelectParam("lineClose")
+'play "{ENTER}"
+'
+'CaptureEdit
+'
+'End Scenario
+
+
+
+
+
+
+'
+'/**************************************************/
+'FUNCTIONS
+
+'Outputs, identical until global architecture change
+function GenOut(sFuncString as string) 'generate/generic file-i/o
+' // open logging file
+    box("Calling:  " + sFuncString)
+    Open sOutLogName for append as #1
+        print #1, sFuncString + chr$(009)     ' + time
+        print hwndViewport, sFuncString + chr$(009)     '+ time
+    Close #1
+end function
+
+function GenOutFunc(sFuncString as string) 'generate file-i/o of current function
+' // open logging file
+    box ("Calling:  " + sFuncString)
+    Open sOutLogName for append as #1
+        print #1, sFuncString + chr$(009) + time$
+        print hwndViewport, sFuncString + chr$(009) + time$
+    Close #1
+end function
+
+
+'for TBPoke only: GetFunc runs the state core, remember to trim tabs
+' this was from TBPoke, but it has been modified not to look for script file
+function GetFunc (sFuncString as string)
+        sFuncString=""
+        'count the entries
+        lCountFunc=lCountFunc+1
+        sFuncString=trim$(sFuncString,009)      'trim tabs
+        sFuncString=trim$(sFuncString," ")      'whatever MST calls a space
+        sFuncString=trim$(sFuncString,255)      'trim truespace
+        if sFuncString=chr$(000) then sFuncString="COMMENT" 'ASCII null
+end function
+
+'Check for runaway file i/o read; consider it "IsCarriageReturn"
+function IsRunaway(sFuncString as string) as string
+    if sFuncString="" then
+        lCountSpace=lCountSpace+1               'begin counting blank entries
+        if lCountSpace=MAX_BLANK then sFuncString="END"
+    else
+        lCountSpace=0
+    end if
+end function
+
+'Find comments
+function IsComment(sFuncString as string) as string
+    select case(ucase$(left$(sFuncString,1)))
+        case ";"
+            sFuncString="COMMENT"
+        case "#"
+            sFuncString="COMMENT"
+        case "'"
+            sFuncString="COMMENT"
+        case ""
+            sFuncString="COMMENT"
+            'IsRunaway(sFuncString)             'count blanks to prevent infinite loop
+            'GenOut(sFuncString, hwndViewport)
+    end select
+
+    'find other comments
+    select case(left$(sFuncString,2))
+        case "//"
+            sFuncString="COMMENT"
+    end select
+
+    'find more comments, I know it is not model code, shut up
+    select case(left$(sFuncString,4))
+        case "REM "                         'with space
+            sFuncString="COMMENT"
+    end select
+
+end function 'IsComment
+
+
+'toggle checkbox state, will leave focus on sCheckbox
+function SetCheckboxControl(sCheckbox as string, lState as long) as long
+    select case(lState)
+        case 0
+            If WCheckState(sCheckbox) = CHECKED then
+                WCheckUnCheck sCheckbox,MY_TIMEOUT
+                if Tracelevel>=3 then GenOut ("Unchecking checkbox "+sCheckbox)
+            else
+                if Tracelevel>=2 then GenOut ("Error: Attempt to WCheckUnCheck unchecked checkbox "+sCheckbox)
+            end if
+        case 1
+            If WCheckState(sCheckbox) = UNCHECKED then
+                WCheckCheck sCheckbox,MY_TIMEOUT
+                if Tracelevel>=3 then GenOut ("Checking checkbox "+sCheckbox)
+            else
+                if Tracelevel>=2 then GenOut ("Error: Attempt to WCheckCheck checked checkbox "+sCheckbox)
+            end if
+    end select
+end function
+
+function HitOK 'hits the OK button
+    WButtonClick "OK", MY_TIMEOUT
+    CaptureEdit
+
+end function
+
+function CallAPI(sFuncString as string, lState as long)
+    if lState > 1 then GenOut("Error:  lState is exceeds value of 1.")
+    GenOut("API:" + chr$(009) + sFuncString)
+    SetCheckboxControl _id(hwndTapiControl.ParamsCheckbox),lState
+    WListItemDblClk _id(hwndTapiControl.Listbox1), sFuncString, MY_TIMEOUT
+    if lState=0 then CaptureEdit  'so calling the API w/ default params gens output & HitOK gens output (see HitOK)
+end function
+
+function SelectParam(sFuncString as string)
+    GenOut("Parameter:" + chr$(009) + sFuncString)
+    WListFind "Parameters:", MY_TIMEOUT
+    WListItemDblClk "Parameters:", sFuncString, MY_TIMEOUT
+end function
+
+function SetParamValue(sFuncString as string)
+        GenOut("Parameter Value:" + chr$(009) + sFuncString)
+        WEditSetFocus "Value:", MY_TIMEOUT
+        select case(ucase$(sFuncString))
+            case ucase$("Null")
+                play "00000000"
+            case ucase$("Valid")  'WATCH THIS:  dankn often displays English here
+                'leave it alone, default is VALID or valid value
+                'play "{DOWN}"
+                'play "{DOWN}"
+            case ucase$("Invalid")
+                play "ffffffff"
+            case else
+                GenOut("Error:  Bad SetParamValue parameter:  " + sFuncstring)
+        end select
+end function
+
+'global ParamValue as string 'put this at front
+'function SetParamValue(sFuncString as string,ParamValue as string)
+'   SelectParam(sFuncString as string)
+
+function SelectBitFlag(sFuncString as string)
+    GenOut("Select Bit Flag: " + sFuncString)
+    'lineOpen has defaults: dwPrivileges.NONE, dwMediaModes.DATAMODEM
+    WListFind "Bit flags:", MY_TIMEOUT
+    WListItemDblClk "Bit flags:", sFuncString, MY_TIMEOUT
+    'BitFlag[] sFuncString  ;;;; soon add cleanup structure
+end function
+
+function EndMsg
+    sEndingMessage="TB BVT ended."
+    sEndTitle="Completed"
+    msgbox sEndingMessage, MB_OK, sEndTitle
+end function
+
+function CaptureEdit
+        'play "{ENTER}" 'assuming child window is in focus and OK button is selected
+        'GenOut("********************  TAPI Report  ********************")
+        'GenOut(ListText(_id(hwndTapiControl.Listbox0, MY_TIMEOUT))
+        sleep 0.1                               'take an i/o break
+        GenOut("TAPI Browser reports: ")
+        GenOut(EditText(_id(hwndTapiControl.Editbox) + chr$(010), MY_TIMEOUT))
+        'GenOut("********************  END REPORT  *********************" + chr$(010 + chr$(010)
+        WButtonClick _id(hwndTapiControl.ClearEditButton), MY_TIMEOUT
+end function
+
+'>>++++
+function MiddleSelect 'not yet:  sFuncString as string      'selects last item in .Listbox0
+        WListSetFocus _id(hwndTapiControl.Listbox0), MY_TIMEOUT
+        'not yet:  WListItemDblClk(_id(hwndTapiControl.Listbox0, sFuncString, MY_TIMEOUT)
+        play "{PGDN}"
+end function
+
+function lineGetProviderList
+    CallAPI "lineGetProviderList",0
+end function
+
+function lineGetTranslateCaps
+    CallAPI "lineGetTranslateCaps",0
+    Box("Dumping buffer")
+    sleep 1
+    Box("Dumping buffer")
+    sleep 1
+end function
+
+function Box(sFuncString as string)
+    'disabled, bug in statusbox is stealing focus
+    'StatusBox sFuncString + chr$(009),ScreenX-300,ScreenY-75,300,75,FALSE,FALSE,"Courier",8,400
+end function
+
+'function SelectLineApp(lLineApp as long) 'machine
+'   'later revise to allow real-time monitor of handles
+'   'select valid lineApp lLineApp, searching top to bottom, exit out having made selection
+'   'It does look bad.  If dankn's conventions stray too far, this will fail
+'   MiddleSelect
+'   if lLineApp > WListCount(_id(hwndTapiControl.Listbox0, MY_TIMEOUT) then
+'       GenOut("Error: BAD ONE, lLineApp of " + str$(lLineApp) + " exceeding WListCount of " + str$(WListCount(_id(hwndTapiControl.Listbox0, MY_TIMEOUT)))
+'       beep
+'       beep
+'       beep
+'       goto SKIPSelectLineApp
+'   end if
+'   play "{PGUP}"
+'   lCountLineApp=WListCount(_id(hwndTapiControl.Listbox0, MY_TIMEOUT)
+'   for GenCount = 1 to lCountLineApp
+'       'do not down-arrow yet since first item is selected
+'       sLineApp=ListItemText(_id(hwndTapiControl.Listbox0, WListIndex(_id(hwndTapiControl.Listbox0,MY_TIMEOUT),MY_TIMEOUT)
+'       select case (left$(ucase$(sLineApp),9))
+'           case ucase$("LineApp=x")    'first half matches (this may happen with invalids too, so look on
+'               select case (val(right$(sLineApp,8)))
+'                   case 0              'is an invalid, so index
+'                       play "{DOWN}"
+'                   case else           'hex value is non-zero, let us use it
+'                       select case (WListIndex(_id(hwndTapiControl.Listbox0,MY_TIMEOUT))
+'                           case (lLineApp) 'is this the index requested?
+'                               GenCount=lCountLineApp  'return 'get out, leaving it focused
+'                           case else       'is not lLineApp, so index
+'                           play "{DOWN}"
+'                       end select
+'               end select
+'           case else                       'is not "LineApp=x", so index
+'               play "{DOWN}"
+'       end select 'THIS MESS DONE SINCE this shitty beta has horrible if-then nesting errors (not me!)
+'   next GenCount
+'   SKIPSelectLineApp:  'skip if lLineApp is bogus value
+'end function
+
+function StartApps
+    run "MTVIEW.EXE", nowait, SW_NORMAL
+    hwndViewport = WFndWnd("Visual Test Viewport",FW_DEFAULT,5) 'find Visual Test Viewport
+    if hwndViewport = 0 then
+'$IFDEF MSTEST32
+        GenOut("MTVIEW.EXE application failed to start")
+'$ELSE
+        fail "MTVIEW.EXE application failed to start"
+'$ENDIF
+    end if
+
+    run "TB14.EXE" , nowait , SW_MAXIMIZE                       'NOWAIT SW_NORMAL
+    sleep 2
+    hwndTapiControl.TapiHandle= WFndWnd("TAPI32 Browser", FW_DEFAULT,5) 'find TAPI32 BROWSER
+    if hwndTapiControl.TapiHandle= 0 then
+'$IFDEF MSTEST32
+        GenOut("TB14.EXE TAPI Brower failed to start")
+'$ELSE
+        fail "TB14.EXE TAPI Brower failed to start"
+'$ENDIF
+    end if
+end function
+
+'not used:
+function StopApps
+    hwndViewport = WFndWnd("Visual Test Viewport", FW_DEFAULT or FW_FOCUS)
+    if hwndViewport <> 0 then
+        Play "%{F4}" 'alt f4
+    end if
+
+    hwndTapiControl.TapiHandle = WFndWnd("TAPI32 Browser", FW_DEFAULT or FW_FOCUS)
+    if hwndTapiControl.TapiHandle <> 0 then
+        Play "%{F4}" 'alt f4
+    end if
+end function
+
+function GenChaos 'all globals
+    ldwPrivilegesBitFlagChaos=(int(rnd*3)+1)
+    ldwMediaModesBitFlagChaos=(int(rnd*14)+1)
+    Box("lineOpen_MediaModes, (CHAOS) LineApp "  + str$(lLineApp) + ", " + sdwPrivileges(ldwPrivilegesBitFlagChaos) + ", " + sdwMediaModes(ldwMediaModesBitFlagChaos))
+    GenOut("lineOpen_MediaModes, (CHAOS)" + str$(ldwPrivilegesBitFlagChaos) +","+ str$(ldwMediaModesBitFlagChaos) + " LineApp " + str$(lLineApp) + ", " + sdwPrivileges(ldwPrivilegesBitFlagChaos) + ", " + sdwMediaModes(ldwMediaModesBitFlagChaos))
+end function
+
+function lineInitialize(lLineApp as long) 'all globals; stipulate lLineApp for ease of array; for ex: lineInitialize(lLineApp); lLineApp being long
+    CallAPI "lineInitialize",0 'create a LineApp
+
+    'lineApp is now open...
+    CallAPI "lineOpen",1       'cheat, use TB to provide clean handle
+    SelectParam("hLineApp")     'select the hLineApp of Params:
+    WEditSetFocus "Value:", MY_TIMEOUT 'set focus, no real reason
+    hLineApp(lLineApp)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+    if Tracelevel >= 1 then GenOut("New hLineApp=" + chr$(009) + hLineApp(lLineApp))
+    Abort
+end function
+
+function LineShutdown(lLineApp as long) 'all globals
+    CallAPI "lineShutdown",1
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT 'ready to enter handle
+    play hLineApp(lLineApp)
+    HitOK
+end function
+
+function SelectLineApp(lLineApp as long) 'all globals
+    MiddleSelect
+    WListItemClk _id(hwndTapiControl.Listbox0), "LineApp=x" + (hLineApp(lLineApp)), MY_TIMEOUT
+end function
+
+'not implemented
+function SelectLine(lLine as long) 'all globals; prep for lineMakeCall
+    MiddleSelect
+    ' (_id(hwndTapiControl.Listbox0, "Line=x" + (hLineApp(lLineApp)), MY_TIMEOUT)
+end function
+
+function lineOpen(lLineApp as long, lLine as long, sPrivileges as string, sMediaModes as string)
+    CallAPI "lineOpen",1       'child window is open and focused
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT
+    play hLineApp(lLineApp)     'handle of LineApp
+
+    SelectParam("dwPrivileges")
+    GenOut("Clearing default on following line:")
+    SelectBitFlag(sdwPrivileges(1)) 'clear default NONE (1)
+    SelectBitFlag(sPrivileges) 'set Bit flag
+    SelectParam("dwMediaModes")
+    GenOut("Clearing default on following line:")
+    SelectBitFlag(sdwMediaModes(4)) 'clear default DATAMODEM (4)
+    SelectBitFlag(sMediaModes)
+
+    HitOK
+
+    CallAPI "lineMakeCall",1  'cheat, use to get hLine value
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT         'set focus, no real reason
+    hLine(lLine)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+    if Tracelevel >= 1 then GenOut("New hLine=" + chr$(009) + hLine(lLine))
+    Abort                                 'abort child
+end function
+
+function lineMakeCall(lLine as long, lCall as long, slpszDestAddress as string)
+    CallAPI "lineMakeCall",1               'child window is open and focused
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+
+    SelectParam("lpszDestAddress")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play slpszDestAddress
+    WButtonClick  "OK", MY_TIMEOUT
+    sleep 5
+
+    'hide dialog
+    if slpszDestAddress <> " " then
+        WButtonFind "&Talk", 15      'use a way to wait for dialog
+        WSetActWnd (hwndTapiControl.TapiHandle) 'refocus TB
+        sleep 1
+    end if
+
+    'if slpszDestAddress <> " " then
+    '   WSetWndPos ( WFndWnd("Call Status", FW_DEFAULT), ScreenX, ScreenY) 'find Call Status window
+    '   sleep 15
+    'end if
+
+    'if slpszDestAddress <> " " then            'being caution of Talk/Hangup dialog
+    '   sleep 12
+    '   WButtonClick( "&Talk", MY_TIMEOUT + 10
+    'end if
+    '
+
+    CallAPI "lineDrop",1                   'cheat, use to get hCall value
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT
+    hCall(lCall)=EditText("Value:", MY_TIMEOUT) 'get pointer/handle string
+    if Tracelevel >= 1 then GenOut("New hCall=" + chr$(009) + hCall(lCall))
+    Abort
+end function
+
+function lineDrop(lCall as long)
+    CallAPI "lineDrop",1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineDeallocateCall(lCall as long)
+    CallAPI "lineDeallocateCall",1
+    Selectparam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify handle
+    HitOK
+end function
+
+'not implemented; in-work
+function lineAddToConference(lLine as long)
+    CallAPI "lineAddToConference",1
+    Selectparam("hLine")
+    'blah
+end function
+
+function lineAnswer
+end function
+
+function Abort
+    play "{ESC}" 'abort child
+    GenOut("Aborted child window:  OK, probably getting handle here." + chr$(010))
+end function
+
+'not implemented
+function CheckErr(TAPIErr as string)
+'lineAddProvider returned LINEERR_INVALPOINTER
+end function
+
+function lineClose(lLine)
+    CallAPI "lineClose",1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+    HitOK
+end function
+
+function lineGetNewCalls(lLine as long)
+    CallAPI "lineGetNewCalls",1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+    HitOK
+end function
+
+function lineGetAddressStatus(lLine as long)
+    CallAPI "lineGetAddressStatus",1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hLine(lLine)                       'specify the handle
+    HitOK
+end function
+
+function lineGetCallInfo(lCall as long)
+    CallAPI "lineGetCallInfo", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineGetCallStatus(lCall as long)
+    CallAPI "lineGetCallStatus", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus, no real reason
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineSetAppSpecific(lCall as long)
+    CallAPI "lineSetAppSpecific", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify the handle
+    HitOK
+end function
+
+function lineDial(lCall as long, slpszDestAddress as string)
+    CallAPI "lineDial", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)                       'specify the handle
+
+    SelectParam("lpszDestAddress")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play slpszDestAddress
+
+    WButtonClick  "OK", MY_TIMEOUT
+    sleep 5
+
+    'hide dialog
+    WButtonFind "&Talk", 15      'use a way to wait for &Talk dialog
+    WSetActWnd (hwndTapiControl.TapiHandle) 'refocus TB
+    sleep 1
+
+    'WButtonClick( "&Talk", MY_TIMEOUT + 10
+end function
+
+function lineGetAddressCaps(lLineApp as long)
+    CallAPI "lineGetAddressCaps", 1
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLineApp(lLineApp)
+    HitOK
+end function
+
+function lineGetAddressID(lLine as long)
+    CallAPI "lineGetAddressID", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetDevConfig
+    'ensure a LineApp is open when calling lineGetDevConfig
+    CallAPI "lineGetDevConfig", 0
+end function
+
+function lineGetDevCaps(lLineApp as long)
+    Box("Dumping buffer")
+    CallAPI "lineGetDevCaps", 1
+    SelectParam("hLineApp")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLineApp(lLineApp)
+    HitOK
+end function
+
+function lineGetID(lLine as long)       'consider parameter Bit flags here
+    CallAPI "lineGetID", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetLineDevStatus(lLine as long)
+    CallAPI "lineGetLineDevStatus", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetNumRings(lLine as long)
+    CallAPI "lineGetNumRings", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineGetStatusMessages(lLine as long)
+    CallAPI "lineGetStatusMessages", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+function lineHold(lCall as long)
+    CallAPI "lineHold", 1
+    SelectParam("hCall")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hCall(lCall)
+    HitOK
+end function
+
+function lineSetNumRings(lLine as long, sdwNumRings as string)
+    CallAPI "lineSetNumRings", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+
+    SelectParam("dwNumRings")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play sdwNumRings
+
+    HitOK
+end function
+
+function lineSetStatusMessages(lLine as long)
+    CallAPI "lineSetStatusMessages", 1
+    SelectParam("hLine")
+    WEditSetFocus "Value:", MY_TIMEOUT     'set focus
+    play hLine(lLine)
+    HitOK
+end function
+
+sub play(text as string)
+    dokeys text
+end sub
+
+
+
+
+'truly the end
diff --git a/private/tapi/qa/bvt/tapidesc.txt b/private/tapi/qa/bvt/tapidesc.txt
new file mode 100644
index 000000000..8c18ab9db
--- /dev/null
+++ b/private/tapi/qa/bvt/tapidesc.txt
@@ -0,0 +1,1066 @@
+                       TAPI BUILD VERIFICATION TEST SPECIFICATION.
+
+                       Test Spec written by Aaron Ridenour a-aaronr
+                       Test Scripts written by Ron Rohr a-rrohr
+                       July 11, 1996
+		
+******************** Test Description ***************************
+
+This Test has been implemented with Visual Test 4.0a. 
+There are 4 files associated with this test.
+TAPI_BVT.MST - Main test script.
+TAPI_BVT.INC - Contains all TAPI_BVT procedures called from the main script.
+TAPI_API.INC - Contains all Const and Type definitions used in the test.
+TAPILOG.INC  - Contains all file output procedures.
+
+******************** Prerequisites ******************************
+
+1) TAPI Browser 2.0 (tb20.exe) must be in the System32 windows subdirectory.
+2) The Test PC must have a modem connected and installed.
+3) Unimdm.tsp service provider must be in the System32 windows subdirectory.
+
+******************* Begin Test Discriptions *********************
+
+***********************************************************************************
+**** Test Case - 4 lineOpen and lineClose with all privileges
+***********************************************************************************
+
+STEPS:  // open line with no privileges
+1 - Run TB
+2 - on the toolbar, press [LAp+]
+3 - click the [Parms] checkbox on, on the toolbar
+4 - on the toolbar, press [Line+]
+5 - In the dialog box, select [dwPrivileges]
+6 - Choose [NONE] in the [Bit flags] listbox
+7 - Press OK
+
+RESULTS:
+1 - Should get a "lineOpen returned SUCCESS" in the results window.
+2 - Line should be listed as DialOut
+
+STEPS:  // open line as monitor
+8  - Press [Line-]
+9  - Press OK on the dialog
+10 - on the toolbar, press [LAp-]
+11 - Press OK on the dialog
+12 - Press [LAp+]
+13 - Press OK on the dialog
+14 - on the toolbar, press [Line+]
+15 - In the dialog box, select [dwPrivileges]
+16 - Choose [MONITOR] in the [Bit flags] listbox
+17 - Press OK
+
+RESULTS:
+3 - Should get a "lineOpen returned SUCCESS" in the results window.
+4 - Line should be listed as Monitor
+
+STEPS:  // open line as owner
+18 - Press [Line-]
+19 - Press OK on the dialog
+20 - on the toolbar, press [LAp-]
+21 - Press OK on the dialog
+22 - Press [LAp+]
+23 - Press OK on the dialog
+24 - on the toolbar, press [Line+]
+25 - In the dialog box, select [dwPrivileges]
+26 - Choose [OWNER] in the [Bit flags] listbox
+27 - Press OK
+
+RESULTS:
+5 - Should get a "lineOpen returned SUCCESS" in the results window.
+6 - Line should be listed as DialInOut
+
+STEPS:
+28 - On toolbar press [Line-]
+29 - In dialog box press [OK]
+30 - On toolbar press [LAp-]
+31 - In dialog box press [OK]
+32- Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 5 lineNegotiateAPIVersion / 1.4
+***********************************************************************************
+
+STEPS: // default call should get 1.4 version # returned
+1 - Run TB
+2 - turn off the [Parms] checkbox
+3 - Choose [LAp+]
+4 - turn on the [Parms] checkbox
+5 - dblclick [lineNegotiateAPIVersion]
+6 - Press OK
+
+RESULTS:
+1 - should get the following in the results window
+    lineNegotiateAPIVersion returned SUCCESS
+      APIVersion=x10004
+      extID.ID0=x0, .ID1=x0, .ID2=x0, .ID3=x0, 
+
+STEPS: //ensure if LOW is > high ver #, this fails.
+7 - dblclick [lineNegotiateAPIVersion]
+8 - click [dwAPILowVersion]
+9 - enter 00030000
+10 - Press OK
+
+RESULTS:
+2 - should get the following in the results window
+    lineNegotiateAPIVersion returned LINEERR_INCOMPATIBLEAPIVERSION
+  
+
+STEPS: //ensure if HIGH is both < high ver # and > low ver# we get a match
+11 - dblclick [lineNegotiateAPIVersion]
+12 - click [dwAPIHighVersion]
+13 - enter 00010003
+14 - Press OK
+
+RESULTS:
+3 - should get the following in the results window
+    lineNegotiateAPIVersion returned SUCCESS
+      APIVersion=x10003
+      extID.ID0=x0, .ID1=x0, .ID2=x0, .ID3=x0, 
+
+STEPS:
+15 - On toolbar click on [LAp-]
+16 - Close TB
+
+***********************************************************************************
+**** Test Case - 8 lineGetDevCaps 
+***********************************************************************************
+
+STEPS: // Verify lineGetDevCaps return for valid device ID
+1 - Run TB
+2 - On toolbar press [LAp+] button
+3 - In function listbox double-click on lineGetDevCaps
+
+RESULTS: 
+1 - "lineGetDevCaps returned SUCCESS" should be displayed.  For further verification, 
+see example below.
+
+STEPS: //Verify lineGetDevCaps return for invalid device ID
+4 - On toolbar check Params box
+5 - In function listbox double-click on lineGetDevCaps
+6 - On dialog box select dwDeviceID
+7 - Set Value to ffffffff
+8 - Press [OK]
+
+RESULT: "lineGetDevCaps returned LINEERR_BADDEVICEID" should be displayed
+
+STEPS:
+9 - On toolbar press [LAp-] button
+10 - Close TB
+
+*********************************
+Example of lineGetDevCaps return:
+*********************************
+
+lineGetDevCaps returned SUCCESS
+LINEDEVCAPS
+  dwTotalSize=x1000
+  dwNeededSize=x180
+  dwUsedSize=x180
+  dwProviderInfoSize=x3e
+  dwProviderInfoOffset=xf0
+    646e6957 2073776f 656c6554 6e6f6870  Windows Telephon
+    65532079 63697672 72502065 6469766f  y Service Provid
+    66207265 5520726f 6576696e 6c617372  er for Universal
+    646f4d20 44206d65 65766972 xxxx0072   Modem Driver.
+  dwPermanentLineID=x18368
+  dwLineNameSize=x17
+  dwLineNameOffset=x12e
+    61726150 6c656c6c 62616320 6f20656c  Parallel cable o
+    504c206e xx003154 xxxxxxxx xxxxxxxx  n LPT1.
+  dwStringFormat=x1, ASCII
+  dwAddressModes=x1, ADDRESSID 
+  dwNumAddresses=x1
+  dwBearerModes=x48, DATA PASSTHROUGH 
+  dwMaxRate=x1c200
+  dwMediaModes=x10, DATAMODEM 
+  dwDevCapFlags=x60, CLOSEDROP DIALBILLING 
+  dwMaxNumActiveCalls=x1
+  dwRingModes=x1
+  dwLineStates=x14406ce, RINGING CONNECTED DISCONNECTED 
+    INSERVICE OUTOFSERVICE OPEN CLOSE REINIT TRANSLATECHANGE 
+    REMOVED 
+  dwDevSpecificSize=x3b
+  dwDevSpecificOffset=x145
+    00000001 00000008 74737953 435c6d65  ........System\C
+    65727275 6f43746e 6f72746e 7465536c  urrentControlSet
+    7265535c 65636976 6c435c73 5c737361  \Services\Class\
+    65646f4d 30305c6d xx003130 xxxxxxxx  Modem\0001.
+  dwLineFeatures=x8, MAKECALL
+
+Note: For this example, a Creative Labs Phoneblaster and Unimodem service provider were 
+employed.  The LINEDEVCAPS return should be compared to installed modem and service 
+provider to verify correctness of lineGetDevCaps API.
+
+***********************************************************************************
+**** Test Case - 9 lineMakeCall - privileges = none, monitor, owner
+***********************************************************************************
+
+STEPS: // Call with privilege=NONE
+1 - Run TAPI Browser
+2 - On toolbar, press [LAp+] button
+3 - On toolbar, check Params box
+4 - On toolbar, press [Line+]
+5 - In lineOpen dialog box, select dwPrivileges
+6 - Under bit flags, select NONE
+7 - On toolbar, press [Call+]
+8 - On lineMakeCall Dialog box press [OK]
+
+RESULT: 
+1) The call should PROCEEDING, with the following text returned:
+
+   lineMakecall returned x1
+   received LINE_REPLY : hDev=x0, cbInst=x0
+     p1=x1,
+     p2=x0,
+     p3=x0
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x8, DIALTONE
+     p2=x20, UNAVAIL
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x10, DIALING
+     p2=x0,
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x200 PROCEEDING
+     p2=x0,
+     p3=x0,
+
+[Note: x_______ is the Call handle]
+
+STEPS: // Call with privilege=MONITOR
+9 - On toolbar, press [Call-] button
+10 - In dialog box, press [OK]
+11 - On toolbar press [Line-]
+12 - In dialog box press [OK]
+13 - On toolbar, press [Line+]
+14 - In lineOpen dialog box, select dwPrivileges
+15 - Under bit flags, select MONITOR
+16 - On toolbar, press [Call+]
+17 - On lineMakeCall Dialog box press [OK]
+
+RESULT: 
+2 - The call should PROCEEDING (with similar text as described above).
+
+
+STEPS: // Call with privilege=MONITOR
+18 - On toolbar, press [Call-] button
+19 - In dialog box, press [OK]
+20 - On toolbar press [Line-]
+21 - In dialog box press [OK]
+22 - On toolbar, press [Line+]
+23 - In lineOpen dialog box, select dwPrivileges
+24 - Under bit flags, select OWNER
+25 - On toolbar, press [Call+]
+26 - On lineMakeCall Dialog box press [OK]
+
+
+RESULT: 
+3 - The call should PROCEEDING (with similar text as described above).
+
+27 - On toolbar, uncheck the Params box
+28 - On toolbar, press [Call-]
+29 - On toolbar press [Line-]
+30 - On toolbar press [LAp-]
+31 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 10 lineMakeCall - line unavalable
+***********************************************************************************
+
+STEPS: // Ensure proper return for call attempted on line already in use
+1 - Run TB
+2 - On toolbar press [LAp+]
+3 - On toolbar press [Line+]
+4 - On toolbar press [Call+]
+          Note: Ensure call is active for steps 5 through 7
+5 - On toolbar press [LAp+]
+6 - On toolbar press [Line+]
+7 - On toolbar press [Call+]
+
+RESULTS:
+1 - "lineMakeCall returned LINEERR_CALLUNAVAIL" should be returned
+
+STEPS:
+
+8 - Click on bottom Line handle
+9 - On toolbar press [Line-]
+10 - Click on bottom LineApp handle
+11 - On toolbar press [LAp-]
+12 - On toolbar press [Call-]
+13 - On toolbar press [Line-]
+14 - On toolbar press [LAp-]
+15 - Close TB
+
+***********************************************************************************
+**** Test Case - 13 lineDrop  - with active call  
+***********************************************************************************
+
+STEPS:  // Verify successful line drop after initiating call
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - On toolbar press [Line+] button
+4 - On toolbar press [Call+] button
+5 - Wait for call state to be proceeding or connected
+6 - In function listbox double-click on lineDrop
+
+RESULTS:
+1 - Return should LINE_CALLSTATE as IDLE
+
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x1, IDLE
+     p2=x0,
+     p3=x0,
+
+STEPS:
+7 - On toolbar press [Call-] button
+8 - On toolbar press [Line-] button
+9 - On toolbar press [LAp-] button
+10 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 14 lineDeallocate - w/ active call	
+***********************************************************************************
+
+STEPS:  // Verify successful line deallocation
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - On toolbar press [Line+] button
+4 - On toolbar press [Call+] button
+5 - Wait for call state to be proceeding or connected
+6 - In function listbox double-click on lineDrop
+7 - In function listbox double-click on lineDeallocateCall
+
+RESULTS:
+1 - "lineDeallocateCall returned SUCCESS" should be displayed
+
+STEPS:
+8 - On toolbar press [Line-] button
+9 - On toolbar press [LAp-] button
+10 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 15 lineShutDown - with active call  
+***********************************************************************************
+
+STEPS:  // Verify successful line drop after initiating call
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - On toolbar press [Line+] button
+4 - On toolbar press [Call+] button
+5 - In function listbox double-click on lineShutdown
+
+RESULTS:
+1 - "lineShutdown returned SUCCESS" should be displayed
+
+STEPS:
+6 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 16 lineClose - with active call  
+***********************************************************************************
+
+STEPS:  // Verify successful line close after initiating call
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - On toolbar press [Line+] button
+4 - On toolbar press [Call+] button
+5 - On toolbar press [Line-] button
+
+RESULTS:
+1 - "lineClose returned SUCCESS" should be displayed
+
+STEPS:
+6 - On toolbar press [LAp-]
+7 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 21 lineSetCurrentLocation - with valid and invalid Location IDs
+***********************************************************************************
+
+Note: For the first segment of this test to be run successfully, a valid location must 
+exist.  Specifically for Step 6 (below) a location must be entered into the Dialing 
+Properties on the My Location tab.  If this entry is not the first location entered 
+into Dialing Proprties (lineTranslateDialog / telephon.cpl), then the value in Step 6 
+must be changed accordingly. 
+
+
+STEPS:  // Verify return for VALID location
+1 - Run TB
+2 - On toolbar press [LAp+] button
+3 - Activate Params box
+4 - In function listbox double-click on lineSetCurrentLocation
+5 - In dialog box select [dwLocation]
+6 - Set Value to 00000001
+7 - Press [OK] button
+
+RESULTS:
+1 - "lineSetCurrentLocation returned SUCCESS" should be displayed
+2 - LINE_LINEDAVSTATE REINIT should be issued
+
+STEPS:  // Verify return for INVALID location
+8 - In function listbox double-click on lineSetCurrentLocation
+9 - In dialog box select [dwLocation]
+10 - Set Value to ffffffff
+11 - Press [OK] button
+
+RESULTS:
+3 - "lineSetCurrentLocation returned LINEERR_INVALLOCATION" should be displayed
+
+
+STEPS:
+12 - On toolbar press [LAp-] button
+13 - In dialog box press [OK]
+14 - Close TB
+
+***********************************************************************************
+**** Test Case - 22 lineGetCountry
+***********************************************************************************
+
+STEPS:  // Verify entire country list can be returned
+1 - Run TB
+2 - On toolbar check Params box
+3 - In function listbox double-click lineGetCountry
+4 - In dialog box select dwCountryID parameter
+5 - Set value to 00000000
+6 - Press [OK] button
+
+RESULT:
+1 - "lineGetCountry returned SUCCESS" should be displayed
+
+Note: LINECOUNTRYLIST will not display all countries in the list; this is due to the TAPI 
+Browser buffer size.  The dwNeededSize will indicate a large value (i.e., 3e45) which 
+exceeds the dwTotalSize (i.e., the buffer, which is 1000).
+
+STEPS: //Verify country list can be accessed
+7 - In function listbox double-click lineGetCountry
+8 - In dialog box select dwCountryID parameter
+9 - Set value to 00000001
+10 - Press [OK] button 
+
+RESULT:
+2 - "lineGetCountry returned SUCCESS" should be displayed along with to follow return:
+
+LINECOUNTRYLIST
+  dwTotalSize=x1000
+  dwNeededSize=x6b
+  dwUsedSize=x6b
+  dwNumCountries=x1
+  dwCountryListSize=x2c
+  dwCountryListOffset=x18
+LINECOUNTRYENTRY[0]
+  dwCountryID=x1
+  dwCountryCode=x1
+  dwNextCountryID=x65
+  dwCountryNameSize=x19
+  dwCountryNameOffset=x52
+    74696e55 53206465 65746174 666f2073  United States of
+    656d4120 61636972 xxxxxx00 xxxxxxxx   America.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x50
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=x5
+  dwLongDistanceRuleOffset=x4b
+    47463120 xxxxxx00 xxxxxxxx xxxxxxxx   1FG.
+  dwInternationalRuleSize=x7
+  dwInternationalRuleOffset=x44
+    45313130 xx004746 xxxxxxxx xxxxxxxx  011EFG.
+
+STEPS: //Verify correct return for invalid country ID
+11 - In function listbox double-click lineGetCountry
+12 - In dialog box select dwCountryID parameter
+13 - Set value to ffffffff
+14 - Press [OK] button
+
+RESULT:
+3 - "lineGetCountry returned LINEERR_INVALCOUNTRYCODE" should be displayed
+
+STEPS:
+15 - Close TB
+
+***********************************************************************************
+**** Test Case - 26 lineGetTranslateCaps - determine SUCCESS and validity of
+***********************************************************************************
+
+Note: For this test to be run successfully, valid locations should exist.  Specifically, a 
+location must be entered into the Dialing Properties on the My Location tab; credit card 
+usage should be defined as well. 
+
+
+STEPS: // Verify lineGetTranslateCaps retrieves all locations & cards data
+1 - Run TAPI Browser
+2 - In function listbox double-click on lineGetTranslateCaps
+
+
+RESULT:
+1 - "lineGetTranslateCaps returned SUCCESS" should be displayed. For further detail, see 
+example below.
+
+STEPS:
+3 - Close TAPI Browser
+
+
+***************************************
+Example of lineGetTranslateCaps return:
+***************************************
+
+lineGetTranslateCaps returned SUCCESS
+LINETRANSLATECAPS
+  dwTotalSize=x1000
+  dwNeededSize=x35d
+  dwUsedSize=xa5d
+  dwNumLocations=x2
+  dwLocationListSize=x88
+  dwLocationListOffset=x2c
+  dwNumCards=x4
+  dwCardListSize=xd0
+  dwCardListOffset=xb4
+  dwCurrentPreferredCardID=x4
+LINELOCATIONENTRY[0]
+  dwLocationNameSize=xa
+  dwLocationNameOffset=x4d4
+    4f20794d 63696666 xxxx0065 xxxxxxxx  My Office.
+  dwCountryCode=x1
+  dwCityCodeSize=x4
+  dwCityCodeOffset=x4e4
+    00363032 xxxxxxxx xxxxxxxx xxxxxxxx  206.
+  dwPreferredCardID=x4
+  dwLocalAccessCodeSize=x3
+  dwLocalAccessCodeOffset=x4de
+    xx002c39 xxxxxxxx xxxxxxxx xxxxxxxx  9,.
+  dwLongDistanceAccessCodeSize=x3
+  dwLongDistanceAccessCodeOffset=x4e1
+    xx002c39 xxxxxxxx xxxxxxxx xxxxxxxx  9,.
+  dwTollPrefixListSize=x1
+  dwTollPrefixListOffset=x4e8
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwCountryID=x1
+  dwCancelCallWaitingSize=x5
+  dwCancelCallWaitingOffset=x4e9
+    2c30372a xxxxxx00 xxxxxxxx xxxxxxxx  *70,.
+LINELOCATIONENTRY[1]
+  dwPermanentLocationID=x1
+  dwLocationNameSize=xe
+  dwLocationNameOffset=x4ee
+    646e6f4c 4f206e6f 63696666 xxxx0065  London Office.
+  dwCountryCode=x2c
+  dwCityCodeSize=x4
+  dwCityCodeOffset=x500
+    00313730 xxxxxxxx xxxxxxxx xxxxxxxx  071.
+  dwLocalAccessCodeSize=x2
+  dwLocalAccessCodeOffset=x4fc
+    xxxx0038 xxxxxxxx xxxxxxxx xxxxxxxx  8.
+  dwLongDistanceAccessCodeSize=x2
+  dwLongDistanceAccessCodeOffset=x4fe
+    xxxx0038 xxxxxxxx xxxxxxxx xxxxxxxx  8.
+  dwTollPrefixListSize=x1
+  dwTollPrefixListOffset=x504
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwCountryID=x2c
+  dwCancelCallWaitingSize=x5
+  dwCancelCallWaitingOffset=x505
+    2c233037 xxxxxx00 xxxxxxxx xxxxxxxx  70#,.
+LINECARDENTRY[0]
+  dwCardNameSize=x13
+  dwCardNameOffset=x50a
+    656e6f4e 69442820 74636572 61694420  None (Direct Dia
+    xx00296c xxxxxxxx xxxxxxxx xxxxxxxx  l).
+  dwSameAreaRuleSize=x1
+  dwSameAreaRuleOffset=x51d
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwLongDistanceRuleSize=x1
+  dwLongDistanceRuleOffset=x51e
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwInternationalRuleSize=x1
+  dwInternationalRuleOffset=x51f
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwOptions=x1, PREDEFINED 
+LINECARDENTRY[1]
+  dwPermanentCardID=x1
+  dwCardNameSize=x1c
+  dwCardNameOffset=x520
+    54265441 72694420 20746365 6c616944  AT&T Direct Dial
+    61697620 41303120 00315454 xxxxxxxx   via 10ATT1.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x53c
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=x9
+  dwLongDistanceRuleOffset=x53e
+    38323031 47463138 xxxxxx00 xxxxxxxx  102881FG.
+  dwInternationalRuleSize=xc
+  dwInternationalRuleOffset=x547
+    38323031 31313038 00474645 xxxxxxxx  10288011EFG.
+  dwOptions=x1, PREDEFINED 
+LINECARDENTRY[2]
+  dwPermanentCardID=x2
+  dwCardNameSize=x10
+  dwCardNameOffset=x553
+    54265441 61697620 41303120 00305454  AT&T via 10ATT0.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x563
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=xc
+  dwLongDistanceRuleOffset=x565
+    38323031 47463038 00485424 xxxxxxxx  102880FG$TH.
+  dwInternationalRuleSize=xe
+  dwInternationalRuleOffset=x571
+    38323031 45313038 54244746 xxxx0048  1028801EFG$TH.
+  dwOptions=x1, PREDEFINED 
+LINECARDENTRY[3]
+  dwPermanentCardID=x4
+  dwCardNameSize=x1b
+  dwCardNameOffset=x57f
+    2049434d 65726944 44207463 206c6169  MCI Direct Dial 
+    20616976 32323031 xx003132 xxxxxxxx  via 102221.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x59a
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=x9
+  dwLongDistanceRuleOffset=x59c
+    32323031 47463132 xxxxxx00 xxxxxxxx  102221FG.
+  dwInternationalRuleSize=xc
+  dwInternationalRuleOffset=x5a5
+    32323031 31313032 00474645 xxxxxxxx  10222011EFG.
+  dwOptions=x1, PREDEFINED 
+
+This return should be checked against the data entered into Dialing Properties.  
+In this example, there were two locations  and four credit cards entered in Dialing 
+Properties.
+
+> dwNumLocations=x2, so LINELOCATIONENTRY is given for values 0 and 1
+> dwNumCards=x4, so LINECARDENTRY is given for values 0 through 3
+> dwCurrentPreferredCardID=x4 which correctly references the MCI card under LINECARDENTRY[3]
+
+
+***********************************************************************************
+**** Test Case - 27 lineTranslateAddress - valid and invalid addresses
+***********************************************************************************
+
+STEPS: // Test for valid address
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - Click Param box
+4 - In function listbox double-click on lineTranslateAddress
+5 - In dialog box select dwTranslateOptions
+6 - Under Value click on "select none"
+7 - In dialog box select lpszAddressln
+8 - Set value to a valid canonical number [i.e., "+1 (555) 555-5555"]
+9 - Press [OK] button
+
+Results:
+1 - "lineTranslateAddress returned SUCCESS" should be displayed
+
+STEPS:  // Test for invalid address
+11 - In function listbox double-click on lineTranslateAddress
+12 - In dialog box select dwTranslateOptions
+13 - Under Value click on "select none"
+14 - In dialog box select lpszAddressln
+15 - Set value to a valid dialable format number [i.e., "206 555-5555"]
+16 - Press [OK] button
+
+RESULTS:
+2 - "lineTranslateAddress returned SUCCESS" should be displayed
+
+STEPS:  // Test for invalid address
+17 - In function listbox double-click on lineTranslateAddress
+18 - In dialog box select dwTranslateOptions
+19 - Under Value click on "select none"
+20 - In dialog box select lpszAddressln
+21 - Set value to "Invalid string pointer"
+22 - Press [OK] button
+
+RESULTS:
+3 - "lineTranslateAddress returned LINEERR_INVALPOINTER" should be displayed
+
+STEPS:
+23 - On toolsbar press [LAp-] button
+24 - In dialog box press [OK]
+25 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 28 lineTranslateAddress - valid and invalid credit cards
+***********************************************************************************
+
+Note: To test the return for a valid credit card, at least one credit card must be defined in Dialing Properties.
+
+STEPS: // Check return for valid credit card ID
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - Check Param box
+4 - In function listbox double-click on lineTranslateAddress
+5 - In dialog box select dwCard
+6 - Set value to a valid dwLocationID (generally 00000001 should be valid)
+7 - Press [OK] button
+
+RESULTS:
+1 - "lineTranslateAddress returned SUCCESS" should be displayed 
+
+STEPS: // Check return for invalid credit card ID
+
+8 - In function listbox double-click on lineTranslateAddress
+9 - In dialog box select dwCard
+10 - Set value to ffffffff
+11 - Press [OK] button
+
+RESULTS:
+2 - "lineTranslateAddress returned LINEERR_INVALCARD" should be displayed
+
+STEPS:
+12 - On toolbar press [LAp-] button
+13 - In dialog box press [OK] button
+14 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 29 lineTranslateAddress - valid and invalid translate options
+***********************************************************************************
+
+Note: Card override translation option is tested under TCM case ID 28.
+
+STEPS: // No translate options
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - Check Params box
+4 - In function listbox double-click on lineTranslateAddress
+5 - In dialog box click on dwTranslateOptions
+6 - Change value to "select none"
+7 - Press [OK] button
+
+RESULTS:
+1 - "lineTranslateAddress returned SUCCESS" should be displayed
+
+STEPS:  // Cancel call waiting
+8 - In function listbox double-click on lineTranslateAddress
+9 - In dialog box click on dwTranslateOptions
+10 - Click on CARDOVERRIDE (to turn off the default)
+11 - Click on CANCELCALLWAITING
+12 - Press [OK] button
+
+RESULTS:
+2 - "lineTranslateAddress returned SUCCESS" should be displayed
+
+STEPS: // Force local call
+13 - In function listbox double-click on lineTranslateAddress
+14 - In dialog box click on dwTranslateOptions
+15 - Click on CARDOVERRIDE (to turn off the default)
+16 - Click on FORCELOCAL
+17 - Press [OK] button
+
+RESULTS:
+3 - "lineTranslateAddress returned SUCCESS" should be displayed
+
+STEPS:  // Force long distance call
+18 - In function listbox double-click on lineTranslateAddress
+19 - In dialog box click on dwTranslateOptions
+20 - Click on CARDOVERRIDE (to turn off the default)
+21 - Click on FORCELD
+22 - Press [OK] button
+
+RESULTS:
+4 - "lineTranslateAddress returned SUCCESS" should be displayed
+
+STEPS:  // Invalid paramters-- conflict local and long distance
+23 - In function listbox double-click on lineTranslateAddress
+24 - In dialog box click on dwTranslateOptions
+25 - Click on CARDOVERRIDE (to turn off the default)
+26 - Click on FORCELOCAL
+27 - Click on FORCELD
+28 - Press [OK] button
+
+RESULTS:
+5 - "lineTranslateAddress returned LINEERR_INVALPARAM" should be displayed
+
+STEPS:
+29 - On toolbar press [LAp-] button
+30 - In dialog box press [OK]
+31 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 31 lineConfigDialog 
+***********************************************************************************
+
+STEPS: // Verify dialog pop-up
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+] button
+3 - In function listbox double-click on lineConfigDialog
+
+RESULTS:
+1 - Pop-up dialog box for configuring installed modem
+
+STEPS: // Close dialog box
+4 - On dialog box press [OK] button
+
+RESULTS:
+2 - "lineConfigDialog returned SUCCESS" should be displayed
+
+STEPS:
+6 - On toolbar press [LAp-] button
+7 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 32 lineTranslateDialog 
+***********************************************************************************
+
+STEPS: // Verify dialog pop-up
+1 - Run TAPI Browser
+2 - In function listbox double-click on lineConfigDialog
+
+RESULTS:
+1 - Pop-up dialog box labeled Dialing Properties
+
+STEPS: // Close dialog box
+3 - On dialog box press [OK] button
+
+RESULTS:
+2 - "lineTranslateDialog returned SUCCESS" should be displayed
+
+STEPS:
+5 - In  function listbox double-click on lineConfigDialog
+6 - On Dialing Properties dialog box, check (or uncheck) Dial as Long Distance box
+7 - On Dialing Properties press [OK] button
+
+RESULTS:
+3 - "lineTranslateDialog returned SUCCESS" should be displayed, as well as "received LINE_LINEDEVSTATE" with param1 returning "REINIT"
+
+STEPS:
+8 - Close TAPI Browser
+
+
+***********************************************************************************
+**** Test Case - 80 lineDial 
+***********************************************************************************
+
+lineInitialize
+lineOpen
+lineMakeCall with lpszDestAddr set to NULL
+lineDial with lpszDestAddr set to a phone number to call.
+
+Result:
+
+Talk/Drop dialog should appear, and call should ring through to the number you entered.
+
+
+lineDrop
+lineClose
+lineShutdown
+
+***********************************************************************************
+**** Test Case - 81 lineGetID - comm & comm/datamodem 	
+***********************************************************************************
+
+lineInitialize
+lineOpen as Owner
+lineGetID with lpszDeviceClass set to 'comm'
+
+Result:
+
+The data after dwStringOffset should be the name of the modem
+
+lineGetID with lpszDeviceClass set to 'ndis'
+
+Result:
+
+The data after dwStringOffset should be set to com.
+
+
+lineGetID with lpszDeviceClass set to 'comm/datamodem'
+
+Result:
+
+The data after dwStringOffset should be a numeric value (8 digits) followed by the name of the modem.  The numeric value is a handle to the comm port.  It's usually 00000000 or a low number.
+
+
+At the bottom of the TB API list, CloseHandle is listed.  Call CloseHandle with hObject set to the numeric value returned in lineGetID with 'comm/datamodem'.
+
+Result:
+
+Handle is closed.  The handle should be identified as the same numeric value entered into hObject.
+
+lineClose
+lineShutdown
+
+
+***********************************************************************************
+**** Test Case - 83 lineReply & lineCallState
+***********************************************************************************
+
+STEPS:  // Check LINE_REPLY is correct for instance of multiple apps running
+1 - Run TAPI Browser
+2 - On toolbar press [LAp+]
+3 - On toolbar press [LAp+]
+4 - On toolbar press [LAp-]
+5 - On toolbar press [Line+]
+6 - On toolbar press [Call+]
+
+RESULTS:
+1 - TB20 should display the following: 
+
+lineMakecall returned x1
+   received LINE_REPLY : hDev=x0, cbInst=x0
+     p1=x1,
+     p2=x0,
+     p3=x0
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x8, DIALTONE
+     p2=x20, UNAVAIL
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x10, DIALING
+     p2=x0,
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x200 PROCEEDING
+     p2=x0,
+     p3=x0,
+
+[Note: The absence of the LINE_REPLY or LINE_CALLSTATE indicates failure of the test case even if the call otherwise succeeds.]
+
+STEPS:
+7 - On toolbar press [Call-]
+8 - On toolbar press [Line-]
+9 - On toolbar press [LAp-]
+10 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 175 lineNegotiateAPIVersion / 2.0
+***********************************************************************************
+
+STEPS: // default call should get 2.0 version # returned
+1 - Run TB
+2 - turn off the [Parms] checkbox
+3 - Double Click lineInitializeEx
+4 - dblclick [lineNegotiateAPIVersion]
+
+RESULTS:
+1 - should get the following in the results window
+    lineNegotiateAPIVersion returned SUCCESS
+      APIVersion=x20000
+      extID.ID0=x0, .ID1=x0, .ID2=x0, .ID3=x0, 
+
+STEPS: //ensure if LOW is > high ver #, this fails.
+5 - turn on the [Parms] checkbox
+6 - dblclick [lineNegotiateAPIVersion]
+7 - click [dwAPILowVersion]
+8 - enter 00030000
+9 - Press OK
+
+RESULTS:
+2 - should get the following in the results window
+    lineNegotiateAPIVersion returned LINEERR_INCOMPATIBLEAPIVERSION
+  
+
+STEPS: //ensure if HIGH is both < high ver # and > low ver# we get a match
+10 - dblclick [lineNegotiateAPIVersion]
+11 - click [dwAPIHighVersion]
+12 - enter 00010003
+13 - Press OK
+
+RESULTS:
+3 - should get the following in the results window
+    lineNegotiateAPIVersion returned SUCCESS
+      APIVersion=x10003
+      extID.ID0=x0, .ID1=x0, .ID2=x0, .ID3=x0, 
+
+STEPS:
+14 - On toolbar click on [LAp-]
+15 - Close TB
+
+***********************************************************************************
+**** Test Case - 176 lineGetMessage
+***********************************************************************************
+
+Note: 1) lineGetMessages must be proceeded with a lineInitializeEx call with it's
+         lineInitializeExParam.Option = USEEVENT.
+      2) lineGetMessage is called after making a TAPI API call that will generate 
+	 messages such as lineMakeCall.             
+
+STEPS:  
+1  - Run TAPI Browser
+2  - click the [Parms] checkbox on, on the toolbar
+3  - Double Click lineInitializeEx
+4  - In the dialog box, select [->dwOptions]
+5  - Choose [USEEVENT] in the [Bit flags] listbox
+6  - Press OK
+7  - Double Click lineOpen
+8  - Press OK
+9  - Double Click lineMakeCall
+10 - Press OK
+
+RESULTS:
+1 - "lineMakeCall should return a positive request ID in the results window 
+(i.e."lineMakeCall returned xN" where n is a positive integer). This Must not be 
+followed by any TAPI messages.
+
+STEPS:  
+11 - Double Click lineGetMessage
+12 - Press OK
+
+RESULTS:
+2 - lineGetMessage should return success and the first queued TAPI message in the 
+results window. This is usually LINE_REPLY.
+
+STEPS:  
+13 - click the [Parms] checkbox off, on the toolbar
+14 - Double click lineDrop
+15 - Double click lineDeallocateCall
+16 - Double click lineClose
+17 - Double click lineShutdown
+18 - Exit TAPI Browser
+
+
+***********************************************************************************
+**** Test Case - 177 lineGetStatusMessage
+***********************************************************************************
+
+STEPS:  
+1 - Run TAPI Browser
+2 - Double Click lineInitializeEx
+3 - Double Click lineOpen
+4 - Double Click lineGetStatusMessage
+
+RESULTS:
+1 - lineGetStatusMessage returns success in the results window.
+
+STEPS:  
+5 - Double Click lineClose
+6 - Double Click lineShutdown
+7 - Exit TAPI Browser
+
+***********************************************************************************
+**** Test Case - 178 lineGetNumRings & lineSetNumRings
+***********************************************************************************
+
+STEPS:  
+1  - Run TAPI Browser
+2  - Double Click lineInitialize
+3  - Double Click lineOpen
+4  - Double Click lineGetNumRings
+
+RESULTS:
+1 - lineGetNumRings should return Success
+2 - num rings = xffffffff.
+
+STEPS:
+5  - click the [Parms] checkbox on, on the toolbar
+6  - Double Click lineSetNumRings
+7  - In the dialog box, select [dwNumRings]
+8  - Enter 9 in the Value: Editbox
+9  - Press OK
+
+RESULTS:
+3 - lineSetNumRings should return Success.
+
+STEPS:
+10 - click the [Parms] checkbox off, on the toolbar
+11 - Double Click lineGetNumRings
+
+RESULTS:
+4 - lineGetNumRings should return Success.
+5 - num rings = x9.
+
+STEPS:  
+12 - Double Click lineClose
+13 - Double Click lineShutdown
+14 - Exit TAPI Browser
+
+************************* End Of TAPI_BVT Test ************************************
diff --git a/private/tapi/qa/bvt/tbglobal.h b/private/tapi/qa/bvt/tbglobal.h
new file mode 100644
index 000000000..f5bf2dd81
--- /dev/null
+++ b/private/tapi/qa/bvt/tbglobal.h
@@ -0,0 +1,187 @@
+'TAPI BVT HEADER
+
+' WARNING:  This is a piece of junk.  No warrantee implied.
+'spaghetti, not authored by me, just scribbled by me, (ajohnh, some time in '95)
+'$INCLUDE 'd:\msdev\include\RECORDER.INC'
+'$include 'd:\msdev\include\winapi.inc'
+'$INCLUDE 'D:\MSDEV\INCLUDE\TBPOKE.H'
+
+'//////////////////////////////////////////
+'////// borrowed from my in-work TBPoke:
+'logging
+global sOutLogName			as string
+global sScriptName			as string
+global sComment				as string
+
+global hwndViewport			as long
+global lCountSpace			as long
+global lCountFunc			as long
+global lCountTab			as long
+global MAX_BLANK			as long
+global sFuncString			as string
+
+'end reporting
+global sEndingMessage		as string
+global sEndTitle			as string
+
+'checkbox function
+global sCheckbox			as string
+global lState				as long
+
+'system metrics
+global ScreenX				as long
+global ScreenY				as long
+
+'time value
+global MY_TIMEOUT			as long
+global PACER				as long
+
+global PARAMS				as long
+global NOPARAMS				as long
+
+global hwndTapiControl		as hwndTAPI_CONTROL
+global ScenarioLog			as LOGINITSTRUCT
+
+global sdwPrivileges		as array of string
+global sPrivileges			as string
+global sdwMediaModes		as array of string
+global sMediaModes			as string
+'
+global hLineApp				as array of string
+global hLine				as array of string
+global hCall				as array of string
+
+redim sdwPrivileges(1 to 3)		as string
+redim sdwMediaModes(1 to 14)	as string
+
+redim hLineApp(1 to 5)			as string   'limit 5 for now
+redim hLine(1 to 5)				as string
+redim hCall(1 to 5)				as string
+'redim hCall(5)				as string
+
+global hLineAppIndex			as pointer to string
+'global hLineIndex				as pointer to string
+'VARPTR(hLineApp(0))        'WATCH IT
+'VARPTR(hLine(0))
+
+'counts
+global	ldwPrivilegesBitFlag		as long 
+global	ldwMediaModesBitFlag		as long
+global	ldwPrivilegesBitFlagChaos	as long
+global	ldwMediaModesBitFlagChaos	as long
+
+global	lLineApp					as long
+global	lLine						as long
+global	lCall						as long
+
+global	GenCount					as long
+global  lCountLineApp				as long		
+global  GenCount2					as long
+
+'coverage statistics
+'not yet implemented
+global	TapiStatistic				as TAPI_STATISTIC
+
+global  Tracelevel					as long 'debug output
+
+'duh
+hwndTapiControl.TapiHandle			= WFndWnd("TAPI32 Browser", FW_DEFAULT) 'find TAPI32 BROWSER
+'by ID, note VT will probably be using the decimal form throughout:
+hwndTapiControl.ParamsCheckbox			=&h000003f9
+hwndTapiControl.LineAppPlusButton		=&h000003ee
+hwndTapiControl.LineAppMinusButton		=&h000003ef
+hwndTapiControl.LinePlusButton			=&h000003f0
+hwndTapiControl.LineMinusButton			=&h000003f1
+hwndTapiControl.CallPlusButton			=&h000003f2
+hwndTapiControl.CallMinusButton			=&h000003f3
+hwndTapiControl.PhoneAppPlusButton		=&h000003f4
+hwndTapiControl.PhoneAppMinusButton		=&h000003f5
+hwndTapiControl.PhoneOpenPlusButton		=&h000003f6
+hwndTapiControl.PhoneOpenMinusButton	=&h000003f7
+hwndTapiControl.ClearEditButton			=&h000003f8
+hwndTapiControl.BlankButton0			=&h000003fa
+hwndTapiControl.BlankButton1			=&h000003fb
+hwndTapiControl.BlankButton2			=&h000003fc
+hwndTapiControl.BlankButton3			=&h000003fd
+hwndTapiControl.BlankButton4			=&h000003fe
+hwndTapiControl.BlankButton5			=&h000003ff
+hwndTapiControl.Listbox0				=&h000003e8		'middle box
+hwndTapiControl.Listbox1				=&h000003e9		'left box
+hwndTapiControl.Editbox					=&h000003eb		'right box
+
+'// assign
+sOutLogName=curdir$+"\tapibvt.log"
+lCountSpace=0
+lCountFunc=0
+lCountTab=1
+MAX_BLANK=20				'static
+MY_TIMEOUT=2
+PACER = 1
+PARAMS=1
+NOPARAMS=0
+
+'debug; 0=no debug; 3 low, 2 med, 1 high --I know it is backward
+Tracelevel=0
+
+ScreenX=GetSystemMetrics(SM_CXSCREEN)
+ScreenY=GetSystemMetrics (SM_CYSCREEN)
+
+ScenarioLog.LogOutputType = LogTypeFile
+ScenarioLog.MinDetailLevel = 3
+ScenarioLog.ProductVersion = "4"
+ScenarioLog.MachineName = "Undefined"
+ScenarioLog.LogLocation = "tapibvt.log"
+ScenarioLog.Language = "US English"
+
+'WATCH IT
+'dwPrivileges string in the form of sdwPrivileges
+
+			'change these to pointers ASAP
+global NONE as long, MONITOR as long, OWNER as long
+			sdwPrivileges(1)="NONE"
+			NONE=1
+			sdwPrivileges(2)="MONITOR"
+			MONITOR=2
+			sdwPrivileges(3)="OWNER"
+			OWNER=3
+
+'dwMediaModes string in the form of sdwMediaModes
+'edit this, this is bulky & hacked:
+
+global UNKNOWN as long, INTERACTIVEVOICE as long, AUTOMATEDVOICE as long
+global DATAMODEM as long, G3FAX as long, TDD as long, G4FAX as long
+global DIGITALDATA as long, TELETEX as long, VIDEOTEX as long
+global TELEX as long, MIXED as long, ADSI as long, VOICEVIEW as long
+
+			sdwMediaModes(1)="UNKNOWN"
+			UNKNOWN=1
+			sdwMediaModes(2)="INTERACTIVEVOICE"
+			INTERACTIVEVOICE=2
+			sdwMediaModes(3)="AUTOMATEDVOICE"
+			AUTOMATEDVOICE=3
+			sdwMediaModes(4)="DATAMODEM"
+			DATAMODEM=4
+			sdwMediaModes(5)="G3FAX"
+			G3FAX=5
+			sdwMediaModes(6)="TDD"
+			TDD=6
+			sdwMediaModes(7)="G4FAX"
+			G4FAX=7
+			sdwMediaModes(8)="DIGITALDATA"
+			DIGITALDATA=8
+			sdwMediaModes(9)="TELETEX"
+			TELETEX=9
+			sdwMediaModes(10)="VIDEOTEX"
+			VIDEOTEX=10
+			sdwMediaModes(11)="TELEX"
+			TELEX=11
+			sdwMediaModes(12)="MIXED"
+			MIXED=12
+			sdwMediaModes(13)="ADSI"
+			ADSI=13
+			sdwMediaModes(14)="VOICEVIEW"
+			VOICEVIEW=14
+
+'/////////////////////////////////
+'///////  END HEADER /////////////
+'/////////////////////////////////
diff --git a/private/tapi/qa/bvt/tbpoke.h b/private/tapi/qa/bvt/tbpoke.h
new file mode 100644
index 000000000..bd3d90261
--- /dev/null
+++ b/private/tapi/qa/bvt/tbpoke.h
@@ -0,0 +1,68 @@
+'control handles for TAPI Browser UI
+type hwndTAPI_CONTROL
+	TapiHandle				as long
+	ParamsCheckbox			as long
+	LineAppPlusButton		as long
+	LineAppMinusButton		as long
+	LinePlusButton			as long
+	LineMinusButton			as long
+	CallPlusButton			as long
+	CallMinusButton			as long
+	PhoneAppPlusButton		as long
+	PhoneAppMinusButton		as long
+	PhoneOpenPlusButton		as long
+	PhoneOpenMinusButton	as long
+	ClearEditButton			as long
+	BlankButton0			as long
+	BlankButton1			as long
+	BlankButton2			as long
+	BlankButton3			as long
+	BlankButton4			as long
+	BlankButton5			as long
+	Listbox0				as long 'middle box
+	Listbox1				as long 'left box
+	Editbox					as long 'right box
+end type
+
+
+'TYPE ORDERS
+'	company AS STRING *30
+'	ordernum AS ARRAY OF LONG
+'	billed AS DOUBLE
+'END TYPE
+'
+'  
+'You must not only explicitly declare any variable of this type using the DIM statement, you must then use the REDIM statement to dimension the array within it:
+'  
+'DIM MyOrders AS ORDERS
+'REDIM (MyOrders.ordernum)(1 TO 30) AS LONG
+
+
+'from RECORDER.INC ???
+'$IFDEF MSTEST32
+TYPE LOGINITSTRUCT
+    LogOutputType AS LONG
+    MinDetailLevel AS LONG
+    ProductVersion AS STRING
+    MachineName AS STRING
+    Language AS STRING
+    LogLocation AS STRING
+'    NotificationProc AS POINTER TO SUB(Action&, Text$)
+END TYPE
+'$ENDIF 
+
+type TAPI_STATISTIC
+	CountlineInitialze				as long
+	CountlineShutdown				as long
+	CountlineOpen					as long
+	CountlineClose					as long
+	CountlineMakeCall				as long
+	CountlineDrop					as long
+	CountlineDeallocateCall			as long
+	CountlineAnswer					as long
+	CountlineGetNumRings			as long
+	CountlineDial					as long
+	CountlineGetTranslateCaps		as long
+	CountlineNegotiateAPIVersion	as long
+	CountlineNegotiateExtVersion	as long
+end type 'more to come
diff --git a/private/tapi/qa/bvt/uni_api.inc b/private/tapi/qa/bvt/uni_api.inc
new file mode 100644
index 000000000..2d8abd348
--- /dev/null
+++ b/private/tapi/qa/bvt/uni_api.inc
@@ -0,0 +1,481 @@
+'******************************************************************************
+
+' Uni_API.inc												 
+' Created April 16, 1996
+' By Ron Rohr
+
+' 
+' This file was created in part using Uni_API.mst which copies the api listing from 
+' TAPI Browser and converts the api's to constant declarations.
+
+'******************************************************************************
+
+
+'$IFNDEF UNICODE_API_INC
+'$DEFINE	UNICODE_API_INC
+
+'**************************** BEGIN DECLARATIONS ******************************
+'------------------------------------------------------------------------------
+' Begin Type declarations 
+
+type ParamAttributes
+
+	Param			as string
+	BitFlagList as string
+	ValueEdit	as string
+	ValueList	as string
+
+end type
+
+type LOpenParam		  'lineOpen return parameters
+
+	hLine as long		  'handle to open line device
+	DevID as short
+	Priv  as string	  'Application Call Privalege
+
+end type
+
+type lNegAPIV				'lineNegotiateAPIVersion return parameters
+
+	API_Ver as string
+	ID      as array of string
+
+end type
+
+type TAPIMSG
+
+	Msg as string
+	device as string
+	cbInst as string
+	param1 as string
+	param2 as string
+	param3 as string
+ 	errorstr as string
+
+ end type
+
+Type ParamInfo			'Registry 
+	VName as string
+	DType as string
+	Value as String
+end type
+
+'------------------------------------------------------------------------------
+' Begin TAPI Browser API variable declarations 
+
+'lineInitialize
+dim hLineApp as long	  'Application usage handle
+dim Num_Dev  as short  'Number of devices returned by lineInitialize
+
+'lineOpen
+dim lOpenRtn as LOpenParam
+
+'lineNegotiateAPIVer
+dim lNegVerRtn as lNegAPIV
+redim	(lNegVerRtn.ID)(3) as string
+
+'lineMakeCall
+dim ReceiveState as TAPIMSG
+
+' End TAPI Browser API variable declarations 
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin Global declarations and definitions
+ 
+Global WTIMEOUT AS LONG           'Timeout value for WFndWnd
+Global teststring as CaseStruct   'Holds test case info for logging by logcase routine
+Global ParamTraits as array of ParamAttributes	'TB20 Parameter info
+Global TC_ID as short				 'Holds Test Case ID
+'Global ParamArray as array of ParamAttributes	'use when multiple API parameters must be set
+
+'------------------------------------------------------------------------------
+' Begin Constants, declarations and definitions for TAPI Browser
+
+dim hTB20         as long	  ' handle to TAPI Browser
+dim hTB_Ctrl(2)   as long	  ' Array TB child controls handles
+dim hTB_CtrlID(2) as long	  ' Array TB child controls IDs
+
+Const TB_APIList = 0
+Const TB_ResList = 1
+Const TB_ResEdit = 2
+
+hTB_CtrlID( TB_APIList ) = &h03E9&
+hTB_CtrlID( TB_ResList ) = &h03E8&
+hTB_CtrlID( TB_ResEdit ) = &h03EB&
+
+Const TB20_CAPTION     = "TAPI32 Browser"
+Const USING_TB_CAPTION = "Using the TAPI Browser"
+Const DEFAULT_VALUES_CAPTION = "Default values"
+Const MOPTIONS         = "&Options"
+Const MDEFAULT         = "&Default values..."
+Const TAPI_BROWSER     = "\TB20.exe"
+Const BUFFER_SIZE		  = "Buffer size"
+Const SIZE_2K			  = "2000" 
+'------------------------------------------------------------------------------
+' Begin Registry Editor Constant definitions
+
+Const KEY_FILENAME		= "\Providers.key"
+Const REGEDIT_CAPTION   = "Registry Editor"
+Const REGEDIT_CLASS     = "RegEdt32"
+
+Const MREG				   = "&Registry"
+Const MEDIT					= "&Edit"
+Const MView					= "&View"
+Const MSAVE_KEY			= "Sa&ve Key..."
+Const MRESTORE				= "R&estore..."
+Const MExit				   = "E&xit"
+Const MADDKEY				= "Add &Key..."
+Const MADDVAL				= "Add &Value..."
+Const MDEL					= "&Delete"
+Const MFKey					= "&Find Key..."
+		
+Const LOC_MACH_CAPTION  = "HKEY_LOCAL_MACHINE on Local Machine"
+Const FIND_CAPTION		= "Find"
+Const WARNING_CAPTION	= "Warning"
+Const SAVEKEY_CAPTION	= "Save Key"
+Const FINDKEY_CAPTION	= "Find Key"
+Const ADDKEY_CAPTION		= "Add Key"
+Const RESKEY_CAPTION		= "Restore Key"
+Const ADDVALUE_CAPTION  = "Add Value"
+Const DWORD_CAPTION		= "DWord Editor"
+Const RSTR_CAPTION		= "String Editor"
+
+Const REGWIN_CLASS		= "REGISTRY_WINDOW"
+Const DIALOG_CLASS		= "#32770"
+
+Const REG_lOC_PATH		= "Software\Microsoft\Windows\CurrentVersion\Telephony\Providers"
+
+' End Registry Editor Constant definitions
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Other Constant definitions 
+
+' Window Classes
+
+Const DIALOG_CLASS = "#32770"
+
+' Menu 
+
+Const MFILE  = "&File"
+Const MEXIT  = "E&xit"
+Const MCLEAR = "&Clear"
+
+' Other
+
+Const CALL_STATUS_CAPTION = "Call Status"
+Const TB_EDIT_FILE = "\UB_EDIT_FILE.txt"
+
+' Used by TC 31
+Const MODEM_PROP_CAPTION = "Modems Properties"
+Const MODEM					 = "Modem"
+Const GEN_TAB				 = "General"
+Const PROPERTIES			 = "Properties"
+
+' Used by TC 32
+Const LOC_INFO_CAPTION   = "Location Information"
+Const DIALOG_CLASS		 = "#32770"
+Const PROPERTIES_CAPTION = "Dialing Properties"
+
+' End Other Constant definitions 
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Modem Properties Constant definitions 
+
+Const MODEM_APPLET		    = "\MODEM.CPL"
+Const MODEM_PROP_CAPTION	 =	"Modems Properties"
+Const INSTALL_MODEM_CAPTION = "Install New Modem"
+
+' End Modem Properties Constant definitions 
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin TC 178 Constant definitions 
+
+Const SET_RINGS = "9"
+
+' End TC 178 Constant definitions 
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin TAPI API Function constant definitions
+
+Const LAPI_Accept = "lineAccept"
+Const LAPI_AddProvider = "lineAddProvider"
+Const LAPI_AddProviderW = "lineAddProviderW"
+Const LAPI_AddToConference = "lineAddToConference"
+Const LAPI_AgentSpecific = "lineAgentSpecific"
+Const LAPI_Answer = "lineAnswer"
+Const LAPI_BlindTransfer = "lineBlindTransfer"
+Const LAPI_BlindTransferW = "lineBlindTransferW"
+Const LAPI_Close = "lineClose"
+Const LAPI_CompleteCall = "lineCompleteCall"
+Const LAPI_CompleteTransfer = "lineCompleteTransfer"
+Const LAPI_ConfigDialog = "lineConfigDialog"
+Const LAPI_ConfigDialogW = "lineConfigDialogW"
+Const LAPI_ConfigDialogEdit = "lineConfigDialogEdit"
+Const LAPI_ConfigDialogEditW = "lineConfigDialogEditW"
+Const LAPI_ConfigProvider = "lineConfigProvider"
+Const LAPI_DeallocateCall = "lineDeallocateCall"
+Const LAPI_DevSpecific = "lineDevSpecific"
+Const LAPI_DevSpecificFeature = "lineDevSpecificFeature"
+Const LAPI_Dial = "lineDial"
+Const LAPI_DialW = "lineDialW"
+Const LAPI_Drop = "lineDrop"
+Const LAPI_Forward = "lineForward"
+Const LAPI_ForwardW = "lineForwardW"
+Const LAPI_GatherDigits = "lineGatherDigits"
+Const LAPI_GatherDigitsW = "lineGatherDigitsW"
+Const LAPI_GenerateDigits = "lineGenerateDigits"
+Const LAPI_GenerateDigitsW = "lineGenerateDigitsW"
+Const LAPI_GenerateTone = "lineGenerateTone"
+Const LAPI_GetAddressCaps = "lineGetAddressCaps"
+Const LAPI_GetAddressCapsW = "lineGetAddressCapsW"
+Const LAPI_GetAddressID = "lineGetAddressID"
+Const LAPI_GetAddressIDW = "lineGetAddressIDW"
+Const LAPI_GetAddressStatus = "lineGetAddressStatus"
+Const LAPI_GetAddressStatusW = "lineGetAddressStatusW"
+Const LAPI_GetAgentActivityList = "lineGetAgentActivityList"
+Const LAPI_GetAgentActivityListW = "lineGetAgentActivityListW"
+Const LAPI_GetAgentCaps = "lineGetAgentCaps"
+Const LAPI_GetAgentGroupList = "lineGetAgentGroupList"
+Const LAPI_GetAgentStatus = "lineGetAgentStatus"
+Const LAPI_GetAppPriority = "lineGetAppPriority"
+Const LAPI_GetAppPriorityW = "lineGetAppPriorityW"
+Const LAPI_GetCallInfo = "lineGetCallInfo"
+Const LAPI_GetCallInfoW = "lineGetCallInfoW"
+Const LAPI_GetCallStatus = "lineGetCallStatus"
+Const LAPI_GetConfRelatedCalls = "lineGetConfRelatedCalls"
+Const LAPI_GetCountry = "lineGetCountry"
+Const LAPI_GetCountryW = "lineGetCountryW"
+Const LAPI_GetDevCaps = "lineGetDevCaps"
+Const LAPI_GetDevCapsW = "lineGetDevCapsW"
+Const LAPI_GetDevConfig = "lineGetDevConfig"
+Const LAPI_GetDevConfigW = "lineGetDevConfigW"
+Const LAPI_GetIcon = "lineGetIcon"
+Const LAPI_GetIconW = "lineGetIconW"
+Const LAPI_GetID = "lineGetID"
+Const LAPI_GetIDW = "lineGetIDW"
+Const LAPI_GetLineDevStatus = "lineGetLineDevStatus"
+Const LAPI_GetMessage = "lineGetMessage"
+Const LAPI_GetNewCalls = "lineGetNewCalls"
+Const LAPI_GetNumRings = "lineGetNumRings"
+Const LAPI_GetProviderList = "lineGetProviderList"
+Const LAPI_GetProviderListW = "lineGetProviderListW"
+Const LAPI_GetRequest = "lineGetRequest"
+Const LAPI_GetRequestW = "lineGetRequestW"
+Const LAPI_GetStatusMessages = "lineGetStatusMessages"
+Const LAPI_GetTranslateCaps = "lineGetTranslateCaps"
+Const LAPI_GetTranslateCapsW = "lineGetTranslateCapsW"
+Const LAPI_Handoff = "lineHandoff"
+Const LAPI_HandoffW = "lineHandoffW"
+Const LAPI_Hold = "lineHold"
+Const LAPI_Initialize = "lineInitialize"
+Const LAPI_IniitializeW = "lineIniitializeW"
+Const LAPI_InitializeEx = "lineInitializeEx"
+Const LAPI_InitializeExW = "lineInitializeExW"
+Const LAPI_MakeCall = "lineMakeCall"
+Const LAPI_MakeCallW = "lineMakeCallW"
+Const LAPI_MonitorDigits = "lineMonitorDigits"
+Const LAPI_MonitorMedia = "lineMonitorMedia"
+Const LAPI_MonitorTones = "lineMonitorTones"
+Const LAPI_NegotiateAPIVersion = "lineNegotiateAPIVersion"
+Const LAPI_NegotiateExtVersion = "lineNegotiateExtVersion"
+Const LAPI_Open = "lineOpen"
+Const LAPI_OpenW = "lineOpenW"
+Const LAPI_Park = "linePark"
+Const LAPI_ParkW = "lineParkW"
+Const LAPI_Pickup = "linePickup"
+Const LAPI_PickupW = "linePickupW"
+Const LAPI_PrepareAddToConference = "linePrepareAddToConference"
+Const LAPI_PrepareAddToConferenceW = "linePrepareAddToConferenceW"
+Const LAPI_ProxyMessage = "lineProxyMessage"
+Const LAPI_ProxyResponse = "lineProxyResponse"
+Const LAPI_Redirect = "lineRedirect"
+Const LAPI_RedirectW = "lineRedirectW"
+Const LAPI_RegisterRequestRecipient = "lineRegisterRequestRecipient"
+Const LAPI_ReleaseUserUserInfo = "lineReleaseUserUserInfo"
+Const LAPI_RemoveFromConference = "lineRemoveFromConference"
+Const LAPI_RemoveProvider = "lineRemoveProvider"
+Const LAPI_SecureCall = "lineSecureCall"
+Const LAPI_SendUserUserInfo = "lineSendUserUserInfo"
+Const LAPI_SetAgentActivity = "lineSetAgentActivity"
+Const LAPI_SetAgentGroup = "lineSetAgentGroup"
+Const LAPI_SetAgentState = "lineSetAgentState"
+Const LAPI_SetAppPriority = "lineSetAppPriority"
+Const LAPI_SetAppPriorityW = "lineSetAppPriorityW"
+Const LAPI_SetAppSpecific = "lineSetAppSpecific"
+Const LAPI_SetCallData = "lineSetCallData"
+Const LAPI_SetCallParams = "lineSetCallParams"
+Const LAPI_SetCallPrivilege = "lineSetCallPrivilege"
+Const LAPI_SetCallQualityOfService = "lineSetCallQualityOfService"
+Const LAPI_SetCallTreatment = "lineSetCallTreatment"
+Const LAPI_SetCurrentLocation = "lineSetCurrentLocation"
+Const LAPI_SetDevConfig = "lineSetDevConfig"
+Const LAPI_SetDevConfigW = "lineSetDevConfigW"
+Const LAPI_SetLineDevStatus = "lineSetLineDevStatus"
+Const LAPI_SetMediaControl = "lineSetMediaControl"
+Const LAPI_SetMediaMode = "lineSetMediaMode"
+Const LAPI_SetNumRings = "lineSetNumRings"
+Const LAPI_SetStatusMessages = "lineSetStatusMessages"
+Const LAPI_SetTerminal = "lineSetTerminal"
+Const LAPI_SetTollList = "lineSetTollList"
+Const LAPI_SetTollListW = "lineSetTollListW"
+Const LAPI_SetupConference = "lineSetupConference"
+Const LAPI_SetupConferenceW = "lineSetupConferenceW"
+Const LAPI_SetupTransfer = "lineSetupTransfer"
+Const LAPI_SetupTransferW = "lineSetupTransferW"
+Const LAPI_Shutdown = "lineShutdown"
+Const LAPI_SwapHold = "lineSwapHold"
+Const LAPI_TranslateAddress = "lineTranslateAddress"
+Const LAPI_TranslateAddressW = "lineTranslateAddressW"
+Const LAPI_TranslateDialog = "lineTranslateDialog"
+Const LAPI_TranslateDialogW = "lineTranslateDialogW"
+Const LAPI_UncompleteCall = "lineUncompleteCall"
+Const LAPI_Unhold = "lineUnhold"
+Const LAPI_Unpark = "lineUnpark"
+Const LAPI_UnparkW = "lineUnparkW"
+Const PAPI_Close = "phoneClose"
+Const PAPI_ConfigDialog = "phoneConfigDialog"
+Const PAPI_ConfigDialogW = "phoneConfigDialogW"
+Const PAPI_DevSpecific = "phoneDevSpecific"
+Const PAPI_GetButtonInfo = "phoneGetButtonInfo"
+Const PAPI_GetButtonInfoW = "phoneGetButtonInfoW"
+Const PAPI_GetData = "phoneGetData"
+Const PAPI_GetDevCaps = "phoneGetDevCaps"
+Const PAPI_GetDevCapsW = "phoneGetDevCapsW"
+Const PAPI_GetDisplay = "phoneGetDisplay"
+Const PAPI_GetGain = "phoneGetGain"
+Const PAPI_GetHookSwitch = "phoneGetHookSwitch"
+Const PAPI_GetIcon = "phoneGetIcon"
+Const PAPI_GetIconW = "phoneGetIconW"
+Const PAPI_GetID = "phoneGetID"
+Const PAPI_GetIDW = "phoneGetIDW"
+Const PAPI_GetLamp = "phoneGetLamp"
+Const PAPI_GetMessage = "phoneGetMessage"
+Const PAPI_GetRing = "phoneGetRing"
+Const PAPI_GetStatus = "phoneGetStatus"
+Const PAPI_GetStatusW = "phoneGetStatusW"
+Const PAPI_GetStatusMessages = "phoneGetStatusMessages"
+Const PAPI_GetVolume = "phoneGetVolume"
+Const PAPI_Initialize = "phoneInitialize"
+Const PAPI_InitializeW = "phoneInitializeW"
+Const PAPI_InitializeEx = "phoneInitializeEx"
+Const PAPI_InitializeExW = "phoneInitializeExW"
+Const PAPI_Open = "phoneOpen"
+Const PAPI_NegotiateAPIVersion = "phoneNegotiateAPIVersion"
+Const PAPI_NegotiateExtVersion = "phoneNegotiateExtVersion"
+Const PAPI_SetButtonInfo = "phoneSetButtonInfo"
+Const PAPI_SetButtonInfoW = "phoneSetButtonInfoW"
+Const PAPI_SetData = "phoneSetData"
+Const PAPI_SetDisplay = "phoneSetDisplay"
+Const PAPI_SetGain = "phoneSetGain"
+Const PAPI_SetHookSwitch = "phoneSetHookSwitch"
+Const PAPI_SetLamp = "phoneSetLamp"
+Const PAPI_SetRing = "phoneSetRing"
+Const PAPI_SetStatusMessages = "phoneSetStatusMessages"
+Const PAPI_SetVolume = "phoneSetVolume"
+Const PAPI_Shutdown = "phoneShutdown"
+Const TAPI_GetLocationInfo = "tapiGetLocationInfo"
+Const TAPI_GetLocationInfoW = "tapiGetLocationInfoW"
+Const TAPI_RequestDrop = "tapiRequestDrop"
+Const TAPI_RequestMakeCall = "tapiRequestMakeCall"
+Const TAPI_RequestMakeCallW = "tapiRequestMakeCallW"
+Const TAPI_RequestMediaCall = "tapiRequestMediaCall"
+Const TAPI_RequestMediaCallW = "tapiRequestMediaCallW"
+Const CLOSE_HANDLE = "Close handle (comm, etc)"
+
+' End TAPI API Function constant definitions
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+'  TAPI API Error constant definitions	  from TAPI.h
+
+Const LINEERR_ALLOCATED                   = &h80000001
+Const LINEERR_BADDEVICEID                 = &h80000002
+Const LINEERR_BEARERMODEUNAVAIL           = &h80000003
+Const LINEERR_CALLUNAVAIL                 = &h80000005
+Const LINEERR_COMPLETIONOVERRUN           = &h80000006
+Const LINEERR_CONFERENCEFULL              = &h80000007
+Const LINEERR_DIALBILLING                 = &h80000008
+Const LINEERR_DIALDIALTONE                = &h80000009
+Const LINEERR_DIALPROMPT                  = &h8000000A
+Const LINEERR_DIALQUIET                   = &h8000000B
+Const LINEERR_INCOMPATIBLEAPIVERSION      = &h8000000C
+Const LINEERR_INCOMPATIBLEEXTVERSION      = &h8000000D
+Const LINEERR_INIFILECORRUPT              = &h8000000E
+Const LINEERR_INUSE                       = &h8000000F
+Const LINEERR_INVALADDRESS                = &h80000010
+Const LINEERR_INVALADDRESSID              = &h80000011
+Const LINEERR_INVALADDRESSMODE            = &h80000012
+Const LINEERR_INVALADDRESSSTATE           = &h80000013
+Const LINEERR_INVALAPPHANDLE              = &h80000014
+Const LINEERR_INVALAPPNAME                = &h80000015
+Const LINEERR_INVALBEARERMODE             = &h80000016
+Const LINEERR_INVALCALLCOMPLMODE          = &h80000017
+Const LINEERR_INVALCALLHANDLE             = &h80000018
+Const LINEERR_INVALCALLPARAMS             = &h80000019
+Const LINEERR_INVALCALLPRIVILEGE          = &h8000001A
+Const LINEERR_INVALCALLSELECT             = &h8000001B
+Const LINEERR_INVALCALLSTATE              = &h8000001C
+Const LINEERR_INVALCALLSTATELIST          = &h8000001D
+Const LINEERR_INVALCARD                   = &h8000001E
+Const LINEERR_INVALCOMPLETIONID           = &h8000001F
+Const LINEERR_INVALCONFCALLHANDLE         = &h80000020
+Const LINEERR_INVALCONSULTCALLHANDLE      = &h80000021
+Const LINEERR_INVALCOUNTRYCODE            = &h80000022
+Const LINEERR_INVALDEVICECLASS            = &h80000023
+Const LINEERR_INVALDEVICEHANDLE           = &h80000024
+Const LINEERR_INVALDIALPARAMS             = &h80000025
+Const LINEERR_INVALDIGITLIST              = &h80000026
+Const LINEERR_INVALDIGITMODE              = &h80000027
+Const LINEERR_INVALDIGITS                 = &h80000028
+Const LINEERR_INVALEXTVERSION             = &h80000029
+Const LINEERR_INVALGROUPID                = &h8000002A
+Const LINEERR_INVALLINEHANDLE             = &h8000002B
+Const LINEERR_INVALLINESTATE              = &h8000002C
+Const LINEERR_INVALLOCATION               = &h8000002D
+Const LINEERR_INVALMEDIALIST              = &h8000002E
+Const LINEERR_INVALMEDIAMODE              = &h8000002F
+Const LINEERR_INVALMESSAGEID              = &h80000030
+Const LINEERR_INVALPARAM                  = &h80000032
+Const LINEERR_INVALPARKID                 = &h80000033
+Const LINEERR_INVALPARKMODE               = &h80000034
+Const LINEERR_INVALPOINTER                = &h80000035
+Const LINEERR_INVALPRIVSELECT             = &h80000036
+Const LINEERR_INVALRATE                   = &h80000037
+Const LINEERR_INVALREQUESTMODE            = &h80000038
+Const LINEERR_INVALTERMINALID             = &h80000039
+Const LINEERR_INVALTERMINALMODE           = &h8000003A
+Const LINEERR_INVALTIMEOUT                = &h8000003B 
+Const LINEERR_INVALTONE                   = &h8000003C
+Const LINEERR_INVALTONELIST               = &h8000003D
+Const LINEERR_INVALTONEMODE               = &h8000003E
+Const LINEERR_INVALTRANSFERMODE           = &h8000003F
+Const LINEERR_LINEMAPPERFAILED            = &h80000040
+Const LINEERR_NOCONFERENCE                = &h80000041
+Const LINEERR_NODEVICE                    = &h80000042
+Const LINEERR_NODRIVER                    = &h80000043
+Const LINEERR_NOMEM                       = &h80000044
+Const LINEERR_NOREQUEST                   = &h80000045
+Const LINEERR_NOTOWNER                    = &h80000046
+Const LINEERR_NOTREGISTERED               = &h80000047
+Const LINEERR_OPERATIONFAILED             = &h80000048
+Const LINEERR_OPERATIONUNAVAIL            = &h80000049
+Const LINEERR_RATEUNAVAIL                 = &h8000004A
+Const LINEERR_RESOURCEUNAVAIL             = &h8000004B
+Const LINEERR_REQUESTOVERRUN              = &h8000004C
+Const LINEERR_STRUCTURETOOSMALL           = &h8000004D
+Const LINEERR_TARGETNOTFOUND              = &h8000004E
+Const LINEERR_TARGETSELF                  = &h8000004F
+Const LINEERR_UNINITIALIZED               = &h80000050
+Const LINEERR_USERUSERINFOTOOBIG          = &h80000051
+Const LINEERR_REINIT                      = &h80000052
+Const LINEERR_ADDRESSBLOCKED              = &h80000053
+Const LINEERR_BILLINGREJECTED             = &h80000054
+Const LINEERR_INVALFEATURE                = &h80000055
+Const LINEERR_NOMULTIPLEINSTANCE          = &h80000056
+
+'  End TAPI API Error constant definitions
+'------------------------------------------------------------------------------
+
+'$ENDIF 'UNICODE_API_INC
diff --git a/private/tapi/qa/bvt/uni_bvt.inc b/private/tapi/qa/bvt/uni_bvt.inc
new file mode 100644
index 000000000..7f1469746
--- /dev/null
+++ b/private/tapi/qa/bvt/uni_bvt.inc
@@ -0,0 +1,2616 @@
+
+'******************************************************************************
+
+' Uni_BVT.inc												 
+' Created April, 1996
+' By Ron Rohr
+
+' This include file contains all the Functions used by the
+' Uni_BVT.MST test Script
+
+'******************************************************************************
+
+' Note: This file uses the Object Naming convention defined in the Visual Basic
+' 4.0 Programmers Guide to name variables and contants associated with a control.
+
+'$IFNDEF UNICODE_BVT_INC
+'$DEFINE UNICODE_BVT_INC
+ 
+'******************** Begin Procedure Declarations ****************************
+
+Declare Sub      EndTest ()
+Declare Sub		  SetWndTimeout ()
+Declare Function DetectModem() as long
+Declare Function StartTAPIBrowser(hTB20 as long, hTB_Child() as long, hTB_ChildID() as long) as long
+Declare Sub	 	  GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+Declare Function Call_LClose ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LConfigDialogW ( hTB20 as long, hTB_Child() as long, _
+												  ParamSet as long, HDlg as long, ModemName as string ) as long
+Declare Function Call_LDeallocateCall ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LDialW ( hTB20 as long, hTB_Child() as long, ParamSet as long, hDlg as long  ) as long
+Declare Function Call_LDrop (hTB20 as long, hTB_Child() as long, _ 
+					  ParamSet as long,  CallState as TAPIMSG) as long
+Declare Function Call_LGetCountryW  (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									        Returnstr as string ) as long
+Declare Function Call_LGetDevCapsW  ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LGetIDW (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  Returnstr as string ) as long
+Declare Function Call_LGetTranslateCapsW  (hTB20 as long, hTB_Child() as long, _
+					  ParamSet as long, Returnstr as string ) as long
+Declare Function Call_LInitialize (hTB20 as long, hTB_Child() as long, _
+					  ParamSet as long, hLine as long, Num_Dev as short ) as long
+Declare Function Call_LInitializeExW (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  hLine as long, Num_Dev as short, Returnstr as string ) as long
+Declare Function Call_LMakeCallW (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+					  CallState as TAPIMSG, returnstr as string) as long
+Declare Function Call_LNegotiateAPIVer (hTB20 as long, hTB_Ctrl() as long, _
+					  ParamSet as long, lNegVerRtn as lNegAPIV) as  long
+Declare Function Call_LOpenW ( hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  RtnlOpen as LOpenParam ) as long
+Declare Function Call_LSetCurrentLocation ( hTB20 as long, hTB_Child() as long, _
+                 ParamSet as long, CurCountryID as string, Returnstr as string ) as long  
+Declare Function Call_LShutDown ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+Declare Function Call_LTranslateAddressW (hTB20 as long, hTB_Child() as long, _
+		           Paramset as long, Returnstr as string ) as long
+Declare Function Call_LTranslateDialogW ( hTB20 as long, hTB_Child() as long, _
+					  hDlg as long, ParamSet as long ) as long
+Declare Function TCloseHandle (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+					  returnstr as string) as long
+
+Declare Function GetEditResults (hTB20 as long,hTBEdit as long, API_CALL as string) as string
+Declare Function GetModemName ( Returnstr as string, strhObject as string) as string
+Declare Function SetParamState (hTB20 as long, State as long)	as long
+Declare Function SetParamAttrib (API_CALL as string)	as long
+Declare Function MsgSplitter (Returntxt as string, MsgStruct as TAPIMSG) as long
+Declare Function DeleteESPtsp () as short
+Declare Sub      RestoreProviders ()
+Declare Sub      SetupProviders ()
+Declare Function LineCallState (CALLSTATEMSG as TAPIMSG, Editstr as string) as long 
+Declare Function LineReturnValue  (ErrorStr as string) as long
+Declare Function LineReturnString (ErrorVal as long) as string
+
+
+'******************** Begin Procedure Definitions *****************************
+
+'******************************************************************************
+'Name   : EndTest
+'Desc   : On End cleanup procedure.
+' 
+'Parms  : None
+'
+'Return : None. 
+'
+'History: 04/22/96 : a-rrohr: Created
+'*****************************************************************************
+Sub EndTest ()
+
+'$IFDEF Already_Validated
+'$ENDIF 'Already_Validated
+
+RestoreProviders ()
+
+
+CloseCase (TEST_SCRIPT_TITLE)
+
+CloseLog ()
+
+Statusbox "The TAPI Build Verification Test is now Complete" + CRLF + _
+			 "Test Case Number " + ltrim$(str$(TC_ID)), 0,0,0,0, TRUE, TRUE 
+Sleep 4
+ 
+End Sub 'EndTest
+
+'******************************************************************************
+'Name   : SetWndTimeout
+'Desc   : Sets the timeout variable used by the WFndWnd function.
+'			 Some of the platforms tested on are very slow and if the timeout isn't
+'			 long enough then	the test continues with out finding the Window and its
+'			 handle, dooming all subsequent test (that are dependent on this handle)
+'			 to complete and utter failure.
+' 
+'Parms  : None
+'
+'Return : None. Sets the Global String variables WTIMEOUT
+'
+'History: 02/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+ Sub SetWndTimeout ()
+
+ dim ProcArch as string									' Generic string variable
+ dim ProcLevel as string
+
+ SetActiveTimeout	(150)
+ SetDefaultWaitTimeout (2)
+
+ ProcArch = space(40)
+ ProcArch = environ$("PROCESSOR_ARCHITECTURE")
+ ProcLevel = space(40)
+ ProcLevel = environ$("PROCESSOR_LEVEL")
+
+ select case ProcArch
+
+	case "MIPS", "PPC"
+		WTIMEOUT = 5		
+		SlowPC = FALSE
+	case "x86"
+		select case ProcLevel
+			case "5"					'Pentium class PCs
+				WTIMEOUT = 5		
+				SlowPC = FALSE
+			case "4"					'486 class PCs
+				WTIMEOUT = 10		
+				SlowPC = TRUE
+				SetDefaultWaitTimeout (4)
+		end select
+	case  "Alpha"
+		WTIMEOUT = 20		
+		SlowPC = TRUE
+		SetDefaultWaitTimeout (8)
+	case else
+		WTIMEOUT = 30		
+	   WritelogItem ("" ,"SetWndTimeout Subroutine - TAPI_BVT.inc")
+	   WritelogItem ("" ,"Unable to set WTIMEOUT: Unknown Processor Architecture")
+	   WritelogItem ("" ,"Processor Architecture	environment variable = " +  ProcArch)
+	   WritelogItem ("" ," ")
+end select
+
+'$IFDEF NUMEGA
+		WTIMEOUT = WTIMEOUT + 5 'If using BoundsChecker then add a few more seconds
+'$ENDIF
+
+end Sub  'SetWndTimeout ()
+
+'******************************************************************************
+'Name   : DetectModem
+'Desc   : Runs Modem.cpl and determines if a modem is installed by which modem
+'			 dialog appears
+'			 
+'Parms  : None
+'
+'Return : True  if a Modem is set up on this computer
+'			 False if not.
+'
+'History: 04/15/96 : a-rrohr: Created
+'******************************************************************************
+
+Function DetectModem() as long
+
+dim w_Flags as long
+dim handle  as long, hCtrl as long
+dim Close_cmdID as long
+dim SysDirPath as string
+dim rtn as long
+
+'Initialize variables
+
+Close_cmdID = &h01&	'Close Command button ID on Modem Properties dialog
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+SysDirPath = string$(168, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + MODEM_APPLET, BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + MODEM_APPLET, nowait
+'$endif 'NUMEGA
+
+DetectModem = FALSE	 'Set default return value
+
+'if the Modems Properties dialog appears then a modem is set up on the computer
+
+handle =  WFndWndC (MODEM_PROP_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'a Modem is set up on this computer
+	hCtrl = GetDlgItem (handle, Close_cmdID)
+	WButtonClick (_hwnd(hCtrl))
+   WritelogItem ("" , "Modem Connected")
+	DetectModem = TRUE
+	Goto EndOFFunction
+endif
+
+'if the Install New Modem dialog appears then a modem is not set up on the 
+'computer and will need to be before the test can continue.
+
+handle =  WFndWndC (INSTALL_MODEM_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if handle > 0 then	'No Modems are set up on this computer
+   WritelogItem ("" , INSTALL_MODEM_CAPTION + " dialog Found")
+   WritelogItem ("" , "There are no Modems Setup on this computer")
+   WritelogItem ("" , " ")
+endif
+
+EndOFFunction:
+end Function 'DetectModem
+
+
+'******************************************************************************
+'Name   : StartTAPIBrowser
+'Desc   : Starts TAPI Browser and retrives all handles
+'			 
+'Parms  : hTB20 handle to TAPI Browser
+'			 hChild_TB() array of child handles 
+'			 all params are sent by reference and filled by this function 
+'
+'Return : True  if a TAPI Browser is started successfully
+'			 False if not.
+'
+'History: 04/16/96 : a-rrohr: Created
+'*****************************************************************************
+Function StartTAPIBrowser(hTB20 as long, hTB_Child() as long, hTB_ChildID() as long) as long
+
+static TBCalledCount as short  'Number of times TAPI Browser has been started
+dim w_flags		as long			 'used with WFndWnd function
+dim hDlg			as long			 'Generic dialog handle
+dim hCtrl		as long			 'Generic control handle
+dim OKcmd_ID	as long			 'hold ID to Using the TAPI Browser OK button
+dim SysDirPath as string		 'holds path to windows system directory
+dim rtn			as long			 'generic return variable
+dim Param_lstID as long
+dim Value_cboID as long
+dim OK_cmdID	 as long
+dim cbo_EditID  as long
+
+'Initialize variables
+
+StartTAPIBrowser = FALSE 'Set default return value
+OKcmd_ID = &h01&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+Param_lstID	  =&h03E8&
+Value_cboID	  =&h03EA&
+OK_cmdID		  =&h01&
+cbo_EditID	  =&h03E9&
+
+
+'Look for the "Using the TAPI Browser" dialog. This dialog appears automatically
+'the first time TB is invoked and never again. it must be closed before the test
+'can proceed.
+
+SysDirPath = string$(168, chr$(0))	 'create a null terminated string
+rtn = GetSystemDirectory (SysDirPath, len(SysDirPath))
+
+if exists (SysDirPath + TAPI_BROWSER) then	'if tapi browser is present, run
+
+	'$ifdef NUMEGA
+		run SysDirPath + TAPI_BROWSER, BoundsChecker
+	'$else
+		run SysDirPath + TAPI_BROWSER, nowait
+	'$endif 'NUMEGA
+else														'otherwise abort test
+
+   WritelogItem ("Unable to run ", SysDirPath + TAPI_BROWSER)
+   WritelogItem ("This Test Will Terminate ", "")
+   WritelogItem ("Please install Tapi Browser 2.0 prior to running this test", "")
+	end
+end if
+
+if TBCalledCount = 0 then
+	hDlg = WFndWndC (USING_TB_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+	if hDlg > 0 then
+		'Get handle to Using the TAPI Browser OK button and close dialog
+		hCtrl	= GetDlgItem(hDlg, OKcmd_ID)	 
+		WButtonClick  (_hwnd(hCtrl), TIMEOUT)
+	end if
+end if
+
+hTB20 = WFndWndC (TB20_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+'if valid TB handle then get child handles and return true
+if hTB20 > 0 then
+	GetChildHandles((hTB20), hTB_Child, (hTB_ChildID))
+	StartTAPIBrowser = TRUE
+endif
+
+if TBCalledCount = 0 then
+	WMenuSelect (MOPTIONS + "\" + MDEFAULT)
+	hDlg = WFndWndC (DEFAULT_VALUES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+	hCtrl = GetDlgItem ( hDlg, Param_lstID)
+	WlistItemClk (_hwnd(hCtrl), BUFFER_SIZE)
+
+	hCtrl = GetDlgItem ( hDlg, Value_cboID)
+	hCtrl = GetDlgItem ( hCtrl, cbo_EditID)
+	WEditSetText (_hwnd(hCtrl), SIZE_2K)
+	
+	hCtrl = GetDlgItem ( hDlg, OK_cmdID)
+	WButtonClick (_hwnd(hCtrl))
+end if
+
+TBCalledCount = TBCalledCount + 1
+
+end Function 'StartTAPIBrowser
+
+'*****************************************************************************
+'Name   : GetChildhandles 
+'Desc   : Fills the hChild array with the handles to the child controls of hParent 
+'         
+'Parms  : hTab = handle to My Location Tab
+'			 hChild = array of My Location child control handles.  
+'			 ChildID = array of child control IDs
+' 
+'Return : Void:   Subroutine fills in the hChild array parameter
+'
+'History: 02/10/96 : a-rrohr: Created
+'*****************************************************************************
+sub GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+
+dim count	  as short
+dim beginning as short
+dim ending    as short
+
+beginning = lbound(hChild)
+ending    = ubound(hChild)
+
+for count = beginning to ending
+	hChild(count) = GetDlgItem (hParent, ChildID(count))
+next	
+end sub
+
+'******************************************************************************
+'Name   : Call_LClose
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 04/19/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LClose ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Close, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Close)
+	if rtn = FALSE then
+		Call_LClose = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Close )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LClose = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LClose 
+
+'******************************************************************************
+'Name   : Call_LConfigDialogW
+'Desc   : Invokes the lineConfigureDialog function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineConfigDialog return value
+'			 
+'History: 05/09/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LConfigDialogW ( hTB20 as long, hTB_Child() as long, ParamSet as long, _
+											HDlg as long, ModemName as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim w_flags as long           'used with WFndWnd function
+dim ViewListID as long		   'IDs
+dim hctrl as long					'Generic control handle
+dim cmdOKID as long				'IDs
+dim cmdCloseID as long
+dim hTab as long					'Handle to Modems Properties General Tab
+dim SysDirPath as string		'Path to Windows\System32 directory
+dim ModemCaption as string		'Holds caption to Config dialog 
+
+cmdOKID			 = &h00000001&
+cmdCloseID		 = &h00000001&
+ViewListID		 = &h00000071&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_ConfigDialogW)
+	if rtn = FALSE then
+		Call_LConfigDialogW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Start the control panel Modem applet
+SysDirPath = space$(168)
+rtn = GetSystemDirectory (SysDirPath, 168)
+run "control.exe " + SysDirPath + "\Modem.CPL", NoWait
+
+' Find Modems Properties dialog and retrieve Modem name
+hDlg = WFndWndC (MODEM_PROP_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if hDlg <> 0 then
+	hTab =  WFndWndC ("General", DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+	if hTab <> 0 then
+		hctrl = GetDlgItem (hTab, ViewListID)
+		if hctrl <> 0 then
+			ModemName = " "
+			ModemName = ViewItemText (_hwnd(hctrl), "@1", "Modem", WTimeout)
+			ModemCaption = ModemName + " " + PROPERTIES
+		endif
+	endif
+	'Close Modems Properties
+	hctrl = GetDlgItem (hDlg, cmdCloseID)
+	WButtonClick (_hwnd(hctrl))
+endif
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_ConfigDialogW, TimeOut)
+sleep .1
+
+' Find Config dialog, save the handle and close and close it
+hDlg = 0
+hDlg = WFndWndC (ModemCaption, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if hDlg <> 0 then
+	cmdOKID = &h00000001&
+	hctrl = GetDlgItem (hdlg, cmdOKID)
+	WButtonClick (_hwnd(hctrl))
+else
+	WritelogItem ("Unable to Find Dialing Properties dialog " , "")
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_ConfigDialogW )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LConfigDialogW = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LConfigDialogW 
+
+'******************************************************************************
+'Name   : Call_LDeallocateCall
+'Desc   : Invokes the lineDeallocateCall function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 04/25/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LDeallocateCall ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+Call_LDeallocateCall = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_DeallocateCall, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_DeallocateCall)
+	if rtn = FALSE then
+		Call_LDeallocateCall = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_DeallocateCall )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LDeallocateCall = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LDeallocateCall 
+
+'******************************************************************************
+'Name   : Call_LDialW
+'Desc   : Invokes the lineDialW function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet:  state of param checkbox
+'			 hDlg:      handle to Call Status dialog
+'
+'Return : lineDialW return value
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LDialW ( hTB20 as long, hTB_Child() as long, ParamSet as long, hDlg as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hCtrl as long
+dim w_flags  as long
+dim TalkID	 as long				'ID for Call Status Talk button
+dim HangUpID as long				'ID for Call Status Hang Up button
+
+TalkID	= &h0514&
+HangUpID = &h0515&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+Call_LDialW = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_DialW, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_DialW)
+	if rtn = FALSE then
+		Call_LDialW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+hDlg = WFndWndC (CALL_STATUS_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+if hDlg > 0 then
+	WSetActWnd (hTB20) 'Make TB the active window and get result string
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_DialW )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+if hDlg > 0 then 'Hangup
+	WSetActWnd (hDlg)     'Make Call Status the active window and hangup
+	sleep .1
+	hCtrl = GetDlgItem (hDlg, HangUpID)
+	WButtonClick (_hwnd(hctrl))	
+	Call_LDialW = TRUE
+endif
+
+EndOfFunction:
+End Function 'Call_LDialW 
+
+'******************************************************************************
+'Name   : Call_LDrop
+'Desc   : Invokes the lineMakeCall function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineGetCallStatus return value and CALLSTATE structure
+'			 
+'History: 04/25/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LDrop (hTB20 as long, hTB_Child() as long, _ 
+					  ParamSet as long,  CallState as TAPIMSG) as long
+
+dim Count as long					'Generic counter
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim tempstr  as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Drop, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Drop)
+	if rtn = FALSE then
+		Call_LDrop = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+count = 0
+tempstr = space$ (1)
+'Wait until LineGetCallStatus appears in text before proceeding (text takes time to appear completely)
+do
+	tempstr = edittext(_hwnd(hTB_Child(TB_ResEdit)), 1)
+	if len(tempstr) > 0 then
+		rtn = instr(1, tempstr, "lineGetCallStatus")
+	endif
+	count = count + 1
+	sleep .5
+loop until rtn > 1 or count > 10
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Drop )
+
+Call_LDrop = LineCallState (CallState, (tempstr))
+
+EndOfFunction:
+end Function 'Call_LDrop
+
+'******************************************************************************
+'Name   : Call_LGetCountryW 
+'Desc   : Invokes the lineGetCountry function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineGetCountry return and Edit box text
+'			 
+'History: 05/08/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetCountryW  (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetCountryW , TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetCountryW )
+	if rtn = FALSE then
+		Call_LGetCountryW  = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetCountryW  )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LGetCountryW  = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LGetCountryW 
+
+'******************************************************************************
+'Name   : Call_LGetDevCapsW 
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineGetDevCaps return value
+'			 
+'History: 04/26/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetDevCapsW  ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetDevCapsW, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetDevCapsW)
+	if rtn = FALSE then
+		Call_LGetDevCapsW  = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetDevCapsW )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LGetDevCapsW  = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LGetDevCapsW  
+
+'******************************************************************************
+'Name   : Call_LGetIDW
+'Desc   : Invokes the lineTranslateAddress function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineTranslateAddress return and Edit box text
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetIDW (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+							 Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetIDW, TimeOut) 
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetIDW)
+	if rtn = FALSE then
+		Call_LGetIDW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetIDW )
+
+'Retieve lineGetID return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar , CRLFrtn - Startchar))
+
+Call_LGetIDW = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LGetIDW
+
+'******************************************************************************
+'Name   : Call_LGetTranslateCapsW 
+'Desc   : Invokes the lineGetTranslateCaps function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineGetTranslateCaps return and Edit box texe
+'			 
+'History: 05/03/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LGetTranslateCapsW  (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									      Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_GetTranslateCapsW , TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_GetTranslateCapsW )
+	if rtn = FALSE then
+		Call_LGetTranslateCapsW  = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_GetTranslateCapsW  )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LGetTranslateCapsW  = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LGetTranslateCapsW 
+
+'******************************************************************************
+'Name   : Call_LInitialize
+'Desc   : Invokes the lineInitialize function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'
+'Return : lineInitialize return value
+'			 
+'History: 04/17/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LInitialize (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									hLine as long, Num_Dev as short ) as long
+
+dim listItemCount as long		'holds number of items in results list box
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim firststr as string			'First Edit box string	(function return)
+dim secstr as string				'Second Edit box string (Number of devices)
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_Initialize, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_Initialize)
+	if rtn = FALSE then
+		Call_LInitialize = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get hListApp item number, should be last item
+listItemCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+'Retrieve Usage handle from Results list box
+
+tempstr = ListItemText (_hwnd(hTB_Child(TB_ResList)), listItemCount, Timeout)
+rtn = instr(1, tempstr, "=x")
+if rtn > 0 then
+	tempstr = "&h" + ltrim$(right$(tempstr, len(tempstr) - rtn -1))
+	hLine =  val(tempstr)
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_Initialize )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	firststr	= left$ (tempstr, rtn -1)
+	secstr   = right$(tempstr, len(tempstr) - rtn -1)
+endif
+
+'Retieve lineInitiate return
+rtn = instr(1, firststr, "returned")
+tempstr = ltrim$(right$(firststr, len(firststr) - rtn - len("returned")))
+
+Call_LInitialize = LineReturnValue (tempstr)
+
+'remove CRLF from second string
+rtn = instr(1, secstr, CRLF)
+
+if rtn > 0 then
+	secstr = left$(secstr, rtn -1)
+endif
+
+'retrieve number of devices from second string
+rtn = instr(1, secstr, "=")
+if rtn > 0 then
+	tempstr = right$(secstr, len(secstr) - rtn)
+	Num_Dev = val(tempstr)
+else
+	Num_Dev = 0
+endif
+ 
+EndOfFunction:
+End Function 'Call_LInitialize
+
+'******************************************************************************
+'Name   : Call_LInitializeExW
+'Desc   : Invokes the lineInitializeEx function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'
+'Return : lineInitializeExW return value
+'			 
+'History: 05/28/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LInitializeExW (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									hLine as long, Num_Dev as short, Returnstr as string ) as long
+
+dim listItemCount as long		'holds number of items in results list box
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim firststr as string			'First Edit box string	(function return)
+dim secstr as string				'Second Edit box string (Number of devices)
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_InitializeExW, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_InitializeExW)
+	if rtn = FALSE then
+		Call_LInitializeExW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get hListApp item number, should be last item
+listItemCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+'Retrieve Usage handle from Results list box
+
+tempstr = ListItemText (_hwnd(hTB_Child(TB_ResList)), listItemCount, Timeout)
+rtn = instr(1, tempstr, "=x")
+if rtn > 0 then
+	tempstr = "&h" + ltrim$(right$(tempstr, len(tempstr) - rtn -1))
+	hLine =  val(tempstr)
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_InitializeExW )
+rtn = instr(1, Returnstr, CRLF)
+if rtn > 0 then
+	firststr	= left$ (Returnstr, rtn -1)
+	secstr   = right$(Returnstr, len(Returnstr) - rtn -1)
+endif
+
+'Retieve lineInitiate return
+rtn = instr(1, firststr, "returned")
+tempstr = ltrim$(right$(firststr, len(firststr) - rtn - len("returned")))
+
+Call_LInitializeExW = LineReturnValue (tempstr)
+
+'remove CRLF from second string
+rtn = instr(1, secstr, CRLF)
+
+if rtn > 0 then
+	secstr = left$(secstr, rtn -1)
+endif
+
+'retrieve number of devices from second string
+rtn = instr(1, secstr, "=")
+if rtn > 0 then
+	tempstr = right$(secstr, len(secstr) - rtn)
+	Num_Dev = val(tempstr)
+else
+	Num_Dev = 0
+endif
+ 
+EndOfFunction:
+End Function 'Call_LInitializeExW
+
+'******************************************************************************
+'Name   : Call_LMakeCallW
+'Desc   : Invokes the lineMakeCallW function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineMakeCallW return value	 or CALL STATUS
+'			 
+'History: 04/24/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LMakeCallW (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+					   CallState as TAPIMSG, returnstr as string) as long
+
+dim Count as long					'Generic counter
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim w_flags  as long
+dim hDlg     as long
+dim TalkID	 as long				'ID for Call Status Talk button
+dim HangUpID as long				'ID for Call Status Hang Up button
+
+TalkID	= &h0514&
+HangUpID = &h0515&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_MakeCallW, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_MakeCallW)
+	if rtn = FALSE then
+		Call_LMakeCallW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+hDlg = WFndWndC (CALL_STATUS_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+if hDlg > 0 then
+	WSetActWnd (hTB20)
+endif
+
+
+'Get Edit box strings
+count = 0
+do
+	returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_MakeCallW )
+	count = count + 1
+	sleep .5
+loop until len(returnstr) > 1 or count > 10
+
+'Get the params of CallState only if there is a callstate msg specified
+if len(CallState.msg) > 0 then
+	Call_LMakeCallW = LineCallState (CallState, (returnstr))
+endif
+
+EndOfFunction:
+end Function 'Call_LMakeCall
+
+'******************************************************************************
+'Name   : Call_LNegotiateAPIVer
+'Desc   : Invokes the lineNegotiateAPIVersion function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineNegotiateAPIVersion return value
+'			 
+'History: 04/22/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LNegotiateAPIVer (hTB20 as long, hTB_Child() as long, _ 
+					  ParamSet as long, lNegVerRtn as lNegAPIV) as long
+
+dim Count as long					'Generic counter
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim returnstr as string			'Holds Return String
+dim Versionstr as string		'holds API Version
+dim IDstr		as string		'holds ID strings
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_NegotiateAPIVersion, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_NegotiateAPIVersion)
+	if rtn = FALSE then
+		Call_LNegotiateAPIVer = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+count = 0
+tempstr = space$ (1)
+do
+	tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_NegotiateAPIVersion )
+	count = count + 1
+	sleep .5
+loop until len(tempstr) > 1 or count > 10
+
+'Separate the Function return from the rest of the string
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	returnstr	= left$ (tempstr, rtn -1)
+endif
+
+if len (tempstr) > rtn + 1 then 'if text has more than return then
+  
+'save string minus return in versionstr (lines 2&3)
+	tempstr  = right$(tempstr, len(tempstr) - rtn -1)
+
+'Separate the API Version From the ID numbers
+	rtn = instr(1, tempstr, CRLF)
+	if rtn > 0 then
+		Versionstr	= left$ (tempstr, rtn -1)
+		IDstr       = right$(tempstr, len(tempstr) - rtn -1)
+	endif
+
+'Retrieve API Version
+	rtn = instr(1, Versionstr, "=x")
+	if rtn > 0 then
+		lNegVerRtn.API_Ver = right$(Versionstr, len(Versionstr) - rtn)
+	else
+		lNegVerRtn.API_Ver = "x0"
+	endif
+
+'remove CRLF from ID string
+	rtn = instr(1, IDstr, CRLF)
+
+	if rtn > 0 then
+		IDstr = left$(IDstr, rtn -1)
+	endif
+
+'retrieve ID number of devices from ID string
+	for count = 0 to 3
+		rtn  = instr(1, IDstr, "=")
+		rtn2 = instr(1, IDstr, ",")
+		lNegVerRtn.ID(count) = mid$(IDstr, rtn +1, (rtn2) - (rtn + 1))
+		idstr = right$ (idstr, len (idstr) - rtn2 - 1)
+	next
+else
+	lNegVerRtn.API_Ver	= "x0"
+	lNegVerRtn.ID(0)		= ""
+	lNegVerRtn.ID(1)		= ""
+	lNegVerRtn.ID(2)		= ""
+	lNegVerRtn.ID(3)		= ""
+endif
+
+'Retieve lineNegotiateAPIVersion return
+rtn = instr(1, returnstr, "returned")
+if rtn > 0 then 
+	tempstr = ltrim$(right$(returnstr, len(returnstr) - rtn - len("returned")))
+end if
+
+Call_LNegotiateAPIVer = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LNegotiateAPIVer
+
+'******************************************************************************
+'Name   : Call_LOpenW
+'Desc   : Invokes the lineOpen function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'			 ID - holds value of id returned by lineOpen
+'
+'Return : lineOpen return value
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LOpenW ( hTB20 as long, hTB_Child() as long, ParamSet as long, RtnlOpen as LOpenParam ) as long
+
+dim listItemCount as long		'holds number of items in results list box
+dim BeginCount						'Number of Item before lineOpen is double clicked
+dim rtn as long, rtn2 as long	'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim firststr as string			'First Edit box string	(function return)
+dim hDlg as long					'handle to parameter dialog
+
+
+BeginCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_OpenW, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_OpenW)
+	if rtn = FALSE then
+		Call_LOpenW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get listbox return values
+listItemCount = WListCount	(_hwnd(hTB_Child(TB_ResList)), Timeout)
+
+if listItemCount > BeginCount then
+
+	tempstr = ListItemText (_hwnd(hTB_Child(TB_ResList)), listItemCount, Timeout)
+	rtn = instr(1, tempstr, "=x")
+	if rtn > 0 then
+		tempstr = right$(tempstr, len(tempstr) - rtn -1)
+		rtn = instr(1, tempstr, "id")
+		firststr	= "&h" + ltrim$(left$( tempstr, rtn -1))
+		RtnlOpen.hLine =  val(firststr)
+
+		tempstr = right$(tempstr, len(tempstr) - rtn -1)
+		rtn = instr(1, tempstr, "=")
+		rtn2 = instr(rtn, tempstr, " ")
+		firststr = mid$(tempstr, rtn + 1, (rtn2-1) - (rtn + 1))
+		RtnlOpen.DevID = val(firststr)	
+	
+		RtnlOpen.Priv = Space$(1)
+		RtnlOpen.Priv = ltrim$(right$(tempstr, len(tempstr) - rtn -1))
+	endif
+
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_OpenW )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	firststr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineOpen return
+rtn = instr(1, firststr, "returned")
+tempstr = ltrim$(right$(firststr, len(firststr) - rtn - len("returned")))
+
+Call_LOpenW = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LOpen 
+
+'******************************************************************************
+'Name   : Call_LSetCurrentLocation 
+'Desc   : Invokes the lineSetCurrentLocation function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineSetCurrentLocation return and Edit box texe
+'			 
+'History: 05/03/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LSetCurrentLocation  (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									      CurCountryID as string, Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_SetCurrentLocation, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_SetCurrentLocation)
+	if rtn = FALSE then
+		Call_LSetCurrentLocation  = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_SetCurrentLocation )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LSetCurrentLocation  = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LSetCurrentLocation 
+
+'******************************************************************************
+'Name   : Call_LShutDown
+'Desc   : Invokes the lineClose function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineClose return value
+'			 
+'History: 04/19/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LShutDown ( hTB20 as long, hTB_Child() as long, ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim hDlg as long					'handle to parameter dialog
+
+Call_LShutDown = FALSE
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_ShutDown, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_ShutDown)
+	if rtn = FALSE then
+		Call_LShutDown = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_ShutDown )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LShutDown = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LShutDown 
+
+'******************************************************************************
+'Name   : Call_LTranslateAddressW
+'Desc   : Invokes the lineTranslateAddress function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : lineTranslateAddress return and Edit box text
+'			 
+'History: 05/08/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LTranslateAddressW (hTB20 as long, hTB_Child() as long, ParamSet as long, _
+									      Returnstr as string ) as long
+
+dim rtn as long					'Generic function return variable
+dim CRLFrtn as long
+dim startchar as long
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_TranslateAddressW, TimeOut) 
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_TranslateAddressW)
+	if rtn = FALSE then
+		Call_LTranslateAddressW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_TranslateAddressW )
+
+'Retieve lineGetTranslateCaps return
+rtn = instr(1, Returnstr, "returned")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+startchar = rtn + len("returned")
+tempstr = ltrim$(mid$(Returnstr, startchar ,  CRLFrtn - Startchar))
+
+Call_LTranslateAddressW = LineReturnValue (tempstr)
+ 
+EndOfFunction:
+
+End Function 'Call_LTranslateAddressW
+
+'******************************************************************************
+'Name   : Call_LTranslateDialogW
+'Desc   : Invokes the lineTranslateDialog function on TB 
+'			 
+'Parms  : hChild_TB() array of child handles
+'			 ParamSet - state of param checkbox
+'
+'Return : lineTranslateDialog return value
+'			 
+'History: 05/08/96 : a-rrohr: Created
+'*****************************************************************************
+Function Call_LTranslateDialogW ( hTB20 as long, hTB_Child() as long, HDlg as long, _
+											ParamSet as long ) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+dim w_flags as long           'used with WFndWnd function
+dim txtAreaCodeID as long		'IDs
+dim txtAccessCodeID as long
+dim cmdCloseID as long
+dim cmdOKID as long
+dim hctrl as long					'Generic control handle
+dim handle as long				'Generic handle
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), LAPI_TranslateDialogW, TimeOut)
+sleep .1
+
+if ParamSet then
+	rtn = SetParamAttrib (LAPI_TranslateDialogW)
+	if rtn = FALSE then
+		Call_LTranslateDialogW = FALSE
+		goto EndOfFunction
+	endif
+endif
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'FW_PART OR 
+
+' Find Location Information window and if it exists close it
+handle =  WFndWndC (LOC_INFO_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if handle <> 0 then
+   txtAreaCodeID   = &h0000040E&
+   txtAccessCodeID = &h0000040C&
+	cmdCloseID		 = &h00000001&
+	WSetActWnd (handle)
+
+	hctrl = GetDlgItem (handle, txtAreaCodeID)
+	if hctrl <> 0 then
+		WEditSetText  (_hwnd(hctrl), "333")
+	end if
+
+	hctrl = GetDlgItem (handle, txtAccessCodeID)
+   if hctrl <> 0 then
+      WEditSetText  (_hwnd(hctrl), "7")
+	end if
+
+	hctrl = GetDlgItem (handle, cmdCloseID)
+	WButtonClick (_hwnd(hctrl))
+
+endif
+
+' Find Dialing Properties window and close it
+hDlg = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+if hDlg <> 0 then
+	cmdOKID = &h00000001&
+	hctrl = GetDlgItem (hdlg, cmdOKID)
+	WButtonClick (_hwnd(hctrl))
+else
+	WritelogItem ("Unable to Find Dialing Properties dialog " , "")
+endif
+
+'Get Edit box strings
+tempstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), LAPI_TranslateDialogW )
+rtn = instr(1, tempstr, CRLF)
+if rtn > 0 then
+	tempstr	= left$ (tempstr, rtn -1)
+endif
+
+'Retieve lineClose return
+rtn = instr(1, tempstr, "returned")
+tempstr = ltrim$(right$(tempstr, len(tempstr) - rtn - len("returned")))
+
+Call_LTranslateDialogW = LineReturnValue (tempstr)
+
+EndOfFunction:
+End Function 'Call_LTranslateDialogW 
+
+'******************************************************************************
+'Name   : TCloseHandle
+'Desc   : Invokes the CloseHandle function on TB 
+'			 
+'Parms  : hChild_TB(): array of child handles
+'			 Returnstr: string containg return text
+'
+'Return : Close Handle return and Edit box text
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function TCloseHandle (hTB20 as long, hTB_Child() as long, ParamSet as long,_ 
+							  returnstr as string) as long
+
+dim rtn as long					'Generic function return variable
+dim tempstr as string			'Generic String variable
+
+WListItemDblClk (_hwnd(hTB_Child(TB_APIList)), CLOSE_HANDLE, TimeOut) 
+TCloseHandle = FALSE
+
+if ParamSet then
+	rtn = SetParamAttrib (CLOSE_HANDLE)
+	if rtn = FALSE then
+		goto EndOfFunction
+	endif
+endif
+
+'Get Edit box strings
+Returnstr = GetEditResults ((hTB20), hTB_Child(TB_ResEdit), CLOSE_HANDLE )
+
+rtn = instr(1, Returnstr, "err")
+if rtn = 0 then 
+	TCloseHandle = True
+endif 
+EndOfFunction:
+
+End Function 'CloseHandle
+
+ '******************************************************************************
+'Name   : GetEditResults
+'Desc   : Retrives text from TB20 edit box, saves it to a file and then clears
+'			 the edit box 
+'			 
+'Parms  : hTB20: handle to TB20
+'			 hTBEdit: handle to TB20 editbox
+'			 API_CALL: TAPI call that generated the text in the edit field
+'
+'Return : TAPI API Call results value
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function GetEditResults (hTB20 as long, hTBEdit as long, API_CALL as string) as string
+
+dim tempstr as string
+dim LogFilename as string
+dim rtn as long
+dim FileNum as short
+Static FileOutputCount as short
+
+if SlowPC then
+	sleep .6
+else
+	sleep .1
+end if
+
+tempstr = space$(1)
+tempstr = edittext(_hwnd(hTBEdit), 1)
+
+LogFilename = Space$(168)
+rtn = GetWindowsDirectory (LogFilename, len(LogFilename))
+LogFilename = LogFilename + TB_EDIT_FILE
+
+if FileOutputCount = 0 then
+	FileNum = FreeFile
+	Open  LogFilename for Output as FileNum
+	Print #FileNum,"TEST CASE " + ltrim$(str$(TC_ID)) + " " + API_CALL
+	Print #FileNum, tempstr
+	Close FileNum
+else
+	FileNum = FreeFile
+	Open  LogFilename for Append as FileNum
+	Print #FileNum,"TEST CASE " + ltrim$(str$(TC_ID)) + " " + API_CALL
+	Print #FileNum, tempstr
+	Close FileNum
+endif
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MCLEAR, TIMEOUT)
+
+GetEditResults = tempstr
+
+FileOutputCount = FileOutputCount + 1
+
+end function 'GetEditResults
+
+'******************************************************************************
+'Name   : GetModemName
+'Desc   : Retrives Modem name hObject (as string) from returnstr.  
+'			 
+'Parms  : Returnstr: string containg return text from lineDial function call
+'
+'Return : Modem Name, Also hObject is modified by the function
+'			 
+'History: 05/10/96 : a-rrohr: Created
+'*****************************************************************************
+Function GetModemName ( Returnstr as string, strhObject as string) as string
+
+dim tempstr as string
+dim rtn as long
+dim CRLFrtn as long
+dim periodrtn as long
+dim count as short
+
+GetModemName = ""
+
+'Get hObject
+rtn = instr(1, returnstr, "dwStringOffset")
+CRLFrtn = instr(rtn, returnstr, CRLF)
+strhObject = ltrim$(mid$(returnstr, CRLFrtn + 2, 12))
+
+'Get ModemName
+periodrtn = instr(CRLFrtn, returnstr, "."+ CRLF)
+tempstr = " "
+count = 0
+while (Periodrtn > CRLFrtn AND count < 10)
+	TempStr = TempStr + Mid$(returnstr, CRLFrtn + 2 + 41, 16)
+	CRLFrtn = instr(CRLFrtn + 2, returnstr, CRLF)
+	count = count + 1
+wend
+
+tempstr = Ltrim$(Rtrim$(tempstr))
+rtn = instr(1, tempstr, ("." + CRLF))
+if rtn > 0 then
+	tempstr = left$(tempstr, len(tempstr) - (len(tempstr) - rtn + 1))
+	GetModemName = left$(tempstr, len(tempstr) - (len(tempstr) - rtn + 1))
+endif
+
+End Function 'GetModemName 
+
+'******************************************************************************
+'Name   : SetParamState
+'Desc   : Set the Param checkbox to the desired state 
+'			 
+'Parms  : hTB20 handle to TAPI Browser
+'			 State state to set Param checkbox
+'
+'Return : TRUE if Param checkbox is set
+'			 FALSE if Param checkbox is reset
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function SetParamState (hTB20 as long, State as long)	as long
+
+dim ParamID as long
+dim hParam	as long
+
+ParamID = &h03F9&
+
+hParam = GetDlgItem (hTB20, ParamID)
+
+select case State
+
+	case CHECKED
+		WCheckCheck (_hwnd(hParam), TIMEOUT)
+		SetParamState = TRUE
+	case UNCHECKED
+		WCheckUnCheck (_hwnd(hParam), TIMEOUT)
+		SetParamState = FALSE
+
+end select
+
+end Function 'SetParamState 
+
+'******************************************************************************
+'Name   : SetParamAttrib
+'Desc   : Set the Parameters of the TAPI call 
+'			 
+'Parms  : API_CALL: Title of the dialog caption
+'			 Uses Global array ParamTraits
+'
+'Return : TRUE if Parameters as set correctly
+'			 otherwise FALSE 
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'*****************************************************************************
+Function SetParamAttrib (API_CALL as string)	as long
+
+dim w_flags       as long	'flags for WFndWndC
+dim Param_lstID   as long	'Parameter list box id
+dim Value_cboID   as long	'Value combobox id
+dim BitFlag_lstID as long	'BitFlag list box id
+dim OK_cmdID      as long
+dim Cancel_cmdID  as long
+dim cbo_EditID    as long	'Value combobox editbox id
+dim cbo_ListID    as long	'Value combobox listbox id
+dim hDlg				as long  'handle to Parameter dialog
+dim hParam			as long	'handle to Parameter listbox
+dim hValue			as long	'handle to Value Combobox
+dim hBitFlag		as long	'handle to BitFlag listbox
+dim hValueEdit		as long	'handle to Value Combobox Edit box
+dim hValueList		as long	'handle to Value Combobox List box
+dim hOK_cmd 		as long	'handle to OK Button
+Dim NumSelections As short
+Dim Item				As short
+Dim intarray		As Pointer To LONG
+dim count as long, lArrayLimit as long, uArrayLimit as long
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+
+Param_lstID	  =&h03E8&
+Value_cboID	  =&h03EA&
+BitFlag_lstID =&h03E9&
+OK_cmdID		  =&h01&
+Cancel_cmdID  =&h02&
+cbo_EditID	  =&h03E9&
+cbo_ListID	  =&h03E8&
+
+SetParamAttrib = TRUE
+
+'Get handle to Parameter dialog or exit
+hDlg = WFndWndC (API_CALL, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+if hDlg = 0 then
+	SetParamAttrib = FALSE
+   WritelogItem ("Unable to locate Parameter dialog for", API_CALL)
+	GoTo EndOfFunction
+endif
+
+'Get handles to dialog controls
+hParam	= GetDlgItem (hDlg, Param_lstID)
+hValue	= GetDlgItem (hDlg, Value_cboID)
+	hValueEdit	= GetDlgItem (hValue, cbo_EditID)
+	hValueList	= GetDlgItem (hValue, cbo_ListID)
+hBitFlag = GetDlgItem (hDlg, BitFlag_lstID)
+hOK_cmd  = GetDlgItem (hDlg, OK_cmdID)
+
+lArrayLimit = lbound(ParamTraits)
+uArrayLimit = ubound(ParamTraits)
+
+'Set Parameters of dialog
+for count = lArrayLimit to uArrayLimit
+
+	if ParamTraits(count).Param <> "" then
+		WListItemClk (_hwnd(hParam), ParamTraits(count).Param, TIMEOUT) 
+	endif
+
+	if ParamTraits(count).BitFlagList <> "" then
+		if count = 0 then 
+			'if any items in the bitflag list are selected prior to setting the first bitflag
+			'then deselect them 
+			NumSelections = WListSelCount(_hwnd(hBitFlag))
+
+			If (NumSelections > 0) Then
+				Allocate intarray, NumSelections
+				WListSelItems (_hwnd(hBitFlag), intarray)
+				For item = 1 to NumSelections
+					WListItemClk(_hwnd(hBitFlag), _ord(intarray[item-1]))
+				Next item
+				DeAllocate intarray
+			endif
+		endif
+		WListItemClk (_hwnd(hBitFlag), ParamTraits(count).BitFlagList, TIMEOUT) 
+
+	endif
+
+	if ParamTraits(count).ValueEdit <> "" then	
+		WEditSetText (_hwnd(hValueEdit), ParamTraits(count).ValueEdit, TIMEOUT)
+	endif
+
+	if ParamTraits(count).ValueList <> "" then
+		WComboItemClk (_hwnd(hValue), ParamTraits(count).ValueList, TIMEOUT) 
+	endif
+next 'count
+'Close dialog
+WButtonClick(_hwnd(hOK_cmd), TIMEOUT)	 
+
+EndOfFunction:
+end function 'SetParamAttrib
+
+'******************************************************************************
+'Name   : MsgSplitter
+'Desc   : Takes the Returntxt and looks for the given message (MsgStruct.Msg).
+'			 If found then the removes the message (and all proceeding text from
+'			 the tesxt string and copies the message parameters into MsgStruct.
+'			 The MsgStruct and revised text string is then returned along with 
+'			 Function = True
+'			 else The function returns False.
+'			 
+'Parms  : Retundtxt: Text in TAPI Browser edit box returned by TAPI call
+'			 MsgStruct: Message structure with parameter
+'
+'Return : True is Message is found otherwis False
+'			 
+'History: 05/02/96 : a-rrohr: Created
+'*****************************************************************************
+Function MsgSplitter (Returntxt as string, MsgStruct as TAPIMSG) as long
+
+dim tempstr as string, editstr as string, fieldstr as string
+dim rtn as long, CRLFrtn as long, paramrtn as long
+dim count as short
+
+tempstr = space$(1)
+
+rtn = instr (1, Returntxt, MsgStruct.Msg)
+if rtn > 0 then
+
+	'remove LINE_CALLSTATE 
+	CRLFrtn = instr(rtn, Returntxt, CRLF)
+	editstr = right$(Returntxt, len(Returntxt) - CRLFrtn -1)
+	'Fill CALLSTATEMSG structure
+	for count = 1 to 5
+		paramrtn = instr(1, editstr, "=") 
+		CRLFrtn = instr(paramrtn, editstr, CRLF)
+		if paramrtn > 0 AND CRLFrtn > 0 then
+			fieldstr = mid$(editstr, paramrtn + 1, CRLFrtn - paramrtn -1)
+			editstr = right$(editstr, len(editstr) - CRLFrtn -1)
+			select case count
+				case 1
+					MsgStruct.device = fieldstr 
+				case 2 
+					MsgStruct.cbInst = fieldstr 
+				case 3 
+					MsgStruct.param1 = fieldstr 
+				case 4 
+					MsgStruct.param2 = fieldstr 
+				case 5 
+					MsgStruct.param3 = fieldstr 
+			end select
+		end if  'paramrtn > 0 AND CRLFrtn > 0
+	next 'count
+else
+	MsgSplitter = FALSE
+endif
+
+end function 'MsgSplitter
+
+'*****************************************************************************
+'Name   : DeleteESPtsp 
+'Desc   : Calls the Registry editor and sets Telephony locations 
+'			 NumEntries value equal to zero 
+'         
+'Parms  : None 
+'			 
+'Return : TRUE if successful in setting NumEntries equal to zero, 
+'			 otherwise false
+'
+'History: 02/14/96 : a-rrohr: Created
+'*****************************************************************************
+
+Function DeleteESPtsp () as short
+
+dim handle as long, hTree as long, hList as long		'handles for regedit
+dim hdialog as long, hEdit as long, hOKcmd as long		'handles for Edit dialog
+dim hButton as long, w_flags as long, exitdoloop as long
+dim treepath as string
+dim Windowpath as string
+dim Viewitem   as string
+dim providername as string
+dim rtn as long, count as short
+dim Value_txtID as long, OK_cmdID as long					'Edit dialog control IDs
+
+Value_txtID = &h03E9&
+OK_cmdID =&h0001&
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+
+WindowPath = space$(64)
+GetWindowsDirectory (WindowPath, len(WindowPath))
+
+Run (WindowPath + "\Regedit.exe"), NOWAIT
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, WTIMEOUT)
+
+if handle = 0 then
+	DeleteESPtsp = FALSE
+   WritelogItem ("", "Invailid handle to Registry Editor")
+	goto End_Of_Sub 
+end if
+
+hTree = GetDlgItem (handle, &h00000001)
+if hTree = 0 then
+	DeleteESPtsp = FALSE
+   WritelogItem ("", "Invailid handle to Registry Editor Tree")
+	goto End_Of_Sub 
+end if
+
+hList = GetDlgItem (handle, &h00000002)
+if hList = 0 then
+	DeleteESPtsp = FALSE
+   WritelogItem ("", "Invailid handle to Registry Editor List")
+	goto End_Of_Sub 
+end if
+
+WTreeItemExpand (_hwnd(hTree), REG_lOC_PATH, TIMEOUT)
+WTreeItemClk (_hwnd(hTree), REG_lOC_PATH, VK_LBUTTON, TIMEOUT)
+sleep 1
+
+' The first time dialing properties is invoked the NumEntries dword may not exist.
+
+viewitem = Space$(1)
+count = 0
+do
+  exitdoloop = TRUE
+  viewitem = "ProviderFilename" + ltrim$(str$(count))
+  if WViewItemExists (_hwnd(hList), viewitem, TIMEOUT) then
+    exitdoloop = FALSE
+	WViewItemDblClk (_hwnd(hList), viewitem, VK_LBUTTON, TIMEOUT)
+	hDialog = WFndWndC ("Edit String", DIALOG_CLASS , w_flags, WTIMEOUT)
+	if hDialog = 0 then
+		DeleteESPtsp = FALSE
+		WritelogItem ("", "Invailid handle to Edit dialog")
+		goto End_Of_Sub 
+	end if
+	hEdit = GetDlgItem (hDialog, Value_txtID) 
+	if hEdit = 0 then
+		DeleteESPtsp = FALSE
+		WritelogItem ("", "Invailid handle to Edit dialog Value data edit box")
+		goto End_Of_Sub 
+	end if
+	hOKcmd = GetDlgItem (hDialog, OK_cmdID)
+	if hOKcmd = 0 then
+		DeleteESPtsp = FALSE
+		WritelogItem ("", "Invailid handle to Edit dialog OK button")
+		goto End_Of_Sub 
+	end if
+	providername = editText (_hwnd(hEdit), Timeout)
+	WButtonClick (_hwnd(hOKcmd), Timeout)
+	if providername = "esp32.tsp" then
+        exitdoloop = TRUE
+		WMenuSelect ("&Edit\Delete")
+		hDialog = WFndWndC ("Confirm Value Delete", DIALOG_CLASS , w_flags, WTIMEOUT)
+		hButton = GetDlgItem (hDialog, &h6&)
+		WButtonClick (_hwnd(hButton), Timeout)
+	endif
+  endif
+  count = count + 1
+
+loop until exitdoloop
+
+DONE:' if numentries doesn't exist then jump here
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, WTIMEOUT)
+
+WSetActWnd (handle)
+WMenuSelect ("&Registry\E&xit", TIMEOUT)
+
+End_Of_Sub:  'line lable
+
+end Sub 'DeleteESPtsp
+
+'*****************************************************************************
+'Name   : RestoreProviders 
+'Desc   : Restores Telephony Providers information saved with function
+'			 SetupProviders
+'         
+'Parms  : None 
+'			 
+'Return : None 
+'
+'History: 05/16/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub RestoreProviders ()
+
+dim handle as long, hReg as long, hLocal as long		'handles for regedit
+dim Windowpath as string, SystemPath as string
+dim FindWhatID as long, FindNextID as long, count as long					'Find dialog control IDs
+dim OKID as long, YesID as long, KeyNameID as long
+dim FileNameID as long, CancelID as long
+dim hCtrl as long, w_flags as long, hDlg as long					
+dim RegPath(5) as string
+
+RegPath(0) = "Software"
+RegPath(1) = "Microsoft"
+RegPath(2) = "Windows"
+RegPath(3) = "CurrentVersion"
+RegPath(4) = "Telephony"
+RegPath(5) = "Providers"
+
+'Find dialog IDs
+FindWhatID = &h0480&
+FindNextID = &h0001&
+CancelID   = &h0002&
+
+'Other IDs
+OKID		  = &h0001& 
+YesID		  = &h0006& 
+KeyNameID  = &h0068&
+FileNameID = &h0480&
+
+	'Open Registry Editor 32 and put the focus on the Telephony\Provider key
+	WindowPath = space$(64)
+	GetWindowsDirectory (WindowPath, len(WindowPath))
+	SystemPath = space$(64)
+	GetSystemDirectory (SystemPath, len(SystemPath))
+
+	Run (SystemPath + "\Regedt32.exe"), NOWAIT
+
+	handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, TIMEOUT)
+
+	hReg = WFndWndC (LOC_MACH_CAPTION, REGWIN_CLASS , w_flags, TIMEOUT)
+	WMaxWnd (hReg)
+
+	'Go to Providers key
+	For count = lbound(RegPath) to ubound(RegPath)
+		WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+		hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+		hctrl = GetDlgItem (hDlg, FindWhatID ) 
+		WEditSetText (_hwnd(hCtrl), RegPath(Count), Timeout )
+		hctrl = GetDlgItem (hDlg, FindNextID) 
+	 	WButtonClick(_hwnd(hCtrl), Timeout )
+	next
+	'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	'Select Registry, Restore Key Menu and complete dialog 
+	WMenuSelect (MREG + "\" + MRESTORE, TIMEOUT)
+	hDlg = WFndWndC (RESKEY_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, FileNameID)
+	WEditSetText (_hwnd(hCtrl), Windowpath + KEY_FILENAME, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID)
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	'Close Warning Dialog
+	hDlg = WFndWndC (WARNING_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, YesID)
+  	WButtonClick(_hwnd(hCtrl), Timeout )
+
+
+	'Delete file %windir%\Providers.key
+	if exists (Windowpath + KEY_FILENAME) then
+		Kill (Windowpath + KEY_FILENAME)
+	endif
+
+	'Close Registry Editor 32
+	WResWnd (hReg)
+	WSetActWnd (handle)
+	WMenuSelect (MREG + "\" + MExit, TIMEOUT)
+ 
+End Sub 'RestoreProviders
+
+'*****************************************************************************
+'Name   : SetupProviders 
+'Desc   : Calls the Registry editor, saves Telephony\Providers in a file 
+'			 and configures the providers to kmddsptsp and unimdm.tsp 
+'         
+'Parms  : None 
+'			 
+'Return : None 
+'
+'History: 05/15/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub SetupProviders ()
+
+dim handle as long, hReg as long, hLocal as long		'handles for regedit
+dim Windowpath as string, SystemPath as string
+dim rtn as long, count as short
+dim FindWhatID as long, FindNextID as long					'Find dialog control IDs
+dim CancelID as long, UpID as long, DownID as long
+dim OKID as long, YesID as long, KeyNameID as long
+dim FileNameID as long
+dim hCtrl as long, w_flags as long, hDlg as long					
+dim RegPath(5) as string
+dim ProviderParam(5) as ParamInfo
+dim ValueNameID as long, DataTypeID as long, DataEditID as long
+
+RegPath(0) = "Software"
+RegPath(1) = "Microsoft"
+RegPath(2) = "Windows"
+RegPath(3) = "CurrentVersion"
+RegPath(4) = "Telephony"
+RegPath(5) = "Providers"
+
+ProviderParam(0).VName = "NextProviderID"
+ProviderParam(0).DType = "REG_DWORD"
+ProviderParam(0).Value = "3"
+ProviderParam(1).VName = "NumProviders"
+ProviderParam(1).DType = "REG_DWORD"
+ProviderParam(1).Value =  "2"
+ProviderParam(2).VName = "ProviderFilename0"
+ProviderParam(2).DType = "REG_SZ"
+ProviderParam(2).Value = "kmddsp.tsp"
+ProviderParam(3).VName = "ProviderFilename1"
+ProviderParam(3).DType = "REG_SZ"
+ProviderParam(3).Value = "unimdm.tsp"
+ProviderParam(4).VName = "ProviderID0"
+ProviderParam(4).DType = "REG_DWORD"
+ProviderParam(4).Value = "1"
+ProviderParam(5).VName = "ProviderID1"
+ProviderParam(5).DType = "REG_DWORD"
+ProviderParam(5).Value = "2"
+
+'Find dialog IDs
+FindWhatID = &h0480&
+FindNextID = &h0001&
+CancelID   = &h0002&
+UpID		  = &h0420&
+DownID	  = &h0421&
+
+'Other IDs
+OKID		  = &h0001& 
+YesID		  = &h0006& 
+KeyNameID  = &h0068&
+FileNameID = &h0480&
+
+ValueNameID = &h012E& 
+DataTypeID  = &h012D&
+DataEditID  = &h02C1&
+
+TIMEOUT = 3
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST OR FW_NOERROR _
+			 OR FW_FOCUS OR FW_NOCASE  
+
+WindowPath = space$(64)
+GetWindowsDirectory (WindowPath, len(WindowPath))
+SystemPath = space$(64)
+GetSystemDirectory (SystemPath, len(SystemPath))
+
+Run (SystemPath + "\Regedt32.exe"), NOWAIT
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, TIMEOUT)
+
+hReg = WFndWndC (LOC_MACH_CAPTION, REGWIN_CLASS , w_flags, TIMEOUT)
+WMaxWnd (hReg)
+
+'Go to Providers key
+For count = lbound(RegPath) to ubound(RegPath)
+	WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+	hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, FindWhatID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(Count), Timeout )
+	hctrl = GetDlgItem (hDlg, FindNextID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+next
+'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Save Providers key in Windows directory
+	if exists (Windowpath + KEY_FILENAME) then
+		Kill (Windowpath + KEY_FILENAME)
+	endif
+	WMenuSelect (MREG + "\" + MSAVE_KEY, TIMEOUT)
+	hDlg = WFndWndC (SAVEKEY_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, FileNameID)
+	WEditSetText (_hwnd(hCtrl), Windowpath + KEY_FILENAME, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID)
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Delete Providers Key
+   WMenuSelect (MEDIT + "\" + MDEL, TIMEOUT)
+	hDlg = WFndWndC (WARNING_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, YesID)
+  	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Make way back to Telphony key
+	WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+	hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	'Set Up Option Button
+	hctrl = GetDlgItem (hDlg, UpID ) 
+	WOptionClick (_Hwnd(hctrl), TIMEOUT)
+	'Set key to Telephony
+	hctrl = GetDlgItem (hDlg, FindWhatID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(4), Timeout )
+	hctrl = GetDlgItem (hDlg, FindNextID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+   'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Add new Providers key
+	WSetActWnd (handle)
+	WMenuSelect (MEDIT + "\" + MADDKEY, TIMEOUT)	
+	hDlg = WFndWndC (ADDKEY_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, KeyNameID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(5), Timeout )
+	hctrl = GetDlgItem (hDlg, OKID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	'Put focus back on Providers
+	WMenuSelect (MView	+ "\" + MFKey, TIMEOUT)	
+	hDlg = WFndWndC (FIND_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	'Set Up Option Button
+	hctrl = GetDlgItem (hDlg, DownID ) 
+	WOptionClick (_Hwnd(hctrl), TIMEOUT)
+	'Set key to Telephony
+	hctrl = GetDlgItem (hDlg, FindWhatID ) 
+	WEditSetText (_hwnd(hCtrl), RegPath(5), Timeout )
+	hctrl = GetDlgItem (hDlg, FindNextID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+   'Close Find key dialog
+	hctrl = GetDlgItem (hDlg, CancelID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+'Add Providers key parameters
+
+For count = lbound(ProviderParam) to ubound(ProviderParam)
+	WMenuSelect (MEDIT +"\"+ MADDVAL, TIMEOUT)	
+	hDlg = WFndWndC (ADDVALUE_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	hctrl = GetDlgItem (hDlg, ValueNameID ) 
+	WEditSetText (_hwnd(hCtrl), ProviderParam(Count).VName, Timeout )
+	hctrl = GetDlgItem (hDlg, DataTypeID) 
+ 	WComboItemClk(_hwnd(hCtrl), ProviderParam(Count).DType, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+
+	if ProviderParam(Count).DType = "REG_SZ" then
+		hDlg = WFndWndC (RSTR_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	else
+		hDlg = WFndWndC (DWORD_CAPTION, DIALOG_CLASS , w_flags, TIMEOUT)
+	endif
+	hctrl = GetDlgItem (hDlg, DataEditID ) 
+	WEditSetText (_hwnd(hCtrl), ProviderParam(Count).Value, Timeout )
+	hctrl = GetDlgItem (hDlg, OKID) 
+ 	WButtonClick(_hwnd(hCtrl), Timeout )
+	Sleep 1
+next
+
+WResWnd (hReg)
+WSetActWnd (handle)
+WMenuSelect (MREG + "\" + MExit, TIMEOUT)
+
+End Sub 'SetupProviders
+
+'******************************************************************************
+'Name   : LineCallState
+'Desc   : Checks the TAPI call for LINE_CALLSTATE, and verifies param1
+'			 
+'Parms  : CallStateMsg 
+'			 EditString
+'
+'Return : True if LINE_CALLSTATE param1 is expected value, otherwise false
+'			 also fills CallStateMsg with data returned by call
+'
+'History: 04/25/96 : a-rrohr: Created
+'*****************************************************************************
+Function LineCallState (CALLSTATEMSG as TAPIMSG, Editstr as string) as long 
+
+dim tempstr as string
+dim rtn as long, paramrtn as long, CRLFrtn as long, count as long, functstate as long
+dim param1str as string, fieldstr as string
+
+LineCallState = FALSE
+functstate    = FALSE
+param1str	  = CALLSTATEMSG.param1
+
+
+rtn = instr (1, EditStr, CALLSTATEMSG.Errorstr)
+if rtn = 0 then
+	CALLSTATEMSG.Errorstr = ""
+endif
+do
+	'Find LINE_CALLSTATE in return text
+	rtn = instr (1, EditStr, "LINE_CALLSTATE")
+	if rtn > 0 then   'Fill CallStateMsg with LINE_CALLSTATE parameters
+		
+		'remove LINE_CALLSTATE 
+		CRLFrtn = instr(rtn, editstr, CRLF)
+		editstr = right$(editstr, len(editstr) - CRLFrtn -1)
+		'Fill CALLSTATEMSG structure
+		for count = 1 to 5
+			paramrtn = instr(1, editstr, "=") 
+			CRLFrtn = instr(paramrtn, editstr, CRLF)
+			if paramrtn > 0 AND CRLFrtn > 0 then
+				fieldstr = mid$(editstr, paramrtn + 1, CRLFrtn - paramrtn -1)
+				editstr = right$(editstr, len(editstr) - CRLFrtn -1)
+				select case count
+					case 1
+						CALLSTATEMSG.device = fieldstr 
+					case 2 
+						CALLSTATEMSG.cbInst = fieldstr 
+					case 3 
+						CALLSTATEMSG.param1 = fieldstr 
+					case 4 
+						CALLSTATEMSG.param2 = fieldstr 
+					case 5 
+						CALLSTATEMSG.param3 = fieldstr 
+				end select
+			end if  'paramrtn > 0 AND CRLFrtn > 0
+		next 'count
+		'test for param1
+
+		paramrtn = instr(1, CALLSTATEMSG.param1, ",")
+		tempstr = ltrim$(rtrim$(right$(CALLSTATEMSG.param1, len(CALLSTATEMSG.param1) - paramrtn -1)))
+
+		if tempstr = param1str then
+			LineCallState = TRUE
+			functstate	  = TRUE
+		else
+			LineCallState = FALSE
+			functstate	  = FALSE
+		endif	'CALLSTATEMSG.param1 = param1str
+		
+	endif	'rtn > 0
+
+loop until (rtn = 0) or (functstate = TRUE)
+
+end Function 'LineCallState 
+
+'******************************************************************************
+'Name   : LineReturnValue
+'Desc   : Returns the numeric error code associated with the line error string 
+'			 
+'Parms  : Line Error String
+'
+'Return : Error code
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'******************************************************************************
+Function LineReturnValue  (ErrorStr as string) as long
+
+select case ErrorStr
+
+   case "SUCCESS"
+		LineReturnValue = &h0&
+	case "LINEERR_ALLOCATED"                   
+	   LineReturnValue = &h80000001
+   case "LINEERR_BADDEVICEID"
+      LineReturnValue = &h80000002
+   case "LINEERR_BEARERMODEUNAVAIL"           
+	   LineReturnValue = &h80000003
+   case "LINEERR_CALLUNAVAIL"                 
+	   LineReturnValue = &h80000005
+   case "LINEERR_COMPLETIONOVERRUN"           
+	   LineReturnValue = &h80000006
+   case "LINEERR_CONFERENCEFULL"              
+	   LineReturnValue = &h80000007
+   case "LINEERR_DIALBILLING"                 
+	   LineReturnValue = &h80000008
+   case "LINEERR_DIALDIALTONE"                
+	   LineReturnValue = &h80000009
+   case "LINEERR_DIALPROMPT"                  
+	   LineReturnValue = &h8000000A
+   case "LINEERR_DIALQUIET"
+	   LineReturnValue = &h8000000B
+   case "LINEERR_INCOMPATIBLEAPIVERSION"      
+	   LineReturnValue = &h8000000C
+   case "LINEERR_INCOMPATIBLEEXTVERSION"      
+	   LineReturnValue = &h8000000D
+   case "LINEERR_INIFILECORRUPT"              
+	   LineReturnValue = &h8000000E
+   case "LINEERR_INUSE"                       
+	   LineReturnValue = &h8000000F
+   case "LINEERR_INVALADDRESS"                
+	   LineReturnValue = &h80000010
+   case "LINEERR_INVALADDRESSID"              
+	   LineReturnValue = &h80000011
+   case "LINEERR_INVALADDRESSMODE"            
+	   LineReturnValue = &h80000012
+   case "LINEERR_INVALADDRESSSTATE"           
+	   LineReturnValue = &h80000013
+   case "LINEERR_INVALAPPHANDLE"              
+	   LineReturnValue = &h80000014
+   case "LINEERR_INVALAPPNAME"                
+	   LineReturnValue = &h80000015
+   case "LINEERR_INVALBEARERMODE"             
+	   LineReturnValue = &h80000016
+   case "LINEERR_INVALCALLCOMPLMODE"          
+	   LineReturnValue = &h80000017
+   case "LINEERR_INVALCALLHANDLE"             
+	   LineReturnValue = &h80000018
+   case "LINEERR_INVALCALLPARAMS"             
+	   LineReturnValue = &h80000019
+   case "LINEERR_INVALCALLPRIVILEGE"          
+	   LineReturnValue = &h8000001A
+   case "LINEERR_INVALCALLSELECT"             
+	   LineReturnValue = &h8000001B
+   case "LINEERR_INVALCALLSTATE"              
+	   LineReturnValue = &h8000001C
+   case "LINEERR_INVALCALLSTATELIST"          
+	   LineReturnValue = &h8000001D
+   case "LINEERR_INVALCARD"                   
+	   LineReturnValue = &h8000001E
+   case "LINEERR_INVALCOMPLETIONID"           
+	   LineReturnValue = &h8000001F
+   case "LINEERR_INVALCONFCALLHANDLE"         
+	   LineReturnValue = &h80000020
+   case "LINEERR_INVALCONSULTCALLHANDLE"      
+	   LineReturnValue = &h80000021
+   case "LINEERR_INVALCOUNTRYCODE"            
+	   LineReturnValue = &h80000022
+   case "LINEERR_INVALDEVICECLASS"            
+	   LineReturnValue = &h80000023
+   case "LINEERR_INVALDEVICEHANDLE"           
+	   LineReturnValue = &h80000024
+   case "LINEERR_INVALDIALPARAMS"             
+	   LineReturnValue = &h80000025
+   case "LINEERR_INVALDIGITLIST"              
+	   LineReturnValue = &h80000026
+   case "LINEERR_INVALDIGITMODE"              
+	   LineReturnValue = &h80000027
+   case "LINEERR_INVALDIGITS"                 
+	   LineReturnValue = &h80000028
+   case "LINEERR_INVALEXTVERSION"             
+	   LineReturnValue = &h80000029
+   case "LINEERR_INVALGROUPID"                
+	   LineReturnValue = &h8000002A
+   case "LINEERR_INVALLINEHANDLE"             
+	   LineReturnValue = &h8000002B
+   case "LINEERR_INVALLINESTATE"             
+	   LineReturnValue = &h8000002C
+   case "LINEERR_INVALLOCATION"               
+	   LineReturnValue = &h8000002D
+   case "LINEERR_INVALMEDIALIST"              
+	   LineReturnValue = &h8000002E
+   case "LINEERR_INVALMEDIAMODE"              
+	   LineReturnValue = &h8000002F
+   case "LINEERR_INVALMESSAGEID"              
+	   LineReturnValue = &h80000030
+   case "LINEERR_INVALPARAM"                  
+	   LineReturnValue = &h80000032
+   case "LINEERR_INVALPARKID"                 
+	   LineReturnValue = &h80000033
+   case "LINEERR_INVALPARKMODE"               
+	   LineReturnValue = &h80000034
+   case "LINEERR_INVALPOINTER"                
+	   LineReturnValue = &h80000035
+   case "LINEERR_INVALPRIVSELECT"             
+	   LineReturnValue = &h80000036
+   case "LINEERR_INVALRATE"           
+	   LineReturnValue = &h80000037
+   case "LINEERR_INVALREQUESTMODE"            
+	   LineReturnValue = &h80000038
+   case "LINEERR_INVALTERMINALID"             
+	   LineReturnValue = &h80000039
+   case "LINEERR_INVALTERMINALMODE"           
+	   LineReturnValue = &h8000003A
+   case "LINEERR_INVALTIMEOUT"                
+	   LineReturnValue = &h8000003B 
+   case "LINEERR_INVALTONE"                   
+	   LineReturnValue = &h8000003C
+   case "LINEERR_INVALTONELIST"               
+	   LineReturnValue = &h8000003D
+   case "LINEERR_INVALTONEMODE"               
+	   LineReturnValue = &h8000003E
+   case "LINEERR_INVALTRANSFERMODE"           
+	   LineReturnValue = &h8000003F
+   case "LINEERR_LINEMAPPERFAILED"            
+	   LineReturnValue = &h80000040
+   case "LINEERR_NOCONFERENCE"                
+	   LineReturnValue = &h80000041
+   case "LINEERR_NODEVICE"                    
+	   LineReturnValue = &h80000042
+   case "LINEERR_NODRIVER"                    
+	   LineReturnValue = &h80000043
+   case "LINEERR_NOMEM"                       
+	   LineReturnValue = &h80000044
+   case "LINEERR_NOREQUEST"                   
+	   LineReturnValue = &h80000045
+   case "LINEERR_NOTOWNER"                    
+	   LineReturnValue = &h80000046
+   case "LINEERR_NOTREGISTERED"               
+	   LineReturnValue = &h80000047
+   case "LINEERR_OPERATIONFAILED"             
+	   LineReturnValue = &h80000048
+   case "LINEERR_OPERATIONUNAVAIL"            
+	   LineReturnValue = &h80000049
+   case "LINEERR_RATEUNAVAIL"                 
+	   LineReturnValue = &h8000004A
+   case "LINEERR_RESOURCEUNAVAIL"             
+	   LineReturnValue = &h8000004B
+   case "LINEERR_REQUESTOVERRUN"              
+	   LineReturnValue = &h8000004C
+   case "LINEERR_STRUCTURETOOSMALL"           
+	   LineReturnValue = &h8000004D
+   case "LINEERR_TARGETNOTFOUND"              
+	   LineReturnValue = &h8000004E
+   case "LINEERR_TARGETSELF"                  
+	   LineReturnValue = &h8000004F
+   case "LINEERR_UNINITIALIZED"               
+	   LineReturnValue = &h80000050
+   case "LINEERR_USERUSERINFOTOOBIG"          
+	   LineReturnValue = &h80000051
+   case "LINEERR_REINIT"                      
+	   LineReturnValue = &h80000052
+   case "LINEERR_ADDRESSBLOCKED"              
+	   LineReturnValue = &h80000053
+   case "LINEERR_BILLINGREJECTED"             
+	   LineReturnValue = &h80000054
+   case "LINEERR_INVALFEATURE"
+	   LineReturnValue = &h80000055
+   case "LINEERR_NOMULTIPLEINSTANCE"          
+	   LineReturnValue = &h80000056
+
+end select
+
+End Function 'LineReturnValue
+
+'******************************************************************************
+'Name   : LineReturnString
+'Desc   : Returns the numeric error code associated with the line error string 
+'			 
+'Parms  : Line Error String
+'
+'Return : Error code
+'			 
+'History: 04/18/96 : a-rrohr: Created
+'******************************************************************************
+Function LineReturnString  (ErrorVal as long) as string
+
+select case ErrorVal
+
+case &h0&
+   LineReturnString = "SUCCESS"
+case &h80000001
+	LineReturnString = "LINEERR_ALLOCATED"                   
+case &h80000002
+   LineReturnString = "LINEERR_BADDEVICEID"
+case &h80000003
+   LineReturnString = "LINEERR_BEARERMODEUNAVAIL"           
+case &h80000005
+   LineReturnString = "LINEERR_CALLUNAVAIL"                 
+case &h80000006
+   LineReturnString = "LINEERR_COMPLETIONOVERRUN"           
+case &h80000007
+   LineReturnString = "LINEERR_CONFERENCEFULL"              
+case &h80000008
+   LineReturnString = "LINEERR_DIALBILLING"                 
+case &h80000009
+   LineReturnString = "LINEERR_DIALDIALTONE"                
+case &h8000000A
+   LineReturnString = "LINEERR_DIALPROMPT"                  
+case &h8000000B
+   LineReturnString = "LINEERR_DIALQUIET"
+case &h8000000C
+   LineReturnString = "LINEERR_INCOMPATIBLEAPIVERSION"      
+case &h8000000D
+   LineReturnString = "LINEERR_INCOMPATIBLEEXTVERSION"      
+case &h8000000E
+   LineReturnString = "LINEERR_INIFILECORRUPT"              
+case &h8000000F
+   LineReturnString = "LINEERR_INUSE"                       
+case &h80000010
+   LineReturnString = "LINEERR_INVALADDRESS"                
+case &h80000011
+   LineReturnString = "LINEERR_INVALADDRESSID"              
+case &h80000012
+   LineReturnString = "LINEERR_INVALADDRESSMODE"            
+case &h80000013
+   LineReturnString = "LINEERR_INVALADDRESSSTATE"           
+case &h80000014
+   LineReturnString = "LINEERR_INVALAPPHANDLE"              
+case &h80000015
+   LineReturnString = "LINEERR_INVALAPPNAME"                
+case &h80000016
+   LineReturnString = "LINEERR_INVALBEARERMODE"             
+case &h80000017
+   LineReturnString = "LINEERR_INVALCALLCOMPLMODE"          
+case &h80000018
+   LineReturnString = "LINEERR_INVALCALLHANDLE"             
+case &h80000019
+   LineReturnString = "LINEERR_INVALCALLPARAMS"             
+case &h8000001A
+   LineReturnString = "LINEERR_INVALCALLPRIVILEGE"          
+case &h8000001B
+   LineReturnString = "LINEERR_INVALCALLSELECT"             
+case &h8000001C
+   LineReturnString = "LINEERR_INVALCALLSTATE"              
+case &h8000001D
+   LineReturnString = "LINEERR_INVALCALLSTATELIST"          
+case &h8000001E
+   LineReturnString = "LINEERR_INVALCARD"                   
+case &h8000001F
+   LineReturnString = "LINEERR_INVALCOMPLETIONID"           
+case &h80000020
+   LineReturnString = "LINEERR_INVALCONFCALLHANDLE"         
+case &h80000021
+   LineReturnString = "LINEERR_INVALCONSULTCALLHANDLE"      
+case &h80000022
+   LineReturnString = "LINEERR_INVALCOUNTRYCODE"            
+case &h80000023
+   LineReturnString = "LINEERR_INVALDEVICECLASS"            
+case &h80000024
+   LineReturnString = "LINEERR_INVALDEVICEHANDLE"           
+case &h80000025
+   LineReturnString = "LINEERR_INVALDIALPARAMS"             
+case &h80000026
+   LineReturnString = "LINEERR_INVALDIGITLIST"              
+case &h80000027
+   LineReturnString = "LINEERR_INVALDIGITMODE"              
+case &h80000028
+   LineReturnString = "LINEERR_INVALDIGITS"                 
+case &h80000029
+   LineReturnString = "LINEERR_INVALEXTVERSION"             
+case &h8000002A
+   LineReturnString = "LINEERR_INVALGROUPID"                
+case &h8000002B
+   LineReturnString = "LINEERR_INVALLINEHANDLE"             
+case &h8000002C
+   LineReturnString = "LINEERR_INVALLINESTATE"             
+case &h8000002D
+   LineReturnString = "LINEERR_INVALLOCATION"               
+case &h8000002E
+   LineReturnString = "LINEERR_INVALMEDIALIST"              
+case &h8000002F
+   LineReturnString = "LINEERR_INVALMEDIAMODE"              
+case &h80000030
+   LineReturnString = "LINEERR_INVALMESSAGEID"              
+case &h80000032
+   LineReturnString = "LINEERR_INVALPARAM"                  
+case &h80000033
+   LineReturnString = "LINEERR_INVALPARKID"                 
+case &h80000034
+   LineReturnString = "LINEERR_INVALPARKMODE"               
+case &h80000035
+   LineReturnString = "LINEERR_INVALPOINTER"                
+case &h80000036
+   LineReturnString = "LINEERR_INVALPRIVSELECT"             
+case &h80000037
+   LineReturnString = "LINEERR_INVALRATE"           
+case &h80000038
+   LineReturnString = "LINEERR_INVALREQUESTMODE"            
+case &h80000039
+   LineReturnString = "LINEERR_INVALTERMINALID"             
+case &h8000003A
+   LineReturnString = "LINEERR_INVALTERMINALMODE"           
+case &h8000003B 
+   LineReturnString = "LINEERR_INVALTIMEOUT"                
+case &h8000003C
+   LineReturnString = "LINEERR_INVALTONE"                   
+case &h8000003D
+   LineReturnString = "LINEERR_INVALTONELIST"               
+case &h8000003E
+   LineReturnString = "LINEERR_INVALTONEMODE"               
+case &h8000003F
+   LineReturnString = "LINEERR_INVALTRANSFERMODE"           
+case &h80000040
+   LineReturnString = "LINEERR_LINEMAPPERFAILED"            
+case &h80000041
+   LineReturnString = "LINEERR_NOCONFERENCE"                
+case &h80000042
+   LineReturnString = "LINEERR_NODEVICE"                    
+case &h80000043
+   LineReturnString = "LINEERR_NODRIVER"                    
+case &h80000044
+   LineReturnString = "LINEERR_NOMEM"                       
+case &h80000045
+   LineReturnString = "LINEERR_NOREQUEST"                   
+case &h80000046
+   LineReturnString = "LINEERR_NOTOWNER"                    
+case &h80000047
+   LineReturnString = "LINEERR_NOTREGISTERED"               
+case &h80000048
+   LineReturnString = "LINEERR_OPERATIONFAILED"             
+case &h80000049
+   LineReturnString = "LINEERR_OPERATIONUNAVAIL"            
+case &h8000004A
+   LineReturnString = "LINEERR_RATEUNAVAIL"                 
+case &h8000004B
+   LineReturnString = "LINEERR_RESOURCEUNAVAIL"             
+case &h8000004C
+   LineReturnString = "LINEERR_REQUESTOVERRUN"              
+case &h8000004D
+   LineReturnString = "LINEERR_STRUCTURETOOSMALL"           
+case &h8000004E
+   LineReturnString = "LINEERR_TARGETNOTFOUND"              
+case &h8000004F
+   LineReturnString = "LINEERR_TARGETSELF"                  
+case &h80000050
+   LineReturnString = "LINEERR_UNINITIALIZED"               
+case &h80000051
+   LineReturnString = "LINEERR_USERUSERINFOTOOBIG"          
+case &h80000052
+   LineReturnString = "LINEERR_REINIT"                      
+case &h80000053
+   LineReturnString = "LINEERR_ADDRESSBLOCKED"              
+case &h80000054
+   LineReturnString = "LINEERR_BILLINGREJECTED"             
+case &h80000055
+   LineReturnString = "LINEERR_INVALFEATURE"
+case &h80000056
+   LineReturnString = "LINEERR_NOMULTIPLEINSTANCE"          
+
+end select
+
+End Function 'LineReturnString
+
+'$ENDIF UNICODE_BVT_INC
diff --git a/private/tapi/qa/bvt/uni_bvt.mst b/private/tapi/qa/bvt/uni_bvt.mst
new file mode 100644
index 000000000..6b7a99a10
--- /dev/null
+++ b/private/tapi/qa/bvt/uni_bvt.mst
@@ -0,0 +1,2252 @@
+'******************************************************************************
+
+' UNI_BVT.mst  TAPI Unicode API Build Verification Test
+
+' Ronald Rohr
+' June 14, 1996
+
+' Status = Pre-Test Design Review, Pre-Code Review
+' Version = 0.1
+
+' This test Performs the Build Verification Test of the TAPI Unicode API 
+' Copied from TAPI_BVT.MST
+'
+' A description of the Test Cases Can be found in TCM, Server: lostpup,
+' Database: TAPICASES, Tree: BVT.
+' Logon with ID & Password = Tapicase (read only privlages) 
+
+' TAPI Browser 2.0 (TB20.exe) is required to run this test.
+'******************************************************************************
+
+'******************************************************************************
+
+'                    TEST CASE LIST  (in order of execution)
+
+'*  TC -   4 lineOpen and lineClose with all privileges
+'*  TC -   8 lineGetDevCaps 
+'*  TC -   9 lineMakeCall - privileges = none, monitor, owner
+'*  TC -  10 lineMakeCall - line unavalable
+'*  TC -  13 lineDrop  - with active call  
+'*  TC -  14 lineDeallocate - w/ active call	
+'*  TC -  15 lineShutDown - with active call  
+'*  TC -  16 lineClose - with active call  
+'*  TC -  21 lineSetCurrentLocation - with valid and invalid Location IDs
+'*  TC -  22 lineGetCountry
+'*  TC -  26 lineGetTranslateCaps - determine SUCCESS and validity of
+'*  TC -  27 lineTranslateAddress - valid and invalid addresses
+'*  TC -  28 lineTranslateAddress - valid and invalid credit cards
+'*  TC -  29 lineTranslateAddress - valid and invalid translate options
+'*  TC -  31 lineConfigDialog 
+'*  TC -  32 lineTranslateDialog 
+'  TC -  80 lineDial 
+'  TC -  81 lineGetID - comm & comm/datamodem 	
+'  TC -  83 lineReply & lineCallState
+'  TC - 175 lineNegotiateAPIVersion / 2.0
+
+'$INCLUDE 'declares.inc'
+
+option base 0
+
+	Const TEST_SCRIPT_TITLE = "TAPI Unicode API Build Verification Test" 'Test Script Name
+	Const TEST_SCRIPT_VERSION = "6/14/96"                    'Test Script Version
+	Const TIMEOUT = 3                                        'Timeout value for MSTest APIs
+
+	Global Test_Logfile as string		'Results Log File Name
+	Global SlowPC		  as long		'Set to TRUE if Alpha or 486
+
+	dim rtn as long						'Generic long return
+	dim CRLFrtn as long					'location of CRLF in string
+	dim ErrorMessage  as string		'Error Message string for On Error Procedure
+	dim ParamSet as long					'State of TB20 Param checkbox
+	dim LOpen_ID  as string				'ID returned by lineOpen
+	dim CurCountryID as string			'Hold Current Country ID   TC - 26
+	dim CreditCardID as string			'Hold Credit Card ID			TC - 26
+	dim count as short					'Generic counter
+	dim tempstr as string				'Generic string
+	dim Returnstr as string				'Holds TB20 EditBox text
+	dim hDlg as long						'Generic handle 
+   dim ModemName as string				'Modem Name for TC - 81, found in TC - 31
+	dim strhObject as string			'Used in TC - 81
+	dim NumRings as string				'Number of rings rtn by lineGetNumRings
+
+	'$include 'Tapilog.inc'          'required for all common file I/O procedures
+	'$include 'UNI_API.inc'				'API Constant declarations used in TAPI Browser
+	'$include 'UNI_BVT.inc'			   'Functions and Constants used by TAPI_BVT.MST
+   ''$include 'TAPI_TEMP.INC'			'location of functions under construction
+
+    on error goto ErrorHandler
+	 on end        EndTest
+
+' Bounds Checker can only be run from a system that has Visual Test installed 
+' otherwise a run time error will occur.
+' The Bounds Checker binaries cannot be redistributed.
+' NUMEGA should only be defined when running in the VT environment.
+
+'$ifdef NUMEGA
+   on BoundsCheckerNotify (NULL) Call BoundsChkHandler
+'$endif 'NUMEGA
+
+'$ifdef DEBUG_TEST_SCRIPT
+   viewport on
+   viewport clear
+'$endif 'DEBUG_TEST_SCRIPT
+
+viewport off
+	
+'*** Test Initialization
+
+redim (ParamTraits) (0) as ParamAttributes
+SetDefaultWaitTimeout (5)
+TotalScenarios = 0
+Test_Logfile = TESTMODE$
+CurrentLoggingLevel = DetailCase
+SetLogFileName
+rtn = StartLog (DELETE_LOGFILE, TEST_SCRIPT_TITLE)
+SetWndTimeout ()												'Set timeouts for all platforms
+
+'*** Verify Modem set otherwise stop test
+
+rtn = DetectModem
+if rtn = FALSE then
+   tempstr = "This Test Will Terminate" + CRLF +  CRLF + _
+				 "Please Set up Modem on this computer" + CRLF + _ 
+				 "prior to running the TAPI BVT"
+	WritelogItem ("" , tempstr )
+	Statusbox tempstr, 0,0,0,0, TRUE, TRUE 
+	Sleep 6
+	Stop          'Stop the test
+endif
+	
+'*** Set Service Provider in RegEdit to unimdm.tsp
+
+'$IFDEF Already_Validated
+'$ENDIF 'Already_Validated
+
+SetupProviders ()
+
+'******************************************************************************
+'*** TC - 4 lineOpen and lineClose with all privileges                        *
+'******************************************************************************
+
+
+'*** Start TAPI Browser
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem ("Test Case 4" , "")
+TC_ID = 4
+TotalScenarios = TotalScenarios + 1
+
+redim (ParamTraits) (0) as ParamAttributes
+
+'--- Step 2
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+if Num_Dev = 0 then
+   WritelogItem ("lineInitialize Returned 0 devices ", "")
+   WritelogItem ("Configure Telephony to use Unimodem Service Provider before starting the test ", "")
+   WritelogItem ("This Test Will Terminate", "")
+	end
+endif
+	
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+'--- Step 4, 5 , 6, 7
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "NONE"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Results 1
+
+teststring.TC_Num =  1
+teststring.Expect_Res = "LineOpen Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+
+teststring.TC_Num =  2
+teststring.Expect_Res = "LineOpen DialOut Privilege"
+teststring.Actual_Res =  lOpenRtn.priv
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "DialOut" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 8 through 17
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "MONITOR"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Results 3
+
+teststring.TC_Num =  3
+teststring.Expect_Res = "LineOpen Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 4
+
+teststring.TC_Num =  4
+teststring.Expect_Res = "LineOpen Monitor Privilege"
+teststring.Actual_Res =  lOpenRtn.priv
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "Monitor" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 18 through 27
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "OWNER"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Results 5
+
+teststring.TC_Num = 5
+teststring.Expect_Res = "LineOpen Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 6
+
+teststring.TC_Num =  6
+teststring.Expect_Res = "LineOpen DialInOut Privilege"
+teststring.Actual_Res =  lOpenRtn.priv
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "DialInOut" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 28 through 32
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'All ParamTraits should be set to null
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 13 lineDrop with active call  														*
+'******************************************************************************
+
+'--- Step 1 through 5
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 13" , "")
+TC_ID = 13
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		 = "LINE_CALLSTATE"
+ReceiveState.device	 = ""
+ReceiveState.cbInst	 = ""
+ReceiveState.param1	 = "PROCEEDING"
+ReceiveState.param2	 = ""
+ReceiveState.param3	 = ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+'if rtn <= 0 then
+'   WritelogItem ("lineMakeCall failed error = " , ReceiveState.param1)
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Step 6
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState ) 
+					  
+'--- Results 1
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "IDLE"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+'******************************************************************************
+'  TC - 14 lineDeallocate w/ active call													*
+'******************************************************************************
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+'rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+'Step 7 of TC 13 is in reality TC 14
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 14" , "")
+TC_ID = 14
+TotalScenarios = TotalScenarios + 1
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineDeallocateCall Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 15 lineShutDown with active call  												*
+'******************************************************************************
+
+'--- Step 1 through 4
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 15" , "")
+TC_ID = 15
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'if rtn = FALSE then
+'   WritelogItem ("lineMakeCall failed error = " ,ReceiveState.param1)
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Results 1
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineShutDown Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 16 lineClose with active call  													*
+'******************************************************************************
+
+'--- Step 1 through 4
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 16" , "")
+TC_ID = 16
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+'if rtn <= 0 then
+'   WritelogItem ("lineMakeCall failed error = " ,ReceiveState.param1)
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Step 5
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Result 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineClose Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 6, 7
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  8 lineGetDevCaps 																		*
+'******************************************************************************
+
+'--- Step 1, 2
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 8" , "")
+TC_ID = 8
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3
+rtn = Call_LGetDevCapsW  ( (hTB20), (hTB_Ctrl), Paramset)
+
+'--- Result 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineGetDevCaps Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 4
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param			= "dwDeviceID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "ffffffff"
+
+'--- Step 5 through 8
+rtn = Call_LGetDevCapsW  ( (hTB20), (hTB_Ctrl), Paramset)
+
+'--- Result 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "BADDEVICEID"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_BADDEVICEID then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 9, 10 
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  9 lineMakeCall - Privileges = none, monitor, owner							*
+'******************************************************************************
+
+'--- Step 1, 2
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 9" , "")
+TC_ID = 9
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3, 4, 5, 6
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "NONE"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 7, 8
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "PROCEEDING"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 9, 10
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 11, 12
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 13 through 15
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "MONITOR"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+'--- Steps 16, 17
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "PROCEEDING"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 18 through 21
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_LDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 22 through 24
+ParamTraits(0).Param			= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "OWNER"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+'--- Steps 25, 26
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "PROCEEDING"
+teststring.Actual_Res =ReceiveState.param1
+TotalTestCases = TotalTestCases + 1
+if rtn = TRUE then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 27 through 28
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC - 10 lineMakeCall - Line unavalable													*
+'******************************************************************************
+
+ '--- Step 1, 2
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 10" , "")
+TC_ID = 10
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 3
+
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 3 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 4
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+'if rtn > 0 then
+'   WritelogItem ("Step 4 - lineMakeCall failed error = " , ltrim$(hex$(rtn)))
+'   WritelogItem ("" , "This Test Will Terminate")
+'	end
+'endif
+
+'--- Step 5
+
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 6
+
+rtn = Call_LOpenW ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Step 7
+
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "PROCEEDING"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = "LINEERR_CALLUNAVAIL"
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LINEERR_CALLUNAVAIL"
+teststring.Actual_Res =ReceiveState.ErrorStr
+TotalTestCases = TotalTestCases + 1
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 8, 9
+count = WListCount(_hwnd(hTB_Ctrl(TB_ResList)), TIMEOUT)
+WListItemClk (_hwnd(hTB_Ctrl(TB_ResList)), "@" + ltrim$(str$(count)), TIMEOUT)
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 10, 11
+count = WListCount(_hwnd(hTB_Ctrl(TB_ResList)), TIMEOUT)
+WListItemClk (_hwnd(hTB_Ctrl(TB_ResList)), "@" + ltrim$(str$(count)), TIMEOUT)
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Step 12 through 15
+ReceiveState.Msg		= "LINE_CALLSTATE"
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= "IDLE"
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 26 lineGetTranslateCaps - determine SUCCESS and validity of
+'  RUN TC-26 BEFORE TC-21 TO GET THE CURRENT LOCATION ID
+'******************************************************************************
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 26" , "")
+WritelogItem ("RUN TC-26 BEFORE TC-21 TO", " GET THE CURRENT LOCATION ID")
+TC_ID = 26
+TotalScenarios = TotalScenarios + 1
+Returnstr = space$(1)
+
+rtn = Call_LGetTranslateCapsW  ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineGetTranslateCaps Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn > 0 then
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+else
+   teststring.Apprase    = "Pass"
+	rtn = instr(1, Returnstr, "dwPermanentLocationID")
+	if rtn > 0 then				' Get the first location ID
+		rtn = instr(rtn, Returnstr, "=x")
+		CurCountryID = mid$(Returnstr, rtn + 2, instr(rtn, Returnstr, CRLF) - (rtn + 2) )
+	endif
+		rtn = instr(1, Returnstr, "dwPermanentCardID")
+	if rtn > 0 then				' Get the first Credit Card ID
+		rtn = instr(rtn, Returnstr, "=x")
+		CreditCardID = mid$(Returnstr, rtn + 2, instr(rtn, Returnstr, CRLF) - (rtn + 2) )
+	endif
+
+endif
+LogCase (teststring)
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+	
+'******************************************************************************
+'  TC - 21 lineSetCurrentLocation With valid and invalid Location IDs			*
+'******************************************************************************
+
+'Note: This test requires a valid Country ID which is returned by TC 26
+ 
+'--- Step 1
+
+if Val( "&h" + CurCountryID) > 0 then  'continue with test
+
+	StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+	WritelogItem (" " , "")
+	WritelogItem ("Test Case 21" , "")
+	TC_ID = 21
+	TotalScenarios = TotalScenarios + 1
+
+	'--- Steps 2, 3
+	ParamSet = SetParamState (hTB20, UNCHECKED)
+
+	rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+	if rtn > 0 then
+		WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+		WritelogItem ("" , "This Test Will Terminate")
+		end
+	endif
+
+	ParamSet = SetParamState (hTB20, CHECKED)
+
+	ParamTraits(0).Param			= "dwLocation"
+	ParamTraits(0).BitFlagList	= ""
+	ParamTraits(0).ValueEdit	= CurCountryID	
+	ParamTraits(0).ValueList   = ""
+
+	Returnstr = " "
+
+	rtn = Call_LSetCurrentLocation  ( (hTB20), (hTB_Ctrl), Paramset, CurCountryID, Returnstr ) 
+
+	'--- Results 1
+	teststring.TC_Num = 1
+	teststring.Expect_Res = "LineSetCurrentLoc Rtn SUCCESS"
+	teststring.Actual_Res = LineReturnString ( rtn )
+	TotalTestCases = TotalTestCases + 1
+
+	if rtn > 0 then
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	else
+		teststring.Apprase    = "Pass"
+		rtn = instr(1, Returnstr, "dwPermanentLocationID")
+		if rtn > 0 then
+			rtn = instr(rtn, Returnstr, "=x")
+			CurCountryID = mid$(Returnstr, rtn + 2, instr(rtn, Returnstr, CRLF) - (rtn + 2) )
+		endif
+	endif
+	LogCase (teststring)
+	
+	'--- Results 2
+	ReceiveState.Msg	= "LINE_LINEDEVSTATE"
+	ReceiveState.device	= ""
+	ReceiveState.cbInst	= ""
+	ReceiveState.param1	= ""
+	ReceiveState.param2	= ""
+	ReceiveState.param3	= ""
+
+	do 
+		rtn = instr(1, Returnstr, ReceiveState.Msg)
+		if rtn > 0 then
+			rtn = MsgSplitter (Returnstr, ReceiveState) 
+		endif
+	loop until rtn = 0 OR ReceiveState.param1 = "TRANSLATECHANGE"
+
+	teststring.TC_Num = 2
+	teststring.Expect_Res = "LINE_LINEDEVSTATE = TRANSLATECHANGE"
+	teststring.Actual_Res = ReceiveState.param1
+	TotalTestCases = TotalTestCases + 1
+
+	if instr(1, ReceiveState.param1, "TRANSLATECHANGE") > 0 then
+		teststring.Apprase    = "Pass"
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	endif
+	LogCase (teststring)
+
+endif
+
+'--- Steps 8 through 11
+
+ParamTraits(0).Param		= "dwLocation"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ffffffff"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LSetCurrentLocation  ( (hTB20), (hTB_Ctrl), Paramset, CurCountryID, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "Rtn LINEERR_INVALLOCATION"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALLOCATION then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+	
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC -  22 lineGetCountry																		*
+'******************************************************************************
+
+'--- Steps 1 through 6
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 22" , "")
+TC_ID = 22
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param		= "dwCountryID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "0"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LGetCountryW  ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineGetCountry Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+ParamTraits(0).Param		= "dwCountryID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "161"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LGetCountryW  ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 14
+ParamTraits(0).Param		= "dwCountryID"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ffffffff"	
+ParamTraits(0).ValueList   = ""
+
+Returnstr = " "
+
+rtn = Call_LGetCountryW  ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "LINEERR_INVALCOUNTRYCODE"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALCOUNTRYCODE then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 15
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  27 lineTranslateAddress - valid and invalid addresses						*
+'******************************************************************************
+
+'--- Steps 1 
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 27" , "")
+TC_ID = 27
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Steps 3 through 9
+ParamSet = SetParamState (hTB20, CHECKED)
+
+redim (ParamTraits) (0 to 1) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "+1(206)543-9876"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 16 Dialable Format Address 
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= "206 777-8888"	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 17 through 22
+ParamTraits(1).Param		= "lpszAddressIn"
+ParamTraits(1).BitFlagList	= ""
+ParamTraits(1).ValueEdit	= ""	
+ParamTraits(1).ValueList   = "Invalid string pointer"
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "LINEERR_INVALPOINTER"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALPOINTER then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 17 through 19
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+
+'******************************************************************************
+'  TC -  28 lineTranslateAddress - valid and invalid credit cards					*
+'******************************************************************************
+'Note: Tis test requires a valid Credit Card ID which is returned by TC - 26
+'--- Steps 1 through 
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 28" , "")
+TC_ID = 28
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Steps 3 through 7
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param		= "dwCard"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= CreditCardID	
+ParamTraits(0).ValueList   = ""
+
+redim (ParamTraits) (0) as ParamAttributes
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 8 through 11
+ParamTraits(0).Param		= "dwCard"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ffffffff"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "LINEERR_INVALCARD"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALCARD then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 12 through 14
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  29 lineTranslateAddress - valid and invalid translate options			*
+'******************************************************************************
+
+'--- Steps 1 through 6
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 29" , "")
+TC_ID = 29
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+'--- Steps 3 through 7
+ParamSet = SetParamState (hTB20, CHECKED)
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "select none"
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 8 through 12
+redim (ParamTraits) (0 to 1) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "CARDOVERRIDE"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ParamTraits(1).Param		= ""
+ParamTraits(1).BitFlagList	= "CANCELCALLWAITING"
+ParamTraits(1).ValueEdit	= ""	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 13 through 17
+redim (ParamTraits) (0) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "FORCELOCAL"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 3
+teststring.TC_Num = 3
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 18 through 22
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "FORCELD"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 4
+teststring.TC_Num = 4
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 23 through 28
+redim (ParamTraits) (0 TO 1) as ParamAttributes
+
+ParamTraits(0).Param		= "dwTranslateOptions"
+ParamTraits(0).BitFlagList	= "FORCELOCAL"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+ParamTraits(1).Param		= ""
+ParamTraits(1).BitFlagList	= "FORCELD"
+ParamTraits(1).ValueEdit	= ""	
+ParamTraits(1).ValueList   = ""
+
+rtn = Call_LTranslateAddressW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 5
+teststring.TC_Num = 5
+teststring.Expect_Res = "LINEERR_INVALPARAM"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = LINEERR_INVALPARAM then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 29 through 31
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  31 lineConfigDialog  verify popup                     			      *
+'******************************************************************************
+
+'--- Step 1
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 31" , "")
+TC_ID = 31
+TotalScenarios = TotalScenarios + 1
+
+'--- Step 2
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+'--- Step 3, 4
+hDlg = 0
+rtn = Call_LConfigDialogW ( (hTB20), (hTB_Ctrl),  Paramset, hDlg, ModemName ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "Valid Modem Prop. Handle"
+teststring.Actual_Res = ltrim$(hex$(hDlg))
+TotalTestCases = TotalTestCases + 1
+
+if hDlg <> 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 5, 6
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC - 32 lineTranslateDialog verify popup											   *
+'******************************************************************************
+
+'--- Step 1 through 3
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 32" , "")
+TC_ID = 32
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+hDlg = 0
+rtn = Call_LTranslateDialogW ( (hTB20), (hTB_Ctrl), hDlg, Paramset ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "Valid Dialing Prop. Handle"
+teststring.Actual_Res = ltrim$(hex$(hDlg))
+TotalTestCases = TotalTestCases + 1
+
+if hDlg <> 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+teststring.TC_Num = 2
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 5 through 7
+'--- Results 3
+
+'--- Step 8
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  80 lineDial																			   *
+'******************************************************************************
+
+'--- Step 1 through 2
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 80" , "")
+TC_ID = 80
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 1 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LOpenW ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 2 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+'--- Step 3
+redim (ParamTraits) (0) as ParamAttributes
+
+ParamTraits(0).Param		= "lpszDestAddress"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = "NULL pointer"
+
+ReceiveState.Msg		= ""
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= ""
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+ParamTraits(0).Param		= "lpszDestAddress"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "55555"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LDialW ( (hTB20), (hTB_Ctrl), ParamSet, hDlg )
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "Valid Call Status Handle"
+teststring.Actual_Res = ltrim$(hex$(hDlg))
+TotalTestCases = TotalTestCases + 1
+
+if hDlg <> 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 5 through 7
+
+sleep .1   'param checkbox will not change if covered by the call 
+			  'status box. The delay allows the dialog to disappear
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  81 lineGetID - comm & comm/datamodem											* 
+'******************************************************************************
+'Note: This test case is dependent on TC 31 returning a valid modem name
+'		 The test cannot run without it
+
+'--- Step 1 through 2
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 81" , "")
+TC_ID = 81
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+redim (ParamTraits) (0) as ParamAttributes
+
+ParamTraits(0).Param		= "dwPrivileges"
+ParamTraits(0).BitFlagList	= "OWNER"
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LOpenW ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ParamTraits(0).Param		= "lpszDeviceClass"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "comm"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetIDW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 1
+teststring.TC_Num = 2
+teststring.Expect_Res = "dwStringFormat = ASCII"
+
+rtn = instr(1, Returnstr, "dwStringFormat")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+rtn = instr(rtn, Returnstr, ",")
+tempstr = ltrim$(mid$(Returnstr , rtn + 1, CRLFrtn - (rtn + 1)))
+ 
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if tempstr = "ASCII" then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 1
+teststring.TC_Num = 3
+teststring.Expect_Res = ModemName	' Returned in TC 31
+teststring.Actual_Res = GetModemName ( Returnstr, strhObject)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = ModemName then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+'************************************************************************************
+
+ParamTraits(0).Param		= "lpszDeviceClass"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "ndis"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetIDW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 1
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "dwStringFormat = BINARY"
+
+rtn = instr(1, Returnstr, "dwStringFormat")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+rtn = instr(rtn, Returnstr, ",")
+tempstr = ltrim$(mid$(Returnstr , rtn + 1, CRLFrtn - (rtn + 1)))
+ 
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if tempstr = "BINARY" then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'************************************************************************************
+
+'--- Step 4
+ParamTraits(0).Param		= "lpszDeviceClass"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "comm/datamodem"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LGetIDW ( (hTB20), (hTB_Ctrl), Paramset, Returnstr ) 
+
+'--- Results 2
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "SUCCESS"
+teststring.Actual_Res = LineReturnString ( rtn )
+TotalTestCases = TotalTestCases + 1
+
+if rtn = 0 then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Results 2
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "dwStringFormat = BINARY"
+
+rtn = instr(1, Returnstr, "dwStringFormat")
+CRLFrtn = instr(rtn, Returnstr, CRLF)
+rtn = instr(rtn, Returnstr, ",")
+tempstr = ltrim$(mid$(Returnstr , rtn + 1, CRLfrtn - (rtn + 1)))
+ 
+teststring.Actual_Res = tempstr
+TotalTestCases = TotalTestCases + 1
+
+if tempstr = "BINARY" then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = ModemName	' Returned in TC 31
+teststring.Actual_Res = GetModemName ( Returnstr, strhObject)
+teststring.Actual_Res = right$(teststring.Actual_Res, len(teststring.Actual_Res) -4)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = ModemName then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Step 5
+
+'Delete leading zeros from strhObject
+strhObject = ltrim$(Hex$(Val("&h"+ strhObject)))
+
+ParamTraits(0).Param		= "hObject"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= strhObject	
+ParamTraits(0).ValueList    = ""
+
+rtn = TCloseHandle ((hTB20), (hTB_Ctrl), ParamSet, returnstr)
+teststring.TC_Num = teststring.TC_Num + 1
+teststring.Expect_Res = "Handle " + strhObject + " Closed"
+CRLFrtn = instr(1, returnstr, CRLF) 
+if	CRLFrtn = 0 then
+	teststring.Actual_Res = returnstr
+else
+	teststring.Actual_Res = left$(returnstr, len(returnstr) - (len(returnstr) - CRLFrtn - 1))
+endif
+TotalTestCases = TotalTestCases + 1
+
+if rtn = True then
+	teststring.Apprase    = "Pass"
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 6, 7
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  83 lineReply & lineCallState														*
+'******************************************************************************
+
+'--- Step 1
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 83" , "")
+TC_ID = 83
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+'--- Steps 2 through 4
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, Returnstr ) 
+if rtn > 0 then
+   WritelogItem ("Step 5 - lineInitialize failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+'--- Steps 5 and 6
+rtn = Call_LOpenW  ( (hTB20), (hTB_Ctrl), ParamSet, lOpenRtn )
+if rtn > 0 then
+   WritelogItem ("Step 6 - lineOpen failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+ReceiveState.Msg		= ""
+ReceiveState.device	= ""
+ReceiveState.cbInst	= ""
+ReceiveState.param1	= ""
+ReceiveState.param2	= ""
+ReceiveState.param3	= ""
+ReceiveState.ErrorStr = ""
+
+rtn = Call_LMakeCallW  ( (hTB20), (hTB_Ctrl), ParamSet, ReceiveState, Returnstr ) 
+
+'--- Results 1
+teststring.TC_Num = 1
+teststring.Expect_Res = "LINE_REPLY or LINE_CALLSTATE"
+TotalTestCases = TotalTestCases + 1
+
+rtn = 0
+rtn = instr (1, returnstr, "LINE_REPLY")
+if rtn > 0 then
+	teststring.Actual_Res = "LINE_REPLY"
+	teststring.Apprase    = "Pass"
+else
+	rtn = instr (1, returnstr, "LINE_CALLSTATE")
+	if rtn > 0 then
+		teststring.Actual_Res = "LINE_CALLSTATE"
+		teststring.Apprase    = "Pass"
+	else
+		teststring.Actual_Res = ""
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	endif
+endif
+LogCase (teststring)
+
+'--- Steps 7 through 10
+rtn = Call_LDrop ( (hTB20), (hTB_Ctrl), ParamSet,ReceiveState ) 
+rtn = Call_lDeallocateCall ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LClose ((hTB20), (hTB_Ctrl), ParamSet )
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'******************************************************************************
+'  TC -  175 lineNegotiateAPIVersion / 2.0						 						*
+'******************************************************************************
+
+'--- Step 1 through 5
+
+StartTAPIBrowser(hTB20, hTB_Ctrl, hTB_CtrlID)
+
+WritelogItem (" " , "")
+WritelogItem ("Test Case 175" , "")
+TC_ID = 175
+TotalScenarios = TotalScenarios + 1
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+rtn = Call_LInitializeExW ( (hTB20), (hTB_Ctrl), Paramset, hLineApp, Num_Dev, returnstr ) 
+
+if rtn > 0 then
+   WritelogItem ("lineInitializeEx failed error = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+
+if Num_Dev = 0 then
+   WritelogItem ("lineInitializeEx returned 0 devices = " , ltrim$(hex$(rtn)))
+   WritelogItem ("" , "This Test Will Terminate")
+	end
+endif
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 1
+
+teststring.TC_Num = 1
+teststring.Expect_Res = "LineNegotiateAPIVersion Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- API Version Results
+
+teststring.Expect_Res = "x20000"
+teststring.Actual_Res =  lNegVerRtn.API_Ver
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.Expect_Res = "ID's = x0"
+TotalTestCases = TotalTestCases + 1
+rtn = 0
+for count = 0 to 3
+	if lNegVerRtn.ID(count) <> "x0" then
+		rtn = rtn + 1							 'rtn is used as a fail counter
+	end if
+next
+
+if rtn = 0 then
+	teststring.Actual_Res =  "ID's = x0"
+   teststring.Apprase    = "Pass"
+else
+	teststring.Actual_Res =  "ID's <> x0"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+ParamSet = SetParamState (hTB20, CHECKED)
+
+'--- Steps 6 through 9
+ParamTraits(0).Param			= "dwAPILowVersion"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "00030000"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 2
+
+teststring.TC_Num = 2
+teststring.Expect_Res = "INCOMPATIBLEAPIVERSION"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = LineReturnString (LINEERR_INCOMPATIBLEAPIVERSION) then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- Steps 11 through 14
+
+ParamTraits(0).Param			= "dwAPILowVersion"
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= "00010003"	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LNegotiateAPIVer ( (hTB20), (hTB_Ctrl), ParamSet, lNegVerRtn )
+
+'--- Results 3
+
+teststring.TC_Num = 3
+teststring.Expect_Res = "LineNegotiateAPIVersion Rtn SUCCESS"
+teststring.Actual_Res = LineReturnString (rtn)
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = "SUCCESS" then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+'--- API Version Results
+
+teststring.Expect_Res = "x20000"
+teststring.Actual_Res =  lNegVerRtn.API_Ver
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res then
+   teststring.Apprase    = "Pass"
+else
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+teststring.Expect_Res = "ID's = x0"
+TotalTestCases = TotalTestCases + 1
+rtn = 0
+for count = 0 to 3
+	if lNegVerRtn.ID(count) <> "x0" then
+		rtn = rtn + 1							 'rtn is used as a fail counter
+	end if
+next
+
+if rtn = 0 then
+	teststring.Actual_Res =  "ID's = x0"
+   teststring.Apprase    = "Pass"
+else
+	teststring.Actual_Res =  "ID's <> x0"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+endif
+LogCase (teststring)
+
+ParamTraits(0).Param			= ""
+ParamTraits(0).BitFlagList	= ""
+ParamTraits(0).ValueEdit	= ""	
+ParamTraits(0).ValueList   = ""
+
+rtn = Call_LShutDown ((hTB20), (hTB_Ctrl), ParamSet )
+
+ParamSet = SetParamState (hTB20, UNCHECKED)
+
+' Close TAPI Browser	- ALL LINES MUST BE SHUTDOWN BY NOW
+
+WSetActWnd (hTB20)
+WMenuSelect (MFILE + "\" + MEXIT, TIMEOUT)
+
+'$ifdef  NotyetValidated
+
+
+'$endif 'NotyetValidated
+'******************************************************************************
+'*** END OF TEST																					*
+'******************************************************************************
+
+END 'TAPI_BVT Test
+
+'****************************** On Error Routine ******************************
+
+ErrorHandler:
+    ErrorMessage = "Unexpected error in the TAPI Unicode BV Test: "  + CRLF + CRLF + _
+                   "Error:   " + error$										 + CRLF + _
+                   "Error #:"  + str$(Err)									 + CRLF + _
+                   "Line #: "  + str$(Erl)									 + CRLF + _
+                   "File: "    + Erf												+ CRLF + CRLF + _
+                   "Attempt to continue?"
+
+'$IFDEF DEBUG_TEST_SCRIPT
+   if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+      resume next
+   else
+      Stop
+   endif
+'$ELSE
+   Statusbox "Run Time error detected, Test will terminate", _
+				 0,0,0,0, TRUE, TRUE 
+   Sleep 4
+   WritelogItem ("" , ErrorMessage)
+   Stop
+'$ENDIF 'DEBUG_TEST_SCRIPT
+'******************************************************************************
diff --git a/private/tapi/qa/bvt/unidesc.txt b/private/tapi/qa/bvt/unidesc.txt
new file mode 100644
index 000000000..02d08705b
--- /dev/null
+++ b/private/tapi/qa/bvt/unidesc.txt
@@ -0,0 +1,923 @@
+                       TAPI UNICODE BUILD VERIFICATION TEST SPECIFICATION.
+
+                       Test Spec written by Aaron Ridenour a-aaronr
+                       Test Scripts written by Ron Rohr a-rrohr
+                       July 11, 1996
+
+******************** Test Description *********************************************		
+
+This Test has been implemented with Visual Test 4.0a. 
+There are 4 files associated with this test.
+Uni_BVT.MST - Main test script.
+Uni_BVT.INC - Contains all TAPI_BVT procedures called from the main script.
+Uni_API.INC - Contains all Const and Type definitions used in the test.
+TAPILOG.INC - Contains all file output procedures.
+
+******************** Prerequisites ************************************************
+
+1) TAPI Browser 2.0 (tb20.exe) must be in the System32 windows subdirectory.
+2) The Test PC must have a modem connected and installed.
+3) Unimdm.tsp service provider must be in the System32 windows subdirectory.
+
+******************** Begin Test Discriptions **************************************
+
+***********************************************************************************
+**** Test Case - 4 lineOpen and lineClose with all privileges
+***********************************************************************************
+
+STEPS:  // open line with no privileges
+1 - Run TB
+2 - In the Function listbox double-click lineInitializeExW
+3 - click the [Parms] checkbox on, on the toolbar
+4 - In the Function listbox double-click lineOpenW
+5 - In the dialog box, select [dwPrivileges]
+6 - Choose [NONE] in the [Bit flags] listbox
+7 - Press OK
+
+RESULTS:
+1 - Should get a "lineOpen returned SUCCESS" in the results window.
+2 - Line should be listed as DialOut
+
+STEPS:  // open line as monitor
+8  - In the Function listbox double-click lineClose
+9  - Press OK on the dialog
+10 - In the Function listbox double-click lineShutdown
+11 - Press OK on the dialog
+12 - In the Function listbox double-click lineInitializeExW
+13 - Press OK on the dialog
+14 - In the Function listbox double-click lineOpenW
+15 - In the dialog box, select [dwPrivileges]
+16 - Choose [MONITOR] in the [Bit flags] listbox
+17 - Press OK
+
+RESULTS:
+3 - Should get a "lineOpen returned SUCCESS" in the results window.
+4 - Line should be listed as Monitor
+
+STEPS:  // open line as owner
+18 - In the Function listbox double-click lineClose
+19 - Press OK on the dialog
+20 - In the Function listbox double-click lineShutdown
+21 - Press OK on the dialog
+22 - In the Function listbox double-click lineInitializeExW
+23 - Press OK on the dialog
+24 - In the Function listbox double-click lineOpenW
+25 - In the dialog box, select [dwPrivileges]
+26 - Choose [OWNER] in the [Bit flags] listbox
+27 - Press OK
+
+RESULTS:
+5 - Should get a "lineOpen returned SUCCESS" in the results window.
+6 - Line should be listed as DialInOut
+
+STEPS:
+28 - In the Function listbox double-click on lineClose
+29 - In dialog box press [OK]
+30 - In the Function listbox double-click on lineShutdown
+31 - In dialog box press [OK]
+32- Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 8 lineGetDevCapsW 
+***********************************************************************************
+
+STEPS: // Verify lineGetDevCapsW return for valid device ID
+1 - Run TB
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In function listbox double-click on lineGetDevCapsW
+
+RESULTS: 
+1 - "lineGetDevCapsW returned SUCCESS" should be displayed.  For further verification, 
+see example below.
+
+STEPS: //Verify lineGetDevCapsW return for invalid device ID
+4 - On toolbar check Params box
+5 - In function listbox double-click on lineGetDevCapsW
+6 - On dialog box select dwDeviceID
+7 - Set Value to ffffffff
+8 - Press [OK]
+
+RESULT: "lineGetDevCapsW returned LINEERR_BADDEVICEID" should be displayed
+
+STEPS:
+9 - In the Function listbox double-click on lineShutdown
+10 - Close TB
+
+*********************************
+Example of lineGetDevCapsW return:
+*********************************
+
+lineGetDevCapsW returned SUCCESS
+LINEDEVCAPS
+  dwTotalSize=x1000
+  dwNeededSize=x180
+  dwUsedSize=x180
+  dwProviderInfoSize=x3e
+  dwProviderInfoOffset=xf0
+    646e6957 2073776f 656c6554 6e6f6870  Windows Telephon
+    65532079 63697672 72502065 6469766f  y Service Provid
+    66207265 5520726f 6576696e 6c617372  er for Universal
+    646f4d20 44206d65 65766972 xxxx0072   Modem Driver.
+  dwPermanentLineID=x18368
+  dwLineNameSize=x17
+  dwLineNameOffset=x12e
+    61726150 6c656c6c 62616320 6f20656c  Parallel cable o
+    504c206e xx003154 xxxxxxxx xxxxxxxx  n LPT1.
+  dwStringFormat=x1, ASCII
+  dwAddressModes=x1, ADDRESSID 
+  dwNumAddresses=x1
+  dwBearerModes=x48, DATA PASSTHROUGH 
+  dwMaxRate=x1c200
+  dwMediaModes=x10, DATAMODEM 
+  dwDevCapFlags=x60, CLOSEDROP DIALBILLING 
+  dwMaxNumActiveCalls=x1
+  dwRingModes=x1
+  dwLineStates=x14406ce, RINGING CONNECTED DISCONNECTED 
+    INSERVICE OUTOFSERVICE OPEN CLOSE REINIT TRANSLATECHANGE 
+    REMOVED 
+  dwDevSpecificSize=x3b
+  dwDevSpecificOffset=x145
+    00000001 00000008 74737953 435c6d65  ........System\C
+    65727275 6f43746e 6f72746e 7465536c  urrentControlSet
+    7265535c 65636976 6c435c73 5c737361  \Services\Class\
+    65646f4d 30305c6d xx003130 xxxxxxxx  Modem\0001.
+  dwLineFeatures=x8, MAKECALL
+
+Note: For this example, a Creative Labs Phoneblaster and Unimodem service provider were 
+employed.  The LINEDEVCAPS return should be compared to installed modem and service 
+provider to verify correctness of lineGetDevCapsW API.
+
+***********************************************************************************
+**** Test Case - 9 lineMakeCallW- privileges = none, monitor, owner
+***********************************************************************************
+
+STEPS: // Call with privilege=NONE
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - On toolbar, check Params box
+4 - In the Function listbox double-click on lineOpenW
+5 - In lineOpen dialog box, select dwPrivileges
+6 - Under bit flags, select NONE
+7 - In the Function listbox double-click on lineMakeCallW
+8 - On lineMakeCallW Dialog box press [OK]
+
+RESULT: 
+1) The call should PROCEEDING, with the following text returned:
+
+   lineMakeCallW returned x1
+   received LINE_REPLY : hDev=x0, cbInst=x0
+     p1=x1,
+     p2=x0,
+     p3=x0
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x8, DIALTONE
+     p2=x20, UNAVAIL
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x10, DIALING
+     p2=x0,
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x200 PROCEEDING
+     p2=x0,
+     p3=x0,
+
+[Note: x_______ is the Call handle]
+
+STEPS: // Call with privilege=MONITOR
+9 - In the Function listbox double-click on lineDrop and then lineDeallocateCall
+10 - In dialog box, press [OK]
+11 - In the Function listbox double-click on lineClose
+12 - In dialog box press [OK]
+13 - In the Function listbox double-click on lineOpenW
+14 - In lineOpen dialog box, select dwPrivileges
+15 - Under bit flags, select MONITOR
+16 - In the Function listbox double-click on lineMakeCallW
+17 - On lineMakeCallW Dialog box press [OK]
+
+RESULT: 
+2 - The call should PROCEEDING (with similar text as described above).
+
+
+STEPS: // Call with privilege=MONITOR
+18 - In the Function listbox double-click on lineDrop and then lineDeallocateCall
+19 - In dialog box, press [OK]
+20 - In the Function listbox double-click on lineClose
+21 - In dialog box press [OK]
+22 - In the Function listbox double-click on lineOpenW
+23 - In lineOpen dialog box, select dwPrivileges
+24 - Under bit flags, select OWNER
+25 - In the Function listbox double-click on lineMakeCallW
+26 - On lineMakeCallW Dialog box press [OK]
+
+
+RESULT: 
+3 - The call should PROCEEDING (with similar text as described above).
+
+27 - On toolbar, uncheck the Params box
+28 - In the Function listbox double-click on lineDrop and then lineDeallocateCall
+29 - In the Function listbox double-click on lineClose
+30 - In the Function listbox double-click on lineShutdown
+31 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 10 lineMakeCallW- line unavalable
+***********************************************************************************
+
+STEPS: // Ensure proper return for call attempted on line already in use
+1 - Run TB
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In the Function listbox double-click on lineOpenW
+4 - In the Function listbox double-click on lineMakeCallW
+          Note: Ensure call is active for steps 5 through 7
+5 - In the Function listbox double-click on lineInitializeExW
+6 - In the Function listbox double-click on lineOpenW
+7 - In the Function listbox double-click on lineMakeCallW
+
+RESULTS:
+1 - "lineMakeCallW returned LINEERR_CALLUNAVAIL" should be returned
+
+STEPS:
+
+8 - Click on bottom Line handle
+9 - In the Function listbox double-click on lineClose
+10 - Click on bottom LineApp handle
+11 - In the Function listbox double-click on lineShutdown
+12 - In the Function listbox double-click on lineDrop and then lineDeallocateCall
+13 - In the Function listbox double-click on lineClose
+14 - In the Function listbox double-click on lineShutdown
+15 - Close TB
+
+***********************************************************************************
+**** Test Case - 13 lineDrop  - with active call  
+***********************************************************************************
+
+STEPS:  // Verify successful line drop after initiating call
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In the Function listbox double-click on lineOpenW
+4 - In the Function listbox double-click on lineMakeCallW
+5 - Wait for call state to be proceeding or connected
+6 - In function listbox double-click on lineDrop
+
+RESULTS:
+1 - Return should LINE_CALLSTATE as IDLE
+
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x1, IDLE
+     p2=x0,
+     p3=x0,
+
+STEPS:
+7 - In the Function listbox double-click on lineDrop and then lineDeallocateCall
+8 - In the Function listbox double-click on lineClose
+9 - In the Function listbox double-click on lineShutdown
+10 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 14 lineDeallocate - w/ active call	
+***********************************************************************************
+
+STEPS:  // Verify successful line deallocation
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In the Function listbox double-click on lineOpenW
+4 - In the Function listbox double-click on lineMakeCallW
+5 - Wait for call state to be proceeding or connected
+6 - In function listbox double-click on lineDrop
+7 - In function listbox double-click on lineDeallocateCall
+
+RESULTS:
+1 - "lineDeallocateCall returned SUCCESS" should be displayed
+
+STEPS:
+8 - In the Function listbox double-click on lineClose
+9 - In the Function listbox double-click on lineShutdown
+10 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 15 lineShutDown - with active call  
+***********************************************************************************
+
+STEPS:  // Verify successful line drop after initiating call
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In the Function listbox double-click on lineOpenW
+4 - In the Function listbox double-click on lineMakeCallW
+5 - In function listbox double-click on lineShutdown
+
+RESULTS:
+1 - "lineShutdown returned SUCCESS" should be displayed
+
+STEPS:
+6 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 16 lineClose - with active call  
+***********************************************************************************
+
+STEPS:  // Verify successful line close after initiating call
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In the Function listbox double-click on lineOpenW
+4 - In the Function listbox double-click on lineMakeCallW
+5 - In the Function listbox double-click on lineClose
+
+RESULTS:
+1 - "lineClose returned SUCCESS" should be displayed
+
+STEPS:
+6 - In the Function listbox double-click on lineShutdown
+7 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 21 lineSetCurrentlocationW - with valid and invalid Location IDs
+***********************************************************************************
+
+Note: For the first segment of this test to be run successfully, a valid location must 
+exist.  Specifically for Step 6 (below) a location must be entered into the Dialing 
+Properties on the My Location tab.  If this entry is not the first location entered 
+into Dialing Proprties (lineTranslateDialog / telephon.cpl), then the value in Step 6 
+must be changed accordingly. 
+
+
+STEPS:  // Verify return for VALID location
+1 - Run TB
+2 - In the Function listbox double-click on lineInitializeExW
+3 - Activate Params box
+4 - In function listbox double-click on lineSetCurrentlocationW
+5 - In dialog box select [dwLocation]
+6 - Set Value to 00000001
+7 - Press [OK] button
+
+RESULTS:
+1 - "lineSetCurrentlocationW returned SUCCESS" should be displayed
+2 - LINE_LINEDAVSTATE REINIT should be issued
+
+STEPS:  // Verify return for INVALID location
+8 - In function listbox double-click on lineSetCurrentlocationW
+9 - In dialog box select [dwLocation]
+10 - Set Value to ffffffff
+11 - Press [OK] button
+
+RESULTS:
+3 - "lineSetCurrentlocationW returned LINEERR_INVALLOCATION" should be displayed
+
+
+STEPS:
+12 - In the Function listbox double-click on lineShutdown
+13 - In dialog box press [OK]
+14 - Close TB
+
+***********************************************************************************
+**** Test Case - 22 lineGetCountryW
+***********************************************************************************
+
+STEPS:  // Verify entire country list can be returned
+1 - Run TB
+2 - On toolbar check Params box
+3 - In function listbox double-click lineGetCountryW
+4 - In dialog box select dwCountryID parameter
+5 - Set value to 00000000
+6 - Press [OK] button
+
+RESULT:
+1 - "lineGetCountryW returned SUCCESS" should be displayed
+
+Note: LINECOUNTRYLIST will not display all countries in the list; this is due to the TAPI 
+Browser buffer size.  The dwNeededSize will indicate a large value (i.e., 3e45) which 
+exceeds the dwTotalSize (i.e., the buffer, which is 1000).
+
+STEPS: //Verify country list can be accessed
+7 - In function listbox double-click lineGetCountryW
+8 - In dialog box select dwCountryID parameter
+9 - Set value to 00000001
+10 - Press [OK] button 
+
+RESULT:
+2 - "lineGetCountryW returned SUCCESS" should be displayed along with to follow return:
+
+LINECOUNTRYLIST
+  dwTotalSize=x1000
+  dwNeededSize=x6b
+  dwUsedSize=x6b
+  dwNumCountries=x1
+  dwCountryListSize=x2c
+  dwCountryListOffset=x18
+LINECOUNTRYENTRY[0]
+  dwCountryID=x1
+  dwCountryCode=x1
+  dwNextCountryID=x65
+  dwCountryNameSize=x19
+  dwCountryNameOffset=x52
+    74696e55 53206465 65746174 666f2073  United States of
+    656d4120 61636972 xxxxxx00 xxxxxxxx   America.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x50
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=x5
+  dwLongDistanceRuleOffset=x4b
+    47463120 xxxxxx00 xxxxxxxx xxxxxxxx   1FG.
+  dwInternationalRuleSize=x7
+  dwInternationalRuleOffset=x44
+    45313130 xx004746 xxxxxxxx xxxxxxxx  011EFG.
+
+STEPS: //Verify correct return for invalid country ID
+11 - In function listbox double-click lineGetCountryW
+12 - In dialog box select dwCountryID parameter
+13 - Set value to ffffffff
+14 - Press [OK] button
+
+RESULT:
+3 - "lineGetCountryW returned LINEERR_INVALCOUNTRYCODE" should be displayed
+
+STEPS:
+15 - Close TB
+
+***********************************************************************************
+**** Test Case - 26 lineGetTranslateCapsW - determine SUCCESS and validity of
+***********************************************************************************
+
+Note: For this test to be run successfully, valid locations should exist.  Specifically, a 
+location must be entered into the Dialing Properties on the My Location tab; credit card 
+usage should be defined as well. 
+
+
+STEPS: // Verify lineGetTranslateCapsW retrieves all locations & cards data
+1 - Run TAPI Browser
+2 - In function listbox double-click on lineGetTranslateCapsW
+
+
+RESULT:
+1 - "lineGetTranslateCapsW returned SUCCESS" should be displayed. For further detail, see 
+example below.
+
+STEPS:
+3 - Close TAPI Browser
+
+
+***************************************
+Example of lineGetTranslateCapsW return:
+***************************************
+
+lineGetTranslateCapsW returned SUCCESS
+LINETRANSLATECAPS
+  dwTotalSize=x1000
+  dwNeededSize=x35d
+  dwUsedSize=xa5d
+  dwNumLocations=x2
+  dwLocationListSize=x88
+  dwLocationListOffset=x2c
+  dwNumCards=x4
+  dwCardListSize=xd0
+  dwCardListOffset=xb4
+  dwCurrentPreferredCardID=x4
+LINELOCATIONENTRY[0]
+  dwLocationNameSize=xa
+  dwLocationNameOffset=x4d4
+    4f20794d 63696666 xxxx0065 xxxxxxxx  My Office.
+  dwCountryCode=x1
+  dwCityCodeSize=x4
+  dwCityCodeOffset=x4e4
+    00363032 xxxxxxxx xxxxxxxx xxxxxxxx  206.
+  dwPreferredCardID=x4
+  dwLocalAccessCodeSize=x3
+  dwLocalAccessCodeOffset=x4de
+    xx002c39 xxxxxxxx xxxxxxxx xxxxxxxx  9,.
+  dwLongDistanceAccessCodeSize=x3
+  dwLongDistanceAccessCodeOffset=x4e1
+    xx002c39 xxxxxxxx xxxxxxxx xxxxxxxx  9,.
+  dwTollPrefixListSize=x1
+  dwTollPrefixListOffset=x4e8
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwCountryID=x1
+  dwCancelCallWaitingSize=x5
+  dwCancelCallWaitingOffset=x4e9
+    2c30372a xxxxxx00 xxxxxxxx xxxxxxxx  *70,.
+LINELOCATIONENTRY[1]
+  dwPermanentLocationID=x1
+  dwLocationNameSize=xe
+  dwLocationNameOffset=x4ee
+    646e6f4c 4f206e6f 63696666 xxxx0065  London Office.
+  dwCountryCode=x2c
+  dwCityCodeSize=x4
+  dwCityCodeOffset=x500
+    00313730 xxxxxxxx xxxxxxxx xxxxxxxx  071.
+  dwLocalAccessCodeSize=x2
+  dwLocalAccessCodeOffset=x4fc
+    xxxx0038 xxxxxxxx xxxxxxxx xxxxxxxx  8.
+  dwLongDistanceAccessCodeSize=x2
+  dwLongDistanceAccessCodeOffset=x4fe
+    xxxx0038 xxxxxxxx xxxxxxxx xxxxxxxx  8.
+  dwTollPrefixListSize=x1
+  dwTollPrefixListOffset=x504
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwCountryID=x2c
+  dwCancelCallWaitingSize=x5
+  dwCancelCallWaitingOffset=x505
+    2c233037 xxxxxx00 xxxxxxxx xxxxxxxx  70#,.
+LINECARDENTRY[0]
+  dwCardNameSize=x13
+  dwCardNameOffset=x50a
+    656e6f4e 69442820 74636572 61694420  None (Direct Dia
+    xx00296c xxxxxxxx xxxxxxxx xxxxxxxx  l).
+  dwSameAreaRuleSize=x1
+  dwSameAreaRuleOffset=x51d
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwLongDistanceRuleSize=x1
+  dwLongDistanceRuleOffset=x51e
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwInternationalRuleSize=x1
+  dwInternationalRuleOffset=x51f
+    xxxxxx00 xxxxxxxx xxxxxxxx xxxxxxxx  .
+  dwOptions=x1, PREDEFINED 
+LINECARDENTRY[1]
+  dwPermanentCardID=x1
+  dwCardNameSize=x1c
+  dwCardNameOffset=x520
+    54265441 72694420 20746365 6c616944  AT&T Direct Dial
+    61697620 41303120 00315454 xxxxxxxx   via 10ATT1.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x53c
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=x9
+  dwLongDistanceRuleOffset=x53e
+    38323031 47463138 xxxxxx00 xxxxxxxx  102881FG.
+  dwInternationalRuleSize=xc
+  dwInternationalRuleOffset=x547
+    38323031 31313038 00474645 xxxxxxxx  10288011EFG.
+  dwOptions=x1, PREDEFINED 
+LINECARDENTRY[2]
+  dwPermanentCardID=x2
+  dwCardNameSize=x10
+  dwCardNameOffset=x553
+    54265441 61697620 41303120 00305454  AT&T via 10ATT0.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x563
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=xc
+  dwLongDistanceRuleOffset=x565
+    38323031 47463038 00485424 xxxxxxxx  102880FG$TH.
+  dwInternationalRuleSize=xe
+  dwInternationalRuleOffset=x571
+    38323031 45313038 54244746 xxxx0048  1028801EFG$TH.
+  dwOptions=x1, PREDEFINED 
+LINECARDENTRY[3]
+  dwPermanentCardID=x4
+  dwCardNameSize=x1b
+  dwCardNameOffset=x57f
+    2049434d 65726944 44207463 206c6169  MCI Direct Dial 
+    20616976 32323031 xx003132 xxxxxxxx  via 102221.
+  dwSameAreaRuleSize=x2
+  dwSameAreaRuleOffset=x59a
+    xxxx0047 xxxxxxxx xxxxxxxx xxxxxxxx  G.
+  dwLongDistanceRuleSize=x9
+  dwLongDistanceRuleOffset=x59c
+    32323031 47463132 xxxxxx00 xxxxxxxx  102221FG.
+  dwInternationalRuleSize=xc
+  dwInternationalRuleOffset=x5a5
+    32323031 31313032 00474645 xxxxxxxx  10222011EFG.
+  dwOptions=x1, PREDEFINED 
+
+This return should be checked against the data entered into Dialing Properties.  
+In this example, there were two locations  and four credit cards entered in Dialing 
+Properties.
+
+> dwNumLocations=x2, so LINELOCATIONENTRY is given for values 0 and 1
+> dwNumCards=x4, so LINECARDENTRY is given for values 0 through 3
+> dwCurrentPreferredCardID=x4 which correctly references the MCI card under LINECARDENTRY[3]
+
+
+***********************************************************************************
+**** Test Case - 27 lineTranslateAddressW - valid and invalid addresses
+***********************************************************************************
+
+STEPS: // Test for valid address
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - Click Param box
+4 - In function listbox double-click on lineTranslateAddressW
+5 - In dialog box select dwTranslateOptions
+6 - Under Value click on "select none"
+7 - In dialog box select lpszAddressln
+8 - Set value to a valid canonical number [i.e., "+1 (555) 555-5555"]
+9 - Press [OK] button
+
+Results:
+1 - "lineTranslateAddressW returned SUCCESS" should be displayed
+
+STEPS:  // Test for invalid address
+11 - In function listbox double-click on lineTranslateAddressW
+12 - In dialog box select dwTranslateOptions
+13 - Under Value click on "select none"
+14 - In dialog box select lpszAddressln
+15 - Set value to a valid dialable format number [i.e., "206 555-5555"]
+16 - Press [OK] button
+
+RESULTS:
+2 - "lineTranslateAddressW returned SUCCESS" should be displayed
+
+STEPS:  // Test for invalid address
+17 - In function listbox double-click on lineTranslateAddressW
+18 - In dialog box select dwTranslateOptions
+19 - Under Value click on "select none"
+20 - In dialog box select lpszAddressln
+21 - Set value to "Invalid string pointer"
+22 - Press [OK] button
+
+RESULTS:
+3 - "lineTranslateAddressW returned LINEERR_INVALPOINTER" should be displayed
+
+STEPS:
+23 - On toolsbar press lineShutdown 
+24 - In dialog box press [OK]
+25 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 28 lineTranslateAddressW - valid and invalid credit cards
+***********************************************************************************
+
+Note: To test the return for a valid credit card, at least one credit card must be defined in Dialing Properties.
+
+STEPS: // Check return for valid credit card ID
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - Check Param box
+4 - In function listbox double-click on lineTranslateAddressW
+5 - In dialog box select dwCard
+6 - Set value to a valid dwLocationID (generally 00000001 should be valid)
+7 - Press [OK] button
+
+RESULTS:
+1 - "lineTranslateAddressW returned SUCCESS" should be displayed 
+
+STEPS: // Check return for invalid credit card ID
+
+8 - In function listbox double-click on lineTranslateAddressW
+9 - In dialog box select dwCard
+10 - Set value to ffffffff
+11 - Press [OK] button
+
+RESULTS:
+2 - "lineTranslateAddressW returned LINEERR_INVALCARD" should be displayed
+
+STEPS:
+12 - In the Function listbox double-click on lineShutdown 
+13 - In dialog box press [OK] button
+14 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 29 lineTranslateAddressW - valid and invalid translate options
+***********************************************************************************
+
+Note: Card override translation option is tested under TCM case ID 28.
+
+STEPS: // No translate options
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - Check Params box
+4 - In function listbox double-click on lineTranslateAddressW
+5 - In dialog box click on dwTranslateOptions
+6 - Change value to "select none"
+7 - Press [OK] button
+
+RESULTS:
+1 - "lineTranslateAddressW returned SUCCESS" should be displayed
+
+STEPS:  // Cancel call waiting
+8 - In function listbox double-click on lineTranslateAddressW
+9 - In dialog box click on dwTranslateOptions
+10 - Click on CARDOVERRIDE (to turn off the default)
+11 - Click on CANCELCALLWAITING
+12 - Press [OK] button
+
+RESULTS:
+2 - "lineTranslateAddressW returned SUCCESS" should be displayed
+
+STEPS: // Force local call
+13 - In function listbox double-click on lineTranslateAddressW
+14 - In dialog box click on dwTranslateOptions
+15 - Click on CARDOVERRIDE (to turn off the default)
+16 - Click on FORCELOCAL
+17 - Press [OK] button
+
+RESULTS:
+3 - "lineTranslateAddressW returned SUCCESS" should be displayed
+
+STEPS:  // Force long distance call
+18 - In function listbox double-click on lineTranslateAddressW
+19 - In dialog box click on dwTranslateOptions
+20 - Click on CARDOVERRIDE (to turn off the default)
+21 - Click on FORCELD
+22 - Press [OK] button
+
+RESULTS:
+4 - "lineTranslateAddressW returned SUCCESS" should be displayed
+
+STEPS:  // Invalid paramters-- conflict local and long distance
+23 - In function listbox double-click on lineTranslateAddressW
+24 - In dialog box click on dwTranslateOptions
+25 - Click on CARDOVERRIDE (to turn off the default)
+26 - Click on FORCELOCAL
+27 - Click on FORCELD
+28 - Press [OK] button
+
+RESULTS:
+5 - "lineTranslateAddressW returned LINEERR_INVALPARAM" should be displayed
+
+STEPS:
+29 - In the Function listbox double-click on lineShutdown 
+30 - In dialog box press [OK]
+31 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 31 lineConfigDialogW 
+***********************************************************************************
+
+STEPS: // Verify dialog pop-up
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In function listbox double-click on lineConfigDialogW
+
+RESULTS:
+1 - Pop-up dialog box for configuring installed modem
+
+STEPS: // Close dialog box
+4 - On dialog box press [OK] button
+
+RESULTS:
+2 - "lineConfigDialogW returned SUCCESS" should be displayed
+
+STEPS:
+6 - In the Function listbox double-click on lineShutdown 
+7 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 32 lineTranslateDialog 
+***********************************************************************************
+
+STEPS: // Verify dialog pop-up
+1 - Run TAPI Browser
+2 - In function listbox double-click on lineConfigDialogW
+
+RESULTS:
+1 - Pop-up dialog box labeled Dialing Properties
+
+STEPS: // Close dialog box
+3 - On dialog box press [OK] button
+
+RESULTS:
+2 - "lineTranslateDialog returned SUCCESS" should be displayed
+
+STEPS:
+5 - In  function listbox double-click on lineConfigDialogW
+6 - On Dialing Properties dialog box, check (or uncheck) Dial as Long Distance box
+7 - On Dialing Properties press [OK] button
+
+RESULTS:
+3 - "lineTranslateDialog returned SUCCESS" should be displayed, as well as "received LINE_LINEDEVSTATE" with param1 returning "REINIT"
+
+STEPS:
+8 - Close TAPI Browser
+
+
+***********************************************************************************
+**** Test Case - 80 lineDialW 
+***********************************************************************************
+
+lineInitializeW
+lineOpenW
+lineMakeCallW with lpszDestAddr set to NULL
+lineDialW with lpszDestAddr set to a phone number to call.
+
+Result:
+
+Talk/Drop dialog should appear, and call should ring through to the number you entered.
+
+
+lineDrop
+lineClose
+lineShutdown
+
+***********************************************************************************
+**** Test Case - 81 lineGetIDW - comm & comm/datamodem 	
+***********************************************************************************
+
+lineInitializeExW
+lineOpenW as Owner
+lineGetIDW with lpszDeviceClass set to 'comm'
+
+Result:
+
+The data after dwStringOffset should be the name of the modem
+
+lineGetIDW with lpszDeviceClass set to 'ndis'
+
+Result:
+
+The data after dwStringOffset should be set to com.
+
+
+lineGetIDW with lpszDeviceClass set to 'comm/datamodem'
+
+Result:
+
+The data after dwStringOffset should be a numeric value (8 digits) followed by the name of the modem.  The numeric value is a handle to the comm port.  It's usually 00000000 or a low number.
+
+
+At the bottom of the TB API list, CloseHandle is listed.  Call CloseHandle with hObject set to the numeric value returned in lineGetIDW with 'comm/datamodem'.
+
+Result:
+
+Handle is closed.  The handle should be identified as the same numeric value entered into hObject.
+
+lineClose
+lineShutdown
+
+
+***********************************************************************************
+**** Test Case - 83 lineReply & lineCallState
+***********************************************************************************
+
+STEPS:  // Check LINE_REPLY is correct for instance of multiple apps running
+1 - Run TAPI Browser
+2 - In the Function listbox double-click on lineInitializeExW
+3 - In the Function listbox double-click on lineInitializeExW
+4 - In the Function listbox double-click on lineShutdown
+5 - In the Function listbox double-click on lineOpenW
+6 - In the Function listbox double-click on lineMakeCallW
+
+RESULTS:
+1 - TB20 should display the following: 
+
+lineMakeCallW returned x1
+   received LINE_REPLY : hDev=x0, cbInst=x0
+     p1=x1,
+     p2=x0,
+     p3=x0
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x8, DIALTONE
+     p2=x20, UNAVAIL
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x10, DIALING
+     p2=x0,
+     p3=x0,
+   received LINE_CALLSTATE : hDev=x_______, cbInst=x0
+     p1=x200 PROCEEDING
+     p2=x0,
+     p3=x0,
+
+[Note: The absence of the LINE_REPLY or LINE_CALLSTATE indicates failure of the test case even if the call otherwise succeeds.]
+
+STEPS:
+7 - In the Function listbox double-click on lineDrop and then lineDeallocateCall
+8 - In the Function listbox double-click on lineClose
+9 - In the Function listbox double-click on lineShutdown
+10 - Close TAPI Browser
+
+***********************************************************************************
+**** Test Case - 175 lineNegotiateAPIVersion / 2.0
+***********************************************************************************
+
+STEPS: // default call should get 2.0 version # returned
+1 - Run TB
+2 - turn off the [Parms] checkbox
+3 - Double Click lineInitializeEx
+4 - dblclick [lineNegotiateAPIVersion]
+
+RESULTS:
+1 - should get the following in the results window
+    lineNegotiateAPIVersion returned SUCCESS
+      APIVersion=x20000
+      extID.ID0=x0, .ID1=x0, .ID2=x0, .ID3=x0, 
+
+STEPS: //ensure if LOW is > high ver #, this fails.
+5 - turn on the [Parms] checkbox
+6 - dblclick [lineNegotiateAPIVersion]
+7 - click [dwAPILowVersion]
+8 - enter 00030000
+9 - Press OK
+
+RESULTS:
+2 - should get the following in the results window
+    lineNegotiateAPIVersion returned LINEERR_INCOMPATIBLEAPIVERSION
+  
+
+STEPS: //ensure if HIGH is both < high ver # and > low ver# we get a match
+10 - dblclick [lineNegotiateAPIVersion]
+11 - click [dwAPIHighVersion]
+12 - enter 00010003
+13 - Press OK
+
+RESULTS:
+3 - should get the following in the results window
+    lineNegotiateAPIVersion returned SUCCESS
+      APIVersion=x10003
+      extID.ID0=x0, .ID1=x0, .ID2=x0, .ID3=x0, 
+
+STEPS:
+14 - In the Function listbox double-click lineShutdown
+15 - Close TB
+
+************************* End Of Uni_BVT Test ************************************
diff --git a/private/tapi/qa/bvt/working/lineapi.inc b/private/tapi/qa/bvt/working/lineapi.inc
new file mode 100644
index 000000000..521e79241
--- /dev/null
+++ b/private/tapi/qa/bvt/working/lineapi.inc
@@ -0,0 +1,3 @@
+ function lineIntialize()
+ 	wListItemdblClk _hwnd(GenData.hAPIList)
+ end function
\ No newline at end of file
diff --git a/private/tapi/qa/bvt/working/tapibvt.mst b/private/tapi/qa/bvt/working/tapibvt.mst
new file mode 100644
index 000000000..afb449e96
--- /dev/null
+++ b/private/tapi/qa/bvt/working/tapibvt.mst
@@ -0,0 +1,58 @@
+'$define TESTCTRL
+'$include 'declares'
+'$include 'mstest32.inc'
+'$include 'winapi32.inc'
+'$include 'vars.inc'
+'$include 'TAPILog.Inc'
+'$include 'TB.INC'
+'$include 'Window.inc'
+
+dim ret  as short 'General return value catcher
+dim hwnd as short 'Handle to TB
+DIM API  as String
+
+CurrentLoggingLevel = 5
+SetLogFileName
+StartLog TRUE, "TAPI 2.0 BVTs"
+
+LogItem DETAILFUNCTION,  "Launching TAPI Browswer"
+ret  = LaunchTB(curdir$+"\",14,GenData)
+
+
+   API = "LineInitialize"
+   'LogStartCase API
+   Params ENABLE
+   wButtonClick _hwnd(GenData.hClear)
+   wListItemDblClk _hwnd(GenData.hAPIList), API
+   GetOptionWindowHandles GenData, "LineInitialize"
+   wButtonClick _hwnd(GenData.hOK)
+   'LogEndCase SUCCESS, TRUE, "This is the comment"
+
+   Params DISABLE
+   API = "LineOpen"
+   'LogStartCase API
+   wButtonClick _hwnd(GenData.hClear)
+   wListItemDblClk _hwnd(GenData.hAPIList), API
+   'LogEndCase SUCCESS, FALSE,  "This is the comment"
+
+   API = "LineClose"
+   'LogStartCase API
+   wButtonClick _hwnd(GenData.hClear)
+   wListItemDblClk _hwnd(GenData.hAPIList), API
+   'LogEndCase SUCCESS, FALSE, "This is the comment"
+
+   API = "LineShutDown"
+   'LogStartCase API
+   wButtonClick _hwnd(GenData.hClear)
+   wListItemDblClk _hwnd(GenData.hAPIList), API
+   'LogEndCase SUCCESS, TRUE, "This is the comment"
+
+   'Need to write summary information to the log
+CloseLog
+
+msgbox "all done"
+ret = SendMessage(GenData.hTB, WM_CLOSE, 0,0)
+
+end
+
+
diff --git a/private/tapi/qa/bvt/working/tapilog.inc b/private/tapi/qa/bvt/working/tapilog.inc
new file mode 100644
index 000000000..b5d3dfd4a
--- /dev/null
+++ b/private/tapi/qa/bvt/working/tapilog.inc
@@ -0,0 +1,366 @@
+'$IFNDEF TAPILog_inc
+'$DEFINE TAPILog_inc
+
+type CaseStruct
+
+   TC_Num     as short
+   Expect_Res as string
+   Actual_Res as string
+   Apprase    as string
+
+end type
+
+declare sub SetLogFileName()
+declare function StartLog( ClearLog as Integer, Comment as string) as integer
+declare sub CloseLog()
+declare sub LogItem ( Level as short, Comment as String )
+declare sub WriteLogItem( Token as String, Item as string )
+declare Sub LogOSMemory ()
+declare sub StartCase()
+declare sub LogCase(X as CaseStruct)
+declare sub CloseCase (TitleComment as string)
+
+const DETAILOTHER    = 1
+const DETAILCASE     = 2
+const DETAILFUNCTION = 3
+
+Const VER_PLATFORM_WIN32s           =  0
+Const VER_PLATFORM_WIN32_WINDOWS    =  1
+Const VER_PLATFORM_WIN32_NT         =  2
+Const SectionGen                    =  "GENERAL"
+Const SectionSummary                =  "SUMMARY"
+Const SectionDetail                 =  "DETAIL"
+Const OS                            =  "Operating System"
+
+Const DELETE_LOGFILE = TRUE      'Pass one of these two constants as the
+Const APPEND_LOGFILE = FALSE     'first parameter to StartLog function.
+
+global CurrentLoggingLevel as integer
+global LogFileName         as string
+
+global TotalScenarios  as short
+global TotalTestCases  as short
+global FailedTestCases as short
+
+global LogTokenStartCase    as string
+global LogTokenCaseItem     as string
+global LogTokenFunctionItem as string
+global LogTokenDefaultItem  as string
+global LogTokenStopCase     as string
+global LogTokenOtherItem    as string
+
+
+'*****************************************************************************
+'*****************************************************************************
+'Name   : SetLogFileName
+'Desc   : Configures the log filename. This is done in a fuction so the logic
+'         can be easily added down the road to get the tests to dynamically
+'         log to different locations.
+'Parms  : none
+'Return : none
+'History: 01/09/96 : peterje : Created
+'*****************************************************************************
+sub SetLogFileName()
+'  LogFileName = curdir$+"\TAPI BVT LOG.txt"      obsolete line
+   LogFileName = curdir$+"\" + TEST_LOGFILE
+end sub
+'*****************************************************************************
+
+'*****************************************************************************
+'*****************************************************************************
+'Name   : StartLog
+'Desc   : Opens and initialized the log file. This function also writes several
+'         system values into the [general] section of the log file.
+'Parms  : ClearLog  : Should the file be deleted if it exists before starting?
+'         LogComment: Comment to write to the log file
+'Return : 1 if a log file was deleted
+'         0 otherwise
+'History: 01/09/96 : peterje : Created
+'ToDo   : Need to add error trapping for the kill function
+'*****************************************************************************
+function StartLog( ClearLog as Integer, LogComment as string) as integer
+   dim ret as integer
+
+
+   LogTokenStartCase    = "START CASE : "
+   LogTokenCaseItem     = CHR$(9)+"CASE : "
+   LogTokenFunctionItem = CHR$(9)+"FUNCTION : "
+   LogTokenDefaultItem  = CHR$(9)+"Invalid detail Level; The CurrentLoggingLevel variable must be > 1"
+   LogTokenStopCase     = "END CASE : "
+   LogTokenOtherItem    = ""
+
+   StartLog = 0
+   if ClearLog then
+      if exists( LogFileName ) then
+         kill LogFileName
+         StartLog = 1
+      endif
+   endif
+
+   LogItem (DETAILOTHER, "Log Opened -- "+Time$+" "+Date$)
+   LogItem (DETAILOTHER, LogComment)
+   LogItem (DETAILOTHER, "")
+   LogItem (DETAILOTHER, "[General]")
+   LogItem (DETAILOTHER, "")
+   LogOSMemory
+   LogItem (DETAILOTHER, "")
+   LogItem (DETAILOTHER, "")
+   LogItem (DETAILOTHER, "[Details]")
+   LogItem (DETAILOTHER, "<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
+   StartCase
+
+end function
+'*****************************************************************************
+
+
+'*****************************************************************************
+'*****************************************************************************
+'Name   : CloseLog
+'Desc   : Closed the log file, and writes the time, date to the end
+'Parms  : none
+'Return : none
+'History: 01/09/96 : peterje : Created
+'*****************************************************************************
+sub CloseLog()
+   LogItem (DETAILOTHER, "Log Closed -- "+Time$+" "+Date$)
+end sub
+'*****************************************************************************
+
+
+'*****************************************************************************
+'*****************************************************************************
+'Name   : LogItem
+'Desc   : Calls WriteLogItem based on the current log level, and the level
+'         for this item.
+'Parms  : Level : Logging level associated with this item
+'         LogComment : Item to be writen to the logfile.
+'Return : none
+'History: 01/09/96 : peterje : Created
+'*****************************************************************************
+sub LogItem ( Level as short, LogComment as String )
+   if Level <= CurrentLoggingLevel then
+      Select Case Level
+         Case DETAILOTHER
+            WriteLogItem (LogTokenOtherItem, LogComment)
+         Case DETAILCASE
+            WriteLogItem (LogTokenCaseItem, LogComment)
+         Case DETAILFUNCTION
+            WriteLogItem (LogTokenFunctionItem, LogComment)
+         Case else
+            WriteLogItem (LogTokenDefaultItem, LogComment)
+      End Select
+   else
+      WriteLogItem (LogTokenDefaultItem, LogComment)
+   endif
+end sub
+'*****************************************************************************
+
+
+'*****************************************************************************
+'*****************************************************************************
+'Name   : WriteLogItem
+'Desc   : Actually writes the item to the log. The file is opened and closed
+'         for every item to help avoid data loss if the current test crashes.
+'Parms  : Token : Token to preceed the item in the log
+'         LogComment: Item to be writen to the log
+'Return : none
+'History: 01/09/96 : peterje : Created
+'ToDo   : Need to add error trapping for the open and the write functions.
+'*****************************************************************************
+sub WriteLogItem( Token as String, LogComment as string )
+   dim FileNum as integer
+   dim counter as integer
+
+   FileNum = FreeFile
+   Open  LogFilename for Append as FileNum
+   Print #FileNum, Token + LogComment
+   Close FileNum
+
+end sub
+'*****************************************************************************
+
+
+'*****************************************************************************
+'*****************************************************************************
+'Name   : LogOSMemory
+'Desc   : Continues the initialization of the log file started by the StartLog
+'         function. This function writes information on The Test Pc Operating
+'         system to the [general] section of the log file.
+'Parms  : None. The Subroutine uses the following Const:
+'         VER_PLATFORM_WIN32s
+'         VER_PLATFORM_WIN32_WINDOWS
+'         VER_PLATFORM_WIN32_NT
+'         SectionGen
+'         OS
+'         Note: The Const TEST_SCRIPT_VERSION MUST be set in the main test script
+'
+'         The global variable logfilename is also used.
+'
+'Return : No Return Value
+'
+'History: 01/10/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub LogOSMemory ()
+
+   dim verinfo as OSVersionInfo                   'Operating System Data Structure
+  ' dim ptr_verinfo as pointer to OSVersionInfo
+   dim rtn as long                                'Generic
+   dim tempstring as string                       'Generic
+   dim minfo as memorystatus                      'Memory Data Structure
+   dim ptr_minfo as pointer to memorystatus
+
+' Get Test PC Operating System data
+
+   verinfo.dwOSVersionInfoSize = len(verinfo)
+  ' ptr_verinfo = varptr (verinfo)
+   rtn = GetVersionEx (verinfo)
+
+   Select case verinfo.dwPlatformID
+      case VER_PLATFORM_WIN32s
+          LogItem (DETAILOTHER, OS + "= Win32s")
+      case VER_PLATFORM_WIN32_WINDOWS
+          LogItem (DETAILOTHER, OS + "= Windows 95")
+      case VER_PLATFORM_WIN32_NT
+          LogItem (DETAILOTHER, OS + "= Windows NT")
+   end select
+
+   LogItem (DETAILOTHER, "Version= " + str$(verinfo.dwMajorVersion) + "." + ltrim$(str$(verinfo.dwMinorVersion)))
+
+   LogItem (DETAILOTHER, "Build Number= " + str$(Loword(verinfo.dwBuildNumber)))
+
+' Get Test PC Memory Configuration
+
+   minfo.dwlength = len(minfo)
+   GlobalMemoryStatus (minfo)
+
+   LogItem (DETAILOTHER,  "MemoryLoad= " + str$(minfo.dwMemoryLoad) + "%")
+   LogItem (DETAILOTHER,  "Total Physical Memory= " + str$(csng(minfo.dwTotalPhys)))
+'  LogItem (DETAILOTHER,  "Available Virtual Memory= " + str$(csng(minfo.dwAvailVirtual)))
+
+'Define the Processor
+
+	LogItem (DETAILOTHER, "")
+	tempstring = space$(80)
+	tempstring = environ$("PROCESSOR_ARCHITECTURE")
+	LogItem (DETAILOTHER, "Processor Architechture = " + tempstring)
+
+	tempstring = space$(80)
+	tempstring = environ$("PROCESSOR_IDENTIFIER")
+	LogItem (DETAILOTHER, "Processor Identifier = " + tempstring)
+
+	tempstring = space$(80)
+	tempstring = environ$("NUMBER_OF_PROCESSORS")
+	LogItem (DETAILOTHER, "Nunber of Processor = " + tempstring)
+'Define the Language Character set
+
+	LogItem (DETAILOTHER, "")
+	if (GetSystemMetrics (SM_DBCSENABLED) = 0) then
+		LogItem (DETAILOTHER, "Single Byte Characterset Enabled")
+	else
+		LogItem (DETAILOTHER, "Double Byte Characterset Enabled")
+	endif
+	LogItem (DETAILOTHER, "")
+
+' Write Test Script Version Number - This is dependent on a Const string: TEST_SCRIPT_VERSION
+
+   LogItem (DETAILOTHER, "Test Script Version=" + TEST_SCRIPT_VERSION)
+
+End Sub
+
+'*****************************************************************************
+'Name   : StartCase
+'Desc   : Continues the initialization of the log file started by the StartLog
+'         function. This function writes Test Case Header after the [Details]
+'         section of the log file. This routine is called by StartLog.
+'Parms  : None.
+'
+'Return : No Return Value
+'
+'History: 01/15/96 : a-rrohr: Created
+'*****************************************************************************
+sub StartCase()
+
+dim Heading as string * 80
+
+Heading = "Case #"           + string$(7,chr$(32)) + _
+          "Expected Results" + string$(14,chr$(32))+ _
+          "Actual Results"   + string$(9,chr$(32)) + _
+          "Pass/Fail"
+
+logitem (DETAILOTHER, "")       'New Line
+LogItem (DETAILOTHER, (Heading))
+LogItem (DETAILOTHER, "")       'New Line
+
+End sub 'StartCase()
+
+'*****************************************************************************
+
+'*****************************************************************************
+'Name   : LogCase
+'Desc   : This function writes Test Case information to the [Details]
+'         section of the log file. This information consists of the Test Case
+'         number, the expected results (limited to 27 char), the actual results
+'         (limited to 27 char) and Pass/Fail.
+'
+'Parms  : CaseStruct variable that contains the information strings.
+'
+'Return : No Return Value
+'
+'History: 01/15/96 : a-rrohr: Created
+'*****************************************************************************
+sub LogCase (X as CaseStruct)
+
+dim OutputLine as string * 80
+dim tempstring1 as string
+dim tempstring2 as string * 27
+dim tempstring3 as string * 27
+dim tempstring4 as string * 6
+
+tempstring1 = ltrim$(str$(X.TC_Num))
+tempstring1 = space$(4-len(tempstring1)) +  tempstring1
+tempstring2 = X.Expect_Res
+tempstring3 = X.Actual_Res
+tempstring4 = X.Apprase
+
+OutputLine =  tempstring1 + " | " + _
+              tempstring2 + " | " + _
+              tempstring3 + " | " + _
+              tempstring4
+
+LogItem (DETAILOTHER, (OutputLine))
+
+End sub 'LogCase
+'*****************************************************************************
+
+'*****************************************************************************
+'Name   : CloseCase
+'Desc   : This function writes Test Case information to the [Details]
+'         section of the log file. This information consists of the Test Case
+'         number, the expected results (limited to 27 char), the actual results
+'         (limited to 27 char) and Pass/Fail.
+'
+'Parms  : TitleComment - contains Test Script Name.
+'         Also Uses Global Variables TotalScenarios, TotalTestCases and 
+'			 FailedTestCases
+'
+'Return : No Return Value
+'
+'History: 01/16/96 : a-rrohr: Created
+'*****************************************************************************
+sub CloseCase (TitleComment as string)
+
+   LogItem (DETAILOTHER, "")
+   LogItem (DETAILOTHER, "Summary for Test Script " + TiTleComment)
+   LogItem (DETAILOTHER, "")
+
+	LogItem (DETAILOTHER, "  Total Number of Test Scenarios Executed = " + ltrim$(Str$(TotalScenarios)))
+	LogItem (DETAILOTHER, "  Total Number of Test Cases Executed     = " + ltrim$(Str$(TotalTestCases)))
+   LogItem (DETAILOTHER, "  Total Number of Failed Test Cases       = " + ltrim$(Str$(FailedTestCases)))
+   LogItem (DETAILOTHER, "")
+
+
+End sub 'CloseCase
+'*****************************************************************************
+
+'$ENDIF
diff --git a/private/tapi/qa/bvt/working/tb.inc b/private/tapi/qa/bvt/working/tb.inc
new file mode 100644
index 000000000..a3ba8724e
--- /dev/null
+++ b/private/tapi/qa/bvt/working/tb.inc
@@ -0,0 +1,179 @@
+'General include file
+
+
+'$ifndef TB_INC
+'$define TB_IBC
+declare function LaunchTB(Path$, Version as integer, GenData as General_Type)as integer
+declare Function GetOptionWindowHandles(GenData as General_Type, APIName as string ) as integer
+declare Function GetTBWindowHandles(GenData as General_Type ) as integer
+declare Function LogResults ( Expect as short, DumpResultsToLog as short, LogComment as string ) as short
+declare SUB Params( Mode as short )
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'Name    : LaunchTB
+'Notes   : Launches TAPIBrowser( passed version ), and puts the window handle for
+'          the launched version into the General data structure.
+'Parms   : Version - Number of version to launch
+'          GenData - Data structure which gets the window handle
+'Return  : 0 - App was started properly
+'          2 - App was not started. Bad filename likely
+'History :
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+function LaunchTB(Path$, Version as integer, GenData as General_Type)as integer
+    dim ret     as Integer
+    dim AppName as String
+    dim hButton as long
+    dim hDlg    as long
+
+    ret = run(Path$+"tb"+trim$(str$(Version))+".exe")
+    if ret = 0 then
+        select case Version
+            case 14
+                AppName = "TAPI32 Browser"
+            case 20
+                AppName = "TAPI32 Browser"
+            case else
+                AppName = "TAPI32 Browser"
+        end select
+
+        GenData.hTB = FindWindow("#32770", AppName)
+        if GenData.hTB <> 0 then GetTBWindowHandles(GenData)
+
+        'Close that 1st window if this is the 1st time TB has been run
+        hDlg = FindWindow("#32770","Using the TAPI Browser")
+        if hDlg <> 0 then 'this is the 1st run
+          hButton = GetWindow( hDlg,GW_CHILD )
+          wButtonClick  _hwnd(hButton)
+        endif
+    endif
+    LaunchTB = ret
+end function
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+
+
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'Name    : GetTBWindowHandles
+'Notes   : Gets the handles for the controls on the main TB UI
+'Parms   : GenData - Data structure which gets the window handle
+'Return  : 0  - All handles were obtained
+'          -1 - Could not get one or more handles
+'History : PeterJe | 12/18/95 | Created
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+Function GetTBWindowHandles(GenData as General_Type ) as integer
+   GenData.hAPIList  = GetDlgItem(GenData.hTB, CID_TBAPIListWindow)
+   GenData.hLineInfo = GetDlgItem(GenData.hTB, CID_TBLineInfoWindow)
+   GenData.hResults  = GetDlgItem(GenData.hTB, CID_TBResultsWindow)
+   GenData.hParams   = GetDlgItem(GenData.hTB, CID_TBParmsCheckBox)
+   GenData.hClear    = GetDlgItem(GenData.hTB, CID_TBClearButton)
+end function
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+
+
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'Name    : GetOptionsWindowHandles
+'Notes   : Gets the handles for the controls on the main TB UI
+'Parms   : GenData - Data structure which gets the window handle
+'Return  : 0  - All handles were obtained
+'          -1 - Could not get one or more handles
+'History : PeterJe | 12/18/95 | Created
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+Function GetOptionWindowHandles(GenData as General_Type, APIName as string ) as integer
+   dim x as  long
+   GenData.hOptions = FindWindow ("#32770", APIName )
+   if GenData.hOptions <> 0 then
+      x =  GetWindow(GenData.hOptions, GW_CHILD) 'parameters label. Don't need to capture
+      GenData.hParameters = GetWindow(x, GW_HWNDNEXT)
+
+      x = GetWindow(GenData.hParameters,GW_HWNDNEXT) 'Value label, don't need to capture
+      GenData.hValueCBox = GetWindow(x,GW_HWNDNEXT)
+      x = GetWindow(GenData.hValueCBox, GW_HWNDNEXT) 'BitFlags label, don't need to capture
+      GenData.hValueCBoxList = GetWindow(GenData.hValueCBox,GW_CHILD)
+      GenData.hValueCBoxEdit = GetWindow(GenData.hValueCBoxList, GW_HWNDNEXT)
+
+
+      x = GetWindow(GenData.hValueCBox, GW_HWNDNEXT) 'BitFlags label, don't need to capture
+      GenData.hBitFlags = GetWindow( x, GW_HWNDNEXT )
+      GenData.hOK       = GetWindow( GenData.hBitFlags, GW_HWNDNEXT )
+      GenData.hCancel   = GetWindow( GenData.hOK, GW_HWNDNEXT )
+      GenData.hHelp     = GetWindow( GenData.hCancel, GW_HWNDNEXT )
+   endif
+end function
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+
+
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+'Name    : CallTAPI
+'Notes   : Uses TB to invoke TAPI function calls
+'Parms   :
+'Return  :
+'
+'History : PeterJe | 12/19/95 | Created
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+Function LogResults ( Expect as short, DumpResultsToLog as short, LogComment as string ) as short
+
+   Dim Results      as String
+   dim ret          as short
+   dim FoundError   as long
+   dim FoundSuccess as long
+
+
+   'Get and verify results
+   Results = space$(32767)
+   WGetText GenData.hResults, Results
+
+
+   if DumpResultsToLog = TRUE then LogItem DETAILFUNCTION, Trim$(Results)
+
+   FoundSuccess = instr(1,Results, "SUCCESS")
+   FoundError = instr(1,Results, "LINEERR_")
+   if FoundError = 0 then
+      FoundError = instr(1,Results, "PHONEERR_")
+      if FoundError = 0 then
+         FoundError = instr(1,Results, "TAPIERR_")
+      endif
+   endif
+
+
+   if FoundSuccess > 0 and FoundError > 0 then
+      ret = -1
+   elseif FoundSuccess = 0 and FoundError = 0 then
+      ret = -2
+   elseif Expect = SUCCESS and FoundSuccess > 0 then
+      ret = 1
+   elseif expect = FAILURE and FoundError > 0 then
+      Ret = 1
+   else
+      Ret = 0
+   endif
+
+   Select Case ret
+      Case 0
+         LogItem DETAILFUNCTION, "Problems encounterd. Could not determine success or failure."
+         LogResults = FALSE
+      Case 1
+         LogItem DETAILFUNCTION, "API resulted as expected."
+         LogResults = TRUE
+      case -1
+         LogItem DETAILFUNCTION, "Found both success and failure. Logged as failure."
+         LogResults = FALSE
+      case -2
+         LogItem DETAILFUNCTION, "Didn't find SUCCESS or ERR_. Logged as failure."
+         LogResults = FALSE
+   end select
+
+end Function
+'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+
+SUB Params( Mode as short )
+   if Mode = ENABLE then
+      wCheckCheck _hwnd(GenData.hParams)
+   else
+      wCheckUnCheck _hwnd(GenData.hParams)
+   endif
+end sub
+
+
+'$endif
\ No newline at end of file
diff --git a/private/tapi/qa/bvt/working/vars.inc b/private/tapi/qa/bvt/working/vars.inc
new file mode 100644
index 000000000..2646cdc26
--- /dev/null
+++ b/private/tapi/qa/bvt/working/vars.inc
@@ -0,0 +1,57 @@
+'Data types and vars
+'$ifndef VARS_INC
+'$define VARS_IBC
+
+Type General_Type
+   'Main TAPI Browser UI handles ( used to drive TB )
+   hTB            as long
+   hAPIList       as long
+   hLineInfo      as long
+   hResults       as long
+   hParams        as long
+   hClear         as long
+
+	'Handles for the Options dialog
+	hOptions       as long
+	hParameters    as long
+	hValueCBox     as long
+	hValueCBoxList as long
+	hValueCBoxEdit as long
+	hBitFlags      as long
+	hOK            as long
+	hCancel        as long
+	hHelp			   as long
+end type
+
+Global GenData as General_Type
+
+
+
+const CID_TBAPILISTWINDOW = 1001
+const CID_TBLINEINFOWINDOW = 1000
+const CID_TBRESULTSWINDOW = 1003
+const CID_TBPARMSCHECKBOX = 1017
+const CID_TBCLEARBUTTON   = 1016
+
+const CID_OPARAMETERS = 1000
+const CID_OVALUE      = 1001
+const CID_OVALUELIST  = 1002
+const CID_OBITFLAGS   = 1001 'ListBox
+const CID_OOK         = 1
+const CID_OCANCEL     = 2
+
+const IDM_LOGFILE =40010
+const IDM_CLEAR   =40011
+const IDM_PARAMS  =40012
+const IDM_EXIT    =40013
+
+Global LogFileHandle as integer
+
+
+CONST SUCCESS = 1
+CONST FAILURE = 2
+
+CONST ENABLE  = 1
+CONST DISABLE = 2
+
+'$endif
\ No newline at end of file
diff --git a/private/tapi/qa/bvt/working/window.inc b/private/tapi/qa/bvt/working/window.inc
new file mode 100644
index 000000000..0bc6b9d70
--- /dev/null
+++ b/private/tapi/qa/bvt/working/window.inc
@@ -0,0 +1,70 @@
+'Window manager 'stuffs'
+
+'$ifndef WINDOW_INC
+'$define WINDOW_IBC
+declare Function GetWinDir (WinDir as String) as short
+declare FUNCTION FxindWindow (Caption as String, WaitTime as Integer ) as Long
+declare Function lbxSelectItem( Item as string, hwndListBox as long ) as integer
+'****************************************************************************
+'GetWinDir (WinDir)
+' Params : a string for the Windows directory
+' Tasks : Gets the path of the Win dir (where Windows is installed)
+' Return : True if successful, False if not
+' Author : PeterJe 12/15/95
+'****************************************************************************
+Function GetWinDir (WinDir as String) as short
+	Dim BufLen as short
+	BufLen = 50
+	WinDir = Space$(BufLen)
+	GetWinDir = GetWindowsDirectory(WinDir,BufLen)
+End Function
+'****************************************************************************
+
+'******************************************************************************
+'******************************************************************************
+'ar_DialogFindWindow
+' Parms  : Caption  - Title bar of the dialog
+'			  WaitTime - For what period of seconds should the function look
+'			      		 for the inidcated dialog?
+' Task   : Finds a window based on its caption.
+' Return : hWnd to the dialog
+' Error  : None
+' History : 09/xx/94 | a-peterj | Created
+'******************************************************************************
+FUNCTION FxindWindow (Caption as String, WaitTime as Integer ) as Long
+	DIM hApp
+	hApp = WFndWndWait( Caption, FW_Full or FW_RestoreIcon or FW_Focus or FW_NOCASE, 0 )
+	if hApp = 0 THEN hApp = WFndWndWait( Caption, FW_Full or FW_RestoreIcon or FW_Focus or FW_NOCASE, WaitTime )
+	FxindWindow = hApp
+END FUNCTION
+'******************************************************************************
+
+'******************************************************************************
+'******************************************************************************
+'lbxSelectItem
+' Parms  : Caption  -
+' Task   : Selects an  item in a listbox
+' Return : 1 if success, 0 otherwise
+' Error  : None
+' History : 12/18/95 | peterje | Created
+'******************************************************************************
+Function lbxSelectItem( Item as string, hwndListBox as long )as integer
+	dim ret as integer
+	dim handle as string
+
+	handle = "="+trim$(str$(hwndListBox))
+	ret = WListItemExists(handle,Item)
+	if ret > 0 then
+
+		msgbox "we found it"
+		lbxSelectItem = 1
+	else
+		msgbox "where is it?"
+		lbxSelectItem = 0
+	endif
+
+end function
+'******************************************************************************
+
+
+'$endif
\ No newline at end of file
diff --git a/private/tapi/qa/collect.bat b/private/tapi/qa/collect.bat
new file mode 100644
index 000000000..638cbe946
--- /dev/null
+++ b/private/tapi/qa/collect.bat
@@ -0,0 +1,52 @@
+set V=retail
+if (%NTDEBUG%)==(cvp)  set V=debug
+if (%NTDEBUG%)==(ntsd) set V=debug
+if (%NTDEBUG%)==(sym)  set V=debug
+set P=%PROCESSOR_ARCHITECTURE%
+if (%P%)==(x86) set P=i386
+
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\cline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\iline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\line20.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\sline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tcline.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tcore.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\testapp.exe         %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tiline.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tline20.dll         %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\ttest.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tphone.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tsline.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\ttphone.dll         %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\txline.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tyline.dll          %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\xline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\yline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\uline.dll           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy .\bin\%P%\trapper.exe    %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy .\trapper\trapper.ini    %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy .\trapper\readme.txt     %RP_MAIN%\current\tapi\%P%\%V%\
+
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tcline.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tcore.dll   %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tiline.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tline.dll   %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tline20.dll %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tsline.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\ttest.dll   %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\ttphone.dll %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\txline.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\tyline.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\wline.dll   %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\wphone.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+xcopy %_NTBINDIR%\public\sdk\lib\unicode\%P%\uline.dll  %RP_MAIN%\current\tapi\%P%\%V%\unicode\
+
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\tclient.exe           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\clntapp.exe           %RP_MAIN%\current\tapi\%P%\%V%\
+xcopy %_NTBINDIR%\public\sdk\lib\%P%\srvapp.exe           %RP_MAIN%\current\tapi\%P%\%V%\
+
+set V=
+set P=
+
+
\ No newline at end of file
diff --git a/private/tapi/qa/dialingp/dialrule.inc b/private/tapi/qa/dialingp/dialrule.inc
new file mode 100644
index 000000000..ec91b05da
--- /dev/null
+++ b/private/tapi/qa/dialingp/dialrule.inc
@@ -0,0 +1,1695 @@
+'Created On 3/27/96	2:48:52 PM
+'With Phone.MST from file \\TNixon\Public\Country List\TAPI 2.0 Country List.txt
+
+'$IFNDEF DIALRULE2_INC
+'$DEFINE DIALRULE2_INC
+
+'************************* Define Types **************************************
+
+Type itemlist
+
+item as short
+tested as short
+country as string
+
+end type
+
+Type TelephoneNo
+
+CountryCode  as short
+AreaCode		 as string
+SubscriberNo as string
+
+end type
+
+Type CountryRule
+
+Code		 as short
+Country	 as string
+LocalRule as string
+LongRule	 as string
+InterRule as string 
+
+end type
+
+Type CardData
+
+ID		 as short
+Cardname	 as string
+LocalRule as string
+LongRule	 as string
+InterRule as string
+Tested    as long			 ' Set to true when this card is tested
+Number	 as long			 ' Set to true if a calling card number is required
+
+end type
+
+'************************* Dimension Arrays ***********************************
+
+dim CallingCard (22) as CardData
+dim DialingRule(241) as CountryRule
+
+'************************* Define CallingCard array ***************************
+
+dim CallingCardNumber as short	'Enter this number when Calling Card Number is
+CallingCardNumber = 1234			'enabled (i.e. CallingCard(X).Number = TRUE)
+
+CallingCard(0).ID = 0
+CallingCard(0).Cardname = "None (Direct Dial)"
+CallingCard(0).LocalRule = ""
+CallingCard(0).LongRule  = ""
+CallingCard(0).InterRule = ""
+CallingCard(0).Number = FALSE
+CallingCard(0).Tested = FALSE
+
+CallingCard(1).ID = 1
+CallingCard(1).Cardname = "AT&T Direct Dial via 10ATT1"
+CallingCard(1).LocalRule = "G"
+CallingCard(1).LongRule  = "102881FG"
+CallingCard(1).InterRule = "10288011EFG"
+CallingCard(1).Number = FALSE
+CallingCard(1).Tested = FALSE
+
+CallingCard(2).ID = 2
+CallingCard(2).Cardname = "AT&T via 10ATT0"
+CallingCard(2).LocalRule = "G"
+CallingCard(2).LongRule  = "102880FG$TH"
+CallingCard(2).InterRule = "1028801EFG$TH"
+CallingCard(2).Number = TRUE
+CallingCard(2).Tested = FALSE
+
+CallingCard(3).ID = 3
+CallingCard(3).Cardname = "AT&T via 1-800-321-0288"
+CallingCard(3).LocalRule = "G"
+CallingCard(3).LongRule  = "18003210288$TFG$TH"
+CallingCard(3).InterRule = "18003210288$T01EFG$TH"
+CallingCard(3).Number = TRUE
+CallingCard(3).Tested = FALSE
+
+CallingCard(15).ID = 15
+CallingCard(15).Cardname = "British Telecom (UK)"
+CallingCard(15).LocalRule = "144$H,0FG"
+CallingCard(15).LongRule  = "144$H,0FG"
+CallingCard(15).InterRule = "144$H,010EFG"
+CallingCard(15).Number = TRUE
+CallingCard(15).Tested = FALSE
+
+CallingCard(12).ID = 12
+CallingCard(12).Cardname = "Calling Card via 0"
+CallingCard(12).LocalRule = "G"
+CallingCard(12).LongRule  = "0FG$TH"
+CallingCard(12).InterRule = "01EFG$TH"
+CallingCard(12).Number = TRUE
+CallingCard(12).Tested = FALSE
+
+CallingCard(13).ID = 13
+CallingCard(13).Cardname = "Carte France Telecom"
+CallingCard(13).LocalRule = "T3610,H,G#"
+CallingCard(13).LongRule  = "T3610,H,16,FG#"
+CallingCard(13).InterRule = "T3610,H,19,EFG#"
+CallingCard(13).Number = TRUE
+CallingCard(13).Tested = FALSE
+
+CallingCard(16).ID = 16
+CallingCard(16).Cardname = "CLEAR Communications (New Zealand)"
+CallingCard(16).LocalRule = "0502333$TH,0FG"
+CallingCard(16).LongRule  = "0502333$TH,0FG"
+CallingCard(16).InterRule = "0502333$TH,00EFG"
+CallingCard(16).Number = TRUE
+CallingCard(16).Tested = FALSE
+
+CallingCard(18).ID = 18
+CallingCard(18).Cardname = "Global Card (Taiwan to USA)"
+CallingCard(18).LocalRule = "G"
+CallingCard(18).LongRule  = "0FG"
+CallingCard(18).InterRule = "0080,102880$TFG$H"
+CallingCard(18).Number = TRUE
+CallingCard(18).Tested = FALSE
+
+CallingCard(4).ID = 4
+CallingCard(4).Cardname = "MCI Direct Dial via 102221"
+CallingCard(4).LocalRule = "G"
+CallingCard(4).LongRule  = "102221FG"
+CallingCard(4).InterRule = "10222011EFG"
+CallingCard(4).Number = FALSE
+CallingCard(4).Tested = FALSE
+
+CallingCard(5).ID = 5
+CallingCard(5).Cardname = "MCI via 102220"
+CallingCard(5).LocalRule = "G"
+CallingCard(5).LongRule  = "102220FG$TH"
+CallingCard(5).InterRule = "1022201EFG$TH"
+CallingCard(5).Number = TRUE
+CallingCard(5).Tested = FALSE
+
+CallingCard(7).ID = 7
+CallingCard(7).Cardname = "MCI via 1-800-674-0700"
+CallingCard(7).LocalRule = "G"
+CallingCard(7).LongRule  = "18006740700,,,,,,TH,,FG"
+CallingCard(7).InterRule = "18006740700,,,,,,TH,,011EFG"
+CallingCard(7).Number = TRUE
+CallingCard(7).Tested = FALSE
+
+CallingCard(8).ID = 8
+CallingCard(8).Cardname = "MCI via 1-800-674-7000"
+CallingCard(8).LocalRule = "G"
+CallingCard(8).LongRule  = "18006747000,,,,,,TH,,FG"
+CallingCard(8).InterRule = "18006747000,,,,,,TH,,011EFG"
+CallingCard(8).Number = TRUE
+CallingCard(8).Tested = FALSE
+
+CallingCard(6).ID = 6
+CallingCard(6).Cardname = "MCI via 1-800-888-8000"
+CallingCard(6).LocalRule = "G"
+CallingCard(6).LongRule  = "18008888000,,,,,,TH,,FG"
+CallingCard(6).InterRule = "18008888000,,,,,,TH,,011EFG"
+CallingCard(6).Number = TRUE
+CallingCard(6).Tested = FALSE
+
+CallingCard(14).ID = 14
+CallingCard(14).Cardname = "Mercury (UK)"
+CallingCard(14).LocalRule = "0500800800$TH,0FG"
+CallingCard(14).LongRule  = "0500800800$TH,0FG"
+CallingCard(14).InterRule = "0500800800$TH,0FG"
+CallingCard(14).Number = TRUE
+CallingCard(14).Tested = FALSE
+
+CallingCard(22).ID = 22
+CallingCard(22).Cardname = "Optus (Australia) via 008551812"
+CallingCard(22).LocalRule = "FG"
+CallingCard(22).LongRule  = "FG"
+CallingCard(22).InterRule = "008551812@TH,0011EFG"
+CallingCard(22).Number = TRUE
+CallingCard(22).Tested = FALSE
+
+CallingCard(21).ID = 21
+CallingCard(21).Cardname = "Optus (Australia) via 1812"
+CallingCard(21).LocalRule = "FG"
+CallingCard(21).LongRule  = "FG"
+CallingCard(21).InterRule = "1812@TH,0011EFG"
+CallingCard(21).Number = TRUE
+CallingCard(21).Tested = FALSE
+
+CallingCard(19).ID = 19
+CallingCard(19).Cardname = "Telecom Australia via 1818 (voice)"
+CallingCard(19).LocalRule = "1818$TH,FG#"
+CallingCard(19).LongRule  = "1818$TH,FG#"
+CallingCard(19).InterRule = "1818$TH,0011EFG#"
+CallingCard(19).Number = TRUE
+CallingCard(19).Tested = FALSE
+
+CallingCard(20).ID = 20
+CallingCard(20).Cardname = "Telecom Australia via 1818 (fax)"
+CallingCard(20).LocalRule = "1818$TH,FG#"
+CallingCard(20).LongRule  = "1818$TH,FG#"
+CallingCard(20).InterRule = "1818$TH,0015EFG#"
+CallingCard(20).Number = TRUE
+CallingCard(20).Tested = FALSE
+
+CallingCard(17).ID = 17
+CallingCard(17).Cardname = "Telecom New Zealand"
+CallingCard(17).LocalRule = "012,0FG?H"
+CallingCard(17).LongRule  = "012,0FG?H"
+CallingCard(17).InterRule = "012,00EFG?H"
+CallingCard(17).Number = TRUE
+CallingCard(17).Tested = FALSE
+
+CallingCard(9).ID = 9
+CallingCard(9).Cardname = "US Sprint Direct Dial via 103331"
+CallingCard(9).LocalRule = "G"
+CallingCard(9).LongRule  = "103331FG"
+CallingCard(9).InterRule = "10333011EFG"
+CallingCard(9).Number = FALSE
+CallingCard(9).Tested = FALSE
+
+CallingCard(10).ID = 10
+CallingCard(10).Cardname = "US Sprint via 103330"
+CallingCard(10).LocalRule = "G"
+CallingCard(10).LongRule  = "103330FG$TH"
+CallingCard(10).InterRule = "1033301EFG$TH"
+CallingCard(10).Number = TRUE
+CallingCard(10).Tested = FALSE
+
+CallingCard(11).ID = 11
+CallingCard(11).Cardname = "US Sprint via 1-800-877-8000"
+CallingCard(11).LocalRule = "G"
+CallingCard(11).LongRule  = "18008778000,,,T0FG,,H"
+CallingCard(11).InterRule = "18008778000,,,T01EFG#,H"
+CallingCard(11).Number = TRUE
+CallingCard(11).Tested = FALSE
+
+'************************* Define DialingRule array **************************
+
+DialingRule(0).Code = 1
+DialingRule(0).Country = "United States of America"
+DialingRule(0).LocalRule = "G"
+DialingRule(0).LongRule = " 1FG"
+DialingRule(0).InterRule = "011EFG"
+
+DialingRule(1).Code = 1
+DialingRule(1).Country = "Anguilla"
+DialingRule(1).LocalRule = "G"
+DialingRule(1).LongRule = " 1FG"
+DialingRule(1).InterRule = "011EFG"
+
+DialingRule(2).Code = 1
+DialingRule(2).Country = "Antigua"
+DialingRule(2).LocalRule = "G"
+DialingRule(2).LongRule = " 1FG"
+DialingRule(2).InterRule = "011EFG"
+
+DialingRule(3).Code = 1
+DialingRule(3).Country = "Bahamas"
+DialingRule(3).LocalRule = "G"
+DialingRule(3).LongRule = " 1FG"
+DialingRule(3).InterRule = "011EFG"
+
+DialingRule(4).Code = 1
+DialingRule(4).Country = "Barbados"
+DialingRule(4).LocalRule = "G"
+DialingRule(4).LongRule = " 1FG"
+DialingRule(4).InterRule = "011EFG"
+
+DialingRule(5).Code = 1
+DialingRule(5).Country = "Bermuda"
+DialingRule(5).LocalRule = "G"
+DialingRule(5).LongRule = " 1FG"
+DialingRule(5).InterRule = "011EFG"
+
+DialingRule(6).Code = 1
+DialingRule(6).Country = "British Virgin Islands"
+DialingRule(6).LocalRule = "G"
+DialingRule(6).LongRule = " 1FG"
+DialingRule(6).InterRule = "011EFG"
+
+DialingRule(7).Code = 1
+DialingRule(7).Country = "Canada"
+DialingRule(7).LocalRule = "G"
+DialingRule(7).LongRule = " 1FG"
+DialingRule(7).InterRule = "011EFG"
+
+DialingRule(8).Code = 1
+DialingRule(8).Country = "Cayman Islands"
+DialingRule(8).LocalRule = "G"
+DialingRule(8).LongRule = " 1FG"
+DialingRule(8).InterRule = "011EFG"
+
+DialingRule(9).Code = 1
+DialingRule(9).Country = "Dominica"
+DialingRule(9).LocalRule = "G"
+DialingRule(9).LongRule = " 1FG"
+DialingRule(9).InterRule = "011EFG"
+
+DialingRule(10).Code = 1
+DialingRule(10).Country = "Dominican Republic"
+DialingRule(10).LocalRule = "G"
+DialingRule(10).LongRule = " 1FG"
+DialingRule(10).InterRule = "011EFG"
+
+DialingRule(11).Code = 1
+DialingRule(11).Country = "Grenada"
+DialingRule(11).LocalRule = "G"
+DialingRule(11).LongRule = " 1FG"
+DialingRule(11).InterRule = "011EFG"
+
+DialingRule(12).Code = 1
+DialingRule(12).Country = "Jamaica"
+DialingRule(12).LocalRule = "G"
+DialingRule(12).LongRule = " 1FG"
+DialingRule(12).InterRule = "011EFG"
+
+DialingRule(13).Code = 1
+DialingRule(13).Country = "Montserrat"
+DialingRule(13).LocalRule = "G"
+DialingRule(13).LongRule = " 1FG"
+DialingRule(13).InterRule = "011EFG"
+
+DialingRule(14).Code = 1
+DialingRule(14).Country = "Nevis"
+DialingRule(14).LocalRule = "G"
+DialingRule(14).LongRule = " 1FG"
+DialingRule(14).InterRule = "011EFG"
+
+DialingRule(15).Code = 1
+DialingRule(15).Country = "St. Kitts"
+DialingRule(15).LocalRule = "G"
+DialingRule(15).LongRule = " 1FG"
+DialingRule(15).InterRule = "011EFG"
+
+DialingRule(16).Code = 1
+DialingRule(16).Country = "St. Vincent and the Grenadines"
+DialingRule(16).LocalRule = "G"
+DialingRule(16).LongRule = " 1FG"
+DialingRule(16).InterRule = "0EFG"
+
+DialingRule(17).Code = 1
+DialingRule(17).Country = "Trinidad and Tobago"
+DialingRule(17).LocalRule = "G"
+DialingRule(17).LongRule = " 1FG"
+DialingRule(17).InterRule = "01EFG"
+
+DialingRule(18).Code = 1
+DialingRule(18).Country = "Turks and Caicos Islands"
+DialingRule(18).LocalRule = "G"
+DialingRule(18).LongRule = " 1FG"
+DialingRule(18).InterRule = "0EFG"
+
+DialingRule(19).Code = 1
+DialingRule(19).Country = "Barbuda"
+DialingRule(19).LocalRule = "G"
+DialingRule(19).LongRule = " 1FG"
+DialingRule(19).InterRule = "011EFG"
+
+DialingRule(20).Code = 1
+DialingRule(20).Country = "Puerto Rico"
+DialingRule(20).LocalRule = "G"
+DialingRule(20).LongRule = " 1FG"
+DialingRule(20).InterRule = "011EFG"
+
+DialingRule(21).Code = 1
+DialingRule(21).Country = "Saint Lucia"
+DialingRule(21).LocalRule = "G"
+DialingRule(21).LongRule = " 1FG"
+DialingRule(21).InterRule = "011EFG"
+
+DialingRule(22).Code = 1
+DialingRule(22).Country = "United States Virgin Islands"
+DialingRule(22).LocalRule = "G"
+DialingRule(22).LongRule = " 1FG"
+DialingRule(22).InterRule = "011EFG"
+
+DialingRule(23).Code = 20
+DialingRule(23).Country = "Egypt"
+DialingRule(23).LocalRule = "G"
+DialingRule(23).LongRule = "0FG"
+DialingRule(23).InterRule = "00EFG"
+
+DialingRule(24).Code = 212
+DialingRule(24).Country = "Morocco"
+DialingRule(24).LocalRule = "G"
+DialingRule(24).LongRule = "0IG"
+DialingRule(24).InterRule = "00EFG"
+
+DialingRule(25).Code = 213
+DialingRule(25).Country = "Algeria"
+DialingRule(25).LocalRule = "G"
+DialingRule(25).LongRule = "0FG"
+DialingRule(25).InterRule = "00,EFG"
+
+DialingRule(26).Code = 216
+DialingRule(26).Country = "Tunisia"
+DialingRule(26).LocalRule = "G"
+DialingRule(26).LongRule = "0FG"
+DialingRule(26).InterRule = "00EFG"
+
+DialingRule(27).Code = 218
+DialingRule(27).Country = "Libya"
+DialingRule(27).LocalRule = "G"
+DialingRule(27).LongRule = ""
+DialingRule(27).InterRule = "00EFG"
+
+DialingRule(28).Code = 220
+DialingRule(28).Country = "Gambia"
+DialingRule(28).LocalRule = "G"
+DialingRule(28).LongRule = ""
+DialingRule(28).InterRule = "00EFG"
+
+DialingRule(29).Code = 221
+DialingRule(29).Country = "Senegal Republic"
+DialingRule(29).LocalRule = "G"
+DialingRule(29).LongRule = "0FG"
+DialingRule(29).InterRule = "00EFG"
+
+DialingRule(30).Code = 222
+DialingRule(30).Country = "Mauritania"
+DialingRule(30).LocalRule = "G"
+DialingRule(30).LongRule = ""
+DialingRule(30).InterRule = "00EFG"
+
+DialingRule(31).Code = 223
+DialingRule(31).Country = "Mali"
+DialingRule(31).LocalRule = "G"
+DialingRule(31).LongRule = ""
+DialingRule(31).InterRule = "00EFG"
+
+DialingRule(32).Code = 224
+DialingRule(32).Country = "Guinea"
+DialingRule(32).LocalRule = "G"
+DialingRule(32).LongRule = ""
+DialingRule(32).InterRule = "00EFG"
+
+DialingRule(33).Code = 225
+DialingRule(33).Country = "Ivory Coast"
+DialingRule(33).LocalRule = "G"
+DialingRule(33).LongRule = ""
+DialingRule(33).InterRule = "00EFG"
+
+DialingRule(34).Code = 226
+DialingRule(34).Country = "Burkina Faso"
+DialingRule(34).LocalRule = "G"
+DialingRule(34).LongRule = ""
+DialingRule(34).InterRule = "00EFG"
+
+DialingRule(35).Code = 227
+DialingRule(35).Country = "Niger"
+DialingRule(35).LocalRule = "G"
+DialingRule(35).LongRule = ""
+DialingRule(35).InterRule = "00EFG"
+
+DialingRule(36).Code = 228
+DialingRule(36).Country = "Togo"
+DialingRule(36).LocalRule = "G"
+DialingRule(36).LongRule = ""
+DialingRule(36).InterRule = "00EFG"
+
+DialingRule(37).Code = 229
+DialingRule(37).Country = "Benin"
+DialingRule(37).LocalRule = "G"
+DialingRule(37).LongRule = ""
+DialingRule(37).InterRule = "00EFG"
+
+DialingRule(38).Code = 230
+DialingRule(38).Country = "Mauritius"
+DialingRule(38).LocalRule = "G"
+DialingRule(38).LongRule = ""
+DialingRule(38).InterRule = "00EFG"
+
+DialingRule(39).Code = 231
+DialingRule(39).Country = "Liberia"
+DialingRule(39).LocalRule = "G"
+DialingRule(39).LongRule = ""
+DialingRule(39).InterRule = "0EFG"
+
+DialingRule(40).Code = 232
+DialingRule(40).Country = "Sierra Leone"
+DialingRule(40).LocalRule = "G"
+DialingRule(40).LongRule = "IG"
+DialingRule(40).InterRule = "00EFG"
+
+DialingRule(41).Code = 233
+DialingRule(41).Country = "Ghana"
+DialingRule(41).LocalRule = "G"
+DialingRule(41).LongRule = ""
+DialingRule(41).InterRule = "00EFG"
+
+DialingRule(42).Code = 234
+DialingRule(42).Country = "Nigeria"
+DialingRule(42).LocalRule = "G"
+DialingRule(42).LongRule = ""
+DialingRule(42).InterRule = "009EFG"
+
+DialingRule(43).Code = 235
+DialingRule(43).Country = "Chad"
+DialingRule(43).LocalRule = "G"
+DialingRule(43).LongRule = ""
+DialingRule(43).InterRule = "15EFG"
+
+DialingRule(44).Code = 236
+DialingRule(44).Country = "Central African Republic"
+DialingRule(44).LocalRule = "G"
+DialingRule(44).LongRule = ""
+DialingRule(44).InterRule = "19EFG"
+
+DialingRule(45).Code = 237
+DialingRule(45).Country = "Cameroon"
+DialingRule(45).LocalRule = "G"
+DialingRule(45).LongRule = ""
+DialingRule(45).InterRule = "00EFG"
+
+DialingRule(46).Code = 238
+DialingRule(46).Country = "Cape Verde Islands"
+DialingRule(46).LocalRule = "G"
+DialingRule(46).LongRule = ""
+DialingRule(46).InterRule = "0EFG"
+
+DialingRule(47).Code = 239
+DialingRule(47).Country = "Sao Tome and Principe"
+DialingRule(47).LocalRule = "G"
+DialingRule(47).LongRule = ""
+DialingRule(47).InterRule = "00EFG"
+
+DialingRule(48).Code = 240
+DialingRule(48).Country = "Equatorial Guinea"
+DialingRule(48).LocalRule = "G"
+DialingRule(48).LongRule = ""
+DialingRule(48).InterRule = "00EFG"
+
+DialingRule(49).Code = 241
+DialingRule(49).Country = "Gabon"
+DialingRule(49).LocalRule = "G"
+DialingRule(49).LongRule = ""
+DialingRule(49).InterRule = "00EFG"
+
+DialingRule(50).Code = 242
+DialingRule(50).Country = "Congo"
+DialingRule(50).LocalRule = "G"
+DialingRule(50).LongRule = ""
+DialingRule(50).InterRule = "00EFG"
+
+DialingRule(51).Code = 243
+DialingRule(51).Country = "Zaire"
+DialingRule(51).LocalRule = "G"
+DialingRule(51).LongRule = ""
+DialingRule(51).InterRule = "00EFG"
+
+DialingRule(52).Code = 244
+DialingRule(52).Country = "Angola"
+DialingRule(52).LocalRule = "G"
+DialingRule(52).LongRule = "0FG"
+DialingRule(52).InterRule = "00EFG"
+
+DialingRule(53).Code = 245
+DialingRule(53).Country = "Guinea-Bissau"
+DialingRule(53).LocalRule = "G"
+DialingRule(53).LongRule = ""
+DialingRule(53).InterRule = "099EFG"
+
+DialingRule(54).Code = 246
+DialingRule(54).Country = "Diego Garcia"
+DialingRule(54).LocalRule = "G"
+DialingRule(54).LongRule = ""
+DialingRule(54).InterRule = "00EFG"
+
+DialingRule(55).Code = 247
+DialingRule(55).Country = "Ascension Island"
+DialingRule(55).LocalRule = "G"
+DialingRule(55).LongRule = ""
+DialingRule(55).InterRule = "01EFG"
+
+DialingRule(56).Code = 248
+DialingRule(56).Country = "Seychelle Islands"
+DialingRule(56).LocalRule = "G"
+DialingRule(56).LongRule = ""
+DialingRule(56).InterRule = "00EFG"
+
+DialingRule(57).Code = 249
+DialingRule(57).Country = "Sudan"
+DialingRule(57).LocalRule = "G"
+DialingRule(57).LongRule = "0FG"
+DialingRule(57).InterRule = "00EFG"
+
+DialingRule(58).Code = 250
+DialingRule(58).Country = "Rwanda"
+DialingRule(58).LocalRule = "G"
+DialingRule(58).LongRule = ""
+DialingRule(58).InterRule = "00EFG"
+
+DialingRule(59).Code = 251
+DialingRule(59).Country = "Ethiopia"
+DialingRule(59).LocalRule = "G"
+DialingRule(59).LongRule = "0FG"
+DialingRule(59).InterRule = "00EFG"
+
+DialingRule(60).Code = 252
+DialingRule(60).Country = "Somalia"
+DialingRule(60).LocalRule = "G"
+DialingRule(60).LongRule = ""
+DialingRule(60).InterRule = "19,EFG"
+
+DialingRule(61).Code = 253
+DialingRule(61).Country = "Djibouti"
+DialingRule(61).LocalRule = "G"
+DialingRule(61).LongRule = ""
+DialingRule(61).InterRule = "00EFG"
+
+DialingRule(62).Code = 254
+DialingRule(62).Country = "Kenya"
+DialingRule(62).LocalRule = "G"
+DialingRule(62).LongRule = "0FG"
+DialingRule(62).InterRule = "000EFG"
+
+DialingRule(63).Code = 255
+DialingRule(63).Country = "Tanzania"
+DialingRule(63).LocalRule = "G"
+DialingRule(63).LongRule = ""
+DialingRule(63).InterRule = "0900EFG"
+
+DialingRule(64).Code = 256
+DialingRule(64).Country = "Uganda"
+DialingRule(64).LocalRule = "G"
+DialingRule(64).LongRule = "0FG"
+DialingRule(64).InterRule = "00EFG"
+
+DialingRule(65).Code = 257
+DialingRule(65).Country = "Burundi"
+DialingRule(65).LocalRule = "G"
+DialingRule(65).LongRule = ""
+DialingRule(65).InterRule = "90EFG"
+
+DialingRule(66).Code = 258
+DialingRule(66).Country = "Mozambique"
+DialingRule(66).LocalRule = "G"
+DialingRule(66).LongRule = ""
+DialingRule(66).InterRule = "00EFG"
+
+DialingRule(67).Code = 260
+DialingRule(67).Country = "Zambia"
+DialingRule(67).LocalRule = "G"
+DialingRule(67).LongRule = "0FG"
+DialingRule(67).InterRule = "00EFG"
+
+DialingRule(68).Code = 261
+DialingRule(68).Country = "Madagascar"
+DialingRule(68).LocalRule = "G"
+DialingRule(68).LongRule = ""
+DialingRule(68).InterRule = "16EFG"
+
+DialingRule(69).Code = 262
+DialingRule(69).Country = "Reunion Island"
+DialingRule(69).LocalRule = "G"
+DialingRule(69).LongRule = ""
+DialingRule(69).InterRule = "19EFG"
+
+DialingRule(70).Code = 263
+DialingRule(70).Country = "Zimbabwe"
+DialingRule(70).LocalRule = "G"
+DialingRule(70).LongRule = "1FG"
+DialingRule(70).InterRule = "110EFG"
+
+DialingRule(71).Code = 264
+DialingRule(71).Country = "Namibia"
+DialingRule(71).LocalRule = "G"
+DialingRule(71).LongRule = "0FG"
+DialingRule(71).InterRule = "09EFG"
+
+DialingRule(72).Code = 265
+DialingRule(72).Country = "Malawi"
+DialingRule(72).LocalRule = "G"
+DialingRule(72).LongRule = ""
+DialingRule(72).InterRule = "101EFG"
+
+DialingRule(73).Code = 266
+DialingRule(73).Country = "Lesotho"
+DialingRule(73).LocalRule = "G"
+DialingRule(73).LongRule = ""
+DialingRule(73).InterRule = "00EFG"
+
+DialingRule(74).Code = 267
+DialingRule(74).Country = "Botswana"
+DialingRule(74).LocalRule = "G"
+DialingRule(74).LongRule = "0FG"
+DialingRule(74).InterRule = "00EFG"
+
+DialingRule(75).Code = 268
+DialingRule(75).Country = "Swaziland"
+DialingRule(75).LocalRule = "G"
+DialingRule(75).LongRule = ""
+DialingRule(75).InterRule = "00EFG"
+
+DialingRule(76).Code = 269
+DialingRule(76).Country = "Mayotte Island"
+DialingRule(76).LocalRule = "G"
+DialingRule(76).LongRule = ""
+DialingRule(76).InterRule = "10EFG"
+
+DialingRule(77).Code = 269
+DialingRule(77).Country = "Comoros"
+DialingRule(77).LocalRule = "G"
+DialingRule(77).LongRule = ""
+DialingRule(77).InterRule = "10EFG"
+
+DialingRule(78).Code = 27
+DialingRule(78).Country = "South Africa"
+DialingRule(78).LocalRule = "G"
+DialingRule(78).LongRule = "0FG"
+DialingRule(78).InterRule = "09EFG"
+
+DialingRule(79).Code = 290
+DialingRule(79).Country = "St. Helena"
+DialingRule(79).LocalRule = "G"
+DialingRule(79).LongRule = ""
+DialingRule(79).InterRule = "01EFG"
+
+DialingRule(80).Code = 291
+DialingRule(80).Country = "Eritrea"
+DialingRule(80).LocalRule = "G"
+DialingRule(80).LongRule = "0FG"
+DialingRule(80).InterRule = "00EFG"
+
+DialingRule(81).Code = 297
+DialingRule(81).Country = "Aruba"
+DialingRule(81).LocalRule = "G"
+DialingRule(81).LongRule = ""
+DialingRule(81).InterRule = "00EFG"
+
+DialingRule(82).Code = 298
+DialingRule(82).Country = "Faeroe Islands"
+DialingRule(82).LocalRule = "G"
+DialingRule(82).LongRule = ""
+DialingRule(82).InterRule = "009EFG"
+
+DialingRule(83).Code = 299
+DialingRule(83).Country = "Greenland"
+DialingRule(83).LocalRule = "G"
+DialingRule(83).LongRule = ""
+DialingRule(83).InterRule = "009EFG"
+
+DialingRule(84).Code = 30
+DialingRule(84).Country = "Greece"
+DialingRule(84).LocalRule = "G"
+DialingRule(84).LongRule = "0FG"
+DialingRule(84).InterRule = "00EFG"
+
+DialingRule(85).Code = 31
+DialingRule(85).Country = "Netherlands"
+DialingRule(85).LocalRule = "G"
+DialingRule(85).LongRule = "0FG"
+DialingRule(85).InterRule = "00EFG"
+
+DialingRule(86).Code = 32
+DialingRule(86).Country = "Belgium"
+DialingRule(86).LocalRule = "G"
+DialingRule(86).LongRule = "0FG"
+DialingRule(86).InterRule = "00EFG"
+
+DialingRule(87).Code = 33
+DialingRule(87).Country = "France"
+DialingRule(87).LocalRule = "0FG"
+DialingRule(87).LongRule = "0FG"
+DialingRule(87).InterRule = "00EFG"
+
+DialingRule(88).Code = 377
+DialingRule(88).Country = "Monaco"
+DialingRule(88).LocalRule = "G"
+DialingRule(88).LongRule = ""
+DialingRule(88).InterRule = "00EFG"
+
+DialingRule(89).Code = 34
+DialingRule(89).Country = "Spain"
+DialingRule(89).LocalRule = "G"
+DialingRule(89).LongRule = "9FG"
+DialingRule(89).InterRule = "07,EFG"
+
+DialingRule(90).Code = 350
+DialingRule(90).Country = "Gibraltar"
+DialingRule(90).LocalRule = "G"
+DialingRule(90).LongRule = ""
+DialingRule(90).InterRule = "00EFG"
+
+DialingRule(91).Code = 351
+DialingRule(91).Country = "Portugal"
+DialingRule(91).LocalRule = "G"
+DialingRule(91).LongRule = "0FG"
+DialingRule(91).InterRule = "00EFG"
+
+DialingRule(92).Code = 352
+DialingRule(92).Country = "Luxembourg"
+DialingRule(92).LocalRule = "G"
+DialingRule(92).LongRule = ""
+DialingRule(92).InterRule = "00EFG"
+
+DialingRule(93).Code = 353
+DialingRule(93).Country = "Ireland"
+DialingRule(93).LocalRule = "G"
+DialingRule(93).LongRule = "0FG"
+DialingRule(93).InterRule = "00EFG"
+
+DialingRule(94).Code = 354
+DialingRule(94).Country = "Iceland"
+DialingRule(94).LocalRule = "G"
+DialingRule(94).LongRule = ""
+DialingRule(94).InterRule = "00EFG"
+
+DialingRule(95).Code = 355
+DialingRule(95).Country = "Albania"
+DialingRule(95).LocalRule = "G"
+DialingRule(95).LongRule = "0FG"
+DialingRule(95).InterRule = "00EFG"
+
+DialingRule(96).Code = 356
+DialingRule(96).Country = "Malta"
+DialingRule(96).LocalRule = "G"
+DialingRule(96).LongRule = ""
+DialingRule(96).InterRule = "00EFG"
+
+DialingRule(97).Code = 357
+DialingRule(97).Country = "Cyprus"
+DialingRule(97).LocalRule = "G"
+DialingRule(97).LongRule = "0FG"
+DialingRule(97).InterRule = "00EFG"
+
+DialingRule(98).Code = 358
+DialingRule(98).Country = "Finland"
+DialingRule(98).LocalRule = "G"
+DialingRule(98).LongRule = "0FG"
+DialingRule(98).InterRule = "00EFG"
+
+DialingRule(99).Code = 359
+DialingRule(99).Country = "Bulgaria"
+DialingRule(99).LocalRule = "G"
+DialingRule(99).LongRule = "0FG"
+DialingRule(99).InterRule = "00EFG"
+
+DialingRule(100).Code = 36
+DialingRule(100).Country = "Hungary"
+DialingRule(100).LocalRule = "G"
+DialingRule(100).LongRule = " 06,FG"
+DialingRule(100).InterRule = "00EFG"
+
+DialingRule(101).Code = 370
+DialingRule(101).Country = "Lithuania"
+DialingRule(101).LocalRule = "G"
+DialingRule(101).LongRule = " 8WFG"
+DialingRule(101).InterRule = "8W10EFG"
+
+DialingRule(102).Code = 371
+DialingRule(102).Country = "Latvia"
+DialingRule(102).LocalRule = "G"
+DialingRule(102).LongRule = " 8,IG"
+DialingRule(102).InterRule = "00EFG"
+
+DialingRule(103).Code = 372
+DialingRule(103).Country = "Estonia"
+DialingRule(103).LocalRule = "G"
+DialingRule(103).LongRule = " 8,2FG"
+DialingRule(103).InterRule = "8,00EFG"
+
+DialingRule(104).Code = 373
+DialingRule(104).Country = "Moldova"
+DialingRule(104).LocalRule = "G"
+DialingRule(104).LongRule = " 8WFG"
+DialingRule(104).InterRule = "8W10EFG"
+
+DialingRule(105).Code = 374
+DialingRule(105).Country = "Armenia"
+DialingRule(105).LocalRule = "G"
+DialingRule(105).LongRule = " 8,FG"
+DialingRule(105).InterRule = "8,10EFG"
+
+DialingRule(106).Code = 375
+DialingRule(106).Country = "Belarus"
+DialingRule(106).LocalRule = "G"
+DialingRule(106).LongRule = " 8WFG"
+DialingRule(106).InterRule = "8W10EFG"
+
+DialingRule(107).Code = 376
+DialingRule(107).Country = "Andorra"
+DialingRule(107).LocalRule = "G"
+DialingRule(107).LongRule = ""
+DialingRule(107).InterRule = "00EFG"
+
+DialingRule(108).Code = 378
+DialingRule(108).Country = "San Marino"
+DialingRule(108).LocalRule = "G"
+DialingRule(108).LongRule = "0IG"
+DialingRule(108).InterRule = "00EFG"
+
+DialingRule(109).Code = 39
+DialingRule(109).Country = "Vatican City"
+DialingRule(109).LocalRule = "G"
+DialingRule(109).LongRule = "0FG"
+DialingRule(109).InterRule = "00EFG"
+
+DialingRule(110).Code = 380
+DialingRule(110).Country = "Ukraine"
+DialingRule(110).LocalRule = "G"
+DialingRule(110).LongRule = " 8WFG"
+DialingRule(110).InterRule = "8W10EFG"
+
+DialingRule(111).Code = 381
+DialingRule(111).Country = "Yugoslavia"
+DialingRule(111).LocalRule = "G"
+DialingRule(111).LongRule = "0FG"
+DialingRule(111).InterRule = "99EFG"
+
+DialingRule(112).Code = 385
+DialingRule(112).Country = "Croatia"
+DialingRule(112).LocalRule = "G"
+DialingRule(112).LongRule = "0FG"
+DialingRule(112).InterRule = "00EFG"
+
+DialingRule(113).Code = 386
+DialingRule(113).Country = "Slovenia"
+DialingRule(113).LocalRule = "G"
+DialingRule(113).LongRule = "0FG"
+DialingRule(113).InterRule = "00EFG"
+
+DialingRule(114).Code = 387
+DialingRule(114).Country = "Bosnia and Herzegovina"
+DialingRule(114).LocalRule = "G"
+DialingRule(114).LongRule = "0FG"
+DialingRule(114).InterRule = "00EFG"
+
+DialingRule(115).Code = 389
+DialingRule(115).Country = "F.Y.R.O.M. (Former Yugoslav Republic of Macedonia)"
+DialingRule(115).LocalRule = "G"
+DialingRule(115).LongRule = "0FG"
+DialingRule(115).InterRule = "00EFG"
+
+DialingRule(116).Code = 39
+DialingRule(116).Country = "Italy"
+DialingRule(116).LocalRule = "G"
+DialingRule(116).LongRule = "0FG"
+DialingRule(116).InterRule = "00EFG"
+
+DialingRule(117).Code = 40
+DialingRule(117).Country = "Romania"
+DialingRule(117).LocalRule = "G"
+DialingRule(117).LongRule = " 0FG"
+DialingRule(117).InterRule = "00EFG"
+
+DialingRule(118).Code = 41
+DialingRule(118).Country = "Switzerland"
+DialingRule(118).LocalRule = "G"
+DialingRule(118).LongRule = "0FG"
+DialingRule(118).InterRule = "00EFG"
+
+DialingRule(119).Code = 41
+DialingRule(119).Country = "Liechtenstein"
+DialingRule(119).LocalRule = "G"
+DialingRule(119).LongRule = "0FG"
+DialingRule(119).InterRule = "00EFG"
+
+DialingRule(120).Code = 42
+DialingRule(120).Country = "Czech Republic"
+DialingRule(120).LocalRule = "G"
+DialingRule(120).LongRule = "0FG"
+DialingRule(120).InterRule = "00EFG"
+
+DialingRule(121).Code = 42
+DialingRule(121).Country = "Slovak Republic"
+DialingRule(121).LocalRule = "G"
+DialingRule(121).LongRule = "0FG"
+DialingRule(121).InterRule = "00EFG"
+
+DialingRule(122).Code = 43
+DialingRule(122).Country = "Austria"
+DialingRule(122).LocalRule = "G"
+DialingRule(122).LongRule = "0FG"
+DialingRule(122).InterRule = "00EFG"
+
+DialingRule(123).Code = 44
+DialingRule(123).Country = "United Kingdom"
+DialingRule(123).LocalRule = "G"
+DialingRule(123).LongRule = "0FG"
+DialingRule(123).InterRule = "00EFG"
+
+DialingRule(124).Code = 45
+DialingRule(124).Country = "Denmark"
+DialingRule(124).LocalRule = "G"
+DialingRule(124).LongRule = ""
+DialingRule(124).InterRule = "00EFG"
+
+DialingRule(125).Code = 46
+DialingRule(125).Country = "Sweden"
+DialingRule(125).LocalRule = "G"
+DialingRule(125).LongRule = "0FG"
+DialingRule(125).InterRule = "009EFG"
+
+DialingRule(126).Code = 47
+DialingRule(126).Country = "Norway"
+DialingRule(126).LocalRule = "G"
+DialingRule(126).LongRule = ""
+DialingRule(126).InterRule = "00EFG"
+
+DialingRule(127).Code = 48
+DialingRule(127).Country = "Poland"
+DialingRule(127).LocalRule = "G"
+DialingRule(127).LongRule = "0FG"
+DialingRule(127).InterRule = "00EFG"
+
+DialingRule(128).Code = 49
+DialingRule(128).Country = "Germany"
+DialingRule(128).LocalRule = "G"
+DialingRule(128).LongRule = "0FG"
+DialingRule(128).InterRule = "00EFG"
+
+DialingRule(129).Code = 500
+DialingRule(129).Country = "Falkland Islands"
+DialingRule(129).LocalRule = "G"
+DialingRule(129).LongRule = ""
+DialingRule(129).InterRule = "0EFG"
+
+DialingRule(130).Code = 501
+DialingRule(130).Country = "Belize"
+DialingRule(130).LocalRule = "G"
+DialingRule(130).LongRule = "0FG"
+DialingRule(130).InterRule = "00EFG"
+
+DialingRule(131).Code = 502
+DialingRule(131).Country = "Guatemala"
+DialingRule(131).LocalRule = "G"
+DialingRule(131).LongRule = "0IG"
+DialingRule(131).InterRule = "00EFG"
+
+DialingRule(132).Code = 503
+DialingRule(132).Country = "El Salvador"
+DialingRule(132).LocalRule = "G"
+DialingRule(132).LongRule = ""
+DialingRule(132).InterRule = "0EFG"
+
+DialingRule(133).Code = 504
+DialingRule(133).Country = "Honduras"
+DialingRule(133).LocalRule = "G"
+DialingRule(133).LongRule = ""
+DialingRule(133).InterRule = "00EFG"
+
+DialingRule(134).Code = 505
+DialingRule(134).Country = "Nicaragua"
+DialingRule(134).LocalRule = "G"
+DialingRule(134).LongRule = "0FG"
+DialingRule(134).InterRule = "00EFG"
+
+DialingRule(135).Code = 506
+DialingRule(135).Country = "Costa Rica"
+DialingRule(135).LocalRule = "G"
+DialingRule(135).LongRule = ""
+DialingRule(135).InterRule = "00EFG"
+
+DialingRule(136).Code = 507
+DialingRule(136).Country = "Panama"
+DialingRule(136).LocalRule = "G"
+DialingRule(136).LongRule = ""
+DialingRule(136).InterRule = "0EFG"
+
+DialingRule(137).Code = 508
+DialingRule(137).Country = "St. Pierre and Miquelon"
+DialingRule(137).LocalRule = "G"
+DialingRule(137).LongRule = ""
+DialingRule(137).InterRule = "19,EFG"
+
+DialingRule(138).Code = 509
+DialingRule(138).Country = "Haiti"
+DialingRule(138).LocalRule = "G"
+DialingRule(138).LongRule = ""
+DialingRule(138).InterRule = "00EFG"
+
+DialingRule(139).Code = 51
+DialingRule(139).Country = "Peru"
+DialingRule(139).LocalRule = "G"
+DialingRule(139).LongRule = "0FG"
+DialingRule(139).InterRule = "00EFG"
+
+DialingRule(140).Code = 52
+DialingRule(140).Country = "Mexico"
+DialingRule(140).LocalRule = "G"
+DialingRule(140).LongRule = " 91FG"
+DialingRule(140).InterRule = "98EFG"
+
+DialingRule(141).Code = 53
+DialingRule(141).Country = "Cuba"
+DialingRule(141).LocalRule = "G"
+DialingRule(141).LongRule = "0FG"
+DialingRule(141).InterRule = "119EFG"
+
+DialingRule(142).Code = 53
+DialingRule(142).Country = "Guantanamo Bay"
+DialingRule(142).LocalRule = "G"
+DialingRule(142).LongRule = "0FG"
+DialingRule(142).InterRule = "00EFG"
+
+DialingRule(143).Code = 54
+DialingRule(143).Country = "Argentina"
+DialingRule(143).LocalRule = "G"
+DialingRule(143).LongRule = "0FG"
+DialingRule(143).InterRule = "00EFG"
+
+DialingRule(144).Code = 55
+DialingRule(144).Country = "Brazil"
+DialingRule(144).LocalRule = "G"
+DialingRule(144).LongRule = "0FG"
+DialingRule(144).InterRule = "00EFG"
+
+DialingRule(145).Code = 56
+DialingRule(145).Country = "Chile"
+DialingRule(145).LocalRule = "G"
+DialingRule(145).LongRule = "0FG"
+DialingRule(145).InterRule = "00EFG"
+
+DialingRule(146).Code = 57
+DialingRule(146).Country = "Colombia"
+DialingRule(146).LocalRule = "G"
+DialingRule(146).LongRule = "0FG"
+DialingRule(146).InterRule = "00EFG"
+
+DialingRule(147).Code = 58
+DialingRule(147).Country = "Venezuela"
+DialingRule(147).LocalRule = "G"
+DialingRule(147).LongRule = "0FG"
+DialingRule(147).InterRule = "00EFG"
+
+DialingRule(148).Code = 590
+DialingRule(148).Country = "Guadeloupe"
+DialingRule(148).LocalRule = "G"
+DialingRule(148).LongRule = ""
+DialingRule(148).InterRule = "19,EFG"
+
+DialingRule(149).Code = 590
+DialingRule(149).Country = "French Antilles"
+DialingRule(149).LocalRule = "G"
+DialingRule(149).LongRule = ""
+DialingRule(149).InterRule = "19,EFG"
+
+DialingRule(150).Code = 591
+DialingRule(150).Country = "Bolivia"
+DialingRule(150).LocalRule = "G"
+DialingRule(150).LongRule = "0FG"
+DialingRule(150).InterRule = "00EFG"
+
+DialingRule(151).Code = 592
+DialingRule(151).Country = "Guyana"
+DialingRule(151).LocalRule = "G"
+DialingRule(151).LongRule = "0FG"
+DialingRule(151).InterRule = "001EFG"
+
+DialingRule(152).Code = 593
+DialingRule(152).Country = "Ecuador"
+DialingRule(152).LocalRule = "G"
+DialingRule(152).LongRule = "0FG"
+DialingRule(152).InterRule = "00EFG"
+
+DialingRule(153).Code = 594
+DialingRule(153).Country = "French Guiana"
+DialingRule(153).LocalRule = "G"
+DialingRule(153).LongRule = ""
+DialingRule(153).InterRule = "19,EFG"
+
+DialingRule(154).Code = 595
+DialingRule(154).Country = "Paraguay"
+DialingRule(154).LocalRule = "G"
+DialingRule(154).LongRule = "0FG"
+DialingRule(154).InterRule = "00EFG"
+
+DialingRule(155).Code = 596
+DialingRule(155).Country = "Martinique"
+DialingRule(155).LocalRule = "G"
+DialingRule(155).LongRule = ""
+DialingRule(155).InterRule = "19,EFG"
+
+DialingRule(156).Code = 597
+DialingRule(156).Country = "Suriname"
+DialingRule(156).LocalRule = "G"
+DialingRule(156).LongRule = ""
+DialingRule(156).InterRule = "00EFG"
+
+DialingRule(157).Code = 598
+DialingRule(157).Country = "Uruguay"
+DialingRule(157).LocalRule = "G"
+DialingRule(157).LongRule = "0FG"
+DialingRule(157).InterRule = "00EFG"
+
+DialingRule(158).Code = 599
+DialingRule(158).Country = "Netherlands Antilles"
+DialingRule(158).LocalRule = "G"
+DialingRule(158).LongRule = "0FG"
+DialingRule(158).InterRule = "00EFG"
+
+DialingRule(159).Code = 60
+DialingRule(159).Country = "Malaysia"
+DialingRule(159).LocalRule = "G"
+DialingRule(159).LongRule = "0FG"
+DialingRule(159).InterRule = "007EFG"
+
+DialingRule(160).Code = 61
+DialingRule(160).Country = "Australia"
+DialingRule(160).LocalRule = "G"
+DialingRule(160).LongRule = " 0FG"
+DialingRule(160).InterRule = "0011EFG"
+
+DialingRule(161).Code = 61
+DialingRule(161).Country = "Cocos-Keeling Islands"
+DialingRule(161).LocalRule = "G"
+DialingRule(161).LongRule = " 0FG"
+DialingRule(161).InterRule = "00EFG"
+
+DialingRule(162).Code = 62
+DialingRule(162).Country = "Indonesia"
+DialingRule(162).LocalRule = "G"
+DialingRule(162).LongRule = "0FG"
+DialingRule(162).InterRule = "001EFG"
+
+DialingRule(163).Code = 63
+DialingRule(163).Country = "Philippines"
+DialingRule(163).LocalRule = "G"
+DialingRule(163).LongRule = "0FG"
+DialingRule(163).InterRule = "00EFG"
+
+DialingRule(164).Code = 64
+DialingRule(164).Country = "New Zealand"
+DialingRule(164).LocalRule = "G"
+DialingRule(164).LongRule = "0FG"
+DialingRule(164).InterRule = "00EFG"
+
+DialingRule(165).Code = 65
+DialingRule(165).Country = "Singapore"
+DialingRule(165).LocalRule = "G"
+DialingRule(165).LongRule = ""
+DialingRule(165).InterRule = "001EFG"
+
+DialingRule(166).Code = 66
+DialingRule(166).Country = "Thailand"
+DialingRule(166).LocalRule = "G"
+DialingRule(166).LongRule = "0FG"
+DialingRule(166).InterRule = "001EFG"
+
+DialingRule(167).Code = 670
+DialingRule(167).Country = "Saipan Island"
+DialingRule(167).LocalRule = "G"
+DialingRule(167).LongRule = " 1FG"
+DialingRule(167).InterRule = "011EFG"
+
+DialingRule(168).Code = 670
+DialingRule(168).Country = "Rota Island"
+DialingRule(168).LocalRule = "G"
+DialingRule(168).LongRule = " 1FG"
+DialingRule(168).InterRule = "011EFG"
+
+DialingRule(169).Code = 670
+DialingRule(169).Country = "Tinian Island"
+DialingRule(169).LocalRule = "G"
+DialingRule(169).LongRule = " 1FG"
+DialingRule(169).InterRule = "011EFG"
+
+DialingRule(170).Code = 671
+DialingRule(170).Country = "Guam"
+DialingRule(170).LocalRule = "G"
+DialingRule(170).LongRule = ""
+DialingRule(170).InterRule = "011EFG"
+
+DialingRule(171).Code = 672
+DialingRule(171).Country = "Christmas Island"
+DialingRule(171).LocalRule = "G"
+DialingRule(171).LongRule = "0FG"
+DialingRule(171).InterRule = "00EFG"
+
+DialingRule(172).Code = 672
+DialingRule(172).Country = "Australian Antarctic Territory"
+DialingRule(172).LocalRule = "G"
+DialingRule(172).LongRule = "0FG"
+DialingRule(172).InterRule = "00EFG"
+
+DialingRule(173).Code = 672
+DialingRule(173).Country = "Norfolk Island"
+DialingRule(173).LocalRule = "G"
+DialingRule(173).LongRule = ""
+DialingRule(173).InterRule = "0101EFG"
+
+DialingRule(174).Code = 673
+DialingRule(174).Country = "Brunei"
+DialingRule(174).LocalRule = "G"
+DialingRule(174).LongRule = "0FG"
+DialingRule(174).InterRule = "00EFG"
+
+DialingRule(175).Code = 674
+DialingRule(175).Country = "Nauru"
+DialingRule(175).LocalRule = "G"
+DialingRule(175).LongRule = ""
+DialingRule(175).InterRule = "115EFG"
+
+DialingRule(176).Code = 675
+DialingRule(176).Country = "Papua New Guinea"
+DialingRule(176).LocalRule = "G"
+DialingRule(176).LongRule = ""
+DialingRule(176).InterRule = "05EFG"
+
+DialingRule(177).Code = 676
+DialingRule(177).Country = "Tonga"
+DialingRule(177).LocalRule = "G"
+DialingRule(177).LongRule = ""
+DialingRule(177).InterRule = "00EFG"
+
+DialingRule(178).Code = 677
+DialingRule(178).Country = "Solomon Islands"
+DialingRule(178).LocalRule = "G"
+DialingRule(178).LongRule = ""
+DialingRule(178).InterRule = "00EFG"
+
+DialingRule(179).Code = 678
+DialingRule(179).Country = "Vanuatu"
+DialingRule(179).LocalRule = "G"
+DialingRule(179).LongRule = ""
+DialingRule(179).InterRule = "00EFG"
+
+DialingRule(180).Code = 679
+DialingRule(180).Country = "Fiji Islands"
+DialingRule(180).LocalRule = "G"
+DialingRule(180).LongRule = ""
+DialingRule(180).InterRule = "05EFG"
+
+DialingRule(181).Code = 680
+DialingRule(181).Country = "Palau"
+DialingRule(181).LocalRule = "G"
+DialingRule(181).LongRule = ""
+DialingRule(181).InterRule = "00EFG"
+
+DialingRule(182).Code = 681
+DialingRule(182).Country = "Wallis and Futuna Islands"
+DialingRule(182).LocalRule = "G"
+DialingRule(182).LongRule = ""
+DialingRule(182).InterRule = "19,EFG"
+
+DialingRule(183).Code = 682
+DialingRule(183).Country = "Cook Islands"
+DialingRule(183).LocalRule = "G"
+DialingRule(183).LongRule = ""
+DialingRule(183).InterRule = "00EFG"
+
+DialingRule(184).Code = 683
+DialingRule(184).Country = "Niue"
+DialingRule(184).LocalRule = "G"
+DialingRule(184).LongRule = ""
+DialingRule(184).InterRule = "00EFG"
+
+DialingRule(185).Code = 684
+DialingRule(185).Country = "American Samoa"
+DialingRule(185).LocalRule = "G"
+DialingRule(185).LongRule = ""
+DialingRule(185).InterRule = "00EFG"
+
+DialingRule(186).Code = 685
+DialingRule(186).Country = "Western Samoa"
+DialingRule(186).LocalRule = "G"
+DialingRule(186).LongRule = ""
+DialingRule(186).InterRule = "0EFG"
+
+DialingRule(187).Code = 686
+DialingRule(187).Country = "Kiribati Republic"
+DialingRule(187).LocalRule = "G"
+DialingRule(187).LongRule = ""
+DialingRule(187).InterRule = "00EFG"
+
+DialingRule(188).Code = 687
+DialingRule(188).Country = "New Caledonia"
+DialingRule(188).LocalRule = "G"
+DialingRule(188).LongRule = ""
+DialingRule(188).InterRule = "00EFG"
+
+DialingRule(189).Code = 688
+DialingRule(189).Country = "Tuvalu"
+DialingRule(189).LocalRule = "G"
+DialingRule(189).LongRule = ""
+DialingRule(189).InterRule = "00EFG"
+
+DialingRule(190).Code = 689
+DialingRule(190).Country = "French Polynesia"
+DialingRule(190).LocalRule = "G"
+DialingRule(190).LongRule = ""
+DialingRule(190).InterRule = "00EFG"
+
+DialingRule(191).Code = 690
+DialingRule(191).Country = "Tokelau"
+DialingRule(191).LocalRule = "G"
+DialingRule(191).LongRule = ""
+DialingRule(191).InterRule = "00EFG"
+
+DialingRule(192).Code = 691
+DialingRule(192).Country = "Micronesia, Federated States of"
+DialingRule(192).LocalRule = "G"
+DialingRule(192).LongRule = ""
+DialingRule(192).InterRule = "011EFG"
+
+DialingRule(193).Code = 692
+DialingRule(193).Country = "Marshall Islands"
+DialingRule(193).LocalRule = "G"
+DialingRule(193).LongRule = "0FG"
+DialingRule(193).InterRule = "00EFG"
+
+DialingRule(194).Code = 7
+DialingRule(194).Country = "Russia"
+DialingRule(194).LocalRule = "G"
+DialingRule(194).LongRule = " 8WFG"
+DialingRule(194).InterRule = "8W10EFG"
+
+DialingRule(195).Code = 7
+DialingRule(195).Country = "Kazakhstan"
+DialingRule(195).LocalRule = "G"
+DialingRule(195).LongRule = " 8WFG"
+DialingRule(195).InterRule = "8W10EFG"
+
+DialingRule(196).Code = 7
+DialingRule(196).Country = "Kyrgyz Republic"
+DialingRule(196).LocalRule = "G"
+DialingRule(196).LongRule = " 8WFG"
+DialingRule(196).InterRule = "00EFG"
+
+DialingRule(197).Code = 7
+DialingRule(197).Country = "Tajikistan"
+DialingRule(197).LocalRule = "G"
+DialingRule(197).LongRule = " 8WFG"
+DialingRule(197).InterRule = "8W10EFG"
+
+DialingRule(198).Code = 7
+DialingRule(198).Country = "Turkmenistan"
+DialingRule(198).LocalRule = "G"
+DialingRule(198).LongRule = " 8WFG"
+DialingRule(198).InterRule = "8W10EFG"
+
+DialingRule(199).Code = 7
+DialingRule(199).Country = "Uzbekistan"
+DialingRule(199).LocalRule = "G"
+DialingRule(199).LongRule = " 8WFG"
+DialingRule(199).InterRule = "8W10EFG"
+
+DialingRule(200).Code = 800
+DialingRule(200).Country = "International Freephone Service"
+DialingRule(200).LocalRule = ""
+DialingRule(200).LongRule = ""
+DialingRule(200).InterRule = ""
+
+DialingRule(201).Code = 81
+DialingRule(201).Country = "Japan"
+DialingRule(201).LocalRule = "G"
+DialingRule(201).LongRule = "0FG"
+DialingRule(201).InterRule = "001EFG"
+
+DialingRule(202).Code = 82
+DialingRule(202).Country = "Korea (Republic of)"
+DialingRule(202).LocalRule = "G"
+DialingRule(202).LongRule = "0FG"
+DialingRule(202).InterRule = "001EFG"
+
+DialingRule(203).Code = 84
+DialingRule(203).Country = "Vietnam"
+DialingRule(203).LocalRule = "G"
+DialingRule(203).LongRule = "0FG"
+DialingRule(203).InterRule = "00EFG"
+
+DialingRule(204).Code = 850
+DialingRule(204).Country = "Korea (North)"
+DialingRule(204).LocalRule = "G"
+DialingRule(204).LongRule = ""
+DialingRule(204).InterRule = "00EFG"
+
+DialingRule(205).Code = 852
+DialingRule(205).Country = "Hong Kong"
+DialingRule(205).LocalRule = "G"
+DialingRule(205).LongRule = ""
+DialingRule(205).InterRule = "001EFG"
+
+DialingRule(206).Code = 853
+DialingRule(206).Country = "Macau"
+DialingRule(206).LocalRule = "G"
+DialingRule(206).LongRule = ""
+DialingRule(206).InterRule = "00EFG"
+
+DialingRule(207).Code = 855
+DialingRule(207).Country = "Cambodia"
+DialingRule(207).LocalRule = "G"
+DialingRule(207).LongRule = "0FG"
+DialingRule(207).InterRule = "00EFG"
+
+DialingRule(208).Code = 856
+DialingRule(208).Country = "Laos"
+DialingRule(208).LocalRule = "G"
+DialingRule(208).LongRule = ""
+DialingRule(208).InterRule = "14EFG"
+
+DialingRule(209).Code = 86
+DialingRule(209).Country = "China"
+DialingRule(209).LocalRule = "G"
+DialingRule(209).LongRule = "0FG"
+DialingRule(209).InterRule = "00EFG"
+
+DialingRule(210).Code = 870
+DialingRule(210).Country = "INMARSAT"
+DialingRule(210).LocalRule = "00EFG#"
+DialingRule(210).LongRule = "00EFG#"
+DialingRule(210).InterRule = "00EFG#"
+
+DialingRule(211).Code = 871
+DialingRule(211).Country = "INMARSAT (Atlantic-East)"
+DialingRule(211).LocalRule = "00EFG#"
+DialingRule(211).LongRule = "00EFG#"
+DialingRule(211).InterRule = "00EFG#"
+
+DialingRule(212).Code = 872
+DialingRule(212).Country = "INMARSAT (Pacific)"
+DialingRule(212).LocalRule = "00EFG#"
+DialingRule(212).LongRule = "00EFG#"
+DialingRule(212).InterRule = "00EFG#"
+
+DialingRule(213).Code = 873
+DialingRule(213).Country = "INMARSAT (Indian)"
+DialingRule(213).LocalRule = "00EFG#"
+DialingRule(213).LongRule = "00EFG#"
+DialingRule(213).InterRule = "00EFG#"
+
+DialingRule(214).Code = 874
+DialingRule(214).Country = "INMARSAT (Atlantic-West)"
+DialingRule(214).LocalRule = "00EFG#"
+DialingRule(214).LongRule = "00EFG#"
+DialingRule(214).InterRule = "00EFG#"
+
+DialingRule(215).Code = 880
+DialingRule(215).Country = "Bangladesh"
+DialingRule(215).LocalRule = "G"
+DialingRule(215).LongRule = "0FG"
+DialingRule(215).InterRule = "00EFG"
+
+DialingRule(216).Code = 886
+DialingRule(216).Country = "Taiwan, Republic of China"
+DialingRule(216).LocalRule = "G"
+DialingRule(216).LongRule = "0FG"
+DialingRule(216).InterRule = "002EFG"
+
+DialingRule(217).Code = 90
+DialingRule(217).Country = "Turkey"
+DialingRule(217).LocalRule = "G"
+DialingRule(217).LongRule = "0FG"
+DialingRule(217).InterRule = "00EFG"
+
+DialingRule(218).Code = 91
+DialingRule(218).Country = "India"
+DialingRule(218).LocalRule = "G"
+DialingRule(218).LongRule = "0FG"
+DialingRule(218).InterRule = "00EFG"
+
+DialingRule(219).Code = 92
+DialingRule(219).Country = "Pakistan"
+DialingRule(219).LocalRule = "G"
+DialingRule(219).LongRule = "0FG"
+DialingRule(219).InterRule = "00EFG"
+
+DialingRule(220).Code = 93
+DialingRule(220).Country = "Afghanistan"
+DialingRule(220).LocalRule = "G"
+DialingRule(220).LongRule = "0FG"
+DialingRule(220).InterRule = "00EFG"
+
+DialingRule(221).Code = 94
+DialingRule(221).Country = "Sri Lanka"
+DialingRule(221).LocalRule = "G"
+DialingRule(221).LongRule = "0FG"
+DialingRule(221).InterRule = "00EFG"
+
+DialingRule(222).Code = 95
+DialingRule(222).Country = "Myanmar"
+DialingRule(222).LocalRule = "G"
+DialingRule(222).LongRule = ""
+DialingRule(222).InterRule = "0EFG"
+
+DialingRule(223).Code = 960
+DialingRule(223).Country = "Maldives"
+DialingRule(223).LocalRule = "G"
+DialingRule(223).LongRule = ""
+DialingRule(223).InterRule = "00EFG"
+
+DialingRule(224).Code = 961
+DialingRule(224).Country = "Lebanon"
+DialingRule(224).LocalRule = "G"
+DialingRule(224).LongRule = "0FG"
+DialingRule(224).InterRule = "00EFG"
+
+DialingRule(225).Code = 962
+DialingRule(225).Country = "Jordan"
+DialingRule(225).LocalRule = "G"
+DialingRule(225).LongRule = "FG"
+DialingRule(225).InterRule = "00EFG"
+
+DialingRule(226).Code = 963
+DialingRule(226).Country = "Syria"
+DialingRule(226).LocalRule = "G"
+DialingRule(226).LongRule = "0FG"
+DialingRule(226).InterRule = "00EFG"
+
+DialingRule(227).Code = 964
+DialingRule(227).Country = "Iraq"
+DialingRule(227).LocalRule = "G"
+DialingRule(227).LongRule = "FG"
+DialingRule(227).InterRule = "00EFG"
+
+DialingRule(228).Code = 965
+DialingRule(228).Country = "Kuwait"
+DialingRule(228).LocalRule = "G"
+DialingRule(228).LongRule = ""
+DialingRule(228).InterRule = "00EFG"
+
+DialingRule(229).Code = 966
+DialingRule(229).Country = "Saudi Arabia"
+DialingRule(229).LocalRule = "G"
+DialingRule(229).LongRule = "0FG"
+DialingRule(229).InterRule = "00EFG"
+
+DialingRule(230).Code = 967
+DialingRule(230).Country = "Yemen"
+DialingRule(230).LocalRule = "G"
+DialingRule(230).LongRule = "0FG"
+DialingRule(230).InterRule = "00EFG"
+
+DialingRule(231).Code = 968
+DialingRule(231).Country = "Oman"
+DialingRule(231).LocalRule = "G"
+DialingRule(231).LongRule = ""
+DialingRule(231).InterRule = "00EFG"
+
+DialingRule(232).Code = 971
+DialingRule(232).Country = "United Arab Emirates"
+DialingRule(232).LocalRule = "G"
+DialingRule(232).LongRule = "0FG"
+DialingRule(232).InterRule = "00EFG"
+
+DialingRule(233).Code = 972
+DialingRule(233).Country = "Israel"
+DialingRule(233).LocalRule = "G"
+DialingRule(233).LongRule = "0FG"
+DialingRule(233).InterRule = "00EFG"
+
+DialingRule(234).Code = 973
+DialingRule(234).Country = "Bahrain"
+DialingRule(234).LocalRule = "G"
+DialingRule(234).LongRule = ""
+DialingRule(234).InterRule = "0EFG"
+
+DialingRule(235).Code = 974
+DialingRule(235).Country = "Qatar"
+DialingRule(235).LocalRule = "G"
+DialingRule(235).LongRule = ""
+DialingRule(235).InterRule = "0EFG"
+
+DialingRule(236).Code = 975
+DialingRule(236).Country = "Bhutan"
+DialingRule(236).LocalRule = "G"
+DialingRule(236).LongRule = ""
+DialingRule(236).InterRule = "00EFG"
+
+DialingRule(237).Code = 976
+DialingRule(237).Country = "Mongolia"
+DialingRule(237).LocalRule = "G"
+DialingRule(237).LongRule = "0FG"
+DialingRule(237).InterRule = "00EFG"
+
+DialingRule(238).Code = 977
+DialingRule(238).Country = "Nepal"
+DialingRule(238).LocalRule = "G"
+DialingRule(238).LongRule = ""
+DialingRule(238).InterRule = "00EFG"
+
+DialingRule(239).Code = 98
+DialingRule(239).Country = "Iran"
+DialingRule(239).LocalRule = "G"
+DialingRule(239).LongRule = "FG"
+DialingRule(239).InterRule = "00EFG"
+
+DialingRule(240).Code = 994
+DialingRule(240).Country = "Azerbaijan"
+DialingRule(240).LocalRule = "G"
+DialingRule(240).LongRule = " 8WFG"
+DialingRule(240).InterRule = "8W10EFG"
+
+DialingRule(241).Code = 995
+DialingRule(241).Country = "Georgia"
+DialingRule(241).LocalRule = "G"
+DialingRule(241).LongRule = " 8WFG"
+DialingRule(241).InterRule = "8W10EFG"
+
+'$ENDIF 'DIALRULE2_INC
diff --git a/private/tapi/qa/dialingp/dp32.inc b/private/tapi/qa/dialingp/dp32.inc
new file mode 100644
index 000000000..7b1b21d27
--- /dev/null
+++ b/private/tapi/qa/dialingp/dp32.inc
@@ -0,0 +1,4801 @@
+'******************************************************************************
+
+' DP32.inc												 
+' Created January 03, 1996
+' By Ron Rohr
+
+' This include file contains all the Functions and Constants used by the
+' DP32.MST test Script
+
+'******************************************************************************
+
+' Note: This file uses the Object Naming convention defined in the Visual Basic
+' 4.0 Programmers Guide to name variables and contants associated with a control.
+
+'$IFNDEF DP32_INC
+'$DEFINE DP32_INC
+ 
+'**************************** BEGIN CONSTANTS *********************************
+
+'$include 'DialRule.inc'
+
+'------------------------------------------------------------------------------
+' Section and Key constants of the dp32.ini file
+'------------------------------------------------------------------------------
+Const TEST_INI_FILE = "DP32.INI"
+Const Seclang		  = "Language"
+Const Secmenu	 	  = "Menu Strings"
+Const SecCaption	  = "Caption Strings"
+Const SecWinClass   = "Window Classes"
+Const SecLabels	  = "Dialing Properties Control Labels"
+
+Const KeyMFILE	   = "MFILE"
+Const KeyMEXIT		= "MEXIT"
+Const KeyMTOOLS	= "MTOOLS"
+Const KeyMDP		= "MDIAL_PROPERTIES"
+Const keyMOPTIONS = "MOPTIONS"
+Const keyMDEFAULT = "MDEFAULT"
+
+Const KeyPHONEDIALER  = "DIALER_CAPTION"
+Const KeyPROPERTIES   = "PROPERTIES_CAPTION"
+Const KeyConnectUse   = "CONNECT_USE_CAPTION"
+Const KeyWarning      = "WARNING_BOX_CAPTION"
+Const KeyLocInfo      = "LOCATION_CAPTION"
+Const KeyTB20		    = "TB20_CAPTION"
+Const KeyUTB		 	 = "USING_TB_CAPTION"
+Const KeyForSure      = "REALLY_CAPTION"
+Const KeyChangeCard   = "CHANGE_CARD_CAPTION"
+Const KeyNewCard		 = "NEW_CARD_CAPTION"
+Const KeyDefault		 = "DEFAULT_VALUES_CAPTION"
+Const KeyDialingR		 = "DIAL_RULE_CAPTION"
+Const KeyNoPIN			 = "NO_PIN_CAPTION"
+Const KeyPDCLASS      = "PHONE_DIALER_CLASS"
+Const KeyCopyRule		 = "COPY_RULE_CAPTION"
+Const KeyImproperRule = "IMPROPER_CHAR_CAPTION"
+
+Const KeyLANG         = "Language"
+Const KeyNEWBUTTON    = "cmd_NEW"
+Const KeyREMOVEBUTTON = "cmd_REMOVE"
+Const KeyCHANGEBUTTON = "cmd_CHANGE"
+Const KeyOKBUTTON     = "cmd_OK"
+Const KeyCANCELBUTTON = "cmd_Cancel"
+Const KeyAPPLYBUTTON  = "cmd_Apply"
+Const KeyLOCALTXT     = "txt_LOCAL"
+Const KeyLONGTXT      = "txt_LONGDIST"
+Const KeyAREACODETXT  = "txt_AREACODE"
+Const KeyTONEOPT      = "opt_TONE"
+Const KeyPULSEOPT     = "opt_PULSE"
+Const KeyCARDCHK		 = "chk_CARD"
+Const KeyWAITCHK		 = "chk_WAITING"
+Const KeyFROMSTR		 = "cbo_DIALINGFROM"
+Const KeyIAMINSTR		 = "cbo_IAMIN"
+Const KeyACCESSLABLE	 = "lable_ACCESS"
+Const KeyOPTLABLE		 = "lable_OPT_BTN"
+Const KeyWHERELABLE	 = "lable_FRM_WHERE"
+Const KeyHOWLABLE		 = "lable_FRM_HOW"
+Const KeyNONELABLE	 = "lable_DIR_DIAL"
+Const KeyLOCATIONTAB  = "tab_MY_LOCATION"
+Const KeyTELDRVTAB	 = "tab_TEL_DRV"
+
+Const lable_FRM_WHERE = "Where I am:"
+
+' End Section and Key constants of the dp32.ini file
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin Constant definitions used with child control handle arrays 
+' (array element enumerations)
+
+Const DP_OKcmd		 = 0
+Const DP_CANCELcmd = 1
+Const DP_APPLYcmd	 = 2
+
+Const NEW_cmd      = 0
+Const REMOVE_cmd   = 1
+Const CHANGE_cmd   = 2
+Const LOCATION_cbo = 3
+Const COUNTRY_cbo  = 4
+Const AREA_txt     = 5
+Const LOCAL_txt    = 6
+Const LONG_txt     = 7
+Const CARD_chk     = 8
+Const WAIT_chk     = 9
+Const WaitStr_cbo	 = 10
+Const TONE_opt     = 11
+Const PULSE_opt    = 12
+Const ADDRESS_lbl	 = 13
+Const NUMBER_lbl	 = 14
+Const DIAL_AS_chk	 = 15
+
+Const TD_ADDcmd		=0
+Const TD_REMOVEcmd	=1
+Const TD_SETUPcmd		=2
+Const TD_DRIVERlst	=3
+
+Const CARD_OKcmd		= 0
+Const CARD_CANCELcmd	= 1
+Const CARD_NAMEcbo	= 2
+Const CARD_NUMBERtxt	= 3
+Const CARD_NEWcmd		= 4
+Const Card_RULEScmd	= 5
+Const CARD_REMOVEcmd	= 6
+
+Const NEW_OKcmd		= 0
+Const NEW_CANCELcmd	= 1
+Const NEW_NAMETXT		= 2
+
+Const Rule_CLOSEcmd  = 0
+Const Rule_COPYcmd   = 1
+Const Rule_LOCALtxt  = 2
+Const Rule_LONGtxt   = 3
+Const Rule_INTERtxt  = 4
+
+' End Constant definitions used with MY_hCtrl and TD_hCtrl arrays
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin Registry Editor Constant definitions (used with SetLocationsZero)
+
+Const REGEDIT_CAPTION = "Registry Editor"
+Const REGEDIT_CLASS   = "RegEdit_RegEdit"
+Const REG_lOC_PATH    = "My Computer\HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Telephony\locations"
+
+' End Registry Editor Constant definitions
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Other Constant definitions 
+
+Const NEW_LOCATION = "New Location"
+
+' End Other Constant definitions 
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin VerifyCallingCard Constant definitions 
+
+Const TAPI_BROWSER			= "\TB20.exe"
+Const lineTranDlg_API		= "lineTranslateDialog"
+
+' End VerifyCallingCard Constant definitions 
+'------------------------------------------------------------------------------
+'------------------------------------------------------------------------------
+' Begin Type declarations
+
+Type Location
+	Location		as string
+	AreaCode		as string
+	Country		as string
+	LocalAccess as string
+	LongAccess	as string
+	CardSet		as short
+	WaitSet		as short
+	ToneSet		as short
+	PulseSet		as short
+end type
+
+' End Type declarations
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' Begin Global declarations and definitions
+ 
+   Global WTIMEOUT AS LONG           'Timeout value for WFndWnd
+	Global teststring as CaseStruct   ' Holds test case info for logging by logcase routine
+	Global w_flags as long            'used with WFndWnd function
+
+   w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'FW_PART OR 
+
+
+' End Global declarations and definitions
+'------------------------------------------------------------------------------
+
+'------------------------------------------------------------------------------
+' DP32.ini
+' The following variables are use to save strings from DP32.INI
+'------------------------------------------------------------------------------
+
+   global Language as string
+' Menu Strings Variables
+
+   global MFILE as string
+   global MExit as string
+   global MTOOLS as string
+   global MDIAL_PROPERTIES as string
+	global MOPTIONS as string
+	global MDEFAULT as string
+
+' Caption Strings Variables
+
+   global DIALER_CAPTION       as string
+   global PROPERTIES_CAPTION   as string
+   global LOC_INFO_CAPTION     as string
+   global CONNECT_USE_CAPTION  as string 
+	global WARN_BOX_CAPTION     as string
+	global TAPI_BROWSER_CAPTION as string
+	global USING_TB_CAPTION		 as string
+	global REALLY_CAPTION		 as string
+	global CHANGE_CARD_CAPTION  as string
+	global NEW_CARD_CAPTION		  as string
+	global DEFAULT_VALUES_CAPTION as string
+	global DIAL_RULE_CAPTION	  as string
+	global NO_PIN_CAPTION		 as string
+	global COPY_RULE_CAPTION	 as string
+ 	global IMPROPER_CHAR_CAPTION as string
+
+' Window Classes Strings Variables
+
+   global DIALOG_CLASS as string
+
+ 'Dialing Properties Control Labels Strings Variables
+
+   global cmd_NEW    as string
+   global cmd_REMOVE as string
+   global cmd_CHANGE as string
+   global cmd_OK     as string
+   global cmd_CANCEL as string
+   global cmd_APPLY  as string
+
+   global txt_LOCAL    as string
+   global txt_LONGDIST as string
+   global txt_AREACODE as string
+
+   global cbo_DIALINGFROM as string
+   global cbo_IAMIN as string
+   
+	global chk_CARD as string
+   global chk_WAIT as string
+
+	global opt_TONE as string
+	global opt_PULSE as string
+
+	global lbl_ACCESS as string
+	global lbl_OPT_BTN as string
+	global lbl_FRM_WHERE as string
+	global lbl_FRM_HOW as string 
+	global lbl_DIR_DIAL as string
+   global tab_MY_LOCATION as string
+   global tab_TEL_DRV as string
+
+
+ ' End of strings from DP32.INI variables
+'------------------------------------------------------------------------------
+
+
+'*********************** PROCEDURE DECLARATIONS (In order of appearence) ******
+
+Declare Sub		  BoundsChkHandler (vtNotifyData as variant)
+Declare Sub		  SetWndTimeout ()
+Declare Function Start_App () as long
+Declare Function Call_Dialing_Prop (hTabCtrl as long, hMLTab as long, hTDTab as long) as long
+
+Declare Sub      GetLangStr ()
+Declare Function GetStringandValidate (Section as string * 35, KeyName as string, _ 
+												   Default as string * 20, FileNameINI as string * 128) as string
+Declare Sub      SetDefaultLabels ()
+Declare Sub		  Validate_Strings (hTab as long, hChild() as long)
+Declare Sub		  GetDPCtrlh (hDProp as long, Prop_hChild() as long, _
+									  Prop_ChildID() as long)
+Declare Sub	 	  GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+Declare Sub      AddLocations (Prop_hChild() as long, ML_hChild() as long, _
+										 FirstLoc as location, Eastside as location, Cork as location)
+Declare Sub		  FindNewLocMessage ()
+Declare Sub		  ModifyLocation (Prop_hChild() as long, ML_hChild() as long, ChangeLoc as location)
+Declare Sub		  VerifyModifyLoc (ML_hChild() as long, ChangeLoc as location, hDP_OKcmd as long)
+Declare Sub   	  VerifyCallWaiting (Prop_ChildID() as long, ML_ChildID() as long, TestLoc as location)
+Declare Sub   	  DefaultCallingCard	(CallingCard() as CardData, Prop_ChildID() as long, ML_ChildID() as long)
+Declare Sub   	  VerifyCallingCard	(Prop_ChildID() as long, ML_ChildID() as long)
+Declare Function SetLocationsZero () as short
+Declare Sub		  EditLocationInfo (NewLocal as location, hML_Child() as long)
+Declare Sub		  SetLocationInfo (FirstLoc as Location) 
+Declare Sub		  VerifyCurrentLoc (ML_hChild() as long, Default as location)
+Declare Sub		  CountryDialRules (DialingRule() as CountryRule, Prop_ChildID() as long, _
+											  ML_ChildID() as long)
+Declare Function RemoveLocation (Prop_hChild() as long, ML_hChild() as long, _
+					  CmdButton as short) as string
+Declare Sub		  VerifyRemoveLoc (ML_hChild() as long, LocString as string)
+Declare Sub		  FindRemLocMessage (RemoveState as short)
+Declare Sub      SetCallingCardChildID (Card_ChildID() as long, NEW_ChildID() as long, _ 
+								               Rule_ChildID() as long, DV_OKcmd as long, _
+								               DV_list as long, DV_edit as long, TAPI_API_List as long)
+Declare Function CreateDestAddress (Rule as string, phone as TelephoneNo ) as string
+Declare Function ConvertRule (Rule as string) as string
+
+Declare Function lTranslateDialog ( hMLTab as long, hTB20 as long) as long
+
+'*********************** BEGIN PROCEDURES *************************************
+
+'*****************************************************************************
+'Name   : BoundsChkHandler
+'Desc   : This routine is called whenever BoundsChecker uncovers a failure.
+'		    The failure is then written ton the log and reports to the user via
+'			 a message box. 
+'			 The routine is called with the On BoundsCheckerNotify (NULL) Call
+'			 BoundsChkHandler statement in DP32.mst.
+'
+'Parms  : None. 
+'
+'Return : None. Writes failure data directly to  the log.
+'
+'History: 02/26/96 : a-rrohr: Created
+'*****************************************************************************
+sub BoundsChkHandler (vtNotifyData as variant)
+
+dim ErrorMessage as string, SizeofString as long, count as short, lastchar as short
+
+ErrorMessage = "Unexpected BoundsChecker error in Dialing Properties Test"  + CRLF
+
+' Since the size of the string BoundsChecker returns is unknown the routine must be
+' capable of formatting a large string into a paragraph whose lines are not greater
+' than 72 characters.
+
+While (len(vtNotifyData) >= 72)
+	SizeofString = len(vtNotifyData)
+	count = 1
+	do
+		lastchar = count
+		count = instr(lastchar + 1,vtNotifyData, " ")
+	' instr(lastchar + 1,vtNotifyData, " ") will return zero on the last word of
+	' the string so break the do loop when count = 0
+	loop while count < 72 and count <> 0
+
+	ErrorMessage = ErrorMessage + rtrim$(left$(vtNotifyData, lastchar)) + CRLF
+	vtNotifyData = right$(vtNotifyData, (SizeofString - lastchar))
+Wend
+
+If (len(vtNotifyData) >= 1) then 
+		ErrorMessage = ErrorMessage + vtNotifyData + CRLF
+end if
+
+
+'$IFDEF DEBUG_TEST_SCRIPT
+if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+   resume next
+else
+   Stop
+endif
+'$ENDIF 'DEBUG_TEST_SCRIPT
+
+end sub 'BoundsChkHandler
+'******************************************************************************
+
+'******************************************************************************
+'Name   : SetWndTimeout
+'Desc   : Sets the timeout variable used by the WFndWnd function.
+'			 Some of the platforms tested on are very slow and if the timeout isn't
+'			 long enough then	the test continues with out finding the Window and its
+'			 handle, dooming all subsequent test (that are dependent on this handle)
+'			 to complete and utter failure.
+' 
+'Parms  :
+'
+'Return : None. Sets the Global String variables WTIMEOUT
+'
+'History: 02/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+ Sub SetWndTimeout ()
+
+ dim tempstring as string									' Generic string variable
+
+ tempstring = space(40)
+ tempstring = environ$("PROCESSOR_ARCHITECTURE")
+
+ select case tempstring
+
+	case "x86"
+		WTIMEOUT = 5		' Dog
+	case "Alpha"
+		WTIMEOUT = 10		' Old Dog
+	case "MIPS"
+		WTIMEOUT = 20		' Comatose Dog
+	case "PPC"
+		WTIMEOUT = 30		' Road Kill
+	case else
+		WTIMEOUT = 30		' IBM PS/2
+	   logitem (CurrentLoggingLevel, "Unable to set WTIMEOUT: Unknown Processor Architecture")
+	   logitem (CurrentLoggingLevel, "Processor Architecture	environment variable = " +  tempstring)
+end select
+
+'$IFDEF DEBUG_TEST_SCRIPT
+		WTIMEOUT = WTIMEOUT + 5 'If using BoundsChecker then add a few more seconds
+'$ENDIF
+
+end Sub  'SetWndTimeout ()
+
+'*****************************************************************************
+'Name   : GetLangStr
+'Desc   : Gets the language strings from DP32.ini and save them in global
+'         variables or If DP32.ini file doesnt exist it gets default srtings.
+'			 Also Runtime arguments COMMAND$ and TESTMODE$.
+'			 COMMAND$ is the path to the DP32.ini file
+'         TESTMODE$ is the name of the Results file
+' 
+'Parms  : None. This function uses the language string file (DP32.ini) Constant
+'               and the command line variable, command$, that has the path to the
+'               language string file
+'
+'Return : None. Sets the Global String variables defined in section DP32.ini
+'
+'History: 01/13/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub GetLangStr ()
+
+ dim szSection      as String *35
+ dim szDefault      as String *20
+ dim szDestBuffer   as String *64
+ dim BufferSize     as long
+ dim szFileNameINI  as String *128
+
+ DIM TEMPSTRING AS STRING
+ dim rtn as long
+
+ TotalTestCases = TotalTestCases + 1
+
+ TEMPSTRING = COMMAND$ 
+ if exists(TEMPSTRING) then   'IF THE LANGUAGE STRING FILE EXISTS THEN
+'  ************************** COMMON STRINGS *******************
+	szFileNameINI = TempString 
+   szDefault = "A" 
+
+'  Get Language Section Strings
+
+   szSection = SecLang '+ string$(len(szSection) - len(SecLang), 0)
+
+   Language = GetStringandValidate ((szSection), (KeyLang), (szDefault), (szFileNameINI))
+
+
+'  Get Menu Section Strings
+
+   szSection = Secmenu + string$(1, 0)
+
+   MFILE = GetStringandValidate (szSection, KEYMFILE, szDefault, szFileNameINI)
+
+   MExit = GetStringandValidate (szSection, KEYMEXIT, szDefault, szFileNameINI)
+
+   MTOOLS = GetStringandValidate (szSection, KeyMTOOLS, szDefault, szFileNameINI)
+
+   MDIAL_PROPERTIES = GetStringandValidate (szSection, KeyMDP, szDefault, szFileNameINI)
+
+	MOPTIONS = GetStringandValidate (szSection, keyMOPTIONS, szDefault, szFileNameINI)
+
+	MDEFAULT = GetStringandValidate (szSection, keyMDEFAULT, szDefault, szFileNameINI)
+
+'  Get Caption Section Strings
+
+   szSection = SecCaption + string$(1, 0)
+
+   DIALER_CAPTION = GetStringandValidate (szSection, KeyPHONEDIALER, szDefault, szFileNameINI)
+
+   LOC_INFO_CAPTION = GetStringandValidate (szSection, KeyLocInfo, szDefault, szFileNameINI)
+
+   PROPERTIES_CAPTION = GetStringandValidate (szSection, KeyPROPERTIES, szDefault, szFileNameINI)
+ 
+   CONNECT_USE_CAPTION = GetStringandValidate (szSection, KeyConnectUse, szDefault, szFileNameINI)
+ 
+   WARN_BOX_CAPTION = GetStringandValidate (szSection, KeyWarning, szDefault, szFileNameINI)
+
+	TAPI_BROWSER_CAPTION = GetStringandValidate (szSection, KeyTB20, szDefault, szFileNameINI)
+	
+	USING_TB_CAPTION	= GetStringandValidate (szSection, KeyUTB, szDefault, szFileNameINI)
+
+	REALLY_CAPTION  = GetStringandValidate (szSection, KeyForSure, szDefault, szFileNameINI)
+ 
+	CHANGE_CARD_CAPTION = GetStringandValidate (szSection, KeyChangeCard, szDefault, szFileNameINI)
+
+	NEW_CARD_CAPTION = GetStringandValidate (szSection, KeyNewCard, szDefault, szFileNameINI)
+
+	DEFAULT_VALUES_CAPTION = GetStringandValidate (szSection, KeyDefault, szDefault, szFileNameINI)
+
+	DIAL_RULE_CAPTION = GetStringandValidate (szSection, KeyDialingR, szDefault, szFileNameINI)
+	
+	NO_PIN_CAPTION = GetStringandValidate (szSection, KeyNoPIN, szDefault, szFileNameINI)
+
+	COPY_RULE_CAPTION	= GetStringandValidate (szSection, KeyCopyRule, szDefault, szFileNameINI)
+
+	IMPROPER_CHAR_CAPTION =  GetStringandValidate (szSection, KeyImproperRule, szDefault, szFileNameINI)
+	
+'  Get Window Class Section Strings
+
+   szSection = SecWinClass + string$(1, 0)
+
+   DIALOG_CLASS = GetStringandValidate (szSection, KeyPDClass, szDefault, szFileNameINI)
+
+'  Get Control label Strings
+
+  szSection = SecLabels + string$(1, 0)
+
+  chk_CARD  = GetStringandValidate (szSection, KeyCARDCHK, szDefault, szFileNameINI)
+
+  chk_WAIT  = GetStringandValidate (szSection, KeyWAITCHK, szDefault, szFileNameINI)
+
+  opt_TONE  = GetStringandValidate (szSection, KeyTONEOPT, szDefault, szFileNameINI)
+
+  opt_PULSE  = GetStringandValidate (szSection, KeyPULSEOPT, szDefault, szFileNameINI)
+	
+  cmd_OK   = GetStringandValidate (szSection, KeyOKBUTTON, szDefault, szFileNameINI)   
+
+  cmd_CANCEL = GetStringandValidate (szSection, KeyCANCELBUTTON, szDefault, szFileNameINI) 
+
+  cmd_APPLY  = GetStringandValidate (szSection, KeyAPPLYBUTTON, szDefault, szFileNameINI) 
+
+  cmd_NEW = GetStringandValidate (szSection, KeyNEWBUTTON, szDefault, szFileNameINI)
+
+  cmd_REMOVE = GetStringandValidate (szSection, KeyREMOVEBUTTON, szDefault, szFileNameINI)
+
+  cmd_CHANGE = GetStringandValidate (szSection, KeyCHANGEBUTTON, szDefault, szFileNameINI)
+
+  txt_LOCAL = GetStringandValidate (szSection, KeyLOCALTXT, szDefault, szFileNameINI)
+
+  txt_LONGDIST = GetStringandValidate (szSection, KeyLONGTXT, szDefault, szFileNameINI)
+
+  txt_AREACODE = GetStringandValidate (szSection, KeyAREACODETXT, szDefault, szFileNameINI)
+
+  cbo_DIALINGFROM = GetStringandValidate (szSection, KeyFROMSTR, szDefault, szFileNameINI)
+
+  cbo_IAMIN = GetStringandValidate (szSection, KeyIAMINSTR, szDefault, szFileNameINI)
+
+  lbl_ACCESS = GetStringandValidate (szSection, KeyACCESSLABLE, szDefault, szFileNameINI)
+
+  lbl_OPT_BTN = GetStringandValidate (szSection, KeyOPTLABLE, szDefault, szFileNameINI)
+
+  lbl_FRM_WHERE = GetStringandValidate (szSection, KeyWHERELABLE, szDefault, szFileNameINI)
+
+  lbl_FRM_HOW = GetStringandValidate (szSection, KeyHOWLABLE, szDefault, szFileNameINI)
+ 
+  lbl_DIR_DIAL = GetStringandValidate (szSection, KeyNONELABLE, szDefault, szFileNameINI)
+
+  tab_MY_LOCATION = GetStringandValidate (szSection, KeyLOCATIONTAB, szDefault, szFileNameINI)
+
+  tab_TEL_DRV = GetStringandValidate (szSection, KeyTELDRVTAB, szDefault, szFileNameINI)
+
+ else    'IF THE LANGUAGE STRING FILE DOESN'T EXIST THEN USE DEFAULTS
+
+   SetDefaultLabels
+   teststring.TC_Num =  35
+   teststring.Expect_Res = TEST_INI_FILE + " Does Exist"
+   teststring.Actual_Res = TEST_INI_FILE + " Doesn't Exist"
+   teststring.Apprase    = "FAIL *"
+   FailedTestCases = FailedTestCases + 1
+   LogCase (teststring)
+
+ end if
+
+end sub
+
+'*****************************************************************************
+'Name   : GetStringandValidate
+'Desc   : Uses the GetPrivateProfileString to obtain test strings from the
+'         DP32.INI file. Verifies that a Null or default string was not returned.
+'
+'Parms  : Section: zero terminated string containing Section Name,
+'         Key: zero terminated string containing Key Name,
+'         Default: zero terminated string containing Default string,
+'         DestBuffer: Buffer for retrieved string,
+'         FileNameINI: zero terminated string containing INI File Name
+'
+'Return : None. Sets the Global String variables defined in section DP32.ini
+'
+'History: 01/13/96 : a-rrohr: Created
+'*****************************************************************************
+
+function GetStringandValidate (Section as string * 35, KeyName as string, _
+										 Default as string * 20, FileNameINI as string * 128) as string
+   dim rtn as long
+   dim teststring as casestruct
+   dim Key as string * 30
+	dim DestBuffer as string
+
+   Key = KeyName + string$(len(Key) - len(KeyName), 0)
+   DestBuffer = string$(64, 0)
+
+   rtn = GetPrivateProfileString(Section, Key, Default, DestBuffer, _
+                               len(DestBuffer), FileNameINI)
+
+   teststring.TC_Num =  35
+   teststring.Expect_Res = Key + "label"
+   teststring.Actual_Res = DestBuffer
+
+   if (rtn = 0) or (DestBuffer ="") then
+      teststring.Apprase    = "FAIL *"
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+      GetStringandValidate = DestBuffer
+   endif
+
+'print "Section "; section
+'print "KeyName ="; KeyName
+'print "Default ="; Default
+'print "FileNameINI ="; FileNameINI
+'print "DestBuffer ="; DestBuffer
+
+
+End function
+
+'*****************************************************************************
+'Name   : SetDefaultLabels
+'Desc   : Sets the language string variables to default US English strings
+'
+'Parms  : None. This function uses the language string file (DP32.ini) Constant
+'               and the command line variable, command$, that has the path to the
+'               language string file
+'
+'Return : None. Sets the Global String variables defined in section DP32.ini
+'
+'History: 01/13/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub SetDefaultLabels ()
+
+   Language= "USA_ENG"
+
+   MFILE = "&File"
+   MExit = "E&xit"
+   MTOOLS = "&Tools"
+   MDIAL_PROPERTIES = "&Dialing Properties..."
+	MOPTIONS = "&Options"
+	MDEFAULT = "&Default values..."
+
+   DIALER_CAPTION			= "Phone Dialer"
+   LOC_INFO_CAPTION     = "Location Information"
+   CONNECT_USE_CAPTION  = "Connect Using" 
+	WARN_BOX_CAPTION     = "Warning"
+	PROPERTIES_CAPTION   = "Dialing Properties"
+   TAPI_BROWSER_CAPTION	= "TAPI32 Browser"
+	USING_TB_CAPTION		= "Using the TAPI Browser"
+	REALLY_CAPTION			= "Are You Sure?"
+	CHANGE_CARD_CAPTION	= "Change Calling Card"
+	NEW_CARD_CAPTION		= "Create New Calling Card"
+	DIALOG_CLASS			 = "#32770"
+	DEFAULT_VALUES_CAPTION = "Default values"
+ 	DIAL_RULE_CAPTION		 = "Dialing Rules" 	
+	NO_PIN_CAPTION			= "Required Entry Not Made"
+	COPY_RULE_CAPTION    = "Copy Dialing Rules"
+	IMPROPER_CHAR_CAPTION = "Improper Character Entered"
+
+   cmd_NEW    = "&New..."
+   cmd_REMOVE = "&Remove"
+	cmd_CHANGE = "C&hange..."
+	cmd_OK     = "OK"
+	cmd_Cancel = "Cancel"
+	cmd_Apply  = "&Apply"
+
+	txt_LOCAL       = "for local,"
+	txt_LONGDIST    = "for long distance."
+   txt_AREACODE    = "The area &code is:"
+   cbo_DIALINGFROM = "I am &dialing from:"
+   cbo_IAMIN       = "&I am in:"
+	opt_TONE        = "&Tone dialing"
+	opt_PULSE       = "&Pulse dialing"
+	chk_CARD        = "Dial &using Calling Card:"
+	chk_WAIT        = "This location has call &waiting. To disable it, dial:"
+	lbl_ACCESS      = "To access an &outside line, first dial:"
+	lbl_OPT_BTN     = "The phone system at this location uses:"
+	lbl_FRM_WHERE   = "Where I am:"
+	lbl_FRM_HOW     = "How I dial from this location:"
+   lbl_DIR_DIAL	 = "None (Direct Dial)"
+	tab_MY_LOCATION = "My Locations"
+   tab_TEL_DRV     = "Telephony Drivers"
+
+End Sub 'SetDefaultLabels
+
+'*****************************************************************************
+
+'*****************************************************************************
+'Name   : Start_App
+'Desc   : Invokes Phone Dialer Application.
+'
+'Parms  : None. This function uses the Const that contains the Phone Dialer
+'               application name
+'
+'Return : Returns the Handle to the Phone Dialer
+'
+'History: 01/12/96 : a-rrohr: Created
+'*****************************************************************************
+
+Function Start_App () as long
+
+   dim handle as long, hctrl as long
+   dim teststring as casestruct
+   dim txtAreaCodeID as integer, txtAccessCodeID as integer, Failcount as short
+   dim StaticID as long
+   dim messagestr as string
+
+   txtAreaCodeID = &h0000040E
+   txtAccessCodeID = &h0000040C
+
+   teststring.TC_Num =  33
+
+'$ifdef NUMEGA
+  run TEST_APP, BoundsChecker
+'$else
+  run TEST_APP, nowait
+'$endif 'NUMEGA
+
+  handle = 0
+' look for the Location Information window and if it exists enter default location
+
+    
+	'$ifdef WIN95
+
+		handle =  WFndWndC (LOC_INFO_CAPTION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+
+		if handle <> 0 then
+			TotalTestCases = TotalTestCases + 1
+
+			WSetActWnd handle
+			hctrl = GetDlgItem (handle, txtAreaCodeID)
+			if hctrl <> 0 then
+				WEditSetText  _hwnd(hctrl), "333"
+			else
+				failcount = failcount + 1
+			end if
+			hctrl = GetDlgItem (handle, txtAccessCodeID)
+	      if hctrl <> 0 then
+		      WEditSetText  _hwnd(hctrl), "7"
+			else
+				failcount = failcount + 1
+			end if
+			if failcount > 0 then
+				teststring.Expect_Res = "Accessible Window Controls"
+				teststring.Actual_Res = "dialog Controls Inoperative" + Str$(handle)
+				teststring.Apprase    = "FAIL *"
+				LogCase (teststring)
+				FailedTestCases = FailedTestCases + 1
+			end if
+			WButtonClick cmd_OK
+		end if
+	
+	'$elseifdef NT	OR PROCESSOR_MIPS OR PROCESSOR_ALPHA OR PROCESSOR_POWERPC
+ 	
+		handle = WFndWndC (WARN_BOX_CAPTION, DIALOG_CLASS, w_flags, Wtimeout)
+
+		if handle <> 0 then
+  			TotalTestCases = TotalTestCases + 1
+			teststring.Expect_Res = "Enabled Telephone Device"
+			teststring.Actual_Res = "No Telephone Device Enabled" 
+			teststring.Apprase    = "FAIL *"
+			LogCase (teststring)
+			FailedTestCases = FailedTestCases + 1
+			StaticID = &h0000FFFF&
+								  
+			hCtrl = GetDlgItem (handle, StaticID)
+			IF hCtrl <> 0 then
+				messagestr = StaticText (_hwnd(hCtrl), TIMEOUT)
+				logitem (CurrentLoggingLevel, messagestr)
+				WButtonClick (cmd_OK)
+			endif
+		endif
+
+
+		handle = WFndWndC (CONNECT_USE_CAPTION, DIALOG_CLASS, w_flags, wtimeout)
+		if handle <> 0 then
+			WButtonClick (cmd_OK)
+		endif
+
+	 '$endif
+
+ 	'$ifdef WIN95
+ 		handle =  WFndWndC (DIALER_CAPTION, "DialerClass", w_flags, WTIMEOUT)
+  '$elseifdef NT	OR PROCESSOR_MIPS OR PROCESSOR_ALPHA OR PROCESSOR_POWERPC
+		handle =  WFndWndC (DIALER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+ 	 '$endif
+  TotalTestCases = TotalTestCases + 1
+
+   teststring.Expect_Res = "Valid Phone Dialer Handle"
+   teststring.Actual_Res = "Phone Dialer Handle =" + Str$(handle)
+
+   if handle = 0 then
+      teststring.Apprase    = "FAIL *"
+      LogCase (teststring)
+      FailedTestCases = FailedTestCases + 1
+      stop
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+   Start_App = handle
+
+end function 'Start_App
+
+'*****************************************************************************
+'Name   : SetLocationInfo
+'Desc   : Sets the Data in the Location Information window
+'			 SetLocationsZero is called to set Telephony Register Location 
+'			 NumEntries to zero inorder to force the Location Information window 
+'			 to appear. 
+'
+'Parms  : FirstLoc Location structure containing the default location info.
+'
+'Return : None
+'
+'History: 02/16/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub SetLocationInfo (FirstLoc as Location) 
+
+   dim handle as long				'Generic window handle
+   dim hctrl as long					'Generic Handle to Control
+   dim teststring as casestruct	'Test Log Info
+   dim SysDirPath as string		'Path to system32 directory
+   dim rtn as long					'Generic return variable
+   dim failcount as short
+   dim StaticID as long
+   dim messagestr as string
+   dim txtAreaCodeID as integer, txtAccessCodeID as integer 
+	dim cboCountryID as integer, optPulseID as integer, cmdCloseID as integer
+
+	txtAreaCodeID   = &h0000040E	   'Location Information dialog
+   txtAccessCodeID = &h0000040C		'Control IDs
+   cboCountryID	 = &h0000040F
+	optPulseID      = &h000017A2
+	cmdCloseID      = &h00000001
+
+	SysDirPath = space$(168)
+	rtn = GetSystemDirectory (SysDirPath, 168)
+
+if SetLocationsZero()  then
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", nowait
+'$endif 'NUMEGA
+
+'Test for the existance of the Location Information Window
+'Note: This window appears only once when telepony.cpl is invoked and no
+'      locations have been set. The window can be forced to appear if the
+'	    NumEntries in the Registry editor is set to 0 (done in SetLocationsZero)
+'      path = HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Telephony\Locations
+
+ 	handle =  WFndWndC (LOC_INFO_CAPTION, DIALOG_CLASS, w_Flags, WTIMEOUT)
+
+	if handle <> 0 then
+		TotalTestCases = TotalTestCases + 1
+	
+		WSetActWnd (handle)
+		
+		hctrl = GetDlgItem (handle, cboCountryID)
+		if hctrl <> 0 then
+			WComboItemClk (_hwnd(hctrl), FirstLoc.COUNTRY)
+		else
+			failcount = failcount + 1
+		end if
+		sleep 1
+		hctrl = GetDlgItem (handle, txtAreaCodeID)
+		if hctrl <> 0 then
+			WEditSetText  (_hwnd(hctrl), FirstLoc.AreaCode)
+		else
+			failcount = failcount + 1
+		end if
+		sleep 1
+		hctrl = GetDlgItem (handle, txtAccessCodeID)
+	     if hctrl <> 0 then
+	      WEditSetText  (_hwnd(hctrl), FirstLoc.LocalAccess)
+		else
+			failcount = failcount + 1
+		end if
+		sleep 1
+		hctrl = GetDlgItem (handle, optPulseID)
+	     if hctrl <> 0 then
+	      if WOptionState(_hwnd(hctrl), TIMEOUT) = FALSE THEN
+				WOptionClick(_hwnd(hctrl), TIMEOUT)
+			endif
+		else
+			failcount = failcount + 1
+		end if
+		
+		sleep 1
+		
+		if failcount > 0 then
+			teststring.Expect_Res = "Accessible Window Controls"
+			teststring.Actual_Res = "dialog Controls Inoperative" + Str$(handle)
+			teststring.Apprase    = "FAIL *"
+			LogCase (teststring)
+			FailedTestCases = FailedTestCases + 1
+		end if
+		hctrl = GetDlgItem (handle, cmdCloseID)
+		WButtonClick (_hwnd(hctrl))
+
+	   sleep 1
+	end if ' handle
+else
+	logitem (CurrentLoggingLevel, "Problem accessing Telephony Registry Info")
+	logitem (CurrentLoggingLevel, "Test Will Terminate")
+	Stop
+endif 'SetLocationsZero
+
+' End Test for the existance of the Location Information Window
+
+
+End Sub ' SetLocationInfo
+
+'*****************************************************************************
+'Name   : Call_Dialing_Prop
+'Desc   : Invokes the Dialing Properties window and returns the handle to the
+'         Dialing Properties dialog, the SysTabControl32, the My Location Tab, 
+'			 and the Telephony Drivers Tab. 
+'
+'Parms  : Passed 3 variables to store the handles to the Tab Control, 
+'			 My Location Tab and the Telephony Drivers Tab
+'
+'Return : Returns the Handle to the Dialing Properties dialog
+'
+'History: 01/12/96: a-rrohr: Created
+'Modified 02/16/96: a-rrohr: deleted the Location Information code 
+'									  (now in subroutine SetLocationInfo)
+'*****************************************************************************
+
+Function Call_Dialing_Prop (hTabCtrl as long, hMLTab as long, hTDTab as long) as long
+
+   dim handle as long				'Generic window handle
+   dim hdialog as long				'Handle of Dialing Properties dialog, function rtns this value
+   dim hctrl as long					'Generic Handle to Control
+   dim teststring as casestruct	'Test Log Info
+   dim SysDirPath as string		'Path to system32 directory
+   dim rtn as long					'Generic return variable
+   dim SysTabCtrlID as integer	'ID of SysTabCtrl32 control
+   dim OK_cmdID as long				'ID of Dialing Properties OK button
+   dim failcount as short
+   dim StaticID as long
+   dim messagestr as string
+
+   SysTabCtrlID = &h03020&
+	OK_cmdID		 = &h0001&
+
+	SysDirPath = space$(168)
+	rtn = GetSystemDirectory (SysDirPath, 168)
+
+' If a pre-existing instance of dialing properties exists close it with an OK button click
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+	if hdialog <> 0 then
+		hctrl = GetDlgItem (hdialog, OK_cmdID)
+		WButtonClick (_hwnd(hctrl))				'Click the Dialing Properties OK button
+		sleep 1
+	end if
+
+' Invoke Dialing Properties
+
+'$ifdef NUMEGA
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", BoundsChecker
+'$else
+	run "control.exe " + SysDirPath + "\TELEPHON.CPL", nowait
+'$endif 'NUMEGA
+
+' Get and validate Dialing Properties window handle
+
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  34
+   teststring.Expect_Res = "Valid Properties Handle"
+   teststring.Actual_Res = "Properties Handle =" + Str$(hdialog)
+
+   if hdialog = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+   WSetWndPos  (hdialog, 1, 1)
+   Call_Dialing_Prop =  hdialog
+
+' End - Get and validate Dialing Properties window handle
+' Get and validate SysTabControl32 handle
+
+	hTabCtrl = GetDlgItem (hdialog, SysTabCtrlID)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  34
+   teststring.Expect_Res = "Valid SysTab Control Handle"
+   teststring.Actual_Res = "Sys Tab Handle =" + Str$(hTabCtrl)
+
+   if hTabCtrl = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+' End - Get and validate SysTabControl32 handle
+' Get and validate My Location Tab handle
+
+	hMLTab  =  WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  34
+   teststring.Expect_Res = "Valid My Location Handle"
+   teststring.Actual_Res = "Tab Handle =" + Str$(hMLTab)
+
+   if hMLTab = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+' End Get and validate My Location Tab handle
+' Get and validate Telephony Drivers Tab handle
+
+' Make the SysTabControl32 the active window and 
+' Send a right arrow key to the Tab to put the focus on the Telephony Tab
+
+	WSetActWnd (hTabCtrl)
+'	play hTabCtrl, "^({Tab})" 
+	play hTabCtrl, "{RIGHT}" 
+
+	hTDTab=  WFndWndC (tab_TEL_DRV, DIALOG_CLASS, W_Flags, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  34
+   teststring.Expect_Res = "Valid Telephony Drv Handle"
+   teststring.Actual_Res = "Tab Handle =" + Str$(hTDTab)
+
+   if hTDTab = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+	WSetActWnd (hTabCtrl)
+	play hTabCtrl, "{LEFT}" 
+
+	WSetActWnd (hdialog)
+
+end function
+
+'*****************************************************************************
+'Name   : SetLocationsZero 
+'Desc   : Calls the Registry editor and sets Telephony locations 
+'			 NumEntries value equal to zero 
+'         
+'Parms  : None 
+'			 
+'Return : TRUE if successful in setting NumEntries equal to zero, 
+'			 otherwise false
+'
+'History: 02/14/96 : a-rrohr: Created
+'*****************************************************************************
+
+Function SetLocationsZero () as short
+
+dim handle as long, hTree as long, hList as long		'handles for regedit
+dim hdialog as long, hEdit as long, hOKcmd as long		'handles for Edit dialog
+dim treepath as string
+dim Windowpath as string
+dim rtn as long
+dim Value_txtID as long, OK_cmdID as long					'Edit dialog control IDs
+
+Value_txtID = &h03E9&
+OK_cmdID =&h0001&
+
+WindowPath = space$(64)
+GetWindowsDirectory (WindowPath, len(WindowPath))
+
+Run (WindowPath + "\Regedit.exe"), NOWAIT
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, WTIMEOUT)
+
+if handle = 0 then
+	SetLocationsZero = FALSE
+   logitem (CurrentLoggingLevel, "Invailid handle to Registry Editor")
+	goto End_Of_Sub 
+end if
+
+hTree = GetDlgItem (handle, &h00000001)
+if hTree = 0 then
+	SetLocationsZero = FALSE
+   logitem (CurrentLoggingLevel, "Invailid handle to Registry Editor Tree")
+	goto End_Of_Sub 
+end if
+
+hList = GetDlgItem (handle, &h00000002)
+if hList = 0 then
+	SetLocationsZero = FALSE
+   logitem (CurrentLoggingLevel, "Invailid handle to Registry Editor List")
+	goto End_Of_Sub 
+end if
+
+WTreeItemExpand (_hwnd(hTree), REG_lOC_PATH, TIMEOUT)
+WTreeItemClk (_hwnd(hTree), REG_lOC_PATH, VK_LBUTTON, TIMEOUT)
+sleep 1
+
+' The first time dialing properties is invoked the NumEntries dword may not exist.
+if WViewItemExists (_hwnd(hList), "NumEntries", TIMEOUT)	then
+	WViewItemDblClk (_hwnd(hList), "NumEntries", VK_LBUTTON, TIMEOUT)
+else
+	goto DONE
+endif
+
+hDialog = WFndWndC ("Edit DWORD Value", DIALOG_CLASS , w_flags, WTIMEOUT)
+if hDialog = 0 then
+	SetLocationsZero = FALSE
+   logitem (CurrentLoggingLevel, "Invailid handle to Edit dialog")
+	goto End_Of_Sub 
+end if
+
+hEdit = GetDlgItem (hDialog, Value_txtID) 
+if hEdit = 0 then
+	SetLocationsZero = FALSE
+   logitem (CurrentLoggingLevel, "Invailid handle to Edit dialog Value data edit box")
+	goto End_Of_Sub 
+end if
+
+hOKcmd = GetDlgItem (hDialog, OK_cmdID)
+if hOKcmd = 0 then
+	SetLocationsZero = FALSE
+   logitem (CurrentLoggingLevel, "Invailid handle to Edit dialog OK button")
+	goto End_Of_Sub 
+end if
+
+WeditSetText (_hwnd(hEdit), "0", Timeout)
+sleep 2
+WButtonClick (_hwnd(hOKcmd), Timeout)
+
+DONE:' if numentries doesn't exist then jump here
+
+handle = WFndWndC (REGEDIT_CAPTION, REGEDIT_CLASS , w_flags, WTIMEOUT)
+if handle <> 0 then
+	SetLocationsZero = TRUE
+else
+	SetLocationsZero = FALSE
+endif
+
+WSetActWnd (handle)
+WMenuSelect ("&Registry\E&xit", TIMEOUT)
+
+End_Of_Sub:  'line lable
+
+end Sub 'SetLocationsZero
+ 
+'*****************************************************************************
+'Name   : GetDPCtrlh
+'Desc   : Get the handles to the dialing properties OK, Cancel and Apply 
+'			 command buttons
+'         
+'Parms  : hDProp			handle to the dialing properties window
+' 			 hctrlOK			assigned handle to OK button
+'			 hctrlCancel	assigned handle to Cancel button
+'			 hctlApply		assigned handle to Apply button
+'
+'Return : None. Handles are assigned to the above referenced parameters
+'
+'History: 02/07/96: a-rrohr: Created
+'Modified 02/16/96: handles are now saved in an array of handles 
+'*****************************************************************************
+sub GetDPCtrlh (hDProp as long, Prop_hChild() as long, Prop_ChildID() as long)
+
+Prop_hChild(DP_OKcmd)     = GetDlgItem (hDProp, Prop_ChildID(DP_OKcmd))
+Prop_hChild(DP_CANCELcmd) = GetDlgItem (hDProp, Prop_ChildID(DP_CANCELcmd))
+Prop_hChild(DP_APPLYcmd)  = GetDlgItem (hDProp, Prop_ChildID(DP_APPLYcmd))
+
+end sub
+
+'*****************************************************************************
+'Name   : Validate_Strings
+'Desc   : Verifies the strings in the Dialing Properties dialog and fills the 
+'			 hCtrl array with the handles to the child controls of the Tab window
+'         
+'Parms  : hTab = handle to My Location Tab
+'			 hCtrl = array of My Location child control handles.  
+'
+'Return : Void:
+'			 Subroutine fills in the hCtrl array
+'
+'History: 02/01/96 : a-rrohr: Created
+'*****************************************************************************
+sub Validate_Strings (hTab as long, hChild() as long)
+
+dim numchar as long		'Generic long return variable
+dim rtn as short			'Generic short return variable
+dim lable as string		'Generic string return variable
+dim hCtrl as long			'Generic control handle
+teststring.TC_Num =  46
+
+' ******************* Verify Strings of Dialing Properties ********************
+' TO BE ADDED
+' ******************* End Verify Strings of Dialing Properties ****************
+
+' ******************* Verify Strings of My location Tab ***********************
+
+IF hTab <> 0 then
+
+'Get "Where am I"	lable
+
+	teststring.Expect_Res =  lbl_FRM_WHERE
+	TotalTestCases = TotalTestCases + 1
+	lable = string$(64, str$(0))
+	Numchar = GetDlgItemText (hTab, &h0000FFFF&, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = lbl_FRM_WHERE THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Get "How I dial ..." lable
+
+	teststring.Expect_Res =  lbl_FRM_HOW
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h00000001, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = lbl_FRM_HOW THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Get "To access an outside ..." lable
+
+	teststring.Expect_Res =  lbl_ACCESS
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h00001395, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = lbl_ACCESS THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Get "The Phone system ..." lable
+
+	teststring.Expect_Res =  lbl_OPT_BTN
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h000017A4, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = lbl_OPT_BTN THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Get "None (Direct Dial)" lable
+
+	teststring.Expect_Res =  lbl_DIR_DIAL
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h00001391, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = lbl_DIR_DIAL THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Get "Dialing From" combo box lable
+
+	teststring.Expect_Res =  cbo_DIALINGFROM
+	TotalTestCases = TotalTestCases + 1
+	hCtrl = GetDlgItem (hTab, &h00001392)
+		IF hCtrl <> 0 then
+			lable = StaticText (_hwnd(hCtrl), TIMEOUT)
+			teststring.Actual_Res = lable 
+			IF lable = cbo_DIALINGFROM THEN
+				teststring.Apprase    = "Pass"
+				LogCase (teststring)
+			else
+				teststring.Apprase    = "FAIL *"
+				FailedTestCases = FailedTestCases + 1
+				LogCase (teststring)
+			endif
+		endif
+	
+'Get "I am in" combo box lable
+
+	teststring.Expect_Res =  cbo_IAMIN
+	TotalTestCases = TotalTestCases + 1
+	hCtrl = GetDlgItem (hTab, &h00001394)
+		IF hCtrl <> 0 then
+			lable = StaticText (_hwnd(hCtrl), TIMEOUT)
+			teststring.Actual_Res = lable 
+			IF	lable = cbo_IAMIN THEN
+				teststring.Apprase    = "Pass"
+				LogCase (teststring)
+			else
+				teststring.Apprase    = "FAIL *"
+				FailedTestCases = FailedTestCases + 1
+				LogCase (teststring)
+			endif
+		endif
+
+'Get "The area code ..." edit box lable
+
+	teststring.Expect_Res =  txt_AREACODE
+	TotalTestCases = TotalTestCases + 1
+	hCtrl = GetDlgItem (hTab, &h00001393)
+		IF hCtrl <> 0 then
+			lable = StaticText (_hwnd(hCtrl), TIMEOUT)
+			teststring.Actual_Res = lable 
+			IF lable = txt_AREACODE THEN
+				teststring.Apprase    = "Pass"
+				LogCase (teststring)
+			else
+				teststring.Apprase    = "FAIL *"
+				FailedTestCases = FailedTestCases + 1
+				LogCase (teststring)
+			endif
+		endif
+
+'Get "for local" edit box lable
+
+	teststring.Expect_Res =  txt_LOCAL
+	TotalTestCases = TotalTestCases + 1
+	hCtrl = GetDlgItem (hTab, &h00001396)
+		IF hCtrl <> 0 then
+			lable = StaticText (_hwnd(hCtrl), TIMEOUT)
+			teststring.Actual_Res = lable 
+			IF lable = txt_LOCAL THEN
+				teststring.Apprase    = "Pass"
+				LogCase (teststring)
+			else
+				teststring.Apprase    = "FAIL *"
+				FailedTestCases = FailedTestCases + 1
+				LogCase (teststring)
+			endif
+		endif
+
+'Get "for long dist" edit box lable
+
+	teststring.Expect_Res =  txt_LONGDIST
+	TotalTestCases = TotalTestCases + 1
+	hCtrl = GetDlgItem (hTab, &h00001397)
+		IF hCtrl <> 0 then
+			lable = StaticText (_hwnd(hCtrl), TIMEOUT)
+			teststring.Actual_Res = lable 
+			IF lable = txt_LONGDIST THEN
+				teststring.Apprase    = "Pass"
+				LogCase (teststring)
+			else
+				teststring.Apprase    = "FAIL *"
+				FailedTestCases = FailedTestCases + 1
+				LogCase (teststring)
+			endif
+		endif
+
+'Verify "New" command button lable
+
+	teststring.Expect_Res =  cmd_NEW
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h00001389, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = cmd_NEW THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+  'Verify "Remove" command button lable
+
+   teststring.Expect_Res =  cmd_REMOVE
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h0000138B, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = cmd_REMOVE THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+  'Verify "Change" command button lable
+
+   teststring.Expect_Res =  cmd_CHANGE
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h0000138C, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = cmd_CHANGE THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+ 'Verify "Tone" option button lable
+
+   teststring.Expect_Res =  opt_TONE
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h000017A3, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = opt_TONE THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+ 'Verify "Pulse" option button lable
+
+   teststring.Expect_Res =  opt_PULSE
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h000017A2, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = opt_PULSE THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+   teststring.Expect_Res =  chk_CARD
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h0000138D, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = chk_CARD THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+   teststring.Expect_Res =  chk_WAIT
+	lable = string$(64, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	Numchar = GetDlgItemText (hTab, &h0000138E, lable, 63)
+	teststring.Actual_Res = lable 
+		IF lable = chk_WAIT THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+end if 'hTab
+' **************** End Verify Strings of My location Tab **********************
+
+' **************** Verify Strings of Telephony Drivers Tab ********************
+'	TO BE ADDED
+' **************** End Verify Strings of Telephony Drivers Tab ****************
+    
+end sub 'Validate_Strings
+
+'*************************************************************************************
+
+
+'*****************************************************************************
+'Name   : GetChildhandles 
+'Desc   : Fills the hChild array with the handles to the child controls of hParent 
+'         
+'Parms  : hTab = handle to My Location Tab
+'			 hChild = array of My Location child control handles.  
+'			 ChildID = array of child control IDs
+' 
+'Return : Void:   Subroutine fills in the hChild array parameter
+'
+'History: 02/10/96 : a-rrohr: Created
+'*****************************************************************************
+sub GetChildhandles (hParent as long, hChild() as long, ChildID() as long)
+
+dim count	  as short
+dim beginning as short
+dim ending    as short
+
+beginning = lbound(hChild)
+ending    = ubound(hChild)
+
+for count = beginning to ending
+	hChild(count) = GetDlgItem (hParent, ChildID(count))
+next	
+end sub
+'*************************************************************************************
+
+'*****************************************************************************
+'Name   : AddLocations 
+'Desc   : Verifies Default location information and creates several new 
+'			 locations. This routine requires that the My Location property page 
+'			 is displayed.
+'         
+'Parms  : ML_hChild: array holding the handles to the My Location controls 
+'			 The 2 locations to be added.
+'			 
+'Return : None
+'
+'History: 02/14/96 : a-rrohr: Created
+'*****************************************************************************
+sub AddLocations (Prop_hChild() as long, ML_hChild() as long, FirstLoc as location, _ 
+						Eastside as location, Cork as location)
+
+dim CurrentLoc as string
+dim CurrentArea as string
+dim CurrentCountry as string
+dim CurrentAccess as string
+dim item as long
+teststring.TC_Num =  41
+
+'Verify Default Location Information = Info as set in Location Information window
+
+VerifyCurrentLoc (ML_hChild, FirstLoc)
+
+' Add 2 new locations, Redmond & Cork
+
+WButtonClick (_hwnd(ML_hChild(New_cmd)))
+FindNewLocMessage()								'close New location message box
+
+' The 'I am dialing from:' combobox should have the focus
+
+	teststring.Expect_Res = "Location Combo has Focus"
+	TotalTestCases = TotalTestCases + 1
+		
+		IF WComboFocus (_hwnd(ML_hChild(Location_cbo))) THEN
+			teststring.Actual_Res = "True" 
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Actual_Res = "False" 
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+EditLocationInfo (Eastside, ML_hChild)		'enter Redmond location info
+
+WButtonClick (_hwnd(ML_hChild(New_cmd)))
+FindNewLocMessage()								'close New location message box
+
+' The 'I am dialing from:' combobox should have the focus
+
+	teststring.Expect_Res = "Location Combo has Focus"
+	TotalTestCases = TotalTestCases + 1
+		
+		IF WComboFocus (_hwnd(ML_hChild(Location_cbo))) THEN
+			teststring.Actual_Res = "True" 
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Actual_Res = "False" 
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+' The 'I am dialing from:' combobox should read New Location
+
+	teststring.Expect_Res =  NEW_LOCATION
+	TotalTestCases = TotalTestCases + 1
+	
+	CurrentLoc = string$(64, str$(0))
+	item = WComboIndex (_hwnd(ML_hChild( LOCATION_cbo )), TIMEOUT)
+	CurrentLoc = ComboItemText (_hwnd ( ML_hChild( LOCATION_cbo )), Item, TIMEOUT)
+	teststring.Actual_Res = CurrentLoc 
+	
+'Test for the existance New Location in current location String. The location string
+'has a counter that is incremented every time a new location is created.
+
+		IF instr(1, CurrentLoc, NEW_LOCATION) > 0 THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+
+EditLocationInfo (Cork, ML_hChild)		'enter Ireland location Info
+
+' Close Dialing Properties dialog
+
+WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)))
+
+end sub 'AddLocations
+
+'*****************************************************************************
+'Name   : FindNewLocMessage
+'
+'Desc   : As of build 1261 clicking the New button to create a New location
+'			 opens a message box telling the user that he clicked the New button
+'			 This function detects the message box and closes it with 
+'			 the appropriate button.
+'			 Can't blame the developer as this fixes a "bug" in Raid.
+'			 
+'Parms  : None
+'			 
+'Return : None
+'
+'History: 03/06/96 : a-rrohr: Created
+'*****************************************************************************
+sub FindNewLocMessage ()
+
+	dim w_flags as long            
+	dim hParent as long
+	dim hChildWnd as long, hButton as long
+	dim OK_CmdID as long
+
+   w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'FW_PART OR 
+
+OK_CmdID	 = &h00000002&
+
+'Get the handle to the static message field
+hChildWnd = WFndWndC ("A new location was created", "Static", w_flags, TIMEOUT)
+
+'Get the static message parent handle (the message box handle) 
+if hChildWnd > 0 then
+	hParent = GetParent (hChildWnd)
+else
+   logitem (CurrentLoggingLevel, "FindNewLocMessage Procedure")
+   logitem (CurrentLoggingLevel, "Invalid handle to New Location message box Static Control")
+   logitem (CurrentLoggingLevel, "Test Will Terminate")
+   Stop
+end if
+
+'Get the handle to the message box OK button
+if hParent > 0 then
+	hButton = GetDlgItem (hParent, OK_cmdID)
+else
+   logitem (CurrentLoggingLevel, "FindNewLocMessage Procedure")
+   logitem (CurrentLoggingLevel, "Invalid handle to New Location message box")
+   logitem (CurrentLoggingLevel, "Test Will Terminate")
+   Stop
+endif
+
+'Close the Message Box
+if hButton > 0 then
+	WButtonClick (_hwnd(hButton), TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "FindNewLocMessage Procedure")
+   logitem (CurrentLoggingLevel, "Invalid handle to New Location message box OK Button")
+   logitem (CurrentLoggingLevel, "Test Will Terminate")
+   Stop
+endif
+
+end sub'FindNewLocMessage
+
+'*****************************************************************************
+'Name   : ModifyLocation 
+'Desc   : Sets the Current location to the existing New Location and modifys
+'			 the Location Info to that contained in the ChangeLoc structure.
+'			 Verifies Changed location data is saved when dialing properties is 
+'			 closed and reopened. This routine requires that the My Location 
+'         property page is displayed.
+'			 
+'Parms  : ML_hChild: array holding the handles to the My Location controls 
+'			 The Change Location Info .
+'			 
+'Return : None
+'
+'History: 02/14/96 : a-rrohr: Created
+'*****************************************************************************
+sub ModifyLocation (Prop_hChild() as long, ML_hChild() as long, ChangeLoc as location)
+
+' Change current location to the existing New Location
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), New_Location, Timeout)
+
+' enter the change location data and close the dialing properties dialog.
+EditLocationInfo (ChangeLoc, ML_hChild)
+WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)))
+
+end sub 'ModifyLocation
+
+
+'*****************************************************************************
+'Name   : VerifyModifyLoc 
+'Desc   : Sets the Current location to the existing New Location and modifys
+'			 the Location Info to that contained in the ChangeLoc structure.
+'			 Verifies Changed location data is saved when dialing properties is 
+'			 closed and reopened. This routine requires that the My Location 
+'         property page is displayed.
+'			 
+'Parms  : ML_hChild: array holding the handles to the My Location controls 
+'			 The Change Location Info .
+'			 
+'Return : None
+'
+'History: 02/14/96 : a-rrohr: Created
+'*****************************************************************************
+sub VerifyModifyLoc (ML_hChild() as long, ChangeLoc as location, hDP_OKcmd as long)
+
+VerifyCurrentLoc (ML_hChild, ChangeLoc)
+
+teststring.Expect_Res =  NEW_LOCATION + " Doesn't Exist"
+TotalTestCases = TotalTestCases + 1
+	
+	if (NOT WComboItemExists (_hwnd(ML_hChild( LOCATION_cbo )),NEW_LOCATION, TIMEOUT)) then
+		teststring.Actual_Res = NEW_LOCATION + " Doesn't Exist" 
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Actual_Res = NEW_LOCATION + " Exist" 
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	endif
+
+WButtonClick (_hwnd(hDP_OKcmd), TIMEOUT)
+end sub 'VerifyModifyLoc
+
+'*****************************************************************************
+'Name   : VerifyCallWaiting 
+'Desc   :  
+'         
+'Parms  : Prop_ChildID: array holding the IDs to the Dialing Prop controls 
+'			 ML_ChildID: array holding the IDs to the My Location controls 
+'			 TestLoc structure that hold location Info
+'
+'Return : None
+'
+'History: 04/08/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub VerifyCallWaiting (Prop_ChildID() as long, ML_ChildID() as long, TestLoc as location)
+
+	dim w_flags			 as long			 'used with WFndWnd function
+	dim PhoneNo			 as TelephoneNo 'Holds lpszDestAddress
+	dim rtn				 as long			 'Generic Return variable
+	dim WinSysDir		 as string		 'Path to Windows System32 directory
+	dim count			 as short		 'Generic counter
+	dim WaitStr(3)		 as string		 'Wait Strings in Call Waiiting combobox
+	dim tempstr			 as string		 'Generic string variable
+'handles	& IDs
+	dim hTB20			 as long			 'handle to TAPI Browser
+	dim hList			 as long			 'handle to TAPI Browser	API list box
+	dim hProperties	 as long			 'handle to Dialing Properties
+	dim Prop_hChild(2) as long			 'handles to Dialing Properties child controls 
+	dim hMyLocTab		 as long			 'handle to the My Location property page 
+	dim ML_hChild(15)  as long			 'handles to My Locations child controls
+ 	dim hCtrl			 as long			 'Generic Handle to a control
+	dim DV_OKcmd		 as long			 'ID to Default Values dialog OK button
+	dim DV_list			 as long			 'ID to Default Values dialog list 
+	dim DV_edit			 as long			
+	dim TAPI_API_List  as long			 'ID to TB20 API list
+	dim hDlg				 as long			 'Generic dialog handle
+
+'ID to the Default Values child controls 
+
+DV_OKcmd	= &h00000001&
+DV_list  = &h000003E8&
+DV_edit  = &h000003E9&
+
+'ID to the TAPI Browser list box control listing all the TAPI API functions 
+
+TAPI_API_List	= &h000003E9&
+
+WaitStr(0) = "*70,"
+WaitStr(1) = "70#,"
+WaitStr(2) = "1170,"
+WaitStr(3) = "*99#,"
+
+'Set Test Values
+
+PhoneNo.CountryCode	= 1
+PhoneNo.AreaCode 		= "777"
+PhoneNo.SubscriberNo	= "9998888"
+
+ w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+'** Start Tapi Browser and set lpszDestAddress 
+
+WinSysDir = space$(32)
+rtn = GetSystemDirectory (WinSysDir, len(WinSysDir))
+
+'-- Start TAPI Browser and save handles
+
+if exists(WinSysDir + TAPI_BROWSER)	then
+	run WinSysDir + TAPI_BROWSER, nowait
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + WinSysDir + TAPI_BROWSER)
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto StopTestCase
+endif
+
+hTB20 = WFndWndC (TAPI_BROWSER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+'Look for the "Using the TAPI Browser" dialog. This dialog appears automatically
+'the first time TB is invoked and never again. it must be closed before the test
+'can proceed.
+
+hDlg = WFndWndC (USING_TB_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+if hDlg > 0 then
+	'Get handle to Using the TAPI Browser OK button and close dialog
+	hCtrl	= GetDlgItem(hDlg, DV_OKcmd)	 
+	WButtonClick  (_hwnd(hCtrl), TIMEOUT)
+end if
+	
+
+' Select Options / Default Values from menu and
+' Set Destination Address in TAPI Browser
+
+WMenuSelect (MOPTIONS + "\" + MDEFAULT, TIMEOUT)
+hDlg = WFndWndC (DEFAULT_VALUES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+sleep .1
+'Select lpszDestAddress
+hCtrl	= GetDlgItem(hDlg, DV_list)
+if WListItemExists (_hwnd(hCtrl), "line: lpszDestAddress", TIMEOUT) THEN
+	WListItemclk (_hwnd(hCtrl), "line: lpszDestAddress", TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find line: lpszDestAddress in Default Option Parameter list")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseTB20
+end if
+
+' Enter Destination Address (phone number) in edit control
+' I have to tab to the Edit box as both the Values edit box and the 
+' Bit flags list box have the same ID.
+
+play hDlg, "{TAB}"
+play hDlg, "{+}"+ ltrim$(str$(PhoneNo.CountryCode)) +"{(}"+ PhoneNo.AreaCode +"{)}" + PhoneNo.SubscriberNo
+
+'Close Dialog with OK
+hCtrl	= GetDlgItem(hDlg, DV_OKcmd)
+WButtonClick  (_hwnd(hCtrl), TIMEOUT)
+
+'** Start Dialing Properties
+
+hList = GetDlgItem (hTB20, TAPI_API_List)
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseTB20
+endif	 
+
+'** Get Handles to Dialing Properties, My Location and all child controls
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseDP
+endif
+		
+GetDPCtrlh (hProperties, Prop_hChild, Prop_ChildID)
+
+hMyLocTab = WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hMyLocTab = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + tab_MY_LOCATION + " Property Page")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseDP
+endif
+GetChildhandles (hMyLocTab, ML_hChild, ML_ChildID)
+
+'** Set Location to TestLoc
+
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), TestLoc.location, Timeout)
+
+'** Verify initial condition of Call Waiting Controls
+
+teststring.Expect_Res =  "Call Waiting Chkbox Unchk"
+TotalTestCases = TotalTestCases + 1
+
+rtn= WCheckEnabled (_Hwnd(ML_hChild(Wait_Chk)))
+select case rtn
+	case UNCHECKED
+		teststring.Actual_Res = "Call Waiting Chkbox Unchk" 
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	case CHECKED
+		teststring.Actual_Res = "Call Waiting Chkbox is Set" 
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	case GRAYED
+ 		teststring.Actual_Res = "Call Waiting Chkbox is Grayed" 
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+end select
+
+teststring.Expect_Res =  "Call Waiting Combo Disabled"
+TotalTestCases = TotalTestCases + 1
+
+if Not WComboEnabled (_hwnd(ML_hChild(WaitStr_Cbo)), 1) then
+	teststring.Actual_Res = "Call Waiting Combo Disabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Call Waiting Combo Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'** Set Call Waiting Check Box 
+
+WCheckCheck (_hwnd(ML_hChild(Wait_Chk)), 1)
+
+'** Verify Call Waiting Stings combobox is enabled and has proper strings.
+
+teststring.Expect_Res =  "Call Waiting Combo Enabled"
+TotalTestCases = TotalTestCases + 1
+
+if WComboEnabled (_hwnd(ML_hChild(WaitStr_Cbo)), 1) then
+	teststring.Actual_Res = "Call Waiting Combo Enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Call Waiting Combo Disabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+for count = lbound(WaitStr) to (Ubound(WaitStr) - 1)
+	teststring.Expect_Res =  "Call Waiting String " + WaitStr(count)
+	TotalTestCases = TotalTestCases + 1
+
+	if WComboItemExists (_hwnd(ML_hChild(WaitStr_Cbo)), WaitStr(count), 1) then
+		teststring.Actual_Res = WaitStr(count) + " Exists" 
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Actual_Res = WaitStr(count) + " Does Not Exist" 
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	end if
+next
+
+teststring.Expect_Res =  "Total Number of String = 3" + WaitStr(count)
+TotalTestCases = TotalTestCases + 1
+
+count = WComboCount(_hwnd(ML_hChild(WaitStr_Cbo)), 1)
+teststring.Actual_Res = "String count = " + ltrim$(str$(count))
+if count = 3 then
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'** Select each string and verify Number to be dialed has string
+
+for count = lbound(WaitStr) to (Ubound(WaitStr) - 1)
+	WComboItemClk (_hwnd(ML_hChild(WaitStr_Cbo)), WaitStr(count), 1)
+	teststring.Expect_Res =  "Call Waiting String " + WaitStr(count)
+	TotalTestCases = TotalTestCases + 1
+
+	TempStr = string$(64, str$(0))
+	rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempStr, 63)
+	rtn = instr (1, TempStr, WaitStr(count))
+
+	if rtn = 1 then
+		teststring.Actual_Res = WaitStr(count) + " Exists in Number" 
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Actual_Res = WaitStr(count) + " Not in Number" 
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	end if
+next
+
+'** Type in new string in combobox and verify Number to be dialed has it.
+
+count = 3
+WComboSetText(_hwnd(ML_hChild(WaitStr_Cbo)), WaitStr(count), 1)
+sleep .1
+teststring.Expect_Res =  "Call Waiting String " + WaitStr(count)
+TotalTestCases = TotalTestCases + 1
+
+TempStr = string$(64, str$(0))
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempStr, 63)
+rtn = instr (1, TempStr, WaitStr(count))
+
+if rtn = 1 then
+	teststring.Actual_Res = WaitStr(count) + " Exists in Number" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = WaitStr(count) + " Not in Number" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'** Close and reopen Dialing Properties
+
+WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)))	'Close dialing properties
+
+rtn = SetActiveWindow (hTB20)					   'Make sure TB20 is the active window
+WMenuSelect	(MFILE + "\" + MEXIT, TIMEOUT)	'Exit TB20
+
+sleep .2
+
+' Start TAPI Browser and save handles
+
+if exists(WinSysDir + TAPI_BROWSER)	then
+	run WinSysDir + TAPI_BROWSER, nowait
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + WinSysDir + TAPI_BROWSER)
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto StopTestCase
+endif
+
+hTB20 = WFndWndC (TAPI_BROWSER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+' Start Dialing properties
+
+hList = GetDlgItem (hTB20, TAPI_API_List)
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseTB20
+endif	 
+
+' Get Handles to Dialing Properties, My Location and all child controls
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseDP
+endif
+		
+GetDPCtrlh (hProperties, Prop_hChild, Prop_ChildID)
+
+hMyLocTab = WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hMyLocTab = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + tab_MY_LOCATION + " Property Page")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto CloseDP
+endif
+GetChildhandles (hMyLocTab, ML_hChild, ML_ChildID)
+
+'** Verify previous condition has been saved.
+
+count = 3
+teststring.Expect_Res =  "Call Waiting String " + WaitStr(count)
+TotalTestCases = TotalTestCases + 1
+TempStr = string$(64, str$(0))
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempStr, 63)
+rtn = instr (1, TempStr, WaitStr(count))
+
+if rtn = 1 then
+	teststring.Actual_Res = WaitStr(count) + " Exists in Number" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = WaitStr(count) + " Not in Number" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'** Reset Call Waiting Checkbox 
+
+WCheckUnCheck (_hwnd(ML_hChild(Wait_Chk)), 1)
+
+'** Verify Call Waiting ComboBox is disabled and Number to be dialed is correct
+
+teststring.Expect_Res =  "Call Waiting Combo Disabled"
+TotalTestCases = TotalTestCases + 1
+
+if Not WComboEnabled (_hwnd(ML_hChild(WaitStr_Cbo)), 1) then
+	teststring.Actual_Res = "Call Waiting Combo Disabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Call Waiting Combo Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'** Close Dialing Properties and TAPI Browser
+
+CloseDP:
+WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)))	'Close dialing properties
+
+CloseTB20:
+rtn = SetActiveWindow (hTB20)					   'Make sure TB20 is the active window
+WMenuSelect	(MFILE + "\" + MEXIT, TIMEOUT)	'Exit TB20
+
+StopTestCase:
+
+End Sub 'VerifyCallWaiting 
+
+'*****************************************************************************
+'Name   : ModifyCallingCard 
+'Desc   : Verifies that the the default calling cards are listed correctly in 
+'			 the Calling Call to use combobox and that their dialing rules are
+'			 correct.
+'         
+'Parms  : Prop_ChildID: array containing the IDs to the Dialing Prop controls 
+'			 ML_ChildID: array containing the IDs to the My Location controls 
+'			 CallingCard array containing information on the default cards
+'Return : None
+'
+'History: 04/11/96 : a-rrohr: Created
+'*****************************************************************************
+
+Sub DefaultCallingCard (CallingCard() as CardData, Prop_ChildID() as long, ML_ChildID() as long)
+
+	dim w_flags			 as long			 'used with WFndWnd function
+	dim PhoneNo			 as TelephoneNo 'Holds lpszDestAddress
+	dim rtn				 as long			 'Generic long return variable
+	dim WinSysDir		 as string		 'Path to Windows System32 directory
+	dim count			 as long		 'Generic counter
+	dim Startcount		 as short		 'starting element of array
+	dim Endcount		 as short		 'ending element of array
+	dim tempstr			 as string		 'Generic string variable
+	dim item				 as long
+	dim SizeofArray	 as short
+	dim itemtest as array of long		 'Calling-Card-to-used tested flag
+'handles	& IDs
+	dim hTB20			 as long			 'handle to TAPI Browser
+	dim hList			 as long			 'handle to TAPI Browser	API list box
+	dim hProperties	 as long			 'handle to Dialing Properties
+	dim Prop_hChild(2) as long			 'handles to Dialing Properties child controls 
+	dim hMyLocTab		 as long			 'handle to the My Location property page 
+	dim ML_hChild(15)  as long			 'handles to My Locations child controls
+	dim DV_OKcmd		 as long			 'ID to Default Values dialog OK button
+	dim DV_list			 as long			 'ID to Default Values dialog list 
+	dim DV_edit			 as long			
+	dim TAPI_API_List  as long			 'ID to TB20 API list
+	dim hCardDlg		 as long 		 'handles to Change Calling Card dialog & controls
+	dim Card_hChild(6) as long
+	dim Card_ChildID(6) as long 
+	dim hRuleDlg		 as long			 'handles to Dialing Rules dialog & controls
+	dim Rule_hChild(4) as long
+	dim Rule_ChildID(4) as long
+	dim NEW_ChildID(2)	 as long			 'Just to utilize SetCallingCardChildID, not used
+
+	dim hCtrl			 as long			 'Generic Handle to a control
+	dim hDlg				 as long			 'Generic dialog handle
+
+'Set Test Values
+
+PhoneNo.CountryCode	= 1
+PhoneNo.AreaCode 		= "777"
+PhoneNo.SubscriberNo	= "9998888"
+
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+          OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+'** 1 Get IDs
+
+SetCallingCardChildID (Card_ChildID, NEW_ChildID, Rule_ChildID, _
+							  DV_OKcmd, DV_list, DV_edit, TAPI_API_List)
+
+'** 2 Start TAPI Browser and set lpszDestAddress
+
+WinSysDir = space$(32)
+rtn = GetSystemDirectory (WinSysDir, len(WinSysDir))
+
+if exists(WinSysDir + TAPI_BROWSER)	then
+	run WinSysDir + TAPI_BROWSER, nowait
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + WinSysDir + TAPI_BROWSER)
+   logitem (CurrentLoggingLevel, "Ending Default Calling Card test")
+	goto StopTestCase
+endif
+
+hTB20 = WFndWndC (TAPI_BROWSER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+' Select Options / Default Values from menu and
+' Set Destination Address in TAPI Browser
+
+WMenuSelect (MOPTIONS + "\" + MDEFAULT, TIMEOUT)
+hDlg = WFndWndC (DEFAULT_VALUES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+sleep .1
+'Select lpszDestAddress
+hCtrl	= GetDlgItem(hDlg, DV_list)
+if WListItemExists (_hwnd(hCtrl), "line: lpszDestAddress", TIMEOUT) THEN
+	WListItemclk (_hwnd(hCtrl), "line: lpszDestAddress", TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find line: lpszDestAddress in Default Option Parameter list")
+   logitem (CurrentLoggingLevel, "Ending Default Calling Card test")
+	goto CloseTB20
+end if
+
+' Enter Destination Address (phone number) in edit control
+' I have to tab to the Edit box as both the Values edit box and the 
+' Bit flags list box have the same ID.
+
+play hDlg, "{TAB}"
+play hDlg, "{+}"+ ltrim$(str$(PhoneNo.CountryCode)) +"{(}"+ PhoneNo.AreaCode +"{)}" + PhoneNo.SubscriberNo
+
+'Close Dialog with OK
+hCtrl	= GetDlgItem(hDlg, DV_OKcmd)
+WButtonClick  (_hwnd(hCtrl), TIMEOUT)
+
+'** 3 Start Dialing Properties, get handles and set the location
+
+hList = GetDlgItem (hTB20, TAPI_API_List)
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Default Calling Card test")
+	goto CloseTB20
+endif	 
+
+'** Get Handles to Dialing Properties, My Location and all child controls
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Default Calling Card test")
+	goto CloseDP
+endif
+		
+GetDPCtrlh (hProperties, Prop_hChild, Prop_ChildID)
+
+hMyLocTab = WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hMyLocTab = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + tab_MY_LOCATION + " Property Page")
+   logitem (CurrentLoggingLevel, "Ending Default Calling Card test")
+	goto CloseDP
+endif
+GetChildhandles (hMyLocTab, ML_hChild, ML_ChildID)
+
+'** 4 Set Dial using Calling Card and click Change
+
+WCheckCheck (_hwnd(ML_hChild(CARD_Chk)), 1)
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))	'open Change Calling Card
+
+'** 5 Get Change Calling Card handles 
+
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+teststring.Expect_Res =  "Valid Change Calling Card Handle"
+teststring.Actual_Res =  "Handle = " + Str$(hCardDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hCardDlg > 0 then 
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+	GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+	logitem (CurrentLoggingLevel, "Unable to find Change Calling Card dialog")
+   logitem (CurrentLoggingLevel, "Terminating Default Calling Cards test")
+	Goto CloseDP
+End if
+
+'** 5a   Verify all callingcard() are listed in Calling Card to use list box
+
+startcount = lbound(callingcard)
+endcount   = ubound(callingcard)
+rtn = WComboCount(_hwnd(Card_hChild(CARD_NAMEcbo)), 1)
+redim itemtest (1 to rtn)
+
+for count = 1 to rtn
+	itemtest(count) = FALSE	  'set item tested flags to false
+next
+
+'Test for Number of default cards
+sizeofarray = endcount - (startcount -1)
+teststring.Expect_Res =  ltrim$(Str$(sizeofarray)) +" Cards in Calling Card to use"
+teststring.Actual_Res =  ltrim$(Str$(rtn)) + " Cards in ComboBox"
+TotalTestCases = TotalTestCases + 1
+select case rtn
+
+	case is < sizeofarray
+		teststring.Apprase = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+	case  sizeofarray
+		teststring.Apprase = "Pass"
+	case is > sizeofarray
+		teststring.Apprase = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+end select
+logcase (teststring)
+
+'Verify that CallingCard(count) is listed in Calling Card to use Combobox
+
+for count = startcount to endcount
+
+   WritelogItem ("" , " ")
+	item = WComboItemIndex(_hwnd(Card_hChild(CARD_NAMEcbo)), CallingCard(count).Cardname, 1)	
+	
+	teststring.Expect_Res =  CallingCard(count).Cardname +" is in ComboBox"
+	TotalTestCases = TotalTestCases + 1
+
+	if (item-1) >= 0 then
+		itemtest(item) = TRUE
+		CallingCard(count).Tested = TRUE
+		teststring.Actual_Res =  CallingCard(count).Cardname +" is in ComboBox"
+		teststring.Apprase    = "Pass"
+		logcase (teststring)
+	else
+		teststring.Actual_Res =  CallingCard(count).Cardname + " is Not in ComboBox"
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		logcase (teststring)
+	End if
+
+'** 5b Select each calling card and verify controls and dialing rules
+
+ if CallingCard(count).Tested then  'Test only those cards verified in the combobox
+
+	WComboItemClk (_hwnd(Card_hChild(CARD_NAMEcbo)), CallingCard(count).Cardname, 1)	
+	
+	' Verify state of Calling Card Number edit box
+	if CallingCard(count).Number then
+		teststring.Expect_Res = "Calling Card Number Enabled"
+	else
+		teststring.Expect_Res = "Calling Card Number Disabled"
+	endif
+	
+	TotalTestCases = TotalTestCases + 1
+	rtn = WEditEnabled (_hwnd(Card_hChild(CARD_NUMBERtxt)),1)
+
+	if rtn then
+		teststring.Actual_Res = "Calling Card Number Enabled"
+	else
+		teststring.Actual_Res = "Calling Card Number Disabled"
+	endif
+	
+	if CallingCard(count).Number = rtn then
+		teststring.Apprase    = "Pass"
+		logcase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		logcase (teststring)
+	endif
+
+'Verify Dialing rules of Calling card
+
+	WButtonClick (_hwnd(Card_hChild(Card_RULEScmd)))	
+	sleep .1
+	hRuleDlg = WFndWndC (DIAL_RULE_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+	GetChildhandles (hRuleDlg, Rule_hChild, Rule_ChildID) 
+
+'Verify Local Dialing Rule	
+	
+	teststring.Actual_Res = edittext(_hwnd(Rule_hChild(Rule_LOCALtxt)),1)
+
+	teststring.Expect_Res =  CallingCard(count).LocalRule +" Local Rule"
+	TotalTestCases = TotalTestCases + 1
+
+	if teststring.Actual_Res = CallingCard(count).LocalRule then
+		teststring.Apprase    = "Pass"
+		logcase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		logcase (teststring)
+	End if
+
+'Verify Long Distance Dialing Rule	
+	
+	teststring.Actual_Res = edittext(_hwnd(Rule_hChild(Rule_LONGtxt)),1)
+	
+	teststring.Expect_Res =  CallingCard(count).LongRule + " Long Dist Rule" 
+	TotalTestCases = TotalTestCases + 1
+
+	if teststring.Actual_Res = CallingCard(count).LongRule then
+		teststring.Apprase    = "Pass"
+		logcase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		logcase (teststring)
+	End if
+	
+'Verify International Dialing Rule	
+	
+	teststring.Actual_Res = edittext(_hwnd(Rule_hChild(Rule_INTERtxt)),1)
+
+	teststring.Expect_Res =  CallingCard(count).interRule +" International Rule"
+	TotalTestCases = TotalTestCases + 1
+
+	if teststring.Actual_Res = CallingCard(count).interRule then
+		teststring.Apprase    = "Pass"
+		logcase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		logcase (teststring)
+	End if
+
+'Close Dialing Rules
+	
+	WButtonClick (_hwnd(Rule_hChild(Rule_CLOSEcmd)))
+
+ endif
+
+next
+
+'** 5c   Verify that no listed default calling cards were untested
+
+startcount = lbound(itemtest)
+endcount	  = ubound(itemtest)
+for count = startcount to endcount
+
+	if Not itemtest(count) then
+		teststring.Actual_Res =  "Is Not a Default card"
+		teststring.Expect_Res =  ComboItemText(_hwnd(Card_hChild(CARD_NAMEcbo)), count, 1) + " Default card"
+		TotalTestCases = TotalTestCases + 1
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		logcase (teststring)
+	End if
+
+Next 
+
+'** 6 Close Change Calling Card, Dialing properties and tapi browser
+
+CloseCallingCard:
+WButtonClick (_hwnd(Card_hChild(CARD_CANCELcmd)))	'Close Change Calling Card dialog
+
+CloseDP:
+WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)))	'Close dialing properties
+
+CloseTB20:
+rtn = SetActiveWindow (hTB20)					   'Make sure TB20 is the active window
+WMenuSelect	(MFILE + "\" + MEXIT, TIMEOUT)	'Exit TB20
+
+StopTestCase:
+
+end Sub 'DefaultCallingCard
+
+'*****************************************************************************
+'Name   : VerifyCallingCard 
+'Desc   : Verifies default location and location information added in the 
+'			 AddLocation sub. This routine requires that the My Location 
+'			 property page is displayed.
+'         
+'Parms  : Prop_ChildID: array holding the IDs to the Dialing Prop controls 
+'			 ML_ChildID: array holding the IDs to the My Location controls 
+'
+'Return : None
+'
+'History: 03/08/96 : a-rrohr: Created
+'*****************************************************************************
+sub VerifyCallingCard (Prop_ChildID() as long, ML_ChildID() as long)
+
+	dim w_flags as long            'used with WFndWnd function
+	dim hTB20 as long, hProperties as long, hMyLocTab as long
+	dim hList as long, Prop_hChild (2) as long, ML_hChild(14) as long
+	dim hCardDlg as long, Card_hChild(6) as long, Card_ChildID(6) as long 
+	dim hNewDlg as long, NEW_hChild(2) as long, NEW_ChildID(2) as long, hNewCtrl as long
+	dim hRuleDlg as long, Rule_hChild(4) as long, Rule_ChildID(4) as long, hRuleCtrl as long
+	dim TAPI_API_List as long
+	DIM DV_OKcmd as long, DV_list as long, DV_edit as long, hDVctrl as long
+	dim rtn as long, item as long, hDlg as long, hCtrl as long
+	dim CardName as string, TempString as string
+	dim WinSysDir as string
+	
+   w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+'Set Child control IDs
+SetCallingCardChildID (Card_ChildID, NEW_ChildID, Rule_ChildID, _
+							  DV_OKcmd, DV_list, DV_edit, TAPI_API_List)
+
+' Start the TAPI Browser application
+
+WinSysDir = space$(32)
+rtn = GetSystemDirectory (WinSysDir, len(WinSysDir))
+
+if exists(WinSysDir + TAPI_BROWSER)	then
+	run WinSysDir + TAPI_BROWSER, nowait
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + WinSysDir + TAPI_BROWSER)
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto NoTAPIBrowser
+endif
+
+hTB20 = WFndWndC (TAPI_BROWSER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+' Set Destination Address in TAPI Browser
+
+WMenuSelect (MOPTIONS + "\" + MDEFAULT, TIMEOUT)
+hDlg = WFndWndC (DEFAULT_VALUES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+'Select lpszDestAddress
+hDVctrl	= GetDlgItem(hDlg, DV_list)
+if WListItemExists (_hwnd(hDVctrl), "line: lpszDestAddress", TIMEOUT) THEN
+	WListItemclk (_hwnd(hDVctrl), "line: lpszDestAddress", TIMEOUT)
+end if
+
+'Enter Destination Address (phone number) in edit control
+' I have to tab to the Edit box as both the Values edit box and the 
+' Bit flags list box have the same ID.
+play hDlg, "{TAB}"
+play hDlg, "{+}1{(}206{)}7881234"
+'hDVctrl	= GetDlgItem(hDlg, DV_edit)
+'WEditSetText  (_hwnd(hDVctrl), "+1(206)7881234", TIMEOUT)
+
+'Close Dialog with OK
+hDVctrl	= GetDlgItem(hDlg, DV_OKcmd)
+WButtonClick  (_hwnd(hDVctrl), TIMEOUT)
+
+' Call lineTranslateDialog from TAPI Browser
+
+hList = GetDlgItem (hTB20, TAPI_API_List)
+'print "Listbox handle = "; hList
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto NoDialingProp
+endif	 
+
+' Get all Dialing Properties handles
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto NoDialingProp
+endif
+
+GetDPCtrlh (hProperties, Prop_hChild, Prop_ChildID)
+
+hMyLocTab = WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hMyLocTab = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + tab_MY_LOCATION + " Property Page")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto StopTestCase
+endif
+GetChildhandles (hMyLocTab, ML_hChild, ML_ChildID)
+
+'Set location to local (Redmond) area code
+
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), "Redmond", timeout)
+
+' Start of Test Cases
+
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))	'Open Change Calling Card dialog
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+
+' TEST FOR DEFAULT STATE OF CHANGE CALLING CARD DIALOG CONTROLS
+
+teststring.Expect_Res =  "NEW Button Enabled"
+TotalTestCases = TotalTestCases + 1
+
+if WButtonEnabled (_Hwnd(Card_hChild(CARD_NEWcmd))) then
+	teststring.Actual_Res = "NEW Button Enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "NEW Button is not Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res =  "Remove Button is not Enabled"
+TotalTestCases = TotalTestCases + 1
+
+if WButtonEnabled (_Hwnd(Card_hChild(CARD_REMOVEcmd))) then
+	teststring.Actual_Res = "Remove Button is Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Remove Button is not Enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+endif
+
+teststring.Expect_Res =  "Advanced Button Enabled"
+TotalTestCases = TotalTestCases + 1
+
+if WButtonEnabled (_Hwnd(Card_hChild(Card_RULEScmd))) then
+	teststring.Actual_Res = "Advanced Button Enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Advanced Button is not Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res =  "OK Button Enabled"
+TotalTestCases = TotalTestCases + 1
+
+if WButtonEnabled (_Hwnd(Card_hChild(CARD_OKcmd))) then
+	teststring.Actual_Res = "OK Button Enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "OK Button is not Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res =  "OK Button has Focus"
+TotalTestCases = TotalTestCases + 1
+
+if WButtonFocus (_Hwnd(Card_hChild(CARD_OKcmd))) then
+	teststring.Actual_Res = "OK Button has Focus" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "OK Button does not have Focus" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res =  "CANCEL Button Enabled"
+TotalTestCases = TotalTestCases + 1
+
+if WButtonEnabled (_Hwnd(Card_hChild(CARD_CANCELcmd))) then
+	teststring.Actual_Res = "CANCEL Button Enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "CANCEL Button is not Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res =  "No Calling Card Number"
+TotalTestCases = TotalTestCases + 1
+
+if WEditLen (_Hwnd(Card_hChild(CARD_NUMBERtxt))) = 0 then
+	teststring.Actual_Res = "No Calling Card Number" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Calling Card Number" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res =  "Default Calling Card exists"
+TotalTestCases = TotalTestCases + 1
+
+item = WComboIndex (_hwnd(Card_hChild(CARD_NAMEcbo)), TIMEOUT)
+if item = 0 then
+	teststring.Actual_Res = "No Default Calling Card" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Default Calling Card exists" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+end if
+
+teststring.Expect_Res = lbl_DIR_DIAL
+TotalTestCases = TotalTestCases + 1
+
+CardName = space$(32)
+CardName = ComboItemText (_hwnd(Card_hChild(CARD_NAMEcbo)), item, TIMEOUT)
+if CardName = teststring.Expect_Res then
+	teststring.Actual_Res = "Valid Calling Card " + CardName
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Invalid Calling Card " + CardName
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+' Add New Calling Card
+
+WButtonClick (_hwnd(Card_hChild(CARD_NEWcmd)))
+hNewDlg = WFndWndC (NEW_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+hNewCtrl = GetDlgItem (hNewDlg, NEW_ChildID(NEW_NAMEtxt))
+WEditSetText (_hwnd(hNewCtrl), "New Card", TIMEOUT)
+
+teststring.Expect_Res =  "New Card"
+TotalTestCases = TotalTestCases + 1
+
+CardName = space$(32)
+CardName = EditText (_hwnd(hNewCtrl), TIMEOUT)
+if CardName = teststring.Expect_Res then
+	teststring.Actual_Res = "Valid Calling Card " + CardName
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Invalid Calling Card " + CardName
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+hNewCtrl = GetDlgItem (hNewDlg, NEW_ChildID(NEW_OKcmd))
+WButtonClick (_hwnd(hNewCtrl))				               'Close Create New Calling Card
+
+'************* Add Test to verify DP Message and close      *****************
+w_flags = FW_ALL OR FW_CHILDOK OR FW_PART OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+hCtrl = WFndWndC ("You Now Must", "Static", w_flags, WTIMEOUT)
+hDlg  = GetParent (hCtrl)
+
+'Verify Caption of Parent is Dialing Properties
+teststring.Expect_Res = PROPERTIES_CAPTION
+teststring.Actual_Res = string$(64, str$(0))
+rtn = GetWindowText (hDlg, teststring.Actual_Res, len(teststring.Actual_Res))
+TotalTestCases = TotalTestCases + 1
+
+if teststring.Actual_Res = teststring.Expect_Res  then 
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+	logitem (CurrentLoggingLevel, "Unable to find Dialing Properties Message")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+hCtrl = GetDlgItem (hDlg, &h0002&)		'Get Handle to OK button
+WButtonClick (_hwnd(hCtrl), TIMEOUT)
+
+'reset window search flag
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+'Verify that the Dialing Rules dialog appears, enter dialing rules and close
+
+hRuleDlg = WFndWndC (DIAL_RULE_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+teststring.Expect_Res =  "Valid Dialing Rules Handle"
+teststring.Actual_Res =  "Handle = " + Str$(hRuleDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hRuleDlg > 0 then 
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+	GetChildhandles (hRuleDlg, Rule_hChild, Rule_ChildID) 
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+	logitem (CurrentLoggingLevel, "Unable to find Dialing Rules dialog")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+'Verify US Country Dialing Rules
+teststring.Expect_Res =  TempString + "G"
+TotalTestCases = TotalTestCases + 1
+
+teststring.Actual_Res = string$(32, str$(0))
+teststring.Actual_Res = ltrim$(EditText (_hwnd(Rule_hChild(Rule_LOCALtxt)), TIMEOUT))
+
+IF teststring.Actual_Res = teststring.Expect_Res  THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+teststring.Expect_Res =  TempString + "1FG"
+TotalTestCases = TotalTestCases + 1
+
+teststring.Actual_Res = string$(32, str$(0))
+teststring.Actual_Res = ltrim$(EditText (_hwnd(Rule_hChild(Rule_LONGtxt)), TIMEOUT))
+
+IF teststring.Actual_Res = teststring.Expect_Res  THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+teststring.Expect_Res =  TempString + "011EFG"
+TotalTestCases = TotalTestCases + 1
+
+teststring.Actual_Res = string$(32, str$(0))
+teststring.Actual_Res = ltrim$(EditText (_hwnd(Rule_hChild(Rule_INTERtxt)), TIMEOUT))
+
+IF teststring.Actual_Res = teststring.Expect_Res  THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+'Set Rules to NULL string
+WEditSetText (_hwnd(Rule_hChild(Rule_LOCALtxt)), "", TIMEOUT)
+WEditSetText (_hwnd(Rule_hChild(Rule_LONGtxt)), "", TIMEOUT)
+WEditSetText (_hwnd(Rule_hChild(Rule_INTERtxt)), "", TIMEOUT)
+WButtonClick (_hwnd(Rule_hChild(Rule_CLOSEcmd)), TIMEOUT)
+
+'****************************************************************************
+
+teststring.Expect_Res =  "New Card"
+TotalTestCases = TotalTestCases + 1
+
+CardName = space$(32)
+CardName = ComboItemText (_hwnd(Card_hChild(CARD_NAMEcbo)), item, TIMEOUT)
+if CardName = teststring.Expect_Res then
+	teststring.Actual_Res = "Valid Calling Card " + CardName
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Invalid Calling Card " + CardName
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+WButtonClick (_hwnd(Card_hChild(CARD_OKcmd)))	'Close Change Calling Card
+
+'*** Verify Number to be dialed Test - blank dialing rules
+
+'Verify calling card static lable
+
+teststring.Expect_Res =  "New Card"
+TotalTestCases = TotalTestCases + 1
+
+	CardName = string$(32, str$(0))
+	TotalTestCases = TotalTestCases + 1
+	rtn = GetDlgItemText (hMyLocTab, &h00001391, CardName, 31)
+	teststring.Actual_Res = CardName 
+		IF CardName = "New Card" THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Verify Number to be dialed static lable
+
+TempString = string$(32, str$(0))
+TempString = EditText (_hwnd(ML_hChild(local_txt)), TIMEOUT)
+
+if TempString <> "" then 
+	teststring.Expect_Res =  TempString + " 7881234"
+else
+	teststring.Expect_Res =  "7881234"
+end if
+TotalTestCases = TotalTestCases + 1
+
+	TempString = string$(64, str$(0))
+	rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempString, 31)
+	teststring.Actual_Res = TempString 
+		IF TempString = teststring.Expect_Res  THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'Set Calling Card checkbox and Verify Number to be dialed static lable
+
+WCheckCheck (_hwnd(ML_hChild(CARD_chk)), TIMEOUT)
+
+TempString = string$(32, str$(0))
+TempString = EditText (_hwnd(ML_hChild(local_txt)), TIMEOUT)
+
+ teststring.Expect_Res =  TempString
+ TotalTestCases = TotalTestCases + 1
+
+	TempString = string$(64, str$(0))
+	rtn = GetDlgItemText (hMyLocTab, ML_ChildID(Address_lbl), TempString, 31)
+	teststring.Actual_Res = TempString 
+		IF TempString = teststring.Expect_Res THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+'*** Enter Advanced Dialing Rules
+
+' Open Change Calling Card and click the Advanced button
+
+'Open Change Calling Card dialog	& get child handles
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+
+'*******************************************************************************
+' At this point the Calling Card should be New Card (works manually)
+' But when the automated test is executed the default card is None.
+' As a workaround select the New Card and force it to be the default.
+'*******************************************************************************
+
+WComboItemClk (_hwnd(Card_hChild(Card_Namecbo)), "New Card", timeout)
+
+'Open Dialing Rules dialog	& get child handles
+WButtonClick (_hwnd(Card_hChild(Card_RULEScmd)))	
+hRuleDlg = WFndWndC (DIAL_RULE_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+' Verify that the Dialing Rules dialog appears, enter dialing rules and close
+
+teststring.Expect_Res =  "Valid Dialing Rules Handle"
+teststring.Actual_Res =  "Handle = " + Str$(hRuleDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hRuleDlg > 0 then 
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+	GetChildhandles (hRuleDlg, Rule_hChild, Rule_ChildID) 
+	WEditSetText (_hwnd(Rule_hChild(Rule_LOCALtxt)), "HG", TIMEOUT)
+	WEditSetText (_hwnd(Rule_hChild(Rule_LONGtxt)), "FG", TIMEOUT)
+	WEditSetText (_hwnd(Rule_hChild(Rule_INTERtxt)), "EFG", TIMEOUT)
+	WButtonClick (_hwnd(Rule_hChild(Rule_CLOSEcmd)), TIMEOUT)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+	logitem (CurrentLoggingLevel, "Unable to find Dialing Rules dialog")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+' Click Change Calling Card OK & verify error message
+WButtonClick (_hwnd(Card_hChild(Card_OKcmd)))
+hDlg = WFndWndC (NO_PIN_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+teststring.Expect_Res =  "Valid Error Dialog Handle"
+teststring.Actual_Res =  "Handle = " + Str$(hDlg)
+TotalTestCases = TotalTestCases + 1
+
+if hDlg > 0 Then
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+	hCtrl = GetDlgItem(hDlg, &h02&)	'Close error message box with OK button
+	WButtonClick (_hwnd(hCtrl), TIMEOUT)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+   logitem (CurrentLoggingLevel, "Unable to find No PIN error message")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+' Enter Pin number, click OK and verify error message does not appear
+
+WEditSetText (_hwnd(Card_hChild(Card_NUMBERtxt)), "1234", TIMEOUT)
+WButtonClick (_hwnd(Card_hChild(Card_OKcmd)), TIMEOUT)
+
+hDlg = WFndWndC (NO_PIN_CAPTION, DIALOG_CLASS, w_flags, 1)
+
+teststring.Expect_Res =  "No Error Message"
+TotalTestCases = TotalTestCases + 1
+
+if hDlg = 0 Then
+	teststring.Actual_Res =  "No Error Message"
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Actual_Res =  "PIN Error Message"
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+   logitem (CurrentLoggingLevel, "PIN error message dialog was found")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	hCtrl = GetDlgItem(hDlg, &h02&)	'Close error message box with OK button
+	WButtonClick (_hwnd(hCtrl), TIMEOUT)
+	Goto StopTestCase
+End if
+
+' Verify Local Dialing rule
+
+WCheckUnCheck (_hwnd(ML_hChild(CARD_chk)), TIMEOUT)
+WCheckCheck (_hwnd(ML_hChild(CARD_chk)), TIMEOUT)
+
+TempString = string$(32, str$(0))
+TempString = EditText (_hwnd(ML_hChild(local_txt)), TIMEOUT)
+
+teststring.Expect_Res =  TempString + " [New Card] 7881234"
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(Address_lbl), TempString, 31)
+
+teststring.Actual_Res = TempString 
+	IF TempString = teststring.Expect_Res THEN
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	endif
+
+' Select Long distance location, Open Change calling card, select card
+' & verify Long distance dialing rules 
+
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), "Chicago", timeout)
+
+' Make sure new card is selected for long distance location
+
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+
+WComboItemClk (_hwnd(Card_hChild(Card_NAMEcbo)), lbl_DIR_DIAL, timeout)
+WComboItemClk (_hwnd(Card_hChild(Card_NAMEcbo)), "New Card", timeout)
+WButtonClick (_hwnd(Card_hChild(Card_OKcmd)), TIMEOUT)
+ 
+'Verify Calling Card Dialing Rules
+WCheckCheck (_hwnd(ML_hChild(CARD_chk)), TIMEOUT)
+
+TempString = string$(32, str$(0))
+TempString = EditText (_hwnd(ML_hChild(LONG_txt)), TIMEOUT)
+
+teststring.Expect_Res =  TempString + " 206 7881234"
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(Address_lbl), TempString, 31)
+
+teststring.Actual_Res = TempString 
+	IF TempString = teststring.Expect_Res THEN
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	endif
+
+' Select International location, Open Cahnge calling card, select card
+' & verify International dialing rules 
+
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), "Cork", timeout)
+
+' Make sure new card is selected for long distance location
+
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+
+WComboItemClk (_hwnd(Card_hChild(Card_NAMEcbo)), lbl_DIR_DIAL, timeout)
+WComboItemClk (_hwnd(Card_hChild(Card_NAMEcbo)), "New Card", timeout)
+WButtonClick (_hwnd(Card_hChild(Card_OKcmd)), TIMEOUT)
+ 
+'Verify Calling Card Dialing Rules
+
+WCheckCheck (_hwnd(ML_hChild(CARD_chk)), TIMEOUT)
+
+TempString = string$(32, str$(0))
+TempString = EditText (_hwnd(ML_hChild(LONG_txt)), TIMEOUT)
+
+teststring.Expect_Res =  TempString + " 1 206 7881234"
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(Address_lbl), TempString, 31)
+
+teststring.Actual_Res = TempString 
+	IF TempString = teststring.Expect_Res THEN
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	endif
+
+' Deselect dialing rules & verify dialing rule revers to country rule
+
+WCheckUnCheck (_hwnd(ML_hChild(CARD_chk)), TIMEOUT)
+
+TempString = string$(32, str$(0))
+TempString = EditText (_hwnd(ML_hChild(LONG_txt)), TIMEOUT)
+teststring.Expect_Res =  TempString + " 00 1 206 7881234"
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(Address_lbl), TempString, 31)
+
+teststring.Actual_Res = TempString 
+	IF TempString = teststring.Expect_Res THEN
+		teststring.Apprase    = "Pass"
+		LogCase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	endif
+
+' Create a 2nd New calling card and copy rules from previous new card
+
+'CREATE SECOND CARD
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+WButtonClick (_hwnd(Card_hChild(CARD_NEWcmd)))
+hNewDlg = WFndWndC (NEW_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+hNewCtrl = GetDlgItem (hNewDlg, NEW_ChildID(NEW_NAMEtxt))
+WEditSetText (_hwnd(hNewCtrl), "Second Card", TIMEOUT)
+hNewCtrl = GetDlgItem (hNewDlg, NEW_ChildID(NEW_OKcmd))
+WButtonClick (_hwnd(hNewCtrl))
+'Close Dialing Properties message Box
+w_flags = FW_ALL OR FW_CHILDOK OR FW_PART OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+hCtrl = WFndWndC ("You Now Must", "Static", w_flags, WTIMEOUT)
+hDlg  = GetParent (hCtrl)
+'Verify Caption of Parent is Dialing Properties
+hCtrl = GetDlgItem (hDlg, &h0002&)
+WButtonClick (_hwnd(hCtrl), TIMEOUT)
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+
+'SELECT ADVANCED BUTTON, SELECT COPY FROM, VERIFY COPY DIALING RULES APPEARS
+WButtonClick (_hwnd(Card_hChild(Card_RULEScmd)))	
+hRuleDlg = WFndWndC (DIAL_RULE_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hRuleDlg, Rule_hChild, Rule_ChildID) 
+WButtonClick (_hwnd(Rule_hChild(Rule_COPYcmd)))	
+hDlg = WFndWndC (COPY_RULE_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+teststring.Expect_Res =  "Valid dialog handle"
+TotalTestCases = TotalTestCases + 1
+teststring.Actual_Res =  "Handle " + Str$(hDlg)
+if hDlg > 0 Then
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+   logitem (CurrentLoggingLevel, "Unable to find Copy Dialing Rules dialog")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+'SELECT NEW CARD FROM LIST BOX AND CLICK OK
+hCtrl = GetDlgItem (hDlg, &h0407&)
+WListItemClk (_hwnd(hCtrl), "New Card", timeout)
+'Click OK button
+hCtrl = GetDlgItem (hDlg, &h01&)
+WButtonClick (_hwnd(hCtrl))
+
+'VERIFY TEXT FIELDS ARE FILLED AND CLICK OK
+TempString = Space$(10)
+TempString = EditText (_hwnd(Rule_hChild(Rule_LOCALtxt)))
+
+teststring.Expect_Res =  "HG"
+TotalTestCases = TotalTestCases + 1
+teststring.Actual_Res = TempString 
+
+IF TempString = teststring.Expect_Res THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+TempString = Space$(10)
+TempString = EditText (_hwnd(Rule_hChild(Rule_LONGtxt)))
+
+teststring.Expect_Res =  "FG"
+TotalTestCases = TotalTestCases + 1
+teststring.Actual_Res = TempString 
+
+IF TempString = teststring.Expect_Res THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+TempString = Space$(10)
+TempString = EditText (_hwnd(Rule_hChild(Rule_INTERtxt)))
+
+teststring.Expect_Res =  "EFG"
+TotalTestCases = TotalTestCases + 1
+teststring.Actual_Res = TempString 
+
+IF TempString = teststring.Expect_Res THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+WButtonClick (_hwnd(Rule_hChild(Rule_CLOSEcmd)))
+' Remove Calling Card
+
+'REMOVE SECOND CARD, VERIFY "ARE YOU SURE" MESSAGE APPEARS, CLOSE MESSAGE
+WButtonClick (_hwnd(Card_hChild(Card_REMOVEcmd)))
+hDlg = WFndWndC (REALLY_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+teststring.Expect_Res =  "Valid dialog handle"
+TotalTestCases = TotalTestCases + 1
+teststring.Actual_Res =  "Handle " + str$(hDlg)
+if hDlg > 0 Then
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+   logitem (CurrentLoggingLevel, "Unable to find Are You Sure dialog")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+'Get handle to yes button and click it.
+hCtrl = GetDlgItem (hDlg, &h0006&) 
+WButtonClick (_hwnd(hCtrl))
+
+'VERIFY CARD IS REMOVED, NONE BECOMES DEFAULT AND REMOVE BUTTON IS DISABLED.
+
+teststring.Expect_Res =  "Second Card is removed"
+TotalTestCases = TotalTestCases + 1
+
+if WComboItemExists (_hwnd(Card_hChild(Card_NAMEcbo)), "Second Card") Then
+	teststring.Actual_Res =  "Second Card still exists"
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+else
+	teststring.Actual_Res =  "Second Card is removed"
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+End if
+
+teststring.Expect_Res =  "None (Direct Dial)"
+TotalTestCases = TotalTestCases + 1
+
+TempString = ComboText (_hwnd(Card_hChild(Card_NAMEcbo)))
+teststring.Actual_Res =  TempString
+
+if TempString = teststring.Expect_Res Then
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+End if
+
+'SELECT NEW CARD, REMOVE, VERIFY "ARE YOU SURE" MESSAGE APPEARS, CLOSE MESSAGE
+WComboItemClk (_hwnd(Card_hChild(Card_NAMEcbo)), "New Card")
+WButtonClick (_hwnd(Card_hChild(Card_REMOVEcmd)))
+hDlg = WFndWndC (REALLY_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+teststring.Expect_Res =  "Valid dialog handle"
+TotalTestCases = TotalTestCases + 1
+teststring.Actual_Res =  "Handle " + str$(hDlg)
+if hDlg > 0 Then
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+   logitem (CurrentLoggingLevel, "Unable to find Are You Sure dialog")
+   logitem (CurrentLoggingLevel, "Terminating Validate Calling Cards test")
+	Goto StopTestCase
+End if
+
+'Get handle to yes button and click it.
+hCtrl = GetDlgItem (hDlg, &h0006&) 
+WButtonClick (_hwnd(hCtrl))
+
+'VERIFY CARD IS REMOVED, NONE BECOMES DEFAULT AND REMOVE BUTTON IS DISABLED.
+
+teststring.Expect_Res =  "New Card is removed"
+TotalTestCases = TotalTestCases + 1
+
+if WComboItemExists (_hwnd(Card_hChild(Card_NAMEcbo)), "New Card") Then
+	teststring.Actual_Res =  "New Card still exists"
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+else
+	teststring.Actual_Res =  "New Card is removed"
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+End if
+
+teststring.Expect_Res =  "None (Direct Dial)"
+TotalTestCases = TotalTestCases + 1
+
+TempString = ComboText (_hwnd(Card_hChild(Card_NAMEcbo)))
+teststring.Actual_Res =  TempString
+
+if TempString = teststring.Expect_Res Then
+	teststring.Apprase    = "Pass"
+	logcase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	logcase (teststring)
+End if
+
+WButtonClick (_hwnd(Card_hChild(Card_OKcmd)))
+
+' End of Test Cases
+
+StopTestCase:
+
+WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)))	'Close dialing properties
+
+NoDialingProp:
+
+rtn = SetActiveWindow (hTB20)					   'Make sure TB20 is the active window
+WMenuSelect	(MFILE + "\" + MEXIT, TIMEOUT)	'Exit TB20
+
+NoTapiBrowser:
+end sub 'VerifyCallingCard
+
+'*****************************************************************************
+'Name   : VerifyCurrentLoc 
+'Desc   : Verifies default location and location information added in the 
+'			 AddLocation sub. This routine requires that the My Location 
+'			 property page is displayed.
+'         
+'Parms  : ML_hChild: array holding the handles to the My Location controls 
+'			 The 2 locations to be added
+'
+'Return : None
+'
+'History: 02/16/96 : a-rrohr: Created
+'*****************************************************************************
+sub VerifyCurrentLoc (ML_hChild() as long, Default as location)
+
+dim CurrentLoc as string
+dim CurrentArea as string
+dim CurrentCountry as string
+dim CurrentAccess as string
+dim item as long
+dim State as long					'State of option button 1 for set 0 for reset
+
+' verify 'I am dialing from' text
+
+	teststring.Expect_Res =  Default.Location
+	TotalTestCases = TotalTestCases + 1
+	
+	CurrentLoc = string$(64, str$(0))
+	item = WComboIndex (_hwnd(ML_hChild( LOCATION_cbo )), TIMEOUT)
+	CurrentLoc = ComboItemText (_hwnd ( ML_hChild( LOCATION_cbo )), Item, TIMEOUT)
+	teststring.Actual_Res = CurrentLoc 
+	
+		IF CurrentLoc = Default.Location THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	teststring.Expect_Res =  Default.Country
+	TotalTestCases = TotalTestCases + 1
+	
+	CurrentCountry = string$(64, str$(0))
+	CurrentCountry = ComboText (_hwnd ( ML_hChild( COUNTRY_cbo )), TIMEOUT)
+	teststring.Actual_Res = CurrentCountry 
+	
+		IF CurrentCountry = Default.Country THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	teststring.Expect_Res =  Default.AreaCode
+	TotalTestCases = TotalTestCases + 1
+	
+	CurrentArea = string$(64, str$(0))
+	CurrentArea = EditText (_hwnd ( ML_hChild( AREA_txt )), TIMEOUT)
+	teststring.Actual_Res = CurrentArea 
+	
+		IF CurrentArea = Default.AreaCode THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	teststring.Expect_Res =  Default.localAccess
+	TotalTestCases = TotalTestCases + 1
+	
+	CurrentAccess = string$(64, str$(0))
+	CurrentAccess = EditText (_hwnd ( ML_hChild( LOCAL_txt )), TIMEOUT)
+	teststring.Actual_Res = CurrentAccess 
+	
+		IF CurrentAccess = Default.LocalAccess THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	teststring.Expect_Res =  Default.LongAccess
+	TotalTestCases = TotalTestCases + 1
+	
+	CurrentAccess = string$(64, str$(0))
+	CurrentAccess = EditText (_hwnd ( ML_hChild( LONG_txt )), TIMEOUT)
+	teststring.Actual_Res = CurrentAccess 
+	
+		IF CurrentAccess = Default.longAccess THEN
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	if Default.PulseSet then
+		teststring.Expect_Res = "Pulse Dialing Set"
+	else
+		teststring.Expect_Res = "Pulse Dialing Not Set"
+	end if
+	TotalTestCases = TotalTestCases + 1
+		
+		'WOptionState returns 1 and not true for set therefor the state
+		'variable is set to 1 for true & 0 for false to test against the
+		'WOptionState return value.
+		IF Default.PulseSet then
+			State = 1
+		else
+			State = 0
+		end if		
+		IF (WOptionState (_hwnd ( ML_hChild(PULSE_opt)), TIMEOUT) = State) THEN
+			if Default.PulseSet then
+				teststring.Actual_Res = "Pulse Dialing Set"
+			else
+				teststring.Actual_Res = "Pulse Dialing Not Set"
+			end if
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			if Default.PulseSet then
+				teststring.Actual_Res = "Pulse Dialing Set"
+			else
+				teststring.Actual_Res = "Pulse Dialing Not Set"
+			end if
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	if Default.ToneSet then
+		teststring.Expect_Res = "Tone Dialing Set"
+	else
+		teststring.Expect_Res = "Tone Dialing Not Set"
+	end if
+	TotalTestCases = TotalTestCases + 1
+	
+		'WOptionState returns 1 and not true for set therefor the state
+		'variable is set to 1 for true & 0 for false to test against the
+		'WOptionState return value.
+		IF Default.ToneSet then
+			State = 1
+		else
+			State = 0
+		end if		
+		IF (WOptionState (_hwnd ( ML_hChild(TONE_opt)), TIMEOUT) = State) THEN
+			if Default.ToneSet then
+				teststring.Actual_Res = "Tone Dialing Set"
+			else
+				teststring.Actual_Res = "Tone Dialing Not Set"
+			end if
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			if Default.ToneSet then
+				teststring.Actual_Res = "Tone Dialing Set"
+			else
+				teststring.Actual_Res = "Tone Dialing Not Set"
+			end if
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	if Default.Cardset then
+		teststring.Expect_Res = "Calling Card Checked"
+	else	
+		teststring.Expect_Res = "Calling Card Not Checked"
+	end if
+	TotalTestCases = TotalTestCases + 1
+		
+		IF WCheckState (_hwnd ( ML_hChild(CARD_chk)), TIMEOUT) = Default.CardSet THEN
+			if Default.Cardset then
+				teststring.Actual_Res = "Calling Card Checked"
+			else	
+				teststring.Actual_Res = "Calling Card Not Checked"
+			end if
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			if Default.Cardset then
+				teststring.Actual_Res = "Calling Card Not Checked"
+			else	
+				teststring.Actual_Res = "Calling Card Checked"
+			end if
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+	if Default.WaitSet then	
+		teststring.Expect_Res = "Call Waiting Checked"
+	else
+		teststring.Expect_Res = "Call Waiting Not Checked"
+	end if
+	TotalTestCases = TotalTestCases + 1
+		
+		IF WCheckState (_hwnd ( ML_hChild(WAIT_chk)), TIMEOUT) = Default.WaitSet THEN
+			if Default.Waitset then
+				teststring.Actual_Res = "Call Waiting Checked"
+			else	
+				teststring.Actual_Res = "Call Waiting Not Checked"
+			end if
+			teststring.Apprase    = "Pass"
+			LogCase (teststring)
+		else
+			if Default.Waitset then
+				teststring.Actual_Res = "Call Waiting Not Checked"
+			else	
+				teststring.Actual_Res = "Call Waiting Checked"
+			end if
+			teststring.Apprase    = "FAIL *"
+			FailedTestCases = FailedTestCases + 1
+			LogCase (teststring)
+		endif
+
+end sub	
+
+'*****************************************************************************
+'Name   : EditLocationInfo 
+'Desc   : Enters data from location variable into My Location controls
+'			 Called by SetLocationsZero, AddLocation and ModifyLocation.
+'
+'Parms  : Location structure containing new location info 
+'			 Array of My Location child control handles
+'Return : None
+'
+'History: 02/15/96 : a-rrohr: Created
+'*****************************************************************************
+sub EditLocationInfo (NewLocal as location, hML_Child() as long)
+	
+	dim rtn as long
+
+	WComboSetText (_hwnd(hML_Child(LOCATION_cbo)), NewLocal.Location)
+	WComboItemClk (_hwnd(hML_Child(COUNTRY_cbo)), NewLocal.Country)
+	
+	WEditSetText  (_hwnd(hML_Child(AREA_txt)), NewLocal.AreaCode)
+	WEditSetText  (_hwnd(hML_Child(LOCAL_txt)), NewLocal.LocalAccess)
+	WEditSetText  (_hwnd(hML_Child(LONG_txt)), NewLocal.LongAccess)
+			
+
+	if (NewLocal.CardSet = Checked) then
+		WCheckSetFocus  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+		WCheckCheck  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+	else
+		WCheckSetFocus  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+		WCheckUnCheck  (_hwnd(hML_Child(CARD_chk)), TIMEOUT)
+	endif
+	
+	sleep .1
+
+	if (NewLocal.WaitSet = Checked) then
+		WCheckSetFocus  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+		WCheckCheck  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+'print "NewLocal.WaitSet = Checked is true"
+'print "Handle to Call waiting check box = ";hML_Child(WAIT_chk)	
+	else
+'print "NewLocal.WaitSet = Checked is False"
+'print "NewLocal.WaitSet = ";NewLocal.WaitSet
+		WCheckSetFocus  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+		WCheckUnCheck  (_hwnd(hML_Child(WAIT_chk)), TIMEOUT)
+	endif
+	
+	rtn = WOptionState (_hwnd(hML_Child(TONE_opt)))
+	if  rtn <> NewLocal.ToneSet then
+		WOptionClick  (_hwnd(hML_Child(TONE_opt)), TIMEOUT)
+	endif
+
+end sub 'EditLocationInfo
+
+'*****************************************************************************
+'Name   : CountryDialRules 
+'Desc   : Verifies the dialing rules of each country.
+'
+'Parms  : DialingRule() containg the Country dialing rule information 
+'			 IDs to the Dialing properties and My Location child windows
+'
+'Return : None
+'
+'History: 03/22/96 : a-rrohr: Created
+'*****************************************************************************
+Sub CountryDialRules (DialRule() as CountryRule, Prop_ChildID() as long, ML_ChildID() as long)
+
+'generic variables
+dim rtn as long, item as long, hDlg as long, hCtrl as long, Tempstring as string  
+'other variables
+dim count as long, startcount as short, endcount as short, w_flags as long
+dim WinSysDir as string, searchstr as string, startsearch as short, endsearch as short
+dim NumberToBeDialed as string 
+dim PhoneNo as TelephoneNo
+
+'handles	& IDs
+dim hTB20			  as long	'handle to TAPI Browser
+dim hList			  as long	'handle to TAPI Browser	API list box
+dim hProperties	  as long	'handle to Dialing Properties
+dim Prop_hChild(2)  as long	'handles to Dialing Properties child controls 
+dim hMyLocTab		  as long	  
+dim ML_hChild(14)   as long	'handles to Dialing Properties child controls
+dim hCardDlg		  as long 	'handle to Calling Card
+dim Card_hChild(6)  as long 	'handles to Calling Card child controls
+dim Card_ChildID(6) as long 	'IDs to Calling Card child controls
+dim hNewDlg			  as long 
+dim NEW_hChild(2)   as long 
+dim NEW_ChildID(2)  as long 
+dim hNewCtrl		  as long
+dim hRuleDlg		  as long
+dim Rule_hChild(4)  as long
+dim Rule_ChildID(4) as long 
+dim hRuleCtrl		  as long
+dim TAPI_API_List	  as long
+dim DV_OKcmd		  as long
+dim DV_list			  as long 
+dim DV_edit			  as long 
+dim hDVctrl			  as long
+
+'initialize varibles
+
+'********************** Delete Me *****************************
+dim countrylist (1 to 242) as itemlist
+for count = 1 to 242
+	countrylist(count).tested = false	
+next
+'**************************************************************
+
+SetCallingCardChildID (Card_ChildID, NEW_ChildID, Rule_ChildID, _
+							 DV_OKcmd, DV_list, DV_edit, TAPI_API_List)
+
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+          OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+startcount = Lbound(dialrule)
+endcount   = Ubound(dialrule)
+
+PhoneNo.AreaCode 		= "777"
+PhoneNo.SubscriberNo	= "9998888"
+
+WinSysDir = space$(32)
+rtn = GetSystemDirectory (WinSysDir, len(WinSysDir))
+
+
+
+'-- Start TAPI Browser and save handles
+
+if exists(WinSysDir + TAPI_BROWSER)	then
+	'run WinSysDir + "\cdb -g -G " + WinSysDir + TAPI_BROWSER, nowait
+	run WinSysDir + TAPI_BROWSER, nowait
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + WinSysDir + TAPI_BROWSER)
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto StopTestCase
+endif
+
+hTB20 = WFndWndC (TAPI_BROWSER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+sleep 1
+'PAUSE	"DIALING PPROPERTIES TEST" + CRLF + "New Set up PView and continue with the test" 
+
+'========================= START TEST LOOP ================================
+FOR COUNT = STARTCOUNT TO ENDCOUNT
+
+
+'-- Select Options / Default Values from menu and
+' Set Destination Address in TAPI Browser
+
+' the following line is here to better format the output log file
+WritelogItem ("" , " ")
+
+WMenuSelect (MOPTIONS + "\" + MDEFAULT, TIMEOUT)
+hDlg = WFndWndC (DEFAULT_VALUES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+sleep .1
+'Select lpszDestAddress
+hDVctrl	= GetDlgItem(hDlg, DV_list)
+if WListItemExists (_hwnd(hDVctrl), "line: lpszDestAddress", TIMEOUT) THEN
+	WListItemclk (_hwnd(hDVctrl), "line: lpszDestAddress", TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find line: lpszDestAddress in Default Option Parameter list")
+   logitem (CurrentLoggingLevel, "Ending Country Dialing Rules test")
+	goto StopTestCase
+end if
+
+'-- Enter Destination Address with country(count) code and close default values
+'Enter Destination Address (phone number) in edit control
+' I have to tab to the Edit box as both the Values edit box and the 
+' Bit flags list box have the same ID.
+
+play hDlg, "{TAB}"
+play hDlg, "{+}"+ ltrim$(str$(DialRule(count).code)) +"{(}"+ PhoneNo.AreaCode +"{)}" + PhoneNo.SubscriberNo
+
+'Close Dialog with OK
+hDVctrl	= GetDlgItem(hDlg, DV_OKcmd)
+WButtonClick  (_hwnd(hDVctrl), TIMEOUT)
+
+'-- Start dialing properties with lineTranslateDialog	and save handles
+
+Tempstring = space$(32)
+Tempstring = "Dialing Properties Test" + CRLF + "Country " + ltrim$(str$(count)) + " to " + ltrim$(str$(endcount))
+StatusBox tempstring, 5000, -1, 210, 50, FALSE, TRUE,"courier",9,400
+
+hList = GetDlgItem (hTB20, TAPI_API_List)
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Country Dialing Rules test")
+	goto StopTestCase
+endif	 
+
+'**************************************************************************
+
+'if count = 0 or count = 12 then
+'	Pause "Country Rules Pause, Count =" + Str$(count) + " Check Calling Cards"
+'endif
+
+'**************************************************************************
+
+' Get all Dialing Properties handles
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto StopTestCase
+endif
+		
+GetDPCtrlh (hProperties, Prop_hChild, Prop_ChildID)
+
+hMyLocTab = WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hMyLocTab = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + tab_MY_LOCATION + " Property Page")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto StopTestCase
+endif
+GetChildhandles (hMyLocTab, ML_hChild, ML_ChildID)
+
+'-- If country(count) code = 353 set "I am in:" = USA else set to Ireland.
+if DialRule(count).Code = 353 then	
+	WComboItemClk (_hwnd(ML_hChild(COUNTRY_cbo)), DialRule(1).Country, 1)
+end if
+
+'-- Set area code to 999
+WEditSetText  (_hwnd(ML_hChild(AREA_txt)), "777")
+
+'-- Veriy country(count)code is part of number to be dialed
+teststring.Expect_Res =  ltrim$(str$(DialRule(count).Code))
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempString, 63)
+searchstr = ltrim$(str$(DialRule(count).Code)) + " 777"
+startsearch = instr(1, tempstring, searchstr)
+
+if startsearch > 0 then 
+	endsearch = instr(startsearch, tempstring, " ")	
+	if endsearch > 0 then	
+		teststring.Actual_Res = mid$(tempstring, startsearch, endsearch - startsearch)
+	else
+		teststring.Actual_Res = tempstring
+	endif
+else
+	teststring.Actual_Res = tempstring
+end if
+
+	IF teststring.Actual_Res = teststring.Expect_Res  THEN
+		teststring.Apprase    = "Pass"
+		teststring.Expect_Res =  DialRule(count).Country + " code = " + teststring.Expect_Res
+	
+		LogCase (teststring)
+	else
+		teststring.Apprase    = "FAIL *"
+		teststring.Expect_Res =  DialRule(count).Country + " code = " + teststring.Expect_Res
+		FailedTestCases = FailedTestCases + 1
+		LogCase (teststring)
+	endif
+
+
+'-- Verify country(count) is listed in "I am in" combobox
+
+teststring.Expect_Res = DialRule(count).Country 
+TotalTestCases = TotalTestCases + 1
+rtn = WComboItemIndex (_hwnd(ML_hChild(COUNTRY_cbo)), DialRule(count).Country, 1)
+
+if rtn > 0 then
+	teststring.Actual_Res = DialRule(count).Country + " Index # =" + ltrim$(str$(rtn))
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = DialRule(count).Country + " Doesn't Exist" 
+	teststring.Apprase    = "FAIL *" + str$(rtn)
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'-- Set "I am in:" to Country under test
+if WComboItemIndex (_hwnd(ML_hChild(COUNTRY_cbo)), DialRule(count).Country, 1) then
+	WComboItemClk (_hwnd(ML_hChild(COUNTRY_cbo)), DialRule(count).Country, 1)
+endif
+
+'-- Veriy country(count)code is not part of number to be dialed
+'*****************************************************************************
+' Do not run this test if country is INMARSAT
+' By design of Dialing Properties they will all fail (Normal)
+'*****************************************************************************
+
+IF DialRule(count).Code < 870 OR DialRule(count).Code > 874 THEN
+	'teststring.Expect_Res =  ltrim$(str$(DialRule(count).Code))
+	TotalTestCases = TotalTestCases + 1
+
+	TempString = string$(64, str$(0))
+	rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempString, 63)
+	searchstr = ltrim$(str$(DialRule(count).Code)) + " 777"
+	startsearch = instr(1, tempstring, searchstr)
+
+	if startsearch = 0 then 
+		teststring.Apprase    = "Pass"
+		teststring.Actual_Res = "777"
+		teststring.Expect_Res =  "777"
+	else
+		teststring.Apprase    = "FAIL *"
+		teststring.Actual_Res = searchstr
+		teststring.Expect_Res =  "No code in Dial string"
+		FailedTestCases = FailedTestCases + 1
+	endif
+	LogCase (teststring)
+
+END IF 'DialRule(count).Code) < 870 OR DialRule(count).Code) > 874
+'*****************************************************************************
+' Do not run the following tests if country is International FreePhone
+' By design of Dialing Properties they will all fail (Normal)
+'*****************************************************************************
+
+IF DialRule(count).code <> 800 THEN 
+
+'-- Verify local Number to be dialed
+PhoneNo.CountryCode = DialRule(count).code
+NumberToBeDialed = CreateDestAddress ((DialRule(count).LocalRule), PhoneNo)
+tempstring =  EditText (_hwnd ( ML_hChild( LOCAL_txt )), TIMEOUT)
+if tempString <> "" then
+	NumberToBeDialed = tempstring + " " + NumberToBeDialed
+endif
+teststring.Expect_Res =  NumberToBeDialed
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempString, 63)
+
+if TempString = teststring.Expect_Res then 
+	teststring.Actual_Res = "Local Number OK" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	teststring.Actual_Res = TempString 
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+'** Verify long distance Number to be dialed
+
+WEditSetText  (_hwnd(ML_hChild(AREA_txt)), "333")
+NumberToBeDialed = CreateDestAddress ((DialRule(count).LongRule), PhoneNo)
+
+if DialRule(count).LongRule = "" then	  'There is no long distance dialing rule
+	tempstring = EditText (_hwnd ( ML_hChild( LOCAL_txt )), TIMEOUT)
+	if tempstring <> "" then
+		NumberToBeDialed = tempstring + " " + NumberToBeDialed
+	endif
+else	
+	tempstring = EditText (_hwnd ( ML_hChild( LONG_txt )), TIMEOUT)
+	if tempstring <> "" then
+		NumberToBeDialed = tempstring + " " + NumberToBeDialed
+	endif
+endif
+
+teststring.Expect_Res =  NumberToBeDialed
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempString, 63)
+
+if TempString = teststring.Expect_Res then 
+	teststring.Actual_Res = "Long Distance Number OK" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	teststring.Actual_Res = TempString 
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+'** Verify International Number to be dialed	**************************************
+'close dialing properties
+WButtonClick (_hwnd(Prop_hChild(DP_CANCELcmd)))	'Close dialing properties
+
+'set lpszDestAddress to a country other that the country under test
+WMenuSelect (MOPTIONS + "\" + MDEFAULT, TIMEOUT)
+hDlg = WFndWndC (DEFAULT_VALUES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+sleep .1
+'Select lpszDestAddress
+hDVctrl	= GetDlgItem(hDlg, DV_list)
+if WListItemExists (_hwnd(hDVctrl), "line: lpszDestAddress", TIMEOUT) THEN
+	WListItemclk (_hwnd(hDVctrl), "line: lpszDestAddress", TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find line: lpszDestAddress in Default Option Parameter list")
+   logitem (CurrentLoggingLevel, "Ending Country Dialing Rules test")
+	goto StopTestCase
+end if
+
+select case DialRule(count).code
+	'countries that share the same code 
+	case 1, 7, 33, 41, 42, 53, 61, 269, 590, 670, 672
+		PhoneNo.CountryCode = 353	'Ireland
+	case	DialRule(endcount).code
+		PhoneNo.CountryCode = 1   'USA
+	case else
+		PhoneNo.CountryCode = DialRule(count+1).code   'Next country
+end select
+
+play hDlg, "{TAB}"
+play hDlg, "{+}"+ ltrim$(str$(PhoneNo.CountryCode)) +"{(}"+ PhoneNo.AreaCode +"{)}" + PhoneNo.SubscriberNo
+
+'Close Dialog with OK
+hDVctrl	= GetDlgItem(hDlg, DV_OKcmd)
+WButtonClick  (_hwnd(hDVctrl), TIMEOUT)
+
+'** Start Dialing Properties
+hList = GetDlgItem (hTB20, TAPI_API_List)
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Country Dialing Rules test")
+	goto StopTestCase
+endif	 
+
+' Get all Dialing Properties handles
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto StopTestCase
+endif
+		
+GetDPCtrlh (hProperties, Prop_hChild, Prop_ChildID)
+
+hMyLocTab = WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, w_flags, WTIMEOUT)
+if hMyLocTab = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + tab_MY_LOCATION + " Property Page")
+   logitem (CurrentLoggingLevel, "Ending Validate Calling Cards test")
+	goto StopTestCase
+endif
+GetChildhandles (hMyLocTab, ML_hChild, ML_ChildID)
+
+'** Set location to country to be tested and verify Number to be dialed
+WComboItemClk (_hwnd(ML_hChild(COUNTRY_cbo)), DialRule(count).Country, 1)
+NumberToBeDialed = CreateDestAddress ((DialRule(count).InterRule), PhoneNo)
+tempstring = EditText (_hwnd ( ML_hChild( LONG_txt )), TIMEOUT)
+if tempString <> "" then
+	NumberToBeDialed = tempstring + " " + NumberToBeDialed
+endif
+
+teststring.Expect_Res =  NumberToBeDialed
+TotalTestCases = TotalTestCases + 1
+
+TempString = string$(64, str$(0))
+rtn = GetDlgItemText (hMyLocTab, ML_ChildID(ADDRESS_LBL), TempString, 63)
+
+if TempString = teststring.Expect_Res then 
+	teststring.Actual_Res = "International Number OK" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	teststring.Actual_Res = TempString 
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+'*********************************************************
+
+'-- Select Change and add a calling card.
+
+WButtonClick (_hwnd(ML_hChild(CHANGE_cmd)))	'Open Change Calling Card dialog
+hCardDlg = WFndWndC (CHANGE_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hCardDlg, Card_hChild, Card_ChildID) 
+
+' Add a new card
+WButtonClick (_hwnd(Card_hChild(CARD_NEWcmd)))
+hNewDlg = WFndWndC (NEW_CARD_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+hNewCtrl = GetDlgItem (hNewDlg, NEW_ChildID(NEW_NAMEtxt))
+WEditSetText (_hwnd(hNewCtrl), DialRule(count).Country, TIMEOUT)
+
+hNewCtrl = GetDlgItem (hNewDlg, NEW_ChildID(NEW_OKcmd))
+WButtonClick (_hwnd(hNewCtrl))				               'Close Create New Calling Card
+
+' Get Handle to Dialing Properties Message & click OK button
+w_flags = FW_ALL OR FW_CHILDOK OR FW_PART OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+hCtrl = WFndWndC ("You Now Must", "Static", w_flags, WTIMEOUT)
+hDlg  = GetParent (hCtrl)
+hCtrl = GetDlgItem (hDlg, &h0002&)		'Get Handle to OK button
+WButtonClick (_hwnd(hCtrl), TIMEOUT)
+
+'reset window search flag
+w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+
+' Look for 'Improper Character Entered' message and click OK if it appears
+
+hDlg = WFndWndC (IMPROPER_CHAR_CAPTION, DIALOG_CLASS, w_flags, 1)
+if hDlg <> 0 then
+	hCtrl = GetDlgItem (hDlg, &h0002&)		'Get Handle to OK button
+	WButtonClick (_hwnd(hCtrl), TIMEOUT)
+   logitem (CurrentLoggingLevel, IMPROPER_CHAR_CAPTION + " Dialog has appeared and was closed")
+   logitem (CurrentLoggingLevel, "This dialog appeared because of an invalid dialing rule character")
+   logitem (CurrentLoggingLevel, "is in the default dialing rules. This is an error with  Dialing Properties")
+	FailedTestCases = FailedTestCases + 1
+endif	
+
+'Verify that the Dialing Rules dialog appears, enter dialing rules and close
+
+hRuleDlg = WFndWndC (DIAL_RULE_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+GetChildhandles (hRuleDlg, Rule_hChild, Rule_ChildID) 
+
+'--Verify Country Dialing Rules
+
+' Verify local rule
+teststring.Expect_Res = ConvertRule((DialRule(count).LocalRule)) 
+TotalTestCases = TotalTestCases + 1
+
+teststring.Actual_Res = string$(32, str$(0))
+teststring.Actual_Res = EditText (_hwnd(Rule_hChild(Rule_LOCALtxt)), TIMEOUT)
+
+IF teststring.Actual_Res = teststring.Expect_Res  THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+' Verify Long Distance rule
+teststring.Expect_Res = ConvertRule((DialRule(count).LongRule))
+TotalTestCases = TotalTestCases + 1
+
+teststring.Actual_Res = string$(32, str$(0))
+teststring.Actual_Res = EditText (_hwnd(Rule_hChild(Rule_LONGtxt)), TIMEOUT)
+
+IF teststring.Actual_Res = teststring.Expect_Res  THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+teststring.Expect_Res = ConvertRule((DialRule(count).InterRule))
+TotalTestCases = TotalTestCases + 1
+
+teststring.Actual_Res = string$(32, str$(0))
+teststring.Actual_Res = EditText (_hwnd(Rule_hChild(Rule_INTERtxt)), TIMEOUT)
+
+IF teststring.Actual_Res = teststring.Expect_Res  THEN
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+endif
+
+' Close Dialing Rules dialog
+WButtonClick (_hwnd(Rule_hChild(Rule_CLOSEcmd)), TIMEOUT)
+
+'-- Remove the calling card and close calling card dialog
+
+' Set focus on New Calling Card
+WComboItemClk (_hwnd(Card_hChild(Card_Namecbo)), DialRule(count).Country, timeout)
+
+' Click Remove button 
+
+WButtonClick (_hwnd(Card_hChild(Card_REMOVEcmd)))
+
+'Find 'Are You Sure' dailog, get handle to yes button and click it.
+hDlg = WFndWndC (REALLY_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+hCtrl = GetDlgItem (hDlg, &h0006&) 
+WButtonClick (_hwnd(hCtrl))
+
+'Close 'Change Calling Card' dialog with OK button
+WButtonClick (_hwnd(Card_hChild(Card_OKcmd)))
+
+'-- Reset Country Location to USA or Ireland as required.
+
+END IF 'DialRule(count).code <> 800 
+
+WButtonClick (_hwnd(Prop_hChild(DP_CANCELcmd)))	'Close dialing properties
+
+'-- Close Dialing properties
+'if count =100 or count = 200 then
+'	PAUSE	"DIALING PPROPERTIES TEST" + CRLF + "Count = " + ltrim$(str$(count))
+'endif
+next 'count
+
+rtn = SetActiveWindow (hTB20)					   'Make sure TB20 is the active window
+WMenuSelect	(MFILE + "\" + MEXIT, TIMEOUT)	'Exit TB20
+
+
+'PAUSE	"DIALING PPROPERTIES TEST" + CRLF + "TAPI Browser will close when OK is selected" 
+
+'============================== END TEST LOOP ================================
+
+StatusBox Close
+
+StopTestCase:
+end Sub 'CountryDialRules ()
+
+'*****************************************************************************
+'Name   : RemoveLocation 
+'Desc   : Verifies the functionality of Removing locations.
+'			 
+'Parms  : ML_hChild: array holding the handles to the My Location controls 
+'			 Prop_hChild() array holding handles to the Dialing Prop controls
+'			 CmdButton Boolean to select OK or Cancel Button.
+'
+'Return : String containing last location name
+'
+'History: 02/23/96 : a-rrohr: Created
+'*****************************************************************************
+Function RemoveLocation (Prop_hChild() as long, ML_hChild() as long, _
+								 CmdButton as short) as string
+
+dim LocationText as string
+dim LastLocationText as string
+dim count as long
+dim item as long
+dim RemoveState as short
+
+' Find and save the number of combobox items
+count = WComboCount (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+'print "The number of items in the Location combobox = ";count
+
+' Verify Remove button is enabled otherwise end the test
+teststring.Expect_Res =  cmd_REMOVE + " is enabled" 
+TotalTestCases = TotalTestCases + 1
+	
+if WButtonEnabled (_hwnd(ML_hChild(REMOVE_cmd)), TIMEOUT) then
+	teststring.Actual_Res = cmd_REMOVE + " is enabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = cmd_REMOVE + " is Not Enabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+   logitem (CurrentLoggingLevel, "Remove Locations test case is terminated")
+	Goto TheEnd
+endif
+
+'Click the last item, save the location name, click the Remove button
+'butdo not remove
+
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), _ord(count), TIMEOUT)
+LocationText = space$(96)
+LocationText = ComboText (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+
+teststring.Expect_Res = LocationText + " is not deleted" 
+TotalTestCases = TotalTestCases + 1
+
+WButtonClick (_hwnd(ML_hChild(REMOVE_cmd)), TIMEOUT)
+RemoveState = FALSE
+FindRemLocMessage (RemoveState)
+
+if WComboItemIndex (_hwnd(ML_hChild(LOCATION_cbo)), LocationText, TIMEOUT) then
+	teststring.Actual_Res = LocationText + " still exists"
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = LocationText + " is deleted" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+'Click the last item, save the location name and then remove
+
+WComboItemClk (_hwnd(ML_hChild(LOCATION_cbo)), _ord(count), TIMEOUT)
+LocationText = space$(96)
+LocationText = ComboText (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+
+teststring.Expect_Res = LocationText + " is deleted" 
+TotalTestCases = TotalTestCases + 1
+
+WButtonClick (_hwnd(ML_hChild(REMOVE_cmd)), TIMEOUT)
+RemoveState = TRUE
+FindRemLocMessage (RemoveState)
+
+if WComboItemIndex (_hwnd(ML_hChild(LOCATION_cbo)), LocationText, TIMEOUT) then
+	teststring.Actual_Res = LocationText + " still exists"
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+else
+	teststring.Actual_Res = LocationText + " is deleted" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+end if
+
+'The current location should now be the first location
+teststring.Expect_Res = "Current Location index = 1" 
+TotalTestCases = TotalTestCases + 1
+
+item = WComboIndex (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+If (item = 1) then
+	teststring.Actual_Res = "Current location Index = " + str$(item)
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else 
+	teststring.Actual_Res = "Current location Index = " + str$(item)
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+LastLocationText = space$(96)
+LastLocationText = ComboItemText (_hwnd(ML_hChild(LOCATION_cbo)), (count-1), TIMEOUT)
+
+'Remove all locations but the last 
+while (WComboCount (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT) > 1)
+	WButtonClick (_hwnd(ML_hChild(REMOVE_cmd)), TIMEOUT)
+RemoveState = TRUE
+FindRemLocMessage (RemoveState)
+Wend
+
+' Verify Remove button is disabled otherwise end the test
+teststring.Expect_Res =  cmd_REMOVE + " is disabled" 
+TotalTestCases = TotalTestCases + 1
+	
+if Not(WButtonEnabled (_hwnd(ML_hChild(REMOVE_cmd)), TIMEOUT)) then
+	teststring.Actual_Res = cmd_REMOVE + " is disabled" 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = cmd_REMOVE + " is Not Disabled" 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+   logitem (CurrentLoggingLevel, "Remove Locations test case is terminated")
+	Goto TheEnd
+endif
+
+'Verify current location is the last location
+'then return the text of the location
+LocationText = space$(96)
+LocationText = ComboText (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+
+teststring.Expect_Res =  "Current Location = " + LastLocationText
+TotalTestCases = TotalTestCases + 1
+
+if (LastLocationText = LocationText) then
+	teststring.Actual_Res = "Current Location = " + LocationText 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Current Location = " + LocationText 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+RemoveLocation = LocationText
+
+If CmdButton then
+	WButtonClick (_hwnd(Prop_hChild(DP_OKcmd)), TIMEOUT)
+else
+	WButtonClick (_hwnd(Prop_hChild(DP_CANCELcmd)), TIMEOUT)
+end if
+
+TheEnd:
+end Sub 'RemoveLocations
+
+'*****************************************************************************
+'Name   : VerifyRemoveLoc 
+'Desc   : Verifies that locations removed from Dialing Properties 
+'			 (and Dialing Properties is closed with the OK button) are actually remove 
+'			 when Dialing Properties is opened again, 
+'			 
+'Parms  : ML_hChild: array holding the handles to the My Location controls 
+'			 Prop_hChild() array holding handles to the Dialing Prop controls
+'			 Locstring: Text of current location when Dialing Properties is closed
+'
+'Return : None
+'
+'History: 02/23/96 : a-rrohr: Created
+'*****************************************************************************
+sub VerifyRemoveLoc (ML_hChild() as long, Locstring as string)
+
+dim LocationText as string
+dim count as long
+
+LocationText = space$(96)
+LocationText = ComboText (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+
+teststring.Expect_Res =  "Current Location = " + LocationText
+TotalTestCases = TotalTestCases + 1
+
+if (LocationText = Locstring) then
+	teststring.Actual_Res = "Current Location = " + Locstring 
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+else
+	teststring.Actual_Res = "Current Location = " + Locstring 
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+end if
+
+count = WComboCount (_hwnd(ML_hChild(LOCATION_cbo)), TIMEOUT)
+
+teststring.Expect_Res = "Location item count = 1" 
+TotalTestCases = TotalTestCases + 1
+
+If (Count <> 1) then
+	teststring.Actual_Res = "Location item count = " + str$(count)
+	teststring.Apprase    = "FAIL *"
+	FailedTestCases = FailedTestCases + 1
+	LogCase (teststring)
+else 
+	teststring.Actual_Res = "Location item count = " + str$(count)
+	teststring.Apprase    = "Pass"
+	LogCase (teststring)
+end if
+
+end sub 'VerifyRemoveLoc
+
+'*****************************************************************************
+'Name   : FindRemLocMessage
+'
+'Desc   : As of build 1261 Removing a location by clicking the Remove button
+'			 opens a message box asking the user if he really wants to remove the 
+'			 location. This function detects the message box and closes it with 
+'			 the appropriate button.
+'			 Can't blame the developer as this fixes a "bug" in Raid.
+'			 
+'Parms  : None
+'			 
+'Return : None
+'
+'History: 03/07/96 : a-rrohr: Created
+'*****************************************************************************
+sub FindRemLocMessage (RemoveState as short)
+
+	dim w_flags as long            
+	dim hWnd as long, hButton as long
+	dim Yes_CmdID as long, No_CmdID as long
+
+   w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE 'FW_PART OR 
+
+Yes_CmdID = &h00000006&
+No_CmdID	 = &h00000007&
+
+'Get the handle to the static message field
+hWnd = WFndWndC ("Are You Sure?", DIALOG_CLASS, w_flags, TIMEOUT)
+
+'Get the static message parent handle (the message box handle) 
+if hWnd > 0 then
+	If RemoveState Then
+		hButton = GetDlgItem (hWnd, Yes_cmdID)
+	else
+		hButton = GetDlgItem (hWnd, No_cmdID)
+	end if
+else
+   logitem (CurrentLoggingLevel, "FindRemLocMessage Procedure")
+   logitem (CurrentLoggingLevel, "Invalid handle to 'Are You Sure?' message box")
+   logitem (CurrentLoggingLevel, "Test Will Terminate")
+   Stop
+endif
+
+'Close the Message box
+if hButton > 0 then
+	WButtonClick (_hwnd(hButton), TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "FindRemLocMessage Procedure")
+	if RemoveState then
+		logitem (CurrentLoggingLevel, "Invalid handle to New Location message box Yes button")
+   else
+		logitem (CurrentLoggingLevel, "Invalid handle to New Location message box No button")
+   endif
+	logitem (CurrentLoggingLevel, "Test Will Terminate")
+   Stop
+endif
+
+end sub'FindRemLocMessage
+
+'*****************************************************************************
+'Name   : SetCallingCardChildID
+'
+'Desc   : Sets IDs for use in calling card and country dialing rule test
+'			 
+'Parms  : Card_ChildID()	Calling Card dialog control IDs 
+'			 NEW_ChildID()		Create New Calling Card dialog control IDs
+'			 Rule_ChildID()	Dialing Rules dialog control IDs 
+'			 DV_OKcmd			Default Value OK button
+'			 DV_list 			Default Value parameters list box
+'			 DV_edit 			Default Value value edit box
+'			 TAPI_API_List  	TAPI API list box
+'			 
+'Return : None
+'
+'History: 03/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+sub SetCallingCardChildID (Card_ChildID() as long, NEW_ChildID() as long, _ 
+								  Rule_ChildID() as long, DV_OKcmd as long, _ 
+								  DV_list as long, DV_edit as long, TAPI_API_List as long)
+
+'ID to the Default Values child controls 
+
+DV_OKcmd	= &h00000001&
+DV_list  = &h000003E8&
+DV_edit  = &h000003E9&
+
+'ID to the TAPI Browser list box control listing all the TAPI API functions 
+
+TAPI_API_List	= &h000003E9&
+
+'ID to the Change Calling Card child controls 
+
+Card_ChildID(CARD_OKcmd)		 = &h00000001&
+Card_ChildID(CARD_CANCELcmd)	 = &h00000002&
+Card_ChildID(CARD_NAMEcbo)		 = &h00001770&
+Card_ChildID(CARD_NUMBERtxt)	 = &h00001771&
+Card_ChildID(CARD_NEWcmd)		 = &h00001773&
+Card_ChildID(Card_RULEScmd)	 = &h00001775&
+Card_ChildID(CARD_REMOVEcmd)	 = &h00001774&
+
+'ID to the Change Calling Card child controls 
+
+NEW_ChildID(NEW_OKcmd)			 = &h00000001&
+NEW_ChildID(NEW_CANCELcmd)		 = &h00000002&				
+NEW_ChildID(NEW_NAMEtxt)		 = &h00001F41&
+
+'ID to the Dialing Rules child controls
+ 
+Rule_ChildID(Rule_CLOSEcmd) = &h00000001&
+Rule_ChildID(Rule_COPYcmd)	 = &h000003FE&
+Rule_ChildID(Rule_LOCALtxt) = &h00000400&
+Rule_ChildID(Rule_LONGtxt)  = &h00000401&
+Rule_ChildID(Rule_INTERtxt) = &h00000402&
+
+end sub 'SetCallingCardChildID
+
+'*****************************************************************************
+'Name   : CreateDestAddress 
+'
+'Desc   : Creates destination addresses based on the local and long distance
+'			 dialing rules of the country under test and an international 
+'			 destination address based on the dialing rule of the next country 
+'			 under test
+'			 
+'Parms  : A structure containing the area code and phone number
+'			 A structure containing	the dialing rules.
+'			 
+'Return : A structure containing the three destination address.
+'
+'History: 03/22/96 : a-rrohr: Created
+'*****************************************************************************
+
+function CreateDestAddress (Rule as string, phone as TelephoneNo ) as string
+
+dim tempstr as string
+dim char as string
+dim count as short
+dim LeadingSpace as long
+
+LeadingSpace = FALSE
+COUNT = 0
+if Rule = "" then 
+ tempstr = phone.SubscriberNo
+else
+ while  len(RULE) > 0
+
+	char = space$(1)
+	char = mid$(rule, 1, 1)
+	RULE = right$(rule, len(rule) - 1)
+
+	select case char
+
+		case  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
+			Tempstr = Tempstr + char
+ 		case  "A", "B", "C", "D", "*"
+			Tempstr = Tempstr + char
+		case "#"
+			Tempstr = Tempstr + " " + char
+		case " "
+			Tempstr = Tempstr + char
+			if count = 0 then
+				LeadingSpace = TRUE
+			endif
+		case ",", "W"
+			'ignore
+		case  "E"
+			Tempstr = Tempstr + " " + ltrim$(str$(Phone.CountryCode))
+		case  "F"
+			Tempstr = Tempstr + " " + Phone.AreaCode
+		case  "G"
+			Tempstr = Tempstr + " " + Phone.SubscriberNo
+		case  "I"
+			Tempstr = Tempstr + " " + Phone.AreaCode
+		case else 
+				Tempstr = Tempstr + char 'should show as an error
+
+	end select
+	COUNT = COUNT + 1
+  Wend
+ endif
+ 
+ IF LeadingSpace THEN
+	CreateDestAddress = tempstr
+ else
+	CreateDestAddress = ltrim$(tempstr)
+ endif
+ end function	'CreateDestAddress
+
+'*****************************************************************************
+'Name   : ConvertRule 
+'
+'Desc   : Converts a dialing rules of the country under test to the format 
+'			 expected in the dialing rules dialog. That is it converts I to F.
+'			 
+'Parms  : The dialing rule of interest
+'			 
+'Return : The converted dialing rule .
+'
+'History: 04/05/96 : a-rrohr: Created
+'*****************************************************************************
+
+function ConvertRule (Rule as string) as string
+
+dim tempstr as string
+dim char as string
+
+ tempstr = Space$(10)
+ tempstr = ""
+
+ if RULE <> ""	then
+	while  len(RULE) > 0
+
+	 	char = space$(1)
+		char = mid$(rule, 1, 1)
+		RULE = right$(rule, len(rule) - 1)
+
+		select case char
+
+			case  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
+				Tempstr = Tempstr + char
+			case  "A", "B", "C", "D", "*", " ", "#", ","
+				Tempstr = Tempstr + char
+			case ","
+				'ignore
+			case  "E", "F", "G"
+				Tempstr = Tempstr + char
+			case  "I"
+				Tempstr = Tempstr + "F"
+			case else 
+					Tempstr = Tempstr + char 'should show as an error
+
+		end select
+
+	Wend
+
+ endif
+
+ConvertRule	= tempstr
+
+end function  'ConvertRule
+
+
+'*****************************************************************************
+'Name   : lTranslateDialog
+'Desc   : Invokes the Dialing Properties dialog with TAPI Browser 2.0 
+'			 lineTranslateDialog call. The function returns the handle to the
+'         Dialing Properties dialog, the My Location Tab, and TAPI Browser.
+'			 This function was derived from Call_Dialing_Prop function 
+'
+'Parms  : Passed 3 variables to store the handles to the Tab Control, 
+'			 My Location Tab and TAPI Browser
+'
+'Return : Returns the Handle to the Dialing Properties dialog
+'
+'History: 05/23/96: a-rrohr: Created
+'*****************************************************************************
+
+Function lTranslateDialog ( hMLTab as long, hTB20 as long) as long
+
+   dim hdialog as long				'Generic window handle
+   dim hProperties as long			'Handle of Dialing Properties dialog, function rtns this value
+   dim hctrl as long					'Generic Handle to Control
+   dim teststring as casestruct	'Test Log Info
+   dim SysDirPath as string		'Path to system32 directory
+	dim rtn as long					'Generic return variable
+	dim TAPI_API_List as long		'ID of TB API list box
+   dim OK_cmdID as long
+   dim StaticID as long
+   dim messagestr as string
+	dim hDlg as long, hList as long
+
+	TAPI_API_List	= &h000003E9&
+	OK_cmdID       = &h00000001&
+	w_flags = FW_ALL OR FW_CHILDOK OR FW_DIALOGOK OR FW_EXIST _
+             OR FW_NOERROR OR FW_FOCUS OR FW_NOCASE  
+	
+	SysDirPath = space$(MAX_PATH)
+	rtn = GetSystemDirectory (SysDirPath, MAX_PATH)
+	lTranslateDialog = 0
+' If a pre-existing instance of dialing properties exists close it with an OK button click
+   hdialog =  WFndWnd (PROPERTIES_CAPTION, FW_EXIST, WTIMEOUT)
+	if hdialog <> 0 then
+		hctrl = GetDlgItem (hdialog, OK_cmdID)
+		WButtonClick (_hwnd(hctrl))				'Click the Dialing Properties OK button
+		sleep 1
+	end if
+
+'-- Start TAPI Browser and save handles
+if hTB20 = 0 then
+	if exists(SysDirPath + TAPI_BROWSER)	then
+		run SysDirPath + TAPI_BROWSER, nowait
+	else
+		logitem (CurrentLoggingLevel, "Unable to Find " + SysDirPath + TAPI_BROWSER)
+	   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+		goto StopTestCase
+	endif
+
+	hTB20 = WFndWndC (TAPI_BROWSER_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+
+'Look for the "Using the TAPI Browser" dialog. This dialog appears automatically
+'the first time TB is invoked and never again. it must be closed before the test
+'can proceed.
+
+	hDlg = WFndWndC (USING_TB_CAPTION, DIALOG_CLASS, w_flags, 5)
+
+	if hDlg > 0 then
+	'Get handle to Using the TAPI Browser OK button and close dialog
+		hCtrl	= GetDlgItem(hDlg, OK_cmdID)	 
+		WButtonClick  (_hwnd(hCtrl), TIMEOUT)
+	end if
+
+endif 'hTB20 = 0
+	
+hList = GetDlgItem (hTB20, TAPI_API_List)
+
+if WListItemExists (_hwnd(hList), lineTranDlg_API, TIMEOUT)	then
+	WListItemDblClk (_hwnd(hList), lineTranDlg_API, TIMEOUT)
+else
+   logitem (CurrentLoggingLevel, "Unable to Find " + lineTranDlg_API + " in TB20 listbox")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto StopTestCase
+endif	 
+
+'** Get Handles to Dialing Properties, My Location and all child controls
+
+hProperties = WFndWndC (PROPERTIES_CAPTION, DIALOG_CLASS, w_flags, WTIMEOUT)
+lTranslateDialog = hProperties
+if hProperties = 0 then
+   logitem (CurrentLoggingLevel, "Unable to Find " + PROPERTIES_CAPTION + " Window")
+   logitem (CurrentLoggingLevel, "Ending Call Waiting test")
+	goto StopTestCase
+endif
+
+' Get and validate My Location Tab handle
+
+	hMLTab  =  WFndWndC (tab_MY_LOCATION, DIALOG_CLASS, W_Flags, WTIMEOUT)
+   TotalTestCases = TotalTestCases + 1
+   teststring.TC_Num =  34
+   teststring.Expect_Res = "Valid My Location Handle"
+   teststring.Actual_Res = "Tab Handle =" + Str$(hMLTab)
+
+   if hMLTab = 0 then
+      teststring.Apprase    = "FAIL *"
+      FailedTestCases = FailedTestCases + 1
+      LogCase (teststring)
+   else
+      teststring.Apprase    = "Pass"
+      LogCase (teststring)
+   endif
+
+StopTestCase:
+end function 'lTranslateDialog
+
+'$ENDIF
\ No newline at end of file
diff --git a/private/tapi/qa/dialingp/dp32.ini b/private/tapi/qa/dialingp/dp32.ini
new file mode 100644
index 000000000..c493f4680
--- /dev/null
+++ b/private/tapi/qa/dialingp/dp32.ini
@@ -0,0 +1,65 @@
+[Language]
+
+Language= USA_ENG
+
+[Menu Strings]
+
+MFILE= &File
+MEXIT= E&xit
+MTOOLS = &Tools
+MDIAL_PROPERTIES= &Dialing Properties...
+MOPTIONS = &Options
+MDEFAULT = &Default values...
+
+[Caption Strings]
+
+DIALER_CAPTION= Phone Dialer
+PROPERTIES_CAPTION= Dialing Properties
+LOCATION_CAPTION= Location Information
+CONNECT_USE_CAPTION= Connect Using
+WARNING_BOX_CAPTION= Warning
+TB20_CAPTION = TAPI32 Browser
+USING_TB_CAPTION = Using the TAPI Browser
+REALLY_CAPTION = Are You Sure?
+CHANGE_CARD_CAPTION = Change Calling Card
+NEW_CARD_CAPTION = Create New Calling Card
+DEFAULT_VALUES_CAPTION = Default values
+DIAL_RULE_CAPTION = Dialing Rules
+NO_PIN_CAPTION = Required Entry Not Made
+COPY_RULE_CAPTION = Copy Dialing Rules
+IMPROPER_CHAR_CAPTION = Improper Character Entered
+
+[Window Classes]
+
+PHONE_DIALER_CLASS = #32770
+
+[Dialing Properties Control Labels]
+
+tab_MY_LOCATION= My Locations
+tab_TEL_DRV= Telephony Drivers
+
+cmd_NEW= &New...
+cmd_REMOVE= &Remove
+cmd_CHANGE= C&hange...
+cmd_OK= OK
+cmd_Cancel= Cancel
+cmd_Apply= &Apply
+
+txt_LOCAL= for local,
+txt_LONGDIST= for long distance.
+txt_AREACODE= The area &code is:
+
+cbo_DIALINGFROM = I am &dialing from:
+cbo_IAMIN= &I am in:
+
+opt_TONE= &Tone dialing
+opt_PULSE= &Pulse dialing
+
+chk_CARD= Dial &using Calling Card:
+chk_WAITING= This location has call &waiting. To disable it, dial:
+
+lable_ACCESS= To access an &outside line, first dial:
+lable_OPT_BTN= The phone system at this location uses:
+lable_FRM_WHERE= Where I am:
+lable_FRM_HOW= How I dial from this location:
+lable_DIR_DIAL= None (Direct Dial)
\ No newline at end of file
diff --git a/private/tapi/qa/dialingp/dp32.mst b/private/tapi/qa/dialingp/dp32.mst
new file mode 100644
index 000000000..5972d4eb9
--- /dev/null
+++ b/private/tapi/qa/dialingp/dp32.mst
@@ -0,0 +1,353 @@
+'******************************************************************************
+
+' DP32.mst
+' This test scripts validates the operation of the Dialing Properties 
+' TAPI component
+
+' Ronald Rohr
+' January 03, 1996
+
+' Status = Pre-Test Design Review, Pre-Code Review
+' Version = 0.1
+
+' A description of the Test Cases Can be found in TCM, Server: lostpup,
+' Database: TAPICASES, Tree: Dialing Properties.
+' Logon with ID & Password = Tapicase (read only privlages) 
+
+' To run this test the command$ variable must be set to the path of the DP32.ini
+' file otherwise the test will use default english strings.
+'******************************************************************************
+
+'******************************************************************************
+
+'                    TEST CASE LIST  (in order of execution)
+
+'  TC - 33  Start Phone Dialer Application
+'  TC - 35  Set Language Strings
+'  TC - 34  Invoke Dialing Properties Window
+'  TC - 46  Verify Language Strings
+'  TC - 41  Add Locations
+'  TC - 84  Modify a Location
+'  TC - 45  Verify Calling Cards
+'  TC - 37	Country Dialing Rules
+'  TC - 85  Remove a Location
+
+'$INCLUDE 'declares.inc'
+
+option base 0
+
+	Const TEST_SCRIPT_TITLE = "Dialing Properties Test"   'Test Script Name
+	Const TEST_SCRIPT_VERSION = "4/15/96"                 'Test Script Version
+	Const TEST_APP    = "Dialer.exe"                      'File name of the Application Under Test
+	Const TIMEOUT = 3                                     'Timeout value for MSTest APIs
+
+	Global Test_Logfile as string		'Results Log File Name
+
+
+   '$include 'Tapilog.inc'          'required for all common file I/O procedures
+   '$include 'DP32.inc'             'Functions and Constants used by DP32.MST
+
+   dim hPhoneDialer as long         ' Handle to main Dialer window
+   dim hProperties as long          ' Handle to Dialing Properties dialog
+   dim hParentTab as long           ' Handle to Dialing Properties Tab Control
+   dim hMyLocTab as long				' Handle to Dialing Properties My Location tab
+   dim hTelDrvTab as long				' Handle to Dialing Properties Telephone Drivers tab
+   dim hDPcmdOK as long					' Handle to Dialing Properties OK command button
+   dim hDPcmdCancel as long			' Handle to Dialing Properties Cancel command button
+   dim hDPcmdApply as long				' Handle to Dialing Properties Apply command button
+   dim Prop_hCtrl(2)	as long			' Array of handles to the Dialing Properties child controls 
+   dim Prop_CtrlID (2) as long		' Array My Location Tab child controls IDs
+   dim ML_hCtrl (15) as long			' Array of handles to the My Location Tab child controls
+   dim ML_CtrlID (15) as long			' Array My Location Tab child controls IDs
+   dim TD_hCtrl (3) as long			' Array of handles to the Telephony Drivers Tab child controls
+   dim TD_CtrlID (3) as long			' Array Telephony Drivers Tab child controls IDs
+	dim rtn as long                  ' Generic long function return value
+   dim ret as integer               ' Generic integer function return value
+   dim rtnstring as string				' Generic string function return value
+	dim ErrorMessage  as string      ' Error Message string for On Error Procedure
+	dim InitialLoc as Location			' Initial location Information
+	dim Redmond as Location				' Location Information for location test
+	dim Ireland as Location				' Ditto
+	dim Chicago as Location				' Ditto
+
+'************************ End Variable Declarations *******************
+
+'************************ Define Arrays *******************************	
+
+'Dialing Properties child control IDs
+
+Prop_CtrlID(DP_OKcmd)     = &h00000001&
+Prop_CtrlID(DP_CANCELcmd) = &h00000002&
+Prop_CtrlID(DP_APPLYcmd)  = &h00003021&
+
+'My Location Tab child control IDs
+
+ML_CtrlID(NEW_cmd)		= &h00001389&
+ML_CtrlID(REMOVE_cmd)	= &h0000138B&
+ML_CtrlID(CHANGE_cmd)	= &h0000138C&
+ML_CtrlID(LOCATION_cbo)	= &h00001388&
+ML_CtrlID(COUNTRY_cbo)	= &h0000040F&
+ML_CtrlID(AREA_txt)		= &h0000040E&
+ML_CtrlID(LOCAL_txt)		= &h0000040C&
+ML_CtrlID(LONG_txt)		= &h0000040D&
+ML_CtrlID(CARD_chk)		= &h0000138D&
+ML_CtrlID(DIAL_AS_chk)	= &h0000138A&
+ML_CtrlID(WAIT_chk)		= &h0000138E&
+ML_CtrlID(WAITStr_cbo)	= &h00001390&
+ML_CtrlID(TONE_opt)		= &h000017A3&
+ML_CtrlID(PULSE_opt)		= &h000017A2&
+ML_CtrlID(ADDRESS_lbl)	= &h00002329&
+ML_CtrlID(NUMBER_lbl)	= &h00002328&
+
+'Telephony Drivers Tab child controls IDs
+
+TD_CtrlID(TD_ADDcmd)		= &h00000422
+TD_CtrlID(TD_REMOVEcmd)	= &h00000423
+TD_CtrlID(TD_SETUPcmd)	= &h00000420
+TD_CtrlID(TD_DRIVERlst)	= &h00000421
+
+
+'************************ End Define Arrays ***************************	
+ 
+'************************ Start Test **********************************
+   on error goto ErrorHandler
+
+
+' Bounds Checker can only be run from a system that has Visual Test installed 
+' otherwise a run time error will occur.
+' The Bounds Checker binaries cannot be redistributed.
+' NUMEGA should only be defined when running in a VT environment.
+
+'$ifdef NUMEGA
+   on BoundsCheckerNotify (NULL) Call BoundsChkHandler
+'$endif 'NUMEGA
+
+   '$ifdef DEBUG_TEST_SCRIPT
+   'viewport on
+   'viewport clear
+   '$endif 'DEBUG_TEST_SCRIPT
+	viewport off
+
+	SetDefaultWaitTimeout (5)
+	TotalScenarios = 0
+   Test_Logfile = TESTMODE$
+   CurrentLoggingLevel = DetailCase
+   SetLogFileName
+   rtn = StartLog (DELETE_LOGFILE, TEST_SCRIPT_TITLE)
+	SetWndTimeout ()
+
+'  ********* TC - 35 Get Language Strings from INI file or use defaults
+	TotalScenarios = TotalScenarios + 1
+
+   GetLangStr
+
+'  ********* TC - 33 Start Phone Dialer application
+
+'NOTE: Phone dialer will not be used to invoke dialing properties so Start_App 
+'      is no longer needed. Dialing properties will be invoked from the
+'      Call_Dialing_Prop fuction using control.exe. 
+
+'    hPhoneDialer = Start_App
+
+'  ********* TC - 34 Invoke Dialing Properties Window
+
+
+	TotalScenarios = TotalScenarios + 1
+	
+	InitialLoc.Location		= "New Location"
+	InitialLoc.AreaCode		= "312"
+	InitialLoc.Country		= "United States of America"
+	InitialLoc.LocalAccess  = "7"
+	InitialLoc.LongAccess	= InitialLoc.LocalAccess 
+	InitialLoc.CardSet		= UNCHECKED
+	InitialLoc.WaitSet		= UNCHECKED
+	InitialLoc.ToneSet		= FALSE
+	InitialLoc.PulseSet		= TRUE
+
+	' Delete preexisting locations and set default location = InitialLoc.
+
+	SetLocationInfo (InitialLoc)
+   
+	' Callup dialing properties and get main handles
+   ' Handles to the Parent tab and the property pages are returned via 
+	' the three function arguments 
+	
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+
+	'GetDPCtrlh gets the handles to the dialing properties command buttons
+
+	GetDPCtrlh (hProperties, Prop_hCtrl, Prop_CtrlID)
+
+'  ********* TC - 46 Verify Language Strings
+
+   'Check the existance of the Tab controls
+   'First convert tab control handle to a string that WTab functions like
+
+	TotalScenarios = TotalScenarios + 1
+
+	Validate_Strings (hMyLocTab, ML_hCtrl)
+
+'  *********  NOT A TEST CASE
+'  Retrieve handles to child controls on all property pages
+'	for use with other test cases
+
+   GetChildhandles (hTelDrvTab, TD_hCtrl, TD_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	'Define locations for Test Cases 41, 84 and 85
+	Redmond.Location		= "Redmond"
+	Redmond.AreaCode		= "206"
+	Redmond.Country		= "United States of America"
+	Redmond.LocalAccess  = "9"
+	Redmond.LongAccess   = "8"
+	Redmond.CardSet		= UNCHECKED
+	Redmond.WaitSet		= CHECKED
+	Redmond.ToneSet		= TRUE
+	Redmond.PulseSet		= FALSE
+
+	Ireland.Location		= "Cork"
+	Ireland.AreaCode		= "21"
+	Ireland.Country		= "Ireland"
+	Ireland.LocalAccess  = "8"
+	Ireland.LongAccess   = "9"
+	Ireland.CardSet		= CHECKED
+	Ireland.WaitSet		= UNCHECKED
+	Ireland.ToneSet		= FALSE
+	Ireland.PulseSet		= TRUE
+
+	Chicago.Location		= "Chicago"
+	Chicago.AreaCode		= "312"
+	Chicago.Country		= "United States of America"
+	Chicago.LocalAccess  = "5"
+	Chicago.LongAccess   = "6"
+	Chicago.CardSet		= CHECKED
+	Chicago.WaitSet		= UNCHECKED
+	Chicago.ToneSet		= TRUE
+	Chicago.PulseSet		= FALSE
+
+	'  ********* TC - 41 Add Locations
+	TotalScenarios = TotalScenarios + 1
+
+	' add 2 new locations
+	AddLocations (Prop_hCtrl, ML_hCtrl, InitialLoc, Redmond, Ireland)
+
+   ' invoke Dialing properties and get Handles
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+   GetDPCtrlh (hProperties, Prop_hCtrl, Prop_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	' verify that the current location (Cork, Ireland) became the default location
+	VerifyCurrentLoc (ML_hCtrl, Ireland)
+
+	'  ********* TC - 84 Modify a Location
+
+	teststring.TC_Num =  84
+	TotalScenarios = TotalScenarios + 1
+
+	ModifyLocation (Prop_hCtrl, ML_hCtrl, Chicago)
+
+   ' invoke Dialing properties and get Handles
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+   GetDPCtrlh (hProperties, Prop_hCtrl, Prop_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	' verify that the current location (Chicago) became the default location
+	' then close Dialing Properties
+	VerifyModifyLoc (ML_hCtrl, Chicago, Prop_hCtrl(DP_OKcmd))
+
+  	'  ********* TC - 39 Verify Call Waiting 
+
+  	teststring.TC_Num =  39
+	TotalScenarios = TotalScenarios + 1
+	
+	VerifyCallWaiting (Prop_CtrlID, ML_CtrlID, Chicago)
+ 
+  	'  ********* TC - 45 Verify Calling Cards
+
+  	teststring.TC_Num =  45
+	TotalScenarios = TotalScenarios + 1
+
+	DefaultCallingCard (CallingCard, Prop_CtrlID, ML_CtrlID)
+
+	VerifyCallingCard (Prop_CtrlID, ML_CtrlID)
+
+  	'  ********* TC - 37 Country Dialing Rules
+   teststring.TC_Num =  37
+	TotalScenarios = TotalScenarios + 1
+
+	CountryDialRules(DialingRule, Prop_CtrlID, ML_CtrlID)	' The DialingRule array is defined in dialrule.inc
+
+	'  ********* TC - 85 Remove Locations
+
+''$ifdef NOTBERNIE
+
+	teststring.TC_Num =  85
+	TotalScenarios = TotalScenarios + 1
+
+   ' invoke Dialing properties and get Handles
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+   GetDPCtrlh (hProperties, Prop_hCtrl, Prop_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	'remove locations but Cancel out of dialing properties
+	rtnstring = space$(20)
+	rtnstring = RemoveLocation (Prop_hCtrl, ML_hCtrl, FALSE)
+ 
+   ' invoke Dialing properties and get Handles
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+   GetDPCtrlh (hProperties, Prop_hCtrl, Prop_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	'remove locations and OK out of dialing properties
+	rtnstring = space$(20)
+	rtnstring = RemoveLocation (Prop_hCtrl, ML_hCtrl, TRUE)
+
+   ' invoke Dialing properties and get Handles
+	hProperties = Call_Dialing_Prop (hParentTab, hMyLocTab, hTelDrvTab)
+   GetDPCtrlh (hProperties, Prop_hCtrl, Prop_CtrlID)
+   GetChildhandles (hMyLocTab, ML_hCtrl, ML_CtrlID)
+
+	VerifyRemoveLoc (ML_hCtrl, rtnstring)
+
+'  ********* End of Test
+
+''$IFDEF Run_Rest_Of_Test
+
+  'Close Dialing Properties window
+   WButtonClick (_hwnd(Prop_hCtrl(DP_OKcmd)), TIMEOUT)
+
+''$ENDIF 'Run_Rest_Of_Test
+
+ ''$endif 'NOTBERNIE
+ 
+   CloseCase (TEST_SCRIPT_TITLE)
+
+   CloseLog
+
+   Statusbox "The Dialing Properties Test is now Complete", _
+				 0,0,0,0, TRUE, TRUE 
+   Sleep 4
+ 
+   end
+
+'****************************** On Error Routine ******************************
+
+ErrorHandler:
+    ErrorMessage = "Unexpected error in the Dialing Properties Test: "  + CRLF + CRLF + _
+                   "Error:   " + error$											+ CRLF + _
+                   "Error #:"  + str$(Err)										+ CRLF + _
+                   "Line #: "  + str$(Erl)										+ CRLF + _
+                   "File: "    + Erf												+ CRLF + CRLF + _
+                   "Attempt to continue?"
+
+'$IFDEF DEBUG_TEST_SCRIPT
+   if Msgbox(ErrorMessage, MB_ICONEXCLAMATION or MB_YESNO) = IDYES then
+      resume next
+   else
+      Stop
+   endif
+'$ELSE
+   logitem (CurrentLoggingLevel, ErrorMessage)
+   Stop
+'$ENDIF 'DEBUG_TEST_SCRIPT
+'******************************************************************************
diff --git a/private/tapi/qa/dirs b/private/tapi/qa/dirs
new file mode 100644
index 000000000..9eac5f39a
--- /dev/null
+++ b/private/tapi/qa/dirs
@@ -0,0 +1,26 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS=\
+     tcore      \
+     trapper    \
+
diff --git a/private/tapi/qa/standalo/calltest/callt32.def b/private/tapi/qa/standalo/calltest/callt32.def
new file mode 100644
index 000000000..871296152
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/callt32.def
@@ -0,0 +1,13 @@
+NAME         callt32
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/qa/standalo/calltest/calltest.c b/private/tapi/qa/standalo/calltest/calltest.c
new file mode 100644
index 000000000..a7627f8e9
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/calltest.c
@@ -0,0 +1,1188 @@
+/****************************************************************************
+
+    PROGRAM:  calltest.c
+
+    PURPOSE:   
+
+    FUNCTIONS:
+
+         WinMain() - calls initialization function, processes message loop
+         MainWndProc() - processes messages
+         About() - processes messages for "About" dialog box
+         InitApplication() - initializes window data and registers window
+         InitInstance() - saves instance handle and creates main window
+		 TestCase() runs a single test case
+		 TestCase2() runs defined number of cases for menu 2
+		 TestCase3() runs defined number of cases for menu 3
+
+****************************************************************************/
+
+#include "windows.h"
+#include <tapi.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <malloc.h>
+
+
+#include "calltest.h"
+
+
+/********************************
+ * CONSTS
+ ********************************/
+#define IDM_TEST2_1 40021
+#define IDM_TEST2_2 40022
+#define IDM_TEST2_5 40025
+#define IDM_TEST2_6 40026
+
+#define IDM_TEST3_1 40031
+#define IDM_TEST3_2 40032
+#define IDM_TEST3_5 40035
+
+#define kRepetitionKeyword "/REPS"
+#define kDropTestKeyword "/DROP"
+#define kCloseTestKeyword "/CLOSE"
+#define kSingleTestKeyword "/SINGLE"
+
+#define kDropTestName "DROP TEST"
+#define kCloseTestName "CLOSE TEST"
+#define kSingleTestName "SINGLE TEST"
+
+
+#define TSPLineNameForHMSP "Testing SP"
+#define kMyMutexName "HMTSP Mutex"
+
+#ifndef WIN32
+#define MoveToEx( hdc, x, y, z )   MoveTo( hdc, x, y )
+#endif
+
+
+
+
+/*****************************************
+		Forward Declarations
+******************************************/
+//void FAR _cdecl _DebugOutput( UINT flags, LPCSTR lpszFmt, ... );
+
+
+int PASCAL WinMain( HANDLE, HANDLE, LPSTR, int );
+//long FAR PASCAL MainWndProc( HWND, unsigned, WORD, LONG );
+void   BlockMove (char	*src,char  *dest,long destSize);
+LRESULT CALLBACK MainWndProc( HWND, UINT, WPARAM, LPARAM );
+BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );
+static BOOL InitApplication( HANDLE );
+static BOOL InitInstance( HANDLE, int );
+void	WaitLineNotBusy(HLINE  theLine);
+
+
+/* Test Case Routines*/
+long TestCase ();
+long TestCase2 (long	reps);
+long TestCase3 (long	reps);
+
+BOOL	MakeCallOnHMTSP (HLINEAPP theLineApp, DWORD  dwDevice, HLINE theLine, HCALL *callhandle);
+
+void PassControl ();
+void CheckCommandLine(LPSTR	theCommandLine);
+
+/*****************************************
+		Global Vars
+******************************************/
+long   NumOfDevices;
+HANDLE ghInstance;
+static HANDLE hInst;
+static HWND   hwnd;            /* handle to main window */
+static BOOL Bailout = FALSE;
+static BOOL LineReceivedReply = FALSE;
+static BOOL LineIsIdle = FALSE;
+static HCALL ghCall = 0L;
+static char *TestName = 0L;
+
+DWORD  			_MyMutex  = 0L;
+HLINEAPP ghLineApp = NULL;
+MSG localmsg;
+
+
+
+
+
+
+//****************************************************************************
+//****************************************************************************
+#define RandomNumber(min,max) ((UINT) ( (long)rand()*(max-min) / (long)RAND_MAX ) + min)
+
+
+
+/***********************************************************************/
+/***********************************************************************/
+VOID CALLBACK FAR PASCAL MyCallback( HANDLE hDevice,
+                                       DWORD  dwMsg,
+                                       DWORD  dwCallbackInstance,
+                                       DWORD  dwParam1,
+                                       DWORD  dwParam2,
+                                       DWORD  dwParam3 )
+{
+   
+   	char	errstr[256];
+    
+	switch (dwMsg) {
+
+		case LINE_REPLY:
+			 LineReceivedReply=TRUE;
+			 if (dwParam2 < 0L) {
+				sprintf( errstr,"LINE_REPLY requestID %l returned error=0x%lx",dwParam1,dwParam2 );
+				MessageBox(GetFocus(), errstr, "Error", MB_OK);
+				Bailout = TRUE;
+			 	}//*if*
+				break;
+		case LINE_CALLSTATE:
+			 if (dwParam1 == LINECALLSTATE_IDLE) {
+			 	 LineIsIdle = TRUE;
+				 }//*if
+			 else {
+				LineIsIdle = FALSE;
+				}//*else
+			 break;
+								 
+
+		}//*switch
+    
+    return;
+}
+
+
+/****************************************************************************
+
+    FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
+
+    PURPOSE: calls initialization function, processes message loop
+
+****************************************************************************/
+
+int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance,
+                    LPSTR lpCmdLine,  int nCmdShow)
+    {
+    MSG msg;
+    DWORD dwNumDevs;
+    
+    
+    //* Save a copy of the hInstance
+	ghInstance = hInstance;
+    
+    if (hPrevInstance == 0)
+        if (InitApplication(hInstance) == 0)
+        {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "initapp failed Lasterr=0x%08lx", err);
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                        "Error",
+                        MB_OK
+                      );
+            return (FALSE);
+        }
+
+    if (InitInstance(hInstance, nCmdShow) == 0)
+    {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "initinstance failed Lasterr=0x%08lx", err );
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                    "Error",
+                    MB_OK
+                  );
+        return (FALSE);
+    }
+
+
+	CheckCommandLine(lpCmdLine);
+  
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+        {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        }
+
+
+  
+    return (msg.wParam);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: InitApplication(HANDLE)
+
+    PURPOSE: Initializes window data and registers window class
+
+****************************************************************************/
+
+static BOOL InitApplication(HANDLE hInstance)
+    {
+    WNDCLASS  wc;
+    char      szMenu[26], szClass[26];
+
+    LoadString (hInstance, ID_MENUSTR, szMenu, sizeof (szMenu));
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+
+    wc.style          = 0;
+    wc.lpfnWndProc    = MainWndProc;
+    wc.cbClsExtra     = 0;
+    wc.cbWndExtra     = 0;
+    wc.hInstance      = hInstance;
+    wc.hIcon          = LoadIcon(0, IDI_APPLICATION);
+    wc.hCursor        = LoadCursor(0, IDC_ARROW);
+    wc.hbrBackground  = GetStockObject(WHITE_BRUSH);
+    wc.lpszMenuName   = (LPSTR)szMenu;
+    wc.lpszClassName  = (LPSTR)szClass;
+
+
+	 
+
+
+    return (RegisterClass(&wc));
+    }
+
+
+/****************************************************************************
+
+    FUNCTION:  InitInstance(HANDLE, int)
+
+    PURPOSE:  Saves instance handle and creates main window
+
+****************************************************************************/
+
+static BOOL InitInstance(HANDLE hInstance, int nCmdShow)
+    {
+    char szClass[16], szTitle[40];
+
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+    LoadString (hInstance, ID_CAPTIONSTR, szTitle, sizeof (szTitle));
+
+    hInst = hInstance;
+
+    hwnd = CreateWindow(
+             szClass,
+             szTitle,
+             WS_OVERLAPPEDWINDOW +WS_VISIBLE+ WS_MINIMIZE,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             280,
+             70,
+             0,
+             0,
+             hInstance,
+             0 );
+
+    if (hwnd == 0 )
+        return ( FALSE );
+
+ 	ShowWindow(hwnd, nCmdShow);
+    UpdateWindow(hwnd);
+    return (TRUE);
+    }
+
+
+
+
+
+
+
+
+
+void WriteNums( HWND hWnd, DWORD dwPass, DWORD NumDevices)
+{
+   char szOutput[100];
+   int len;
+   HDC hdc;
+
+   len = wsprintf( szOutput, 
+#ifdef WIN32
+   "%s C32-%08ld Devs:%03d"
+#else
+   "%s C16-%08ld Devs:%03d"
+#endif
+   ,TestName,dwPass,NumDevices);
+
+   hdc = GetDC( hWnd );
+
+   MoveToEx( hdc, 10, 10, NULL );
+
+   TextOut( hdc, 0, 0, szOutput, len );
+
+   ReleaseDC( hWnd, hdc );
+
+   SetWindowText( hWnd, szOutput );
+
+   return;
+}
+
+
+
+
+
+
+
+
+
+
+
+/****************************************************************************
+
+    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages
+
+    MESSAGES:
+
+        WM_COMMAND    - application menu (About dialog box)
+        WM_DESTROY    - destroy window
+
+    COMMENTS:
+
+
+****************************************************************************/
+
+LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,
+                              WPARAM wParam, LPARAM lParam)
+{
+
+    FARPROC  lpProcAbout;
+    char szDlgBox[9], szMsgBoxCap[12], szStatus1[14], szStatus2[14];
+
+    char szAddress[20];
+    WORD uInitPrefix;
+    DWORD n;
+    MSG localmsg;
+	
+
+
+	//* Set the global window handle *
+	hwnd=hWnd;
+
+    LoadString (hInst, ID_DLGBOX, szDlgBox, sizeof (szDlgBox));
+    LoadString (hInst, ID_MSGBOXCAP, szMsgBoxCap, sizeof (szMsgBoxCap));
+    LoadString (hInst, ID_STATUS1, szStatus1, sizeof (szStatus1));
+    LoadString (hInst, ID_STATUS2, szStatus2, sizeof (szStatus2));
+
+    switch ( message )
+        {
+        case WM_COMMAND:
+            switch ( wParam )
+                {
+                case IDM_ABOUT:
+                    lpProcAbout = MakeProcInstance( About, hInst );
+                    DialogBox(hInst, szDlgBox, hWnd, lpProcAbout);
+                    FreeProcInstance( lpProcAbout );
+                    break;
+
+
+                case IDM_STOPTEST:
+                    Bailout = TRUE;
+                    break;
+
+				
+				case IDM_TEST2_1:
+					Bailout=FALSE;
+					TestCase2(32000);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+                case IDM_TEST2_2:
+				Bailout=FALSE;
+					TestCase2(100);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+                case IDM_TEST2_5:
+				Bailout=FALSE;
+					TestCase2(-1L);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+
+                case IDM_TEST2_6:
+				Bailout=FALSE;
+					TestCase2(1L);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+
+				case IDM_TEST3_1:
+				Bailout=FALSE;
+					TestCase3(32000);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+
+
+                case IDM_TEST3_2:
+				Bailout=FALSE;
+					TestCase3(100);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+
+
+                case IDM_TEST3_5:
+				Bailout=FALSE;
+					TestCase3(-1L);
+						if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+					break;
+
+
+                case IDM_TEST1:
+                case IDM_TEST2:
+                case IDM_TEST5:
+                case IDM_TEST6:
+	                {
+	                    DWORD dwLoops;
+
+	                    //
+	                    // 
+	                    //
+
+                       switch ( wParam )
+                       {
+                          case IDM_TEST1:
+                             dwLoops = 32000;
+                             break;
+
+                          case IDM_TEST2:
+                             dwLoops = 100;
+                             break;
+
+                          case IDM_TEST6:
+                             dwLoops = 1;
+                             break;
+
+
+                       }
+
+	                    Bailout = FALSE;
+
+	                    for ( n = 0 ;
+	                          !Bailout && ((n < dwLoops) || (wParam == IDM_TEST5));
+	                          n++)
+	                    {
+
+	                        Yield();
+
+
+							TestCase();
+
+	                        WriteNums( hWnd, (DWORD)n, NumOfDevices);
+
+							if (Bailout == TRUE) break;
+
+
+                          if ( PeekMessage( &localmsg,
+                                            NULL,
+                                            0,
+                                            0,
+                                            PM_REMOVE) )
+	                        {
+	                           TranslateMessage(&localmsg);
+	                           DispatchMessage(&localmsg);
+	                        }
+
+
+
+	                    }//*for
+
+	                    if (Bailout)
+	                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+	                    else
+	                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+	                    break;
+	                }/*case*/
+
+
+
+
+                }//*switch
+            break;
+
+        case WM_DESTROY:
+
+            Bailout = TRUE;
+
+            PostQuitMessage(0);
+#ifdef WIN32
+			ReleaseMutex((HANDLE)_MyMutex);
+#endif
+            break;
+
+        default:
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+     	}
+    return (FALSE);
+}
+
+
+/****************************************************************************
+
+    FUNCTION: About(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages for "About" dialog box
+
+    MESSAGES:
+
+        WM_INITDIALOG - initialize dialog box
+        WM_COMMAND    - Input received
+
+****************************************************************************/
+
+BOOL FAR PASCAL About(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
+    {
+    switch (message)
+        {
+        case WM_INITDIALOG:
+            return (TRUE);
+
+        case WM_COMMAND:
+            if (wParam == IDOK || wParam == IDCANCEL)
+                {
+                EndDialog(hDlg, TRUE);
+                return (TRUE);
+                }
+            break;
+        }
+    return (FALSE);
+    }
+
+
+//*************************************************
+//* Run the TestCase once per call.
+//* Case currently consists of :
+//* 
+//*	lineInitialize
+//*	lineOpen   
+//* lineMakeCall (if HMSP is installed.)
+//* lineClose
+//* lineShutdown
+//*************************************************
+long TestCase () {
+	
+	long result 		= 0L;
+	long errcode 		= 0L;
+	HLINEAPP hLineApp 	= 0L;
+	DWORD   deviceID    = 0L;
+	char	errstr[256];
+	HLINE	lineArray[30];	
+		
+TestName=&kSingleTestName;
+
+//* LineInitialize 
+#ifdef WIN32
+	_MyMutex=OpenMutex(SYNCHRONIZE,TRUE,kMyMutexName);
+
+	if (_MyMutex==0L) {		
+		_MyMutex=CreateMutex(0L,FALSE,kMyMutexName);
+		}
+
+	errcode=WAIT_TIMEOUT;
+	while (errcode==WAIT_TIMEOUT) {
+		errcode=WaitForSingleObject((HANDLE)_MyMutex,	50);
+		PassControl();
+	    }
+#endif
+
+	errcode =  lineInitialize(&hLineApp, ghInstance, (LINECALLBACK)&MyCallback, "calltest", &NumOfDevices);
+	if (errcode != 0L) {
+		result = errcode;
+		sprintf( errstr,"lineInitialize Failed   error=0x%lx",errcode );
+		MessageBox(GetFocus(), errstr, "Error", MB_OK);
+		Bailout = TRUE;
+		goto cleanup;					  
+		}//*if
+
+//* Open all devices
+
+	for (deviceID = 0L; deviceID < NumOfDevices; deviceID++ ) {
+		    lineArray[deviceID] = 0L;
+			errcode =  lineOpen(hLineApp, deviceID, &lineArray[deviceID], 
+								0x00010003,0L,NULL,LINECALLPRIVILEGE_NONE,0L,NULL);
+			if (errcode != 0L) {
+			    sprintf( errstr,"lineOpen Failed   device#= 0x%08lx error=0x%lx",deviceID, errcode );
+				MessageBox(GetFocus(), errstr, "Error", MB_OK);
+				Bailout = TRUE;
+				}//*if
+		
+		}//*for
+
+
+
+	for (deviceID = 0L; deviceID < NumOfDevices; deviceID++) {
+		BOOL callResult = FALSE;
+
+		if (MakeCallOnHMTSP (hLineApp, deviceID, lineArray[deviceID], NULL)) {
+			callResult = TRUE;
+			break;
+			}//*if*
+
+		if (deviceID+1 >= NumOfDevices) {
+			if (!callResult) {
+				MessageBox(GetFocus(),"Could not find a copy of HMSP.TSP, please install and then run the tests again.","Error",MB_OK);
+				Bailout=TRUE;
+				}//*if
+			}//*if*
+
+		PassControl();
+
+		}//*for*
+		
+
+		
+
+//* Close all open devices
+	for (;deviceID >= 1L;deviceID--) {
+		    errcode = lineClose(lineArray[deviceID-1]);
+			if (errcode != 0L) {
+			    sprintf( errstr,"lineClose Failed   error=0x%lx",errcode );
+				MessageBox(GetFocus(), errstr, "Error", MB_OK);
+				Bailout = TRUE;
+				}//*if
+			}
+
+//* LineShutdown
+	errcode =  lineShutdown(hLineApp);
+	if (errcode != 0L) {
+		result = errcode;
+		sprintf( errstr,"lineShutdown Failed   error=0x%lx",errcode );
+		MessageBox(GetFocus(), errstr, "Error", MB_OK);
+		Bailout = TRUE;
+		goto cleanup;
+		}//*if
+
+	Yield();
+cleanup:
+#ifdef WIN32
+    ReleaseMutex((HANDLE)_MyMutex);
+#endif
+	return(result);	
+
+}
+
+
+//*******************************************
+
+long TestCase2 (long	reps) {
+	
+	long result 		= 0L;
+	long errcode 		= 0L;
+	HLINEAPP hLineApp 	= 0L;
+	DWORD   deviceID    = 0L;
+	char	errstr[256];
+	HLINE	lineArray[30];
+	long counter = 0L;	
+
+//* LineInitialize 
+    TestName=&kCloseTestName;
+
+	errcode =  lineInitialize(&hLineApp, ghInstance, (LINECALLBACK)&MyCallback, "calltest", &NumOfDevices);
+	if (errcode != 0L) {
+		result = errcode;
+		sprintf( errstr,"lineInitialize Failed   error=0x%lx",errcode );
+		MessageBox(GetFocus(), errstr, "Error", MB_OK);
+		Bailout = TRUE;
+		goto cleanup;					  
+		}//*if
+
+//* Open all devices
+
+
+	for (counter=0L; counter!=reps; counter++) {
+
+		for (deviceID = 0L; deviceID < NumOfDevices; deviceID++ ) {
+			    lineArray[deviceID] = 0L;
+				errcode =  lineOpen(hLineApp, deviceID, &lineArray[deviceID], 
+									0x00010003,0L,NULL,LINECALLPRIVILEGE_NONE,0L,NULL);
+				if (errcode != 0L) {
+				    sprintf( errstr,"lineOpen Failed   device#= 0x%08lx error=0x%lx",deviceID, errcode );
+					MessageBox(GetFocus(), errstr, "Error", MB_OK);
+					Bailout = TRUE;
+					}//*if
+
+				PassControl();
+		
+			}//*for
+#ifdef WIN32
+			_MyMutex=OpenMutex(SYNCHRONIZE,TRUE,kMyMutexName);
+
+			if (_MyMutex==0L) {		
+				_MyMutex=CreateMutex(0L,FALSE,kMyMutexName);
+				}
+		
+			errcode=WAIT_TIMEOUT;
+			while (errcode==WAIT_TIMEOUT) {
+				errcode=WaitForSingleObject((HANDLE)_MyMutex,	50);
+				PassControl();
+			    }
+#endif
+
+	    for (deviceID = 0L; deviceID < NumOfDevices; deviceID++) {
+			BOOL callResult = FALSE;
+
+			PassControl();
+
+			
+			if (MakeCallOnHMTSP (hLineApp, deviceID, lineArray[deviceID], NULL)) {
+				callResult = TRUE;
+				}//*if*
+
+			if (deviceID+1 >= NumOfDevices) {
+				if (!callResult) {
+					MessageBox(GetFocus(),"Could not find a copy of HMSP.TSP, please install and then run the tests again.","Error",MB_OK);
+					Bailout=TRUE;
+					}//*if
+				}//*if*
+			}//*for*   
+
+
+
+
+	//* Close all open devices
+		for (;deviceID >= 1L;deviceID--) {
+			    errcode = lineClose(lineArray[deviceID-1]);
+				if (errcode != 0L) {
+				    sprintf( errstr,"lineClose Failed   error=0x%lx",errcode );
+					MessageBox(GetFocus(), errstr, "Error", MB_OK);
+					Bailout = TRUE;
+					}//*if
+				}
+
+		if (Bailout == TRUE)
+         break;
+
+		WriteNums( hwnd, (DWORD)counter, NumOfDevices);
+
+		PassControl();
+#ifdef WIN32	
+		ReleaseMutex((HANDLE)_MyMutex);	
+#endif
+		}//*for*
+//* LineShutdown
+cleanup:
+	errcode =  lineShutdown(hLineApp);
+	if (errcode != 0L) {
+		result = errcode;
+		sprintf( errstr,"lineShutdown Failed   error=0x%lx",errcode );
+		MessageBox(GetFocus(), errstr, "Error", MB_OK);
+		Bailout = TRUE;
+		goto cleanup;
+		}//*if
+
+
+	return(result);	
+
+}
+
+
+//*******************************************
+
+long TestCase3 (long	reps) {
+	
+	long result 		= 0L;
+	long errcode 		= 0L;
+	HLINEAPP hLineApp 	= 0L;
+	DWORD   deviceID    = 0L;
+	char	errstr[256];
+	HLINE	lineArray[30];
+	long counter = 0L;	
+
+	TestName=&kDropTestName;
+
+
+//* LineInitialize 
+
+	errcode =  lineInitialize(&hLineApp, ghInstance, (LINECALLBACK)&MyCallback, "calltest", &NumOfDevices);
+	if (errcode != 0L) {
+		result = errcode;
+		sprintf( errstr,"lineInitialize Failed   error=0x%lx",errcode );
+		MessageBox(GetFocus(), errstr, "Error", MB_OK);
+		Bailout = TRUE;
+		goto cleanup;					  
+		}//*if
+
+//* Open all devices
+
+
+
+	for (deviceID = 0L; deviceID < NumOfDevices; deviceID++ ) {
+			    lineArray[deviceID] = 0L;
+				errcode =  lineOpen(hLineApp, deviceID, &lineArray[deviceID], 
+									0x00010003,0L,NULL,LINECALLPRIVILEGE_NONE,0L,NULL);
+				if (errcode != 0L) {
+				    sprintf( errstr,"lineOpen Failed   device#= 0x%08lx error=0x%lx",deviceID, errcode );
+					MessageBox(GetFocus(), errstr, "Error", MB_OK);
+					Bailout = TRUE;
+					}//*if
+		
+			}//*for
+
+	for (counter=0L;counter!=reps;counter++) {
+		HCALL	hCall = 0L;
+
+	    for (deviceID = 0L; deviceID < NumOfDevices; deviceID++) {
+		
+			BOOL callResult = FALSE;
+
+			hCall = 0L;
+
+			LineReceivedReply = FALSE;
+#ifdef WIN32		
+			_MyMutex=OpenMutex(SYNCHRONIZE,TRUE,kMyMutexName);
+
+			if (_MyMutex==0L) {		
+				_MyMutex=CreateMutex(0L,FALSE,kMyMutexName);
+				}
+								 	
+			errcode=WAIT_TIMEOUT;
+			while (errcode==WAIT_TIMEOUT) {
+				errcode=WaitForSingleObject((HANDLE)_MyMutex,	50);
+				PassControl();
+			    }
+#endif			
+
+			if (MakeCallOnHMTSP (hLineApp, deviceID, lineArray[deviceID], &hCall)) {
+				callResult = TRUE;
+				}//*if*
+
+
+
+			if (hCall != 0L) {
+				errcode= lineDrop(hCall, NULL, 0L);
+				if (errcode < 0L) {
+				    sprintf( errstr,"lineDrop Failed  error=0x%lx", errcode );
+					MessageBox(GetFocus(), errstr, "Error", MB_OK);
+					Bailout = TRUE;
+					}//*if
+
+				while(!LineIsIdle ) {
+					PassControl();
+					}
+				LineIsIdle = FALSE;
+
+				errcode= lineDeallocateCall(hCall);
+				if (errcode < 0L) {
+				    sprintf( errstr,"lineDeallocateCall Failed  error=0x%lx", errcode );
+					MessageBox(GetFocus(), errstr, "Error", MB_OK);
+					Bailout = TRUE;
+					}//*if
+				}//*if*
+#ifdef  WIN32
+			WaitLineNotBusy(lineArray[deviceID]);
+			ReleaseMutex((HANDLE)_MyMutex);
+#endif
+			PassControl();
+
+
+			if (deviceID+1 >= NumOfDevices) {
+				if (!callResult) {
+					MessageBox(GetFocus(),"Could not find a copy of HMSP.TSP, please install and then run the tests again.","Error",MB_OK);
+					Bailout=TRUE;
+					}//*if
+				}//*if*
+
+			}//*for*   
+
+		if (Bailout == TRUE) break;
+		PassControl();
+
+		WriteNums( hwnd, (DWORD)counter, NumOfDevices);
+
+
+		}//*for*
+cleanup:
+
+	//* Close all open devices
+		for (;deviceID >= 1L;deviceID--) {
+			    errcode = lineClose(lineArray[deviceID-1]);
+				if (errcode != 0L) {
+				    sprintf( errstr,"lineClose Failed   error=0x%lx",errcode );
+					MessageBox(GetFocus(), errstr, "Error", MB_OK);
+					Bailout = TRUE;
+					}//*if
+				}
+
+//* LineShutdown
+	errcode =  lineShutdown(hLineApp);
+	if (errcode != 0L) {
+		result = errcode;
+		sprintf( errstr,"lineShutdown Failed   error=0x%lx",errcode );
+		MessageBox(GetFocus(), errstr, "Error", MB_OK);
+		Bailout = TRUE;
+		goto cleanup;
+		}//*if
+
+	return(result);	
+}
+
+
+
+//* This function makes a call if the line is an HMTSP provided line.
+
+BOOL	MakeCallOnHMTSP (HLINEAPP theLineApp, DWORD  dwDevice, HLINE theLine, HCALL *callhandle) {
+
+LINEDEVCAPS		*DeviceCaps = 0L;
+char			*nameofprovider = 0L;
+char			lineName[256];
+char			*tempptr;
+HCALL			hCall = 0L;
+BOOL			result = FALSE;
+long			error = 0L;
+long			offset = 0L;
+char			errstr[256];
+
+	
+	DeviceCaps = (LINEDEVCAPS *)malloc	(sizeof(LINEDEVCAPS)+256);
+    memset (DeviceCaps, 0, sizeof(LINEDEVCAPS)+256);
+    DeviceCaps->dwTotalSize = sizeof(LINEDEVCAPS)+256;
+
+/* 	Get the name of the line that the  service provider is using.  Then look for the ones which are from HMSP.TSP
+    If we find the HMSP.TSP is installed then we use it.  */
+
+	error = lineGetDevCaps(theLineApp,dwDevice,0x00010003,0L,DeviceCaps);
+	if (error != 0L) {
+			sprintf( errstr,"lineGetDevCaps Failed   error=0x%lx",error );
+			MessageBox(GetFocus(), errstr, "Error", MB_OK);
+			Bailout = TRUE;
+			goto cleanup;
+			}//*if
+
+
+	if (!error) {
+		offset = DeviceCaps->dwLineNameOffset;
+
+			nameofprovider =  (char *)DeviceCaps + offset;
+			if (DeviceCaps->dwLineNameSize != 0L) 
+	      {
+				lstrcpy(lineName, nameofprovider);
+
+	      }
+
+		}//*if*
+	else {goto cleanup;}
+
+
+	tempptr = strstr( lineName, &TSPLineNameForHMSP );
+	ghCall = 0L;
+	if (tempptr != 0L) {
+
+/* Have a problem with multiple instances, they sometime will try to make a call on an alredy busy line. */
+/* To synchronie with other apps make sure no one else has put in a mutex with our name on it. */
+				
+
+		result=TRUE;
+//* Cheap fix for errors with lineMakeCall, to make it work across both WIN16 and WIN32 
+//* We check the error and if is a LINEERR_RESOURCEUNAVAIL then we try again.
+
+		error=LINEERR_RESOURCEUNAVAIL;
+		while (error == LINEERR_RESOURCEUNAVAIL) { 
+		  error=lineMakeCall(theLine, &ghCall, "123456789", 0L, 0L);
+		  PassControl();
+		  }
+
+		if (error < 0L) {
+			sprintf( errstr,"lineMakeCall Failed   error=0x%lx",error );
+			MessageBox(GetFocus(), errstr, "Error", MB_OK);
+			Bailout = TRUE;
+			goto cleanup;
+			}//*if
+		if (error > 0L) { //Wait for the line to connect.
+				while(!LineReceivedReply && !Bailout) {
+					PassControl();
+					}//*while
+			}//*if
+/* If callhandle is valid, then return this call handle, when done with test. */
+		if (callhandle != 0L) {
+			*callhandle = ghCall;
+			}//*if*
+		}//*if*
+
+cleanup:
+	if (DeviceCaps !=0L) free(DeviceCaps);
+
+	return(result);
+
+
+}//*MakeCallOnHMTSP
+			
+
+
+
+void PassControl () {
+	   
+	   if ( PeekMessage( &localmsg,
+	                      NULL,
+	                      0,
+	                      0,
+	                      PM_REMOVE)
+	       )
+	    {
+	       TranslateMessage(&localmsg);
+	       DispatchMessage(&localmsg);
+	    }
+	  else Yield();
+}//*passcontrol*
+
+
+
+void CheckCommandLine (LPSTR theCommandLine) {
+	 
+	 long   numArgs = 0L;
+	 long	s_pos = 0L;
+	 long	e_pos = 0L;
+	 long	pos = 0L;
+	 long   reps = -1L;
+	 char	reps_str[256];
+	 char	*tempStr = 0L;
+	 BOOL   validline = FALSE;
+
+	 memset(&reps_str,0,256);
+
+	 if (strstr(theCommandLine,&kDropTestKeyword) != 0L) {
+	 	validline = TRUE;
+		}//*if
+		
+	 if (strstr(theCommandLine,&kCloseTestKeyword) != 0L) {
+	 	validline = TRUE;
+		}//*if
+
+     if (strstr(theCommandLine,&kSingleTestKeyword) != 0L) {
+	    validline = TRUE;
+		}//*if
+
+	 if (validline) {
+	 	PostMessage(hwnd,WM_SYSCOMMAND,SC_MINIMIZE,0L);
+		}//*if
+	 else {
+		goto cleanup;
+		}//*else
+
+
+	 tempStr=strstr(theCommandLine,kRepetitionKeyword);
+	 if (tempStr != 0L) {
+		 pos=strlen(kRepetitionKeyword)+2;
+		 s_pos=pos;
+		 if (pos <= strlen(tempStr)) {
+		 	while (tempStr[pos] !=0  && 
+		 	       tempStr[pos]!=' ' && 
+		 	       tempStr[pos]!='/') {
+				   pos++;
+				   }//*while
+			
+			 e_pos = pos;
+	 	 
+			 if (e_pos >= s_pos ) {
+			 	lstrcpyn(&reps_str,&tempStr[s_pos-1],(e_pos-s_pos)+2);
+				reps=atol(reps_str);
+			 	}//*if
+			}//*if
+		 }//*if
+
+	 if (strstr(theCommandLine,&kDropTestKeyword) != 0L) {
+
+	 	TestCase3(reps);
+		PostMessage(hwnd,WM_SYSCOMMAND,SC_RESTORE,0L);
+		if (Bailout)
+		    MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+		else
+		    MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);	
+		}//*if
+
+	 if (strstr(theCommandLine,&kCloseTestKeyword) != 0L) {
+	 	TestCase2(reps);
+		PostMessage(hwnd,WM_SYSCOMMAND,SC_RESTORE,0L);
+		if (Bailout)
+		    MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+		else
+		    MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);	
+		}//*if
+
+	if (strstr(theCommandLine,&kSingleTestKeyword) != 0L) {
+
+		long n;
+
+		for ( n = 0 ;
+              !Bailout && ((n != reps) );
+              n++)
+        {
+
+            Yield();
+
+
+			TestCase();
+
+            WriteNums( hwnd, (DWORD)n, NumOfDevices);
+
+			if (Bailout == TRUE) break;
+
+
+            PassControl();
+
+
+        }//*for
+
+		PostMessage(hwnd,WM_SYSCOMMAND,SC_RESTORE,0L);
+
+		if (Bailout)
+		    MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+		else
+		    MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);	
+		}//*if
+
+cleanup:
+	
+	return;
+}//*CheckCommandLine
+
+
+
+void	WaitLineNotBusy(HLINE  theLine) {
+	
+	LINEDEVSTATUS	lineStatus;
+
+	memset(&lineStatus, 0, sizeof(LINEDEVSTATUS));
+	lineStatus.dwTotalSize=sizeof(LINEDEVSTATUS);
+
+	while (lineStatus.dwNumActiveCalls != 0) {
+		PassControl();
+		}
+
+	}
+	 
diff --git a/private/tapi/qa/standalo/calltest/calltest.def b/private/tapi/qa/standalo/calltest/calltest.def
new file mode 100644
index 000000000..8f12e858b
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/calltest.def
@@ -0,0 +1,20 @@
+NAME         calltest
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+EXETYPE      WINDOWS
+
+STUB         'WINSTUB.EXE'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     4024
+STACKSIZE    12120
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/qa/standalo/calltest/calltest.h b/private/tapi/qa/standalo/calltest/calltest.h
new file mode 100644
index 000000000..cd630f206
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/calltest.h
@@ -0,0 +1,33 @@
+#if !defined(tolltest_h)
+#define tolltest_h
+
+#define IDM_ABOUT     101
+
+#define IDM_TEST1     201
+#define IDM_TEST2     202
+#define IDM_TEST3     203
+#define IDM_TEST4     204
+#define IDM_TEST5     205
+#define IDM_TEST6     206
+
+//#define IDM_TEST2_1     226
+//#define IDM_TEST2_2     227
+//#define IDM_TEST2_5     228
+
+//#define IDM_TEST3_1     239
+//#define IDM_TEST3_2     230
+//#define IDM_TEST3_5     231
+
+
+#define IDM_STOPTEST  290
+
+#define ID_MENUSTR      301
+#define ID_CLASSSTR     302
+#define ID_CAPTIONSTR   303
+#define ID_DLGBOX       304
+#define ID_MSGBOXCAP    305
+#define ID_STATUS1      306
+#define ID_STATUS2      307
+#define ID_STATUS3      308
+
+#endif
diff --git a/private/tapi/qa/standalo/calltest/calltest.rc b/private/tapi/qa/standalo/calltest/calltest.rc
new file mode 100644
index 000000000..d5f05a80f
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/calltest.rc
@@ -0,0 +1,128 @@
+//Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#define APSTUDIO_HIDDEN_SYMBOLS
+#include "windows.h"
+#undef APSTUDIO_HIDDEN_SYMBOLS
+#include "calltest.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+CALLTESTMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "S&ingle Call"
+    BEGIN
+        MENUITEM "Test &1 - 32000 repetitions", IDM_TEST1
+        MENUITEM "Test &2 - 100 repetitions",   IDM_TEST2
+        MENUITEM "Test &3 - Infinite repetitions", IDM_TEST5
+        MENUITEM "Test &4 - 1 repetition",   IDM_TEST6
+        MENUITEM SEPARATOR
+        MENUITEM "&About Sample ...",           IDM_ABOUT
+    END
+    POPUP "&Line Close"
+    BEGIN
+        MENUITEM "Test &1 - 32000 repetitions", IDM_TEST2_1
+        MENUITEM "Test &2 - 100 repetitions",   IDM_TEST2_2
+        MENUITEM "Test &3 - Infinite repetitions", IDM_TEST2_5
+        MENUITEM "Test &4 - 1 repetition", IDM_TEST2_6
+    END
+    POPUP "&Drop Call"
+    BEGIN
+        MENUITEM "Test &1 - 32000 repetitions", IDM_TEST3_1
+        MENUITEM "Test &2 - 100 repetitions",   IDM_TEST3_2
+        MENUITEM "Test &3 - Infinite repetitions", IDM_TEST3_5
+    END
+    MENUITEM "&Stop test...",               IDM_STOPTEST
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+ABOUTBOX DIALOG DISCARDABLE  22, 17, 144, 75
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About CallTest"
+BEGIN
+    CTEXT           "Microsoft Windows TAPI Call Stress Test App",-1,0,5,144,8
+    CTEXT           "Version 0.1",-1,0,34,144,8
+    DEFPUSHBUTTON   "OK",IDOK,53,59,32,14,WS_GROUP
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""windows.h""\r\n"
+    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""calltest.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_MENUSTR              "CallTestMenu"
+    ID_CLASSSTR             "CallTestClass"
+    ID_CAPTIONSTR           "TAPI CallTests Test App"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_DLGBOX               "AboutBox"
+    ID_MSGBOXCAP            "InitList Test"
+    ID_STATUS1              "Entering Test"
+    ID_STATUS2              "Test Failed !"
+    ID_STATUS3              "Test Successful !"
+END
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/private/tapi/qa/standalo/calltest/depend.mk b/private/tapi/qa/standalo/calltest/depend.mk
new file mode 100644
index 000000000..b6806eead
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/depend.mk
@@ -0,0 +1,3 @@
+.\calltest.obj: ..\calltest.c ..\calltest.h
+
+.\calltest.res: ..\calltest.rc ..\calltest.h ..\resource.h
diff --git a/private/tapi/qa/standalo/calltest/makefile b/private/tapi/qa/standalo/calltest/makefile
new file mode 100644
index 000000000..9f6b20824
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/makefile
@@ -0,0 +1,29 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+##############################################################################
+#
+#   telephon.cpl Make file
+#
+##############################################################################
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/qa/standalo/calltest/makefile.def b/private/tapi/qa/standalo/calltest/makefile.def
new file mode 100644
index 000000000..53df5cd79
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/makefile.def
@@ -0,0 +1,91 @@
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..\..
+
+
+#DEFENTRY=main
+
+DEPENDNAME=..\depend.mk
+
+SRCDIR=..
+
+IS_OEM = TRUE
+
+!ifdef WIN32
+
+##############################################################################
+#
+#   callt32 Make file
+#
+##############################################################################
+
+WANT_C932=1
+IS_32 = TRUE
+WIN32=1
+
+DRVNAME=callt32
+TARGETS=callt32.exe
+
+L32EXE=callt32.exe		# Name of exe.
+L32DEF=..\callt32.def              # Our def file.
+#L32MAP=callt32.map		# Our map file.
+L32LIBS= \
+        $(ROOT)\dev\tools\c932\lib\rpcrt4.lib   \
+        $(ROOT)\dev\tools\c932\lib\msvcrt.lib   \
+        $(ROOT)\dev\tools\c932\lib\crtdll.lib   \
+        $(W32LIBID)\kernel32.lib                \
+        $(W32LIBID)\user32.lib                  \
+        $(W32LIBID)\gdi32.lib                   \
+        $(W32LIBID)\tapi32.lib
+
+L32RES=calltest.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L32OBJS = calltest.res calltest.obj
+
+L32FLAGS=$(L32FLAGS) /PDB:callt32.pdb /MAP:callt32.map
+
+CFLAGS=$(CFLAGS) -DWIN32=100 -DWIN_32=100
+
+
+!else
+
+##############################################################################
+#
+#   calltest Make file
+#
+##############################################################################
+
+IS_16 = TRUE
+
+DRVNAME=calltest
+TARGETS=calltest.exe
+
+L16EXE=calltest.exe		# Name of exe.
+L16DEF=..\calltest.def              # Our def file.
+#L16MAP=calltest.map		# Our map file.
+L16LIBS= \
+        $(WLIBID)\libw.lib \
+        $(WLIBID)\tapi.lib \
+        $(DEVROOT)\tools\c816\lib\mlibcew.lib
+
+L16RES=calltest.res	# Resource file.
+
+
+#-----------------------------------------------------------------------
+# Object files
+#-----------------------------------------------------------------------
+L16OBJS = calltest.res calltest.obj
+
+
+!endif
+
+
+!include $(ROOT)\dev\master.mk
+
+!IF "$(VERDIR)" == "debug"
+CFLAGS = $(CFLAGS) -DDBG=1
+!endif
diff --git a/private/tapi/qa/standalo/calltest/readme.txt b/private/tapi/qa/standalo/calltest/readme.txt
new file mode 100644
index 000000000..e8b54ad9f
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/readme.txt
@@ -0,0 +1,45 @@
+CALLTEST.EXE:
+
+
+Only one test may be called per command line.
+USAGE:  CALLTEST  </DROP | /SINGLE | /CLOSE> [/REPS XXXX]
+
+each of the following tests can be run from the command line as well:
+        /DROP = Drop Call tests
+        /SINGLE = Single Call tests
+        /CLOSE = Line Close tests
+        /REPS = Number of repetitions for tests. Otherwise it is infinite.
+
+Assuming you have HMTSP.TSP installed in the telephon.cpl, you can run these
+tests.
+
+Three different tests to use with tapi:
+
+Single call:
+lineInitialize
+  lineOpen (for each line available.)
+      lineMakeCall (for each HMTSP.TSP line.)
+  lineClose
+lineShutdown
+
+Line Close:
+lineInitialize (at the start of the test)
+    repeat {
+        lineOpen (for each line available.)
+          lineMakeCall (for each HMTSP.TSP line.)
+        lineClose
+        }
+lineShutdown
+
+Drop Call:
+lineInitialize (at the start of the test)
+    lineOpen (for each line available.)
+    repeat {
+       lineMakeCall (for each HMTSP.TSP line.)
+         lineDrop
+         lineDeallocateCall
+       }
+    lineClose (for each line available.)
+lineShutdown
+
+
diff --git a/private/tapi/qa/standalo/calltest/resource.h b/private/tapi/qa/standalo/calltest/resource.h
new file mode 100644
index 000000000..21c10e6de
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/resource.h
@@ -0,0 +1,24 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by callTEST.RC
+//
+#define IDM_TEST2_1                     40021
+#define IDM_TEST2_2                     40022
+#define IDM_TEST2_5                     40025
+#define IDM_TEST2_6                     40026
+
+#define IDM_TEST3_1                     40031
+#define IDM_TEST3_2                     40032
+#define IDM_TEST3_5                     40035
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40007
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/qa/standalo/calltest/sources b/private/tapi/qa/standalo/calltest/sources
new file mode 100644
index 000000000..acbbbb4b7
--- /dev/null
+++ b/private/tapi/qa/standalo/calltest/sources
@@ -0,0 +1,53 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=callt32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMENTRY =winmain
+
+USE_CRTDLL=1
+
+SOURCES=calltest.c   \
+        calltest.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/standalo/inittest/initt32.def b/private/tapi/qa/standalo/inittest/initt32.def
new file mode 100644
index 000000000..ac17ea4ee
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/initt32.def
@@ -0,0 +1,13 @@
+NAME         initt32
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/qa/standalo/inittest/inittest.c b/private/tapi/qa/standalo/inittest/inittest.c
new file mode 100644
index 000000000..66165e3b1
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/inittest.c
@@ -0,0 +1,535 @@
+/****************************************************************************
+
+    PROGRAM:  InitTest.c
+
+    PURPOSE:   
+
+    FUNCTIONS:
+
+         WinMain() - calls initialization function, processes message loop
+         MainWndProc() - processes messages
+         About() - processes messages for "About" dialog box
+         InitApplication() - initializes window data and registers window
+         InitInstance() - saves instance handle and creates main window
+         TestProc1() - First test procedure.
+         TestProc2() - Second test procedure.
+         TestProc3() - Third test procedure
+         TestProc4() - Fourth test procedure
+       TestCase() runs a single test case
+
+****************************************************************************/
+
+#include "windows.h"
+#include <tapi.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "inittest.h"
+
+
+
+#ifndef WIN32
+#define MoveToEx( hdc, x, y, z )   MoveTo( hdc, x, y )
+#endif
+
+
+
+//void FAR _cdecl _DebugOutput( UINT flags, LPCSTR lpszFmt, ... );
+
+
+int PASCAL WinMain( HINSTANCE, HINSTANCE, LPSTR, int );
+//long FAR PASCAL MainWndProc( HWND, unsigned, WORD, LONG );
+LRESULT CALLBACK MainWndProc( HWND, UINT, WPARAM, LPARAM );
+BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );
+static BOOL InitApplication( HANDLE );
+static BOOL InitInstance( HANDLE, int );
+long TestCase ( BOOL );
+
+
+long   NumOfDevices;
+HANDLE ghInstance;
+static HANDLE hInst;
+static HWND   hwnd;            /* handle to main window */
+static BOOL Bailout = FALSE;
+
+
+HLINEAPP ghLineApp = NULL;
+
+
+
+//****************************************************************************
+//****************************************************************************
+#define RandomNumber(min,max) ((UINT) ( (long)rand()*(max-min) / (long)RAND_MAX ) + min)
+
+
+
+/***********************************************************************/
+/***********************************************************************/
+VOID CALLBACK FAR PASCAL MyCallback( HANDLE hDevice,
+                                       DWORD  dwMsg,
+                                       DWORD  dwCallbackInstance,
+                                       DWORD  dwParam1,
+                                       DWORD  dwParam2,
+                                       DWORD  dwParam3 )
+{
+    return;
+}
+
+
+/****************************************************************************
+
+    FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
+
+    PURPOSE: calls initialization function, processes message loop
+
+****************************************************************************/
+
+int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                    LPSTR lpCmdLine,  int nCmdShow)
+    {
+    MSG msg;
+    DWORD dwNumDevs;
+    
+    
+    //* Save a copy of the hInstance
+   ghInstance = hInstance;
+    
+    if (hPrevInstance == 0)
+        if (InitApplication(hInstance) == 0)
+        {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "initapp failed Lasterr=0x%08lx", err);
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                        "Error",
+                        MB_OK
+                      );
+            return (FALSE);
+        }
+
+    if (InitInstance(hInstance, nCmdShow) == 0)
+    {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "initapp failed Lasterr=0x%08lx", err );
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                    "Error",
+                    MB_OK
+                  );
+        return (FALSE);
+    }
+
+
+  
+
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+        {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        }
+
+
+  
+    return (msg.wParam);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: InitApplication(HANDLE)
+
+    PURPOSE: Initializes window data and registers window class
+
+****************************************************************************/
+
+static BOOL InitApplication(HANDLE hInstance)
+    {
+    WNDCLASS  wc;
+    char      szMenu[26], szClass[26];
+
+    LoadString (hInstance, ID_MENUSTR, szMenu, sizeof (szMenu));
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+
+    wc.style          = 0;
+    wc.lpfnWndProc    = MainWndProc;
+    wc.cbClsExtra     = 0;
+    wc.cbWndExtra     = 0;
+    wc.hInstance      = hInstance;
+    wc.hIcon          = LoadIcon(0, IDI_APPLICATION);
+    wc.hCursor        = LoadCursor(0, IDC_ARROW);
+    wc.hbrBackground  = GetStockObject(WHITE_BRUSH);
+    wc.lpszMenuName   = (LPSTR)szMenu;
+    wc.lpszClassName  = (LPSTR)szClass;
+
+    return (RegisterClass(&wc));
+    }
+
+
+/****************************************************************************
+
+    FUNCTION:  InitInstance(HANDLE, int)
+
+    PURPOSE:  Saves instance handle and creates main window
+
+****************************************************************************/
+
+static BOOL InitInstance(HANDLE hInstance, int nCmdShow)
+    {
+    char szClass[16], szTitle[40];
+
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+    LoadString (hInstance, ID_CAPTIONSTR, szTitle, sizeof (szTitle));
+
+    hInst = hInstance;
+
+    hwnd = CreateWindow(
+             szClass,
+             szTitle,
+             WS_OVERLAPPEDWINDOW,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             280,
+             70,
+             0,
+             0,
+             hInstance,
+             0 );
+
+    if (hwnd == 0 )
+        return ( FALSE );
+
+    ShowWindow(hwnd, nCmdShow);
+    UpdateWindow(hwnd);
+    return (TRUE);
+    }
+
+
+
+
+
+
+
+
+
+void WriteNums( HWND hWnd, DWORD dwPass, DWORD NumDevices)
+{
+   char szOutput[100];
+   int len;
+   HDC hdc;
+
+   len = wsprintf( szOutput, 
+#ifdef WIN32
+   "I32-%08ld Devs:%03d"
+#else
+   "I16-%08ld Devs:%03d"
+#endif
+   ,dwPass,NumDevices);
+
+   hdc = GetDC( hWnd );
+
+   MoveToEx( hdc, 10, 10, NULL );
+
+   TextOut( hdc, 0, 0, szOutput, len );
+
+   ReleaseDC( hWnd, hdc );
+
+   SetWindowText( hWnd, szOutput );
+
+   return;
+}
+
+
+
+
+
+
+
+
+
+
+
+/****************************************************************************
+
+    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages
+
+    MESSAGES:
+
+        WM_COMMAND    - application menu (About dialog box)
+        WM_DESTROY    - destroy window
+
+    COMMENTS:
+
+
+****************************************************************************/
+
+LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,
+                              WPARAM wParam, LPARAM lParam)
+{
+
+    FARPROC  lpProcAbout;
+    char szDlgBox[9], szMsgBoxCap[12], szStatus1[14], szStatus2[14];
+
+    char szAddress[20];
+    WORD uInitPrefix;
+    DWORD n;
+    MSG localmsg;
+
+
+
+    LoadString (hInst, ID_DLGBOX, szDlgBox, sizeof (szDlgBox));
+    LoadString (hInst, ID_MSGBOXCAP, szMsgBoxCap, sizeof (szMsgBoxCap));
+    LoadString (hInst, ID_STATUS1, szStatus1, sizeof (szStatus1));
+    LoadString (hInst, ID_STATUS2, szStatus2, sizeof (szStatus2));
+
+    switch ( message )
+        {
+        case WM_COMMAND:
+            switch ( wParam )
+                {
+                case IDM_ABOUT:
+//                    lpProcAbout = MakeProcInstance( About, hInst );
+                    DialogBox(hInst, szDlgBox, hWnd, (DLGPROC)About);
+//                    FreeProcInstance( lpProcAbout );
+                    break;
+
+
+                case IDM_STOPTEST:
+                    Bailout = TRUE;
+                    break;
+
+
+                case IDM_TEST1:
+                case IDM_TEST2:
+                case IDM_TEST5:
+                case IDM_TESTA:
+                case IDM_TESTB:
+                case IDM_TESTC:
+                   {
+                       DWORD dwLoops;
+
+                       //
+                       // This test
+                       // randomly picks numbers to add and remove.
+                       //
+
+                       dwLoops = ( (
+                                      (wParam == IDM_TEST1)
+                                    ||
+                                      (wParam == IDM_TESTA)
+                                   )
+                                      ? 32000 : 100 );
+
+
+                       Bailout = FALSE;
+
+                       for ( n = 0 ;
+                             !Bailout && ((n < dwLoops) || (wParam == IDM_TEST5));
+                             n++)
+                       {
+
+                           Yield();
+
+                     TestCase(
+                                (
+                                   (wParam == IDM_TEST1)
+                                 ||
+                                   (wParam == IDM_TEST2)
+                                 ||
+                                   (wParam == IDM_TEST5)
+                                )
+                             );
+
+                           WriteNums( hWnd, (DWORD)n, NumOfDevices);
+
+                     if (Bailout == TRUE) break;
+
+
+                          while ( PeekMessage( &localmsg,
+                                             NULL,
+                                             0,
+                                             0,
+                                             PM_REMOVE )
+                              )
+                           {
+                              TranslateMessage(&localmsg);
+                              DispatchMessage(&localmsg);
+                           }
+
+
+
+                       }//*for
+
+                       if (Bailout)
+                           MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+                       else
+                           MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+                       break;
+                   }/*case*/
+
+
+
+
+                }//*switch
+            break;
+
+        case WM_DESTROY:
+
+            Bailout = TRUE;
+
+            PostQuitMessage(0);
+            break;
+
+        default:
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+        }
+    return (FALSE);
+}
+
+
+/****************************************************************************
+
+    FUNCTION: About(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages for "About" dialog box
+
+    MESSAGES:
+
+        WM_INITDIALOG - initialize dialog box
+        WM_COMMAND    - Input received
+
+****************************************************************************/
+
+BOOL FAR PASCAL About(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
+    {
+    switch (message)
+        {
+        case WM_INITDIALOG:
+            return (TRUE);
+
+        case WM_COMMAND:
+            if (wParam == IDOK || wParam == IDCANCEL)
+                {
+                EndDialog(hDlg, TRUE);
+                return (TRUE);
+                }
+            break;
+        }
+    return (FALSE);
+    }
+
+
+//*************************************************
+//* Run the TestCase once per call.
+//* Case currently consists of :
+//* 
+//*   lineInitialize
+//*   lineOpen   
+//* lineClose
+//* lineShutdown
+//*************************************************
+long TestCase ( BOOL fOpenLines )
+{
+   long result       = 0L;
+   long errcode       = 0L;
+   HLINEAPP hLineApp    = 0L;
+//   DWORD   deviceID    = 0L;
+   LONG   deviceID    = 0L;
+   char   errstr[256];
+   HLINE   lineArray[30];   
+
+//* LineInitialize 
+
+   errcode =  lineInitialize(&hLineApp, ghInstance, (LINECALLBACK)&MyCallback, "INITTEST", &NumOfDevices);
+   if (errcode != 0L)
+   {
+      result = errcode;
+      sprintf( errstr,"lineInitialize Failed   error=0x%lx",errcode );
+      MessageBox(GetFocus(), errstr, "Error", MB_OK);
+      Bailout = TRUE;
+      goto cleanup;                 
+   }
+
+
+   if ( fOpenLines )
+   {
+
+//* Open all devices
+
+      for (deviceID = 0; deviceID < NumOfDevices; deviceID++ )
+      {
+             lineArray[deviceID] = 0L;
+
+            errcode =  lineOpen(hLineApp, deviceID, &lineArray[deviceID], 
+                           0x00010003,0L,0,LINECALLPRIVILEGE_NONE,0L,NULL);
+
+            if (errcode != 0L)
+            {
+               sprintf( errstr,"lineOpen Failed   device#= 0x%08lx error=0x%lx",deviceID, errcode );
+               MessageBox(GetFocus(), errstr, "Error", MB_OK);
+               Bailout = TRUE;
+            }
+      
+      }
+
+//* Close all open devices
+      for (;deviceID >= 1L;deviceID--)
+      {
+         errcode = lineClose(lineArray[deviceID-1]);
+         if (errcode != 0L)
+         {
+            sprintf( errstr,"lineClose Failed   error=0x%lx",errcode );
+            MessageBox(GetFocus(), errstr, "Error", MB_OK);
+            Bailout = TRUE;
+         }
+      }
+   }
+
+
+//* LineShutdown
+
+   {
+      MSG localmsg;
+
+      while ( PeekMessage( &localmsg,
+                        NULL,
+                        0,
+                        0,
+                        PM_REMOVE )
+         )
+      {
+         TranslateMessage(&localmsg);
+         DispatchMessage(&localmsg);
+      }
+   }
+
+   errcode =  lineShutdown(hLineApp);
+   if (errcode != 0L)
+   {
+      result = errcode;
+
+      sprintf( errstr,"lineShutdown Failed   error=0x%lx",errcode );
+
+      MessageBox(GetFocus(), errstr, "Error", MB_OK);
+
+      Bailout = TRUE;
+
+      goto cleanup;
+   }
+
+cleanup:
+   return(result);   
+
+}
diff --git a/private/tapi/qa/standalo/inittest/inittest.def b/private/tapi/qa/standalo/inittest/inittest.def
new file mode 100644
index 000000000..07543d0f2
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/inittest.def
@@ -0,0 +1,20 @@
+NAME         inittest
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+EXETYPE      WINDOWS
+
+STUB         'WINSTUB.EXE'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     4024
+STACKSIZE    12120
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/qa/standalo/inittest/inittest.h b/private/tapi/qa/standalo/inittest/inittest.h
new file mode 100644
index 000000000..b99321cc9
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/inittest.h
@@ -0,0 +1,27 @@
+#if !defined(tolltest_h)
+#define tolltest_h
+
+#define IDM_ABOUT     101
+
+#define IDM_TEST1     201
+#define IDM_TEST2     202
+#define IDM_TEST3     203
+#define IDM_TEST4     204
+#define IDM_TEST5     205
+
+#define IDM_TESTA     210
+#define IDM_TESTB     211
+#define IDM_TESTC     212
+
+#define IDM_STOPTEST  230
+
+#define ID_MENUSTR      301
+#define ID_CLASSSTR     302
+#define ID_CAPTIONSTR   303
+#define ID_DLGBOX       304
+#define ID_MSGBOXCAP    305
+#define ID_STATUS1      306
+#define ID_STATUS2      307
+#define ID_STATUS3      308
+
+#endif
diff --git a/private/tapi/qa/standalo/inittest/inittest.rc b/private/tapi/qa/standalo/inittest/inittest.rc
new file mode 100644
index 000000000..846135cd9
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/inittest.rc
@@ -0,0 +1,120 @@
+//Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#define APSTUDIO_HIDDEN_SYMBOLS
+#include "windows.h"
+#undef APSTUDIO_HIDDEN_SYMBOLS
+#include "inittest.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+INITTESTMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "& Init&open Tests"
+    BEGIN
+        MENUITEM "Test &1 - 32000 Init/open && close/Shutdown operations", IDM_TEST1
+        MENUITEM "Test &2 - 100 Init/open && close/Shutdown operations", IDM_TEST2
+        MENUITEM "Test &3 - Infinite Init/open && close/Shutdown operations", IDM_TEST5
+        MENUITEM SEPARATOR
+        MENUITEM "About &Sample ...",           IDM_ABOUT
+    END
+    POPUP "& Init only Tests"
+    BEGIN
+        MENUITEM "Test &A - 32000 Init && Shutdown operations", IDM_TESTA
+        MENUITEM "Test &B - 100 Init && Shutdown operations", IDM_TESTB
+        MENUITEM "Test &C - Infinite Init && Shutdown operations", IDM_TESTC
+    END
+    MENUITEM "&Stop test...",               IDM_STOPTEST
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+ABOUTBOX DIALOG DISCARDABLE  22, 17, 144, 75
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About InitTest"
+BEGIN
+    CTEXT           "Microsoft Windows TAPI InitTest Thingy",-1,0,5,144,8
+    CTEXT           "Version 0.1",-1,0,34,144,8
+    DEFPUSHBUTTON   "OK",IDOK,53,59,32,14,WS_GROUP
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""windows.h""\r\n"
+    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""inittest.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_MENUSTR              "InitTestMenu"
+    ID_CLASSSTR             "InitTestClass"
+    ID_CAPTIONSTR           "Microsoft Windows Telephony InitList Test thingy"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    ID_DLGBOX               "AboutBox"
+    ID_MSGBOXCAP            "InitList Test"
+    ID_STATUS1              "Entering Test"
+    ID_STATUS2              "Test Failed !"
+    ID_STATUS3              "Test Successful !"
+END
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/private/tapi/qa/standalo/inittest/makefile b/private/tapi/qa/standalo/inittest/makefile
new file mode 100644
index 000000000..31081c457
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/makefile
@@ -0,0 +1,23 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/qa/standalo/inittest/makefile.def b/private/tapi/qa/standalo/inittest/makefile.def
new file mode 100644
index 000000000..04544388a
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/makefile.def
@@ -0,0 +1,37 @@
+!ifdef WIN32
+all: cleanit initt32.exe
+!else
+all: cleanit inittest.exe
+!endif
+
+
+!ifdef WIN32
+APP_compile = -c -Zpie -W2 -Od /Fc
+!else
+APP_compile = -c -AM -Gw -Zpie -W2 -Od /Fc
+!endif
+APP_link = /CO /NOD /NOE
+
+inittest.obj: $*.c $*.h
+     cl $(APP_compile) $*.c
+
+inittest.res: $*.rc $*.h
+     rc -r $*.rc
+
+
+!ifdef WIN32
+initt32.exe: inittest.obj initt32.def inittest.res
+     link /DEF:initt32.def /MAP /MACHINE:IX86 /SUBSYSTEM:Windows /Defaultlib:user32.lib,gdi32.lib,tapi32.lib  inittest.obj inittest.res
+!else
+inittest.exe: inittest.obj inittest.def inittest.res
+     link $(APP_link) $*, $*, $*/map/li /align:16, libw ..\tapi.lib mlibcew, $*.def
+!endif
+     rc inittest.res
+     mapsym $*
+
+
+
+cleanit:
+     del inittest.obj
+     del inittest.res
+
diff --git a/private/tapi/qa/standalo/inittest/resource.h b/private/tapi/qa/standalo/inittest/resource.h
new file mode 100644
index 000000000..17cfe015f
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/resource.h
@@ -0,0 +1,16 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by initTEST.RC
+//
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/private/tapi/qa/standalo/inittest/sources b/private/tapi/qa/standalo/inittest/sources
new file mode 100644
index 000000000..26991ad25
--- /dev/null
+++ b/private/tapi/qa/standalo/inittest/sources
@@ -0,0 +1,28 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=initt32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32l.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMENTRY =winmain
+
+USE_CRTDLL=1
+
+SOURCES=inittest.c   \
+        inittest.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/standalo/lta_test/lta_test.c b/private/tapi/qa/standalo/lta_test/lta_test.c
new file mode 100644
index 000000000..c15725f07
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/lta_test.c
@@ -0,0 +1,443 @@
+/****************************************************************************
+
+    PROGRAM:  lta_test
+
+    PURPOSE:  Microsoft Sample Application
+
+    FUNCTIONS:
+
+         WinMain() - calls initialization function, processes message loop
+         MainWndProc() - processes messages
+         About() - processes messages for "About" dialog box
+         InitApplication() - initializes window data and registers window
+         InitInstance() - saves instance handle and creates main window
+         TestProc1() - First test procedure.
+         TestProc2() - Second test procedure.
+         TestProc3() - Third test procedure
+         TestProc4() - Fourth test procedure
+
+****************************************************************************/
+
+#include "windows.h"
+#include "lta_test.h"
+#include <tapi.h>
+
+int _pascal WinMain( HANDLE, HANDLE, LPSTR, int );
+long _far _pascal MainWndProc( HWND, unsigned, WORD, LONG );
+BOOL _far _pascal About( HWND, unsigned, WORD, LONG );
+static BOOL InitApplication( HANDLE );
+static BOOL InitInstance( HANDLE, int );
+static int _pascal TestProc1( HWND );
+static int _pascal TestProc2( HWND );
+static int _pascal TestProc3( HWND );
+static int _pascal TestProc4( HWND );
+
+static HANDLE hInst;
+static HWND   hwnd;            /* handle to main window */
+
+HLINEAPP ghLineApp = NULL;
+
+
+
+/***********************************************************************/
+/***********************************************************************/
+VOID CALLBACK _far _pascal MyCallback( HANDLE hDevice,
+                                       DWORD  dwMsg,
+                                       DWORD  dwCallbackInstance,
+                                       DWORD  dwParam1,
+                                       DWORD  dwParam2,
+                                       DWORD  dwParam3 )
+{
+    return;
+}
+
+
+
+
+
+
+
+
+
+
+//****************************************************************************
+//****************************************************************************
+void WriteNums( HWND hWnd, WORD wPass, WORD wPrefix )
+{
+   char szOutput[100];
+   int len;
+   HDC hdc;
+
+   len = wsprintf( szOutput, "Pass: %05d   Prefix:%03d", wPass, wPrefix);
+
+   hdc = GetDC( hWnd );
+
+   MoveTo( hdc, 10, 10 );
+
+   TextOut( hdc, 0, 0, szOutput, len );
+
+   ReleaseDC( hWnd, hdc );
+
+   SetWindowText( hWnd, szOutput );
+
+   return;
+}
+
+
+
+
+
+
+
+
+
+
+
+/****************************************************************************
+
+    FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
+
+    PURPOSE: calls initialization function, processes message loop
+
+****************************************************************************/
+
+int _pascal WinMain(HANDLE hInstance, HANDLE hPrevInstance,
+                    LPSTR lpCmdLine,  int nCmdShow)
+    {
+    MSG msg;
+    DWORD dwNumDevs;
+
+    if (hPrevInstance == 0)
+        if (InitApplication(hInstance) == 0)
+            return (FALSE);
+
+    if (InitInstance(hInstance, nCmdShow) == 0)
+        return (FALSE);
+
+    if ( lineInitialize( &ghLineApp,
+                         hInstance,
+                         (LINECALLBACK)&MyCallback,
+                         "TollTest",
+                         &dwNumDevs
+                       )
+       )
+    {
+
+        MessageBox( GetFocus(),
+                    "lineInitialize() failed",
+                    "Error",
+                    MB_OK
+                  );
+         return FALSE;
+
+    }
+
+
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+        {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        }
+
+    lineShutdown( ghLineApp );
+
+    return (msg.wParam);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: InitApplication(HANDLE)
+
+    PURPOSE: Initializes window data and registers window class
+
+****************************************************************************/
+
+static BOOL InitApplication(HANDLE hInstance)
+    {
+    WNDCLASS  wc;
+    char      szMenu[11], szClass[12];
+
+    LoadString (hInstance, ID_MENUSTR, szMenu, sizeof (szMenu));
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+
+    wc.style          = 0;
+    wc.lpfnWndProc    = MainWndProc;
+    wc.cbClsExtra     = 0;
+    wc.cbWndExtra     = 0;
+    wc.hInstance      = hInstance;
+    wc.hIcon          = LoadIcon(0, IDI_APPLICATION);
+    wc.hCursor        = LoadCursor(0, IDC_ARROW);
+    wc.hbrBackground  = GetStockObject(WHITE_BRUSH);
+    wc.lpszMenuName   = szMenu;
+    wc.lpszClassName  = szClass;
+
+    return (RegisterClass(&wc));
+    }
+
+
+/****************************************************************************
+
+    FUNCTION:  InitInstance(HANDLE, int)
+
+    PURPOSE:  Saves instance handle and creates main window
+
+****************************************************************************/
+
+static BOOL InitInstance(HANDLE hInstance, int nCmdShow)
+    {
+    char szClass[12], szTitle[40];
+
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+    LoadString (hInstance, ID_CAPTIONSTR, szTitle, sizeof (szTitle));
+
+    hInst = hInstance;
+
+    hwnd = CreateWindow(
+             szClass,
+             szTitle,
+             WS_OVERLAPPEDWINDOW,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             0,
+             0,
+             hInstance,
+             0 );
+
+    if (hwnd == 0 )
+        return ( FALSE );
+
+    ShowWindow(hwnd, nCmdShow);
+    UpdateWindow(hwnd);
+    return (TRUE);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages
+
+    MESSAGES:
+
+        WM_COMMAND    - application menu (About dialog box)
+        WM_DESTROY    - destroy window
+
+    COMMENTS:
+
+        WM_COMMAND processing:
+
+            IDM_ABOUT - display "About" box.
+            IDM_TEST1 - First Test Procedure.
+            IDM_TEST2 - Second Test Procedure.
+            IDM_TEST3 - Third Test Procedure.
+            IDM_TEST4 - Fourth Test Procedure.
+
+****************************************************************************/
+
+long _far _pascal MainWndProc(HWND hWnd, unsigned message,
+                              WORD wParam, LONG lParam)
+    {
+
+    FARPROC  lpProcAbout;
+    char szDlgBox[9], szMsgBoxCap[12], szStatus1[14], szStatus2[14];
+
+
+    char szAddress[20];
+    UINT uTollPrefix;
+    int n;
+    static BOOL Bailout = FALSE;
+    MSG localmsg;
+
+
+    LoadString (hInst, ID_DLGBOX, szDlgBox, sizeof (szDlgBox));
+    LoadString (hInst, ID_MSGBOXCAP, szMsgBoxCap, sizeof (szMsgBoxCap));
+    LoadString (hInst, ID_STATUS1, szStatus1, sizeof (szStatus1));
+    LoadString (hInst, ID_STATUS2, szStatus2, sizeof (szStatus2));
+
+    switch ( message )
+        {
+        case WM_COMMAND:
+            switch ( wParam )
+                {
+                case IDM_ABOUT:
+                    lpProcAbout = MakeProcInstance( About, hInst );
+                    DialogBox(hInst, szDlgBox, hWnd, lpProcAbout);
+                    FreeProcInstance( lpProcAbout );
+                    break;
+
+                case IDM_TEST1:
+                    MessageBox( GetFocus(), "Entering Test",
+                              "Sample Test 1", MB_ICONASTERISK | MB_OK );
+
+                    if( TestProc1( hWnd ) != TRUE )
+                        {
+                        MessageBox( GetFocus(), "Test Failed !",
+                                  "Sample Test 1", MB_ICONSTOP | MB_OK );
+                        }
+                    break;
+
+                case IDM_TEST2:
+                    MessageBox( GetFocus(), "Entering Test",
+                              "Sample Test 2", MB_ICONASTERISK | MB_OK );
+
+                    if( TestProc2( hWnd ) != TRUE )
+                        {
+                        MessageBox( GetFocus(), "Test Failed !",
+                                  "Sample Test 2", MB_ICONSTOP | MB_OK );
+                        }
+                    break;
+
+                case IDM_TEST3:
+                    MessageBox( GetFocus(), "Entering Test",
+                              "Sample Test 3", MB_ICONASTERISK | MB_OK );
+
+                    if( TestProc3( hWnd ) != TRUE )
+                        {
+                        MessageBox( GetFocus(), "Test Failed !",
+                                  "Sample Test 3", MB_ICONSTOP | MB_OK );
+                        }
+                    break;
+
+
+                case IDM_TEST4:
+                    MessageBox( GetFocus(), "Entering Test",
+                              " ", MB_ICONASTERISK | MB_OK );
+
+                    Bailout = FALSE;
+
+                    for ( n = 201; n < 1000 & !Bailout; n++)
+                    {
+
+                        Yield();
+
+                        if ( PeekMessage( &localmsg,
+                                          hWnd,
+                                          0,
+                                          0,
+                                          PM_REMOVE )
+                           )
+                        {
+                           TranslateMessage(&localmsg);
+                           DispatchMessage(&localmsg);
+                        }
+
+
+                        wsprintf( szAddress, "+1 (206) %03d-1212", n);
+
+                        WriteNums( hWnd, n-201, n );
+
+                        //
+                        // Try to add it.
+                        //
+                        if ( lineTranslateAddress( ghLineApp,
+                                           0,
+                                           szAddress,
+                                           wParam == IDM_TEST3 ?
+                                                 LINETOLLLISTOPTION_ADD :
+                                                 LINETOLLLISTOPTION_REMOVE )
+                           )
+                        {
+                            MessageBox(GetFocus(), "lineSetTollList call failed", "Error", MB_OK);
+                            break;
+                        }
+
+                    }
+                    if (Bailout)
+                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+                    else
+                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+                    break;
+
+                }
+            break;
+
+
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            break;
+
+        default:
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+     }
+
+    return (FALSE);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: About(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages for "About" dialog box
+
+    MESSAGES:
+
+        WM_INITDIALOG - initialize dialog box
+        WM_COMMAND    - Input received
+
+****************************************************************************/
+
+BOOL _far _pascal About(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
+    {
+    switch (message)
+        {
+        case WM_INITDIALOG:
+            return (TRUE);
+
+        case WM_COMMAND:
+            if (wParam == IDOK || wParam == IDCANCEL)
+                {
+                EndDialog(hDlg, TRUE);
+                return (TRUE);
+                }
+            break;
+        }
+    return (FALSE);
+    }
+
+/***********************************************************************/
+
+
+static int _pascal TestProc1( HWND hWnd )
+    {
+    MessageBox( GetFocus(), "Test Successful !",
+             "Sample Test 1", MB_ICONASTERISK | MB_OK );
+    return (TRUE);
+    }
+
+/***********************************************************************/
+
+
+static int _pascal TestProc2( HWND hWnd )
+    {
+    MessageBox( GetFocus(), "Test Successful !",
+             "Sample Test 2", MB_ICONASTERISK | MB_OK );
+    return (TRUE);
+    }
+
+/***********************************************************************/
+
+
+static int _pascal TestProc3( HWND hWnd )
+    {
+    MessageBox( GetFocus(), "Test Successful !",
+             "Sample Test 3", MB_ICONASTERISK | MB_OK );
+    return (TRUE);
+    }
+
+/***********************************************************************/
+
+
+static int _pascal TestProc4( HWND hWnd )
+    {
+    MessageBox( GetFocus(), "Test Successful !",
+             "Sample Test 4", MB_ICONASTERISK | MB_OK );
+    return (TRUE);
+    }
+
+/* END OF FILE */
diff --git a/private/tapi/qa/standalo/lta_test/lta_test.def b/private/tapi/qa/standalo/lta_test/lta_test.def
new file mode 100644
index 000000000..119c1584d
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/lta_test.def
@@ -0,0 +1,17 @@
+NAME         lta_test
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+EXETYPE      WINDOWS
+
+STUB         'WINSTUB.EXE'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     1024
+STACKSIZE    5120
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
diff --git a/private/tapi/qa/standalo/lta_test/lta_test.h b/private/tapi/qa/standalo/lta_test/lta_test.h
new file mode 100644
index 000000000..7129ae07d
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/lta_test.h
@@ -0,0 +1,20 @@
+#if !defined(lta_test_h)
+#define lta_test_h
+
+#define IDM_ABOUT     101
+
+#define IDM_TEST1     201
+#define IDM_TEST2     202
+#define IDM_TEST3     203
+#define IDM_TEST4     204
+
+#define ID_MENUSTR      301
+#define ID_CLASSSTR     302
+#define ID_CAPTIONSTR   303
+#define ID_DLGBOX       304
+#define ID_MSGBOXCAP    305
+#define ID_STATUS1      306
+#define ID_STATUS2      307
+#define ID_STATUS3      308
+
+#endif
diff --git a/private/tapi/qa/standalo/lta_test/lta_test.rc b/private/tapi/qa/standalo/lta_test/lta_test.rc
new file mode 100644
index 000000000..2f23541a4
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/lta_test.rc
@@ -0,0 +1,37 @@
+#include "windows.h"
+#include "lta_test.h"
+
+STRINGTABLE
+BEGIN
+  ID_MENUSTR,    "SampleMenu"
+  ID_CLASSSTR,   "SampleClass"
+  ID_CAPTIONSTR, "Microsoft Windows Sample Application"
+  ID_DLGBOX,     "AboutBox"
+  ID_MSGBOXCAP,  "Sample Test"
+  ID_STATUS1,    "Entering Test"
+  ID_STATUS2,    "Test Failed !"
+  ID_STATUS3,    "Test Successful !"
+END
+
+SampleMenu MENU
+BEGIN
+    POPUP        "&Sample"
+    BEGIN
+        MENUITEM   "Test &1",       IDM_TEST1
+        MENUITEM   "Test &2",       IDM_TEST2
+        MENUITEM   "Test &3",       IDM_TEST3
+        MENUITEM   "Test &4",       IDM_TEST4
+        MENUITEM   SEPARATOR
+        MENUITEM   "&About Sample ...", IDM_ABOUT
+    END
+END
+
+AboutBox DIALOG 22, 17, 144, 75
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About Sample"
+BEGIN
+    CTEXT "Microsoft Windows"     -1,       0,  5, 144,  8
+    CTEXT "Sample Application"    -1,       0, 14, 144,  8
+    CTEXT "Version 3.0"           -1,       0, 34, 144,  8
+    DEFPUSHBUTTON "OK"          IDOK,      53, 59,  32, 14, WS_GROUP
+END
diff --git a/private/tapi/qa/standalo/lta_test/makefile b/private/tapi/qa/standalo/lta_test/makefile
new file mode 100644
index 000000000..31081c457
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/makefile
@@ -0,0 +1,23 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/qa/standalo/lta_test/makefile.def b/private/tapi/qa/standalo/lta_test/makefile.def
new file mode 100644
index 000000000..95e982126
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/makefile.def
@@ -0,0 +1,15 @@
+all: lta_test.exe
+
+APP_compile = -c -AM -Gw -Zpie -W2 -Od /Fc
+APP_link = /CO /NOD /NOE
+
+lta_test.obj: $*.c $*.h makefile
+     cl $(APP_compile) $*.c
+
+lta_test.res: $*.rc $*.h makefile
+     rc -r $*.rc
+
+lta_test.exe: $*.obj $*.def $*.res
+     link $(APP_link) $*, $*, $*/map/li /align:16, libw ..\tapi.lib mlibcew, $*.def
+     rc $*.res
+     mapsym $*
diff --git a/private/tapi/qa/standalo/lta_test/sources b/private/tapi/qa/standalo/lta_test/sources
new file mode 100644
index 000000000..5c70f094e
--- /dev/null
+++ b/private/tapi/qa/standalo/lta_test/sources
@@ -0,0 +1,28 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=lta_t32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMENTRY =winmain
+
+USE_CRTDLL=1
+
+SOURCES=lta_test.c   \
+        lta_test.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/standalo/tolltest/makefile b/private/tapi/qa/standalo/tolltest/makefile
new file mode 100644
index 000000000..31081c457
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/makefile
@@ -0,0 +1,23 @@
+!if "$(OS)" == "Windows_NT"
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+
+!else
+
+#Ok, we're doing a Win9x build.
+
+ROOT=..\..\..\..\..
+
+VERSIONLIST=debug retail
+
+DEPENDNAME=depend.mk
+
+COMMONMKFILE=makefile.def
+
+IS_OEM=TRUE
+IS_32 = TRUE
+
+!include $(ROOT)\dev\master.mk
+
+!endif
+
diff --git a/private/tapi/qa/standalo/tolltest/makefile.32 b/private/tapi/qa/standalo/tolltest/makefile.32
new file mode 100644
index 000000000..0d7c5d01f
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/makefile.32
@@ -0,0 +1,16 @@
+all: tollt32.exe
+
+APP_compile = -c -Zpie -W2 -Od /Fc
+APP_link = /CO /NOD /NOE
+
+tolltest.obj: $*.c $*.h
+     cl $(APP_compile) $*.c
+
+tolltest.res: $*.rc $*.h
+     rc -r $*.rc
+
+#;     link $(APP_link) $*, $*, $*/map/li , libw ..\tapi.lib mlibcew,
+
+tollt32.exe: tolltest.obj tolltest.def tolltest.res
+     link /DEF:tollt32.def /MAP /MACHINE:IX86 /SUBSYSTEM:Windows /Defaultlib:user32.lib,gdi32.lib,tapi32.lib  tolltest.obj tolltest.res
+     mapsym $*
diff --git a/private/tapi/qa/standalo/tolltest/makefile.def b/private/tapi/qa/standalo/tolltest/makefile.def
new file mode 100644
index 000000000..5d4523b41
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/makefile.def
@@ -0,0 +1,15 @@
+all: tolltest.exe
+
+APP_compile = -c -AM -Gw -Zpie -W2 -Od /Fc
+APP_link = /CO /NOD /NOE
+
+tolltest.obj: $*.c $*.h
+     cl $(APP_compile) $*.c
+
+tolltest.res: $*.rc $*.h
+     rc -r $*.rc
+
+tolltest.exe: $*.obj $*.def $*.res
+     link $(APP_link) $*, $*, $*/map/li /align:16, libw ..\tapi.lib mlibcew, $*.def
+     rc $*.res
+     mapsym $*
diff --git a/private/tapi/qa/standalo/tolltest/sources b/private/tapi/qa/standalo/tolltest/sources
new file mode 100644
index 000000000..da0676673
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/sources
@@ -0,0 +1,28 @@
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tollt32
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+           $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comctl32.lib
+
+INCLUDES=..\inc;$(BASEDIR)\public\sdk\inc;.
+
+C_DEFINES=-DWINVER=0x0400 -DTAPI_NT=1
+
+UMENTRY =winmain
+
+USE_CRTDLL=1
+
+SOURCES=tolltest.c   \
+        tolltest.rc
+
+UMTYPE=windows
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/standalo/tolltest/tollt32.def b/private/tapi/qa/standalo/tolltest/tollt32.def
new file mode 100644
index 000000000..9e5896a18
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/tollt32.def
@@ -0,0 +1,13 @@
+NAME         tollt32
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/qa/standalo/tolltest/tolltest.c b/private/tapi/qa/standalo/tolltest/tolltest.c
new file mode 100644
index 000000000..1867f28af
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/tolltest.c
@@ -0,0 +1,508 @@
+/****************************************************************************
+
+    PROGRAM:  tolltest
+
+    PURPOSE:  Microsoft Sample Application
+
+    FUNCTIONS:
+
+         WinMain() - calls initialization function, processes message loop
+         MainWndProc() - processes messages
+         About() - processes messages for "About" dialog box
+         InitApplication() - initializes window data and registers window
+         InitInstance() - saves instance handle and creates main window
+         TestProc1() - First test procedure.
+         TestProc2() - Second test procedure.
+         TestProc3() - Third test procedure
+         TestProc4() - Fourth test procedure
+
+****************************************************************************/
+
+#include "windows.h"
+#include <tapi.h>
+#include <stdlib.h>
+
+#include "tolltest.h"
+
+
+
+#ifndef WIN32
+#define MoveToEx( hdc, x, y, z )   MoveTo( hdc, x, y )
+#endif
+
+
+
+//void FAR _cdecl _DebugOutput( UINT flags, LPCSTR lpszFmt, ... );
+
+
+int PASCAL WinMain( HINSTANCE, HINSTANCE, LPSTR, int );
+//long FAR PASCAL MainWndProc( HWND, unsigned, WORD, LONG );
+LRESULT CALLBACK MainWndProc( HWND, UINT, WPARAM, LPARAM );
+BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );
+static BOOL InitApplication( HANDLE );
+static BOOL InitInstance( HANDLE, int );
+static int PASCAL TestProc1( HWND );
+static int PASCAL TestProc2( HWND );
+static int PASCAL TestProc3( HWND );
+static int PASCAL TestProc4( HWND );
+
+static HANDLE hInst;
+static HWND   hwnd;            /* handle to main window */
+
+HLINEAPP ghLineApp = NULL;
+
+
+
+//****************************************************************************
+//****************************************************************************
+#define RandomNumber(min,max) ((UINT) ( (long)rand()*(max-min) / (long)RAND_MAX ) + min)
+
+
+
+/***********************************************************************/
+/***********************************************************************/
+VOID CALLBACK FAR PASCAL MyCallback( HANDLE hDevice,
+                                       DWORD  dwMsg,
+                                       DWORD  dwCallbackInstance,
+                                       DWORD  dwParam1,
+                                       DWORD  dwParam2,
+                                       DWORD  dwParam3 )
+{
+    return;
+}
+
+
+/****************************************************************************
+
+    FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
+
+    PURPOSE: calls initialization function, processes message loop
+
+****************************************************************************/
+
+int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                    LPSTR lpCmdLine,  int nCmdShow)
+    {
+    MSG msg;
+    DWORD dwNumDevs;
+    if (hPrevInstance == 0)
+        if (InitApplication(hInstance) == 0)
+        {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "initapp failed Lasterr=0x%08lx", err);
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                        "Error",
+                        MB_OK
+                      );
+            return (FALSE);
+        }
+
+    if (InitInstance(hInstance, nCmdShow) == 0)
+    {
+            char ErrMsg[100];
+            DWORD err;
+
+            err = GetLastError();
+
+            wsprintf( ErrMsg, "initapp failed Lasterr=0x%08lx", err );
+
+            MessageBox( GetFocus(),
+                        ErrMsg,
+                    "Error",
+                    MB_OK
+                  );
+        return (FALSE);
+    }
+
+
+    if ( lineInitialize( &ghLineApp,
+                         hInstance,
+                         (LINECALLBACK)&MyCallback,
+                         "TollTest",
+                         &dwNumDevs
+                       )
+       )
+    {
+
+        MessageBox( GetFocus(),
+                    "lineInitialize() failed",
+                    "Error",
+                    MB_OK
+                  );
+         return FALSE;
+
+    }
+
+
+    while (GetMessage(&msg, 0, 0, 0) != 0)
+        {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        }
+
+
+    lineShutdown( ghLineApp );
+
+    return (msg.wParam);
+    }
+
+
+/****************************************************************************
+
+    FUNCTION: InitApplication(HANDLE)
+
+    PURPOSE: Initializes window data and registers window class
+
+****************************************************************************/
+
+static BOOL InitApplication(HANDLE hInstance)
+    {
+    WNDCLASS  wc;
+    char      szMenu[26], szClass[26];
+
+    LoadString (hInstance, ID_MENUSTR, szMenu, sizeof (szMenu));
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+
+    wc.style          = 0;
+    wc.lpfnWndProc    = MainWndProc;
+    wc.cbClsExtra     = 0;
+    wc.cbWndExtra     = 0;
+    wc.hInstance      = hInstance;
+    wc.hIcon          = LoadIcon(0, IDI_APPLICATION);
+    wc.hCursor        = LoadCursor(0, IDC_ARROW);
+    wc.hbrBackground  = GetStockObject(WHITE_BRUSH);
+    wc.lpszMenuName   = (LPSTR)szMenu;
+    wc.lpszClassName  = (LPSTR)szClass;
+
+    return (RegisterClass(&wc));
+    }
+
+
+/****************************************************************************
+
+    FUNCTION:  InitInstance(HANDLE, int)
+
+    PURPOSE:  Saves instance handle and creates main window
+
+****************************************************************************/
+
+static BOOL InitInstance(HANDLE hInstance, int nCmdShow)
+    {
+    char szClass[16], szTitle[40];
+
+    LoadString (hInstance, ID_CLASSSTR, szClass, sizeof (szClass));
+    LoadString (hInstance, ID_CAPTIONSTR, szTitle, sizeof (szTitle));
+
+    hInst = hInstance;
+
+    hwnd = CreateWindow(
+             szClass,
+             szTitle,
+             WS_OVERLAPPEDWINDOW,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             CW_USEDEFAULT,
+             0,
+             0,
+             hInstance,
+             0 );
+
+    if (hwnd == 0 )
+        return ( FALSE );
+
+    ShowWindow(hwnd, nCmdShow);
+    UpdateWindow(hwnd);
+    return (TRUE);
+    }
+
+
+
+
+
+
+
+
+
+void WriteNums( HWND hWnd, DWORD dwPass, WORD wPrefix )
+{
+   char szOutput[100];
+   int len;
+   HDC hdc;
+
+   len = wsprintf( szOutput,
+#ifdef WIN32
+   "T32-%08ld Prefx:%03d", dwPass, wPrefix);
+#else
+   "T16-%08ld Prefx:%03d", dwPass, wPrefix);
+#endif
+
+   hdc = GetDC( hWnd );
+
+   MoveToEx( hdc, 10, 10, NULL );
+
+   TextOut( hdc, 0, 0, szOutput, len );
+
+   ReleaseDC( hWnd, hdc );
+
+   SetWindowText( hWnd, szOutput );
+
+   return;
+}
+
+
+
+
+
+
+
+
+
+
+
+/****************************************************************************
+
+    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages
+
+    MESSAGES:
+
+        WM_COMMAND    - application menu (About dialog box)
+        WM_DESTROY    - destroy window
+
+    COMMENTS:
+
+
+****************************************************************************/
+
+LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,
+                              WPARAM wParam, LPARAM lParam)
+{
+
+    FARPROC  lpProcAbout;
+    char szDlgBox[9], szMsgBoxCap[12], szStatus1[14], szStatus2[14];
+
+    char szAddress[20];
+    WORD uTollPrefix;
+    DWORD n;
+    static BOOL Bailout = FALSE;
+    MSG localmsg;
+
+
+
+    LoadString (hInst, ID_DLGBOX, szDlgBox, sizeof (szDlgBox));
+    LoadString (hInst, ID_MSGBOXCAP, szMsgBoxCap, sizeof (szMsgBoxCap));
+    LoadString (hInst, ID_STATUS1, szStatus1, sizeof (szStatus1));
+    LoadString (hInst, ID_STATUS2, szStatus2, sizeof (szStatus2));
+
+    switch ( message )
+        {
+        case WM_COMMAND:
+            switch ( wParam )
+                {
+                case IDM_ABOUT:
+                    lpProcAbout = MakeProcInstance( About, hInst );
+                    DialogBox(hInst, szDlgBox, hWnd, lpProcAbout);
+                    FreeProcInstance( lpProcAbout );
+                    break;
+
+
+                case IDM_STOPTEST:
+                    Bailout = TRUE;
+                    break;
+
+
+                case IDM_TEST1:
+                case IDM_TEST2:
+                case IDM_TEST5:
+                {
+                    DWORD dwLoops;
+
+                    //
+                    // This test
+                    // randomly picks numbers to add and remove.
+                    //
+
+                    dwLoops = ( wParam == IDM_TEST1 ? 32000 : 100 );
+
+
+                    Bailout = FALSE;
+
+                    for ( n = 0 ;
+                          !Bailout && ((n < dwLoops) || (wParam == IDM_TEST5));
+                          n++)
+                    {
+
+                        Yield();
+
+                        if ( PeekMessage( &localmsg,
+                                          hWnd,
+                                          0,
+                                          0,
+                                          PM_REMOVE )
+                           )
+                        {
+                           TranslateMessage(&localmsg);
+                           DispatchMessage(&localmsg);
+                        }
+
+
+                        uTollPrefix = RandomNumber(201, 999);
+
+                        wsprintf( szAddress, "+1 (206) %03d-1212", uTollPrefix);
+
+                        if ( RandomNumber(0,200)> 100 )
+                        {
+
+                            WriteNums( hWnd, n, uTollPrefix );
+
+                            //
+                            // Try to add it.
+                            //
+                            if ( lineSetTollList( ghLineApp,
+                                               0,
+                                               szAddress,
+                                               LINETOLLLISTOPTION_ADD )
+                               )
+                            {
+                                MessageBox(GetFocus(), "lineSetTollList (Add) failed", "Error", MB_OK);
+                                break;
+                            }
+
+                        }
+                        else
+                        {
+                            //
+                            // Try to remove it.
+                            //
+                            if ( lineSetTollList( ghLineApp,
+                                               0,
+                                               szAddress,
+                                               LINETOLLLISTOPTION_REMOVE )
+                               )
+                            {
+                                MessageBox(GetFocus(), "lineSetTollList (Remove) failed", "Error", MB_OK);
+                                break;
+                            }
+
+                        }
+
+                    }
+
+                    if (Bailout)
+                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+                    else
+                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+                    break;
+                }
+
+
+                case IDM_TEST3:
+                case IDM_TEST4:
+                    MessageBox( GetFocus(), "Entering Test",
+                              " ", MB_ICONASTERISK | MB_OK );
+
+                    Bailout = FALSE;
+
+                    for ( n = 201; n < 1000 & !Bailout; n++)
+                    {
+
+                        Yield();
+
+                        if ( PeekMessage( &localmsg,
+                                          hWnd,
+                                          0,
+                                          0,
+                                          PM_REMOVE )
+                           )
+                        {
+                           TranslateMessage(&localmsg);
+                           DispatchMessage(&localmsg);
+                        }
+
+
+                        wsprintf( szAddress, "+1 (206) %03d-1212", n);
+
+                        WriteNums( hWnd, (DWORD)(n-201), (WORD)n );
+
+                        //
+                        // Try to add it.
+                        //
+                        if ( lineSetTollList( ghLineApp,
+                                           0,
+                                           szAddress,
+                                           wParam == IDM_TEST3 ?
+                                                 LINETOLLLISTOPTION_ADD :
+                                                 LINETOLLLISTOPTION_REMOVE )
+                           )
+                        {
+                            MessageBox(GetFocus(), "lineSetTollList call failed", "Error", MB_OK);
+                            break;
+                        }
+
+                    }
+                    if (Bailout)
+                        MessageBox(GetFocus(), "Operation stopped", "Done.", MB_OK);
+                    else
+                        MessageBox(GetFocus(), "Operation complete", "Done.", MB_OK);
+
+                    break;
+
+
+                }
+            break;
+
+        case WM_DESTROY:
+
+            Bailout = TRUE;
+
+            PostQuitMessage(0);
+            break;
+
+        default:
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+     }
+
+    return (FALSE);
+}
+
+
+/****************************************************************************
+
+    FUNCTION: About(HWND, unsigned, WORD, LONG)
+
+    PURPOSE:  Processes messages for "About" dialog box
+
+    MESSAGES:
+
+        WM_INITDIALOG - initialize dialog box
+        WM_COMMAND    - Input received
+
+****************************************************************************/
+
+BOOL FAR PASCAL About(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
+    {
+    switch (message)
+        {
+        case WM_INITDIALOG:
+            return (TRUE);
+
+        case WM_COMMAND:
+            if (wParam == IDOK || wParam == IDCANCEL)
+                {
+                EndDialog(hDlg, TRUE);
+                return (TRUE);
+                }
+            break;
+        }
+    return (FALSE);
+    }
+
diff --git a/private/tapi/qa/standalo/tolltest/tolltest.def b/private/tapi/qa/standalo/tolltest/tolltest.def
new file mode 100644
index 000000000..b1fb6845e
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/tolltest.def
@@ -0,0 +1,20 @@
+NAME         tolltest
+
+DESCRIPTION  'Microsoft Windows Sample Application'
+
+EXETYPE      WINDOWS
+
+STUB         'WINSTUB.EXE'
+
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE     4024
+STACKSIZE    12120
+
+EXPORTS
+   MainWndProc     @1
+   About           @2
+
+;IMPORTS
+;   kernel._DebugOutput
diff --git a/private/tapi/qa/standalo/tolltest/tolltest.h b/private/tapi/qa/standalo/tolltest/tolltest.h
new file mode 100644
index 000000000..5693a81e9
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/tolltest.h
@@ -0,0 +1,23 @@
+#if !defined(tolltest_h)
+#define tolltest_h
+
+#define IDM_ABOUT     101
+
+#define IDM_TEST1     201
+#define IDM_TEST2     202
+#define IDM_TEST3     203
+#define IDM_TEST4     204
+#define IDM_TEST5     205
+
+#define IDM_STOPTEST  230
+
+#define ID_MENUSTR      301
+#define ID_CLASSSTR     302
+#define ID_CAPTIONSTR   303
+#define ID_DLGBOX       304
+#define ID_MSGBOXCAP    305
+#define ID_STATUS1      306
+#define ID_STATUS2      307
+#define ID_STATUS3      308
+
+#endif
diff --git a/private/tapi/qa/standalo/tolltest/tolltest.rc b/private/tapi/qa/standalo/tolltest/tolltest.rc
new file mode 100644
index 000000000..00b148b08
--- /dev/null
+++ b/private/tapi/qa/standalo/tolltest/tolltest.rc
@@ -0,0 +1,39 @@
+#include "windows.h"
+#include "tolltest.h"
+
+STRINGTABLE
+BEGIN
+  ID_MENUSTR,    "TollTestMenu"
+  ID_CLASSSTR,   "TollTestClass"
+  ID_CAPTIONSTR, "Microsoft Windows Telephony TollList Test thingy"
+  ID_DLGBOX,     "AboutBox"
+  ID_MSGBOXCAP,  "TollList Test"
+  ID_STATUS1,    "Entering Test"
+  ID_STATUS2,    "Test Failed !"
+  ID_STATUS3,    "Test Successful !"
+END
+
+TollTestMenu MENU
+BEGIN
+    POPUP        "&Tests"
+    BEGIN
+        MENUITEM   "Test &1 - 32000 random add or remove operations",       IDM_TEST1
+        MENUITEM   "Test &2 - 100 random add or remove operations",       IDM_TEST2
+        MENUITEM   "Test &3 - add 201-999 prefixes",       IDM_TEST3
+        MENUITEM   "Test &4 - remove 201-999 prefixes",       IDM_TEST4
+        MENUITEM   SEPARATOR
+        MENUITEM   "Test &5 - Infinite random add or remove operations",       IDM_TEST5
+        MENUITEM   SEPARATOR
+        MENUITEM   "&About Sample ...", IDM_ABOUT
+    END
+    MENUITEM        "&Stop test...", IDM_STOPTEST
+END
+
+AboutBox DIALOG 22, 17, 144, 75
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About TollTest"
+BEGIN
+    CTEXT "Microsoft Windows TAPI TollList Test Thingy"     -1,       0,  5, 144,  8
+    CTEXT "Version 0.1"           -1,       0, 34, 144,  8
+    DEFPUSHBUTTON "OK"          IDOK,      53, 59,  32, 14, WS_GROUP
+END
diff --git a/private/tapi/qa/tcore/devspec.h b/private/tapi/qa/tcore/devspec.h
new file mode 100644
index 000000000..2c8134663
--- /dev/null
+++ b/private/tapi/qa/tcore/devspec.h
@@ -0,0 +1,200 @@
+/*++
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    devspec.h
+
+Abstract:
+
+    This module contains the line/phoneDevSpecific interface
+    definitions for tapi apps to pass data to esp32.tsp,
+    i.e. msgs the app wants esp32.tsp to indicate
+
+Author:
+
+    Dan Knudson (DanKn)    25-Apr-1996
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+
+#define ESPDEVSPECIFIC_KEY  ((DWORD) 'DPSE')
+
+#define ESP_DEVSPEC_MSG     1
+#define ESP_DEVSPEC_RESULT  2
+
+
+//
+// The following structure is used when an app wants to tell esp to
+// indicate a certain message, i.e. LINE_ADDRESSSTATE.  Note that
+// the fields must be filled in with values that are valid at the
+// SPI level, which are not necessarily the same as those at the
+// API level. (Consult the win32 sdk for more info.)  For example,
+// there is no LINE_CALLDEVSPECIFIC message defined a the API level,
+// but it is used at the SPI level to denote that TAPI should pass
+// the corresponding call handle (rather than the line handle) to
+// apps in the hDevice parameter of the LINE_DEVSPECIFIC message
+//
+
+typedef struct _ESPDEVSPECMSG
+{
+    DWORD           dwMsg;
+    DWORD           dwParam1;
+    DWORD           dwParam2;
+    DWORD           dwParam3;
+
+} ESPDEVSPECMSG, *PESPDEVSPECMSG;
+
+
+//
+// The following structure is used when an app wants to tell esp how
+// to complete next request.  (Bear in mind that esp may override the
+// app's request if it encounters an "internal" error somewhere along
+// the way.)  Valid values for the "lResult" field are 0 or any of
+// the LINEERR_XXX / PHONEERR_XXX constants defined in tapi.h.  Valid
+// values for the "dwCompletionType" field are any of the ESP_RESULT_XXX
+// values defined below.
+//
+// This operation allows for testing the following scenarios for
+// synchronous telephony APIs:
+//
+//      1.  Service provider's TSPI_xxx function returns success.
+//          App recives success result
+//
+//      2.  Service provider's TSPI_xxx function returns error.
+//          App recives error result
+//
+// This operation allows for testing the following scenarios for
+// ASYNCHRONOUS telephony APIs (in each case, app recieves a request
+// id from the API, then later a LINE/PHONE_REPLY msg with a matching
+// request id (dwParam1) and result (dwParam2)):
+//
+//      1.  Service provider's TSPI_xxx func calls tapi's completion proc
+//          with success result
+//
+//      2.  Service provider's worker thread calls tapi's completion proc
+//          with success result
+//
+//      3.  Service provider's TSPI_xxx function returns error
+//
+//      4.  Service provider's TSPI_xxx func calls tapi's completion proc
+//          with error result
+//
+//      5.  Service provider's worker thread calls tapi's completion proc
+//          with error result
+//
+
+typedef struct _ESPDEVSPECRESULT
+{
+    LONG            lResult;            // 0, LINEERR_XXX, PHONEERR_XXX
+    DWORD           dwCompletionType;   // ESP_RESULT_XXX
+
+} ESPDEVSPECRESULT, *PESPDEVSPECRESULT;
+
+#define ESP_RESULT_RETURNRESULT         0
+#define ESP_RESULT_CALLCOMPLPROCSYNC    1
+#define ESP_RESULT_CALLCOMPLPROCASYNC   2
+
+
+//
+// The following structure is the device specific information
+// "wrapper".  The app must initialize the dwKey & dwType fields
+// to create a valid header and fill in the appropriate
+// union substructure before passing the info to esp32.tsp via
+// line/phoneDevSpecific.
+//
+// If esp32.tsp detects an invalid parameter(s) it will return an
+// OPERATIONFAILED error, and spit out relevant debug information
+// in the espexe.exe window.
+//
+
+typedef struct _ESPDEVSPECIFICINFO
+{
+    DWORD           dwKey;      // App must init this to ESPDEVSPECIFIC_KEY
+    DWORD           dwType;     // App must init this to ESP_DEVSPEC_MSG, ...
+
+    union
+    {
+
+    ESPDEVSPECMSG       EspMsg;
+    ESPDEVSPECRESULT    EspResult;
+
+    } u;
+
+} ESPDEVSPECIFICINFO, *PESPDEVSPECIFICINFO;
+
+
+/*
+
+//
+// Example: if an app wanted esp32.tsp to indicate a
+//          LINE_LINEDEVSTATE\RENINIT msg it would do
+//          the following
+//
+
+{
+    LONG                 lResult;
+    HLINE                hLine;
+    ESPDEVSPECIFICINFO   info;
+
+
+    // do a lineInitialize, lineNegotiateAPIVersion, lineOpen, etc...
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+
+    info.u.EspMsg.dwMsg    = LINE_LINEDEVSTATE;
+    info.u.EspMsg.dwParam1 = LINEDEVSTATE_REINIT;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lResult = lineDevSpecific (hLine, 0, NULL, &info, sizeof (info));
+
+    // some time later a LINE_LINEDEVSTATE\REINIT msg will show up
+}
+
+
+//
+// Example: if an app wanted esp32.tsp to fail a request
+//          to lineMakeCall asynchronously with the error
+//          LINEERR_CALLUNAVAIL it would do the following
+//          (ESP's worker thread would complete the request
+//          in this case)
+//
+
+{
+    LONG                 lResult, lResult2;
+    HCALL                hCall;
+    HLINE                hLine;
+    ESPDEVSPECIFICINFO   info;
+
+
+    // do a lineInitialize, lineNegotiateAPIVersion, lineOpen, etc...
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+    info.u.EspResult.lResult          = LINEERR_CALLUNAVAIL;
+    info.u.EspResult.dwCompletionType = ESP_RESULT_CALLCOMPLPROCASYNC;
+
+    lResult = lineDevSpecific (hLine, 0, NULL, &info, sizeof (info));
+
+    lResult2 = lineMakeCall (hLine, &hCall, "555-1212", 1, NULL);
+
+    // some time later a LINE_REPLY will show for for both the DevSpecific
+    // & MakeCall requests.  the LINE_REPLY for the MakeCall will have
+    // dwParam1 = lResult2, and dwParam2 = LINEERR_CALLUNAVAIL
+}
+
+
+*/
diff --git a/private/tapi/qa/tcore/dirs b/private/tapi/qa/tcore/dirs
new file mode 100644
index 000000000..529e884a3
--- /dev/null
+++ b/private/tapi/qa/tcore/dirs
@@ -0,0 +1,2 @@
+DIRS= tcorea \
+      tcorew
diff --git a/private/tapi/qa/tcore/doline.c b/private/tapi/qa/tcore/doline.c
new file mode 100644
index 000000000..00f2cdc48
--- /dev/null
+++ b/private/tapi/qa/tcore/doline.c
@@ -0,0 +1,7844 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    doline.c
+
+Abstract:
+
+    This module contains the wrapper functions around the TAPI line device
+    functions.  These functions provide logging and both synchronous
+    and asynchronous API processing to any application or dll using the
+    core dll.
+
+Author:
+
+    Oliver Wallace	(OliverW)   24-Nov-1995
+
+Revision History:
+	
+	Rama Koneru		(a-ramako)	19-Mar-1996		Modified to bld with UNICODE APIs
+
+--*/
+
+
+#define _TCORELIB_
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "doline.h"
+#include "vars.h"
+
+
+BOOL
+WINAPI
+DoLineAccept(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAccept:  enter");
+	
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    (lpTapiLineTestInfo->lpsUserUserInfo == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=x%lx",
+	       lpTapiLineTestInfo->lpsUserUserInfo);
+
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+	lActual = lineAccept(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpsUserUserInfo,
+	       lpTapiLineTestInfo->dwSize
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAccept:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lAccept, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineAddProvider(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAddProvider:  enter");
+
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszProviderFilename == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszProviderFilename=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszProviderFilename=%lx",
+	       lpTapiLineTestInfo->lpwszProviderFilename);
+#else
+    (lpTapiLineTestInfo->lpszProviderFilename == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszProviderFilename=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszProviderFilename=%lx",
+	       lpTapiLineTestInfo->lpszProviderFilename);
+#endif
+    (lpTapiLineTestInfo->hwndOwner == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=x%lx",
+	       lpTapiLineTestInfo->hwndOwner);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwPermanentProviderID=x%lx",
+	       lpTapiLineTestInfo->lpdwPermanentProviderID);
+
+#ifdef WUNICODE
+	lActual = lineAddProviderW(
+	    lpTapiLineTestInfo->lpwszProviderFilename,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpdwPermanentProviderID
+	    );
+#else
+	lActual = lineAddProvider(
+	    lpTapiLineTestInfo->lpszProviderFilename,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpdwPermanentProviderID
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAddProvider:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lAddProvider, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineAddToConference(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAddToConference:  enter");
+    (lpTapiLineTestInfo->lphConfCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConfCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thConfCall=x%lx",
+	       *lpTapiLineTestInfo->lphConfCall);
+    (lpTapiLineTestInfo->lphConsultCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thConsultCall=x%lx",
+	       *lpTapiLineTestInfo->lphConsultCall);
+
+    lActual = lineAddToConference(
+	       *lpTapiLineTestInfo->lphConfCall,
+	       *lpTapiLineTestInfo->lphConsultCall
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAddToConference:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lAddToConference, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+	   if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineAnswer(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAnswer:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    
+	(lpTapiLineTestInfo->lpsUserUserInfo == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=%lx",
+	       lpTapiLineTestInfo->lpsUserUserInfo);
+
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+    
+	lActual = lineAnswer(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpsUserUserInfo,
+	       lpTapiLineTestInfo->dwSize
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAnswer:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lAnswer, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineBlindTransfer(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineBlindTransfer:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL")  :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+#ifdef WUNICODE
+	(lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+#else
+    (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCountryCode=x%lx",
+	       lpTapiLineTestInfo->dwCountryCode);
+
+#ifdef WUNICODE
+	lActual = lineBlindTransferW(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpwszDestAddress,
+	       lpTapiLineTestInfo->dwCountryCode
+	       );
+#else
+	lActual = lineBlindTransfer(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpszDestAddress,
+	       lpTapiLineTestInfo->dwCountryCode
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineBlindTransfer:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lBlindTransfer, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+   	if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineClose(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineClose:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *(lpTapiLineTestInfo->lphLine));
+
+    lActual = lineClose(*(lpTapiLineTestInfo->lphLine));
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineClose:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lClose, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineCompleteCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineCompleteCall:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwCompletionID=x%lx",
+	       lpTapiLineTestInfo->lpdwCompletionID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCompletionMode=x%lx",
+	       lpTapiLineTestInfo->dwCompletionMode);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMessageID=x%lx",
+	       lpTapiLineTestInfo->dwMessageID);
+
+    lActual = lineCompleteCall(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpdwCompletionID,
+	       lpTapiLineTestInfo->dwCompletionMode,
+	       lpTapiLineTestInfo->dwMessageID
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineCompleteCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lCompleteCall, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineCompleteTransfer(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineCompleteTransfer:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lphConsultCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thConsultCall=x%lx",
+	       *lpTapiLineTestInfo->lphConsultCall);
+    (lpTapiLineTestInfo->lphConfCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConfCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConfCall=x%lx",
+	       lpTapiLineTestInfo->lphConfCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTransferMode=x%lx",
+	       lpTapiLineTestInfo->dwTransferMode);
+
+    lActual = lineCompleteTransfer(
+	       *lpTapiLineTestInfo->lphCall,
+	       *lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->lphConfCall,
+	       lpTapiLineTestInfo->dwTransferMode
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineCompleteTransfer:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lCompleteTransfer, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineConfigDialog(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected)
+{
+    LONG lActual;
+    HWND hwndTop, hwndDlg;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineConfigDialog:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    (lpTapiLineTestInfo->hwndOwner == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=x%lx",
+	       lpTapiLineTestInfo->hwndOwner);
+
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+	lActual = lineConfigDialogW(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpwszDeviceClass
+	    );
+#else
+    (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+
+	lActual = lineConfigDialog(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpszDeviceClass
+	    );
+
+#endif
+
+    
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineConfigDialog:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lConfigDialog, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineConfigDialogEdit(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineConfigDialogEdit:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    (lpTapiLineTestInfo->hwndOwner == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=x%lx",
+	       lpTapiLineTestInfo->hwndOwner);
+
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+#else
+    (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+#endif
+    (lpTapiLineTestInfo->lpDeviceConfigIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfigIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfigIn=x%lx",
+	       lpTapiLineTestInfo->lpDeviceConfigIn);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+    (lpTapiLineTestInfo->lpDeviceConfigOut == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfigOut=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfigOut=x%lx",
+	       lpTapiLineTestInfo->lpDeviceConfigOut);
+
+#ifdef WUNICODE
+    lActual = lineConfigDialogEditW(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpwszDeviceClass,
+	    lpTapiLineTestInfo->lpDeviceConfigIn,
+	    lpTapiLineTestInfo->dwSize,
+	    lpTapiLineTestInfo->lpDeviceConfigOut
+	    );
+#else
+    lActual = lineConfigDialogEdit(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpszDeviceClass,
+	    lpTapiLineTestInfo->lpDeviceConfigIn,
+	    lpTapiLineTestInfo->dwSize,
+	    lpTapiLineTestInfo->lpDeviceConfigOut
+	    );
+#endif
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineConfigDialogEdit:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lConfigDialogEdit, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineConfigProvider(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineConfigProvider:  enter");
+    (lpTapiLineTestInfo->hwndOwner == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=x%lx",
+	       lpTapiLineTestInfo->hwndOwner);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwPermanentProviderID=x%lx",
+	       *lpTapiLineTestInfo->lpdwPermanentProviderID);
+
+    lActual = lineConfigProvider(
+	    lpTapiLineTestInfo->hwndOwner,
+	    *lpTapiLineTestInfo->lpdwPermanentProviderID
+	    );
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineConfigProvider:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lConfigProvider, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineDeallocateCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDeallocateCall:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "      lphCall=NULL") :
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "      hCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    lActual = lineDeallocateCall(*lpTapiLineTestInfo->lphCall);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDeallocateCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lDeallocateCall, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineDevSpecific(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDevSpecific:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpParams=x%lx",
+	       lpTapiLineTestInfo->lpParams);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+    lActual = lineDevSpecific(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpParams,
+	       lpTapiLineTestInfo->dwSize
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDevSpecific:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lDevSpecific, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+    	{
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+  
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineDevSpecificFeature(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDevSpecificFeature:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwFeature=x%lx",
+	       lpTapiLineTestInfo->dwFeature);
+    (lpTapiLineTestInfo->lpParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpParams=x%lx",
+	       lpTapiLineTestInfo->lpParams);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+    lActual = lineDevSpecificFeature(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwFeature,
+	       lpTapiLineTestInfo->lpParams,
+	       lpTapiLineTestInfo->dwSize
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDevSpecificFeature:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lDevSpecificFeature, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+	   if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineDial(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDial:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+#else
+    (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCountryCode=x%lx",
+	       lpTapiLineTestInfo->dwCountryCode);
+
+
+#ifdef WUNICODE
+    lActual = lineDialW(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpwszDestAddress,
+	       lpTapiLineTestInfo->dwCountryCode
+	       );
+#else
+    lActual = lineDial(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpszDestAddress,
+	       lpTapiLineTestInfo->dwCountryCode
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDial:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lDial, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineDrop(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDrop:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpsUserUserInfo == NULL ) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=x%lx",
+	       lpTapiLineTestInfo->lpsUserUserInfo);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+    lActual = lineDrop(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpsUserUserInfo,
+	       lpTapiLineTestInfo->dwSize
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineDrop:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lDrop, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	    {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineForward(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineForward:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tbAllAddresses=x%lx",
+	       lpTapiLineTestInfo->bAllAddresses);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lpForwardList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpForwardList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpForwardList=x%lx",
+	       lpTapiLineTestInfo->lpForwardList);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNumRingsNoAnswer=x%lx",
+	       lpTapiLineTestInfo->dwNumRingsNoAnswer);
+    (lpTapiLineTestInfo->lphConsultCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=x%lx",
+	       lpTapiLineTestInfo->lphConsultCall);
+    (lpTapiLineTestInfo->lpCallParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=x%lx",
+	       lpTapiLineTestInfo->lpCallParams);
+
+#ifdef WUNICODE
+    lActual = lineForwardW(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->bAllAddresses,
+	       lpTapiLineTestInfo->dwAddressID,
+	       lpTapiLineTestInfo->lpForwardList,
+	       lpTapiLineTestInfo->dwNumRingsNoAnswer,
+	       lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#else
+    lActual = lineForward(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->bAllAddresses,
+	       lpTapiLineTestInfo->dwAddressID,
+	       lpTapiLineTestInfo->lpForwardList,
+	       lpTapiLineTestInfo->dwNumRingsNoAnswer,
+	       lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineForward:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lForward, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineGatherDigits(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGatherDigits:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDigitModes=x%lx",
+	       lpTapiLineTestInfo->dwDigitModes);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwsDigits == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsDigits=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsDigits=x%lx",
+	       lpTapiLineTestInfo->lpwsDigits);
+#else
+    (lpTapiLineTestInfo->lpsDigits == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsDigits=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsDigits=x%lx",
+	       lpTapiLineTestInfo->lpsDigits);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNumDigits=x%lx",
+	       lpTapiLineTestInfo->dwNumDigits);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszTerminationDigits == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszTerminationDigits=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszTerminationDigits=x%lx",
+	       lpTapiLineTestInfo->lpwszTerminationDigits);
+#else
+    (lpTapiLineTestInfo->lpszTerminationDigits == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszTerminationDigits=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszTerminationDigits=x%lx",
+	       lpTapiLineTestInfo->lpszTerminationDigits);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwFirstDigitTimeout=x%lx",
+	       lpTapiLineTestInfo->dwFirstDigitTimeout);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwInterDigitTimeout=x%lx",
+	       lpTapiLineTestInfo->dwInterDigitTimeout);
+
+#ifdef WUNICODE
+    lActual = lineGatherDigitsW(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwDigitModes,
+	       lpTapiLineTestInfo->lpwsDigits,
+	       lpTapiLineTestInfo->dwNumDigits,
+	       lpTapiLineTestInfo->lpwszTerminationDigits,
+	       lpTapiLineTestInfo->dwFirstDigitTimeout,
+	       lpTapiLineTestInfo->dwInterDigitTimeout);
+#else
+    lActual = lineGatherDigits(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwDigitModes,
+	       lpTapiLineTestInfo->lpsDigits,
+	       lpTapiLineTestInfo->dwNumDigits,
+	       lpTapiLineTestInfo->lpszTerminationDigits,
+	       lpTapiLineTestInfo->dwFirstDigitTimeout,
+	       lpTapiLineTestInfo->dwInterDigitTimeout);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGatherDigits:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGatherDigits, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGenerateDigits(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGenerateDigits:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDigitMode=x%lx",
+	       lpTapiLineTestInfo->dwDigitMode);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDigits == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDigits=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDigits=%lx",
+	       lpTapiLineTestInfo->lpwszDigits);
+#else
+    (lpTapiLineTestInfo->lpszDigits == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDigits=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDigits=%lx",
+	       lpTapiLineTestInfo->lpszDigits);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDuration=x%lx",
+	       lpTapiLineTestInfo->dwDuration);
+
+#ifdef WUNICODE
+    lActual = lineGenerateDigitsW(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwDigitMode,
+	       lpTapiLineTestInfo->lpwszDigits,
+	       lpTapiLineTestInfo->dwDuration);
+#else
+    lActual = lineGenerateDigits(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwDigitMode,
+	       lpTapiLineTestInfo->lpszDigits,
+	       lpTapiLineTestInfo->dwDuration);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGenerateDigits:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGenerateDigits, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGenerateTone(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGenerateTone:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwToneMode=x%lx",
+	       lpTapiLineTestInfo->dwToneMode);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDuration=x%lx",
+	       lpTapiLineTestInfo->dwDuration);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNumTones=x%lx",
+	       lpTapiLineTestInfo->dwNumTones);
+    (lpTapiLineTestInfo->lpTones == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpTones=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpTones=x%lx",
+	       lpTapiLineTestInfo->lpTones);
+
+    lActual = lineGenerateTone(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwToneMode,
+	       lpTapiLineTestInfo->dwDuration,
+	       lpTapiLineTestInfo->dwNumTones,
+	       lpTapiLineTestInfo->lpTones);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGenerateTone:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGenerateDigits, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetAddressCaps(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAddressCaps:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwExtVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwExtVersion);
+    (lpTapiLineTestInfo->lpLineAddressCaps == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineAddressCaps=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineAddressCaps=x%lx",
+	       lpTapiLineTestInfo->lpLineAddressCaps);
+#ifdef WUNICODE
+    lActual = lineGetAddressCapsW(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       lpTapiLineTestInfo->dwAddressID,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       *lpTapiLineTestInfo->lpdwExtVersion,
+	       lpTapiLineTestInfo->lpLineAddressCaps);
+#else
+    lActual = lineGetAddressCaps(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       lpTapiLineTestInfo->dwAddressID,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       *lpTapiLineTestInfo->lpdwExtVersion,
+	       lpTapiLineTestInfo->lpLineAddressCaps);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAddressCaps:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAddressCaps, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetAddressID(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAddressID:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwAddressID=x%lx",
+	       lpTapiLineTestInfo->lpdwAddressID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressMode=x%lx",
+	       lpTapiLineTestInfo->dwAddressMode);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwsAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsAddress=%lx",
+	       lpTapiLineTestInfo->lpwsAddress);
+#else
+    (lpTapiLineTestInfo->lpsAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsAddress=%lx",
+	       lpTapiLineTestInfo->lpsAddress);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+#ifdef WUNICODE
+    lActual = lineGetAddressIDW(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lpdwAddressID,
+	       lpTapiLineTestInfo->dwAddressMode,
+	       lpTapiLineTestInfo->lpwsAddress,
+	       lpTapiLineTestInfo->dwSize
+	       );
+#else
+    lActual = lineGetAddressID(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lpdwAddressID,
+	       lpTapiLineTestInfo->dwAddressMode,
+	       lpTapiLineTestInfo->lpsAddress,
+	       lpTapiLineTestInfo->dwSize
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAddressID:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAddressID, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetAddressStatus(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAddressStatus:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lpLineAddressStatus == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineAddressStatus=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineAddressStatus=x%lx",
+	       lpTapiLineTestInfo->lpLineAddressStatus);
+#ifdef WUNICODE
+    lActual = lineGetAddressStatusW(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       lpTapiLineTestInfo->lpLineAddressStatus);
+#else
+    lActual = lineGetAddressStatus(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       lpTapiLineTestInfo->lpLineAddressStatus);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAddressStatus:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAddressStatus, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetAppPriority(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAppPriority:  enter");
+
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszAppFilename == NULL) ? 
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAppFilename=NULL")        :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAppFilename=%lx",
+	       lpTapiLineTestInfo->lpwszAppFilename);
+#else
+    (lpTapiLineTestInfo->lpszAppFilename == NULL) ? 
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppFilename=NULL")        :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppFilename=%lx",
+	       lpTapiLineTestInfo->lpszAppFilename);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaMode=x%lx",
+	       lpTapiLineTestInfo->dwMediaMode);
+    (lpTapiLineTestInfo->lpExtID == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtensionID=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtensionID=x%lx",
+	       lpTapiLineTestInfo->lpExtID); 
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwRequestMode=x%lx",
+	       lpTapiLineTestInfo->dwRequestMode);
+    (lpTapiLineTestInfo->lpExtensionName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtensionName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtensionName=x%lx",
+	       lpTapiLineTestInfo->lpExtensionName);
+    (lpTapiLineTestInfo->lpdwPriority == NULL) ? 
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwPriority=NULL")        :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwPriority=x%lx",
+	       lpTapiLineTestInfo->lpdwPriority); 
+
+#ifdef WUNICODE
+    lActual = lineGetAppPriorityW(
+	       lpTapiLineTestInfo->lpwszAppFilename,
+	       lpTapiLineTestInfo->dwMediaMode,
+	       lpTapiLineTestInfo->lpExtID,
+	       lpTapiLineTestInfo->dwRequestMode,
+	       lpTapiLineTestInfo->lpExtensionName,
+	       lpTapiLineTestInfo->lpdwPriority);
+#else
+    lActual = lineGetAppPriority(
+	       lpTapiLineTestInfo->lpszAppFilename,
+	       lpTapiLineTestInfo->dwMediaMode,
+	       lpTapiLineTestInfo->lpExtID,
+	       lpTapiLineTestInfo->dwRequestMode,
+	       lpTapiLineTestInfo->lpExtensionName,
+	       lpTapiLineTestInfo->lpdwPriority);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAppPriority:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAppPriority, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetCallInfo(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetCallInfo:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpCallInfo == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallInfo=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallInfo=x%lx",
+	       lpTapiLineTestInfo->lpCallInfo);
+
+#ifdef WUNICODE
+    lActual = lineGetCallInfoW(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpCallInfo
+	    );
+#else
+	lActual = lineGetCallInfo(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpCallInfo
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetCallInfo:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetCallInfo, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetCallStatus(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetCallStatus:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpCallStatus == NULL ) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallStatus=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallStatus=x%lx",
+	       lpTapiLineTestInfo->lpCallStatus);
+
+    lActual = lineGetCallStatus(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpCallStatus
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetCallStatus:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetCallStatus, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetConfRelatedCalls(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetConfRelatedCalls:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpCallList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallList=x%lx",
+	       lpTapiLineTestInfo->lpCallList);
+
+    lActual = lineGetConfRelatedCalls(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpCallList
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetConfRelatedCalls:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetConfRelatedCalls, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetCountry(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetCountry:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCountryID=x%lx",
+	       lpTapiLineTestInfo->dwCountryID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       lpTapiLineTestInfo->dwAPIVersion);
+    (lpTapiLineTestInfo->lpLineCountryList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineCountryList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineCountryList=x%lx",
+	       lpTapiLineTestInfo->lpLineCountryList);
+
+#ifdef WUNICODE
+    lActual = lineGetCountryW(
+	    lpTapiLineTestInfo->dwCountryID,
+	    lpTapiLineTestInfo->dwAPIVersion,
+	    lpTapiLineTestInfo->lpLineCountryList
+	    );
+#else
+    lActual = lineGetCountry(
+	    lpTapiLineTestInfo->dwCountryID,
+	    lpTapiLineTestInfo->dwAPIVersion,
+	    lpTapiLineTestInfo->lpLineCountryList
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetCountry:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetCountry, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetDevCaps(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetDevCaps:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwExtVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwExtVersion);
+    (lpTapiLineTestInfo->lpLineDevCaps == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineDevCaps=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineDevCaps=x%lx",
+	       lpTapiLineTestInfo->lpLineDevCaps);
+
+#ifdef WUNICODE
+    lActual = lineGetDevCapsW(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       *lpTapiLineTestInfo->lpdwExtVersion,
+	       lpTapiLineTestInfo->lpLineDevCaps);
+#else
+    lActual = lineGetDevCaps(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       *lpTapiLineTestInfo->lpdwExtVersion,
+	       lpTapiLineTestInfo->lpLineDevCaps);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetDevCaps:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetDevCaps, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetDevConfig(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetDevConfig:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    (lpTapiLineTestInfo->lpDeviceConfig == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfig=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfig=x%lx",
+	       lpTapiLineTestInfo->lpDeviceConfig);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+
+    lActual = lineGetDevConfigW(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpDeviceConfig,
+	    lpTapiLineTestInfo->lpwszDeviceClass
+	    );
+#else
+    (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+
+    lActual = lineGetDevConfig(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpDeviceConfig,
+	    lpTapiLineTestInfo->lpszDeviceClass
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetDevConfig:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetDevConfig, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetIcon(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetIcon:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+#else
+    (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+#endif
+    (lpTapiLineTestInfo->lphIcon == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphIcon=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphIcon=x%lx",
+	       lpTapiLineTestInfo->lphIcon);
+
+#ifdef WUNICODE
+    lActual = lineGetIconW(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpwszDeviceClass,
+	    lpTapiLineTestInfo->lphIcon
+	    );
+#else
+    lActual = lineGetIcon(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpszDeviceClass,
+	    lpTapiLineTestInfo->lphIcon
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetIcon:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetIcon, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetID(
+		       LPTAPILINETESTINFO lpTapiLineTestInfo,
+		       LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetID:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSelect=x%lx",
+	       lpTapiLineTestInfo->dwSelect);
+    (lpTapiLineTestInfo->lpDeviceID == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceID=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceID=x%lx",
+	       lpTapiLineTestInfo->lpDeviceID);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+
+    lActual = lineGetIDW(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwSelect,
+	       lpTapiLineTestInfo->lpDeviceID,
+	       lpTapiLineTestInfo->lpwszDeviceClass
+	       );
+#else
+    (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+
+    lActual = lineGetID(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->dwSelect,
+	       lpTapiLineTestInfo->lpDeviceID,
+	       lpTapiLineTestInfo->lpszDeviceClass
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetID:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetID, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetLineDevStatus(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetLineDevStatus:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    (lpTapiLineTestInfo->lpLineDevStatus == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineDevStatus=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineDevStatus=x%lx",
+	       lpTapiLineTestInfo->lpLineDevStatus);
+
+    lActual = lineGetLineDevStatus(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lpLineDevStatus);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetLineDevStatus:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetLineDevStatus, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetNewCalls(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetNewCalls:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSelect=x%lx",
+	       lpTapiLineTestInfo->dwSelect);
+    (lpTapiLineTestInfo->lpCallList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallList=x%lx",
+	       lpTapiLineTestInfo->lpCallList);
+
+    lActual = lineGetNewCalls(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->dwSelect,
+	    lpTapiLineTestInfo->lpCallList);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetNewCalls:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetNewCalls, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetNumRings(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetNumRings:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwNumRings=x%lx",
+	       lpTapiLineTestInfo->lpdwNumRings);
+
+    lActual = lineGetNumRings(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       lpTapiLineTestInfo->lpdwNumRings);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetNumRings:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetNumRings, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetProviderList(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetProviderList:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       lpTapiLineTestInfo->dwAPIVersion);
+    (lpTapiLineTestInfo->lpProviderList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpProviderList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpProviderList=x%lx",
+	       lpTapiLineTestInfo->lpProviderList);
+
+#ifdef WUNICODE
+    lActual = lineGetProviderListW(
+	    lpTapiLineTestInfo->dwAPIVersion,
+	    lpTapiLineTestInfo->lpProviderList);
+#else
+    lActual = lineGetProviderList(
+	    lpTapiLineTestInfo->dwAPIVersion,
+	    lpTapiLineTestInfo->lpProviderList);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetProviderList:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetProviderList, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetRequest(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineGetRequest:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwRequestMode=x%lx",
+	       lpTapiLineTestInfo->dwRequestMode);
+    (lpTapiLineTestInfo->lpRequestBuffer == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpRequestBuffer=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpRequestBuffer=x%lx",
+	       lpTapiLineTestInfo->lpRequestBuffer);
+
+#ifdef WUNICODE
+    lActual = lineGetRequestW(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwRequestMode,
+	    lpTapiLineTestInfo->lpRequestBuffer);
+#else
+    lActual = lineGetRequest(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwRequestMode,
+	    lpTapiLineTestInfo->lpRequestBuffer);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetRequest:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetRequest, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetStatusMessages(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetStatusMessages:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwLineStates=x%lx",
+	       lpTapiLineTestInfo->lpdwLineStates);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwAddressStates=x%lx",
+	       lpTapiLineTestInfo->lpdwAddressStates);
+
+    lActual = lineGetStatusMessages(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->lpdwLineStates,
+	    lpTapiLineTestInfo->lpdwAddressStates
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetStatusMessages:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetStatusMessages, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetTranslateCaps(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetTranslateCaps:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+    (lpTapiLineTestInfo->lpTranslateCaps == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpTranslateCaps=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpTranslateCaps=x%lx",
+	       lpTapiLineTestInfo->lpTranslateCaps);
+
+#ifdef WUNICODE
+    lActual = lineGetTranslateCapsW(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    *lpTapiLineTestInfo->lpdwAPIVersion,
+	    lpTapiLineTestInfo->lpTranslateCaps
+	    );
+#else
+    lActual = lineGetTranslateCaps(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    *lpTapiLineTestInfo->lpdwAPIVersion,
+	    lpTapiLineTestInfo->lpTranslateCaps
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetTranslateCaps:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetTranslateCaps, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineHandoff(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineHandoff:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszFileName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszFileName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszFileName=%lx",
+	       lpTapiLineTestInfo->lpwszFileName);
+#else
+    (lpTapiLineTestInfo->lpszFileName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszFileName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszFileName=%lx",
+	       lpTapiLineTestInfo->lpszFileName);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaMode=x%lx",
+	       lpTapiLineTestInfo->dwMediaMode);
+
+#ifdef WUNICODE
+    lActual = lineHandoffW(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpwszFileName,
+	    lpTapiLineTestInfo->dwMediaMode
+	    );
+#else
+    lActual = lineHandoff(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpszFileName,
+	    lpTapiLineTestInfo->dwMediaMode
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineHandoff:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lHandoff, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+// DoLineHold() calls lineHold using the current test params.
+// This function returns TRUE if the return value from lineHold
+// corresponds to the expected value.  Otherwise FALSE is returned.
+// If lineHold returns a positive request ID as predicted, a
+// LINE_REPLY message is added to the list of expected messages.
+BOOL
+WINAPI
+DoLineHold(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineHold:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    lActual = lineHold(*lpTapiLineTestInfo->lphCall);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineHold:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lHold, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+    	if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineInitialize(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineInitialize:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=x%lx",
+	       lpTapiLineTestInfo->lphLineApp);
+    (lpTapiLineTestInfo->hInstance == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thAppInst=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thAppInst=x%lx",
+	       lpTapiLineTestInfo->hInstance);
+    (lpTapiLineTestInfo->lpfnCallback == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpfnCallback=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpfnCallback=x%lx",
+	       lpTapiLineTestInfo->lpfnCallback);
+/*
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszAppName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAppName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAppName=%lx",
+	       lpTapiLineTestInfo->lpwszAppName);
+#else
+*/
+    (lpTapiLineTestInfo->lpszAppName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppName=%lx",
+	       lpTapiLineTestInfo->lpszAppName);
+//#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwNumDevs=x%lx",
+	       lpTapiLineTestInfo->lpdwNumDevs);
+
+/*
+#ifdef WUNICODE
+    lActual = lineInitializeW(
+	       lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->hInstance,
+	       lpTapiLineTestInfo->lpfnCallback,
+	       lpTapiLineTestInfo->lpwszAppName,
+	       lpTapiLineTestInfo->lpdwNumDevs);
+#else
+*/
+    lActual = lineInitialize(
+	       lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->hInstance,
+	       lpTapiLineTestInfo->lpfnCallback,
+	       lpTapiLineTestInfo->lpszAppName,
+	       lpTapiLineTestInfo->lpdwNumDevs);
+//#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineInitialize:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lInitialize, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+// DoLineMakeCall() calls lineMakeCall using the current test params.
+// This function returns TRUE if the return value from lineMakeCall
+// corresponds to the expected value.  Otherwise FALSE is returned.
+// If lineMakeCall returns a positive request ID as expected, an expected
+// LINE_REPLY message is added to the list of expected messages.
+BOOL
+WINAPI
+DoLineMakeCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMakeCall:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=x%lx",
+	       lpTapiLineTestInfo->lphCall);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+#else
+    (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCountryCode=x%lx",
+	       lpTapiLineTestInfo->dwCountryCode);
+    (lpTapiLineTestInfo->lpCallParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=x%lx",
+	       lpTapiLineTestInfo->lpCallParams);
+
+#ifdef WUNICODE
+    lActual = lineMakeCallW(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpwszDestAddress,
+	       lpTapiLineTestInfo->dwCountryCode,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#else
+    lActual = lineMakeCall(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lpszDestAddress,
+	       lpTapiLineTestInfo->dwCountryCode,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMakeCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lMakeCall, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+	   if (lActual > 0)
+	     {
+	       CopyTapiMsgParams(
+		       &TapiMsg,
+		       LINE_REPLY,
+		       0x0,
+		       lpTapiLineTestInfo->dwCallbackInstance,
+		       lActual,
+		       (DWORD) TAPISUCCESS,
+		       0x0,
+		       TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			       TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		       );
+
+	       AddMessageByStruct(&TapiMsg);
+
+	       if (fWaitHere)
+	       {
+		    return (WaitForMessage(&TapiMsg));
+	       }
+	      }
+       }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineMonitorDigits(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMonitorDigits:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDigitModes=x%lx",
+	       lpTapiLineTestInfo->dwDigitModes);
+
+    lActual = lineMonitorDigits(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwDigitModes
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMonitorDigits:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lMonitorDigits, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineMonitorMedia(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMonitorMedia:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaModes=x%lx",
+	       lpTapiLineTestInfo->dwMediaModes);
+
+    lActual = lineMonitorMedia(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwMediaModes
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMonitorMedia:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lMonitorMedia, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineMonitorTones(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMonitorTones:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpToneList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpToneList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpToneList=x%lx",
+	       lpTapiLineTestInfo->lpToneList);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNumEntries=x%lx",
+	       lpTapiLineTestInfo->dwNumEntries);
+
+    lActual = lineMonitorTones(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpToneList,
+	    lpTapiLineTestInfo->dwNumEntries
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineMonitorTones:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lMonitorTones, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineNegotiateAPIVersion(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineNegotiateAPIVersion:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPILowVersion=x%lx",
+	       lpTapiLineTestInfo->dwAPILowVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIHighVersion=x%lx",
+	       lpTapiLineTestInfo->dwAPIHighVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwAPIVersion=x%lx",
+	       lpTapiLineTestInfo->lpdwAPIVersion);
+    (lpTapiLineTestInfo->lpExtID == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtID=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtensionID=x%lx",
+	       lpTapiLineTestInfo->lpExtID);
+
+    lActual = lineNegotiateAPIVersion(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       lpTapiLineTestInfo->dwAPILowVersion,
+	       lpTapiLineTestInfo->dwAPIHighVersion,
+	       lpTapiLineTestInfo->lpdwAPIVersion,
+	       lpTapiLineTestInfo->lpExtID);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineNegotiateAPIVersion:  exit, returned x%lx",
+	       lActual);
+		
+    SetLastTapiResult(lNegotiateAPIVersion, lActual, lExpected);
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineNegotiateExtVersion(
+		       LPTAPILINETESTINFO lpTapiLineTestInfo,
+		       LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineNegotiateExtVersion:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwExtLowVersion=x%lx",
+	       lpTapiLineTestInfo->dwExtLowVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwExtHighVersion=x%lx",
+	       lpTapiLineTestInfo->dwExtHighVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwExtVersion=x%lx",
+	       lpTapiLineTestInfo->lpdwExtVersion);
+
+    lActual = lineNegotiateExtVersion(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       lpTapiLineTestInfo->dwExtLowVersion,
+	       lpTapiLineTestInfo->dwExtHighVersion,
+	       lpTapiLineTestInfo->lpdwExtVersion);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineNegotiateExtVersion:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lNegotiateExtVersion, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineOpen(
+		       LPTAPILINETESTINFO lpTapiLineTestInfo,
+		       LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineOpen:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=x%lx",
+	       lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwExtVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwExtVersion);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCallbackInstance=x%lx",
+	       lpTapiLineTestInfo->dwCallbackInstance);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwPrivileges=x%lx",
+	       lpTapiLineTestInfo->dwPrivileges);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaModes=x%lx",
+	       lpTapiLineTestInfo->dwMediaModes);
+    (lpTapiLineTestInfo->lpCallParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=x%lx",
+	       lpTapiLineTestInfo->lpCallParams);
+
+#ifdef WUNICODE
+    lActual = lineOpenW(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       lpTapiLineTestInfo->lphLine,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       *lpTapiLineTestInfo->lpdwExtVersion,
+	       lpTapiLineTestInfo->dwCallbackInstance,
+	       lpTapiLineTestInfo->dwPrivileges,
+	       lpTapiLineTestInfo->dwMediaModes,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#else
+    lActual = lineOpen(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwDeviceID,
+	       lpTapiLineTestInfo->lphLine,
+	       *lpTapiLineTestInfo->lpdwAPIVersion,
+	       *lpTapiLineTestInfo->lpdwExtVersion,
+	       lpTapiLineTestInfo->dwCallbackInstance,
+	       lpTapiLineTestInfo->dwPrivileges,
+	       lpTapiLineTestInfo->dwMediaModes,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineOpen:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lOpen, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLinePark(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  linePark:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwParkMode=x%lx",
+	       lpTapiLineTestInfo->dwParkMode);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDirAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDirAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDirAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDirAddress);
+#else
+    (lpTapiLineTestInfo->lpszDirAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDirAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDirAddress=%lx",
+	       lpTapiLineTestInfo->lpszDirAddress);
+#endif
+    (lpTapiLineTestInfo->lpNonDirAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpNonDirAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpNonDirAddress=x%lx",
+	       lpTapiLineTestInfo->lpNonDirAddress);
+
+#ifdef WUNICODE
+    lActual = lineParkW(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwParkMode,
+	    lpTapiLineTestInfo->lpwszDirAddress,
+	    lpTapiLineTestInfo->lpNonDirAddress
+	    );
+#else
+    lActual = linePark(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwParkMode,
+	    lpTapiLineTestInfo->lpszDirAddress,
+	    lpTapiLineTestInfo->lpNonDirAddress
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  linePark:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lPark, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+    	{
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLinePickup(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  linePickup:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=x%lx",
+	       lpTapiLineTestInfo->lphCall);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+    (lpTapiLineTestInfo->lpwszGroupID == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszGroupID=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszGroupID=x%lx",
+	       lpTapiLineTestInfo->lpwszGroupID);
+
+    lActual = linePickupW(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpwszDestAddress,
+	    lpTapiLineTestInfo->lpwszGroupID
+	    );
+#else
+    (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+    (lpTapiLineTestInfo->lpszGroupID == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszGroupID=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszGroupID=x%lx",
+	       lpTapiLineTestInfo->lpszGroupID);
+
+    lActual = linePickup(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpszDestAddress,
+	    lpTapiLineTestInfo->lpszGroupID
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  linePickup:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lPickup, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLinePrepareAddToConference(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  linePrepareAddToConference:  enter");
+    (lpTapiLineTestInfo->lphConfCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConfCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thConfCall=x%lx",
+	       *lpTapiLineTestInfo->lphConfCall);
+    (lpTapiLineTestInfo->lphConsultCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=x%lx",
+	       lpTapiLineTestInfo->lphConsultCall);
+    (lpTapiLineTestInfo->lpCallParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=x%lx",
+	       lpTapiLineTestInfo->lpCallParams);
+
+#ifdef WUNICODE
+    lActual = linePrepareAddToConferenceW(
+	    *lpTapiLineTestInfo->lphConfCall,
+	    lpTapiLineTestInfo->lphConsultCall,
+	    lpTapiLineTestInfo->lpCallParams
+	    );
+#else
+    lActual = linePrepareAddToConference(
+	    *lpTapiLineTestInfo->lphConfCall,
+	    lpTapiLineTestInfo->lphConsultCall,
+	    lpTapiLineTestInfo->lpCallParams
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  linePrepareAddToConference:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lPrepareAddToConference, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineRedirect(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineRedirect:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+#else
+    (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCountryCode=x%lx",
+	       lpTapiLineTestInfo->dwCountryCode);
+
+#ifdef WUNICODE
+    lActual = lineRedirectW(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpwszDestAddress,
+	    lpTapiLineTestInfo->dwCountryCode
+	    );
+#else
+    lActual = lineRedirect(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpszDestAddress,
+	    lpTapiLineTestInfo->dwCountryCode
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineRedirect:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lRedirect, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineRegisterRequestRecipient(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineRegisterRequestRecipient:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwRegistrationInstance=x%lx",
+	       lpTapiLineTestInfo->dwRegistrationInstance);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwRequestMode=x%lx",
+	       lpTapiLineTestInfo->dwRequestMode);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tbEnable=x%lx",
+	       lpTapiLineTestInfo->bEnable);
+
+    lActual = lineRegisterRequestRecipient(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->dwRegistrationInstance,
+	       lpTapiLineTestInfo->dwRequestMode,
+	       lpTapiLineTestInfo->bEnable);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineRegisterRequestRecipient:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lRegisterRequestRecipient, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineReleaseUserUserInfo(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineReleaseUserUserInfo:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    lActual = lineReleaseUserUserInfo(*lpTapiLineTestInfo->lphCall);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineReleaseUserUserInfo:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lReleaseUserUserInfo, lActual, lExpected);
+
+//    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+
+}
+
+
+BOOL
+WINAPI
+DoLineRemoveFromConference(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineRemoveFromConference:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    lActual = lineRemoveFromConference(*lpTapiLineTestInfo->lphCall);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineRemoveFromConference:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lRemoveFromConference, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineRemoveProvider(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineRemoveProvider:  enter");
+    TapiLogDetail(
+	    DBUG_SHOW_PARAMS,
+	    "\tdwPermanentProviderID=x%lx",
+	    *lpTapiLineTestInfo->lpdwPermanentProviderID);
+    TapiLogDetail(
+	    DBUG_SHOW_PARAMS,
+	    "\thwndOwner=x%lx",
+	    lpTapiLineTestInfo->hwndOwner);
+
+    lActual = lineRemoveProvider(
+	    *lpTapiLineTestInfo->lpdwPermanentProviderID,
+	    lpTapiLineTestInfo->hwndOwner
+	    );
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineRemoveProvider:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lRemoveProvider, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSecureCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSecureCall:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    lActual = lineSecureCall(*lpTapiLineTestInfo->lphCall);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSecureCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSecureCall, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineSendUserUserInfo(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSendUserUserInfo:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lpsUserUserInfo == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsUserUserInfo=x%lx",
+	       lpTapiLineTestInfo->lpsUserUserInfo);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+    lActual = lineSendUserUserInfo(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpsUserUserInfo,
+	    lpTapiLineTestInfo->dwSize
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSendUserUserInfo:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSendUserUserInfo, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineSetAppPriority(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAppPriority:  enter");
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszAppFilename == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAppFilename=NULL")        :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAppFilename=s%lx",
+	       lpTapiLineTestInfo->lpwszAppFilename);
+#else
+    (lpTapiLineTestInfo->lpszAppFilename == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppFilename=NULL")        :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppFilename=s%lx",
+	       lpTapiLineTestInfo->lpszAppFilename);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaMode=x%lx",
+	       lpTapiLineTestInfo->dwMediaMode);
+    (lpTapiLineTestInfo->lpExtID == NULL) ? 
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtID=NULL")        :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpExtID=x%lx",
+	       lpTapiLineTestInfo->lpExtID);
+
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwRequestMode=x%lx",
+		     lpTapiLineTestInfo->dwRequestMode);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszMediaExtName == NULL) ? 
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszMediaExtName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszMediaExtName=%lx",
+	       lpTapiLineTestInfo->lpwszMediaExtName);
+#else
+    (lpTapiLineTestInfo->lpszMediaExtName == NULL) ? 
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszMediaExtName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszMediaExtName=%lx",
+	       lpTapiLineTestInfo->lpszMediaExtName);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwPriority=x%lx",
+	       *lpTapiLineTestInfo->lpdwPriority);
+
+#ifdef WUNICODE
+    lActual = lineSetAppPriorityW(
+	       lpTapiLineTestInfo->lpwszAppFilename,
+	       lpTapiLineTestInfo->dwMediaMode,
+	       lpTapiLineTestInfo->lpExtID,
+	       lpTapiLineTestInfo->dwRequestMode,
+	       lpTapiLineTestInfo->lpwszMediaExtName,
+	       *lpTapiLineTestInfo->lpdwPriority);
+#else
+    lActual = lineSetAppPriority(
+	       lpTapiLineTestInfo->lpszAppFilename,
+	       lpTapiLineTestInfo->dwMediaMode,
+	       lpTapiLineTestInfo->lpExtID,
+	       lpTapiLineTestInfo->dwRequestMode,
+	       lpTapiLineTestInfo->lpszMediaExtName,
+	       *lpTapiLineTestInfo->lpdwPriority);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAppPriority:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetAppPriority, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetAppSpecific(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAppSpecific:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAppSpecific=x%lx",
+	       lpTapiLineTestInfo->dwAppSpecific);
+
+    lActual = lineSetAppSpecific(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwAppSpecific
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAppSpecific:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetAppSpecific, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetCallParams(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallParams:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwBearerMode=x%lx",
+	       lpTapiLineTestInfo->dwBearerMode);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMinRate=x%lx",
+	       lpTapiLineTestInfo->dwMinRate);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMaxRate=x%lx",
+	       lpTapiLineTestInfo->dwMaxRate);
+    (lpTapiLineTestInfo->lpDialParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDialParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDialParams=x%lx",
+	       lpTapiLineTestInfo->lpDialParams);
+
+    lActual = lineSetCallParams(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwBearerMode,
+	    lpTapiLineTestInfo->dwMinRate,
+	    lpTapiLineTestInfo->dwMaxRate,
+	    lpTapiLineTestInfo->lpDialParams
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallParams:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetCallParams, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+	   if (lActual > 0)
+	    {
+	     CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineSetCallPrivilege(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallPrivilege:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCallPrivilege=x%lx",
+	       lpTapiLineTestInfo->dwCallPrivilege);
+
+    lActual = lineSetCallPrivilege(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwCallPrivilege
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallPrivilege:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetCallPrivilege, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetCurrentLocation(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCurrentLocation:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwLocation=x%lx",
+	       lpTapiLineTestInfo->dwLocation);
+
+    lActual = lineSetCurrentLocation(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwLocation
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCurrentLocation:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetCurrentLocation, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetDevConfig(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetDevConfig:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    (lpTapiLineTestInfo->lpDeviceConfig == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfig=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpDeviceConfig=x%lx",
+	       lpTapiLineTestInfo->lpDeviceConfig);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+
+    lActual = lineSetDevConfigW(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpDeviceConfig,
+	    lpTapiLineTestInfo->dwSize,
+	    lpTapiLineTestInfo->lpwszDeviceClass
+	    );
+#else
+    (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+
+    lActual = lineSetDevConfig(
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpDeviceConfig,
+	    lpTapiLineTestInfo->dwSize,
+	    lpTapiLineTestInfo->lpszDeviceClass
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetDevConfig:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetDevConfig, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetMediaControl(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetMediaControl:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSelect=x%lx",
+	       lpTapiLineTestInfo->dwSelect);
+    (lpTapiLineTestInfo->lpMCDigitList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCDigitList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCDigitList=x%lx",
+	       lpTapiLineTestInfo->lpMCDigitList);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDigitNumEntries=x%lx",
+	       lpTapiLineTestInfo->dwDigitNumEntries);
+    (lpTapiLineTestInfo->lpMCMediaList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCMediaList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCMediaList=x%lx",
+	       lpTapiLineTestInfo->lpMCMediaList);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaNumEntries=x%lx",
+	       lpTapiLineTestInfo->dwMediaNumEntries);
+    (lpTapiLineTestInfo->lpMCToneList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCtoneList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCToneList=x%lx",
+	       lpTapiLineTestInfo->lpMCToneList);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwToneNumEntries=x%lx",
+	       lpTapiLineTestInfo->dwToneNumEntries);
+    (lpTapiLineTestInfo->lpMCCallStateList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCCallStateList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMCCallStateList=x%lx",
+	       lpTapiLineTestInfo->lpMCCallStateList);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCallStateNumEntries=x%lx",
+	       lpTapiLineTestInfo->dwCallStateNumEntries);
+
+    lActual = lineSetMediaControl(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwSelect,
+	    lpTapiLineTestInfo->lpMCDigitList,
+	    lpTapiLineTestInfo->dwDigitNumEntries,
+	    lpTapiLineTestInfo->lpMCMediaList,
+	    lpTapiLineTestInfo->dwMediaNumEntries,
+	    lpTapiLineTestInfo->lpMCToneList,
+	    lpTapiLineTestInfo->dwToneNumEntries,
+	    lpTapiLineTestInfo->lpMCCallStateList,
+	    lpTapiLineTestInfo->dwCallStateNumEntries
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetMediaControl:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetMediaControl, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetMediaMode(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetMediaMode:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMediaMode=x%lx",
+	       lpTapiLineTestInfo->dwMediaMode);
+
+    lActual = lineSetMediaMode(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwMediaMode
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetMediaMode:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetMediaMode, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetNumRings(
+	 LPTAPILINETESTINFO lpTapiLineTestInfo,
+	 LONG               lExpected
+	 )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetNumRings:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNumRings=x%lx",
+	       *lpTapiLineTestInfo->lpdwNumRings);
+
+    lActual = lineSetNumRings(
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->dwAddressID,
+	       *lpTapiLineTestInfo->lpdwNumRings);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetNumRings:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetNumRings, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetStatusMessages(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetStatusMessages:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwLineStates=x%lx",
+	       lpTapiLineTestInfo->dwLineStates);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressStates=x%lx",
+	       lpTapiLineTestInfo->dwAddressStates);
+
+    lActual = lineSetStatusMessages(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwLineStates,
+	    lpTapiLineTestInfo->dwAddressStates
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetStatusMessages:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetStatusMessages, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetTerminal(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetTerminal:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSelect=x%lx",
+	       lpTapiLineTestInfo->dwSelect);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTerminalModes=x%lx",
+	       lpTapiLineTestInfo->dwTerminalModes);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTerminalID=x%lx",
+	       lpTapiLineTestInfo->dwTerminalID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tbEnable=x%lx",
+	       lpTapiLineTestInfo->bEnable);
+
+    lActual = lineSetTerminal(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwSelect,
+	    lpTapiLineTestInfo->dwTerminalModes,
+	    lpTapiLineTestInfo->dwTerminalID,
+	    lpTapiLineTestInfo->bEnable
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetTerminal:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetTerminal, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+	   if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineSetTollList(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetTollList:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszAddressIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAddressIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAddressIn=%lx",
+	       lpTapiLineTestInfo->lpwszAddressIn);
+#else
+    (lpTapiLineTestInfo->lpszAddressIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAddressIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAddressIn=%lx",
+	       lpTapiLineTestInfo->lpszAddressIn);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTollListOption=x%lx",
+	       lpTapiLineTestInfo->dwTollListOption);
+
+#ifdef WUNICODE
+    lActual = lineSetTollListW(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpwszAddressIn,
+	    lpTapiLineTestInfo->dwTollListOption
+	    );
+#else
+    lActual = lineSetTollList(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->lpszAddressIn,
+	    lpTapiLineTestInfo->dwTollListOption
+	    );
+#endif
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineSetTollList:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lSetTollList, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSetupConference(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetupConference:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    (lpTapiLineTestInfo->lphConfCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConfCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConfCall=x%lx",
+	       lpTapiLineTestInfo->lphConfCall);
+    (lpTapiLineTestInfo->lphConsultCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=x%lx",
+	       lpTapiLineTestInfo->lphConsultCall);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNumParties=x%lx",
+	       lpTapiLineTestInfo->dwNumParties);
+    (lpTapiLineTestInfo->lpCallParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=x%lx",
+	       lpTapiLineTestInfo->lpCallParams);
+
+#ifdef WUNICODE
+    lActual = lineSetupConferenceW(
+	       *lpTapiLineTestInfo->lphCall,
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lphConfCall,
+	       lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->dwNumParties,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#else
+    lActual = lineSetupConference(
+	       *lpTapiLineTestInfo->lphCall,
+	       *lpTapiLineTestInfo->lphLine,
+	       lpTapiLineTestInfo->lphConfCall,
+	       lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->dwNumParties,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetupConference:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetupConference, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+//	       (DWORD) *lpTapiLineTestInfo->lphConfCall,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2 
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineSetupTransfer(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetupTransfer:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+    (lpTapiLineTestInfo->lphConsultCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphConsultCall=x%lx",
+	       lpTapiLineTestInfo->lphConsultCall);
+    (lpTapiLineTestInfo->lpCallParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallParams=x%lx",
+	       lpTapiLineTestInfo->lpCallParams);
+
+#ifdef WUNICODE
+    lActual = lineSetupTransferW(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#else
+    lActual = lineSetupTransfer(
+	       *lpTapiLineTestInfo->lphCall,
+	       lpTapiLineTestInfo->lphConsultCall,
+	       lpTapiLineTestInfo->lpCallParams
+	       );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetupTransfer:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetupTransfer, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineShutdown(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineShutdown:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+
+    lActual = lineShutdown(*lpTapiLineTestInfo->lphLineApp);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineShutdown:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lShutdown, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineSwapHold(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSwapHold:  enter");
+    (lpTapiLineTestInfo->hActiveCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thActiveCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thActiveCall=x%lx",
+	       lpTapiLineTestInfo->hActiveCall);
+    (lpTapiLineTestInfo->hHeldCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thHeldCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thHeldCall=x%lx",
+	       lpTapiLineTestInfo->hHeldCall);
+
+    lActual = lineSwapHold(
+	       lpTapiLineTestInfo->hActiveCall,
+	       lpTapiLineTestInfo->hHeldCall
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSwapHold:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSwapHold, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineTranslateAddress(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTranslateAddress:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    TapiLogDetail(
+		DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszAddressIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAddressIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAddressIn=%lx",
+	       lpTapiLineTestInfo->lpwszAddressIn);
+#else
+    (lpTapiLineTestInfo->lpszAddressIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAddressIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAddressIn=%lx",
+	       lpTapiLineTestInfo->lpszAddressIn);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCard=x%lx",
+	       lpTapiLineTestInfo->dwCard);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTranslateOptions=x%lx",
+	       lpTapiLineTestInfo->dwTranslateOptions);
+    (lpTapiLineTestInfo->lpTranslateOutput == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpTranslateOutput=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpTranslateOutput=x%lx",
+	       lpTapiLineTestInfo->lpTranslateOutput);
+
+#ifdef WUNICODE
+    lActual = lineTranslateAddressW(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    *lpTapiLineTestInfo->lpdwAPIVersion,
+	    lpTapiLineTestInfo->lpwszAddressIn,
+	    lpTapiLineTestInfo->dwCard,
+	    lpTapiLineTestInfo->dwTranslateOptions,
+	    lpTapiLineTestInfo->lpTranslateOutput
+	    );
+#else
+    lActual = lineTranslateAddress(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    *lpTapiLineTestInfo->lpdwAPIVersion,
+	    lpTapiLineTestInfo->lpszAddressIn,
+	    lpTapiLineTestInfo->dwCard,
+	    lpTapiLineTestInfo->dwTranslateOptions,
+	    lpTapiLineTestInfo->lpTranslateOutput
+	    );
+#endif
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineTranslateAddress:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lTranslateAddress, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineTranslateDialog(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTranslateDialog:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAPIVersion=x%lx",
+	       *lpTapiLineTestInfo->lpdwAPIVersion);
+    (lpTapiLineTestInfo->hwndOwner == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwndOwner=x%lx",
+	       lpTapiLineTestInfo->hwndOwner);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszAddressIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAddressIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszAddressIn=%lx",
+	       lpTapiLineTestInfo->lpwszAddressIn);
+
+    lActual = lineTranslateDialogW(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    *lpTapiLineTestInfo->lpdwAPIVersion,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpwszAddressIn
+	    );
+#else
+    (lpTapiLineTestInfo->lpszAddressIn == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAddressIn=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAddressIn=%lx",
+	       lpTapiLineTestInfo->lpszAddressIn);
+
+    lActual = lineTranslateDialog(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    *lpTapiLineTestInfo->lpdwAPIVersion,
+	    lpTapiLineTestInfo->hwndOwner,
+	    lpTapiLineTestInfo->lpszAddressIn
+	    );
+#endif
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "  lineTranslateDialog:  exit, returned x%lx",
+	    lActual);
+
+    SetLastTapiResult(lTranslateDialog, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineUncompleteCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineUncompleteCall:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwCompletionID=x%lx",
+	       *lpTapiLineTestInfo->lpdwCompletionID);
+
+    lActual = lineUncompleteCall(
+	       *lpTapiLineTestInfo->lphLine,
+	       *lpTapiLineTestInfo->lpdwCompletionID
+	       );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineUncompleteCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lUncompleteCall, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+// DoLineUnhold() calls lineUnhold using the current test params.
+// This function returns TRUE if the return value from lineUnhold
+// corresponds to the expected value.  Otherwise FALSE is returned.
+// If lineUnhold returns a positive request ID as predicted, a
+// LINE_REPLY message is added to the list of expected messages.
+BOOL
+WINAPI
+DoLineUnhold(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineUnhold:  enter");
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+    lActual = lineUnhold(*lpTapiLineTestInfo->lphCall);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineUnhold:  exit, returned x%lx",
+	       lActual);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineUnpark(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG               lExpected,
+	BOOL               fWaitHere)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineUnpark:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=x%lx",
+	       lpTapiLineTestInfo->lphCall);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+
+    lActual = lineUnparkW(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpwszDestAddress
+	    );
+#else
+    (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+
+    lActual = lineUnpark(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpszDestAddress
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineUnpark:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lUnpark, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add reply message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoTapiGetLocationInfo(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiGetLocationInfo:  enter");
+
+#ifdef WUNICODE
+   (lpTapiLineTestInfo->lpwszCountryCode == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCountryCode=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCountryCode=%lx",
+	       lpTapiLineTestInfo->lpwszCountryCode);
+
+   (lpTapiLineTestInfo->lpwszCityCode == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCityCode=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCityCode=%lx",
+	       lpTapiLineTestInfo->lpwszCityCode);
+
+     lActual = tapiGetLocationInfoW(
+	    lpTapiLineTestInfo->lpwszCountryCode,
+	    lpTapiLineTestInfo->lpwszCityCode
+	    );
+#else
+   (lpTapiLineTestInfo->lpszCountryCode == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCountryCode=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCountryCode=%lx",
+	       lpTapiLineTestInfo->lpszCountryCode);
+
+   (lpTapiLineTestInfo->lpszCityCode == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCityCode=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCityCode=%lx",
+	       lpTapiLineTestInfo->lpszCityCode);
+
+     lActual = tapiGetLocationInfo(
+	    lpTapiLineTestInfo->lpszCountryCode,
+	    lpTapiLineTestInfo->lpszCityCode
+	    );
+#endif
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiGetLocationInfo:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(tGetLocationInfo, lActual, lExpected);
+
+    return CheckSyncTapiResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoTapiRequestDrop(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiRequestDrop:  enter:"); 
+
+   (lpTapiLineTestInfo->hwnd == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwnd=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwnd=x%lx",
+	       lpTapiLineTestInfo->hwnd);
+
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\twRequestID=x%lx",
+	       lpTapiLineTestInfo->wRequestID);
+
+     lActual = tapiRequestDrop(
+	    lpTapiLineTestInfo->hwnd,
+	    lpTapiLineTestInfo->wRequestID
+	    );
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiRequestDrop:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(tRequestDrop, lActual, lExpected);
+
+    return CheckSyncTapiResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoTapiRequestMakeCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiRequestMakeCall:  enter");
+
+#ifdef WUNICODE
+   (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+
+   (lpTapiLineTestInfo->lpwsztapiAppName == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsztapiAppName=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsztapiAppName=%lx",
+	       lpTapiLineTestInfo->lpwsztapiAppName);
+
+   (lpTapiLineTestInfo->lpwszCalledParty == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCalledParty=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCalledParty=%lx",
+	       lpTapiLineTestInfo->lpwszCalledParty);
+
+   (lpTapiLineTestInfo->lpwszComment == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszComment=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszComment=%lx",
+	       lpTapiLineTestInfo->lpwszComment);
+
+     lActual = tapiRequestMakeCallW(
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszDestAddress,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwsztapiAppName,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszCalledParty,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszComment
+	    );
+#else
+   (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+
+   (lpTapiLineTestInfo->lpsztapiAppName == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszApptapiName=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsztapiAppName=%lx",
+	       lpTapiLineTestInfo->lpsztapiAppName);
+
+   (lpTapiLineTestInfo->lpszCalledParty == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCalledParty=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCalledParty=%lx",
+	       lpTapiLineTestInfo->lpszCalledParty);
+
+   (lpTapiLineTestInfo->lpszComment == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszComment=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszComment=%lx",
+	       lpTapiLineTestInfo->lpszComment);
+
+     lActual = tapiRequestMakeCall(
+	    (LPCSTR)lpTapiLineTestInfo->lpszDestAddress,
+	    (LPCSTR)lpTapiLineTestInfo->lpsztapiAppName,
+	    (LPCSTR)lpTapiLineTestInfo->lpszCalledParty,
+	    (LPCSTR)lpTapiLineTestInfo->lpszComment
+	    );
+#endif
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiRequestMakeCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(tRequestMakeCall, lActual, lExpected);
+
+    return CheckSyncTapiResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoTapiRequestMediaCall(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiRequestMediaCall:  enter");
+
+   (lpTapiLineTestInfo->hwnd == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwnd=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thwnd=x%lx",
+	       lpTapiLineTestInfo->hwnd);
+
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\twRequestID=x%lx",
+	       lpTapiLineTestInfo->wRequestID);
+#ifdef WUNICODE
+     (lpTapiLineTestInfo->lpwszDeviceClass == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceClass);
+#else
+     (lpTapiLineTestInfo->lpszDeviceClass == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceClass=%lx",
+	       lpTapiLineTestInfo->lpszDeviceClass);
+#endif
+
+#ifdef WUNICODE
+     (lpTapiLineTestInfo->lpwszDeviceID == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceID=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDeviceID=%lx",
+	       lpTapiLineTestInfo->lpwszDeviceID);
+#else
+     (lpTapiLineTestInfo->lpszDeviceID == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceID=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDeviceID=x%lx",
+	       lpTapiLineTestInfo->lpszDeviceID);
+#endif
+
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSecure=x%lx",
+	       lpTapiLineTestInfo->dwSecure);
+#ifdef WUNICODE
+     (lpTapiLineTestInfo->lpwszDestAddress == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpwszDestAddress);
+
+     (lpTapiLineTestInfo->lpwsztapiAppName == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsztapiAppName=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwsztapiAppName=%lx",
+	       lpTapiLineTestInfo->lpwsztapiAppName);
+
+     (lpTapiLineTestInfo->lpwszCalledParty == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCalledParty=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszCalledParty=%lx",
+	       lpTapiLineTestInfo->lpwszCalledParty);
+
+     (lpTapiLineTestInfo->lpwszComment == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszComment=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszComment=%lx",
+	       lpTapiLineTestInfo->lpwszComment);
+
+     lActual = tapiRequestMediaCallW(
+	    lpTapiLineTestInfo->hwnd,
+	    lpTapiLineTestInfo->wRequestID,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszDeviceClass,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszDeviceID,
+	    lpTapiLineTestInfo->dwSize,
+	    lpTapiLineTestInfo->dwSecure,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszDestAddress,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwsztapiAppName,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszCalledParty,
+	    (LPCWSTR)lpTapiLineTestInfo->lpwszComment
+	    );
+#else
+     (lpTapiLineTestInfo->lpszDestAddress == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszDestAddress=%lx",
+	       lpTapiLineTestInfo->lpszDestAddress);
+
+     (lpTapiLineTestInfo->lpsztapiAppName == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpsztapiAppName=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszAppName=%lx",
+	       lpTapiLineTestInfo->lpsztapiAppName);
+
+     (lpTapiLineTestInfo->lpszCalledParty == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCalledParty=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszCalledParty=%lx",
+	       lpTapiLineTestInfo->lpszCalledParty);
+
+     (lpTapiLineTestInfo->lpszComment == NULL) ?
+	     TapiLogDetail(					 
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszComment=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszComment=%lx",
+	       lpTapiLineTestInfo->lpszComment);
+
+     lActual = tapiRequestMediaCall(
+	    lpTapiLineTestInfo->hwnd,
+	    lpTapiLineTestInfo->wRequestID,
+	    (LPCSTR)lpTapiLineTestInfo->lpszDeviceClass,
+	    (LPCSTR)lpTapiLineTestInfo->lpszDeviceID,
+	    lpTapiLineTestInfo->dwSize,
+	    lpTapiLineTestInfo->dwSecure,
+	    (LPCSTR)lpTapiLineTestInfo->lpszDestAddress,
+	    (LPCSTR)lpTapiLineTestInfo->lpsztapiAppName,
+	    (LPCSTR)lpTapiLineTestInfo->lpszCalledParty,
+	    (LPCSTR)lpTapiLineTestInfo->lpszComment
+	    );
+#endif
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineTapiRequestMediaCall:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(tRequestMediaCall, lActual, lExpected);
+
+    return CheckSyncTapiResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+
+
+#if TAPI_2_0
+
+
+BOOL
+WINAPI
+DoLineAgentSpecific(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAgentSpecific:  enter");
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAgentExtensionIDIndex=x%lx",
+	       lpTapiLineTestInfo->dwAgentExtensionIDIndex);
+
+
+     (lpTapiLineTestInfo->lpParams == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpParams=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpParams=x%lx",
+	       lpTapiLineTestInfo->lpParams);
+
+
+     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+ 
+    lActual = lineAgentSpecific(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->dwAgentExtensionIDIndex,
+	    lpTapiLineTestInfo->lpParams,
+	    lpTapiLineTestInfo->dwSize
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineAgentSpecific:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lAgentSpecific, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	*/
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+     return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineGetAgentCaps(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentCaps:  enter");
+
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwDeviceID=x%lx",
+	       lpTapiLineTestInfo->dwDeviceID);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAppAPIVersion=x%lx",
+	       lpTapiLineTestInfo->dwAppAPIVersion);
+
+ 
+     (lpTapiLineTestInfo->lpAgentCaps == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentCaps=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentCaps=x%lx",
+	       lpTapiLineTestInfo->lpAgentCaps);
+
+ 
+    lActual = lineGetAgentCaps(
+	    *lpTapiLineTestInfo->lphLineApp,
+	    lpTapiLineTestInfo->dwDeviceID,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->dwAppAPIVersion,
+	    lpTapiLineTestInfo->lpAgentCaps
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentCaps:  exit, returned x%lx",
+	       lActual);
+    SetLastTapiResult(lGetAgentCaps, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+		    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+      return fSuccess;
+}
+
+BOOL
+WINAPI
+DoLineGetAgentActivityList(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentActivityList:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+     (lpTapiLineTestInfo->lpAgentActivityList == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentActivityList=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentActivityList=x%lx",
+	       lpTapiLineTestInfo->lpAgentActivityList);
+
+#ifdef WUNICODE
+    lActual = lineGetAgentActivityListW(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lpAgentActivityList
+	    );
+#else
+    lActual = lineGetAgentActivityList(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lpAgentActivityList
+	    );
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentActivityList:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAgentActivityList, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+		    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+     return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoLineGetAgentGroupList(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentGroupList:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+     (lpTapiLineTestInfo->lpAgentGroupList == NULL) ?
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentGroupList=NULL") :
+	     TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentGroupList=x%lx",
+	       lpTapiLineTestInfo->lpAgentGroupList);
+
+ 
+    lActual = lineGetAgentGroupList(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lpAgentGroupList
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentGroupList:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAgentGroupList, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+		    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+     return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineGetAgentStatus(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentStatus:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+    (lpTapiLineTestInfo->lpAgentStatus == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentStatus=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentStatus=x%lx",
+	       lpTapiLineTestInfo->lpAgentStatus);
+
+ 
+    lActual = lineGetAgentStatus(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lpAgentStatus
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetAgentStatus:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetAgentStatus, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+     return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineProxyMessage(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineProxyMessage:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+ 
+    (lpTapiLineTestInfo->lphCall == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwMsg=x%lx",
+	       lpTapiLineTestInfo->dwMsg);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwParam1=x%lx",
+	       lpTapiLineTestInfo->dwParam1);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwParam2=x%lx",
+	       lpTapiLineTestInfo->dwParam2);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwParam3=x%lx",
+	       lpTapiLineTestInfo->dwParam3);
+
+ 
+    lActual = lineProxyMessage(
+	    *lpTapiLineTestInfo->lphLine,
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwMsg,
+	    lpTapiLineTestInfo->dwParam1,
+	    lpTapiLineTestInfo->dwParam2,
+	    lpTapiLineTestInfo->dwParam3
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineProxyMessage:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lProxyMessage, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+
+BOOL
+WINAPI
+DoLineProxyResponse(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected
+	)
+{
+    LONG lActual;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineProxyResponse:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+
+    (lpTapiLineTestInfo->lpProxyRequest == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpProxyRequest=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpProxyRequest=x%lx",
+	       lpTapiLineTestInfo->lpProxyRequest);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwResult=x%lx",
+	       lpTapiLineTestInfo->dwResult);
+
+ 
+    lActual = lineProxyResponse(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->lpProxyRequest,
+	    lpTapiLineTestInfo->dwResult
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineProxyResponse:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lProxyResponse, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetAgentActivity(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAgentActivity:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwActivityID=x%lx",
+	       lpTapiLineTestInfo->dwActivityID);
+
+ 
+    lActual = lineSetAgentActivity(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->dwActivityID
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAgentActivity:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetAgentActivity, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+     return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetAgentGroup(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAgentGroup:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+    (lpTapiLineTestInfo->lpAgentGroupList == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentGroupList=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpAgentGroupList=x%lx",
+	       lpTapiLineTestInfo->lpAgentGroupList);
+
+ 
+    lActual = lineSetAgentGroup(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->lpAgentGroupList
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAgentGroup:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetAgentGroup, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST |
+  //			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+      return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetAgentState(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAgentState:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAddressID=x%lx",
+	       lpTapiLineTestInfo->dwAddressID);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwAgentState=x%lx",
+	       lpTapiLineTestInfo->dwAgentState);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwNextAgentState=x%lx",
+	       lpTapiLineTestInfo->dwNextAgentState);
+
+ 
+    lActual = lineSetAgentState(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwAddressID,
+	    lpTapiLineTestInfo->dwAgentState,
+	    lpTapiLineTestInfo->dwNextAgentState
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetAgentState:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetAgentState, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+	if (lActual > 0)
+	{
+	/*
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	  */
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_PROXYREQUEST,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG 
+// | TAPIMSG_DWCALLBACKINST |
+	//		    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+	
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+	}
+    }
+
+
+      return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetCallData(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallData:  enter");
+
+   (lpTapiLineTestInfo->lphCall == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+ 
+    (lpTapiLineTestInfo->lpCallData == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallData=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpCallData=x%lx",
+	       lpTapiLineTestInfo->lpCallData);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSize=x%lx",
+	       lpTapiLineTestInfo->dwSize);
+
+ 
+     lActual = lineSetCallData(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpCallData,
+	    lpTapiLineTestInfo->dwSize
+	    );
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallData:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetCallData, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+
+      return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetCallQualityOfService(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+   TAPIMSG TapiMsg;
+   LONG lActual;
+   BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallQualityOfService:  enter");
+
+   (lpTapiLineTestInfo->lphCall == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+ 
+    (lpTapiLineTestInfo->lpSendingFlowspec == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpSendingFlowspec=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpSendingFlowspec=x%lx",
+	       lpTapiLineTestInfo->lpSendingFlowspec);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwSendingFlowspecSize=x%lx",
+	       lpTapiLineTestInfo->dwSendingFlowspecSize);
+
+ 
+    (lpTapiLineTestInfo->lpReceivingFlowspec == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpReceivingFlowspec=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpReceivingFlowspec=x%lx",
+	       lpTapiLineTestInfo->lpReceivingFlowspec);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwReceivingFlowspecSize=x%lx",
+	       lpTapiLineTestInfo->dwReceivingFlowspecSize);
+
+ 
+    lActual = lineSetCallQualityOfService(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->lpSendingFlowspec,
+	    lpTapiLineTestInfo->dwSendingFlowspecSize,
+	    lpTapiLineTestInfo->lpReceivingFlowspec,
+	    lpTapiLineTestInfo->dwReceivingFlowspecSize
+	    );
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallQualityOfService:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetCallQualityOfService, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+
+      return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetCallTreatment(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallTreatment:  enter");
+
+   (lpTapiLineTestInfo->lphCall == NULL) ?
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphCall=NULL") :
+	   TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thCall=x%lx",
+	       *lpTapiLineTestInfo->lphCall);
+
+
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTreatment=x%lx",
+	       lpTapiLineTestInfo->dwTreatment);
+
+ 
+     lActual = lineSetCallTreatment(
+	    *lpTapiLineTestInfo->lphCall,
+	    lpTapiLineTestInfo->dwTreatment
+	    );
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetCallTreatment:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetCallTreatment, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }
+    }
+
+
+      return fSuccess;
+}
+
+
+
+BOOL
+WINAPI
+DoLineSetLineDevStatus(
+	LPTAPILINETESTINFO lpTapiLineTestInfo,
+	LONG lExpected,
+	BOOL fWaitHere
+	)
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess = TRUE;
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetLineDevStatus:  enter");
+
+    (lpTapiLineTestInfo->lphLine == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLine=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLine=x%lx",
+	       *lpTapiLineTestInfo->lphLine);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwStatusToChange=x%lx",
+	       lpTapiLineTestInfo->dwStatusToChange);
+
+ 
+      TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tfStatus=x%lx",
+	       lpTapiLineTestInfo->fStatus);
+
+ 
+     lActual = lineSetLineDevStatus(
+	    *lpTapiLineTestInfo->lphLine,
+	    lpTapiLineTestInfo->dwStatusToChange,
+	    lpTapiLineTestInfo->fStatus
+	    );
+
+   TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineSetLineDevStatus:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lSetLineDevStatus, lActual, lExpected);
+
+    fSuccess = ProcessAsyncFunc(lpTapiLineTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiLineTestInfo->fCompletionModeSet)
+      {
+		if (lActual > 0)
+	   {
+	    CopyTapiMsgParams(
+		    &TapiMsg,
+		    LINE_REPLY,
+		    0x0,
+		    lpTapiLineTestInfo->dwCallbackInstance,
+		    lActual,
+		    (DWORD) TAPISUCCESS,
+		    0x0,
+		    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+			    TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+		    );
+
+	    AddMessageByStruct(&TapiMsg);
+
+	    if (fWaitHere)
+	    {
+		 return (WaitForMessage(&TapiMsg));
+	    }
+      }
+	  }      
+    }
+
+
+      return fSuccess;
+}
+
+
+// New apis
+
+BOOL
+WINAPI
+DoLineInitializeEx(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineInitializeEx:  enter");
+    (lpTapiLineTestInfo->lphLineApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphLineApp=x%lx",
+	       lpTapiLineTestInfo->lphLineApp);
+    (lpTapiLineTestInfo->hInstance == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thAppInst=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thAppInst=x%lx",
+	       lpTapiLineTestInfo->hInstance);
+    (lpTapiLineTestInfo->lpfnCallback == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpfnCallback=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpfnCallback=x%lx",
+	       lpTapiLineTestInfo->lpfnCallback);
+#ifdef WUNICODE
+    (lpTapiLineTestInfo->lpwszFriendlyAppName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszFriendlyAppName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszFriendlyAppName=%lx",
+	       lpTapiLineTestInfo->lpwszFriendlyAppName);
+#else
+    (lpTapiLineTestInfo->lpszFriendlyAppName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszFriendlyAppName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszFriendlyAppName=%lx",
+	       lpTapiLineTestInfo->lpszFriendlyAppName);
+#endif
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwNumDevs=x%lx",
+	       lpTapiLineTestInfo->lpdwNumDevs);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwAPIVersion=x%lx",
+	       lpTapiLineTestInfo->lpdwAPIVersion);
+    (lpTapiLineTestInfo->lpLineInitializeExParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineInitializeExParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpLineInitializeExParams=x%lx",
+	       lpTapiLineTestInfo->lpLineInitializeExParams);
+ 
+#ifdef WUNICODE
+    lActual = lineInitializeExW(
+	       lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->hInstance,
+	       lpTapiLineTestInfo->lpfnCallback,
+	       lpTapiLineTestInfo->lpwszFriendlyAppName,
+	       lpTapiLineTestInfo->lpdwNumDevs,
+	       lpTapiLineTestInfo->lpdwAPIVersion,
+	       lpTapiLineTestInfo->lpLineInitializeExParams);
+#else
+    lActual = lineInitializeEx(
+	       lpTapiLineTestInfo->lphLineApp,
+	       lpTapiLineTestInfo->hInstance,
+	       lpTapiLineTestInfo->lpfnCallback,
+	       lpTapiLineTestInfo->lpszFriendlyAppName,
+	       lpTapiLineTestInfo->lpdwNumDevs,
+	       lpTapiLineTestInfo->lpdwAPIVersion,
+	       lpTapiLineTestInfo->lpLineInitializeExParams);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineInitializeEx:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lInitializeEx, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoLineGetMessage(LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetMessage:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thLineApp=x%lx",
+	       *lpTapiLineTestInfo->lphLineApp);
+    (lpTapiLineTestInfo->lpMessage == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMessage=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMessage=x%lx",
+	       lpTapiLineTestInfo->lpMessage);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTimeout=x%lx",
+	       lpTapiLineTestInfo->dwTimeout);
+ 
+
+    lActual = lineGetMessage(
+	       *lpTapiLineTestInfo->lphLineApp,
+	       (LPLINEMESSAGE)lpTapiLineTestInfo->lpMessage,
+	       lpTapiLineTestInfo->dwTimeout);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  lineGetMessage:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(lGetMessage, lActual, lExpected);
+
+    return SyncCheckResult(lpTapiLineTestInfo, lActual, lExpected);
+}
+
+
+#endif
+
+
+						  
diff --git a/private/tapi/qa/tcore/doline.h b/private/tapi/qa/tcore/doline.h
new file mode 100644
index 000000000..05605ad1d
--- /dev/null
+++ b/private/tapi/qa/tcore/doline.h
@@ -0,0 +1,881 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    doline.h
+
+Abstract:
+
+    This module contains the prototypes for the wrapper functions around
+    the Telephony API line functions.  These functions provide logging
+    and both synchronous and asynchronous API processing to any
+    application or dll using the core dll.
+
+Author:
+
+    Oliver Wallace (OliverW)    24-Nov-1995
+
+Revision History:
+
+--*/
+#ifndef DOLINE_H
+#define DOLINE_H
+
+
+#include "windows.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+BOOL
+WINAPI
+DoLineAccept(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineAddProvider(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineAddToConference(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineAnswer(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineBlindTransfer(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineClose(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG               lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineCompleteCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineCompleteTransfer(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineConfigDialog(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineConfigDialogEdit(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineConfigProvider(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineDeallocateCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineDevSpecific(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineDevSpecificFeature(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineDial(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineDrop(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineForward(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineGatherDigits(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGenerateDigits(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGenerateTone(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetAddressCaps(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetAddressID(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetAddressStatus(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetAppPriority(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetCallInfo(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetCallStatus(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetConfRelatedCalls(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetCountry(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetDevCaps(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetDevConfig(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetIcon(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetID(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetLineDevStatus(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetNewCalls(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetNumRings(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetProviderList(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetRequest(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetStatusMessages(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineGetTranslateCaps(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineHandoff(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+// DoLineHold() calls lineHold using the current test params.
+// This function returns TRUE if the return value from lineHold
+// corresponds to the expected value.  Otherwise FALSE is returned.
+// If lineHold returns a positive request ID as predicted, a
+// LINE_REPLY message is added to the list of expected messages.
+BOOL
+WINAPI
+DoLineHold(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineInitialize(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+// DoLineMakeCall() calls lineMakeCall using the current test params.
+// This function returns TRUE if the return value from lineMakeCall
+// corresponds to the expected value.  Otherwise FALSE is returned.
+// If lineMakeCall returns a positive request ID as expected, an expected
+// LINE_REPLY message is added to the list of expected messages.
+BOOL
+WINAPI
+DoLineMakeCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineMonitorDigits(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineMonitorMedia(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineMonitorTones(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineNegotiateAPIVersion(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineNegotiateExtVersion(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineOpen(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLinePark(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLinePickup(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLinePrepareAddToConference(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineRedirect(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineRegisterRequestRecipient(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineReleaseUserUserInfo(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineRemoveFromConference(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineRemoveProvider(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSecureCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineSendUserUserInfo(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineSetAppPriority(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetAppSpecific(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetCallParams(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineSetCallPrivilege(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetCurrentLocation(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetDevConfig(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetMediaControl(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetMediaMode(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetNumRings(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetStatusMessages(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetTerminal(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG               lExpected,
+        BOOL               fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineSetTollList(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSetupConference(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineSetupTransfer(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineShutdown(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineSwapHold(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineTranslateAddress(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineTranslateDialog(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoLineUncompleteCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+// DoLineUnhold() calls lineUnhold using the current test params.
+// This function returns TRUE if the return value from lineUnhold
+// corresponds to the expected value.  Otherwise FALSE is returned.
+// If lineUnhold returns a positive request ID as predicted, a
+// LINE_REPLY message is added to the list of expected messages.
+BOOL
+WINAPI
+DoLineUnhold(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineUnpark(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoTapiGetLocationInfo(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+BOOL
+WINAPI
+DoTapiRequestDrop(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+BOOL
+WINAPI
+DoTapiRequestMakeCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+BOOL
+WINAPI
+DoTapiRequestMediaCall(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+
+#if TAPI_2_0
+
+
+BOOL
+WINAPI
+DoLineAgentSpecific(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineGetAgentCaps(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineGetAgentActivityList(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineGetAgentGroupList(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineGetAgentStatus(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineProxyMessage(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+BOOL
+WINAPI
+DoLineProxyResponse(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+BOOL
+WINAPI
+DoLineSetAgentActivity(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineSetAgentGroup(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineSetAgentState(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineSetCallData(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineSetCallQualityOfService(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineSetCallTreatment(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+BOOL
+WINAPI
+DoLineSetLineDevStatus(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoLineInitializeEx(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+BOOL
+WINAPI
+DoLineGetMessage(
+        LPTAPILINETESTINFO lpTapiLineTestInfo,
+        LONG lExpected
+        );
+
+
+
+#endif
+
+
+#endif  // DOLINE_H
+
diff --git a/private/tapi/qa/tcore/dophone.c b/private/tapi/qa/tcore/dophone.c
new file mode 100644
index 000000000..c5110d6ac
--- /dev/null
+++ b/private/tapi/qa/tcore/dophone.c
@@ -0,0 +1,1894 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    dophone.c
+
+Abstract:
+
+    This module contains the wrapper functions around the TAPI phone
+    device functions.  These functions provide logging and both synchronous
+    and asynchronous API processing to any application or dll using the
+    core dll.
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Nov-1995
+
+Revision History:
+
+--*/
+
+
+#define _TCORELIB_
+
+
+#include "windows.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+#include "dophone.h"
+
+
+BOOL
+WINAPI
+DoPhoneClose(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    (* ((LOGPROC) GetLogProc()))(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneClose:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+
+    lActual = phoneClose(
+            *lpTapiPhoneTestInfo->lphPhone
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneClose:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pClose, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneConfigDialog(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneConfigDialog:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDeviceID=x%lx",
+               lpTapiPhoneTestInfo->dwDeviceID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thwndOwner=x%lx",
+               lpTapiPhoneTestInfo->hwndOwner);
+#ifdef WUNICODE
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpwszDeviceClass=x%lx",
+               lpTapiPhoneTestInfo->lpwszDeviceClass);
+#else
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpszDeviceClass=x%lx",
+               lpTapiPhoneTestInfo->lpszDeviceClass);
+#endif
+
+#ifdef WUNICODE
+    lActual = phoneConfigDialogW(
+            lpTapiPhoneTestInfo->dwDeviceID,
+            lpTapiPhoneTestInfo->hwndOwner,
+            lpTapiPhoneTestInfo->lpwszDeviceClass
+            );
+#else
+	lActual = phoneConfigDialog(
+            lpTapiPhoneTestInfo->dwDeviceID,
+            lpTapiPhoneTestInfo->hwndOwner,
+            lpTapiPhoneTestInfo->lpszDeviceClass
+            );
+#endif
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneConfigDialog:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pConfigDialog, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneDevSpecific(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneDevSpecific:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpParams=x%lx",
+               lpTapiPhoneTestInfo->lpParams);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwSize=x%lx",
+               lpTapiPhoneTestInfo->dwSize);
+
+    lActual = phoneDevSpecific(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->lpParams,
+               lpTapiPhoneTestInfo->dwSize
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneDevSpecific:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pDevSpecific, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetButtonInfo(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetButtonInfo:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwButtonLampID=x%lx",
+               lpTapiPhoneTestInfo->dwButtonLampID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpButtonInfo=x%lx",
+               lpTapiPhoneTestInfo->lpButtonInfo);
+
+    lActual = phoneGetButtonInfo(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->dwButtonLampID,
+            lpTapiPhoneTestInfo->lpButtonInfo
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetButtonInfo:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetButtonInfo, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetData(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetData:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDataID=x%lx",
+               lpTapiPhoneTestInfo->dwDataID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpData=x%lx",
+               lpTapiPhoneTestInfo->lpData);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwSize=x%lx",
+               lpTapiPhoneTestInfo->dwSize);
+
+    lActual = phoneGetData(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->dwDataID,
+            lpTapiPhoneTestInfo->lpData,
+            lpTapiPhoneTestInfo->dwSize
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetData:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetData, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetDevCaps(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetDevCaps:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhoneApp=x%lx",
+               *lpTapiPhoneTestInfo->lphPhoneApp);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDeviceID=x%lx",
+               lpTapiPhoneTestInfo->dwDeviceID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwAPIVersion=x%lx",
+               *lpTapiPhoneTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwExtVersion=x%lx",
+               *lpTapiPhoneTestInfo->lpdwExtVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpPhoneCaps=x%lx",
+               lpTapiPhoneTestInfo->lpPhoneCaps);
+
+    lActual = phoneGetDevCaps(
+            *lpTapiPhoneTestInfo->lphPhoneApp,
+            lpTapiPhoneTestInfo->dwDeviceID,
+            *lpTapiPhoneTestInfo->lpdwAPIVersion,
+            *lpTapiPhoneTestInfo->lpdwExtVersion,
+            lpTapiPhoneTestInfo->lpPhoneCaps
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetDevCaps:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetDevCaps, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetDisplay(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetDisplay:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpDisplay=x%lx",
+               lpTapiPhoneTestInfo->lpDisplay);
+
+    lActual = phoneGetDisplay(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpDisplay
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetDisplay:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetDisplay, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetGain(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetGain:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwHookSwitchDev=x%lx",
+               lpTapiPhoneTestInfo->dwHookSwitchDev);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwGain=x%lx",
+               lpTapiPhoneTestInfo->lpdwGain);
+
+    lActual = phoneGetGain(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->dwHookSwitchDev,
+            lpTapiPhoneTestInfo->lpdwGain
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetGain:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetGain, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetHookSwitch(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetHookSwitch:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwHookSwitchDevs=x%lx",
+               lpTapiPhoneTestInfo->lpdwHookSwitchDevs);
+
+    lActual = phoneGetHookSwitch(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpdwHookSwitchDevs
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetHookSwitch:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetHookSwitch, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetIcon(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetIcon:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDeviceID=x%lx",
+               lpTapiPhoneTestInfo->dwDeviceID);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpwszDeviceClass=x%lx",
+               lpTapiPhoneTestInfo->lpwszDeviceClass);
+#else
+	TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpszDeviceClass=x%lx",
+               lpTapiPhoneTestInfo->lpszDeviceClass);
+#endif
+
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlphIcon=x%lx",
+               lpTapiPhoneTestInfo->lphIcon);
+
+#ifdef WUNICODE
+    lActual = phoneGetIconW(
+            lpTapiPhoneTestInfo->dwDeviceID,
+            lpTapiPhoneTestInfo->lpwszDeviceClass,
+            lpTapiPhoneTestInfo->lphIcon
+            );
+#else
+   lActual = phoneGetIcon(
+            lpTapiPhoneTestInfo->dwDeviceID,
+            lpTapiPhoneTestInfo->lpszDeviceClass,
+            lpTapiPhoneTestInfo->lphIcon
+            );
+#endif
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetIcon:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetIcon, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetID(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetID:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpDeviceID=x%lx",
+               lpTapiPhoneTestInfo->lpDeviceID);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpwszDeviceClass=x%lx",
+               lpTapiPhoneTestInfo->lpwszDeviceClass);
+#else
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpszDeviceClass=x%lx",
+               lpTapiPhoneTestInfo->lpszDeviceClass);
+#endif
+
+#ifdef WUNICODE
+    lActual = phoneGetIDW(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpDeviceID,
+            lpTapiPhoneTestInfo->lpwszDeviceClass
+            );
+#else
+    lActual = phoneGetID(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpDeviceID,
+            lpTapiPhoneTestInfo->lpszDeviceClass
+            );
+#endif
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetID:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetID, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetLamp(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetLamp:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwButtonLampID=x%lx",
+               lpTapiPhoneTestInfo->dwButtonLampID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwLampMode=x%lx",
+               lpTapiPhoneTestInfo->lpdwLampMode);
+
+    lActual = phoneGetLamp(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->dwButtonLampID,
+            lpTapiPhoneTestInfo->lpdwLampMode
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetLamp:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetLamp, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetRing(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetRing:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwRingMode=x%lx",
+               lpTapiPhoneTestInfo->lpdwRingMode);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwVolume=x%lx",
+               lpTapiPhoneTestInfo->lpdwVolume);
+
+    lActual = phoneGetRing(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpdwRingMode,
+            lpTapiPhoneTestInfo->lpdwVolume
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetRing:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetRing, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetStatus(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetStatus:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpPhoneStatus=x%lx",
+               lpTapiPhoneTestInfo->lpPhoneStatus);
+
+    lActual = phoneGetStatus(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpPhoneStatus
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetStatus:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetStatus, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetStatusMessages(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetStatusMessages:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwPhoneStates=x%lx",
+               lpTapiPhoneTestInfo->lpdwPhoneStates);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwButtonModes=x%lx",
+               lpTapiPhoneTestInfo->lpdwButtonModes);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwButtonStates=x%lx",
+               lpTapiPhoneTestInfo->lpdwButtonStates);
+
+    lActual = phoneGetStatusMessages(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->lpdwPhoneStates,
+            lpTapiPhoneTestInfo->lpdwButtonModes,
+            lpTapiPhoneTestInfo->lpdwButtonStates
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetStatusMessages:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetStatusMessages, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetVolume(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneGetVolume:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwHookSwitchDev=x%lx",
+               lpTapiPhoneTestInfo->dwHookSwitchDev);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwVolume=x%lx",
+               lpTapiPhoneTestInfo->lpdwVolume);
+
+    lActual = phoneGetVolume(
+            *lpTapiPhoneTestInfo->lphPhone,
+            lpTapiPhoneTestInfo->dwHookSwitchDev,
+            lpTapiPhoneTestInfo->lpdwVolume
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneGetVolume:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pGetVolume, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneInitialize(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneInitialize:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhoneApp=x%lx",
+               lpTapiPhoneTestInfo->lphPhoneApp);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thInstance=x%lx",
+               lpTapiPhoneTestInfo->hInstance);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpfnCallback=x%lx",
+               lpTapiPhoneTestInfo->lpfnCallback);
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpwszAppName=x%lx",
+               lpTapiPhoneTestInfo->lpwszAppName);
+#else
+*/
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpszAppName=x%lx",
+               lpTapiPhoneTestInfo->lpszAppName);
+//#endif
+
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwNumDevs=x%lx",
+               lpTapiPhoneTestInfo->lpdwNumDevs);
+
+/*
+#ifdef WUNICODE
+    lActual = phoneInitializeW(
+            lpTapiPhoneTestInfo->lphPhoneApp,
+            lpTapiPhoneTestInfo->hInstance,
+            lpTapiPhoneTestInfo->lpfnCallback,
+            lpTapiPhoneTestInfo->lpwszAppName,
+            lpTapiPhoneTestInfo->lpdwNumDevs
+            );
+#else
+*/
+    lActual = phoneInitialize(
+            lpTapiPhoneTestInfo->lphPhoneApp,
+            lpTapiPhoneTestInfo->hInstance,
+            lpTapiPhoneTestInfo->lpfnCallback,
+            lpTapiPhoneTestInfo->lpszAppName,
+            lpTapiPhoneTestInfo->lpdwNumDevs
+            );
+//#endif
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneInitialize:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pInitialize, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneNegotiateAPIVersion(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneNegotiateAPIVersion:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhoneApp=x%lx",
+               *lpTapiPhoneTestInfo->lphPhoneApp);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDeviceID=x%lx",
+               lpTapiPhoneTestInfo->dwDeviceID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwAPILowVersion=x%lx",
+               lpTapiPhoneTestInfo->dwAPILowVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwAPIHighVersion=x%lx",
+               lpTapiPhoneTestInfo->dwAPIHighVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwAPIVersion=x%lx",
+               lpTapiPhoneTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpExtensionID=x%lx",
+               lpTapiPhoneTestInfo->lpExtensionID);
+
+    lActual = phoneNegotiateAPIVersion(
+            *lpTapiPhoneTestInfo->lphPhoneApp,
+            lpTapiPhoneTestInfo->dwDeviceID,
+            lpTapiPhoneTestInfo->dwAPILowVersion,
+            lpTapiPhoneTestInfo->dwAPIHighVersion,
+            lpTapiPhoneTestInfo->lpdwAPIVersion,
+            lpTapiPhoneTestInfo->lpExtensionID
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneNegotiateAPIVersion:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pNegotiateAPIVersion, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneNegotiateExtVersion(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneNegotiateExtVersion:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhoneApp=x%lx",
+               *lpTapiPhoneTestInfo->lphPhoneApp);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDeviceID=x%lx",
+               lpTapiPhoneTestInfo->dwDeviceID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwAPIVersion=x%lx",
+               *lpTapiPhoneTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwExtLowVersion=x%lx",
+               lpTapiPhoneTestInfo->dwExtLowVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwExtHighVersion=x%lx",
+               lpTapiPhoneTestInfo->dwExtHighVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpdwExtVersion=x%lx",
+               lpTapiPhoneTestInfo->lpdwExtVersion);
+
+    lActual = phoneNegotiateExtVersion(
+            *lpTapiPhoneTestInfo->lphPhoneApp,
+            lpTapiPhoneTestInfo->dwDeviceID,
+            *lpTapiPhoneTestInfo->lpdwAPIVersion,
+            lpTapiPhoneTestInfo->dwExtLowVersion,
+            lpTapiPhoneTestInfo->dwExtHighVersion,
+            lpTapiPhoneTestInfo->lpdwExtVersion
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneNegotiateExtVersion:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pNegotiateExtVersion, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneOpen(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneOpen:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhoneApp=x%lx",
+               *lpTapiPhoneTestInfo->lphPhoneApp);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDeviceID=x%lx",
+               lpTapiPhoneTestInfo->dwDeviceID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlphPhone=x%lx",
+               lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwAPIVersion=x%lx",
+               *lpTapiPhoneTestInfo->lpdwAPIVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwExtVersion=x%lx",
+               *lpTapiPhoneTestInfo->lpdwExtVersion);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwCallbackInstance=x%lx",
+               lpTapiPhoneTestInfo->dwCallbackInstance);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwPrivilege=x%lx",
+               lpTapiPhoneTestInfo->dwPrivilege);
+
+    lActual = phoneOpen(
+            *lpTapiPhoneTestInfo->lphPhoneApp,
+            lpTapiPhoneTestInfo->dwDeviceID,
+            lpTapiPhoneTestInfo->lphPhone,
+            *lpTapiPhoneTestInfo->lpdwAPIVersion,
+            *lpTapiPhoneTestInfo->lpdwExtVersion,
+            lpTapiPhoneTestInfo->dwCallbackInstance,
+            lpTapiPhoneTestInfo->dwPrivilege
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneOpen:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pOpen, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetButtonInfo(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetButtonInfo:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwButtonLampID=x%lx",
+               lpTapiPhoneTestInfo->dwButtonLampID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpButtonInfo=x%lx",
+               lpTapiPhoneTestInfo->lpButtonInfo);
+
+    lActual = phoneSetButtonInfo(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->dwButtonLampID,
+               lpTapiPhoneTestInfo->lpButtonInfo
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetButtonInfo:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetButtonInfo, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetData(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetData:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwDataID=x%lx",
+               lpTapiPhoneTestInfo->dwDataID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpData=x%lx",
+               lpTapiPhoneTestInfo->lpData);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwSize=x%lx",
+               lpTapiPhoneTestInfo->dwSize);
+
+    lActual = phoneSetData(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->dwDataID,
+               lpTapiPhoneTestInfo->lpData,
+               lpTapiPhoneTestInfo->dwSize
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetData:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetData, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetDisplay(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetDisplay:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwRow=x%lx",
+               lpTapiPhoneTestInfo->dwRow);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwColumn=x%lx",
+               lpTapiPhoneTestInfo->dwColumn);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tlpsDisplay=x%lx",
+               lpTapiPhoneTestInfo->lpsDisplay);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwSize=x%lx",
+               lpTapiPhoneTestInfo->dwSize);
+
+    lActual = phoneSetDisplay(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->dwRow,
+               lpTapiPhoneTestInfo->dwColumn,
+               lpTapiPhoneTestInfo->lpsDisplay,
+               lpTapiPhoneTestInfo->dwSize
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetDisplay:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetDisplay, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetGain(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetGain:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwHookSwitchDev=x%lx",
+               lpTapiPhoneTestInfo->dwHookSwitchDev);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwGain=x%lx",
+               lpTapiPhoneTestInfo->dwGain);
+
+    lActual = phoneSetGain(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->dwHookSwitchDev,
+               *lpTapiPhoneTestInfo->lpdwGain
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetGain:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetGain, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetHookSwitch(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetHookSwitch:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwHookSwitchDevs=x%lx",
+               *lpTapiPhoneTestInfo->lpdwHookSwitchDevs);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwHookSwitchMode=x%lx",
+               lpTapiPhoneTestInfo->dwHookSwitchMode);
+
+    lActual = phoneSetHookSwitch(
+               *lpTapiPhoneTestInfo->lphPhone,
+               *lpTapiPhoneTestInfo->lpdwHookSwitchDevs,
+               lpTapiPhoneTestInfo->dwHookSwitchMode
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetHookSwitch:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetHookSwitch, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetLamp(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetLamp:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwButtonLampID=x%lx",
+               lpTapiPhoneTestInfo->dwButtonLampID);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwLampMode=x%lx",
+               *lpTapiPhoneTestInfo->lpdwLampMode);
+
+    lActual = phoneSetLamp(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->dwButtonLampID,
+               *lpTapiPhoneTestInfo->lpdwLampMode
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetLamp:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetLamp, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetRing(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetRing:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwRingMode=x%lx",
+               *lpTapiPhoneTestInfo->lpdwRingMode);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwVolume=x%lx",
+               *lpTapiPhoneTestInfo->lpdwVolume);
+
+    lActual = phoneSetRing(
+               *lpTapiPhoneTestInfo->lphPhone,
+               *lpTapiPhoneTestInfo->lpdwRingMode,
+               *lpTapiPhoneTestInfo->lpdwVolume
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetRing:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetRing, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+       }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetStatusMessages(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneSetStatusMessages:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwPhoneStates=x%lx",
+               *lpTapiPhoneTestInfo->lpdwPhoneStates);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwButtonModes=x%lx",
+               *lpTapiPhoneTestInfo->lpdwButtonModes);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwButtonStates=x%lx",
+               *lpTapiPhoneTestInfo->lpdwButtonStates);
+
+    lActual = phoneSetStatusMessages(
+            *lpTapiPhoneTestInfo->lphPhone,
+            *lpTapiPhoneTestInfo->lpdwPhoneStates,
+            *lpTapiPhoneTestInfo->lpdwButtonModes,
+            *lpTapiPhoneTestInfo->lpdwButtonStates
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetStatusMessages:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetStatusMessages, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneSetVolume(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        )
+{
+    TAPIMSG TapiMsg;
+    LONG lActual;
+    BOOL fSuccess;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetVolume:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhone=x%lx",
+               *lpTapiPhoneTestInfo->lphPhone);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwHookSwitchDev=x%lx",
+               lpTapiPhoneTestInfo->dwHookSwitchDev);
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\tdwVolume=x%lx",
+               *lpTapiPhoneTestInfo->lpdwVolume);
+
+    lActual = phoneSetVolume(
+               *lpTapiPhoneTestInfo->lphPhone,
+               lpTapiPhoneTestInfo->dwHookSwitchDev,
+               *lpTapiPhoneTestInfo->lpdwVolume
+               );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneSetVolume:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pSetVolume, lActual, lExpected);
+
+    fSuccess = ProcessAsyncPhoneAPI(lpTapiPhoneTestInfo, lActual, lExpected);
+
+    // Add expected message to list if a positive request ID was
+    // returned as expected
+    if (fSuccess == TRUE)
+    {
+    if(!lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+       if (lActual > 0)
+        {
+            CopyTapiMsgParams(
+                    &TapiMsg,
+                    PHONE_REPLY,
+                    0x0,
+                    lpTapiPhoneTestInfo->dwCallbackInstance,
+                    lActual,
+                    (DWORD) TAPISUCCESS,
+                    0x0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                            TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM2
+                    );
+
+            AddMessageByStruct(&TapiMsg);
+
+            if (fWaitHere)
+            {
+                 return (WaitForMessage(&TapiMsg));
+            }
+        }
+      }
+    }
+
+    return fSuccess;
+}
+
+
+BOOL
+WINAPI
+DoPhoneShutdown(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        )
+{
+    LONG lActual;
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  PhoneShutdown:  enter");
+    TapiLogDetail(
+               DBUG_SHOW_PARAMS,
+               "\thPhoneApp=x%lx",
+               *lpTapiPhoneTestInfo->lphPhoneApp);
+
+    lActual = phoneShutdown(
+            *lpTapiPhoneTestInfo->lphPhoneApp
+            );
+
+    TapiLogDetail(
+               DBUG_SHOW_ENTER_EXIT,
+               "  phoneShutdown:  exit, returned x%lx",
+               lActual);
+
+    SetLastTapiResult(pShutdown, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+
+#if TAPI_2_0
+
+
+BOOL
+WINAPI
+DoPhoneInitializeEx(LPTAPIPHONETESTINFO lpTapiPhoneTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  phoneInitializeEx:  enter");
+    (lpTapiPhoneTestInfo->lphPhoneApp == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphPhoneApp=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlphPhoneApp=x%lx",
+	       lpTapiPhoneTestInfo->lphPhoneApp);
+    (lpTapiPhoneTestInfo->hInstance == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thAppInst=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thAppInst=x%lx",
+	       lpTapiPhoneTestInfo->hInstance);
+    (lpTapiPhoneTestInfo->lpfnCallback == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpfnCallback=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpfnCallback=x%lx",
+	       lpTapiPhoneTestInfo->lpfnCallback);
+
+    #ifdef WUNICODE
+    (lpTapiPhoneTestInfo->lpwszFriendlyAppName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszFriendlyAppName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpwszFriendlyAppName=%lx",
+	       lpTapiPhoneTestInfo->lpwszFriendlyAppName);
+    #else
+	(lpTapiPhoneTestInfo->lpszFriendlyAppName == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszFriendlyAppName=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpszFriendlyAppName=%lx",
+	       lpTapiPhoneTestInfo->lpszFriendlyAppName);
+    #endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwNumDevs=x%lx",
+	       lpTapiPhoneTestInfo->lpdwNumDevs);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpdwAPIVersion=x%lx",
+	       lpTapiPhoneTestInfo->lpdwAPIVersion);
+    (lpTapiPhoneTestInfo->lpPhoneInitializeExParams == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpPhoneInitializeExParams=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpPhoneInitializeExParams=x%lx",
+	       lpTapiPhoneTestInfo->lpPhoneInitializeExParams);
+ 
+#ifdef WUNICODE
+    lActual = phoneInitializeExW(
+	       lpTapiPhoneTestInfo->lphPhoneApp,
+	       lpTapiPhoneTestInfo->hInstance,
+	       lpTapiPhoneTestInfo->lpfnCallback,
+	       lpTapiPhoneTestInfo->lpwszFriendlyAppName,
+	       lpTapiPhoneTestInfo->lpdwNumDevs,
+	       lpTapiPhoneTestInfo->lpdwAPIVersion,
+	       (LPPHONEINITIALIZEEXPARAMS)lpTapiPhoneTestInfo->lpPhoneInitializeExParams);
+#else
+    lActual = phoneInitializeEx(
+	       lpTapiPhoneTestInfo->lphPhoneApp,
+	       lpTapiPhoneTestInfo->hInstance,
+	       lpTapiPhoneTestInfo->lpfnCallback,
+	       lpTapiPhoneTestInfo->lpszFriendlyAppName,
+	       lpTapiPhoneTestInfo->lpdwNumDevs,
+	       lpTapiPhoneTestInfo->lpdwAPIVersion,
+	       (LPPHONEINITIALIZEEXPARAMS)lpTapiPhoneTestInfo->lpPhoneInitializeExParams);
+#endif
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  phoneInitializeEx:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(pInitializeEx, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+
+BOOL
+WINAPI
+DoPhoneGetMessage(LPTAPIPHONETESTINFO lpTapiPhoneTestInfo, LONG lExpected)
+{
+    LONG lActual;
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  phoneGetMessage:  enter");
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\thPhoneApp=x%lx",
+	       *lpTapiPhoneTestInfo->lphPhoneApp);
+    (lpTapiPhoneTestInfo->lpMessage == NULL) ?
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMessage=NULL") :
+	    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tlpMessage=x%lx",
+	       lpTapiPhoneTestInfo->lpMessage);
+    TapiLogDetail(
+	       DBUG_SHOW_PARAMS,
+	       "\tdwTimeout=x%lx",
+	       lpTapiPhoneTestInfo->dwTimeout);
+ 
+
+    lActual = phoneGetMessage(
+	       *lpTapiPhoneTestInfo->lphPhoneApp,
+	       lpTapiPhoneTestInfo->lpMessage,
+	       lpTapiPhoneTestInfo->dwTimeout);
+
+    TapiLogDetail(
+	       DBUG_SHOW_ENTER_EXIT,
+	       "  phoneGetMessage:  exit, returned x%lx",
+	       lActual);
+
+    SetLastTapiResult(pGetMessage, lActual, lExpected);
+
+    return CheckSyncPhoneResult(lpTapiPhoneTestInfo, lActual, lExpected);
+}
+
+#endif
diff --git a/private/tapi/qa/tcore/dophone.h b/private/tapi/qa/tcore/dophone.h
new file mode 100644
index 000000000..f8b64409a
--- /dev/null
+++ b/private/tapi/qa/tcore/dophone.h
@@ -0,0 +1,301 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    dophone.h
+
+Abstract:
+
+    This module contains the prototypes for the wrapper functions around
+    the Telephony API phone functions.  These functions provide logging
+    and both synchronous and asynchronous API processing to any
+    application or dll using the core dll.
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Nov-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef DOPHONE_H
+#define DOPHONE_H
+
+#include "windows.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+BOOL
+WINAPI
+DoPhoneClose(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneConfigDialog(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneDevSpecific(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetButtonInfo(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetData(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetDevCaps(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetDisplay(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetGain(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetHookSwitch(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetIcon(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetID(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetLamp(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetRing(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetStatus(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetStatusMessages(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneGetVolume(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneInitialize(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneNegotiateAPIVersion(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneNegotiateExtVersion(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneOpen(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetButtonInfo(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetData(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetDisplay(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetGain(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetHookSwitch(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetLamp(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetRing(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetStatusMessages(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+BOOL
+WINAPI
+DoPhoneSetVolume(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected,
+        BOOL fWaitHere
+        );
+
+
+BOOL
+WINAPI
+DoPhoneShutdown(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+#if TAPI_2_0
+
+BOOL
+WINAPI
+DoPhoneInitializeEx(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+
+
+BOOL
+WINAPI
+DoPhoneGetMessage(
+        LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+        LONG lExpected
+        );
+
+#endif
+#endif  // DOPHONE_H
diff --git a/private/tapi/qa/tcore/tcore.c b/private/tapi/qa/tcore/tcore.c
new file mode 100644
index 000000000..042168330
--- /dev/null
+++ b/private/tapi/qa/tcore/tcore.c
@@ -0,0 +1,2416 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tcore.c
+
+Abstract:
+
+    This module contains commonly used functions by the core dll that
+    wraps around TAPI.  Functions include:  sync/async API processing,
+    optional message handling, test resource data control, and helper
+    functions to streamline testing of TAPI.
+
+Author:
+
+    Oliver Wallace (OliverW)    13-July-1995
+
+Revision History:
+    pgopi  Mar-22-1996   fixed bug in WaitForMessage()
+
+--*/
+
+
+#define _TCORELIB_
+
+
+#include <windows.h>
+#include <malloc.h>
+#include <string.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+#include "doline.h"
+
+
+// Macros that determine if an error code is valid
+#define IsValidLineError(lError) ((DWORD) (lError) == 0x0 || \
+				 ( (DWORD) (lError) >= LINEERR_ALLOCATED && \
+				 ((DWORD) (lError) <= LAST_LINEERR) ))
+
+#define IsValidPhoneError(lError) ((DWORD) (lError) == 0x0 || \
+				  ( (DWORD) (lError) >= PHONEERR_ALLOCATED && \
+				  ((DWORD) (lError) <= LAST_PHONEERR) ))
+
+
+#define IsValidTapiError(lError) ((DWORD) (lError) == 0x0 || \
+				  ( (DWORD) (lError) >= TAPIERR_ALLOCATED && \
+				  ((DWORD) (lError) <= LAST_TAPIERR) ))
+
+
+
+#ifdef WIN32
+
+#define EXPORT
+
+BOOL
+WINAPI
+TcoreDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+	case DLL_PROCESS_ATTACH:
+
+	    ghDll = hDLL;
+
+	    // Allocate a thread local storage index for the test resources
+	    gdwTlsIndex = TlsAlloc();
+
+	    if (gdwTlsIndex == TLS_OUT_OF_INDEXES)
+	    {
+		return (FALSE);
+	    }
+
+	    AllocTestResources();
+
+	    break;
+
+	case DLL_THREAD_ATTACH:
+
+	    break;
+
+	case DLL_THREAD_DETACH:
+
+	    // TODO:  TLS needs to be reorg'ed due to async event threads
+	    //        in TAPI 2.0 being created and terminated.  This cause
+	    //        a DLL_THREAD_ATTACH every time the last hLineApp is
+	    //        shutdown.
+	    //        For now, don't worry about memory cleanup.  Fix ASAP
+	    //        after SUR beta 1.
+#if 0
+	    // Ensure the thread local storage index was allocated
+	    if (gdwTlsIndex != TLS_OUT_OF_INDEXES)
+	    {
+		// Free the memory allocated for the tests
+		FreeTestResources();
+
+		// Free the TLS index
+		TlsFree(gdwTlsIndex);
+	    }
+#endif
+	    break;
+
+	case DLL_PROCESS_DETACH:
+
+	    // Free the test resources
+	    if (gdwTlsIndex != TLS_OUT_OF_INDEXES)
+	    {
+		// Free the memory allocated for the tests
+		FreeTestResources();
+
+		// Free the TLS index
+		TlsFree(gdwTlsIndex);
+	    }
+	    break;
+    }
+
+    return TRUE;
+}
+
+#else
+
+// BUGBUG
+
+#define EXPORT __export
+
+int
+FAR
+PASCAL
+LibMain(
+    HANDLE  hInstance,
+    WORD    wDataSegment,
+    WORD    wHeapSize,
+    LPSTR   lpszCmdLine
+    )
+{
+    ghDll = hInstance;
+
+    return TRUE;
+}
+
+#endif
+
+
+VOID
+WINAPI
+TapiCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    )
+{
+    DWORD dwExpectedFlags = 0x00000000;
+    BOOL fMsgMatched;
+    LPCALLBACKPARAMS lpCallbackParams = GetCallbackParams();
+    LPTAPIMSG lpReceivedMsg = lpCallbackParams ? lpCallbackParams->lpReceivedMsg : NULL;
+
+    TapiLogDetail(
+	DBUG_SHOW_ENTER_EXIT,
+	"> TapiCallback:  enter"
+	);
+
+    // Copy the received message parameters into a TapiMsg structure
+    CopyTapiMsgParams(
+	lpReceivedMsg,
+	dwMsg,
+	hDevice,
+	dwCallbackInstance,
+	dwParam1,
+	dwParam2,
+	dwParam3,
+	TAPIMSG_ALL
+	);
+
+    // Display the message info for debugging purposes
+    ShowTapiMsgInfo(lpReceivedMsg);
+
+    // Check to see if the received message was in the expected message list
+    // If the message is found, move it from the expected to the received list
+    fMsgMatched = CheckReceivedMessage(
+	lpCallbackParams,
+	lpReceivedMsg,
+	&dwExpectedFlags
+	);
+
+    // Add the message to the received list, first set the dwExpected Flags to match
+    // the expected message if there was a match (it'll be assigned 0x00000000
+    // if fMsgMatched == FALSE)
+    if (lpReceivedMsg)
+    {
+	lpReceivedMsg->dwFlags = dwExpectedFlags;
+    }
+    AddReceivedMessageByStruct(lpReceivedMsg);
+
+
+    if (! fMsgMatched)
+    {
+	// process unexpected message
+
+	switch (dwMsg)
+	{
+	    // TODO:  Add cases for fatal and non-fatal messages received,
+	    //        including ones that might be generated from
+	    //        another test thread (e.g. REINIT)
+	    default:
+		TapiLogDetail(
+		    DBUG_SHOW_DETAIL,
+		    "    Warning:  Unexpected message received"
+		    );
+	}
+    }
+
+    TapiLogDetail(
+	DBUG_SHOW_ENTER_EXIT,
+	"> TapiCallback:  exit"
+	);
+}
+
+
+BOOL
+WINAPI
+TcoreSuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES) TlsGetValue(
+	    gdwTlsIndex
+	    );
+
+    // Assume pointer to log function hasn't been assigned to
+    // thread local storage when TcoreSuiteInit is called
+    return (lpTestResources && (lpTestResources->lpfnLogProc = pfnLog));
+}
+
+
+BOOL
+WINAPI
+TcoreSuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+TcoreSuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+TcoreSuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+VOID
+CALLBACK
+TcoreTimerProc(
+    HWND hwnd,
+    UINT uMsg,
+    UINT idEvent,
+    DWORD dwTime
+    )
+{
+    LPCALLBACKPARAMS lpCallbackParams = GetCallbackParams();
+
+    if (lpCallbackParams)
+    {
+	lpCallbackParams->fMsgTimeout = TRUE;
+    }
+}
+
+
+HLOCAL
+WINAPI
+ITAlloc(size_t size)
+{
+    return LocalAlloc(LPTR, size);
+}
+
+HLOCAL
+WINAPI
+ITFree(LPVOID lpvMem)
+{
+    return LocalFree( LocalHandle(lpvMem) );
+}
+
+DWORD
+WINAPI
+ITSize(
+    LPVOID lpvMem
+    )
+{
+    return LocalSize( LocalHandle(lpvMem) );
+}
+
+LPVOID
+ITMemSet(LPVOID lpvMem, INT c, size_t size)
+{
+    return memset(lpvMem, c, size);
+}
+
+
+VOID
+WINAPI
+OutputTAPIDebugInfo(
+	       int nLogLvl,
+	       LPSTR lpszDebugInfo
+	       )
+{
+    TapiLogDetail(
+	       nLogLvl,
+	       lpszDebugInfo);
+}
+
+
+// ProcessAsyncFunc determines if the initial call to an asynchronous
+// function completed with the expected results.  lExpected should either
+// be set to the expected error value or to TAPISUCCESS if the asynchronous
+// function was supposed to return a positive request ID.  lActual should be
+// set to the value returned from the asynchronous TAPI function.
+// Possible outcomes for this function are:
+//     1)  lActual > 0, lExpected == TAPISUCCESS  --->  returns TRUE
+//     2)  lActual > 0, lExpected == LINEERR_XXX  --->  returns FALSE
+//     3)  lActual < 0, lExpected == lActual      --->  returns TRUE
+//     4)  lActual < 0, lExpected != lActual      --->  returns FALSE
+//     5)  lActual < 0, lExpected == TAPISUCCESS  --->  returns FALSE
+//     6)  lActual == 0                           --->  returns FALSE
+//
+BOOL
+ProcessAsyncFunc(
+	       LPTAPILINETESTINFO lpTapiLineTestInfo,
+	       LONG lActual,
+	       LONG lExpected
+	       )
+{
+    if (lActual < 0)
+    {
+   /*	 XYD, the logic is not right here
+	if (lExpected == TAPISUCCESS && lActual == LINEERR_OPERATIONUNAVAIL)
+	{
+	    TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		">> Device doesn't support API -- returned OPERATIONUNAVAIL <<"
+		);
+	
+	    return TRUE;
+	} */
+	if (lExpected == TAPISUCCESS)
+	{
+	    TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"  Call to TAPI function FAILED");
+	    TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"          expected positive request ID, returned err=x%lx",
+		lActual);
+	    return FALSE;
+	}
+
+	else if (lActual == lExpected)
+	{
+	    // Expected error return matched the actual error return value
+	    TapiLogDetail(
+		DBUG_SHOW_SUCCESS,
+		"  Initial call to asynchronous TAPI function PASSED");
+
+	    return TRUE;
+	}
+	else if (lExpected == TAPISUCCESS && lActual == LINEERR_OPERATIONUNAVAIL)
+	{
+	    TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		">> Device doesn't support API -- returned OPERATIONUNAVAIL <<"
+		);
+	
+	    return TRUE;
+	}
+	else
+	{
+	    // Expected error return did not match the actual error return
+	    TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"          expected err=x%lx, returned err=x%lx",
+		lExpected,
+		lActual);
+	    return FALSE;
+	}
+    }
+    else if (lActual > 0)
+    {
+    if(lpTapiLineTestInfo->fCompletionModeSet)
+      {
+	    if (lExpected < 0)
+	    {
+	    	    // No Error returned when a positive request ID was expected
+	    	  TapiLogDetail(
+			  	  DBUG_SHOW_FAILURE,
+			  	  "          expected return =x%lx, " \
+			  	  "returned positive request ID=x%lx",
+			  	  lExpected,
+			  	  lActual);
+	   	  	   return TRUE;
+		  }
+     }
+    else 
+    {
+	 if (lExpected < 0)
+	 {
+	    // Error was returned when a positive request ID was expected
+	    TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"          expected err=x%lx, " \
+		"returned positive request ID=x%lx",
+		lExpected,
+		lActual);
+	    return FALSE;
+	 }
+	 else if (lExpected == TAPISUCCESS)
+	 {
+	    // Positive request ID was returned as expected.
+	    TapiLogDetail(
+		DBUG_SHOW_SUCCESS,
+		"  Initial call to asynchronous TAPI function PASSED");
+	    return TRUE;
+	 }
+	 else
+	 {
+	    // lExpected should never be > 0
+	    TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"          invalid expected async return value");
+	    return FALSE;
+	 }
+    }
+    }
+    else   // lActual == 0
+    {
+	// TAPI should never return 0 for an asynchronous function
+	TapiLogDetail(
+	    DBUG_SHOW_FAILURE,
+	    "          invalid value of 0 returned");
+	return FALSE;
+    }
+}
+
+
+BOOL
+ProcessAsyncPhoneAPI(
+	       LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+	       LONG lActual,
+	       LONG lExpected
+	       )
+{
+    if (lActual < 0)
+    {
+        if (lExpected == TAPISUCCESS)
+        {
+            TapiLogDetail(
+                DBUG_SHOW_FAILURE,"  Call to TAPI function FAILED");
+            TapiLogDetail(
+                DBUG_SHOW_FAILURE,
+                "    expected positive request ID, returned err=x%lx",
+                lActual);
+            return FALSE;
+        }
+        else if (lActual == lExpected)
+	     {
+	         // Expected error return matched the actual error return value
+	         TapiLogDetail(
+		          DBUG_SHOW_SUCCESS,
+		          "Initial call to asynchronous TAPI function PASSED");
+
+	         return TRUE;
+	     }
+        else if (lExpected == TAPISUCCESS &&
+                 lActual == PHONEERR_OPERATIONUNAVAIL)
+	     {
+	         TapiLogDetail(
+		          DBUG_SHOW_DETAIL,
+		          ">> Device doesn't support API -- returned OPERATIONUNAVAIL <<"
+		          );
+	
+	         return TRUE;
+	     }
+        else
+	     {
+	         // Expected error return did not match the actual error return
+	         TapiLogDetail(
+		          DBUG_SHOW_FAILURE,
+		          "          expected err=x%lx, returned err=x%lx",
+		          lExpected,
+		          lActual);
+	         return FALSE;
+	      }
+    }
+    else if (lActual > 0)
+    {
+    if (lExpected < 0)
+    {
+    if(lpTapiPhoneTestInfo->fCompletionModeSet)
+      {
+	         // Error was returned when a positive request ID was expected
+	         TapiLogDetail(
+		          DBUG_SHOW_FAILURE,
+		          "          expected err=x%lx, " \
+		          "returned positive request ID=x%lx",
+		          lExpected,
+		          lActual);
+	         return TRUE;
+       }
+     else
+      {
+	         // Error was returned when a positive request ID was expected
+	         TapiLogDetail(
+		          DBUG_SHOW_FAILURE,
+		          "          expected err=x%lx, " \
+		          "returned positive request ID=x%lx",
+		          lExpected,
+		          lActual);
+	         return FALSE;
+       }
+      }
+	    else if (lExpected == TAPISUCCESS)
+	     {
+	         // Positive request ID was returned as expected.
+	         TapiLogDetail(
+		          DBUG_SHOW_SUCCESS,
+		          "  Initial call to asynchronous TAPI function PASSED");
+	         return TRUE;
+	     }
+	     else
+	     {
+	         // lExpected should never be > 0
+	         TapiLogDetail(
+		          DBUG_SHOW_FAILURE,
+		          "          invalid expected async return value");
+	         return FALSE;
+	     }
+    }
+    else   // lActual == 0
+    {
+	     // TAPI should never return 0 for an asynchronous function
+	     TapiLogDetail(
+	        DBUG_SHOW_FAILURE,
+	        "          invalid value of 0 returned");
+	        return FALSE;
+    }
+}
+
+
+BOOL
+SyncCheckResult(
+	       LPTAPILINETESTINFO lpTapiLineInfo,
+	       LONG lActual,
+	       LONG lExpected
+	       )
+{
+    if (lActual == lExpected)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_SUCCESS,
+		"> Call to synchronous TAPI function returned matched\r\n" \
+		"    > expected value of:  %s%s",
+		lExpected ? "LINEERR_" : "",
+		aszLineErrors[LOWORD((DWORD) (lActual))]
+		);
+	return TRUE;
+    }
+    else if (lExpected == TAPISUCCESS && lActual == LINEERR_OPERATIONUNAVAIL)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		">> Device doesn't support API -- returned OPERATIONUNAVAIL <<"
+		);
+    return TRUE;
+    }
+    else
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> Call to synchronous TAPI function FAILED\r\n    " \
+		"> \texpected error = %s%s\r\n    > \treturned error = %s%s",
+		lExpected ? "LINEERR_" : "",
+		aszLineErrors[LOWORD((DWORD) (lExpected))],
+		lExpected ? "LINEERR_" : "",
+		aszLineErrors[LOWORD((DWORD) (lActual))]
+		);
+	return FALSE;
+    }
+}
+
+
+BOOL
+CheckSyncPhoneResult(
+	       LPTAPIPHONETESTINFO lpTapiPhoneInfo,
+	       LONG lActual,
+	       LONG lExpected
+	       )
+{
+    if (lActual == lExpected)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_SUCCESS,
+		"> Call to synchronous TAPI function returned matched\r\n" \
+		"    > expected value of:  %s%s",
+		lExpected ? "PHONEERR_" : "",
+		aszPhoneErrors[LOWORD((DWORD) (lActual))]
+		);
+	return TRUE;
+    }
+    else if (lExpected == TAPISUCCESS && lActual == PHONEERR_OPERATIONUNAVAIL)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		">> Device doesn't support API -- returned OPERATIONUNAVAIL <<"
+		);
+     return TRUE;
+    }
+    else
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> Call to synchronous TAPI function FAILED\r\n    " \
+		"> \texpected error = %s%s\r\n    > \treturned error = %s%s",
+		lExpected ? "PHONEERR_" : "",
+		aszPhoneErrors[LOWORD((DWORD) (lExpected))],
+		lExpected ? "PHONEERR_" : "",
+		aszPhoneErrors[LOWORD((DWORD) (lActual))]
+		);
+	return FALSE;
+    }
+}
+
+
+BOOL
+CheckSyncTapiResult(
+	       LPTAPILINETESTINFO lpTapiLineInfo,
+	       LONG lActual,
+	       LONG lExpected
+	       )
+{
+    if (lActual == lExpected)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_SUCCESS,
+		"> Call to synchronous TAPI function returned matched\r\n" \
+		"    > expected value of:  %s%s",
+		lExpected ? "TAPIERR_" : "",
+		aszTapiErrors[LOWORD((DWORD) (abs(lActual)))]
+		);
+	return TRUE;
+    }
+	/*
+    else if (lExpected == TAPISUCCESS && lActual == TAPIERR_OPERATIONUNAVAIL)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		">> Device doesn't support API -- returned OPERATIONUNAVAIL <<"
+		);
+     return TRUE;
+    }
+	*/
+    else
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> Call to synchronous TAPI function FAILED\r\n    " \
+		"> \texpected error = %s%s\r\n    > \treturned error = %s%s",
+		lExpected ? "TAPIERR_" : "",
+		aszTapiErrors[LOWORD((DWORD) (abs(lExpected)))],
+		lExpected ? "TAPIERR_" : "",
+		aszTapiErrors[LOWORD((DWORD) (abs(lActual)))]
+		);
+	return FALSE;
+    }
+}
+
+
+
+VOID
+WINAPI
+TapiLineTestInit()
+{
+    LPTAPILINETESTINFO lpLineTestInfo = GetLineTestInfo();
+    HINSTANCE hAppInstance;
+
+    if (lpLineTestInfo == NULL)
+    {
+	lpLineTestInfo = (LPTAPILINETESTINFO) ITAlloc(sizeof(TAPILINETESTINFO));
+    }
+
+    hAppInstance = (HINSTANCE) GetModuleHandle("trapper.exe");
+   
+    lpLineTestInfo->fCompletionModeSet = FALSE;
+
+    // Initialize pointers
+    lpLineTestInfo->lphLineApp           = &(lpLineTestInfo->hLineApp1);
+    lpLineTestInfo->lphLine              = &(lpLineTestInfo->hLine1);
+    lpLineTestInfo->lpfnCallback         = TapiCallback;
+    lpLineTestInfo->lpExtensionName      = NULL;
+
+#ifdef WUNICODE
+    lpLineTestInfo->lpwszMediaExtName     = NULL;
+    lpLineTestInfo->lpwsztapiAppName      = NULL;
+    lpLineTestInfo->lpwszAppFilename      = NULL;
+    lpLineTestInfo->lpwszFileName         = NULL;
+    lpLineTestInfo->lpwszDeviceClass      = NULL;
+    lpLineTestInfo->lpwszDestAddress      = NULL;
+    lpLineTestInfo->lpwszProviderFilename = NULL;
+    lpLineTestInfo->lpwsAddress           = NULL;
+    lpLineTestInfo->lpwszAddressIn        = NULL;
+#else
+    lpLineTestInfo->lpszMediaExtName     = NULL;
+    lpLineTestInfo->lpsztapiAppName      = NULL;
+    lpLineTestInfo->lpszAppFilename      = NULL;
+    lpLineTestInfo->lpszFileName         = NULL;
+    lpLineTestInfo->lpszDeviceClass      = NULL;
+    lpLineTestInfo->lpszDestAddress      = NULL;
+    lpLineTestInfo->lpszProviderFilename = NULL;
+    lpLineTestInfo->lpsAddress           = NULL;
+    lpLineTestInfo->lpszAddressIn        = NULL;
+#endif
+
+    strcpy(lpLineTestInfo->szAppName, "tcore.dll");
+    lpLineTestInfo->lpszAppName          = &lpLineTestInfo->szAppName[0];
+    lpLineTestInfo->lpsUserUserInfo      = NULL;
+    lpLineTestInfo->lpdwNumDevs          = &lpLineTestInfo->dwNumDevs;
+    lpLineTestInfo->lpdwPriority         = &lpLineTestInfo->dwPriority;
+
+    lpLineTestInfo->lphCall              = &lpLineTestInfo->hCall1;
+    lpLineTestInfo->lphConfCall          = &lpLineTestInfo->hConfCall1;
+    lpLineTestInfo->lphConsultCall       = &lpLineTestInfo->hConsultCall1;
+    lpLineTestInfo->lpdwCompletionID     = &lpLineTestInfo->dwCompletionID;
+    lpLineTestInfo->lpParams             = NULL;
+    lpLineTestInfo->lpTranslateOutput    = NULL;
+    lpLineTestInfo->lpTranslateCaps      = NULL;
+    lpLineTestInfo->lpDialParams         = NULL;
+
+    lpLineTestInfo->lpExtID              = &(lpLineTestInfo->ExtID);
+    lpLineTestInfo->lpdwAPIVersion       = &(lpLineTestInfo->dwAPIVersion);
+    lpLineTestInfo->lpdwExtVersion       = &(lpLineTestInfo->dwExtVersion);
+    lpLineTestInfo->lpdwNumRings         = &(lpLineTestInfo->dwNumRings);
+
+    lpLineTestInfo->lpLineDevCaps        = NULL;
+    lpLineTestInfo->lpLineDevStatus      = NULL;
+    lpLineTestInfo->lpLineAddressCaps    = NULL;
+    lpLineTestInfo->lpLineAddressStatus  = NULL;
+    lpLineTestInfo->lpCallList           = NULL;
+    lpLineTestInfo->lpCallParams         = NULL;
+    lpLineTestInfo->lpCallStatus         = &lpLineTestInfo->CallStatus;
+    lpLineTestInfo->lpForwardList        = NULL;
+    lpLineTestInfo->lphIcon              = &lpLineTestInfo->hIcon;
+    lpLineTestInfo->lpDeviceID           = &lpLineTestInfo->DeviceID;
+    lpLineTestInfo->lpDeviceConfig       = NULL;
+    lpLineTestInfo->lpDeviceConfigIn     = NULL;
+    lpLineTestInfo->lpDeviceConfigOut    = NULL;
+    lpLineTestInfo->lpCallInfo           = NULL;
+    lpLineTestInfo->lpdwLineStates       = &lpLineTestInfo->dwLineStates;
+    lpLineTestInfo->lpdwAddressStates    = &lpLineTestInfo->dwAddressStates;
+    lpLineTestInfo->lpdwAddressID        = &lpLineTestInfo->dwAddressID;
+    lpLineTestInfo->lpdwPermanentProviderID =
+	    &lpLineTestInfo->dwPermanentProviderID;
+    lpLineTestInfo->lpRequestBuffer      = NULL;
+
+    memset(&(lpLineTestInfo->ExtIDZero), 0, sizeof(LINEEXTENSIONID));
+    memset(&(lpLineTestInfo->CallParams), 0, sizeof(LINECALLPARAMS));
+    memset(&(lpLineTestInfo->DeviceID), 0, sizeof(VARSTRING));
+
+    (lpLineTestInfo->CallParams).dwTotalSize = sizeof(LINECALLPARAMS);
+    (lpLineTestInfo->DeviceID).dwTotalSize   = sizeof(VARSTRING);
+
+    // Initialize the remaining fields
+    lpLineTestInfo->hwndOwner            = hAppInstance;
+    lpLineTestInfo->hInstance            = hAppInstance;
+    lpLineTestInfo->dwCountryCode        = 0x00000000;
+    lpLineTestInfo->dwLocation           = 0x00000000;
+    lpLineTestInfo->dwTerminalModes      = 0x00000000;
+    lpLineTestInfo->dwTerminalID         = 0x00000000;
+    lpLineTestInfo->dwTollListOption     = 0x00000000;
+    lpLineTestInfo->dwTranslateOptions   = 0x00000000;
+    lpLineTestInfo->dwCard               = 0x00000000;
+    lpLineTestInfo->dwDeviceID           = 0x00000000;
+    lpLineTestInfo->dwAddressID          = 0x00000000;
+    lpLineTestInfo->dwExtLowVersion      = GOOD_EXTVERSION;
+    lpLineTestInfo->dwExtHighVersion     = GOOD_EXTVERSION;
+    lpLineTestInfo->dwExtVersion         = 0x00000000;
+    lpLineTestInfo->dwAPILowVersion      = LOW_APIVERSION;
+    lpLineTestInfo->dwAPIHighVersion     = HIGH_APIVERSION;
+    lpLineTestInfo->dwAPIVersion         = 0x00000000;
+    lpLineTestInfo->dwMediaModes         = LINEMEDIAMODE_UNKNOWN;
+    lpLineTestInfo->dwMediaMode          = 0x00000000;
+    lpLineTestInfo->dwRequestMode        = 0x00000000;
+    lpLineTestInfo->dwPrivileges         = LINECALLPRIVILEGE_OWNER;
+    lpLineTestInfo->dwCallPrivilege      = 0x00000000;
+    lpLineTestInfo->dwSelect             = 0x00000000;
+    lpLineTestInfo->dwSize               = 0x00000000;
+    lpLineTestInfo->dwBearerMode         = 0x00000000;
+    lpLineTestInfo->dwMinRate            = 0x00000000;
+    lpLineTestInfo->dwMaxRate            = 0x00000000;
+    lpLineTestInfo->dwNumRings           = 0x00000000;
+    lpLineTestInfo->dwLineStates         = 0x00000000;
+    lpLineTestInfo->dwAddressStates      = 0x00000000;
+    lpLineTestInfo->dwAppSpecific        = 0x00000000;
+    lpLineTestInfo->dwCompletionMode     = 0x00000000;
+    lpLineTestInfo->dwTransferMode       = 0x00000000;
+    lpLineTestInfo->dwMessageID          = 0x00000000;
+    lpLineTestInfo->dwFeature            = 0x00000000;
+    lpLineTestInfo->dwNumRingsNoAnswer   = 0x00000000;
+    lpLineTestInfo->bAllAddresses        = 0x00000000;
+    lpLineTestInfo->dwNumParties         = 0x00000000;
+
+    lpLineTestInfo->dwParkMode           = 0x00000000;
+
+#ifdef WUNICODE
+    lpLineTestInfo->lpwszDirAddress       = NULL;
+    lpLineTestInfo->lpwszGroupID          = NULL;
+    lpLineTestInfo->lpwsDigits            = NULL;
+    lpLineTestInfo->lpwszTerminationDigits= NULL;
+    lpLineTestInfo->lpwszDigits           = NULL;
+    lpLineTestInfo->lpwszDeviceClass_Orig = NULL;
+    lpLineTestInfo->lpwszCountryCode      = NULL;
+    lpLineTestInfo->lpwszCityCode         = NULL;
+    lpLineTestInfo->lpwszCalledParty      = NULL;
+    lpLineTestInfo->lpwszComment          = NULL;
+    lpLineTestInfo->lpwszDeviceID         = NULL;
+#else
+    lpLineTestInfo->lpszDirAddress       = NULL;
+    lpLineTestInfo->lpszGroupID          = NULL;
+    lpLineTestInfo->lpsDigits            = NULL;
+    lpLineTestInfo->lpszTerminationDigits= NULL;
+    lpLineTestInfo->lpszDigits           = NULL;
+    lpLineTestInfo->lpszDeviceClass_Orig = NULL;
+    lpLineTestInfo->lpszCountryCode      = NULL;
+    lpLineTestInfo->lpszCityCode         = NULL;
+    lpLineTestInfo->lpszCalledParty      = NULL;
+    lpLineTestInfo->lpszComment          = NULL;
+    lpLineTestInfo->lpszDeviceID         = NULL;
+#endif
+
+    lpLineTestInfo->lpNonDirAddress      = NULL;
+
+    lpLineTestInfo->dwDigitModes         = 0x00000000;
+    lpLineTestInfo->dwNumDigits          = 0x00000000;
+    lpLineTestInfo->dwFirstDigitTimeout  = 0x00000000;
+    lpLineTestInfo->dwInterDigitTimeout  = 0x00000000;
+    lpLineTestInfo->dwDigitModes         = 0x00000000;
+    lpLineTestInfo->dwDigitMode          = 0x00000000;
+    lpLineTestInfo->dwDuration           = 0x00000000;
+    lpLineTestInfo->dwToneMode           = 0x00000000;
+    lpLineTestInfo->dwNumTones           = 0x00000000;
+    lpLineTestInfo->dwNumEntries         = 0x00000000;
+    lpLineTestInfo->dwDigitNumEntries    = 0x00000000;
+    lpLineTestInfo->dwMediaNumEntries    = 0x00000000;
+    lpLineTestInfo->dwToneNumEntries     = 0x00000000;
+    lpLineTestInfo->dwCallStateNumEntries= 0x00000000;
+    lpLineTestInfo->lpMCToneList         = NULL;
+    lpLineTestInfo->lpMCMediaList        = NULL;
+    lpLineTestInfo->lpMCDigitList        = NULL;
+    lpLineTestInfo->lpMCCallStateList    = NULL;
+    lpLineTestInfo->lpToneList           = NULL;
+    lpLineTestInfo->lpTones              = NULL;
+
+    lpLineTestInfo->lpfnCallback_Orig    = NULL;
+    lpLineTestInfo->hLineApp_Orig        = 0x00000000;
+    lpLineTestInfo->hInstance_Orig       = 0x00000000;
+    lpLineTestInfo->hLine_Orig           = 0x00000000;
+    lpLineTestInfo->hCall_Orig           = 0x00000000;
+    lpLineTestInfo->dwCountryCode_Orig   = 0x00000000;
+    lpLineTestInfo->dwDeviceID_Orig      = 0x00000000;
+    lpLineTestInfo->dwAPIVersion_Orig    = 0x00000000;
+    lpLineTestInfo->dwExtVersion_Orig    = 0x00000000;
+    lpLineTestInfo->dwMediaModes_Orig    = 0x00000000;
+    lpLineTestInfo->dwPrivileges_Orig    = 0x00000000;
+    lpLineTestInfo->dwNumDevs_Orig       = 0x00000000;
+    lpLineTestInfo->dwNumRings_Orig      = 0x00000000;
+    lpLineTestInfo->dwAddressID_Orig     = 0x00000000;
+    lpLineTestInfo->dwSelect_Orig        = 0x00000000;
+    lpLineTestInfo->dwSize_Orig          = 0x00000000;
+    lpLineTestInfo->dwLineStates_Orig    = 0x00000000;
+    lpLineTestInfo->dwAddressStates_Orig = 0x00000000;
+
+    lpLineTestInfo->dwRegistrationInstance = 0x00000000;
+    lpLineTestInfo->bEnable              = 0x00000000;
+
+    lpLineTestInfo->hLineApp1            = 0x00000000;
+    lpLineTestInfo->hLineApp2            = 0x00000000;
+    lpLineTestInfo->hLineApp3            = 0x00000000;
+    lpLineTestInfo->hLine1               = 0x00000000;
+    lpLineTestInfo->hLine2               = 0x00000000;
+    lpLineTestInfo->hLine3               = 0x00000000;
+    lpLineTestInfo->hCall1               = 0x00000000;
+    lpLineTestInfo->hCall2               = 0x00000000;
+    lpLineTestInfo->hCall3               = 0x00000000;
+    lpLineTestInfo->hActiveCall          = 0x00000000;
+    lpLineTestInfo->hHeldCall            = 0x00000000;
+    lpLineTestInfo->hIcon                = 0x00000000;
+    lpLineTestInfo->hConfCall1           = 0x00000000;
+    lpLineTestInfo->hConsultCall1        = 0x00000000;
+    
+
+    lpLineTestInfo->hwnd                 = (HWND) NULL;
+    lpLineTestInfo->wRequestID           = 0x00000000;
+    lpLineTestInfo->dwSecure             = 0x00000000;
+	
+
+#if TAPI_2_0
+
+    lpLineTestInfo->dwAgentExtensionIDIndex  = 0x00000000;
+    lpLineTestInfo->dwAppAPIVersion          = 0x00000000;
+    lpLineTestInfo->lpAgentCaps              = NULL;
+    lpLineTestInfo->lpAgentActivityList      = NULL;
+    lpLineTestInfo->lpAgentGroupList         = NULL;
+    lpLineTestInfo->lpAgentStatus            = NULL;
+    lpLineTestInfo->dwMsg                    = 0x00000000;
+    lpLineTestInfo->dwParam1                 = 0x00000000;
+    lpLineTestInfo->dwParam2                 = 0x00000000;
+    lpLineTestInfo->dwParam3                 = 0x00000000;
+    lpLineTestInfo->lpProxyRequest           = NULL;
+    lpLineTestInfo->dwResult                 = 0x00000000;
+    lpLineTestInfo->dwActivityID             = 0x00000000;
+    lpLineTestInfo->dwAgentState             = LINEAGENTSTATE_READY;
+    lpLineTestInfo->dwNextAgentState         = LINEAGENTSTATE_READY;
+    lpLineTestInfo->lpCallData               = NULL;
+    lpLineTestInfo->lpSendingFlowspec        = NULL;
+    lpLineTestInfo->dwSendingFlowspecSize    = 0x00000000;
+    lpLineTestInfo->lpReceivingFlowspec      = NULL;
+    lpLineTestInfo->dwReceivingFlowspecSize  = 0x00000000;
+    lpLineTestInfo->dwTreatment              = 0x00000000;
+    lpLineTestInfo->dwStatusToChange         = LINEAGENTSTATUS_ACTIVITY;
+    lpLineTestInfo->fStatus                  = 0x00000000;
+
+#ifdef WUNICODE
+    lpLineTestInfo->lpwszFriendlyAppName     = NULL;
+#else
+    lpLineTestInfo->lpszFriendlyAppName      = NULL;
+#endif
+    lpLineTestInfo->lpLineInitializeExParams = NULL;
+    lpLineTestInfo->lpMessage                = NULL;
+    lpLineTestInfo->dwTimeout                = 0;
+#endif
+
+    // Information used to keep track of asynchronous messages
+    InitializeCallbackParams();
+
+    lpLineTestInfo->dwCallbackInstance   = (DWORD) GetCallbackParams();
+}
+
+
+VOID
+WINAPI
+TapiPhoneTestInit()
+{
+    LPTAPIPHONETESTINFO lpPhoneTestInfo  = GetPhoneTestInfo();
+
+    if (lpPhoneTestInfo == NULL)
+    {
+	lpPhoneTestInfo = (LPTAPIPHONETESTINFO) ITAlloc(sizeof(TAPIPHONETESTINFO));
+    }
+
+    lpPhoneTestInfo->fCompletionModeSet = FALSE;
+
+    lpPhoneTestInfo->lphPhoneApp         = &lpPhoneTestInfo->hPhoneApp1;
+    lpPhoneTestInfo->lphPhone            = &lpPhoneTestInfo->hPhone1;
+    lpPhoneTestInfo->hInstance           = ghDll;
+    lpPhoneTestInfo->lpdwAPIVersion      = &lpPhoneTestInfo->dwAPIVersion;
+    lpPhoneTestInfo->lpdwExtVersion      = &lpPhoneTestInfo->dwExtVersion;
+    lpPhoneTestInfo->lpdwGain            = &lpPhoneTestInfo->dwGain;
+    lpPhoneTestInfo->lpdwHookSwitchDevs  = &lpPhoneTestInfo->dwHookSwitchDevs;
+    lpPhoneTestInfo->lpdwLampMode        = &lpPhoneTestInfo->dwLampMode;
+    lpPhoneTestInfo->lpdwRingMode        = &lpPhoneTestInfo->dwRingMode;
+    lpPhoneTestInfo->lpdwVolume          = &lpPhoneTestInfo->dwVolume;
+    lpPhoneTestInfo->lpdwPhoneStates     = &lpPhoneTestInfo->dwPhoneStates;
+    lpPhoneTestInfo->lpdwButtonModes     = &lpPhoneTestInfo->dwButtonModes;
+    lpPhoneTestInfo->lpdwButtonStates    = &lpPhoneTestInfo->dwButtonStates;
+    lpPhoneTestInfo->lpdwNumDevs         = &lpPhoneTestInfo->dwNumDevs;
+
+    lpPhoneTestInfo->lpParams                = NULL;
+    lpPhoneTestInfo->lpButtonInfo            = NULL;
+    lpPhoneTestInfo->lpData                  = NULL;
+    lpPhoneTestInfo->lpPhoneCaps             = NULL;
+    lpPhoneTestInfo->lpDisplay               = NULL;
+    lpPhoneTestInfo->lphIcon                 = &lpPhoneTestInfo->hIcon;
+    lpPhoneTestInfo->lpDeviceID              = &lpPhoneTestInfo->DeviceID;
+#ifdef WUNICODE
+    lpPhoneTestInfo->lpwszDeviceClass        = NULL;
+#else
+    lpPhoneTestInfo->lpszDeviceClass         = NULL;
+#endif
+    lpPhoneTestInfo->lpPhoneStatus           = NULL;
+    lpPhoneTestInfo->lpfnCallback            = TapiCallback;
+/*
+#ifdef WUNICODE
+    lpPhoneTestInfo->lpwszAppName            = NULL;
+#else
+*/
+    lpPhoneTestInfo->lpszAppName             = NULL;
+//#endif
+    lpPhoneTestInfo->lpExtensionID           = &lpPhoneTestInfo->ExtensionID;
+    lpPhoneTestInfo->lpButtonInfo            = NULL;
+    lpPhoneTestInfo->lpsDisplay              = NULL;
+
+    lpPhoneTestInfo->dwDeviceID              = 0x00000000;
+    lpPhoneTestInfo->dwSize                  = 0x00000000;
+    lpPhoneTestInfo->dwButtonLampID          = 0x00000000;
+    lpPhoneTestInfo->dwDataID                = 0x00000000;
+    lpPhoneTestInfo->dwAPILowVersion         = LOW_APIVERSION;
+    lpPhoneTestInfo->dwAPIHighVersion        = HIGH_APIVERSION;
+    lpPhoneTestInfo->dwExtLowVersion         = GOOD_EXTVERSION;
+    lpPhoneTestInfo->dwExtHighVersion        = GOOD_EXTVERSION;
+    lpPhoneTestInfo->dwCallbackInstance      = 0x00000000;
+    lpPhoneTestInfo->dwPrivilege             = 0x00000000;
+    lpPhoneTestInfo->dwRow                   = 0x00000000;
+    lpPhoneTestInfo->dwColumn                = 0x00000000;
+
+    lpPhoneTestInfo->hPhoneApp1              = 0x00000000;
+    lpPhoneTestInfo->hPhoneApp2              = 0x00000000;
+    lpPhoneTestInfo->hPhoneApp3              = 0x00000000;
+    lpPhoneTestInfo->hPhone1                 = 0x00000000;
+    lpPhoneTestInfo->hPhone2                 = 0x00000000;
+    lpPhoneTestInfo->hPhone3                 = 0x00000000;
+    lpPhoneTestInfo->dwAPIVersion            = 0x00000000;
+    lpPhoneTestInfo->dwExtVersion            = 0x00000000;
+    lpPhoneTestInfo->dwGain                  = 0x00000000;
+    lpPhoneTestInfo->dwHookSwitchDev         = 0x00000000;
+    lpPhoneTestInfo->dwHookSwitchDevs        = 0x00000000;
+    lpPhoneTestInfo->dwHookSwitchMode        = 0x00000000;
+    lpPhoneTestInfo->dwLampMode              = 0x00000000;
+    lpPhoneTestInfo->dwRingMode              = 0x00000000;
+    lpPhoneTestInfo->dwVolume                = 0x00000000;
+    lpPhoneTestInfo->dwPhoneStates           = 0x00000000;
+    lpPhoneTestInfo->dwButtonModes           = 0x00000000;
+    lpPhoneTestInfo->dwButtonStates          = 0x00000000;
+    lpPhoneTestInfo->dwNumDevs               = 0x00000000;
+    lpPhoneTestInfo->hwndOwner               = 0x00000000;
+    lpPhoneTestInfo->hIcon                   = 0x00000000;
+
+    memset(&lpPhoneTestInfo->DeviceID, 0, sizeof(VARSTRING));
+
+    lpPhoneTestInfo->hPhoneApp_Orig          = 0x00000000;
+    lpPhoneTestInfo->hPhone_Orig             = 0x00000000;
+    lpPhoneTestInfo->hInstance_Orig          = 0x00000000;
+    lpPhoneTestInfo->lpfnCallback_Orig       = 0x00000000;
+    lpPhoneTestInfo->dwDeviceID_Orig         = 0x00000000;
+    lpPhoneTestInfo->dwSize_Orig             = 0x00000000;
+    lpPhoneTestInfo->dwButtonLampID_Orig     = 0x00000000;
+    lpPhoneTestInfo->dwDataID_Orig           = 0x00000000;
+    lpPhoneTestInfo->dwAPIVersion_Orig       = 0x00000000;
+    lpPhoneTestInfo->dwExtVersion_Orig       = 0x00000000;
+    lpPhoneTestInfo->dwGain_Orig             = 0x00000000;
+    lpPhoneTestInfo->dwHookSwitchDev_Orig    = 0x00000000;
+    lpPhoneTestInfo->dwHookSwitchDevs_Orig   = 0x00000000;
+    lpPhoneTestInfo->dwHookSwitchMode_Orig   = 0x00000000;
+    lpPhoneTestInfo->dwLampMode_Orig         = 0x00000000;
+    lpPhoneTestInfo->dwRingMode_Orig         = 0x00000000;
+    lpPhoneTestInfo->dwVolume_Orig           = 0x00000000;
+    lpPhoneTestInfo->dwPhoneStates_Orig      = 0x00000000;
+    lpPhoneTestInfo->dwButtonModes_Orig      = 0x00000000;
+    lpPhoneTestInfo->dwButtonStates_Orig     = 0x00000000;
+    lpPhoneTestInfo->dwCallbackInstance_Orig = 0x00000000;
+    lpPhoneTestInfo->dwPrivilege_Orig        = 0x00000000;
+    lpPhoneTestInfo->dwRow_Orig              = 0x00000000;
+    lpPhoneTestInfo->dwColumn_Orig           = 0x00000000;
+    lpPhoneTestInfo->hwndOwner_Orig          = 0x00000000;
+
+#if TAPI_2_0
+#ifdef WUNICODE
+    lpPhoneTestInfo->lpwszFriendlyAppName     = NULL;
+#else
+    lpPhoneTestInfo->lpszFriendlyAppName      = NULL;
+#endif
+    lpPhoneTestInfo->lpPhoneInitializeExParams= NULL;
+    lpPhoneTestInfo->lpMessage                = NULL;
+    lpPhoneTestInfo->dwTimeout                = 0;
+#endif
+
+    // Information used to keep track of asynchronous messages
+    InitializeCallbackParams();
+
+    lpPhoneTestInfo->dwCallbackInstance   = (DWORD) GetCallbackParams();
+}
+
+
+// AddMessageByStruct() takes the expected message parameters and adds the
+// expected message information to the end of the active elements in
+// the message list stored in the test resources structure.  If
+// the lpCallbackParams pointer is NULL,
+// the message information will not be added to the list and the
+// function will return FALSE, otherwise AddMessageByStruct() will
+// return TRUE.
+LPTAPIMSG
+WINAPI
+AddMessageByStruct(
+    LPTAPIMSG lpMsg
+    )
+{
+    if (lpMsg)
+    {
+	return (AddMessage(
+		lpMsg->dwMsg,
+		lpMsg->hDevCall,
+		lpMsg->dwCallbackInstance,
+		lpMsg->dwParam1,
+		lpMsg->dwParam2,
+		lpMsg->dwParam3,
+		lpMsg->dwFlags
+		));
+    }
+    else
+    {
+	return NULL;
+    }
+}
+
+
+// AddReceivedMessageByStruct() takes the received message parameters
+// and adds the expected message information to the end of the active
+// elements in the message list stored in the test resources structure.
+// If the lpCallbackParams pointer is NULL,
+// the message information will not be added to the list and the
+// function will return FALSE, otherwise AddReceivedMessageByStruct()
+// will return TRUE.
+LPTAPIMSG
+WINAPI
+AddReceivedMessageByStruct(
+    LPTAPIMSG lpMsg
+    )
+{
+    if (lpMsg)
+    {
+	return (AddReceivedMessage(
+		lpMsg->dwMsg,
+		lpMsg->hDevCall,
+		lpMsg->dwCallbackInstance,
+		lpMsg->dwParam1,
+		lpMsg->dwParam2,
+		lpMsg->dwParam3,
+		lpMsg->dwFlags
+		));
+    }
+    else
+    {
+	return NULL;
+    }
+}
+
+
+// AddMessage() takes the expected message parameters and adds the
+// expected message information to the end of the active elements in
+// the message array stored in the test resources structure.  If
+// the array is full or the lpCallbackParams pointer is NULL,
+// the message information will not be added to the array and the
+// function will return FALSE, otherwise AddMessage() will return TRUE.
+LPTAPIMSG
+WINAPI
+AddMessage(
+    DWORD dwMsg,
+    DWORD hDevice,
+    DWORD dwCallbackInstance,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3,
+    DWORD dwFlags
+    )
+{
+    LPCALLBACKPARAMS lpCallbackParams;
+    LPTAPIMSG lpTapiMsgs;
+    LPTAPIMSG lpNewMsg = NULL;
+
+    lpCallbackParams   = GetCallbackParams();
+	
+	/*
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"In the AddMessage");
+
+		ShowExpectedMsgs(lpCallbackParams);
+	  */
+
+    lpTapiMsgs         = lpCallbackParams->lpExpTapiMsgs;
+
+
+    if (lpCallbackParams)
+    {
+	// Allocate a new node
+	if ((lpNewMsg = (LPTAPIMSG) ITAlloc(sizeof(*lpNewMsg))) != NULL)
+	{
+	    // Insert to the beginning of the list
+	    lpNewMsg->dwMsg                    = dwMsg;
+	    lpNewMsg->hDevCall                 = hDevice;
+	    lpNewMsg->dwParam1                 = dwParam1;
+	    lpNewMsg->dwParam2                 = dwParam2;
+	    lpNewMsg->dwParam3                 = dwParam3;
+	    lpNewMsg->dwCallbackInstance       = dwCallbackInstance;
+	    lpNewMsg->dwFlags                  = dwFlags;
+
+	    lpNewMsg->lpNext                   = lpTapiMsgs;
+	    lpCallbackParams->lpExpTapiMsgs    = lpNewMsg;
+	}
+    }
+
+//      ShowExpectedMsgs(lpCallbackParams);
+
+    if (! lpNewMsg)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"  ERROR:  Attempt to add an expected msg failed."
+		);
+    }
+
+    return lpNewMsg;
+}
+
+
+// AddReceivedMessage() takes the received message parameters and adds the
+// expected message information to the end of the active elements in
+// the message list stored in the test resources structure.  If
+// the lpCallbackParams pointer is NULL,
+// the message information will not be added to the array and the
+// function will return FALSE, otherwise AddReceivedMessage() will return
+// TRUE.
+LPTAPIMSG
+WINAPI
+AddReceivedMessage(
+    DWORD dwMsg,
+    DWORD hDevice,
+    DWORD dwCallbackInstance,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3,
+    DWORD dwFlags
+    )
+{
+    LPCALLBACKPARAMS lpCallbackParams;
+    LPTAPIMSG lpTapiMsgs;
+    LPTAPIMSG lpNewMsg = NULL;
+
+    lpCallbackParams   = GetCallbackParams();
+    lpTapiMsgs         = lpCallbackParams->lpRecTapiMsgs;
+
+
+    if (lpCallbackParams)
+    {
+	// Allocate a new node
+	if ((lpNewMsg = (LPTAPIMSG) ITAlloc(sizeof(*lpNewMsg))) != NULL)
+	{
+	    // Insert to the end of the list using the tail pointer
+
+	    // Copy the msg params
+	    lpNewMsg->dwMsg                                = dwMsg;
+	    lpNewMsg->hDevCall                             = hDevice;
+	    lpNewMsg->dwParam1                             = dwParam1;
+	    lpNewMsg->dwParam2                             = dwParam2;
+	    lpNewMsg->dwParam3                             = dwParam3;
+	    lpNewMsg->dwCallbackInstance                   = dwCallbackInstance;
+	    lpNewMsg->dwFlags                              = dwFlags;
+	
+	    lpNewMsg->lpNext                               = NULL;
+	
+	    // Note:  Use the received msg list pointer to determine
+	    //        if the list is empty
+	    if (lpTapiMsgs == NULL)
+	    {
+		// Set the pointer to the first node == to the new tail
+		lpCallbackParams->lpRecTapiMsgs            = lpNewMsg;
+	    }
+	    else
+	    {
+		// Set the old tail to point to the new msg added to the end
+		lpCallbackParams->lpRecTapiMsgTail->lpNext = lpNewMsg;
+	    }
+
+	    // Assign the tail pointer to point to the new msg
+	    lpCallbackParams->lpRecTapiMsgTail             = lpNewMsg;
+		
+	}
+    }
+
+    if (! lpNewMsg)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"  ERROR:  Attempt to add a received msg failed."
+		);
+    }
+
+    return lpNewMsg;
+}
+
+
+// CheckReceivedMessage() searches the list of messages being waited on
+// and finds the message corresponding to the values in the lpReceivedMsg
+// parameter.  If none of the messages in the list match, then FALSE is
+// returned.  If the message parameters do not match the expected message
+// parameters for corresponding IDs, then FALSE is returned.  Otherwise,
+// TRUE is returned.  If a match is found,
+//
+// This function assumes that lpCallbackParams and lpReceivedMsg
+// are valid pointers.
+BOOL
+CheckReceivedMessage(
+    LPCALLBACKPARAMS lpCallbackParams,
+    LPTAPIMSG lpReceivedMsg,
+    LPDWORD lpdwFlags
+    )
+{
+    BOOL fFound                           = FALSE;
+    LPTAPIMSG lpExpMsg                    = lpCallbackParams->lpExpTapiMsgs;
+    LPTAPIMSG lpPrevExpMsg = NULL;
+
+    while(lpExpMsg != NULL && fFound != TRUE)
+    {
+        if (CompareTapiMsgs(lpExpMsg, lpReceivedMsg))
+        {
+            // found a match, expected message was received
+            fFound = TRUE;
+
+            // Copy the dwFlags for the expected msg to preserve its values
+            if (lpdwFlags)
+            {
+                *lpdwFlags = lpExpMsg->dwFlags;
+            }
+	
+            // Remove the received msg from the expected list
+            if (lpPrevExpMsg == NULL)
+            {
+                // Message was at the beginning of the list, so set
+                // the beginning of the list to the next pointer
+                lpCallbackParams->lpExpTapiMsgs = lpExpMsg->lpNext;
+            }
+            else
+            {
+                // Set the previous pointer to point to the next node after
+                // the received msg in the expected msg list
+                lpPrevExpMsg->lpNext = lpExpMsg->lpNext;
+            }
+
+            // Deallocate the found expected message node
+            ITFree(lpExpMsg);
+        }
+        else
+        {
+            lpPrevExpMsg = lpExpMsg;
+            lpExpMsg = lpExpMsg->lpNext;
+        }
+    }
+    return fFound;
+}
+
+
+// IsTapiMsgInQ() searches a linked list of msgs for a match.
+// If lpTapiMsg is in the list pointed to by lpFirstTapiMsg, then
+// this function returns TRUE.  Otherwise, FALSE is returned.
+BOOL
+IsTapiMsgInQ(
+    LPTAPIMSG lpFirstTapiMsg,
+    LPTAPIMSG lpTapiMsg
+    )
+{
+    LPTAPIMSG lpTmpMsg = lpFirstTapiMsg;
+
+    while (lpTmpMsg != NULL)
+    {
+	if(CompareTapiMsgs(lpTmpMsg, lpTapiMsg))
+	{
+	    return TRUE;
+	}
+	lpTmpMsg = lpTmpMsg->lpNext;
+    }
+    return FALSE;
+}
+
+
+// ClearTapiMsg() initializes all of the tapi message fields to zero
+// for the message pointed to by lpTapiMsg.  If lpTapiMsg is null,
+// this function simply returns.
+VOID
+WINAPI
+ClearTapiMsg(
+    LPTAPIMSG lpTapiMsg
+    )
+{
+    if (lpTapiMsg)
+    {
+	memset(
+	    lpTapiMsg,
+	    0,
+	    sizeof(TAPIMSG)
+	    );
+    }
+}
+
+
+// InitializeCallbackParams() resets the flags used for processing
+// asynchronous TAPI messages, and it initalizes information used
+// to maintain the message array.  The current size of the array is
+// set to 0, the count of messages not received is set to 0, the
+// memory containing the message array is filled with 0's, and the
+// flag marking a fatal callback message is set to FALSE.
+VOID
+InitializeCallbackParams()
+{
+    LPCALLBACKPARAMS lpCallbackParams = GetCallbackParams();
+
+    if (lpCallbackParams)
+    {
+	lpCallbackParams->fCallbackFatalError = FALSE;
+	lpCallbackParams->fMsgTimeout         = FALSE;
+
+	ClearTapiMsg(lpCallbackParams->lpReceivedMsg);
+
+	RemoveExpectedMsgs(lpCallbackParams);
+	RemoveReceivedMsgs(lpCallbackParams);
+    }
+}
+
+
+// CopyTapiMsgParams() copies the message parameters into the
+// TAPIMSG structure pointed to by lpTapiMsg if lpTapiMsg is
+// not null.  If lpTapiMsg is null, this function does nothing.
+VOID
+WINAPI
+CopyTapiMsgParams(
+    LPTAPIMSG lpTapiMsg,
+    DWORD dwMsg,
+    DWORD hDevCall,
+    DWORD dwCallbackInstance,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3,
+    DWORD dwFlags
+    )
+{
+    if (lpTapiMsg)
+    {
+	lpTapiMsg->hDevCall           = hDevCall;
+	lpTapiMsg->dwCallbackInstance = dwCallbackInstance;
+	lpTapiMsg->dwMsg              = dwMsg;
+	lpTapiMsg->dwParam1           = dwParam1;
+	lpTapiMsg->dwParam2           = dwParam2;
+	lpTapiMsg->dwParam3           = dwParam3;
+	lpTapiMsg->dwFlags            = dwFlags;
+    }
+}
+
+
+// CallbackParamsGetDevCallHandle() returns the hDevCall field corresponding
+// to the first received message that matches the
+// the dwMsg field of the TAPIMSG with the specified dwMsg value.
+// If lpCallbackParams is NULL or a match isn't found, this function
+// will return 0.
+DWORD
+WINAPI
+CallbackParamsGetDevCallHandle(
+    LPCALLBACKPARAMS lpCallbackParams,
+    DWORD dwMsg
+    )
+{
+    LPTAPIMSG lpTapiMsg;
+
+    if (lpCallbackParams)
+    {
+	lpTapiMsg = lpCallbackParams->lpRecTapiMsgs;
+
+	while (lpTapiMsg)
+	{
+	    if (lpTapiMsg->dwMsg == dwMsg)
+	    {
+		return lpTapiMsg->hDevCall;
+	    }
+    lpTapiMsg = lpTapiMsg->lpNext;  // XYD
+	}
+    }
+    return 0x00000000;
+}
+
+
+// RemoveReceivedMsgs() removes all messages in the received msg list
+// This function does nothing if the lpCallbackParams pointer hasn't
+// been allocated.
+//
+VOID
+WINAPI
+RemoveReceivedMsgs(
+    LPCALLBACKPARAMS lpCallbackParams
+    )
+{
+    if (lpCallbackParams)
+    {
+	FreeTapiMsgList(&lpCallbackParams->lpRecTapiMsgs);
+	lpCallbackParams->lpRecTapiMsgTail = NULL;
+    }
+}
+
+
+// RemoveExpectedMsgs() will deallocate all expected messages.
+// If lpCallbackParams hasn't been allocated, this function does nothing.
+VOID
+WINAPI
+RemoveExpectedMsgs(
+    LPCALLBACKPARAMS lpCallbackParams
+    )
+{
+    if (lpCallbackParams)
+    {
+	FreeTapiMsgList(&lpCallbackParams->lpExpTapiMsgs);
+    }
+}
+
+
+VOID
+WINAPI
+FreeTapiMsgList(
+    LPTAPIMSG *lppMsg
+    )
+{
+    LPTAPIMSG lpMsg, lpMsgPrev;
+
+    if (lppMsg)
+    {
+	lpMsg = *lppMsg;
+
+	while(lpMsg != NULL)
+	{
+	    // Free the previous node and traverse to the next node
+	    lpMsgPrev = lpMsg;
+	    lpMsg     = lpMsg->lpNext;
+	    ITFree(lpMsgPrev);
+	}
+	*lppMsg = NULL;
+    }
+}
+
+
+// ShowReceivedMsgs displays all messages currently in the received
+// message list.
+VOID
+WINAPI
+ShowReceivedMsgs(
+	LPCALLBACKPARAMS lpCallbackParams
+	)
+{
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "> ShowReceivedMsgs:  enter"
+	    );
+
+    if (lpCallbackParams)
+    {
+	ShowTapiMsgList(lpCallbackParams->lpRecTapiMsgs);
+    }
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "> ShowReceivedMsgs:  exit"
+	    );
+}
+
+
+// ShowExpectedMsgs displays all messages currently in the expected
+// message list.
+VOID
+WINAPI
+ShowExpectedMsgs(
+	LPCALLBACKPARAMS lpCallbackParams
+	)
+{
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "> ShowExpectedMsgs:  enter"
+	    );
+
+    if (lpCallbackParams)
+    {
+	ShowTapiMsgList(lpCallbackParams->lpExpTapiMsgs);
+    }
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "> ShowExpectedMsgs:  exit"
+	    );
+}
+
+
+// ShowTapiMsgList() traverses a linked list of TAPI messages and
+// displays all message parameter for each message in the list.
+VOID
+WINAPI
+ShowTapiMsgList(
+	LPTAPIMSG lpTapiMsg
+	)
+{
+    LPTAPIMSG lpMsg = lpTapiMsg;
+
+    while (lpMsg != NULL)
+    {
+	ShowTapiMsgInfo(lpMsg);
+
+	lpMsg = lpMsg->lpNext;
+    }
+}
+
+
+// CompareTapiMsgs() compares two messages and returns TRUE if the messages
+// match.  Otherwise FALSE is returned.  This function only compares
+// parameters that are specified according to the set bit flags in the
+// dwFlags field of the expected message (lpExpectedMsg).
+// If the message matches an asynchronous reply, the status (dwParam2)
+// value is checked, and an error is flagged to the user.
+BOOL
+WINAPI
+CompareTapiMsgs(
+    LPTAPIMSG lpExpectedMsg,
+    LPTAPIMSG lpReceivedMsg
+    )
+{
+    BOOL fMsgsMatch = FALSE;
+    BOOL fAsyncReply = FALSE;
+    DWORD dwFlags;
+    LONG lErrorCode;
+    CHAR szErrorDesc[80] = "";
+    LPCALLBACKPARAMS lpCallbackParams = GetCallbackParams();
+
+    if (lpExpectedMsg && lpReceivedMsg)
+    {
+	dwFlags = lpExpectedMsg->dwFlags;
+
+	if (lpReceivedMsg->dwMsg == LINE_REPLY ||
+	    lpReceivedMsg->dwMsg == PHONE_REPLY)
+	{
+	    lErrorCode = (LONG) lpReceivedMsg->dwParam2;
+	    fAsyncReply = TRUE;
+	    dwFlags &= ~ TAPIMSG_DWPARAM2;    // Don't check async error return here
+	}
+	fMsgsMatch = (
+       (!(dwFlags & TAPIMSG_HDEVCALL) ||
+	    (lpExpectedMsg->hDevCall == lpReceivedMsg->hDevCall)) &&
+	    (!(dwFlags & TAPIMSG_DWCALLBACKINST) ||
+	    (lpExpectedMsg->dwCallbackInstance ==
+		  lpReceivedMsg->dwCallbackInstance)) &&
+	    (!(dwFlags & TAPIMSG_DWMSG) ||
+	    (lpExpectedMsg->dwMsg == lpReceivedMsg->dwMsg)) &&
+	    (!(dwFlags & TAPIMSG_DWPARAM1) ||
+	    (lpExpectedMsg->dwParam1 == lpReceivedMsg->dwParam1)) &&
+	    (!(dwFlags & TAPIMSG_DWPARAM2) ||
+	    (lpExpectedMsg->dwParam2 == lpReceivedMsg->dwParam2)) &&
+	    (!(dwFlags & TAPIMSG_DWPARAM3) ||
+	    (lpExpectedMsg->dwParam3 == lpReceivedMsg->dwParam3)) );
+
+   /*
+   if(lpReceivedMsg->dwMsg == LINE_PROXYREQUEST)
+   {
+	lpCallbackParams->fCallbackFatalError = TRUE;
+    return fMsgsMatch;
+   }
+   */
+	if (fMsgsMatch && fAsyncReply)
+	{
+	    // Report an error if unexpected async reply returned
+	   if (lErrorCode != (LONG) lpExpectedMsg->dwParam2)
+	    {
+		if (lpReceivedMsg->dwMsg == LINE_REPLY &&
+			IsValidLineError(lErrorCode))
+		{
+		    wsprintf(
+			    szErrorDesc,
+			    "%s%s",
+			    lErrorCode ? "LINEERR_" : "",
+			    aszLineErrors[LOWORD(lErrorCode)]
+			    );
+		}
+		else if (lpReceivedMsg->dwMsg == PHONE_REPLY &&
+			IsValidPhoneError(lErrorCode))
+		{
+		    wsprintf(
+			    szErrorDesc,
+			    "%s%s",
+			    lErrorCode ? "PHONEERR_" : "",
+			    aszPhoneErrors[LOWORD(lErrorCode)]
+			    );
+		}
+	  else
+		{
+		    wsprintf(szErrorDesc, "x%lx?", lErrorCode);
+		}
+
+		TapiLogDetail(
+			DBUG_SHOW_FAILURE,
+			"\tError:  unexpected async reply status of %s " \
+			"returned.",
+			szErrorDesc
+			);
+
+		// Mark this as a fatal callback error
+		lpCallbackParams->fCallbackFatalError = TRUE;
+	    }
+	}
+    }
+
+    return fMsgsMatch;
+}
+
+
+// CopyTapiMsgs() copies the message parameters from the source to
+// the destination.  If either of the message pointers are NULL,
+// this function does nothing.
+VOID
+WINAPI
+CopyTapiMsgs(
+    LPTAPIMSG lpSrcMsg,
+    LPTAPIMSG lpDestMsg
+    )
+{
+    if (lpSrcMsg && lpDestMsg)
+    {
+	lpDestMsg->hDevCall           = lpSrcMsg->hDevCall;
+	lpDestMsg->dwCallbackInstance = lpSrcMsg->dwCallbackInstance;
+	lpDestMsg->dwMsg              = lpSrcMsg->dwMsg;
+	lpDestMsg->dwParam1           = lpSrcMsg->dwParam1;
+	lpDestMsg->dwParam2           = lpSrcMsg->dwParam2;
+	lpDestMsg->dwParam3           = lpSrcMsg->dwParam3;
+	lpDestMsg->dwFlags            = lpSrcMsg->dwFlags;
+    }
+}
+
+
+// This function returns the first available address that a test function
+// can use out of a thread local heap.  If there is not enough room for
+// the
+LPVOID
+WINAPI
+AllocFromTestHeap(
+    size_t NeededSize
+    )
+{
+    LPVOID lpvMem;
+    LPTESTHEAPINFO lpTestHeapInfo   = GetTestHeapInfo();
+
+
+    if (lpTestHeapInfo == NULL ||
+	lpTestHeapInfo->dwFreeOffset + (DWORD) NeededSize >= TESTHEAPSIZE)
+    {
+	TapiLogDetail(
+		   DBUG_SHOW_FAILURE,
+		   "  Error -- Not enough storage space in local heap");
+	return NULL;
+    }
+    else
+    {
+	lpvMem = ( (LPVOID) ((DWORD) lpTestHeapInfo->lpHeap +
+		lpTestHeapInfo->dwFreeOffset) );
+	lpTestHeapInfo->dwFreeOffset += (DWORD) NeededSize;
+	TapiLogDetail(
+		 DBUG_SHOW_DETAIL,
+		 "> Allocated x%lx bytes from test heap at x%lx.",
+		 NeededSize,
+		 (DWORD) lpvMem
+		 );
+	return lpvMem;
+    }
+}
+
+
+// FreeTestHeap() zeroes the bytes contained in the heap, and resets the
+// first available offset to 0.
+//
+// Note:  The memory containing the heap is not free'd.
+VOID
+WINAPI
+FreeTestHeap()
+{
+    LPTESTHEAPINFO lpTestHeapInfo = GetTestHeapInfo();
+
+    if (lpTestHeapInfo)
+    {
+        if(lpTestHeapInfo->lpHeap)
+            FillMemory(lpTestHeapInfo->lpHeap, TESTHEAPSIZE, 0);
+        lpTestHeapInfo->dwFreeOffset = 0;
+        TapiLogDetail(DBUG_SHOW_DETAIL, "> Test heap freed");
+    }
+}
+
+
+// DoExtensionIDsMatch() returns true if the LINEEXTENSIONID fields are
+// equal, else it returns false.
+BOOL
+WINAPI
+DoExtensionIDsMatch(
+    LPLINEEXTENSIONID lpExtID1,
+    LPLINEEXTENSIONID lpExtID2
+    )
+{
+    if (lpExtID1 && lpExtID2)
+    {
+	return (memcmp(lpExtID1, lpExtID2, sizeof(LINEEXTENSIONID)) == 0);
+    }
+    else
+    {
+	return FALSE;
+    }
+}
+
+
+// AllocTestResources() allocates the memory needed to store the fields
+// in the test resources structure.  This function then sets the test
+// resources pointer as the value stored in thread local storage.
+VOID
+AllocTestResources()
+{
+    LPTESTRESOURCES lpTestResources;
+
+    // Allocate memory for fields that will store the test data
+    lpTestResources = (LPTESTRESOURCES) ITAlloc(sizeof(TESTRESOURCES));
+    if(lpTestResources == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE,"AllocTestResources:ITAlloc failed");
+        return;
+    }
+
+    lpTestResources->lpTestHeapInfo = (LPTESTHEAPINFO) ITAlloc(
+	    sizeof(TESTHEAPINFO)
+	    );
+    if(lpTestResources->lpTestHeapInfo == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+
+    lpTestResources->lpTestHeapInfo->lpHeap = ITAlloc(TESTHEAPSIZE);
+    if(lpTestResources->lpTestHeapInfo->lpHeap == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+    lpTestResources->lpTestHeapInfo->dwFreeOffset = 0;
+
+    lpTestResources->lpTapiLineTestInfo = (LPTAPILINETESTINFO) ITAlloc(
+	    sizeof(TAPILINETESTINFO)
+	    );
+    if(lpTestResources->lpTapiLineTestInfo == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+    lpTestResources->lpTapiPhoneTestInfo = (LPTAPIPHONETESTINFO) ITAlloc(
+	    sizeof(TAPIPHONETESTINFO)
+	    );
+    if(lpTestResources->lpTapiPhoneTestInfo == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+    lpTestResources->lpCallbackParams = (LPCALLBACKPARAMS) ITAlloc(
+	    sizeof(CALLBACKPARAMS)
+	    );
+    if(lpTestResources->lpCallbackParams == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+    lpTestResources->lpCallbackParams->lpReceivedMsg = (LPTAPIMSG) ITAlloc(
+	    sizeof(TAPIMSG)
+	    );
+    if(lpTestResources->lpCallbackParams->lpReceivedMsg == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+    lpTestResources->lpLastTapiResult = (LPTAPIRESULT) ITAlloc(
+	    sizeof(TAPIRESULT)
+	    );
+    if(lpTestResources->lpLastTapiResult == NULL)
+    {
+        TapiLogDetail(DBUG_SHOW_FAILURE, "AllocTestResources:ITAlloc failed");
+        return;
+    }
+    TlsSetValue(gdwTlsIndex, lpTestResources);
+}
+
+
+// FreeTestResources() frees the memory used to store the fields in the
+// resources.
+VOID
+FreeTestResources()
+{
+    LPTESTRESOURCES lpTestResources =
+	(LPTESTRESOURCES) TlsGetValue(gdwTlsIndex);
+
+    // Test to make sure memory was allocated
+    if (lpTestResources)
+    {
+	if (GetLogProc())
+	{
+	    TapiLogDetail(DBUG_SHOW_ENTER_EXIT, "> Freeing test resources");
+	}
+
+	// Free the various memory allocations made to store
+	// the test data
+	RemoveExpectedMsgs(lpTestResources->lpCallbackParams);
+	RemoveReceivedMsgs(lpTestResources->lpCallbackParams);
+	ITFree((LPVOID) lpTestResources->lpCallbackParams->lpReceivedMsg);
+	ITFree((LPVOID) lpTestResources->lpCallbackParams);
+	ITFree((LPVOID) lpTestResources->lpTestHeapInfo->lpHeap);
+	ITFree((LPVOID) lpTestResources->lpTestHeapInfo);
+	ITFree((LPVOID) lpTestResources->lpTapiLineTestInfo);
+	ITFree((LPVOID) lpTestResources->lpTapiPhoneTestInfo);
+	ITFree((LPVOID) lpTestResources->lpLastTapiResult);
+	ITFree((LPVOID) lpTestResources);
+    }
+}
+
+
+// GetTestHeapInfo returns the pointer to the test heap info structure
+// in the test resources stored in thread local storage.
+LPTESTHEAPINFO
+WINAPI
+GetTestHeapInfo()
+{
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    return lpTestResources ? lpTestResources->lpTestHeapInfo : NULL;
+}
+
+
+// GetLineTestInfo returns the pointer to the line test info structure
+// in the test resources stored in thread local storage.
+LPTAPILINETESTINFO
+WINAPI
+GetLineTestInfo()
+{
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    return lpTestResources ? lpTestResources->lpTapiLineTestInfo : NULL;
+}
+
+
+// GetPhoneTestInfo returns the pointer to the phone test info structure
+// in the test resources stored in thread local storage.
+LPTAPIPHONETESTINFO
+WINAPI
+GetPhoneTestInfo()
+{
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    return lpTestResources ? lpTestResources->lpTapiPhoneTestInfo : NULL;
+}
+
+
+// GetCallbackParams returns the pointer to the structure used
+// to store information used to process solicited and unsolicited
+// TAPI messages.
+LPCALLBACKPARAMS
+WINAPI
+GetCallbackParams()
+{
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    return lpTestResources ? lpTestResources->lpCallbackParams : NULL;
+}
+
+
+// GetLogProc returns the pointer to the logging function set when a
+// process or thread attaches to the test dll.
+LOGPROC
+WINAPI
+GetLogProc()
+{
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    return lpTestResources ? lpTestResources->lpfnLogProc : NULL;
+}
+
+
+// WaitForAllMessages() enters a message loop until all of the messages in
+// the expected message array have been received.  The function returns
+// a BOOL indicating whether all of the messages were successfully received.
+// If an asynchronous reply message indicates an unexpected failure, then
+// this function will return FALSE.
+//
+// Note:  This function will not return until all expected messages have
+//        been received.
+BOOL
+WINAPI
+WaitForAllMessages()
+{
+    MSG msg;
+    LPCALLBACKPARAMS lpCallbackParams = GetCallbackParams();
+
+/*
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"In the WaitForAllMessage");
+
+		ShowExpectedMsgs(lpCallbackParams);
+*/
+    // Reset bool values
+    lpCallbackParams->fCallbackFatalError = FALSE;
+    lpCallbackParams->fMsgTimeout         = FALSE;
+
+    // Start msg timeout timer
+    lpCallbackParams->uTimerID = SetTimer(NULL, 0, 10000, TcoreTimerProc);
+
+    while (! lpCallbackParams->fCallbackFatalError &&
+	     lpCallbackParams->lpExpTapiMsgs != NULL &&
+	   ! lpCallbackParams->fMsgTimeout)
+    {
+	GetMessage (&msg, NULL, 0, 0);
+	DispatchMessage (&msg);
+    }
+
+    KillTimer(NULL, lpCallbackParams->uTimerID);
+
+    // If error didn't occur, then all messages were received
+	if(lpCallbackParams->lpExpTapiMsgs == NULL)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> ERROR:  lpExpTapiMsgs = NULL"
+		);
+    }
+    if (lpCallbackParams->fCallbackFatalError)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> ERROR:  fatal error occured during async wait"
+		);
+    }
+    if (lpCallbackParams->fMsgTimeout)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> ERROR:  Timeout occured waiting for:"
+		);
+
+	ShowExpectedMsgs(lpCallbackParams);
+
+	return FALSE;
+    }
+    else
+    {
+	return TRUE;
+    }
+}
+
+
+// WaitForMessage() enters a message loop until a reply is received that
+// matches the request ID of the message.  This function also verifies
+// that the return value of the reply is successful.  If it is, then TRUE
+// is returned.  Otherwise, false is returned.
+//
+// Note:  This function assumes the TAPI callback function copies the
+//        received message parameters into the lpReceivedMsg field
+//        of the CallbackParams structure.
+//
+BOOL
+WINAPI
+WaitForMessage(LPTAPIMSG lpExpectedMsg)
+{
+    MSG msg;
+    LPCALLBACKPARAMS lpCallbackParams = GetCallbackParams();
+
+    // Reset bool values
+    lpCallbackParams->fCallbackFatalError = FALSE;
+    lpCallbackParams->fMsgTimeout         = FALSE;
+
+
+    // Start msg timeout timer
+    lpCallbackParams->uTimerID = SetTimer(NULL, 0, 10000, TcoreTimerProc);
+
+    while (! lpCallbackParams->fCallbackFatalError &&
+	   IsTapiMsgInQ(lpCallbackParams->lpExpTapiMsgs, lpExpectedMsg) &&
+	   ! lpCallbackParams->fMsgTimeout)
+    {
+	     GetMessage (&msg, NULL, 0, 0);
+	     DispatchMessage (&msg);
+    }
+
+    KillTimer(NULL, lpCallbackParams->uTimerID);
+
+    // If error didn't occur, then all messages were received
+    if (lpCallbackParams->fCallbackFatalError)
+    {
+	     TapiLogDetail(
+		    DBUG_SHOW_FAILURE,
+		    "> ERROR:  fatal error occured during async wait"
+		    );
+
+        //
+        // FIXFIX:
+        // pgopi added return. This if construct did n't have a return
+        // statement .
+        //
+
+        return FALSE;
+    }
+    else if (lpCallbackParams->fMsgTimeout)
+    {
+	     TapiLogDetail(
+		               DBUG_SHOW_FAILURE,
+		               "> ERROR:  Timeout occured waiting for:"
+		               );
+
+	     ShowTapiMsgInfo(lpExpectedMsg);
+
+	     return FALSE;
+    }
+    else
+    {
+	     return TRUE;
+    }
+}
+
+
+VOID
+WINAPI
+ShowTapiMsgInfo(
+	LPTAPIMSG lpMsg
+	)
+{
+    char szBuf[256];
+
+    if (lpMsg)
+    {
+	if (lpMsg >= 0 && lpMsg->dwMsg <= LAST_TAPIMSG)
+	{
+	    wsprintf(
+		    szBuf,
+		    "\tdwMsg=%s hDevCall=x%lx dwCbInst=x%lx\r\n" \
+		    "\tdwParam1=x%lx dwParam2=x%lx dwParam3=x%lx",
+		    aszTapiMessages[lpMsg->dwMsg],
+		    lpMsg->hDevCall,
+		    lpMsg->dwCallbackInstance,
+		    lpMsg->dwParam1,
+		    lpMsg->dwParam2,
+		    lpMsg->dwParam3
+		    );
+	}
+	else
+	{
+	    wsprintf(
+		    szBuf,
+		    "\tdwMsg=x%lx hDevCall=x%lx dwCbInst=x%lx\r\n" \
+		    "\tdwParam1=x%lx dwParam2=x%lx dwParam3=x%lx",
+		    aszTapiMessages[lpMsg->dwMsg],
+		    lpMsg->hDevCall,
+		    lpMsg->dwCallbackInstance,
+		    lpMsg->dwParam1,
+		    lpMsg->dwParam2,
+		    lpMsg->dwParam3
+		    );
+	}
+	TapiLogDetail(DBUG_SHOW_DETAIL, szBuf);
+    }
+}
+
+
+BOOL
+WINAPI
+GetVarField(
+    LPVOID lpVarDataStructure,
+    LPVOID lpVarField,
+    DWORD dwVarFieldSize,
+    DWORD dwVarFieldOffset
+    )
+{
+    if (lpVarDataStructure && lpVarField)
+    {
+	CopyMemory(
+		lpVarField,
+		(LPVOID) ((LPBYTE) lpVarDataStructure + dwVarFieldOffset),
+		dwVarFieldSize
+		);
+
+	return TRUE;
+    }
+    else
+    {
+	return FALSE;
+    }
+}
+
+
+BOOL
+WINAPI
+DoTapiLineFuncs(
+    LPTAPILINETESTINFO lpTapiLineTestInfo,
+    DWORD dwFunc
+    )
+{
+    CHAR szBuf[128];
+    BOOL fSuccess = FALSE;
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "DoTapiLineFuncs:  enter"
+	    );
+
+    if (lpTapiLineTestInfo)
+    {
+	fSuccess = (
+	    (!(dwFunc & LINITIALIZE) ||
+	    DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LINITIALIZEEX) ||
+	    DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LNEGOTIATEAPIVERSION) ||
+	    DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LGETDEVCAPS) ||
+	    DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LOPEN) ||
+	    DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LMAKECALL) ||
+	    DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE)) &&
+
+	    (!(dwFunc & LDROP) ||
+	    DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE)) &&
+
+	    (!(dwFunc & LDEALLOCATECALL) ||
+	    DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LCLOSE) ||
+	    DoLineClose(lpTapiLineTestInfo, TAPISUCCESS)) &&
+
+	    (!(dwFunc & LSHUTDOWN) ||
+	    DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+	    );
+    }
+
+    if (! fSuccess)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_FAILURE,
+		"> DoTapiLineFuncs:  Error occured -- aborting sequence"
+		);
+    }
+
+    TapiLogDetail(
+	    DBUG_SHOW_ENTER_EXIT,
+	    "DoTapiLineFuncs:  exit"
+	    );
+
+    return fSuccess;
+}
+
+
+// GetLastTapiResult() copies the expected, actual, and API Index
+// into the structure pointed to by lpTapiResult.  This function
+// assumes that lpTapiResult is a null pointer
+VOID
+WINAPI
+GetLastTapiResult(
+	LPTAPIRESULT lpTapiResult
+	)
+{
+    LPTAPIRESULT lpStoredResult;
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    // Verify pointers aren't null before using them
+    if (lpTestResources &&
+	    (lpStoredResult = lpTestResources->lpLastTapiResult) &&
+	    lpTapiResult)
+    {
+	lpTapiResult->eTapiFunc = lpStoredResult->eTapiFunc;
+	lpTapiResult->lExpected = lpStoredResult->lExpected;
+	lpTapiResult->lActual   = lpStoredResult->lActual;
+    }
+}
+
+
+VOID
+SetLastTapiResult(
+	FUNCINDEX eTapiFunc,
+	LONG lActual,
+	LONG lExpected
+	)
+{
+    LPTAPIRESULT lpResult;
+    LPTESTRESOURCES lpTestResources = (LPTESTRESOURCES)
+	    TlsGetValue(gdwTlsIndex);
+
+    lpResult = lpTestResources->lpLastTapiResult;
+
+    lpResult->eTapiFunc = eTapiFunc;
+    lpResult->lExpected  = lExpected;
+    lpResult->lActual    = lActual;
+}
+
+
+// FindReceivedMsgs() will return the last received TAPI message
+// that matches the params in lpMatch if fFindMostRecent is false.
+// If fFindMostRecent is true, this function will return all received
+// messages in an allocated linked list stored in lppTapiMsg.
+// This function returns -1 if an allocation fails or an invalid
+// parameter is passed to it (e.g. lppTapiMsg or lpMatch is null).
+// Otherwise, the number of matches is returned.
+LONG
+WINAPI
+FindReceivedMsgs(
+	LPTAPIMSG *lppTapiMsg,
+	LPTAPIMSG lpMatch,
+	DWORD fFindMostRecent
+    )
+{
+    LONG lNumMatches = 0;
+    LPTAPIMSG lpMsg = GetCallbackParams() -> lpRecTapiMsgs;
+    LPTAPIMSG lpTail = NULL;
+    LPTAPIMSG lpNewMsg;
+    DWORD dwFlags;
+    BOOL fMsgsMatch;
+
+    if (lppTapiMsg && lpMatch)
+    {
+	*lppTapiMsg = NULL;
+	dwFlags = lpMatch->dwFlags;
+	
+	while (lpMsg != NULL)
+	{
+	    fMsgsMatch = ( (!(dwFlags & TAPIMSG_HDEVCALL) ||
+		(lpMatch->hDevCall == lpMsg->hDevCall)) &&
+		(!(dwFlags & TAPIMSG_DWCALLBACKINST) ||
+		(lpMatch->dwCallbackInstance ==
+		    lpMsg->dwCallbackInstance)) &&
+		(!(dwFlags & TAPIMSG_DWMSG) ||
+		(lpMatch->dwMsg == lpMsg->dwMsg)) &&
+		(!(dwFlags & TAPIMSG_DWPARAM1) ||
+		(lpMatch->dwParam1 == lpMsg->dwParam1)) &&
+		(!(dwFlags & TAPIMSG_DWPARAM2) ||
+		(lpMatch->dwParam2 == lpMsg->dwParam2)) &&
+		(!(dwFlags & TAPIMSG_DWPARAM3) ||
+		(lpMatch->dwParam3 == lpMsg->dwParam3)) );
+
+	    if (fMsgsMatch)
+	    {
+		if (! fFindMostRecent || *lppTapiMsg == NULL)
+		{
+		    // Allocate a new node
+		    if ((lpNewMsg = (LPTAPIMSG) ITAlloc(sizeof(*lpNewMsg))) ==
+			 NULL)
+		    {
+			FreeTapiMsgList(lppTapiMsg);
+			return -1;
+		    }
+		}
+		
+		lNumMatches++;
+	
+		CopyTapiMsgs(lpMsg, lpNewMsg);
+		lpNewMsg->lpNext = NULL;
+
+		if (!fFindMostRecent)
+		{
+		    if (*lppTapiMsg == NULL)
+		    {
+			*lppTapiMsg = lpNewMsg;
+		    }
+		    else
+		    {
+			// Set the old tail to point to the added message
+			lpTail->lpNext = lpNewMsg;
+		    }
+
+		    lpTail = lpNewMsg;
+		}
+		else
+		{
+		    *lppTapiMsg = lpNewMsg;
+		}
+	    }
+	    lpMsg = lpMsg->lpNext;
+	}
+
+	return fFindMostRecent == TRUE ? (lNumMatches > 0 ? 1 : 0) :
+	    lNumMatches;
+    }
+    else
+    {
+	return -1;
+    }
+}
+					
+
+
diff --git a/private/tapi/qa/tcore/tcore.def b/private/tapi/qa/tcore/tcore.def
new file mode 100644
index 000000000..8053db3d4
--- /dev/null
+++ b/private/tapi/qa/tcore/tcore.def
@@ -0,0 +1,182 @@
+LIBRARY         tcore
+
+DATA            READ WRITE
+
+EXPORTS
+	TcoreSuiteInit
+	TcoreSuiteShutdown
+	TcoreSuiteAbout
+	TcoreSuiteConfig
+
+	TapiCallback
+	OutputTAPIDebugInfo
+	WaitForAllMessages
+	WaitForMessage
+	TapiLineTestInit
+	TapiPhoneTestInit
+	AddMessageByStruct
+	AddMessage
+	CopyTapiMsgParams
+	CopyTapiMsgs
+	CompareTapiMsgs
+	RemoveReceivedMsgs
+	CallbackParamsGetDevCallHandle
+	DoExtensionIDsMatch
+	ShowTapiMsgInfo
+	ShowTapiMsgList
+	FindReceivedMsgs
+	FreeTapiMsgList
+	ShowExpectedMsgs
+	GetVarField
+	DoTapiLineFuncs
+	GetLineTestInfo
+	GetPhoneTestInfo
+	GetLogProc
+	GetCallbackParams
+	GetLastTapiResult
+	AllocFromTestHeap
+	FreeTestHeap
+	ITFree
+	ITAlloc
+	ITSize
+
+	DoLineAccept
+	DoLineAddProvider
+	DoLineAddToConference
+	DoLineAnswer
+	DoLineBlindTransfer
+	DoLineClose
+	DoLineCompleteCall
+	DoLineCompleteTransfer
+	DoLineConfigDialog
+	DoLineConfigDialogEdit
+	DoLineConfigProvider
+	DoLineDeallocateCall
+	DoLineDevSpecific
+	DoLineDevSpecificFeature
+	DoLineDial
+	DoLineDrop
+	DoLineForward
+	DoLineGatherDigits
+	DoLineGenerateDigits
+	DoLineGenerateTone
+	DoLineGetAddressCaps
+	DoLineGetAddressID
+	DoLineGetAddressStatus
+	DoLineGetAppPriority
+	DoLineGetCallInfo
+	DoLineGetCallStatus
+	DoLineGetConfRelatedCalls
+	DoLineGetCountry
+	DoLineGetDevCaps
+	DoLineGetDevConfig
+	DoLineGetIcon
+	DoLineGetID
+	DoLineGetLineDevStatus
+	DoLineGetNewCalls
+	DoLineGetNumRings
+	DoLineGetProviderList
+	DoLineGetRequest
+	DoLineGetStatusMessages
+	DoLineGetTranslateCaps
+	DoLineHandoff
+	DoLineHold
+	DoLineInitialize
+	DoLineMakeCall
+	DoLineMonitorDigits
+	DoLineMonitorMedia
+	DoLineMonitorTones
+	DoLineNegotiateAPIVersion
+	DoLineNegotiateExtVersion
+	DoLineOpen
+	DoLinePark
+	DoLinePickup
+	DoLinePrepareAddToConference
+	DoLineRedirect
+	DoLineRegisterRequestRecipient
+	DoLineReleaseUserUserInfo
+	DoLineRemoveFromConference
+	DoLineRemoveProvider
+	DoLineSecureCall
+	DoLineSendUserUserInfo
+	DoLineSetAppPriority
+	DoLineSetAppSpecific
+	DoLineSetCallParams
+	DoLineSetCallPrivilege
+	DoLineSetCurrentLocation
+	DoLineSetDevConfig
+	DoLineSetMediaControl
+	DoLineSetMediaMode
+	DoLineSetNumRings
+	DoLineSetStatusMessages
+	DoLineSetTerminal
+	DoLineSetTollList
+	DoLineSetupConference
+	DoLineSetupTransfer
+	DoLineShutdown
+	DoLineSwapHold
+	DoLineTranslateAddress
+	DoLineTranslateDialog
+	DoLineUncompleteCall
+	DoLineUnhold
+	DoLineUnpark
+
+	DoPhoneClose
+	DoPhoneConfigDialog
+	DoPhoneDevSpecific
+	DoPhoneGetButtonInfo
+	DoPhoneGetData
+	DoPhoneGetDevCaps
+	DoPhoneGetDisplay
+	DoPhoneGetGain
+	DoPhoneGetHookSwitch
+	DoPhoneGetIcon
+	DoPhoneGetID
+	DoPhoneGetLamp
+	DoPhoneGetRing
+	DoPhoneGetStatus
+	DoPhoneGetStatusMessages
+	DoPhoneGetVolume
+	DoPhoneInitialize
+	DoPhoneNegotiateAPIVersion
+	DoPhoneNegotiateExtVersion
+	DoPhoneOpen
+	DoPhoneSetButtonInfo
+	DoPhoneSetData
+	DoPhoneSetDisplay
+	DoPhoneSetGain
+	DoPhoneSetHookSwitch
+	DoPhoneSetLamp
+	DoPhoneSetRing
+	DoPhoneSetStatusMessages
+	DoPhoneSetVolume
+	DoPhoneShutdown
+
+	DoLineAgentSpecific
+	DoLineGetAgentCaps
+	DoLineGetAgentActivityList
+	DoLineGetAgentGroupList
+	DoLineGetAgentStatus
+	DoLineProxyMessage
+	DoLineProxyResponse
+	DoLineSetAgentActivity
+	DoLineSetAgentGroup
+	DoLineSetAgentState
+	DoLineSetCallData
+	DoLineSetCallQualityOfService
+	DoLineSetCallTreatment
+	DoLineSetLineDevStatus
+
+	DoTapiGetLocationInfo
+	DoTapiRequestDrop
+	DoTapiRequestMakeCall
+	DoTapiRequestMediaCall
+
+	DoLineInitializeEx
+        DoLineGetMessage
+	DoPhoneInitializeEx
+        DoPhoneGetMessage
+
+
+	
+	
diff --git a/private/tapi/qa/tcore/tcore.h b/private/tapi/qa/tcore/tcore.h
new file mode 100644
index 000000000..71723dd24
--- /dev/null
+++ b/private/tapi/qa/tcore/tcore.h
@@ -0,0 +1,1297 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tcore.h
+
+Abstract:
+
+    This module contains the prototypes and data type definitions
+    used by the core dll that wraps around TAPI.
+
+Author:
+
+    Oliver Wallace (OliverW)    13-July-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef TAPICORE_H
+#define TAPICORE_H
+
+#include "windows.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "vars.h"
+#include "devspec.h"
+
+// Macro definitions
+#define TapiLogDetail (* ((LOGPROC) GetLogProc()))
+
+
+#define MultipleBitsSetInDWORD(dw) (((DWORD) dw) & ((DWORD) dw - 1))
+
+#define TAPI_LINEMEDIAMODE_ALL  (LINEMEDIAMODE_UNKNOWN           | \
+				 LINEMEDIAMODE_INTERACTIVEVOICE  | \
+				 LINEMEDIAMODE_AUTOMATEDVOICE    | \
+				 LINEMEDIAMODE_DATAMODEM         | \
+				 LINEMEDIAMODE_G3FAX             | \
+				 LINEMEDIAMODE_TDD               | \
+				 LINEMEDIAMODE_G4FAX             | \
+				 LINEMEDIAMODE_DIGITALDATA       | \
+				 LINEMEDIAMODE_TELETEX           | \
+				 LINEMEDIAMODE_VIDEOTEX          | \
+				 LINEMEDIAMODE_TELEX             | \
+				 LINEMEDIAMODE_MIXED             | \
+				 LINEMEDIAMODE_ADSI              | \
+				 LINEMEDIAMODE_VOICEVIEW  )
+
+
+typedef enum
+{
+    lAccept,
+#if TAPI_1_1
+    lAddProvider,
+#endif
+    lAddToConference,
+    lAnswer,
+    lBlindTransfer,
+    lClose,
+    lCompleteCall,
+    lCompleteTransfer,
+    lConfigDialog,
+#if TAPI_1_1
+    lConfigDialogEdit,
+    lConfigProvider,
+#endif
+    lDeallocateCall,
+    lDevSpecific,
+    lDevSpecificFeature,
+    lDial,
+    lDrop,
+    lForward,
+    lGatherDigits,
+    lGenerateDigits,
+    lGenerateTone,
+    lGetAddressCaps,
+    lGetAddressID,
+    lGetAddressStatus,
+#if TAPI_1_1
+    lGetAppPriority,
+#endif
+    lGetCallInfo,
+    lGetCallStatus,
+    lGetConfRelatedCalls,
+#if TAPI_1_1
+    lGetCountry,
+#endif
+    lGetDevCaps,
+    lGetDevConfig,
+    lGetIcon,
+    lGetID,
+    lGetLineDevStatus,
+    lGetNewCalls,
+    lGetNumRings,
+#if TAPI_1_1
+    lGetProviderList,
+#endif
+    lGetRequest,
+    lGetStatusMessages,
+    lGetTranslateCaps,
+    lHandoff,
+    lHold,
+    lInitialize,
+    lMakeCall,
+    lMonitorDigits,
+    lMonitorMedia,
+    lMonitorTones,
+    lNegotiateAPIVersion,
+    lNegotiateExtVersion,
+    lOpen,
+    lPark,
+    lPickup,
+    lPrepareAddToConference,
+    lRedirect,
+    lRegisterRequestRecipient,
+#if TAPI_1_1
+    lReleaseUserUserInfo,
+#endif
+    lRemoveFromConference,
+#if TAPI_1_1
+    lRemoveProvider,
+#endif
+    lSecureCall,
+    lSendUserUserInfo,
+#if TAPI_1_1
+    lSetAppPriority,
+#endif
+    lSetAppSpecific,
+    lSetCallParams,
+    lSetCallPrivilege,
+    lSetCurrentLocation,
+    lSetDevConfig,
+    lSetMediaControl,
+    lSetMediaMode,
+    lSetNumRings,
+    lSetStatusMessages,
+    lSetTerminal,
+    lSetTollList,
+    lSetupConference,
+    lSetupTransfer,
+    lShutdown,
+    lSwapHold,
+    lTranslateAddress,
+#if TAPI_1_1
+    lTranslateDialog,
+#endif
+    lUncompleteCall,
+    lUnhold,
+    lUnpark,
+
+    pClose,
+    pConfigDialog,
+    pDevSpecific,
+    pGetButtonInfo,
+    pGetData,
+    pGetDevCaps,
+    pGetDisplay,
+    pGetGain,
+    pGetHookSwitch,
+    pGetIcon,
+    pGetID,
+    pGetLamp,
+    pGetRing,
+    pGetStatus,
+    pGetStatusMessages,
+    pGetVolume,
+    pInitialize,
+    pOpen,
+    pNegotiateAPIVersion,
+    pNegotiateExtVersion,
+    pSetButtonInfo,
+    pSetData,
+    pSetDisplay,
+    pSetGain,
+    pSetHookSwitch,
+    pSetLamp,
+    pSetRing,
+    pSetStatusMessages,
+    pSetVolume,
+    pShutdown,
+
+    tGetLocationInfo,
+    tRequestDrop,
+    tRequestMakeCall,
+    tRequestMediaCall,
+
+#if TAPI_2_0
+    lAgentSpecific,
+    lGetAgentCaps,
+    lGetAgentActivityList,
+    lGetAgentGroupList,
+    lGetAgentStatus,
+    lProxyMessage,
+    lProxyResponse,
+    lSetAgentActivity,
+    lSetAgentGroup,
+    lSetAgentState,
+    lSetCallData,
+    lSetCallQualityOfService,
+    lSetCallTreatment,
+    lSetLineDevStatus,
+    lInitializeEx,
+    lGetMessage,
+    pInitializeEx,
+    pGetMessage,
+#endif
+
+} FUNCINDEX;
+
+
+// Flags used for calling sequence of APIs in DoTapiLineFuncs
+// and DoTapiPhoneFuncs
+#define LINITIALIZE           0x00000001
+#define LINITIALIZEEX			0X00000002
+#define LNEGOTIATEAPIVERSION  0x00000004
+#define LGETDEVCAPS           0x00000008
+#define LOPEN                 0x00000010
+#define LMAKECALL             0x00000020
+#define LDROP                 0x00000040
+#define LDEALLOCATECALL       0x00000080
+#define LCLOSE                0x00000100
+#define LSHUTDOWN             0x00000200
+
+
+
+
+
+#if TAPI_2_0
+#define LAST_LINEERR                   LINEERR_DIALVOICEDETECT
+#else
+#define LAST_LINEERR                   LINEERR_NOMULTIPLEINSTANCE
+#endif
+
+#define LAST_PHONEERR                  PHONEERR_REINIT
+#define LAST_TAPIERR                   TAPIERR_INVALPOINTER 
+
+
+#define TAPI_VERSION1_0                0x10003
+#define TAPI_VERSION1_4                0x10004
+#define TAPI_VERSION2_0                0x20000
+
+
+#if TAPI_2_0
+#define LAST_TAPIMSG                   26L
+#else 
+#define LAST_TAPIMSG                   20L
+#endif
+
+
+#define TAPISUCCESS                    0
+
+
+// Defines for Debug levels
+#define DBUG_SHOW_FAILURE              0
+#define DBUG_SHOW_PASS                 1
+#define DBUG_SHOW_SUCCESS              3
+#define DBUG_SHOW_DETAIL               4
+#define DBUG_SHOW_ENTER_EXIT           6
+#define DBUG_SHOW_PARAMS               9
+
+
+
+// values for masking all messages
+#define LINEDEVSTATE_NONE              0x00000000
+#define LINEADDRESSSTATE_NONE          0x00000000
+
+// API and extension version values
+#define LOW_APIVERSION                 0x10003
+#define HIGH_APIVERSION                0x20000
+#define TOOLOW_APIVERSION              0x10002
+#define TOOHIGH_APIVERSION             0x20001
+#define WAYTOOHIGH_APIVERSION          0xFFFFFFFF
+
+// these values aren't really good and bad yet
+// support needs to be in SP for strict extension version checking
+#define GOOD_EXTVERSION                0x10000000
+#define BAD_EXTVERSION                 0xFFFFFFFF
+
+// dw constants
+#define DWMINUSONE                     0xFFFFFFFF
+#define DWMAXPOSVALUE                  0x7FFFFFFF
+
+#define ONE_K                          1024
+#define TWO_K                          2048
+#define THREE_K                        3072
+
+
+// Bit flags to determine which msg params should be checked
+#define TAPIMSG_HDEVCALL        0x00000001
+#define TAPIMSG_DWMSG           0x00000002
+#define TAPIMSG_DWCALLBACKINST  0x00000004
+#define TAPIMSG_DWPARAM1        0x00000008
+#define TAPIMSG_DWPARAM2        0x00000010
+#define TAPIMSG_DWPARAM3        0x00000020
+#define TAPIMSG_ALL             0x0000003F
+
+
+// Structure used to store and retrieve the last TAPI error code, which
+// TAPI function was called, and the expected error code.
+typedef struct TAPIRESULTTAG
+{
+    LONG lExpected;
+    LONG lActual;
+    FUNCINDEX eTapiFunc;
+} TAPIRESULT, FAR* LPTAPIRESULT;
+
+
+// Heap structure for quicker testing
+typedef struct TESTHEAPINFOTAG
+{
+    LPVOID lpHeap;
+    DWORD dwFreeOffset;
+} TESTHEAPINFO, FAR* LPTESTHEAPINFO;
+
+
+#define TESTHEAPSIZE 16384
+
+
+// Data structure used to hold test values for TAPI line interface tests
+typedef struct TAPILINETESTINFOTAG
+{
+    // Fields directly used as parameters to API calls during testing
+    BOOL                fCompletionModeSet;
+
+    LPHLINEAPP          lphLineApp;
+    LPHLINE             lphLine;
+    HINSTANCE           hInstance;
+    LINECALLBACK        lpfnCallback;
+    LPDWORD             lpdwNumDevs;
+    HANDLE              hwndOwner;
+
+    LPHCALL             lphCall;
+    LPHCALL             lphConfCall;
+    LPHCALL             lphConsultCall;
+    DWORD               dwCountryCode;
+    DWORD               dwCountryID;
+    DWORD               dwLocation;
+    DWORD               dwTollListOption;
+    DWORD               dwTerminalModes;
+    DWORD               dwTerminalID;
+    DWORD               dwTranslateOptions;
+    DWORD               dwCard;
+    LPDWORD             lpdwLineStates;
+    LPDWORD             lpdwAddressStates;
+    LPDWORD             lpdwCompletionID;
+    LPVOID              lpParams;
+
+
+    DWORD               dwDeviceID;
+    LPDWORD             lpdwAddressID;
+    DWORD               dwAddressID;
+    DWORD               dwAddressMode;
+    DWORD               dwAPILowVersion;
+    DWORD               dwAPIHighVersion;
+    DWORD               dwExtLowVersion;
+    DWORD               dwExtHighVersion;
+    LPDWORD             lpdwAPIVersion;
+    LPDWORD             lpdwExtVersion;
+    LPLINEEXTENSIONID   lpExtID;
+    LINEEXTENSIONID     ExtIDZero;
+    LPVARSTRING         lpExtensionName;
+#ifdef WUNICODE
+	LPWSTR		        lpwszMediaExtName;
+#else
+	LPSTR               lpszMediaExtName;
+#endif
+    DWORD               dwCallbackInstance;
+    DWORD               dwMediaModes;
+    DWORD               dwMediaMode;
+    DWORD               dwRequestMode;
+    DWORD               dwPriority;
+    DWORD               dwPrivileges;
+    DWORD               dwCallPrivilege;
+    DWORD               dwSelect;
+    DWORD               dwSize;
+    DWORD               dwBearerMode;
+    DWORD               dwMinRate;
+    DWORD               dwMaxRate;
+    DWORD               dwLineStates;
+    DWORD               dwAddressStates;
+    DWORD               dwCompletionID;
+    DWORD               dwCompletionMode;
+    DWORD               dwTransferMode;
+    DWORD               dwMessageID;
+    LPDWORD             lpdwNumRings;
+    DWORD               dwPermanentProviderID;
+    LPDWORD             lpdwPermanentProviderID;
+    DWORD               dwAppSpecific;
+    DWORD               dwFeature;
+    DWORD               bAllAddresses;
+    DWORD               dwNumParties;
+    DWORD               dwNumRingsNoAnswer;
+    LPDWORD             lpdwPriority;
+
+    DWORD               dwParkMode;
+    LPVARSTRING         lpNonDirAddress;
+
+#ifdef WUNICODE
+	LPWSTR		        lpwszDirAddress;
+	LPWSTR		        lpwszGroupID;
+	LPWSTR		        lpwsDigits;
+	LPWSTR		        lpwszTerminationDigits;
+	LPWSTR		        lpwszDigits;
+#else
+    LPSTR               lpszDirAddress;
+    LPSTR               lpszGroupID;
+    LPSTR               lpsDigits;
+    LPSTR               lpszTerminationDigits;
+    LPSTR               lpszDigits;
+#endif
+
+    DWORD               dwNumDigits;
+
+    DWORD               dwFirstDigitTimeout;
+    DWORD               dwInterDigitTimeout;
+    DWORD               dwDigitModes;
+    DWORD               dwDigitMode;
+
+    DWORD               dwDuration;
+    DWORD               dwToneMode;
+    DWORD               dwNumTones;
+    DWORD               dwNumEntries;
+    DWORD               dwDigitNumEntries;
+    DWORD               dwMediaNumEntries;
+    DWORD               dwToneNumEntries;
+    DWORD               dwCallStateNumEntries;
+    LPLINEMEDIACONTROLDIGIT lpMCDigitList;
+    LPLINEMEDIACONTROLMEDIA lpMCMediaList;
+    LPLINEMEDIACONTROLTONE lpMCToneList;
+    LPLINEMEDIACONTROLCALLSTATE lpMCCallStateList;
+    LPLINEMONITORTONE   lpToneList;
+    LPLINEGENERATETONE  lpTones;
+
+    DWORD               dwRegistrationInstance;
+    DWORD               bEnable;
+
+    LPLINEDEVCAPS       lpLineDevCaps;
+    LPLINEDEVSTATUS     lpLineDevStatus;
+    LPLINEADDRESSCAPS   lpLineAddressCaps;
+    LPLINEADDRESSSTATUS lpLineAddressStatus;
+    LPLINECALLPARAMS    lpCallParams;
+    LPLINECALLSTATUS    lpCallStatus;
+    LPLINECALLINFO      lpCallInfo;
+    LPLINECALLLIST      lpCallList;
+    LPLINECOUNTRYLIST   lpLineCountryList;
+    LPLINEFORWARDLIST   lpForwardList;
+    LPHICON             lphIcon;
+    LPLINEPROVIDERLIST  lpProviderList;
+    LPLINETRANSLATECAPS lpTranslateCaps;
+    LPLINETRANSLATEOUTPUT lpTranslateOutput;
+    LPLINEDIALPARAMS    lpDialParams;
+
+    LPVARSTRING         lpDeviceConfig;
+    LPVOID              lpDeviceConfigIn;
+    LPVARSTRING         lpDeviceConfigOut;
+    VARSTRING           DeviceID;
+    LPVARSTRING         lpDeviceID;
+
+#ifdef WUNICODE
+	LPWSTR		            lpwsztapiAppName;
+	LPWSTR		            lpwszAppFilename;
+	LPWSTR		            lpwszFileName;
+	LPWSTR		            lpwsAddress;
+	LPWSTR		            lpwszAddressIn;
+	LPWSTR		            lpwszDeviceClass;
+	LPWSTR		            lpwszDestAddress;
+	LPWSTR		            lpwszProviderFilename;
+#else
+    LPSTR               lpsztapiAppName;
+    LPSTR               lpszAppFilename;
+    LPSTR               lpszFileName;
+    LPSTR               lpsAddress;
+    LPSTR               lpszAddressIn;
+    LPSTR               lpszDeviceClass;
+    LPSTR               lpszDestAddress;
+    LPSTR               lpszProviderFilename;
+#endif
+
+    LPSTR               lpszAppName;
+    LPSTR               lpsUserUserInfo;
+    LPVOID              lpRequestBuffer;
+
+    // Fields used to back up data during testing
+    LINECALLBACK        lpfnCallback_Orig;
+    HLINEAPP            hLineApp_Orig;
+    HINSTANCE           hInstance_Orig;
+    HLINE               hLine_Orig;
+    HCALL               hCall_Orig;
+    DWORD               dwCountryCode_Orig;
+    DWORD               dwDeviceID_Orig;
+#ifdef WUNICODE
+	LPWSTR		        lpwszDeviceClass_Orig;
+#else
+    LPSTR               lpszDeviceClass_Orig;
+#endif
+    DWORD               dwAPIVersion_Orig;
+    DWORD               dwExtVersion_Orig;
+    DWORD               dwMediaModes_Orig;
+    DWORD               dwPrivileges_Orig;
+
+    DWORD               dwNumDevs_Orig;
+    DWORD               dwNumRings_Orig;
+    DWORD               dwAddressID_Orig;
+    DWORD               dwSelect_Orig;
+    DWORD               dwSize_Orig;
+    DWORD               dwLineStates_Orig;
+    DWORD               dwAddressStates_Orig;
+    VARSTRING           DeviceID_Orig;
+
+    // Fields used to store information used during the tests
+//#ifdef WUNICODE
+//    WCHAR               wszAppName[40];
+//#else
+    CHAR                szAppName[40];
+// #endif
+
+    CHAR                szTestFunc[40];
+    CHAR                szTestStepDesc[80];
+
+    HLINEAPP            hLineApp1;
+    HLINEAPP            hLineApp2;
+    HLINEAPP            hLineApp3;
+    HLINE               hLine1;
+    HLINE               hLine2;
+    HLINE               hLine3;
+    HCALL               hCall1;
+    HCALL               hCall2;
+    HCALL               hCall3;
+    HCALL               hConfCall1;
+    HCALL               hConsultCall1;
+    HCALL               hActiveCall;
+    HCALL               hHeldCall;
+    HICON               hIcon;
+
+    DWORD               dwNumDevs;
+    DWORD               dwNumRings;
+    DWORD               dwAPIVersion;
+    DWORD               dwExtVersion;
+
+    LINEDEVCAPS         LineDevCaps;
+    LINEDEVSTATUS       LineDevStatus;
+    LINEADDRESSCAPS     LineAddressCaps;
+    LINEADDRESSSTATUS   LineAddressStatus;
+    LINECALLPARAMS      CallParams;
+    LINECALLSTATUS      CallStatus;
+    LINEEXTENSIONID     ExtID;
+
+    
+#ifdef WUNICODE
+	LPWSTR	            lpwszCountryCode;
+	LPWSTR	            lpwszCityCode;
+	LPWSTR	            lpwszCalledParty;
+	LPWSTR	            lpwszComment;
+   LPWSTR                   lpwszDeviceID;
+#else
+	LPSTR               lpszCountryCode;
+    LPSTR               lpszCityCode;   
+    LPSTR               lpszCalledParty;
+    LPSTR               lpszComment;
+    LPSTR               lpszDeviceID;
+#endif
+
+    HWND                hwnd;
+    WPARAM              wRequestID;
+    DWORD               dwSecure;
+     
+#if TAPI_2_0
+
+    DWORD                       dwAgentExtensionIDIndex;
+    DWORD                       dwAppAPIVersion;
+    LPLINEAGENTCAPS             lpAgentCaps;
+    LINEAGENTCAPS               AgentCaps;
+    LPLINEAGENTACTIVITYLIST     lpAgentActivityList;
+    LINEAGENTACTIVITYLIST       AgentActivityList;
+    LPLINEAGENTGROUPLIST        lpAgentGroupList;
+    LINEAGENTGROUPLIST          AgentGroupList;
+    LPLINEAGENTSTATUS           lpAgentStatus;
+    LINEAGENTSTATUS             AgentStatus;
+    DWORD                       dwMsg;
+    DWORD                       dwParam1;
+    DWORD                       dwParam2;
+    DWORD                       dwParam3;
+    LPLINEPROXYREQUEST          lpProxyRequest;
+    LINEPROXYREQUEST            ProxyRequest;
+    DWORD                       dwResult;
+    DWORD                       dwActivityID;
+    DWORD                       dwAgentState;
+    DWORD                       dwNextAgentState;
+    LPVOID                      lpCallData;
+    LPVOID                      lpSendingFlowspec;
+    DWORD                       dwSendingFlowspecSize;
+    LPVOID                      lpReceivingFlowspec;
+    DWORD                       dwReceivingFlowspecSize;
+    DWORD                       dwTreatment;
+    DWORD                       dwStatusToChange;
+    DWORD                       fStatus;
+
+    
+#ifdef WUNICODE
+	LPWSTR						lpwszFriendlyAppName;
+#else
+	LPSTR                       lpszFriendlyAppName;
+#endif
+    LPLINEINITIALIZEEXPARAMS    lpLineInitializeExParams;
+    LPLINEMESSAGE               lpMessage;
+    DWORD                       dwTimeout;
+#endif                          
+	
+																
+} TAPILINETESTINFO, FAR* LPTAPILINETESTINFO;
+
+
+typedef struct TAPIPHONETESTINFOTAG
+{
+    BOOL                fCompletionModeSet;
+    LPHPHONEAPP         lphPhoneApp;
+    LPHPHONE            lphPhone;
+    HINSTANCE           hInstance;
+    LPDWORD             lpdwAPIVersion;
+    LPDWORD             lpdwExtVersion;
+    LPDWORD             lpdwGain;
+    LPDWORD             lpdwHookSwitchDevs;
+    LPDWORD             lpdwLampMode;
+    LPDWORD             lpdwRingMode;
+    LPDWORD             lpdwVolume;
+    LPDWORD             lpdwPhoneStates;
+    LPDWORD             lpdwButtonModes;
+    LPDWORD             lpdwButtonStates;
+    LPDWORD             lpdwNumDevs;
+
+    LPVOID              lpParams;
+    LPPHONEBUTTONINFO   lpButtonInfo;
+    LPVOID              lpData;
+    LPPHONECAPS         lpPhoneCaps;
+    LPVARSTRING         lpDisplay;
+    LPHICON             lphIcon;
+    LPVARSTRING         lpDeviceID;
+
+#ifdef WUNICODE
+    LPWSTR              lpwszDeviceClass;
+#else
+	LPSTR               lpszDeviceClass;
+#endif
+    LPPHONESTATUS       lpPhoneStatus;
+    PHONECALLBACK       lpfnCallback;
+/*
+#ifdef WUNICODE
+    LPWSTR              lpwszAppName;
+#else
+*/
+	LPSTR               lpszAppName;
+//#endif
+    LPPHONEEXTENSIONID  lpExtensionID;
+	LPSTR               lpsDisplay;
+
+    DWORD               dwDeviceID;
+    DWORD               dwSize;
+    DWORD               dwButtonLampID;
+    DWORD               dwDataID;
+    DWORD               dwAPILowVersion;
+    DWORD               dwAPIHighVersion;
+    DWORD               dwExtLowVersion;
+    DWORD               dwExtHighVersion;
+    DWORD               dwCallbackInstance;
+    DWORD               dwPrivilege;
+    DWORD               dwRow;
+    DWORD               dwColumn;
+
+    HPHONEAPP           hPhoneApp1;
+    HPHONEAPP           hPhoneApp2;
+    HPHONEAPP           hPhoneApp3;
+    HPHONE              hPhone1;
+    HPHONE              hPhone2;
+    HPHONE              hPhone3;
+    DWORD               dwAPIVersion;
+    DWORD               dwExtVersion;
+    DWORD               dwGain;
+    DWORD               dwHookSwitchDev;
+    DWORD               dwHookSwitchDevs;
+    DWORD               dwHookSwitchMode;
+    DWORD               dwLampMode;
+    DWORD               dwRingMode;
+    DWORD               dwVolume;
+    DWORD               dwPhoneStates;
+    DWORD               dwButtonModes;
+    DWORD               dwButtonStates;
+    DWORD               dwNumDevs;
+    HICON               hIcon;
+    HWND                hwndOwner;
+    PHONEEXTENSIONID    ExtensionID;
+    VARSTRING           DeviceID;
+
+    HPHONEAPP           hPhoneApp_Orig;
+    HPHONE              hPhone_Orig;
+    HINSTANCE           hInstance_Orig;
+    PHONECALLBACK       lpfnCallback_Orig;
+    DWORD               dwDeviceID_Orig;
+    DWORD               dwSize_Orig;
+    DWORD               dwButtonLampID_Orig;
+    DWORD               dwDataID_Orig;
+    DWORD               dwAPIVersion_Orig;
+    DWORD               dwExtVersion_Orig;
+    DWORD               dwGain_Orig;
+    DWORD               dwHookSwitchDev_Orig;
+    DWORD               dwHookSwitchDevs_Orig;
+    DWORD               dwHookSwitchMode_Orig;
+    DWORD               dwLampMode_Orig;
+    DWORD               dwRingMode_Orig;
+    DWORD               dwVolume_Orig;
+    DWORD               dwPhoneStates_Orig;
+    DWORD               dwButtonModes_Orig;
+    DWORD               dwButtonStates_Orig;
+    DWORD               dwCallbackInstance_Orig;
+    DWORD               dwPrivilege_Orig;
+    DWORD               dwRow_Orig;
+    DWORD               dwColumn_Orig;
+    HWND                hwndOwner_Orig;
+
+#if TAPI_2_0
+#ifdef WUNICODE
+	LPWSTR                      lpwszFriendlyAppName;
+#else
+    LPSTR                       lpszFriendlyAppName;
+#endif
+    LPPHONEINITIALIZEEXPARAMS   lpPhoneInitializeExParams;
+    LPPHONEMESSAGE              lpMessage;
+    DWORD                       dwTimeout;
+#endif
+
+} TAPIPHONETESTINFO, FAR* LPTAPIPHONETESTINFO;
+
+
+// typedefs for Test(In)ValidBitFlags functions
+typedef enum BITFIELDSIZETAG
+{
+    FIELDSIZE_16,
+    FIELDSIZE_24,
+    FIELDSIZE_32,
+} BITFIELDSIZE;
+
+typedef enum BITFIELDTYPETAG
+{
+    FIELDTYPE_MUTEX,
+    FIELDTYPE_UNION,
+    FIELDTYPE_NA
+} BITFIELDTYPE;
+
+/*
+// Typedef for pointer to sync line test function
+typedef BOOL TAPILINETESTFUNC(
+    LPTAPILINETESTINFO,
+    LONG
+    );
+
+typedef TAPILINETESTFUNC FAR *LPFN_TAPILINETESTFUNC;
+
+
+// Typedef for pointer to sync phone test function
+typedef BOOL TAPIPHONETESTFUNCA(
+    LPTAPIPHONETESTINFO,
+    LONG
+    );
+
+
+typedef TAPIPHONETESTFUNC FAR *LPFN_TAPIPHONETESTFUNC;
+
+*/
+
+
+// Typedef for pointer to sync line test function
+typedef BOOL TAPILINETESTFUNC(
+    LPTAPILINETESTINFO,
+    LONG
+    );
+
+typedef TAPILINETESTFUNC FAR *LPFN_TAPILINETESTFUNC;
+
+
+// Typedef for pointer to sync phone test function
+typedef BOOL TAPIPHONETESTFUNC(
+    LPTAPIPHONETESTINFO,
+    LONG
+    );
+
+typedef TAPIPHONETESTFUNC FAR *LPFN_TAPIPHONETESTFUNC;
+
+
+
+// Typedef for pointer to Async line test function
+typedef BOOL TAPILINETESTFUNCASY(
+    LPTAPILINETESTINFO,
+    LONG,
+    BOOL
+    );
+
+typedef TAPILINETESTFUNCASY FAR *LPFN_TAPILINETESTFUNCASY;
+
+
+// Typedef for pointer to sync phone test function
+typedef BOOL TAPIPHONETESTFUNCASY(
+    LPTAPIPHONETESTINFO,
+    LONG,
+    BOOL
+    );
+
+typedef TAPIPHONETESTFUNCASY FAR *LPFN_TAPIPHONETESTFUNCASY;
+
+
+
+// Array containing list of expected asynchronous request messages
+typedef struct TAPIMSGTAG {
+    DWORD     hDevCall;
+    DWORD     dwMsg;
+    DWORD     dwCallbackInstance;
+    DWORD     dwParam1;
+    DWORD     dwParam2;
+    DWORD     dwParam3;
+    DWORD     dwFlags;             // flags showing which params are important
+    struct TAPIMSGTAG * lpNext;    // pointer to next msg in the list
+} TAPIMSG, FAR* LPTAPIMSG;
+
+// Structure used to keep track of expected TAPI messages
+typedef struct CALLBACKPARAMSTAG {
+    LPTAPIMSG lpReceivedMsg;       // last received message params
+    LPTAPIMSG lpExpTapiMsgs;       // linked list storing the expected msgs
+    LPTAPIMSG lpRecTapiMsgs;       // linked list storing the received msgs
+    LPTAPIMSG lpRecTapiMsgTail;    // pointer to the last rec msg in the list
+				   // Since received messages are appended to
+				   // the linked list to preserve the order,
+				   // it's more efficient to use a tail pointer
+    UINT uTimerID;                 // store timerID for msg timeouts
+    BOOL fCallbackFatalError;      // Reports fatal msg errors
+    BOOL fMsgTimeout;              // Did a timeout occur in msg loop?
+} CALLBACKPARAMS, FAR* LPCALLBACKPARAMS;
+
+// Structure used to store the test resources (async message array,
+// line test info, phone test info, test heap, last tapi call result,
+// and log function pointer)
+typedef struct TESTRESOURCESTAG {
+    LPTAPILINETESTINFO lpTapiLineTestInfo;
+    LPTAPIPHONETESTINFO lpTapiPhoneTestInfo;
+    LOGPROC lpfnLogProc;
+    LPCALLBACKPARAMS lpCallbackParams;
+    LPTESTHEAPINFO lpTestHeapInfo;
+    LPTAPIRESULT lpLastTapiResult;
+} TESTRESOURCES, FAR* LPTESTRESOURCES;
+
+
+BOOL
+WINAPI
+TcoreSuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+TcoreSuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+TcoreSuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+TcoreSuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+// Functions used to manipulate the message array
+
+
+// WaitForAllMessages() enters a message loop until all of the messages in
+// the expected message array have been received.  The function returns
+// a BOOL indicating whether all of the messages were successfully received.
+// If an asynchronous reply message indicates an unexpected failure, then
+// this function will return FALSE.
+//
+// Note:  This function will not return until all expected messages have
+//        been received or a timeout occurs.
+BOOL
+WINAPI
+WaitForAllMessages();
+
+
+BOOL
+WINAPI
+WaitForMessage(
+    LPTAPIMSG lExpectedMsg
+    );
+
+
+HLOCAL
+WINAPI
+ITAlloc(
+    size_t size
+    );
+
+
+HLOCAL
+WINAPI
+ITFree(
+    LPVOID lpvMem
+    );
+
+
+DWORD
+WINAPI
+ITSize(
+    LPVOID lpvMem
+    );
+
+
+BOOL
+ProcessAsyncFunc(
+    LPTAPILINETESTINFO lpTapiLineTestInfo,
+    LONG lActual,
+    LONG lExpected
+    );
+
+
+BOOL
+ProcessAsyncPhoneAPI(
+    LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+    LONG lActual,
+    LONG lExpected
+    );
+
+
+BOOL
+CheckSyncPhoneResult(
+    LPTAPIPHONETESTINFO lpTapiPhoneTestInfo,
+    LONG lActual,
+    LONG lExpected
+    );
+
+BOOL
+CheckSyncTapiResult(
+    LPTAPILINETESTINFO lpTapiLineTestInfo,
+    LONG lActual,
+    LONG lExpected
+    );
+
+
+
+BOOL
+SyncCheckResult(
+    LPTAPILINETESTINFO lpTapiLineTestInfo,
+    LONG lActual,
+    LONG lExpected
+    );
+
+
+VOID
+WINAPI
+TapiLineTestInit();
+
+
+VOID
+WINAPI
+TapiPhoneTestInit();
+
+
+// AddMessageByStruct() takes the expected message parameters and adds the
+// expected message information to the end of the active elements in
+// the message list stored in the test resources structure.  If
+// the lpCallbackParams pointer is NULL,
+// the message information will not be added to the list and the
+// function will return FALSE, otherwise AddMessageByStruct() will
+// return TRUE.
+LPTAPIMSG
+WINAPI
+AddMessageByStruct(
+    LPTAPIMSG lpMsg
+    );
+
+
+// AddReceivedMessageByStruct() takes the expected message parameters
+// and adds the received message information to the end of the
+// the received message list stored in the test resources structure.  If
+// the lpCallbackParams pointer is NULL,
+// the message information will not be added to the list and the
+// function will return FALSE, otherwise AddMessageByStruct() will
+// return TRUE.
+LPTAPIMSG
+WINAPI
+AddReceivedMessageByStruct(
+    LPTAPIMSG lpMsg
+    );
+
+
+// AddMessage() takes the expected message parameters and adds the
+// expected message information to the end of the active elements in
+// the array.  If the array is full or the lpTapiMsgArry pointer is NULL,
+// the message information will not be added to the array and the
+// function will return FALSE, otherwise AddMessage() will return TRUE.
+LPTAPIMSG
+WINAPI
+AddMessage(
+    DWORD dwMsg,
+    DWORD hDevice,
+    DWORD dwCallbackInstance,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3,
+    DWORD dwFlags
+    );
+
+
+// AddReceivedMessage() takes the received message parameters and adds the
+// received message information to the end of the active elements in
+// the array.  If the lpCallbackParams pointer is NULL,
+// the message information will not be added to the list and the function
+// will return FALSE, otherwise AddReceivedMessage() will return TRUE.
+LPTAPIMSG
+WINAPI
+AddReceivedMessage(
+    DWORD dwMsg,
+    DWORD hDevice,
+    DWORD dwCallbackInstance,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3,
+    DWORD dwFlags
+    );
+
+
+// CheckReceivedMessage() searches the array of messages being waited on
+// and finds the message corresponding to the values in the TapiMsgParams
+// parameter.  If none of the messages in the array match, then FALSE is
+// returned.  If the message parameters do not match the expected message
+// parameters for corresponding IDs, then FALSE is returned.  Otherwise,
+// the array element storing the expected message is marked as received,
+// nMsgsNotReceived is decremented, and TRUE is returned.
+BOOL
+CheckReceivedMessage(
+    LPCALLBACKPARAMS lpCallbackParams,
+    LPTAPIMSG lpReceivedMsg,
+    LPDWORD lpdwFlags
+    );
+
+
+// IsTapiMsgInQ() searches a linked list of msgs for a match.
+// If lpTapiMsg is in the list pointed to by lpFirstTapiMsg, then
+// this function returns TRUE.  Otherwise, FALSE is returned.
+BOOL
+IsTapiMsgInQ(
+    LPTAPIMSG lpFirstTapiMsg,
+    LPTAPIMSG lpTapiMsg
+    );
+
+
+// CopyTapiMsgParams() copies the message parameters into the
+// TAPIMSG structure pointed to by lpTapiMsg if lpTapiMsg is
+// not null.  If lpTapiMsg is null, this function does nothing.
+VOID
+WINAPI
+CopyTapiMsgParams(
+    LPTAPIMSG lpTapiMsg,
+    DWORD hDevCall,
+    DWORD dwCallbackInstance,
+    DWORD dwMsg,
+    DWORD dwParam1,
+    DWORD dwParam2,
+    DWORD dwParam3,
+    DWORD dwFlags
+    );
+
+
+// CompareTapiMsgs() compares two messages and returns TRUE if the messages
+// match.  Otherwise FALSE is returned.  This function only compares
+// parameters that are specified according to the set bit flags in the
+// dwFlags field of the expected message (lpExpectedMsg).
+BOOL
+WINAPI
+CompareTapiMsgs(
+    LPTAPIMSG lpExpectedMsg,
+    LPTAPIMSG lpReceivedMsg
+    );
+
+
+// This function returns the first available address that a test function
+// can use out of a thread local heap.  If there is not enough room for
+// the 
+LPVOID
+WINAPI
+AllocFromTestHeap(
+    size_t NeededSize
+    );
+
+
+// FreeTestHeap() zeroes the bytes contained in the heap, and resets the
+// first available offset to 0.
+//
+// Note:  The memory containing the heap is not free'd.
+VOID
+WINAPI
+FreeTestHeap();
+
+
+// AllocTestResources() allocates the memory needed to store the fields
+// in the test resources structure.  This function then sets the test
+// resources pointer as the value stored in thread local storage.
+VOID
+AllocTestResources();
+
+
+// FreeTestResources() frees the memory used to store the fields in the
+// resources.  This function does not free the test resources pointer.
+VOID
+FreeTestResources();
+
+
+// GetTestHeapInfo returns the pointer to the test heap info structure
+// in the test resources stored in thread local storage.
+LPTESTHEAPINFO
+WINAPI
+GetTestHeapInfo();
+
+
+// GetLineTestInfo returns the pointer to the line test info structure
+// in the test resources stored in thread local storage.
+LPTAPILINETESTINFO
+WINAPI
+GetLineTestInfo();
+
+
+// GetPhoneTestInfo returns the pointer to the phone test info structure
+// in the test resources stored in thread local storage.
+LPTAPIPHONETESTINFO
+WINAPI
+GetPhoneTestInfo();
+
+
+// GetCallbackParams returns the pointer to the structure used
+// to store information for processing TAPI messages.
+LPCALLBACKPARAMS
+WINAPI
+GetCallbackParams();
+
+
+LOGPROC
+WINAPI
+GetLogProc();
+
+
+VOID
+InitializeCallbackParams();
+
+
+VOID
+WINAPI
+CopyTapiMsgs(
+    LPTAPIMSG lpSrcMsg,
+    LPTAPIMSG lpDestMsg
+    );
+
+
+VOID
+WINAPI
+RemoveReceivedMsgs(
+    LPCALLBACKPARAMS lpCallbackParams
+    );
+
+
+VOID
+WINAPI
+RemoveExpectedMsgs(
+    LPCALLBACKPARAMS lpCallbackParams
+    );
+
+
+VOID
+FreeTapiMsgList(
+    LPTAPIMSG *lppTapiMsgList
+    );
+
+
+DWORD
+WINAPI
+CallbackParamsGetDevCallHandle(
+    LPCALLBACKPARAMS lpCallbackParams,
+    DWORD dwMsg
+    );
+
+
+BOOL
+WINAPI
+DoExtensionIDsMatch(
+    LPLINEEXTENSIONID lpExtID1,
+    LPLINEEXTENSIONID lpExtID2
+    );
+
+
+VOID
+WINAPI
+OutputTAPIDebugInfo(
+	       int nLogLvl,
+	       LPSTR lpszDebugInfo
+	       );
+
+
+VOID
+WINAPI
+ShowTapiMsgInfo(
+	LPTAPIMSG lpMsg
+	);
+
+
+VOID
+WINAPI
+ShowExpectedMsgs(
+	LPCALLBACKPARAMS lpCallbackParams
+	);
+
+VOID
+WINAPI
+ShowReceivedMsgs(
+	LPCALLBACKPARAMS lpCallbackParams
+	);
+
+
+VOID
+WINAPI
+ShowTapiMsgList(
+	LPTAPIMSG lpTapiMsg
+	);
+
+
+VOID
+WINAPI
+FreeTapiMsgList(
+    LPTAPIMSG *lppMsg
+    );
+
+
+BOOL
+WINAPI
+GetVarField(
+    LPVOID lpVarDataStructure,
+    LPVOID lpVarField,
+    DWORD dwVarFieldSize,
+    DWORD dwVarFieldOffset
+    );
+
+
+BOOL
+WINAPI
+DoTapiLineFuncs(
+    LPTAPILINETESTINFO lpTapiLineTestInfo,
+    DWORD dwFunc
+    );
+
+
+VOID
+WINAPI
+GetLastTapiResult(
+    LPTAPIRESULT lpTapiResult
+    );
+
+
+VOID
+SetLastTapiResult(
+    FUNCINDEX eFuncIndex,
+    LONG lActual,
+    LONG lExpected
+    );
+
+
+// FindReceivedMsgs() will return the last received TAPI message
+// that matches the params in lpMatch if fFindMostRecent is false.
+// If fFindMostRecent is true, this function will return all received
+// messages in an allocated linked list stored in lppTapiMsg.
+// This function returns -1 if an allocation fails or an invalid
+// parameter is passed to it (e.g. lppTapiMsg or lpMatch is null).
+// Otherwise, the number of matches is returned.
+LONG
+WINAPI
+FindReceivedMsgs(
+    LPTAPIMSG *lppTapiMsg,
+    LPTAPIMSG lpMatch,
+    DWORD fFindMostRecent
+    );
+    
+
+#endif  // TAPICORE_H           
diff --git a/private/tapi/qa/tcore/tcore.inc b/private/tapi/qa/tcore/tcore.inc
new file mode 100644
index 000000000..c30dae18a
--- /dev/null
+++ b/private/tapi/qa/tcore/tcore.inc
@@ -0,0 +1,58 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tcore
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x61000000
+
+INCLUDES=..;..\..\trapper;$(BASEDIR)\public\sdk\inc
+
+USE_CRTDLL=1
+
+SOURCES=..\tcore.c  \
+        ..\doline.c \
+        ..\dophone.c \
+        ..\vars.c   \
+        ..\version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_0=1 -DTAPI_1_1=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=TcoreDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/tcore/tcorea/makefile b/private/tapi/qa/tcore/tcorea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/tcore/tcorea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/tcore/tcorea/sources b/private/tapi/qa/tcore/tcorea/sources
new file mode 100644
index 000000000..ff14d04d9
--- /dev/null
+++ b/private/tapi/qa/tcore/tcorea/sources
@@ -0,0 +1,32 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tcore.inc
+
+TARGETPATH=$(TARGETPATH)
+
+DLLDEF= ..\tcore.def
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/tcore/tcorew/makefile b/private/tapi/qa/tcore/tcorew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/tcore/tcorew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/tcore/tcorew/sources b/private/tapi/qa/tcore/tcorew/sources
new file mode 100644
index 000000000..d1b15a557
--- /dev/null
+++ b/private/tapi/qa/tcore/tcorew/sources
@@ -0,0 +1,32 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tcore.inc
+
+DLLDEF= ..\tcore.def
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/tcore/vars.c b/private/tapi/qa/tcore/vars.c
new file mode 100644
index 000000000..98ed2d3a9
--- /dev/null
+++ b/private/tapi/qa/tcore/vars.c
@@ -0,0 +1,502 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    vars.c
+
+Abstract:
+
+    Globals for TAPI core test dll.
+
+Author:
+
+    Oliver Wallace (OliverW)    17-Nov-1995
+
+Revision History:
+
+--*/
+
+
+#define _TCORELIB_
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "vars.h"
+#include "tcore.h"
+
+
+// per mapping instance data for this DLL
+HANDLE      ghDll;
+
+
+// Thread local storage indeces to store the log function pointer
+// that displays test results and to store the test resources
+DWORD       gdwTlsIndex = TLS_OUT_OF_INDEXES;
+
+TCOREAPI DWORD dwTestCase = 0;
+TCOREAPI DWORD dwTestCasePassed = 0;
+TCOREAPI DWORD dwTestCaseFailed = 0;
+
+TCOREAPI DWORD dwglTestCase = 0;
+TCOREAPI DWORD dwglTestCasePassed = 0;
+TCOREAPI DWORD dwglTestCaseFailed = 0;
+
+TCOREAPI DWORD dwTimer = 0;
+TCOREAPI char  szTitle[32];
+
+// Global value for LogLevel
+
+// Array containing TAPI line error return descriptions
+TCOREAPI char *aszLineErrors[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "BEARERMODEUNAVAIL",
+    "invalid error code (0x80000004)",      // 0x80000004 isn't valid err code
+    "CALLUNAVAIL",
+    "COMPLETIONOVERRUN",
+    "CONFERENCEFULL",
+    "DIALBILLING",
+    "DIALDIALTONE",
+    "DIALPROMPT",
+    "DIALQUIET",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALADDRESS",                         // 0x80000010
+    "INVALADDRESSID",
+    "INVALADDRESSMODE",
+    "INVALADDRESSSTATE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBEARERMODE",
+    "INVALCALLCOMPLMODE",
+    "INVALCALLHANDLE",
+    "INVALCALLPARAMS",
+    "INVALCALLPRIVILEGE",
+    "INVALCALLSELECT",
+    "INVALCALLSTATE",
+    "INVALCALLSTATELIST",
+    "INVALCARD",
+    "INVALCOMPLETIONID",
+    "INVALCONFCALLHANDLE",                  // 0x80000020
+    "INVALCONSULTCALLHANDLE",
+    "INVALCOUNTRYCODE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEHANDLE",
+    "INVALDIALPARAMS",
+    "INVALDIGITLIST",
+    "INVALDIGITMODE",
+    "INVALDIGITS",
+    "INVALEXTVERSION",
+    "INVALGROUPID",
+    "INVALLINEHANDLE",
+    "INVALLINESTATE",
+    "INVALLOCATION",
+    "INVALMEDIALIST",
+    "INVALMEDIAMODE",
+    "INVALMESSAGEID",                       // 0x80000030
+    "invalid error code (0x80000031)",      // 0x80000031 isn't valid err code
+    "INVALPARAM",
+    "INVALPARKID",
+    "INVALPARKMODE",
+    "INVALPOINTER",
+    "INVALPRIVSELECT",
+    "INVALRATE",
+    "INVALREQUESTMODE",
+    "INVALTERMINALID",
+    "INVALTERMINALMODE",
+    "INVALTIMEOUT",
+    "INVALTONE",
+    "INVALTONELIST",
+    "INVALTONEMODE",
+    "INVALTRANSFERMODE",
+    "LINEMAPPERFAILED",                     // 0x80000040
+    "NOCONFERENCE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOREQUEST",
+    "NOTOWNER",
+    "NOTREGISTERED",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "RATEUNAVAIL",
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",
+    "STRUCTURETOOSMALL",
+    "TARGETNOTFOUND",
+    "TARGETSELF",
+    "UNINITIALIZED",                        // 0x80000050
+    "USERUSERINFOTOOBIG",
+    "REINIT",
+    "ADDRESSBLOCKED",
+    "BILLINGREJECTED",
+    "INVALFEATURE",
+    "NOMULTIPLEINSTANCE"
+
+#if TAPI_2_0
+    ,
+    "INVALAGENTID",
+    "INVALAGENTGROUP",
+    "INVALPASSWORD",
+    "INVALAGENTSTATE",
+    "INVALAGENTACTIVITY",
+    "DIALVOICEDETECT"
+#endif
+};
+
+TCOREAPI char *aszPhoneErrors[] =
+{
+    "SUCCESS",
+    "ALLOCATED",
+    "BADDEVICEID",
+    "INCOMPATIBLEAPIVERSION",
+    "INCOMPATIBLEEXTVERSION",
+    "INIFILECORRUPT",
+    "INUSE",
+    "INVALAPPHANDLE",
+    "INVALAPPNAME",
+    "INVALBUTTONLAMPID",
+    "INVALBUTTONMODE",
+    "INVALBUTTONSTATE",
+    "INVALDATAID",
+    "INVALDEVICECLASS",
+    "INVALEXTVERSION",
+    "INVALHOOKSWITCHDEV",
+    "INVALHOOKSWITCHMODE",                  // 0x90000010
+    "INVALLAMPMODE",
+    "INVALPARAM",
+    "INVALPHONEHANDLE",
+    "INVALPHONESTATE",
+    "INVALPOINTER",
+    "INVALPRIVILEGE",
+    "INVALRINGMODE",
+    "NODEVICE",
+    "NODRIVER",
+    "NOMEM",
+    "NOTOWNER",
+    "OPERATIONFAILED",
+    "OPERATIONUNAVAIL",
+    "invalid error code (0x9000001E)",      // 0x9000001e isn't valid err code
+    "RESOURCEUNAVAIL",
+    "REQUESTOVERRUN",                       // 0x90000020
+    "STRUCTURETOOSMALL",
+    "UNINITIALIZED",
+    "REINIT"
+};
+
+TCOREAPI char *aszTapiErrors[] =
+{
+    "SUCCESS",
+    "DROPPED",
+    "NOREQUESTRECIPIENT",
+    "REQUESTQUEUEFULL",
+    "INVALDESTADDRESS",
+    "INVALWINDOWHANDLE",
+    "INVALDEVICECLASS",
+    "INVALDEVICEID",
+    "DEVICECLASSUNAVAIL",
+    "DEVICEIDUNAVAIL",
+    "DEVICEINUSE",
+    "DESTBUSY",
+    "DESTNOANSWER",
+    "DESTUNAVAIL",
+    "UNKNOWNWINHANDLE",
+    "UNKNOWNREQUESTID",
+    "REQUESTFAILED",
+    "REQUESTCANCELLED",
+    "INVALPOINTER"
+};
+
+TCOREAPI char *aszFuncNames[] =
+{
+    "lineAccept",
+#if TAPI_1_0
+    "lineAddProvider",
+#endif
+    "lineAddToConference",
+    "lineAnswer",
+    "lineBlindTransfer",
+    "lineClose",
+    "lineCompleteCall",
+    "lineCompleteTransfer",
+    "lineConfigDialog",
+#if TAPI_1_0
+    "lineConfigDialogEdit",
+    "lineConfigProvider",
+#endif
+    "lineDeallocateCall",
+    "lineDevSpecific",
+    "lineDevSpecificFeature",
+    "lineDial",
+    "lineDrop",
+    "lineForward",
+    "lineGatherDigits",
+    "lineGenerateDigits",
+    "lineGenerateTone",
+    "lineGetAddressCaps",
+    "lineGetAddressID",
+    "lineGetAddressStatus",
+#if TAPI_1_0
+    "lineGetAppPriority",
+#endif
+    "lineGetCallInfo",
+    "lineGetCallStatus",
+    "lineGetConfRelatedCalls",
+#if TAPI_1_0
+    "lineGetCountry",
+#endif
+    "lineGetDevCaps",
+    "lineGetDevConfig",
+    "lineGetIcon",
+    "lineGetID",
+    "lineGetLineDevStatus",
+    "lineGetNewCalls",
+    "lineGetNumRings",
+#if TAPI_1_0
+    "lineGetProviderList",
+#endif
+    "lineGetRequest",
+    "lineGetStatusMessages",
+    "lineGetTranslateCaps",
+    "lineHandoff",
+    "lineHold",
+    "lineInitialize",
+    "lineMakeCall",
+    "lineMonitorDigits",
+    "lineMonitorMedia",
+    "lineMonitorTones",
+    "lineNegotiateAPIVersion",
+    "lineNegotiateExtVersion",
+    "lineOpen",
+    "linePark",
+    "linePickup",
+    "linePrepareAddToConference",
+    "lineRedirect",
+    "lineRegisterRequestRecipient",
+#if TAPI_1_0
+    "lineReleaseUserUserInfo",
+#endif
+    "lineRemoveFromConference",
+#if TAPI_1_0
+    "lineRemoveProvider",
+#endif
+    "lineSecureCall",
+    "lineSendUserUserInfo",
+#if TAPI_1_0
+    "lineSetAppPriority",
+#endif
+    "lineSetAppSpecific",
+    "lineSetCallParams",
+    "lineSetCallPrivilege",
+    "lineSetCurrentLocation",
+    "lineSetDevConfig",
+    "lineSetMediaControl",
+    "lineSetMediaMode",
+    "lineSetNumRings",
+    "lineSetStatusMessages",
+    "lineSetTerminal",
+    "lineSetTollList",
+    "lineSetupConference",
+    "lineSetupTransfer",
+    "lineShutdown",
+    "lineSwapHold",
+    "lineTranslateAddress",
+#if TAPI_1_0
+    "lineTranslateDialog",
+#endif
+    "lineUncompleteCall",
+    "lineUnhold",
+    "lineUnpark",
+
+    "phoneClose",
+    "phoneConfigDialog",
+    "phoneDevSpecific",
+    "phoneGetButtonInfo",
+    "phoneGetData",
+    "phoneGetDevCaps",
+    "phoneGetDisplay",
+    "phoneGetGain",
+    "phoneGetHookSwitch",
+    "phoneGetIcon",
+    "phoneGetID",
+    "phoneGetLamp",
+    "phoneGetRing",
+    "phoneGetStatus",
+    "phoneGetStatusMessages",
+    "phoneGetVolume",
+    "phoneInitialize",
+    "phoneOpen",
+    "phoneNegotiateAPIVersion",
+    "phoneNegotiateExtVersion",
+    "phoneSetButtonInfo",
+    "phoneSetData",
+    "phoneSetDisplay",
+    "phoneSetGain",
+    "phoneSetHookSwitch",
+    "phoneSetLamp",
+    "phoneSetRing",
+    "phoneSetStatusMessages",
+    "phoneSetVolume",
+    "phoneShutdown",
+
+    "tapiGetLocationInfo",
+    "tapiRequestDrop",
+    "tapiRequestMakeCall",
+    "tapiRequestMediaCall",
+
+#if TAPI_2_0
+    "lineAgentSpecific",
+    "lineGetAgentCaps",
+    "lineGetAgentActivityList",
+    "lineGetAgentGroupList",
+    "lineGetAgentStatus",
+    "lineProxyMessages",
+    "lineProxyResponse",
+    "lineSetAgentActivity",
+    "lineSetAgentGroup",
+    "lineSetAgentState",
+    "lineSetCallData",
+    "lineSetCallQualityOfService",
+    "lineSetCallTreatment",
+    "lineSetLineDevStatus",
+    "lineInitializeEx",
+    "lineGetMessage",
+    "phoneInitializeEx",
+    "phoneGetMessage"
+#endif
+
+};
+
+// Messages for Phones and Lines
+
+TCOREAPI char *aszTapiMessages[] =
+{
+    "LINE_ADDRESSSTATE",
+    "LINE_CALLINFO",
+    "LINE_CALLSTATE",
+    "LINE_CLOSE",
+    "LINE_DEVSPECIFIC",
+    "LINE_DEVSPECIFICFEATURE",
+    "LINE_GATHERDIGITS",
+    "LINE_GENERATE",
+    "LINE_LINEDEVSTATE",
+    "LINE_MONITORDIGITS",
+    "LINE_MONITORMEDIA",
+    "LINE_MONITORTONE",
+    "LINE_REPLY",
+    "LINE_REQUEST",
+    "PHONE_BUTTON",
+    "PHONE_CLOSE",
+    "PHONE_DEVSPECIFIC",
+    "PHONE_REPLY",
+    "PHONE_STATE",
+    "LINE_CREATE",                                             // TAPI v1.4
+    "PHONE_CREATE",                                            // TAPI v1.4
+    "LINE_AGENTSPECIFIC",                                      // TAPI v2.0
+    "LINE_AGENTSTATUS",                                        // TAPI v2.0
+    "LINE_APPNEWCALL",                                         // TAPI v2.0
+    "LINE_PROXYREQUEST",                                       // TAPI v2.0
+    "LINE_REMOVE",                                             // TAPI v2.0
+    "PHONE_REMOVE"                                             // TAPI v2.0
+};
+
+// Array to store bit masks
+TCOREAPI DWORD FAR dwBitVectorMasks[] =
+{
+    0x0000FFFF,
+    0x00FFFFFF,
+    0xFFFFFFFF
+};
+
+
+// Array containing set of invalid pointer values
+TCOREAPI const DWORD gdwInvalidPointers[NUMINVALIDPOINTERS] = {
+    (DWORD) NULL,
+    0x00000001,
+    0x00000002,
+    0x00000003,
+    0x00000004,
+    0x00000005,
+    0x00000006,
+    0x00000007,
+    0x00000008,
+    0x00000009,
+    0x0000000A,
+    0x0000000C,
+    0x00000010,
+#if defined(_MIPS_)
+    0x7FFFDFFF,
+#else
+    0x7FFFFFFF,
+#endif
+    0x80000000,
+    0x80000001,
+    0x80000002,
+    0x80000003,
+    0x80000004,
+    0x80000005,
+    0x80000006,
+    0x80000007,
+    0x80000008,
+    0x80000009,
+    0x8000000A,
+    0xFFFFFFF6,
+    0xFFFFFFF7,
+    0xFFFFFFF8,
+    0xFFFFFFF9,
+    0xFFFFFFFA,
+    0xFFFFFFFB,
+    0xFFFFFFFC,
+    0xFFFFFFFD,
+    0xFFFFFFFE,
+    0xFFFFFFFF
+    };
+// Array containing set of invalid handle values
+TCOREAPI const DWORD gdwInvalidHandles[NUMINVALIDHANDLES] = {
+    0x00000000,
+    0x00000001,
+    0x00000002,
+    0x00000003,
+    0x00000004,
+    0x00000005,
+    0x00000006,
+    0x00000007,
+    0x00000008,
+    0x00000009,
+    0x0000000A,
+    0x0000000C,
+    0x00000010,
+    0x7FFFFFFF,
+    0x80000000,
+    0x80000001,
+    0x80000002,
+    0x80000003,
+    0x80000004,
+    0x80000005,
+    0x80000006,
+    0x80000007,
+    0x80000008,
+    0x80000009,
+    0x8000000A,
+    0xFFFFFFF6,
+    0xFFFFFFF7,
+    0xFFFFFFF8,
+    0xFFFFFFF9,
+    0xFFFFFFFA,
+    0xFFFFFFFB,
+    0xFFFFFFFC,
+    0xFFFFFFFD,
+    0xFFFFFFFE,
+    0xFFFFFFFF
+    };
+
diff --git a/private/tapi/qa/tcore/vars.h b/private/tapi/qa/tcore/vars.h
new file mode 100644
index 000000000..647f6c69b
--- /dev/null
+++ b/private/tapi/qa/tcore/vars.h
@@ -0,0 +1,83 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    vars.h
+
+Abstract:
+
+    Globals for tapi core dll.
+
+Author:
+
+    Oliver Wallace (OliverW)    13-July-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef VARS_H
+#define VARS_H
+
+
+#if !defined(_TCORELIB_)
+# define TCOREAPI __declspec(dllimport)
+#else
+# define TCOREAPI __declspec(dllexport)
+#endif
+
+
+// per mapping instance data for core dll
+extern HANDLE ghDll;
+
+
+// Tls index for dll
+extern DWORD gdwTlsIndex;
+
+TCOREAPI extern DWORD dwTestCase;
+TCOREAPI extern DWORD dwTestCasePassed;
+TCOREAPI extern DWORD dwTestCaseFailed;
+
+TCOREAPI extern DWORD dwglTestCase;
+TCOREAPI extern DWORD dwglTestCasePassed;
+TCOREAPI extern DWORD dwglTestCaseFailed;
+
+TCOREAPI extern DWORD dwTimer;
+TCOREAPI char  szTitle[];
+
+// Log Level
+
+// Lookup table for masking bits of field sizes 16, 24, and 32
+TCOREAPI extern DWORD FAR dwBitVectorMasks[];
+
+
+// Size of invalid pointer array
+#define NUMINVALIDPOINTERS               35
+
+
+// Array containing set of invalid pointer values
+TCOREAPI extern const DWORD gdwInvalidPointers[NUMINVALIDPOINTERS];
+
+
+// Size of invalid handle array
+#define NUMINVALIDHANDLES               35
+					
+#define BIGBUFSIZE                      1024
+#define BUFSIZE								  256
+
+// Array containing set of invalid handle values
+TCOREAPI extern const DWORD gdwInvalidHandles[NUMINVALIDHANDLES];
+
+
+// Arrays containing descriptive string constants
+TCOREAPI extern char *aszTapiMessages[];
+TCOREAPI extern char *aszFuncNames[];
+TCOREAPI extern char *aszLineErrors[];
+TCOREAPI extern char *aszPhoneErrors[];
+TCOREAPI extern char *aszTapiErrors[];
+
+
+#endif  // VARS_H
diff --git a/private/tapi/qa/tcore/version.rc b/private/tapi/qa/tcore/version.rc
new file mode 100644
index 000000000..171368403
--- /dev/null
+++ b/private/tapi/qa/tcore/version.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI core test Library"
+#define VER_INTERNALNAME_STR        "tcore.dll"
+#define VER_ORIGINALFILENAME_STR    "tcore.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/template/makefile b/private/tapi/qa/template/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/template/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/template/sources b/private/tapi/qa/template/sources
new file mode 100644
index 000000000..d81972eb7
--- /dev/null
+++ b/private/tapi/qa/template/sources
@@ -0,0 +1,51 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=template
+TARGETPATH=..\bin
+TARGETTYPE=DYNLINK
+TARGETLIBS=\nt\public\sdk\lib\*\kernel32.lib \
+           \nt\public\sdk\lib\*\user32.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=..\trapper;..\..\dev\inc;.
+
+USE_CRTDLL=1
+
+SOURCES=template.c  \
+        template.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/template/template.c b/private/tapi/qa/template/template.c
new file mode 100644
index 000000000..f8d3bae42
--- /dev/null
+++ b/private/tapi/qa/template/template.c
@@ -0,0 +1,201 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    template.c
+
+Abstract:
+
+    This module contains the
+
+Author:
+
+    Dan Knudson (DanKn)    05-May-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "template.h"
+
+
+
+HANDLE      ghDll;
+LOGPROC     gpfnLog;
+
+#ifdef WIN32
+
+#define __export
+#define __loadds
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+
+        ghDll = hDLL;
+
+    case DLL_PROCESS_DETACH:
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+
+        break;
+    }
+
+    return TRUE;
+}
+
+#else
+
+int
+FAR
+PASCAL
+LibMain(
+    HANDLE  hInstance,
+    WORD    wDataSegment,
+    WORD    wHeapSize,
+    LPSTR   lpszCmdLine
+    )
+{
+    ghDll = hInstance;
+
+    return TRUE;
+}
+
+#endif
+
+
+VOID
+FAR
+PASCAL
+__loadds
+__export
+TapiCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    )
+{
+    (*gpfnLog)(
+        3,
+        "TapiCallback: enter, dwMsg=x%lx, dwCbInst=%ld, dwP1=x%lx",
+        dwMsg,
+        dwCallbackInstance,
+        dwParam1
+        );
+
+    switch (dwMsg)
+    {
+    } // switch
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    gpfnLog = pfnLog;
+
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Template Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Template Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    (*gpfnLog)(3, "Template: Test1: enter");
+    (*gpfnLog)(3, "Template: Test1: exit");
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    (*gpfnLog)(3, "Template: Test2: enter");
+    (*gpfnLog)(3, "Template: Test2: exit");
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    (*gpfnLog)(3, "Template: Test3: enter");
+    (*gpfnLog)(3, "Template: Test3: exit");
+}
diff --git a/private/tapi/qa/template/template.def b/private/tapi/qa/template/template.def
new file mode 100644
index 000000000..714fe06e3
--- /dev/null
+++ b/private/tapi/qa/template/template.def
@@ -0,0 +1,15 @@
+LIBRARY         template
+EXETYPE         WINDOWS 3.1
+PROTMODE
+CODE            MOVEABLE DISCARDABLE
+DATA            PRELOAD MOVEABLE
+
+EXPORTS
+        TapiCallback
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
diff --git a/private/tapi/qa/template/template.h b/private/tapi/qa/template/template.h
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/private/tapi/qa/template/template.h
diff --git a/private/tapi/qa/template/template.rc b/private/tapi/qa/template/template.rc
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/private/tapi/qa/template/template.rc
diff --git a/private/tapi/qa/tpstress/makefile b/private/tapi/qa/tpstress/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/tpstress/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/tpstress/sources b/private/tapi/qa/tpstress/sources
new file mode 100644
index 000000000..3382eac2e
--- /dev/null
+++ b/private/tapi/qa/tpstress/sources
@@ -0,0 +1,51 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tpstress
+TARGETPATH=..\bin
+TARGETTYPE=DYNLINK
+TARGETLIBS=\nt\public\sdk\lib\*\kernel32.lib \
+           \nt\public\sdk\lib\*\user32.lib \
+           \nt\public\sdk\lib\*\tapi32.lib
+
+DLLBASE=0x60000000
+
+INCLUDES=..\trapper;..\..\dev\inc;.
+
+USE_CRTDLL=1
+
+SOURCES=tpstress.c  \
+        tpstress.rc
+
+UMTYPE=windows
+
+DLLENTRY=DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/tpstress/tpstress.c b/private/tapi/qa/tpstress/tpstress.c
new file mode 100644
index 000000000..ba58d8099
--- /dev/null
+++ b/private/tapi/qa/tpstress/tpstress.c
@@ -0,0 +1,596 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    tpstress.c
+
+Abstract:
+
+    This module contains the
+
+Author:
+
+    Dan Knudson (DanKn)    05-May-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+
+
+typedef struct _INSTANCE_INFO
+{
+    LONG    lExpectedReplyID;
+
+    BOOL    bExpectedMsgReceived;
+
+} INSTANCE_INFO, *PINSTANCE_INFO;
+
+
+#define LOW_API_VERSION     0x10003
+#define HIGH_API_VERSION    0x10005
+
+HANDLE      ghDll;
+LOGPROC     gpfnLog;
+
+char        gszDestAddress[64] = "20110";
+
+#ifdef WIN32
+
+#define __export
+#define __loadds
+
+BOOL
+WINAPI
+DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+
+        ghDll = hDLL;
+
+    case DLL_PROCESS_DETACH:
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+
+        break;
+    }
+
+    return TRUE;
+}
+
+#else
+
+int
+FAR
+PASCAL
+LibMain(
+    HANDLE  hInstance,
+    WORD    wDataSegment,
+    WORD    wHeapSize,
+    LPSTR   lpszCmdLine
+    )
+{
+    ghDll = hInstance;
+
+    return TRUE;
+}
+
+#endif
+
+
+VOID
+FAR
+PASCAL
+__loadds
+__export
+TapiCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    )
+{
+    (*gpfnLog)(
+        3,
+        "TapiCallback: enter, dwMsg=x%lx, dwCbInst=%ld, dwP1=x%lx",
+        dwMsg,
+        dwCallbackInstance,
+        dwParam1
+        );
+
+    switch (dwMsg)
+    {
+    case LINE_REPLY:
+    {
+        PINSTANCE_INFO pInstInfo = (PINSTANCE_INFO) dwCallbackInstance;
+
+
+        if (dwParam1 == (DWORD) pInstInfo->lExpectedReplyID)
+        {
+            pInstInfo->bExpectedMsgReceived = TRUE;
+        }
+
+        break;
+    }
+    } // switch
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    gpfnLog = pfnLog;
+
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Tapi Stress Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Tapi Stress Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+MakeNCalls(
+    DWORD   dwNumCalls
+    )
+{
+    MSG         msg;
+    LONG        lResult;
+    BOOL        bFoundESP = FALSE, bResult = TRUE;
+    DWORD       dwDeviceID, dwAPIVersion, dwNumDevs, i;
+    HCALL       hCall;
+    HLINE       hLine;
+    HLINEAPP    hLineApp;
+    LPLINEDEVCAPS   pLineDevCaps;
+    PINSTANCE_INFO  pInstInfo;
+    LINEEXTENSIONID extensionID;
+
+
+    Sleep (1000); // give other apps time to play
+
+    pInstInfo = LocalAlloc (LPTR, sizeof (INSTANCE_INFO));
+
+    lResult = lineInitialize(
+        &hLineApp,
+        ghDll,
+        TapiCallback,
+        "tpstress.dll",
+        &dwNumDevs
+        );
+
+    if (lResult)
+    {
+        (*gpfnLog)(0, "  TPSTRESS: lineInitialize failed, err=x%lx", lResult);
+
+        return FALSE;
+    }
+
+
+    //
+    // Find an ESP line device
+    //
+
+    pLineDevCaps = (LPLINEDEVCAPS) LocalAlloc (LPTR, 1024);
+
+    for (dwDeviceID = 0; ((dwDeviceID < dwNumDevs) && !bFoundESP); dwDeviceID++)
+    {
+        char *pszProviderInfo;
+
+
+        pLineDevCaps->dwTotalSize = 1024;
+
+        lResult = lineNegotiateAPIVersion(
+            hLineApp,
+            dwDeviceID,
+            LOW_API_VERSION,
+            HIGH_API_VERSION,
+            &dwAPIVersion,
+            &extensionID
+            );
+
+        lResult = lineGetDevCaps(
+            hLineApp,
+            dwDeviceID,
+            dwAPIVersion,
+            0,
+            pLineDevCaps
+            );
+
+        pszProviderInfo = ((char *) pLineDevCaps) +
+            pLineDevCaps->dwProviderInfoOffset;
+
+        try
+        {
+            if (strstr (pszProviderInfo, "ESP"))
+            {
+                bFoundESP = TRUE;
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+    }
+
+    LocalFree (LocalHandle (pLineDevCaps));
+
+    if (dwDeviceID == dwNumDevs)
+    {
+        (*gpfnLog)(0, "  TPSTRESS: couldn't locate ESP line");
+
+        bResult = FALSE;
+
+        goto MakeNCalls_lineShutdown;
+    }
+
+    lResult = lineOpen(
+        hLineApp,
+        dwDeviceID,
+        &hLine,
+        dwAPIVersion,
+        0,
+        (DWORD) pInstInfo,
+        LINECALLPRIVILEGE_NONE,
+        0,
+        (LPLINECALLPARAMS) NULL
+        );
+
+    if (lResult)
+    {
+        (*gpfnLog)(0, "  TPSTRESS: lineOpen failed, err=x%lx", lResult);
+
+        bResult = FALSE;
+
+        goto MakeNCalls_lineShutdown;
+    }
+
+    for (i = 0; i < dwNumCalls; i++)
+    {
+        if ((lResult = lineMakeCall(
+                hLine,
+                &hCall,
+                gszDestAddress,
+                0,
+                (LPLINECALLPARAMS) NULL
+
+                )) > 0)
+        {
+            //
+            // Wait for the make call request to complete
+            //
+
+            pInstInfo->lExpectedReplyID = lResult;
+
+            pInstInfo->bExpectedMsgReceived = FALSE;
+
+            while (!pInstInfo->bExpectedMsgReceived)
+            {
+                GetMessage (&msg, NULL, 0, 0);
+                DispatchMessage (&msg);
+            }
+
+
+            //
+            // Now drop the call
+            //
+
+            if ((lResult = lineDrop (hCall, NULL, 0)) > 0)
+            {
+                //
+                // Wait for the drop request to complete
+                //
+
+                pInstInfo->lExpectedReplyID = lResult;
+
+                pInstInfo->bExpectedMsgReceived = FALSE;
+
+                while (!pInstInfo->bExpectedMsgReceived)
+                {
+                    GetMessage (&msg, NULL, 0, 0);
+                    DispatchMessage (&msg);
+                }
+            }
+
+
+            //
+            // Nuke the call handle
+            //
+
+            lResult = lineDeallocateCall (hCall);
+        }
+        else
+        {
+            (*gpfnLog)(0, "  TPSTRESS: lineMakeCall failed, err=x%lx", lResult);
+        }
+    }
+
+    if ((lResult = lineClose (hLine)))
+    {
+        (*gpfnLog)(0, "  TPSTRESS: lineClose failed, err=x%lx", lResult);
+
+        bResult = FALSE;
+    }
+
+MakeNCalls_lineShutdown:
+
+    if ((lResult = lineShutdown (hLineApp)))
+    {
+        (*gpfnLog)(0, "  TPSTRESS: lineShutdown failed, err=x%lx", lResult);
+
+        bResult = FALSE;
+    }
+
+    LocalFree (LocalHandle (pInstInfo));
+
+    return bResult;
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+Test1(
+    HINSTANCE   hAppInst
+    )
+/*++
+
+    Makes a voice call on an ESP line device
+
+--*/
+{
+    return (MakeNCalls (1));
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+Test2(
+    HINSTANCE   hAppInst
+    )
+/*++
+
+    Makes 10 voice calls on an ESP line device
+
+--*/
+{
+    return (MakeNCalls (10));
+}
+
+
+BOOL
+FAR
+PASCAL
+__export
+Test3(
+    HINSTANCE   hAppInst
+    )
+/*++
+
+    Does a init, open, close, & shutdown on an ESP phone device
+
+--*/
+{
+    BOOL        bResult = TRUE, bFoundESP = FALSE;
+    LONG        lResult;
+    DWORD       dwNumPhones, dwDeviceID, dwGain, dwAPIVersion,
+                dwPrivilege = PHONEPRIVILEGE_OWNER;
+    HPHONE      hPhone;
+    HPHONEAPP   hPhoneApp;
+    LPPHONECAPS pPhoneCaps;
+    PHONEEXTENSIONID    extensionID;
+
+    //
+    // Init TAPI
+    //
+
+    if ((lResult = phoneInitialize(
+            &hPhoneApp,
+            ghDll,
+            TapiCallback,
+            "tpstress.dll",
+            &dwNumPhones
+            )))
+    {
+        (*gpfnLog)(1, "phoneInitialize ret'd x%x", lResult);
+
+        return FALSE;
+    }
+
+
+    //
+    // Try to find an ESP phone device
+    //
+
+    pPhoneCaps = (LPPHONECAPS) LocalAlloc (LPTR, 1024);
+
+    for(
+        dwDeviceID = 0;
+        ((dwDeviceID < dwNumPhones) && !bFoundESP);
+        dwDeviceID++
+        )
+    {
+        char *pszProviderInfo;
+
+
+        pPhoneCaps->dwTotalSize = 1024;
+
+        lResult = phoneNegotiateAPIVersion(
+            hPhoneApp,
+            dwDeviceID,
+            LOW_API_VERSION,
+            HIGH_API_VERSION,
+            &dwAPIVersion,
+            &extensionID
+            );
+
+        lResult = phoneGetDevCaps(
+            hPhoneApp,
+            dwDeviceID,
+            dwAPIVersion,
+            0,
+            pPhoneCaps
+            );
+
+        pszProviderInfo = ((char *) pPhoneCaps) +
+            pPhoneCaps->dwProviderInfoOffset;
+
+        try
+        {
+            if (strstr (pszProviderInfo, "ESP"))
+            {
+                bFoundESP = TRUE;
+            }
+        }
+        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+    }
+
+    LocalFree (LocalHandle (pPhoneCaps));
+
+    if (dwDeviceID == dwNumPhones)
+    {
+        (*gpfnLog)(0, "  TPSTRESS: couldn't locate ESP phone");
+
+        bResult = FALSE;
+
+        goto Test3_phoneShutdown;
+    }
+
+
+    //
+    // Open the ESP phone device & make some basic requests (if we can't
+    // open as owner try opening as monitor)
+    //
+
+    if ((lResult = phoneOpen(
+            hPhoneApp,
+            dwDeviceID,
+            &hPhone,
+            dwAPIVersion,
+            0,
+            0,
+            dwPrivilege
+            )))
+    {
+        dwPrivilege = PHONEPRIVILEGE_MONITOR;
+
+        if ((lResult != PHONEERR_INVALPRIVILEGE) ||
+
+            (lResult = phoneOpen(
+                hPhoneApp,
+                dwDeviceID,
+                &hPhone,
+                dwAPIVersion,
+                0,              // dwExtVersion
+                0,              // dwCallbackInst
+                dwPrivilege
+                )))
+        {
+            (*gpfnLog)(0, "  TPSTRESS: phoneOpen ret'd x%x", lResult);
+
+            bResult = FALSE;
+
+            goto Test3_phoneShutdown;
+        }
+
+    }
+
+
+    if ((lResult = phoneGetGain(
+            hPhone,
+            PHONEHOOKSWITCHDEV_HANDSET,
+            &dwGain
+            )))
+    {
+        (*gpfnLog)(0, "  TPSTRESS: phoneGetDisplay ret'd x%x", lResult);
+
+        bResult = FALSE;
+
+        goto Test3_phoneShutdown;
+    }
+
+
+    //
+    // Clean up
+    //
+
+    if ((lResult = phoneClose (hPhone)))
+    {
+        (*gpfnLog)(0, "  TPSTRESS: phoneClose ret'd x%x", lResult);
+
+        bResult = FALSE;
+    }
+
+Test3_phoneShutdown:
+
+    if ((lResult = phoneShutdown (hPhoneApp)))
+    {
+        (*gpfnLog)(0, "  TPSTRESS: phoneShutdown ret'd x%x", lResult);
+
+        bResult = FALSE;
+    }
+
+    return bResult;
+}
diff --git a/private/tapi/qa/tpstress/tpstress.def b/private/tapi/qa/tpstress/tpstress.def
new file mode 100644
index 000000000..75d9da468
--- /dev/null
+++ b/private/tapi/qa/tpstress/tpstress.def
@@ -0,0 +1,14 @@
+LIBRARY         tpstress
+PROTMODE
+CODE            MOVEABLE DISCARDABLE
+DATA            PRELOAD MOVEABLE
+
+EXPORTS
+        TapiCallback
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
diff --git a/private/tapi/qa/tpstress/tpstress.h b/private/tapi/qa/tpstress/tpstress.h
new file mode 100644
index 000000000..aa35b73b2
--- /dev/null
+++ b/private/tapi/qa/tpstress/tpstress.h
@@ -0,0 +1,29 @@
+#define TEST1                       1
+#define TEST2                       2
+#define TEST3                       3
+#define TEST4                       4
+#define TEST5A                      5
+#define TEST5B                      500
+#define TEST6                       6
+#define TEST7                       7
+
+#define TIMEOUT_TIMER_ID            55
+#define TEST6_TIMER_ID              56
+
+#define DEVSPEC_COMPLETEREQ         1
+#define DEVSPEC_PENDREQ             2
+#define DEVSPEC_COMPLPENDREQ        3
+
+#define TEST3_MAX_RECURSION_LEVEL   8
+#define TEST5_NUM_REPLIES_EXPECTED  2
+#define TEST6_MAX_PENDING_REQS      40
+
+#define IDD_DIALOG1                 1
+
+typedef struct _PENDING_REQUEST
+{
+    DWORD   dwRequestID;
+
+    BOOL    bCompleted;
+
+} PENDING_REQUEST, FAR *PPENDING_REQUEST;
diff --git a/private/tapi/qa/tpstress/tpstress.rc b/private/tapi/qa/tpstress/tpstress.rc
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/private/tapi/qa/tpstress/tpstress.rc
diff --git a/private/tapi/qa/trapper/apilist.xls b/private/tapi/qa/trapper/apilist.xls
new file mode 100644
index 000000000..f70caffd5
--- /dev/null
+++ b/private/tapi/qa/trapper/apilist.xls
diff --git a/private/tapi/qa/trapper/dirs b/private/tapi/qa/trapper/dirs
new file mode 100644
index 000000000..73bbf0f61
--- /dev/null
+++ b/private/tapi/qa/trapper/dirs
@@ -0,0 +1,24 @@
+!IF 0
+
+Copyright (c) 1989-92  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    Steve Wood (stevewo) 17-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\dirs.tpl
+
+!ENDIF
+
+DIRS= itest\
+      trapper 
diff --git a/private/tapi/qa/trapper/fiesta.xls b/private/tapi/qa/trapper/fiesta.xls
new file mode 100644
index 000000000..6fa903472
--- /dev/null
+++ b/private/tapi/qa/trapper/fiesta.xls
diff --git a/private/tapi/qa/trapper/itest/cline/cline.c b/private/tapi/qa/trapper/itest/cline/cline.c
new file mode 100644
index 000000000..91c93deaa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/cline.c
@@ -0,0 +1,316 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    cline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "cline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghCLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+CLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghCLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAddToConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetConfRelatedCalls(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePrepareAddToConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRemoveFromConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetupConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineCompleteCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRedirect(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSecureCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSwapHold(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiGetLocationInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestDrop(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestMakeCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestMediaCall(TRUE, FALSE));
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/cline.def b/private/tapi/qa/trapper/itest/cline/cline.def
new file mode 100644
index 000000000..0cdc5ec34
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/cline.def
@@ -0,0 +1,24 @@
+LIBRARY         cline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+
diff --git a/private/tapi/qa/trapper/itest/cline/cline.h b/private/tapi/qa/trapper/itest/cline/cline.h
new file mode 100644
index 000000000..820fcd1be
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/cline.h
@@ -0,0 +1,183 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    cline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding 		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef CLINE_H
+#define CLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineAddToConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetConfRelatedCalls(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePrepareAddToConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRemoveFromConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetupConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineCompleteCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRedirect(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineSecureCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSwapHold(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestTapiGetLocationInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTapiRequestDrop(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestTapiRequestMakeCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestTapiRequestMediaCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+
+
+#endif  // CLINE_H
diff --git a/private/tapi/qa/trapper/itest/cline/cline.rc b/private/tapi/qa/trapper/itest/cline/cline.rc
new file mode 100644
index 000000000..c8dae99fb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/cline.rc
@@ -0,0 +1,13 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI CLine API test Library"
+#define VER_INTERNALNAME_STR        "cline.dll"
+#define VER_ORIGINALFILENAME_STR    "cline.dll"
+
+#include "common.ver"
+
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlatc.c b/private/tapi/qa/trapper/itest/cline/itlatc.c
new file mode 100644
index 000000000..bb3e9b444
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlatc.c
@@ -0,0 +1,242 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlatc.c
+
+Abstract:
+
+    This module contains the test functions for lineAddToConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineAddToConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAddToConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineAddToConference");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+   fUnimdm = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+	if(fEsp)
+	{
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(fUnimdm)
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineAddToConference for go/no-go");
+
+	
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported these apis");
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    return fTestPassed;
+	}
+	
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		sizeof (LINECALLLIST));
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	if(lpTapiLineTestInfo->lpCallList->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallList->dwNeededSize)
+	{
+		dwSize = lpTapiLineTestInfo->lpCallList->dwNeededSize;
+      FreeTestHeap();
+		lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+			dwSize);
+		lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+		if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+/*
+	for(n=0; n< (INT)lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+*/
+			
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineAddToConference Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineAddToConference Test Failed");
+	
+
+	return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlcc.c b/private/tapi/qa/trapper/itest/cline/itlcc.c
new file mode 100644
index 000000000..2da2301b6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlcc.c
@@ -0,0 +1,203 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcc.c
+
+Abstract:
+
+    This module contains the test functions for lineCompleteCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineCompleteCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineCompleteCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineCompleteCall");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineCompleteCall for go/no-go");
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	lpTapiLineTestInfo->dwMessageID = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->dwCompletionID);		
+	
+	// call linecallinfo to verify the comepletion
+   
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap (
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCompletionID);		
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineCompleteCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineCompleteCall Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlgcrc.c b/private/tapi/qa/trapper/itest/cline/itlgcrc.c
new file mode 100644
index 000000000..605e1ed6a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlgcrc.c
@@ -0,0 +1,246 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgcrc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetConfRelatedCalls
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineGetConfRelatedCalls
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetConfRelatedCalls(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetConfRelatedCalls");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+   fUnimdm = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	
+	if(fEsp)
+	{
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(fUnimdm)
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported these apis");
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    return fTestPassed;
+	}
+	
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetConfRelatedCalls for go/no-go");
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		sizeof (LINECALLLIST));
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	if(lpTapiLineTestInfo->lpCallList->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallList->dwNeededSize)
+	{
+		dwSize = lpTapiLineTestInfo->lpCallList->dwNeededSize;
+	   FreeTestHeap();
+		lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+			dwSize);
+		lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+		if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+/*
+	for(n=0; n< (INT)lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+  */			
+		
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetConfRelatedCalls Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetConfRelatedCalls Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlpatc.c b/private/tapi/qa/trapper/itest/cline/itlpatc.c
new file mode 100644
index 000000000..d2b8c7ae7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlpatc.c
@@ -0,0 +1,260 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpatc.c
+
+Abstract:
+
+    This module contains the test functions for linePrepareAddToConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  linePrepareAddToConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePrepareAddToConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test linePrepareAddToConference");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+   fUnimdm = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	
+
+
+	if(fEsp)
+	{
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported these apis");
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    return fTestPassed;
+	}
+	
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test linePrepareAddToConference for go/no-go");
+
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+	
+	if(fEsp)
+	{	
+	if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		sizeof (LINECALLLIST));
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	if(lpTapiLineTestInfo->lpCallList->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallList->dwNeededSize)
+	{
+		dwSize = lpTapiLineTestInfo->lpCallList->dwNeededSize;
+	    FreeTestHeap();
+		lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+			dwSize);
+		lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+		if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+/*
+	for(n=0; n< (INT) lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+  */			
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePrepareAddToConference Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePrepareAddToConference Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlrd.c b/private/tapi/qa/trapper/itest/cline/itlrd.c
new file mode 100644
index 000000000..d4790d44f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlrd.c
@@ -0,0 +1,181 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrd.c
+
+Abstract:
+
+    This module contains the test functions for lineRedirect
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineRedirect
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRedirect(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineRedirect");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineRedirect for go/no-go");
+
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineRedirect(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRedirect Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRedirect Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlrfc.c b/private/tapi/qa/trapper/itest/cline/itlrfc.c
new file mode 100644
index 000000000..a648abb13
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlrfc.c
@@ -0,0 +1,272 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrfc.c
+
+Abstract:
+
+    This module contains the test functions for lineRemoveFromConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineRemoveFromConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRemoveFromConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineRemoveFromConference");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+   fUnimdm = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	
+	if(fEsp)
+	{
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported these apis");
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    return fTestPassed;
+	}
+	
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineRemoveFromConference for go/no-go");
+
+	
+	if(fEsp)
+	{	
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+	if(fEsp)
+	{	
+	if (! DoLineRemoveFromConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineRemoveFromConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		sizeof (LINECALLLIST));
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	if(lpTapiLineTestInfo->lpCallList->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallList->dwNeededSize)
+	{
+		dwSize = lpTapiLineTestInfo->lpCallList->dwNeededSize;
+	    FreeTestHeap();
+		lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+			dwSize);
+		lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+		if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+/*
+	for(n=0; n<(INT)lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+  */			
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRemoveFromConference Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRemoveFromConference Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlsc.c b/private/tapi/qa/trapper/itest/cline/itlsc.c
new file mode 100644
index 000000000..408bffd96
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlsc.c
@@ -0,0 +1,180 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsc.c
+
+Abstract:
+
+    This module contains the test functions for lineSecureCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineSecureCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSecureCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSecureCall");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSecureCall for go/no-go");
+
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineSecureCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSecureCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	// how to verify the call be secured?
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSecureCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSecureCall Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlsh.c b/private/tapi/qa/trapper/itest/cline/itlsh.c
new file mode 100644
index 000000000..b9d0a5f9d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlsh.c
@@ -0,0 +1,263 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsh.c
+
+Abstract:
+
+    This module contains the test functions for lineSwapHold
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineSwapHold
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSwapHold(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSwapHold");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+   fUnimdm = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported it, return.");
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    return fTestPassed;
+	}
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSwapHold for go/no-go");
+
+
+	// Make second call at same line
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+	lpTapiLineTestInfo->lpCallStatus = (LPLINECALLSTATUS) AllocFromTestHeap (
+		sizeof(LINECALLSTATUS));
+	lpTapiLineTestInfo->lpCallStatus->dwTotalSize = sizeof(LINECALLSTATUS);
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Before: Active: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+	
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Hold: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+	
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSwapHold for go/no-go");
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineSwapHold(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	// Verify the swap
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: Active: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+	
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Hold: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+	}
+	else
+	{	
+	if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+		
+		 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSwapHold Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSwapHold Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/itlsuc.c b/private/tapi/qa/trapper/itest/cline/itlsuc.c
new file mode 100644
index 000000000..becf1ec14
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/itlsuc.c
@@ -0,0 +1,179 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsuc.c
+
+Abstract:
+
+    This module contains the test functions for lineSetupConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineSetupConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetupConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetupConference");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetupConference for go/no-go");
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetupConference Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetupConference Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/ittgli.c b/private/tapi/qa/trapper/itest/cline/ittgli.c
new file mode 100644
index 000000000..0a34019d5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/ittgli.c
@@ -0,0 +1,112 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittgli.c
+
+Abstract:
+
+    This module contains the test functions for tapiGetLocationInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiGetLocationInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiGetLocationInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwCountrySize, dwCitySize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiGetLocationInfo");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiGetLocationInfo for go/no-go");
+
+	dwCountrySize = 16;
+	dwCitySize = 16;
+   lpTapiLineTestInfo->lpszCountryCode = AllocFromTestHeap(dwCountrySize);
+   lpTapiLineTestInfo->lpszCityCode = AllocFromTestHeap(dwCitySize);
+
+	if (! DoTapiGetLocationInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+	
+	(lpTapiLineTestInfo->lpszCountryCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCountryCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCountryCode = %s",
+			lpTapiLineTestInfo->lpszCountryCode);		
+ 
+	(lpTapiLineTestInfo->lpszCityCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCityCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCityCode = %s",
+			lpTapiLineTestInfo->lpszCityCode);		
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiGetLocationInfo Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiGetLocationInfo Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/ittrd.c b/private/tapi/qa/trapper/itest/cline/ittrd.c
new file mode 100644
index 000000000..018cfa4b6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/ittrd.c
@@ -0,0 +1,91 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrd.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestDrop
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiRequestDrop
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestDrop(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiRequestDrop");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiRequestDrop for go/no-go");
+
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+
+	if (! DoTapiRequestDrop(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+       {
+			fTestPassed = FALSE;
+       }
+
+ 
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestDrop Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestDrop Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/ittrmc.c b/private/tapi/qa/trapper/itest/cline/ittrmc.c
new file mode 100644
index 000000000..0fb493e66
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/ittrmc.c
@@ -0,0 +1,191 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrmc.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestMakeCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiRequestMakeCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestMakeCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiRequestMakeCall");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiRequestMakeCall for go/no-go");
+																
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->dwMediaMode = 0;
+	lpTapiLineTestInfo->dwRequestMode =  LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpszAppFilename = "cline test";
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+        sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwPriority = 1;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+  
+
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)"cline test";
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+	
+	if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	for(n=0; n<10; n++)
+     {
+	  if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			TLINE_FAIL();
+       }
+     }
+
+	for(n=0; n<10; n++)
+     {
+	   if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			TLINE_FAIL();
+       }
+     }
+    if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOREQUEST))
+      {
+ 		TLINE_FAIL();
+      }
+ 
+   
+   lpTapiLineTestInfo->dwMediaMode = 0;
+	lpTapiLineTestInfo->dwRequestMode =  LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpszAppFilename = "cline test";
+   lpTapiLineTestInfo->dwPriority = 0;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+   FreeTestHeap();
+
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMakeCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMakeCall Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/ittrmec.c b/private/tapi/qa/trapper/itest/cline/ittrmec.c
new file mode 100644
index 000000000..779da95b9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/ittrmec.c
@@ -0,0 +1,98 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrmec.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestMediaCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiRequestMediaCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestMediaCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiRequestMediaCall");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiRequestMediaCall for go/no-go");
+
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+   lpTapiLineTestInfo->lpszDeviceClass = "line/tapi";
+   lpTapiLineTestInfo->lpDeviceID = 0;
+   lpTapiLineTestInfo->dwSize = 0;
+   lpTapiLineTestInfo->dwSecure = 0;
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpszAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)"xxx";
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+	
+	if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+       {
+			fTestPassed = FALSE;
+       }
+
+ 
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMediaCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMediaCall Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/cline/makefile b/private/tapi/qa/trapper/itest/cline/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/cline/sources b/private/tapi/qa/trapper/itest/cline/sources
new file mode 100644
index 000000000..70fa6d746
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/cline/sources
@@ -0,0 +1,74 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=cline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x66000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	cline.c \
+		itlatc.c \
+		itlgcrc.c \
+		itlpatc.c  \
+		itlrfc.c  \
+		itlsuc.c \
+		itlcc.c	\
+		itlrd.c \
+		itlsc.c	\
+		itlsh.c	\
+		ittgli.c  \
+		ittrd.c  \
+		ittrmc.c  \
+		ittrmec.c \
+		cline.rc
+
+		
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=CLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/dirs b/private/tapi/qa/trapper/itest/dirs
new file mode 100644
index 000000000..a7a66100a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/dirs
@@ -0,0 +1,23 @@
+DIRS= ttesta    \
+      ttestw    \
+      wline     \
+      phone     \
+      xline     \
+      yline     \
+      line      \
+      line20    \
+      iline     \
+      cline     \
+      sline     \
+      testapp   \
+      txline    \
+      tline20   \
+      tcline    \
+      tyline    \
+      tphone    \
+      wphone    \
+      tiline    \
+      tsline    \
+      testapp   \
+      uline
+
diff --git a/private/tapi/qa/trapper/itest/iline/iline.c b/private/tapi/qa/trapper/itest/iline/iline.c
new file mode 100644
index 000000000..34b1e2d33
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/iline.c
@@ -0,0 +1,335 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    iline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "iline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghILineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+ILineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghILineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAccept(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAnswer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineBlindTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineForward(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineReleaseUserUserInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSendUserUserInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetupTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineCompleteTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineNegotiateExtVersion(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineHold(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUnhold(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAppSpecific(TRUE, FALSE));
+}
+
+
+
+/*
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTest(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTestX(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTestY(TRUE, FALSE));
+}
+
+*/
diff --git a/private/tapi/qa/trapper/itest/iline/iline.def b/private/tapi/qa/trapper/itest/iline/iline.def
new file mode 100644
index 000000000..9c3b5dcb0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/iline.def
@@ -0,0 +1,22 @@
+LIBRARY         iline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
diff --git a/private/tapi/qa/trapper/itest/iline/iline.h b/private/tapi/qa/trapper/itest/iline/iline.h
new file mode 100644
index 000000000..294d279fc
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/iline.h
@@ -0,0 +1,200 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    iline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef ILINE_H
+#define ILINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineAccept(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineAnswer(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineBlindTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineForward(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineReleaseUserUserInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSendUserUserInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetupTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineCompleteTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineNegotiateExtVersion(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineHold(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineUnhold(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineSetAppSpecific(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+
+/*
+BOOL
+TestLineTest(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineTestX(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineTestY(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+*/
+
+
+
+
+#endif  // ILINE_H
diff --git a/private/tapi/qa/trapper/itest/iline/iline.rc b/private/tapi/qa/trapper/itest/iline/iline.rc
new file mode 100644
index 000000000..9c540ebba
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/iline.rc
@@ -0,0 +1,13 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI ILine API test Library"
+#define VER_INTERNALNAME_STR        "iline.dll"
+#define VER_ORIGINALFILENAME_STR    "iline.dll"
+
+#include "common.ver"
+
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlac.c b/private/tapi/qa/trapper/itest/iline/itlac.c
new file mode 100644
index 000000000..5a2d3c879
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlac.c
@@ -0,0 +1,254 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlac.c
+
+Abstract:
+
+    This module contains the test functions for lineAccept
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineAccept
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAccept(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+ 	LPTAPIMSG lpTapiMsg = NULL;
+   LPTAPIMSG lpMatch;
+	LONG lret;
+	LPTAPIMSG lpMsg;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineAccept");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"lineAccept did not work for Unimodem.  Please manuly test it");
+	    // Shutdown and end the tests
+   	 if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+	    {
+   	     TLINE_FAIL();
+	    }
+	    return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+//	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+	_itoa(lpTapiLineTestInfo->dwDeviceID, 
+		  lpTapiLineTestInfo->lpszDestAddress,
+		  10);	 
+
+//	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)lpTapiLineTestInfo->dwDeviceID;
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+	lret = WaitForAllMessages();
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									 
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_CALLSTATE;
+	lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+	lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+   if(lret == 1)
+	{
+ 	*lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+	}
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"lret = %lx, New hCall = %lx", 
+		lret, 
+		*lpTapiLineTestInfo->lphCall);
+	
+	// Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineAccept for go/no-go");
+
+
+	lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+   lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineAccept(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: dwUserUserInfoSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+	if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+	{
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"#### lpUserUserInfo = %s",
+			((LPBYTE)lpTapiLineTestInfo->lpCallInfo) + 
+						lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	}
+
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAccept Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAccept Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlas.c b/private/tapi/qa/trapper/itest/iline/itlas.c
new file mode 100644
index 000000000..8f3e0bf81
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlas.c
@@ -0,0 +1,250 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlas.c
+
+Abstract:
+
+    This module contains the test functions for lineAnswer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineAnswer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAnswer(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+   LPTAPIMSG lpMatch;
+	
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineAnswer");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"lineAnswer did not work for Unimodem.  Please manuly test it");
+	    // Shutdown and end the tests
+   	 if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+	    {
+   	     TLINE_FAIL();
+	    }
+	    return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+//	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+	_itoa(lpTapiLineTestInfo->dwDeviceID, 
+		  lpTapiLineTestInfo->lpszDestAddress,
+		  10);	 
+
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+	WaitForAllMessages();
+
+
+	// Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+
+	lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_CALLSTATE;
+	lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+	lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+   if(lret == 1)
+	{
+ 	*lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+	}																					
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"lret = %lx, New hCall = %lx", 
+		lret, 
+		*lpTapiLineTestInfo->lphCall);
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineAnswer for go/no-go");
+
+	lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+   lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineAnswer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: dwUserUserInfoSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+	if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+	{
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"#### lpUserUserInfo = %s",
+			((LPBYTE)lpTapiLineTestInfo->lpCallInfo) + 
+						lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	}
+
+ 	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAnswer Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAnswer Test Failed");
+ 
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlbt.c b/private/tapi/qa/trapper/itest/iline/itlbt.c
new file mode 100644
index 000000000..8886de9e4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlbt.c
@@ -0,0 +1,179 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlbt.c
+
+Abstract:
+
+    This module contains the test functions for lineBlindTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineBlindTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineBlindTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineBlindTransfer");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineBlindTransfer for go/no-go");
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineBlindTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineBlindTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineBlindTransfer Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineBlindTransfer Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlct.c b/private/tapi/qa/trapper/itest/iline/itlct.c
new file mode 100644
index 000000000..6feafb7fe
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlct.c
@@ -0,0 +1,198 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlct.c
+
+Abstract:
+
+    This module contains the test functions for lineCompleteTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineCompleteTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineCompleteTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEspFlag, fUnimdmFlag;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineCompleteTransfer");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+ 
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	fEspFlag = TRUE;
+	fUnimdmFlag = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEspFlag = FALSE;
+	fUnimdmFlag = TRUE;
+	}
+	else
+	{
+	fEspFlag = FALSE;
+	fUnimdmFlag = FALSE;
+	}
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(fEspFlag)
+	{
+	if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(fUnimdmFlag)
+	{
+	if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineCompleteTransfer for go/no-go");
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+	if(fEspFlag)
+	{
+	if (! DoLineCompleteTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(fUnimdmFlag)
+	{
+	if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineCompleteTransfer Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineCompleteTransfer Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlfw.c b/private/tapi/qa/trapper/itest/iline/itlfw.c
new file mode 100644
index 000000000..172006665
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlfw.c
@@ -0,0 +1,186 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlfw.c
+
+Abstract:
+
+    This module contains the test functions for lineForward
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineForward
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineForward(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineForward");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->bAllAddresses = TRUE;
+	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+	lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+	lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+	lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineForward for go/no-go");
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+		
+	lpTapiLineTestInfo->lpLineAddressStatus = (LPLINEADDRESSSTATUS) AllocFromTestHeap (
+			sizeof(LINEADDRESSSTATUS));
+	lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = sizeof(LINEADDRESSSTATUS);
+
+	if (! DoLineGetAddressStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+  
+     }
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineForward Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineForward Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlh.c b/private/tapi/qa/trapper/itest/iline/itlh.c
new file mode 100644
index 000000000..d93c71172
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlh.c
@@ -0,0 +1,222 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlh.c
+
+Abstract:
+
+    This module contains the test functions for lineHold
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "iline.h"
+
+
+//  lineHold
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Valid test case (with ESP)
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//
+
+BOOL TestLineHold(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    DWORD               dwESPDeviceID;
+    INT                 n;
+    BOOL                fResult;
+    BOOL                fTestPassed       = TRUE;
+    BOOL fEspFlag = TRUE;
+
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_UNKNOWN;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwAPILowVersion     = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion    = HIGH_APIVERSION;
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    // Open a line with LINECALLPRIVILEGE_OWNER
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_NONE;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineHold  <<<<<<<<"
+            );
+            
+    // Test uninitialized state    
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case : uninitialized state");
+
+        if (! DoLineHold(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED,
+                FALSE
+                ))
+        {
+            TLINE_FAIL();
+        }
+
+    }
+
+
+    // Place a call on hold and verify ONHOLD state message is sent
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case : valid params and state and verify\r\n" \
+            ">> LINECALLSTATE/ONHOLD message is sent"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    // Initialize and Negotiate, then find an ESP device that
+    // supports lineHold
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! FindESPLineDevice(lpTapiLineTestInfo))
+    {
+       fEspFlag = FALSE;
+       lpTapiLineTestInfo->dwDeviceID = 0;
+       TLINE_FAIL();
+       fTestPassed = TRUE;
+    }
+    dwESPDeviceID = lpTapiLineTestInfo->dwDeviceID;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Put the call on hold
+    if(fEspFlag)
+    {
+    if (! (fResult = DoLineHold(lpTapiLineTestInfo, TAPISUCCESS, FALSE)))
+    {
+        TLINE_FAIL();
+    }
+
+    // Verify that the LINE_CALLSTATE/ONHOLD message is sent when the call is
+    // is put on hold
+    if (fResult)
+    {
+        AddMessage(
+                LINE_CALLSTATE,
+                (DWORD) *lpTapiLineTestInfo->lphCall,
+                (DWORD) lpCallbackParams,
+                LINECALLSTATE_ONHOLD,
+                0x0,
+                0x0,
+                TAPIMSG_ALL
+                );
+    }
+
+    // Wait for the async reply
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    if (! DoLineUnhold(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	 }
+    else
+    {
+    if (! (fResult = DoLineHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE)))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+
+
+    // Take the call off hold
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Free the memory taken from the heap
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineHold Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineHold Test Failed");
+
+ 
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineHold  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlnev.c b/private/tapi/qa/trapper/itest/iline/itlnev.c
new file mode 100644
index 000000000..9f18516b9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlnev.c
@@ -0,0 +1,212 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlnev.c
+
+Abstract:
+
+    This module contains the test functions for lineNegotiateExtVersion
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "iline.h"
+
+
+//  lineNegotiateExtVersion
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//  LINEERR_BADDEVICEID             Y
+//  LINEERR_INCOMPATIBLEAPIVERSION  Y
+//  LINEERR_INCOMPATIBLEEXTVERSION  Y    High/Low both too high tested
+//                                       High/Low invalide and flipped tested
+//                                       High/Low each invalid -- both tested
+//  LINEERR_INVALAPPHANDLE          Y
+//  LINEERR_INVALPOINTER            Y
+//  LINEERR_NOMEM
+//  LINEERR_NODEVICE
+//  LINEERR_NODRIVER
+//  LINEERR_OPERATIONFAILED
+//  LINEERR_RESOURCEUNAVAIL
+//  LINEERR_UNINITIALIZED
+//  LINEERR_OPERATIONUNAVAIL
+//
+//  Valid Cases                     Y
+//
+//  hLineApp                        Y
+//  dwDeviceID                      Y
+//  dwAPIVersion                    Y
+//  dwExtLowVersion                 Y
+//  dwExtHighVersion                Y
+//  lpdwExtVersion                  Y
+
+BOOL TestLineNegotiateExtVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+
+    BOOL fTestPassed                  = TRUE;
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineNegotiateExtVersion");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+   lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+   lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	 if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   }
+   else
+   {
+	 if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+   }
+
+
+/*
+    // Try invalid higher version...low version still ok
+    lpTapiLineTestInfo->dwExtHighVersion = BAD_EXTVERSION;
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLNEV_FAIL();
+    }
+    lpTapiLineTestInfo->dwExtHighVersion  = GOOD_EXTVERSION;
+
+    // Flip high and low extension version parameters.
+    // Also, make the high parameter too low to be valid and the low too high.
+    // This checks that the low is being checked as the low version and the
+    // high is being checked as the high version.
+    lpTapiLineTestInfo->dwExtLowVersion  = BAD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = BAD_EXTVERSION;
+    if (! DoLineNegotiateExtVersion(
+                         lpTapiLineTestInfo,
+                         LINEERR_INCOMPATIBLEEXTVERSION
+                         ))
+    {
+        ITLNEV_FAIL();
+    }
+    lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+    // Check low and high extension versions that are both too high
+    lpTapiLineTestInfo->dwExtLowVersion  = BAD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = BAD_EXTVERSION;
+    if (! DoLineNegotiateExtVersion(
+                         lpTapiLineTestInfo,
+                         LINEERR_INCOMPATIBLEEXTVERSION
+                         ))
+    {
+        ITLNEV_FAIL();
+    }
+    lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+    // Check bad device ID
+    lpTapiLineTestInfo->dwDeviceID = INVLD_DWDEVICEID;
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        ITLNEV_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = dwDeviceID;
+
+    // Check invalid line app handle
+    hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    *lpTapiLineTestInfo->lphLineApp = INVLD_HLINEAPP;
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+    {
+        ITLNEV_FAIL();
+    }
+    *lpTapiLineTestInfo->lphLineApp = hLineApp_Orig;
+
+    // Check null lpdwExtVersion pointer
+    lpTapiLineTestInfo->lpdwExtVersion = NULL;
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+    {
+        ITLNEV_FAIL();
+    }
+    TapiLineTestInfo.lpdwExtVersion = &dwExtVersion;
+
+    // Check incompatible API Version
+    dwAPIVersion_Orig = *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineNegotiateExtVersion(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        ITLNEV_FAIL();
+    }
+    *lpTapiLineTestInfo->lpdwAPIVersion = dwAPIVersion_Orig;
+    
+*/
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineNegotiateExtVersion Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineNegotiateExtVersion Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlruui.c b/private/tapi/qa/trapper/itest/iline/itlruui.c
new file mode 100644
index 000000000..761c88409
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlruui.c
@@ -0,0 +1,195 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlruui.c
+
+Abstract:
+
+    This module contains the test functions for lineReleaseUserUserInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineReleaseUserUserInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineReleaseUserUserInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineReleaseUserUserInfo");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineReleaseUserUserInfo for go/no-go");
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: dwUserUserInfoSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineReleaseUserUserInfo Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineReleaseUserUserInfo Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlsas.c b/private/tapi/qa/trapper/itest/iline/itlsas.c
new file mode 100644
index 000000000..538367d52
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlsas.c
@@ -0,0 +1,242 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsas.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAppSpecific
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "iline.h"
+
+
+#define DWAPPSPECIFICVALUE 0x12349876
+
+
+//  lineSetAppSpecific
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Verify dwAppSpecific field of LINECALLINFO structure is set
+//     3)  Verify LINECALLINFO/APPSPECIFIC message is sent to other apps
+//         that have call handles
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//
+
+BOOL TestLineSetAppSpecific(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT                 n;
+    BOOL                fResult;
+    BOOL                fTestPassed       = TRUE;
+
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_UNKNOWN;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetAppSpecific  <<<<<<<<"
+            );
+            
+    // Test uninitialized state    
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case : uninitialized state");
+
+        if (! DoLineSetAppSpecific(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+
+    }
+
+    // Try a valid test case
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case : valid params and state");
+
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    // InitializeEx a line app
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the API version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with LINECALLPRIVILEGE_OWNER
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Make a call
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Set the dwAppSpecific field and verify it was set
+    lpTapiLineTestInfo->dwAppSpecific = DWAPPSPECIFICVALUE;
+    if (! DoLineSetAppSpecific(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case : Verify dwAppSpecific field was updated correctly");
+
+    // Call lineGetCallInfo and verify that the dwAppSpecific field of
+    // the LINECALLINFO structure has been updated.
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+            sizeof(LINECALLINFO)
+            );
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (lpTapiLineTestInfo->lpCallInfo->dwAppSpecific != DWAPPSPECIFICVALUE)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_FAILURE,
+                "!> dwAppSpecific field was not updated correctly");
+
+        TLINE_FAIL();
+    }
+
+
+    // Verify that the LINE_CALLINFO/APPSPECIFIC message is sent to another
+    // app that has a call handle for this call
+    AddMessage(
+            LINE_CALLINFO,
+            0x0,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_APPSPECIFIC,
+            0x0,
+            0x0,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the async reply
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Drop the call
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Deallocate the call
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the line and shutdown
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Free the memory taken from the heap
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAppSpecific Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAppSpecific Test Failed");
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetAppSpecific  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlst.c b/private/tapi/qa/trapper/itest/iline/itlst.c
new file mode 100644
index 000000000..cfd3869c0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlst.c
@@ -0,0 +1,182 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlst.c
+
+Abstract:
+
+    This module contains the test functions for lineSetupTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineSetupTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetupTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetupTransfer");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetupTransfer for go/no-go");
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetupTransfer Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetupTransfer Test Failed");
+ 
+ 	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itlsuui.c b/private/tapi/qa/trapper/itest/iline/itlsuui.c
new file mode 100644
index 000000000..938393084
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itlsuui.c
@@ -0,0 +1,208 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsuui.c
+
+Abstract:
+
+    This module contains the test functions for lineSendUserUserInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineSendUserUserInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSendUserUserInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSendUserUserInfo");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSendUserUserInfo for go/no-go");
+
+	lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+	lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+	lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: dwUserUserInfoSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+		lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+	if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+	{
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"#### lpUserUserInfo = %s",
+			((LPBYTE)lpTapiLineTestInfo->lpCallInfo) + 
+						lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	}
+
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSendUserUserInfo Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSendUserUserInfo Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/iline/itluh.c b/private/tapi/qa/trapper/itest/iline/itluh.c
new file mode 100644
index 000000000..7dd6e6528
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/itluh.c
@@ -0,0 +1,255 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itluh.c
+
+Abstract:
+
+    This module contains the test functions for lineUnhold
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "iline.h"
+
+
+//  lineUnhold
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized (called before any lines are initialized)
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//
+
+BOOL TestLineUnhold(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    DWORD               dwESPDeviceID;
+    INT                 n;
+    BOOL                fResult;
+    BOOL                fTestPassed       = TRUE;
+    BOOL fEspFlag = TRUE;
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_UNKNOWN;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwAPILowVersion     = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion    = HIGH_APIVERSION;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineUnhold  <<<<<<<<"
+            );
+            
+    // Test uninitialized state    
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case : uninitialized state");
+
+        if (! DoLineUnhold(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED,
+                FALSE
+                ))
+        {
+            TLINE_FAIL();
+        }
+
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case : valid params and state and verify\r\n" \
+            ">> LINECALLSTATE message is sent when line is taken off hold"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    // InitializeEx a line app
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the API version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Find an ESP device that supports Hold/Unhold
+    if (! FindESPLineDevice(lpTapiLineTestInfo))
+    {
+       fEspFlag = FALSE;
+       lpTapiLineTestInfo->dwDeviceID = 0;
+       TLINE_FAIL();
+       fTestPassed = TRUE;
+    }
+    dwESPDeviceID = lpTapiLineTestInfo->dwDeviceID;
+    
+    // Open a line with LINECALLPRIVILEGE_NONE
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_NONE;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Make a call
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Put the call on hold
+    if(fEspFlag)
+    {
+    if (! (fResult = DoLineHold(lpTapiLineTestInfo, TAPISUCCESS, FALSE)))
+    {
+        TLINE_FAIL();
+    }
+
+    // Verify that the LINE_CALLSTATE/ONHOLD message is sent when the call is
+    // is put on hold
+    if (fResult)
+    {
+        AddMessage(
+                LINE_CALLSTATE,
+                (DWORD) *lpTapiLineTestInfo->lphCall,
+                (DWORD) lpCallbackParams,
+                LINECALLSTATE_ONHOLD,
+                0x0,
+                0x0,
+                TAPIMSG_ALL
+                );
+    }
+
+    // Wait for the async reply
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Retrieve the held call
+    if (! DoLineUnhold(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Verify that a LINE_CALLSTATE message is sent notifying the owner of
+    // the current state the retrieved call is in.
+    if (fResult)
+    {
+        AddMessage(
+                LINE_CALLSTATE,
+                (DWORD) *lpTapiLineTestInfo->lphCall,
+                (DWORD) lpCallbackParams,
+                0x0,  // Call state might be connected or in another state
+                0x0,
+                0x0,
+                TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST
+                );
+    }
+
+    // Wait for the async reply
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    }
+    else
+    {
+    if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    }
+ 
+
+    // Drop the call
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Deallocate the call
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the line and shutdown
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Free the memory taken from the heap
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineUnhold Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineUnhold Test Failed");
+
+ 
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineUnhold  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/iline/makefile b/private/tapi/qa/trapper/itest/iline/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/iline/sources b/private/tapi/qa/trapper/itest/iline/sources
new file mode 100644
index 000000000..2f478eb06
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/iline/sources
@@ -0,0 +1,70 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=iline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x68000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	iline.c \
+		itlac.c \
+		itlas.c	\
+		itlbt.c	\
+		itlfw.c	\
+		itlruui.c \
+		itlsuui.c \
+		itlst.c	\
+		itlct.c \
+                itlnev.c \
+                itlh.c \
+                itluh.c \
+                itlsas.c \
+		iline.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=ILineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/line/dirs b/private/tapi/qa/trapper/itest/line/dirs
new file mode 100644
index 000000000..ed8aadd2c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/dirs
@@ -0,0 +1,3 @@
+DIRS= linea\
+      linew
+
diff --git a/private/tapi/qa/trapper/itest/line/itlc.c b/private/tapi/qa/trapper/itest/line/itlc.c
new file mode 100644
index 000000000..a4821928b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlc.c
@@ -0,0 +1,1541 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlc.c
+
+Abstract:
+
+    This module contains the test functions for lineClose
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tline.h"
+
+
+#define DWNUMCALLS 1
+
+// Macro for handling unexpected failures during the tests
+#define ITLC_FAIL()    {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                       }
+
+
+//  lineClose
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid hLines
+//     3)  Close line and close same line again
+//     4)  Verify LINE_LINEDEVSTATE/OPEN and CLOSE messages are received
+//         by a monitor on the same hLineApp
+//     5)  Verify LINE_LINEDEVSTATE/OPEN and CLOSE messages are received
+//         by a monitor on different hLineApps
+//     6)  Verify LINE_LINEDEVSTATE/OPEN and CLOSE messages are received
+//         by an owner on the same hLineApp
+//     7)  Verify LINE_LINEDEVSTATE/OPEN and CLOSE messages are received
+//         by an owner on different hLineApps
+//     8)  Verify LINE_CALLINFO/NUMMONITORS message sent to call owner
+//         if the monitor is closed on the same hLineApp as the owner
+//     9)  Verify LINE_CALLINFO/NUMMONITORS and LINE_CALLINFO/
+//         NUMOWNERINCR messages are sent when a monitor becomes a second
+//         owner.  Next, verify LINE_CALLINFO/NUMOWNERDECR message is
+//         sent when one of the owners is close (on same hLineApp)
+//    10)  Verify LINE_CALLINFO/NUMMONITORS message sent to call owner
+//         if the monitor is closed on different hLineApps as the owner
+//    11)  Verify LINE_CALLINFO/NUMMONITORS and LINE_CALLINFO/
+//         NUMOWNERINCR messages are sent when a monitor becomes a second
+//         owner.  Next, verify LINE_CALLINFO/NUMOWNERDECR message is
+//         sent when one of the owners is close (on different hLineApps)
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineClose(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+
+    BOOL fTestPassed                  = TRUE;
+    INT n;
+
+    InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineClose");
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    // Allocate more than enough to store a call handle
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 8;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineClose  <<<<<<<<"
+            );
+            
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized state", dwTestCase+1);
+        if (! DoLineClose(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            ITLC_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+
+    // Try closing a line before one has been opened
+    // Go ahead and initialize to prevent the possibility of an
+    // UNINITIALIZED error to be returned
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lineClose before line has been opened", dwTestCase+1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Try the close before a line has been opened
+    // lphLine is initialized to point to hLine1, so set it to an invalid
+    // value (e.g. the hLineApp value)
+    lpTapiLineTestInfo->hLine1 = (HLINE) *lpTapiLineTestInfo->lphLineApp;
+    if (! DoLineClose(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+    // Shutdown the line to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    
+    // Try a valid close with no active call handles
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid lineClose with no active calls", dwTestCase+1);
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Try the valid close with active call handles
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid lineClose with an active call process", dwTestCase+1);
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            | LMAKECALL
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+     lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+//    lpTapiLineTestInfo->lpLineDevCaps = AllocFromTestHeap(sizeof(LINEDEVCAPS));
+//    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL | LCLOSE
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Attempt to close the line again
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %d: Testing lineClose using hLine that was just closed", dwTestCase+1);
+    if (! DoLineClose(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+    {
+        ITLC_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+    
+    // Test some invalid line handles with at least one valid open line handle
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line handles", dwTestCase+1);
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineClose(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+        {
+            ITLC_FAIL();
+        }
+    }
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+
+    // Begin testing LINE_LINEDEVSTATE messages are sent.
+    // For the first test, open a line with monitor privilege.
+    // Set the status messages to allow LINE_LINEDEVSTATE/OPEN & CLOSE
+    // messages to be received by the monitor.  Open another monitor
+    // using the same hLineApp, and close the second monitor.  Verify
+    // that both the OPEN and CLOSE messages are sent.
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_LINEDEVSTATE/OPEN & CLOSE messages are\r\n" \
+            ">> received by monitor (on same hLineApp)", dwTestCase+1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Set the status messages to allow it to receive LINE_LINEDEVSTATE
+    // OPEN and CLOSE messages.
+    lpTapiLineTestInfo->dwLineStates    = LINEDEVSTATE_OPEN |
+                                          LINEDEVSTATE_CLOSE;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_ALL;
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Open a second monitor on with the same hLineApp
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/OPEN message to the list of expected
+    // messages
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_OPEN,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/OPEN message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Now close the second monitor and verify that LINE_LINEDEVSTATE/CLOSE
+    // is sent to the other monitor
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+
+    // Add the LINE_LINEDEVSTATE/CLOSE message to the list of expected
+    // messages
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_CLOSE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/CLOSE message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+        
+    // For the next test, open a second line with monitor privilege
+    // using the same line device but with a different hLineApp.
+    // Close the second monitor.  Verify that both the OPEN and
+    // CLOSE messages are sent to the other monitor.
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_LINEDEVSTATE/OPEN & CLOSE messages are\r\n" \
+            ">> received by monitor (on different hLineApp)", dwTestCase+1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Set the status messages to allow it to receive LINE_LINEDEVSTATE
+    // OPEN and CLOSE messages.
+    lpTapiLineTestInfo->dwLineStates    = LINEDEVSTATE_OPEN |
+                                          LINEDEVSTATE_CLOSE;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_ALL;
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the first hLineApp and hLine values
+    lpTapiLineTestInfo->hLineApp2 = *lpTapiLineTestInfo->lphLineApp;
+    lpTapiLineTestInfo->hLine2    = *lpTapiLineTestInfo->lphLine;
+
+    // Initialize another hLineApp
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Open a line with monitor privilege using a different hLineApp
+    // than the existing monitor (Use the same line device
+    // and device capabilities negotiated before.  Assume the device
+    // still exists and it's capabilities haven't changed).
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/OPEN message to the list of expected
+    // messages
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_OPEN,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/OPEN message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Now close the second monitor and verify that LINE_LINEDEVSTATE/CLOSE
+    // is sent to the other monitor
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/CLOSE message to the list of expected
+    // messages
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_CLOSE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/CLOSE message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Shutdown the hLineApp that was closed
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    // Close the first monitor and shutdown the line app instance
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Next test...initialize a line app and open a line with owner
+    // privilege.  Set the status messages for the owner to receive
+    // LINE_LINEDEVSTATE/OPEN and CLOSE.  Verify that OPEN and CLOSE
+    // messages are sent to the owner when another line is opened and
+    // and closed (using the same hLineApp).
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_LINEDEVSTATE/OPEN & CLOSE messages are\r\n" \
+            ">> received by owner (on same hLineApp)", dwTestCase +1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Set the status messages to allow it to receive LINE_LINEDEVSTATE
+    // OPEN and CLOSE messages.
+    lpTapiLineTestInfo->dwLineStates    = LINEDEVSTATE_OPEN |
+                                          LINEDEVSTATE_CLOSE;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_ALL;
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the first hLineApp and hLine values
+    lpTapiLineTestInfo->hLineApp2 = *lpTapiLineTestInfo->lphLineApp;
+    lpTapiLineTestInfo->hLine2    = *lpTapiLineTestInfo->lphLine;
+
+    // Open another line using the same hLineApp and verify a
+    // LINE_LINEDEVSTATE message is sent to the owner.
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/OPEN message to the list of expected
+    // messages
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_OPEN,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/OPEN message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Now close the second line and verify that LINE_LINEDEVSTATE/CLOSE
+    // is sent to the owner
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/CLOSE message to the list of expected
+    // messages
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_CLOSE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/CLOSE message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown the hLineApp to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // For the next test, open a second line with monitor privilege
+    // using the same line device but with a different hLineApp.
+    // Close the monitor.  Verify that both the OPEN and
+    // CLOSE messages are sent to the owner.
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_LINEDEVSTATE/OPEN & CLOSE messages are\r\n" \
+            ">> received by owner (on different hLineApp)", dwTestCase+1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Set the status messages to allow it to receive LINE_LINEDEVSTATE
+    // OPEN and CLOSE messages.
+    lpTapiLineTestInfo->dwLineStates    = LINEDEVSTATE_OPEN |
+                                          LINEDEVSTATE_CLOSE;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_ALL;
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the first hLineApp and hLine values
+    lpTapiLineTestInfo->hLineApp2 = *lpTapiLineTestInfo->lphLineApp;
+    lpTapiLineTestInfo->hLine2    = *lpTapiLineTestInfo->lphLine;
+
+    // Open another line using the same hLineApp and verify a
+    // LINE_LINEDEVSTATE message is sent to the owner.
+
+    // Initialize another hLineApp
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Open a line with monitor privilege using a different hLineApp
+    // than the owner (Use the same line device and device
+    // capabilities negotiated before.  Assume the device
+    // still exists and it's capabilities haven't changed).
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/OPEN message to the list of expected
+    // messages the owner should receive
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_OPEN,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/OPEN message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Now close the monitor and verify that LINE_LINEDEVSTATE/CLOSE
+    // is sent to the owner
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Add the LINE_LINEDEVSTATE/CLOSE message to the list of expected
+    // messages the owner should receive
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine2,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_CLOSE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+    // Wait for the LINE_LINEDEVSTATE/CLOSE message
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Shutdown the hLineApp that was closed
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    // Close the owner and shutdown the line app instance
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+
+    // Verify that the LINE_CALLINFO/NUMMONITORS message is sent to
+    // a call owner when a monitor on the same line is closed.
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMMONITORS message is\r\n" \
+            ">> received by owner after closing a monitor (on same hLineApp)", dwTestCase+1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store line handle from the owner line before opening the 
+    // second line with monitor privilege
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+
+    // Make a call with the owner (hLine2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        ITLC_FAIL();
+    }
+
+    // Open another line (using the same hLineApp and device) with
+    // monitor privilege
+
+    // Store the call handle for the owner with hLine2 and hLineApp2
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    // Verify LINECALLINFO/NUMMONITORS message is sent to the owner
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Now close the line and see if another LINE_CALLINFO/NUMMONITORS
+    // message is sent to the owner (hLine2, hCall2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+
+    // Close and shutdown to isolate the test case
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    // Now test (using the same call and owner) with a monitor opened
+    // using a different line app instance
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMMONITORS message is received\r\n" \
+            ">> by owner after closing a monitor (on different hLineApp)", dwTestCase+1
+            );
+
+//    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    // XYD, it should be hLineApp2 
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store line handle from the owner line before opening the 
+    // second line with monitor privilege
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+
+    // Make a call with the owner (hLine2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        ITLC_FAIL();
+    }
+
+    // Open another line (using a different hLineApp) with
+    // monitor privilege
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    // Verify LINECALLINFO/NUMMONITORS message is sent to the owner
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Now close the line and see if another LINE_CALLINFO/NUMMONITORS
+    // message is sent to the owner (hLine2, hCall2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Close and shutdown to isolate the test case
+
+    // First, shutdown the closed monitor's hLineApp
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Second, clean up and remove the owner
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine    = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall    = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    // Verify LINE_CALLINFO/NUMOWNERINCR & NUMMONITORS msg is sent
+    // to the owner of a call when a monitor becomes an owner
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMOWNERINCR & NUMMONITORS msg is\r\n" \
+            ">> received by owner after changing a monitor\r\n" \
+            ">> to an owner (on same hLineApp)", dwTestCase+1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store line handle from the owner line before opening the 
+    // second line with monitor privilege
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+
+    // Make a call with the owner (hLine2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        ITLC_FAIL();
+    }
+
+    // Open another line (using the same hLineApp and device) with
+    // monitor privilege
+
+    // Store the call handle for the owner with hLine2 and hLineApp2
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    // Verify LINECALLINFO/NUMMONITORS message is sent to the owner
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Make the monitor an owner and verify the proper message is sent to
+    // the original owner.
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    if (DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        AddMessage(
+                LINE_CALLINFO,
+                (DWORD) lpTapiLineTestInfo->hCall2,
+                (DWORD) lpCallbackParams,
+                LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERINCR,
+                0x00000000,
+                0x00000000,
+                TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+                );
+
+        if (! WaitForAllMessages())
+        {
+            ITLC_FAIL();
+        }
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Verify LINE_CALLINFO/NUMOWNERDECR msg is received \r\n" \
+            ">> by owner after removing an owner (on same hLineApp)\r\n"
+            );
+
+        // Close the second owner and check for NUMOWNERDECR message
+        if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            ITLC_FAIL();
+        }
+
+        AddMessage(
+                LINE_CALLINFO,
+                (DWORD) lpTapiLineTestInfo->hCall2,
+                (DWORD) lpCallbackParams,
+                LINECALLINFOSTATE_NUMOWNERDECR,
+                0x00000000,
+                0x00000000,
+                TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+                );
+
+        if (! WaitForAllMessages())
+        {
+            ITLC_FAIL();
+        }
+    }
+    else
+    {
+        ITLC_FAIL();
+    }
+    
+    // Close and shutdown to isolate the test case
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Verify LINE_CALLINFO/NUMOWNERINCR & NUMMONITORS msg and
+    // LINE_CALLINFO/NUMOWNERDECR are sent to owner
+    // on different hLineApp
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMOWNERINCR & NUMMONITORS msg is received\r\n" \
+            ">> by owner after changing a monitor to an owner\r\n" \
+            ">> (on different hLineApp)", dwTestCase+1
+            );
+
+    // XYD, hLineApp should be 2
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+//    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store line handle from the owner line before opening the 
+    // second line with monitor privilege
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+
+    // Make a call with the owner (hLine2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        ITLC_FAIL();
+    }
+
+
+    // Open another line (using a different hLineApp) with
+    // monitor privilege
+    
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+
+    // Verify LINECALLINFO/NUMMONITORS message is sent to the owner
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+
+    // Make the monitor an owner
+    // XYD add, before call, must set hCall to hCall1
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+    
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERINCR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Verify LINE_CALLINFO/NUMOWNERDECR msg is received \r\n" \
+        ">> by owner after removing an owner (on different hLineApp)\r\n"
+        );
+
+    // Now close the line and see if LINE_CALLINFO/NUMOWNERDECR
+    // message is sent to the owner (hLineApp2, hLine2, hCall2)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMOWNERDECR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        ITLC_FAIL();
+    }
+
+    // Close and shutdown to isolate the test case
+
+    // First, shutdown the closed monitor's hLineApp
+    // XYD 2/27/96
+//    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        ITLC_FAIL();
+    }
+
+    // Second, clean up and remove the owner
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine    = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall    = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        ITLC_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    //  Test Case: generate a LINE_CLOSE message and try to open
+    //                the line device again.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld : Generate LINE_CLOSE msg and try to open"
+        " hLine -- should succeed",
+        dwTestCase+1);
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = LINE_CLOSE;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = &info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the LINESTATE_CLOSE message to the list of expected
+    // messages.
+    //
+
+    AddMessage(LINE_CLOSE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               0x00000000,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG));
+
+    if(!DoLineDevSpecific(lpTapiLineTestInfo,TAPISUCCESS,TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TLINE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "TestLineClose: Did not receive LINE_CLOSE message.");
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+  
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineClose: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineClose  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itldc.c b/private/tapi/qa/trapper/itest/line/itldc.c
new file mode 100644
index 000000000..af61978f7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itldc.c
@@ -0,0 +1,523 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itldc.c
+
+Abstract:
+
+    This module contains the test functions for lineDeallocateCall
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define DWNUMCALLS 1
+
+
+//  lineDeallocateCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+// x*  1)  Uninitialized
+// x   2)  Invalid hCalls
+// x   3)  Deallocate when sole owner and not idle
+//         It is allowed now.
+// x   4)  Verify hCall no longer valid by deallocating a second time
+// x   5)  Verify LINE_CALLINFO/NUMMONITORS sent to call owner after
+//         deallocating a monitor
+//     6)  Verify LINE_CALLINFO/NUMMONITORS & NUMOWNERINCR sent
+//         to call owner when the number of owners is incremented
+//     7)  Verify LINE_CALLINFO/NUMOWNERDECR msg sent to call owner when
+//         the number of owners is decremented
+//     8)  Verify deallocation does not affect the call state of the
+//         physical call
+//
+
+BOOL TestLineDeallocateCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT n;
+    BOOL fResult;
+    BOOL fTestPassed                        = TRUE;
+    ESPDEVSPECIFICINFO info;
+
+
+    InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineDeallocateCall  <<<<<<<<"
+            );
+            
+    // Test uninitialized if this is the only TAPI app running
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineDeallocateCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Start with invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1);
+
+    // Init and open a line
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Get the device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    // Allocate more than enough to store the call handle
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 1;
+    
+    // Open a line with owner privilege
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//        lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    // Try a set of invalid call handles
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineDeallocateCall(
+                lpTapiLineTestInfo,
+                LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify hCall no longer good (try to dwalloc again)", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Deallocate the call a second time (call handle should now be invalid)
+    TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            ">> Verify call handle is invalid after it's been deallocated");
+
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     // Make a call and verify LINECALLINFO/NUMMONITORS msg sent when
+    // deallocating a monitor
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINECALLINFO/MONITORS sent when deallocating a monitor", dwTestCase + 1);
+
+    // Reinit a line and make a call
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    // BUGBUG
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Open another line using the same line device with monitor privilege
+    lpTapiLineTestInfo->lphLine      = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall2)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    // Add the expected LINE_CALLINFO message to the list of expected
+    // TAPI messages that the owner will receive and wait for it
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMMONITORS,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Deallocate the monitor and verify LINECALLINFO/NUMMONITORS sent
+    // to owner as an indication that the total has been decremented
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMMONITORS,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop, deallocate, close, and shutdown the owner (it will cleanup
+    // the deallocated monitor since it's on the same hLineApp)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Next, verify that the LINE_CALLINFO/NUMOWNERINCR and NUMOWNERDECR
+    // messages are sent to the original call owner when the second owner
+    // is created and deallocated.
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINECALLINFO/NUMOWNERINCR msgs sent", dwTestCase + 1);
+
+
+    // Reinit a line and make a call
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    // BUGBUG
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Open another line using the same line device with monitor privilege
+    lpTapiLineTestInfo->lphLine      = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Acquire a call handle for the second open line
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall2)
+    // Note:  The lpCallList structure has already been allocated
+    //        from the previous scenario.
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    // Add the expected LINE_CALLINFO message to the list of expected
+    // TAPI messages that the owner will receive and wait for it
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMMONITORS,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Obtain owner privilege and check for LINE_CALLINFO/NUMOWNERINCR
+    // message to be sent to original owner
+    lpTapiLineTestInfo->lphCall      = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    if (! (fResult = DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS)))
+    {
+        TLINE_FAIL();
+    }
+
+    if (fResult)
+    {
+        AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERINCR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+    }
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINECALLINFO/NUMOWNERDECR msgs sent", dwTestCase + 1);
+
+    // Deallocate the second owner and verify LINECALLINFO/NUMOWNERDECR
+    // sent to owner as an indication that the total has been decremented
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMOWNERDECR,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop, deallocate, close, and shutdown the owner (it will cleanup
+    // the deallocated monitor since it's on the same hLineApp)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Free the memory allocated from the heap during the test cases
+    FreeTestHeap();
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineDeallocateCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+ 
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineDeallocateCall  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itldial.c b/private/tapi/qa/trapper/itest/line/itldial.c
new file mode 100644
index 000000000..52d9b2727
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itldial.c
@@ -0,0 +1,774 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itldial.c
+
+Abstract:
+
+    This module contains the test functions for lineDial
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/28/96		Added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define DWNUMCALLS 1
+
+
+//  lineDial
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized
+//     2)  Attempt to dial without owner privilege
+//     3)  Invalid hCalls (test array of gdwInvalidHandles)
+//     4)  Invalid lpszDestAddress pointers (test array of gdwInvalidPointers)
+//     5)  Call lineDial before a line has been opened
+//     6)  Valid test cases
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineDial(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT n;
+    BOOL fResult;
+
+    BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+    WCHAR wszValidAddress[]           = L"55555";
+#else
+    CHAR szValidAddress[]             = "55555";
+#endif
+    ESPDEVSPECIFICINFO info;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    // Allocate more than enough to store a call handle
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 1;
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineDial  <<<<<<<<"
+            );
+            
+    // Test uninitialized case.
+    // Note:  It is assumed that the parameter fStandAlone correctly
+    //        indicates if there are any other TAPI apps or threads
+    //        currently running.
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineDial(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    // Init and get dev caps
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify lineDial fails when a line hasn't been opened", dwTestCase + 1
+            );
+
+    // Allocate linedevcaps
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    // Try dialing before a line has been opened
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            );
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Try dialing after line has been opened but before calling lineMakeCall
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify lineDial fails after lineOpen but before lineMakeCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Test invalid lpszDestAddress pointers
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDestAddress pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDestAddress pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) gdwInvalidPointers[n];
+#else
+        lpTapiLineTestInfo->lpszDestAddress = (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+/*
+    // Perform a valid test
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCountryCode, -1", dwTestCase + 1
+            );
+
+    // Prep again for lineDrop test
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = NULL;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = NULL;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    lpTapiLineTestInfo->dwCountryCode = 0xffffffff;
+ 
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCOUNTRYCODE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop the call, deallocate it, and start over.
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+*/
+
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    // Test invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *lpTapiLineTestInfo->lphCall;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    *lpTapiLineTestInfo->lphCall = lpTapiLineTestInfo->hCall_Orig;
+
+    // Drop the call, deallocate it, and start over.
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Perform a valid test
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, with valid params and state", dwTestCase + 1
+            );
+
+    // Prep again for lineDrop test
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = NULL;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = NULL;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    if (! DoLineDial(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop the call, deallocate it, and start over.
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Verify lineDial fails when not the owner of the call
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify lineDial fails when not the owner of the call", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = NULL;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = NULL;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a second line (same device) with monitor privilege
+    
+    // Store the owner's line handle
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+    lpTapiLineTestInfo->hCall2 = *lpTapiLineTestInfo->lphCall;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    // Note:  The lpCallList structure has already been allocated
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Deallocate the call handle and close the monitor line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop and clean up the owner line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+
+    if (! DoLineDial(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL 
+            );
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Drop the call, deallocate it, and start over.
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.u.EspResult.lResult = LINEERR_ADDRESSBLOCKED;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+
+    if (! DoLineDial(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+ 
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL 
+            );
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Drop the call, deallocate it, and start over.
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineDial: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineDial  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itldrop.c b/private/tapi/qa/trapper/itest/line/itldrop.c
new file mode 100644
index 000000000..784bd281c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itldrop.c
@@ -0,0 +1,781 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itldrop.c
+
+Abstract:
+
+    This module contains the test functions for lineDrop
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define DWNUMCALLS 1
+#define NUMTOTALSIZES 5
+
+
+
+//  lineDrop
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized
+//     2)  Attempt to drop a call when not the owner
+//     3)  Invalid hCalls
+//     4)  Invalid lpUserUserInfo pointers
+//     5)  Combinations of allocation sizes and dwTotalSize values for
+//         lpUserUserInfo
+//     6)  Valid test case when lpUserUserInfo == NULL
+//     7)  Valid test case when lpUserUserInfo != NULL
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineDrop(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS lpCallbackParams;
+    DWORD dwAllMediaModes;
+    CHAR szValidUUInfo[] = "Testing valid UserUserInfo string";
+    INT n;
+    DWORD dwFixedSize = strlen(szValidUUInfo);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+    BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+#else
+    CHAR szValidAddress[] = "55555";
+#endif
+    ESPDEVSPECIFICINFO info;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Allocate more than enough to store a call handle
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 1;
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineDrop  <<<<<<<<"
+            );
+            
+    // Test uninitialized case.
+    // Note:  It is assumed that the parameter fStandAlone correctly
+    //        indicates if there are any other TAPI apps or threads
+    //        currently running.
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    
+
+    // Test invalid hCall values
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *lpTapiLineTestInfo->lphCall;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphCall = lpTapiLineTestInfo->hCall_Orig;
+
+    // Drop the call, deallocate it, and start over.
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid lpUserUserInfo pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpUserUserInfo pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwSize = 128;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LGETDEVCAPS | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+// XYD, it should test invail lpUserUserInfo, not lpszDestAddress
+//         lpTapiLineTestInfo->lpszDestAddress = (LPSTR) gdwInvalidPointers[n];
+         lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) gdwInvalidPointers[n];
+        if (lpTapiLineTestInfo->lpsUserUserInfo != NULL)   // NULL is valid
+        {
+            if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+//XYD    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+    lpTapiLineTestInfo->lpsUserUserInfo = NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad UserUserInfo dwSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = szValidUUInfo;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->dwSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineDrop(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwSize = dwFixedSize;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad UserUserInfo dwSize, -1 (lpsUserUserInfo != NULL)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = szValidUUInfo;
+    lpTapiLineTestInfo->dwSize           = (DWORD) strlen(szValidUUInfo);
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwSize = 0xffffffff;
+
+    if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwSize = 0;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/  
+        
+    // Open a line.  Open the same line device
+    // using the same hLineApp with monitor privilege.  Make a call
+    // with the first hLine.  Have the monitor get the call handle of
+    // the outbound call.  Try dropping the call with the monitor's
+    // call handle (should return LINEERR_NOTOWNER).
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify lineDrop fails when not the owner of the call", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a second line (same device) with monitor privilege
+    
+    // Store the owner's line handle
+    lpTapiLineTestInfo->hLine2 = *lpTapiLineTestInfo->lphLine;
+    lpTapiLineTestInfo->hCall2 = *lpTapiLineTestInfo->lphCall;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    // Note:  The lpCallList structure has already been allocated
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Deallocate the call handle and close the monitor line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop and clean up the owner line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+// XYD: should add dwSize test case here
+
+    // Test valid params and state (lpUserUserInfo == NULL)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid params and state (lpsUserUserInfo == NULL)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+//    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Test valid params and state (lpUserUserInfo == valid string)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid params and state (lpsUserUserInfo != NULL)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = szValidUUInfo;
+    lpTapiLineTestInfo->dwSize           = (DWORD) strlen(szValidUUInfo);
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineDrop(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALCALLSTATE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineDrop(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineDrop: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineDrop  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgac.c b/private/tapi/qa/trapper/itest/line/itlgac.c
new file mode 100644
index 000000000..399304964
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgac.c
@@ -0,0 +1,919 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgac.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAddressCaps
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "ttest.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetAddressCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid Device ID (-1, dwNumDevs)
+//     3)  Invalid Address ID (-1, dwNumAddresses)
+//     4)  Invalid hLineApps
+//     5)  Incompatible API version (too low, too high)
+//     6)  Incompatible extension version
+//     7)  Invalid lpLineAddressCaps pointers
+//     8)  Test combinations of allocations and dwTotalSizes
+//         (some valid and some invalid)
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineGetAddressCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    CHAR szTestFunc[] = "lineGetAddressCaps";
+    size_t VersionSize;
+    LPLINEADDRESSCAPS lpLineAddressCaps;
+    DWORD dwFixedSize1 = 44*sizeof(DWORD);
+    DWORD dwFixedSize2 = 45*sizeof(DWORD);
+    DWORD dwTotalSizes1[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize1 - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+    DWORD dwTotalSizes2[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize2 - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+    DWORD dwFixedSize = sizeof(LINEADDRESSCAPS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    strcpy(lpTapiLineTestInfo->szTestFunc, szTestFunc);
+    lpTapiLineTestInfo->lpExtID          = (LPLINEEXTENSIONID)
+            AllocFromTestHeap(sizeof(LINEEXTENSIONID));
+
+    // Allocate fixed size for lpLineAddressCaps pointer during
+    // these initial test sets
+    lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+            sizeof(LINEADDRESSCAPS));
+    lpTapiLineTestInfo->lpLineAddressCaps =
+            (LPLINEADDRESSCAPS) lpLineAddressCaps;
+    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+
+    // Allocate fixed size for lpLineDevCaps pointer
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetAddressCaps  <<<<<<<<"
+            );
+
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized state", dwTestCase + 1);
+        if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+
+            
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+// Try working with any device
+#if 0
+    // Find an ESP line device
+    if (! FindESPLineDevice(lpTapiLineTestInfo))
+    {
+        TLINE_FAIL();
+    }
+#endif
+
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Try bad device id (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check invalid lplineAddressCaps pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid invalid lpLineAddressCaps pointers", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpLineAddressCaps =
+            (LPLINEADDRESSCAPS) gdwInvalidPointers[n];
+        if (! DoLineGetAddressCaps(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the lplineAddressCaps pointer
+    lpTapiLineTestInfo->lpLineAddressCaps = lpLineAddressCaps;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineGetAddressCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineGetAddressCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible extension version
+    // TODO: Error will never occur if ESP line device is used.
+    //       ESP just sets the extension version equal to the
+    //       high value passed to lineNegotiateExtVersion API function...
+    //       A test provider (such as a modified version of ESP)
+    //       could be used to enforce certain version values to be valid.
+#if 0
+    lpTapiLineTestInfo->dwExtVersion_Orig =
+            *lpTapiLineTestInfo->lpdwExtVersion;
+    *(lpTapiLineTestInfo->lpdwExtVersion) = BAD_EXTVERSION;
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEEXTVERSION))
+    {
+        TLINE_FAIL();
+    }
+    *(lpTapiLineTestInfo->lpdwExtVersion) = 
+            lpTapiLineTestInfo->dwExtVersion_Orig;
+#endif
+
+    // Check invalid address ID (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAddressID = DWMINUSONE;
+    if (! DoLineGetAddressCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check invalid address ID (dwNumAddresses)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (dwNumAddresses)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAddressID = 
+            lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineGetAddressCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Set dwAddressID to 0
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize for 1.3 API version", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = 0x00010003;
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap (
+        dwFixedSize1);
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = 
+                        dwTotalSizes1[n];
+	     if(dwTotalSizes1[n] < dwFixedSize1)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes1[n]);
+        if (! DoLineGetAddressCaps(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize for 1.4 API version", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = 0x00010004;
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap (
+        dwFixedSize2);
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = 
+                        dwTotalSizes2[n];
+	     if(dwTotalSizes2[n] < dwFixedSize2)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes2[n]);
+        if (! DoLineGetAddressCaps(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize for 2.0 API version", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap (
+        dwFixedSize);
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetAddressCaps(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+   lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = dwFixedSize;
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwExtVersion", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwExtVersion = BAD_EXTVERSION;
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_INCOMPATIBLEEXTVERSION))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwExtVersion = 0x00000000;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+     // Free the local heap allocations
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify retutrn data for different APIversion", dwTestCase + 1);
+ 
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = 0x00010004;
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap (
+        dwFixedSize2);
+    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = dwFixedSize2;
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+	 TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "dwAddressFeatures = %lx",
+       lpTapiLineTestInfo->lpLineAddressCaps->dwAddressFeatures);
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap (
+        dwFixedSize);
+    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = dwFixedSize;
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+	 TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "dwAddressFeatures = %lx, dwCallFeatures2 = %lx, dwAvaiMediaModes = %lx",
+       lpTapiLineTestInfo->lpLineAddressCaps->dwAddressFeatures,
+       lpTapiLineTestInfo->lpLineAddressCaps->dwCallFeatures2,
+       lpTapiLineTestInfo->lpLineAddressCaps->dwAvailableMediaModes);
+
+     // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+     // Free the local heap allocations
+    FreeTestHeap();
+
+
+
+    n = ESP_RESULT_RETURNRESULT; 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+ 				);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+            sizeof(LINEADDRESSCAPS));
+    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEADDRESSCAPS);
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, info.u.EspResult.lResult))
+       {
+          TLINE_FAIL();
+       }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap(); 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+ 				);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+ 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+            sizeof(LINEADDRESSCAPS));
+    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEADDRESSCAPS);
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, info.u.EspResult.lResult))
+       {
+          TLINE_FAIL();
+       }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+    
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetAddressCaps: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetAddressCaps  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgaid.c b/private/tapi/qa/trapper/itest/line/itlgaid.c
new file mode 100644
index 000000000..a4bb2cad8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgaid.c
@@ -0,0 +1,796 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgaid.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAddressID
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+#define ALL_DWSELECTS    (LINECALLSELECT_LINE | \
+			  LINECALLSELECT_ADDRESS | \
+			  LINECALLSELECT_CALL)
+
+
+#define ALL_LINEADDRESSMODES (LINEADDRESSMODE_DIALABLEADDR)
+
+
+//
+//  lineGetAddressID
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  
+//  *  1)  Uninitialized
+//     2)  Invalid hLines
+//     3)  Invalid lpdwAddressID pointers
+//     4)  Invalid bit flag combinations for dwAddressMode
+//     5)  Invalid lpsAddress pointers
+//     6)  Invalid dwSizes
+//     7)  Valid cases
+//  
+//  * = Stand-alone test case
+//
+
+BOOL TestLineGetAddressID(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+    LONG lExpected;
+    DWORD dwESPDeviceID;
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+    DWORD dwFixedSize = wcslen(wszValidAddress);
+#else
+    CHAR szValidAddress[] = "55555";
+    DWORD dwFixedSize = strlen(szValidAddress);
+#endif
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                     = TRUE;
+    BOOL fEspFlag = TRUE;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+			   0,
+			   (DWORD) dwFixedSize - 1,
+				0x70000000,
+			   0x7FFFFFFF,
+			   0xFFFFFFFF
+			   };
+ 
+	
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineGetAddressID");
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  Begin testing lineGetAddressID  <<<<<<<<"
+	    );
+	    
+    // Test uninitialized case if this is the only TAPI app running
+    if (fStandAlone)
+    {
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+	if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+	{
+	    TLINE_FAIL();
+	}
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    // Start with invalid hLines
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid hLine values", dwTestCase + 1);
+
+    // Init and open a line
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Get the device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = LINEADDRESSMODE_DIALABLEADDR;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    if (! FindESPLineDevice(lpTapiLineTestInfo))
+    {
+       fEspFlag = FALSE;
+       lpTapiLineTestInfo->dwDeviceID = 0;
+       TLINE_FAIL();
+       fTestPassed = TRUE;
+    }
+
+    // Try opening the ESP device (Unimodem doesn't support DIALABLEADDR)
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+	TLINE_FAIL();
+      }
+ 
+
+    // Save the dwDeviceID of the ESP device
+    dwESPDeviceID = lpTapiLineTestInfo->dwDeviceID;
+
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+	*lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+	if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+	{
+	    TLINE_FAIL();
+	}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+    // Test invalid lpdwAddressID pointers
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpdwAddressID pointers", dwTestCase + 1);
+
+    // Init and open a line
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = LINEADDRESSMODE_DIALABLEADDR;
+    lpTapiLineTestInfo->dwDeviceID       = dwESPDeviceID;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+	TapiLogDetail(
+	DBUG_SHOW_DETAIL,
+	"n= %ld", n);
+	 lpTapiLineTestInfo->lpdwAddressID =
+	    (LPDWORD) gdwInvalidPointers[n];
+	if (! DoLineGetAddressID(
+			   lpTapiLineTestInfo,
+			   LINEERR_INVALPOINTER))
+	{
+	    TLINE_FAIL();
+	}
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the lpdwAddressID pointer
+    lpTapiLineTestInfo->lpdwAddressID = &lpTapiLineTestInfo->dwAddressID;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+    // Test invalid lpsAddress pointers
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpwsAddress pointers", dwTestCase + 1);
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpsAddress pointers", dwTestCase + 1);
+#endif
+
+    // Init and open a line
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = LINEADDRESSMODE_DIALABLEADDR;
+    lpTapiLineTestInfo->dwDeviceID       = dwESPDeviceID;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+	TapiLogDetail(
+	DBUG_SHOW_DETAIL,
+	"n= %ld", n);
+#ifdef WUNICODE
+	 lpTapiLineTestInfo->lpwsAddress = (LPWSTR) gdwInvalidPointers[n];
+#else
+	 lpTapiLineTestInfo->lpsAddress = (LPSTR) gdwInvalidPointers[n];
+#endif
+	if (! DoLineGetAddressID(
+			   lpTapiLineTestInfo,
+			   LINEERR_INVALPOINTER))
+	{
+	    TLINE_FAIL();
+	}
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the lpsAddress pointer
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+#endif
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Bad dwSize", dwTestCase + 1);
+
+    // Init and open a line
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwDeviceID       = dwESPDeviceID;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+	{
+	lpTapiLineTestInfo->dwSize = 
+			dwTotalSizes[n];
+   if(dwTotalSizes[n] == 0)
+   {
+#ifdef WUNICODE
+      if(IsESPLineDevice(lpTapiLineTestInfo))
+         lExpected = TAPISUCCESS;
+      else
+	      lExpected = LINEERR_OPERATIONUNAVAIL;
+#else      
+         lExpected = LINEERR_INVALPOINTER;
+#endif
+   }
+   else if(dwTotalSizes[n] > 0 && dwTotalSizes[n] < dwFixedSize)
+   {
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = TAPISUCCESS;
+	 else
+	    lExpected = LINEERR_OPERATIONUNAVAIL;
+   }
+   else
+	   lExpected = LINEERR_INVALPOINTER;
+
+	TapiLogDetail(
+	   DBUG_SHOW_DETAIL,
+	   "dwTotalSize = %lx", dwTotalSizes[n]);
+	if (! DoLineGetAddressID(lpTapiLineTestInfo, lExpected))
+	   {
+	      TLINE_FAIL();
+	   }
+	}
+
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwSize = dwFixedSize;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LCLOSE | LSHUTDOWN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid dwAddressMode (-1)", dwTestCase + 1);
+
+    // Init and open a line
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = 0xFFFFFFFF;
+    lpTapiLineTestInfo->dwDeviceID       = dwESPDeviceID;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_INVALADDRESSMODE))
+    {
+	   TLINE_FAIL();
+    }
+    }
+    else
+    {
+    if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+	   TLINE_FAIL();
+    }
+    }
+ 
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LCLOSE | LSHUTDOWN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: BitVectorParamErrorTest for dwAddressMode", dwTestCase + 1);
+
+    // Init and open a line
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwDeviceID       = dwESPDeviceID;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+      lExpected = LINEERR_INVALADDRESSMODE;
+    else
+      lExpected = LINEERR_OPERATIONUNAVAIL;
+																			 
+    if (! TestInvalidBitFlags(
+	    lpTapiLineTestInfo,
+	    DoLineGetAddressID,
+	    (LPDWORD) &lpTapiLineTestInfo->dwAddressMode,
+	    lExpected,
+	    FIELDTYPE_NA,
+	    FIELDTYPE_UNION,
+	    FIELDSIZE_32,
+	    ALL_LINEADDRESSMODES,
+	    ~dwBitVectorMasks[(int) FIELDSIZE_32],
+	    0x00000000,
+	    0xFFFFFFFF,
+	    FALSE
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwAddressMode = LINEADDRESSMODE_DIALABLEADDR;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LCLOSE | LSHUTDOWN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    // Test valid params and state 
+    // TODO:  The valid bit flag test should be used here
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, valid params and state", dwTestCase + 1);
+
+    // Init and open a line
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwAddressID    = &lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = LINEADDRESSMODE_DIALABLEADDR;
+    lpTapiLineTestInfo->dwDeviceID       = dwESPDeviceID;
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLineGetAddressID(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	  TLINE_FAIL();
+    }
+    }
+    else
+    {
+    if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+	  TLINE_FAIL();
+    }
+    }
+ 
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LCLOSE | LSHUTDOWN
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = LINEADDRESSMODE_DIALABLEADDR;
+ 
+    if ( ! DoLineGetAddressID(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwsAddress       = wszValidAddress;
+    lpTapiLineTestInfo->dwSize           = wcslen(wszValidAddress);
+#else
+    lpTapiLineTestInfo->lpsAddress       = szValidAddress;
+    lpTapiLineTestInfo->dwSize           = strlen(szValidAddress);
+#endif
+    lpTapiLineTestInfo->dwAddressMode    = LINEADDRESSMODE_DIALABLEADDR;
+ 
+    if ( ! DoLineGetAddressID(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetAddressID: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+ 
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  End testing lineGetAddressID  <<<<<<<<"
+	    );
+	    
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itlgas.c b/private/tapi/qa/trapper/itest/line/itlgas.c
new file mode 100644
index 000000000..f08e79e0a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgas.c
@@ -0,0 +1,615 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgas.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAddressStatus
+
+Author:
+
+    Oliver Wallace (OliverW)    10-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetAddressStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid hLines (test array of gdwInvalidHandles in itest.h)
+//     3)  Invalid dwAddressID (-1, dwNumAddresses for a line device)
+//     4)  Invalid lpAddressStatus pointers (test array of gdwInvalidPointers
+//         in itest.h)
+//     5)  Test various allocation sizes and dwTotalSize values for
+//         lpAddressStatus (see test case in this file for details)
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineGetAddressStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPLINEADDRESSSTATUS lpLineAddressStatus;
+    size_t AddressStatusSize = sizeof(LINEADDRESSSTATUS);
+    DWORD dwFixedSize = sizeof(LINEADDRESSSTATUS);
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+									0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+
+    LONG                lExpected;
+    INT                 n;
+
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                      = TRUE;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetAddressStatus  <<<<<<<<"
+            );
+            
+    // Test uninitialized case.
+    // Note:  It is assumed that the parameter fStandAlone correctly
+    //        indicates if there are any other TAPI apps or threads
+    //        currently running.
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineGetAddressStatus(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED
+                ))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Allocate the minimum amount of memory needed for the
+    // LINEADDRESSSTATUS structure so that some of the initial tests
+    // do not return INVALPOINTER errors due to the unassigned value of
+    // lpLineAddressStatus
+    if (! (lpTapiLineTestInfo->lpLineAddressStatus =
+            (LPLINEADDRESSSTATUS) AllocFromTestHeap(
+                    sizeof(LINEADDRESSSTATUS)
+                    )))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize =
+            sizeof(LINEADDRESSSTATUS);
+
+    // Allocate the fixed size for the LINEDEVCAPS structure
+    if (! (lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS)
+            AllocFromTestHeap(sizeof(LINEDEVCAPS))))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize =
+            sizeof(LINEDEVCAPS);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Test some invalid hLines
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineGetAddressStatus(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwAddressID, 0", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Test some invalid hLines
+    lpTapiLineTestInfo->dwAddressID = 0;
+    if (! DoLineGetAddressStatus(
+                     lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwAddressID, dwNumAddresses", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Test some invalid hLines
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineGetAddressStatus(
+                     lpTapiLineTestInfo,
+                     LINEERR_INVALADDRESSID))
+      {
+          TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+
+    // Test invalid dwAddressID (-1)
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (-1)", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID      = 0xFFFFFFFF;
+    if (! DoLineGetAddressStatus(lpTapiLineTestInfo, LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+    
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid lpLineAddressStatus pointers
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpLineAddressStatus pointers", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Back up the original valid lpLineAddressStatus pointer    
+    lpLineAddressStatus = lpTapiLineTestInfo->lpLineAddressStatus;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpLineAddressStatus =
+                (LPLINEADDRESSSTATUS) gdwInvalidPointers[n];
+        if (! DoLineGetAddressStatus(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the line address status pointer
+    lpTapiLineTestInfo->lpLineAddressStatus = lpLineAddressStatus;
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetAddressStatus(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = dwFixedSize;
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = dwFixedSize;
+    if (! DoLineGetAddressStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Close and shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineAddressStatus =
+            (LPLINEADDRESSSTATUS) AllocFromTestHeap(
+                    sizeof(LINEADDRESSSTATUS) );
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize =
+            sizeof(LINEADDRESSSTATUS);
+
+    if ( ! DoLineGetAddressStatus(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineAddressStatus =
+            (LPLINEADDRESSSTATUS) AllocFromTestHeap(
+                    sizeof(LINEADDRESSSTATUS) );
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize =
+            sizeof(LINEADDRESSSTATUS);
+
+    if ( ! DoLineGetAddressStatus(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetAddressStatus: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetAddressStatus  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgci.c b/private/tapi/qa/trapper/itest/line/itlgci.c
new file mode 100644
index 000000000..fea3358e5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgci.c
@@ -0,0 +1,553 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgci.c
+
+Abstract:
+
+    This module contains the test functions for lineGetCallInfo
+
+Author:
+
+    Oliver Wallace (OliverW)    17-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+
+//  lineGetCallInfo
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hCalls
+//     3)  Invalid lpCallInfo pointers
+//     4)  Combinations of allocations and dwTotalSizes for lpCallInfo
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineGetCallInfo(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPLINECALLINFO lpCallInfo;
+    size_t CallInfoSize = sizeof(LINECALLINFO);
+    DWORD dwFixedSize = sizeof(LINECALLINFO);
+    DWORD dwTotalSizes[] = {
+        0x0,
+        dwFixedSize - 1,
+        0x70000000,
+        0x7FFFFFFF,
+        0xFFFFFFFF
+        };
+
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+#else
+    CHAR szValidAddress[] = "55555";
+#endif
+
+    INT                 n;
+    LONG                lExpected;
+
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+
+	 InitTestNumber();
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineGetCallInfo");
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetCallInfo  <<<<<<<<"
+            );
+            
+    // Call lineSetCallPrivilege before any lines are initialized
+    // Note:  This test must be run in a stand-alone mode
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineGetCallInfo(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+            CallInfoSize + 256);
+    lpCallInfo->dwTotalSize = (DWORD) (CallInfoSize + 256);
+    lpTapiLineTestInfo->lpCallInfo = lpCallInfo;
+
+
+    // Try a valid case
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid params and state", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallInfo       = lpCallInfo;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Stop, Drop, and Close to isolate test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Try invalid hCalls
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallInfo       = lpCallInfo;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Back up the active call handle before testing invalid ones
+    lpTapiLineTestInfo->hCall_Orig = *lpTapiLineTestInfo->lphCall;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphCall = 
+                (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGetCallStatus(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the valid call handle
+    *lpTapiLineTestInfo->lphCall = lpTapiLineTestInfo->hCall_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Try invalid lpCallInfo pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallInfo pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallInfo       = lpCallInfo;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Backup the lpCallInfo pointer before testing invalid pointers
+    lpCallInfo = lpTapiLineTestInfo->lpCallInfo;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpCallInfo = 
+                (LPLINECALLINFO) gdwInvalidPointers[n];
+        if (! DoLineGetCallInfo(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lpCallInfo = lpCallInfo;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallInfo       = lpCallInfo;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallInfo->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetCallInfo(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = dwFixedSize;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+            CallInfoSize + 256);
+    lpCallInfo->dwTotalSize = (DWORD) (CallInfoSize + 256);
+
+    if ( ! DoLineGetCallInfo(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+            CallInfoSize + 256);
+    lpCallInfo->dwTotalSize = (DWORD) (CallInfoSize + 256);
+
+    if ( ! DoLineGetCallInfo(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetCallInfo: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+ 	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetCallInfo  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itlgcs.c b/private/tapi/qa/trapper/itest/line/itlgcs.c
new file mode 100644
index 000000000..cbd044d38
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgcs.c
@@ -0,0 +1,559 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgcs.c
+
+Abstract:
+
+    This module contains the test functions for lineGetCallStatus
+
+Author:
+
+    Oliver Wallace (OliverW)    17-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetCallStatus
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hCalls
+//     3)  Invalid lpCallStatus pointers
+//     4)  Combinations of allocations and dwTotalSizes for lpCallStatus
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineGetCallStatus(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPLINECALLSTATUS lpCallStatus;
+    size_t CallStatusSize = sizeof(LINECALLSTATUS);
+    DWORD dwFixedSize = sizeof(LINECALLSTATUS);
+    DWORD dwTotalSizes[] = {
+        0x0,
+        dwFixedSize - 1,
+        0x70000000,
+        0x7FFFFFFF,
+        0xFFFFFFFF
+        };
+
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+#else
+    CHAR szValidAddress[] = "55555";
+#endif
+
+    INT                 n;
+    LONG                lExpected;
+
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineGetCallStatus");
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetCallStatus  <<<<<<<<"
+            );
+            
+    // Call lineSetCallPrivilege before any lines are initialized
+    // Note:  This test must be run in a stand-alone mode
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineGetCallStatus(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    lpCallStatus = (LPLINECALLSTATUS) AllocFromTestHeap(
+            CallStatusSize + 256);
+    lpCallStatus->dwTotalSize = (DWORD) (CallStatusSize + 256);
+    lpTapiLineTestInfo->lpCallStatus = lpCallStatus;
+
+
+    // Test valid state and params
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid state and params", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallStatus     = lpCallStatus;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Stop, Drop, and Close to isolate test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Try invalid hCalls
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallStatus     = lpCallStatus;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Backup the valid call handle
+    lpTapiLineTestInfo->hCall_Orig = *lpTapiLineTestInfo->lphCall;
+
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphCall = 
+                (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGetCallStatus(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the valid call handle
+//XYD    *lpTapiLineTestInfo->lphCall = lpTapiLineTestInfo->hCall_Orig;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Try invalid lpCallStatus pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallStatus pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallStatus     = lpCallStatus;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpCallStatus = 
+                (LPLINECALLSTATUS) gdwInvalidPointers[n];
+        if (! DoLineGetCallStatus(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the LineCallStatus pointer
+    lpTapiLineTestInfo->lpCallStatus = lpCallStatus;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpCallStatus     = lpCallStatus;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallStatus->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetCallStatus(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallStatus->dwTotalSize = dwFixedSize;
+    // Restore the LineCallStatus pointer
+    lpTapiLineTestInfo->lpCallStatus = lpCallStatus;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+        
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpCallStatus = (LPLINECALLSTATUS) AllocFromTestHeap(
+            CallStatusSize + 256);
+    lpCallStatus->dwTotalSize = (DWORD) (CallStatusSize + 256);
+
+    if ( ! DoLineGetCallStatus(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpCallStatus = (LPLINECALLSTATUS) AllocFromTestHeap(
+            CallStatusSize + 256);
+    lpCallStatus->dwTotalSize = (DWORD) (CallStatusSize + 256);
+
+    if ( ! DoLineGetCallStatus(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetCallStatus: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetCallStatus  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itlgdc.c b/private/tapi/qa/trapper/itest/line/itlgdc.c
new file mode 100644
index 000000000..a0dd56b66
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgdc.c
@@ -0,0 +1,853 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetDevCaps
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES   5
+
+
+//  lineGetDevCaps
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid lpLineDevCaps pointers
+//     3)  Invalid dwDeviceID (dwNumDevs, -1)
+//     4)  Invalid hLineApps
+//     5)  Incompatible API version (too low, too high)
+//     6)  Test various allocation sizes and dwTotalSizes for
+//         lpLineDevCaps
+//     7)  Incompatible extension version (not tested yet)
+//     8)  Verify that lineGetDevCaps succeeds with valid parameters
+//         for dwDeviceIDs from 0 through dwNumDevs - 1
+//    10)  Solicit SPI errors (NODEVICE, NODRIVER, NOMEM, OPERATIONFAILED,
+//         RESOURCEUNAVAIL, OPERATIONUNAVAIL) (not done yet...will be done
+//         in separate SP/device specific tests)
+//    11)  Verify returned data on success (not done yet...will be done
+//         in separate SP/device specific tests
+//
+//  *  =   Test must be run as a stand-alone test case
+
+BOOL TestLineGetDevCaps(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+#ifdef WUNICODE
+    WCHAR *pwszProviderInfo;
+    WCHAR *pwszLineName;
+    WCHAR *wszEspInfo = L"ESP v2.0";
+    WCHAR *wszUnimdmInfo = L"Windows Telephony Service Provider for Universal Modem Driver";
+    WCHAR *wszEspLineName = L"ESP Line 0";
+    WCHAR *wszUnimdmLineName = L"Zoom VFX 28.8";
+#else
+    char *pszProviderInfo;
+    char *pszLineName;
+    char *szEspInfo = "ESP v2.0";
+    char *szUnimdmInfo = "Windows Telephony Service Provider for Universal Modem Driver";
+    char *szEspLineName = "ESP Line 0";
+    char *szUnimdmLineName = "Zoom VFX 28.8";
+#endif
+
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LPVOID lpLineDevCaps;
+    size_t VersionSize;
+    BOOL fResult;
+    DWORD dwFixedSize = sizeof(LINEDEVCAPS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpExtID       = (LPLINEEXTENSIONID)
+            AllocFromTestHeap(sizeof(LINEEXTENSIONID));
+
+    // Allocated fixed size for lpLineDevCaps pointer during
+    // these initial test sets
+    lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) lpLineDevCaps;
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetDevCaps  <<<<<<<<"
+            );
+            
+    // Test for LINEERR_UNINITIALIZED if this is the only TAPI app running
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineGetDevCaps(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpLineDevCaps pointers", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Check invalid lpLineDevCaps pointers
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpLineDevCaps =
+            (LPLINEDEVCAPS) gdwInvalidPointers[n];
+        if (! DoLineGetDevCaps(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the lpLineDevCaps pointer
+    lpTapiLineTestInfo->lpLineDevCaps = lpLineDevCaps;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwExtVersion", dwTestCase + 1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+/*
+    if (! FindESPLineDevice(lpTapiLineTestInfo))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate an extension version for the device
+    *(lpTapiLineTestInfo->lpdwExtVersion) = GOOD_EXTVERSION;
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check incompatible extension version
+    // Currently this test will not fail because strict ext version
+    // checking not supported by SP
+    lpTapiLineTestInfo->dwExtVersion_Orig = 
+        *(lpTapiLineTestInfo->lpdwExtVersion);
+*/
+    *(lpTapiLineTestInfo->lpdwExtVersion) = BAD_EXTVERSION;
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEEXTVERSION))
+    {
+        TLINE_FAIL();
+    }
+    *lpTapiLineTestInfo->lpdwExtVersion =  0x00000000;
+//        lpTapiLineTestInfo->dwExtVersion_Orig;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1
+            );
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = *lpTapiLineTestInfo->lpdwNumDevs;
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Restore dwDeviceID
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try bad device id (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1
+            );
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore dwDeviceID
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLineApp handles", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles;
+        if (! DoLineGetDevCaps(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLineApp = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+        *(lpTapiLineTestInfo->lpdwAPIVersion);
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOHIGH_APIVERSION;
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore API version to version previously negotiated
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+        lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+        *(lpTapiLineTestInfo->lpdwAPIVersion);
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore API version to version previously negotiated
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+        lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) lpLineDevCaps;
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetDevCaps(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = dwFixedSize;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = dwFixedSize;
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // zero the memory used from the heap
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, compare Provider strings", dwTestCase + 1);
+
+     lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = dwFixedSize;
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            BIGBUFSIZE);
+//            lpTapiLineTestInfo->lpLineDevCaps->dwNeededSize);
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = 
+            BIGBUFSIZE;
+//            lpTapiLineTestInfo->lpLineDevCaps->dwNeededSize;
+ 
+    if (! DoLineGetDevCaps(
+                       lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+#ifdef WUNICODE
+    pwszProviderInfo = (WCHAR *)(((LPBYTE) lpTapiLineTestInfo->lpLineDevCaps) +
+                       lpTapiLineTestInfo->lpLineDevCaps->dwProviderInfoOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %ws",
+		pwszProviderInfo);
+
+    pwszLineName = (WCHAR *)(((LPBYTE) lpTapiLineTestInfo->lpLineDevCaps) +
+                       lpTapiLineTestInfo->lpLineDevCaps->dwLineNameOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### LineName = %ws",
+		pwszLineName);
+#else
+    pszProviderInfo = ((char *) lpTapiLineTestInfo->lpLineDevCaps) +
+                       lpTapiLineTestInfo->lpLineDevCaps->dwProviderInfoOffset;
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %s",
+		pszProviderInfo);
+
+    pszLineName = (char *)(((LPBYTE) lpTapiLineTestInfo->lpLineDevCaps) +
+                       lpTapiLineTestInfo->lpLineDevCaps->dwLineNameOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### LineName = %s",
+		pszLineName);
+#endif
+
+#ifdef WUNICODE
+        if (!lstrcmpW(pwszProviderInfo, wszEspInfo))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The provider is ESP");
+          fTestPassed = TRUE;
+          }
+        else if (!lstrcmpW(pwszProviderInfo, wszUnimdmInfo))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The provider is UNIMDM");
+          fTestPassed = TRUE;
+          }
+        else
+          fTestPassed = FALSE;
+#else
+        if (!lstrcmpA(pszProviderInfo, szEspInfo))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The provider is ESP");
+          fTestPassed = TRUE;
+          }
+        else if (!lstrcmpA(pszProviderInfo, szUnimdmInfo))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The provider is UNIMDM");
+          fTestPassed = TRUE;
+          }
+        else
+          fTestPassed = FALSE;
+#endif
+  
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, compare LineName strings", dwTestCase + 1);
+
+
+#ifdef WUNICODE
+        if (!lstrcmpW(pwszLineName, wszEspLineName))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The LineName is ESP");
+          fTestPassed = TRUE;
+          }
+        else if (!lstrcmpW(pwszLineName, wszUnimdmLineName))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The LineName is UNIMDM");
+          fTestPassed = TRUE;
+          }
+        else
+          fTestPassed = FALSE;
+#else
+        if (!lstrcmpA(pszLineName, szEspLineName))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The LineName is ESP");
+          fTestPassed = TRUE;
+          }
+        else if (!lstrcmpA(pszLineName, szUnimdmLineName))
+          {
+          TapiLogDetail(
+             DBUG_SHOW_PASS,
+             "The LineName is UNIMDM");
+          fTestPassed = TRUE;
+          }
+        else
+          fTestPassed = FALSE;
+#endif
+  
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // zero the memory used from the heap
+    FreeTestHeap();
+
+     lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if ( ! DoLineGetDevCaps(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_NODRIVER;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if ( ! DoLineGetDevCaps(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetDevCaps: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetDevCaps  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgid.c b/private/tapi/qa/trapper/itest/line/itlgid.c
new file mode 100644
index 000000000..eb7abec08
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgid.c
@@ -0,0 +1,965 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgid.c
+
+Abstract:
+
+    This module contains the test functions for lineGetID
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES    5
+
+#define ALL_DWSELECTS    (LINECALLSELECT_LINE | \
+                          LINECALLSELECT_ADDRESS | \
+                          LINECALLSELECT_CALL)
+
+
+//
+//  lineGetID
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  
+//  *  1)  Uninitialized
+//     2)  Invalid hLines
+//     3)  Invalid hCalls
+//     4)  Invalid bit flag combinations for dwSelect
+//     5)  Invalid lpDeviceID pointers
+//     6)  Invalid lpszDeviceClass pointers
+//     7)  Combinations of invalid and valid allocations with various
+//         dwTotalSize values
+//     8)  Valid bit flag combinations for dwSelect
+//  
+//  * = Stand-alone test case
+//
+
+BOOL TestLineGetID(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPVARSTRING lpDeviceID;
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+    WCHAR wszValidDeviceClass[] = L"tapi/line";
+    WCHAR wszDeviceClass[] = L"wave";
+#else
+    CHAR szValidAddress[] = "55555";
+    CHAR szValidDeviceClass[] = "tapi/line";
+    CHAR szDeviceClass[] = "wave";
+#endif
+    INT n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                     = TRUE;
+    size_t VarStringSize                 = sizeof(VARSTRING);
+    DWORD dwFixedSize = sizeof(VARSTRING);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineGetID");
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetID  <<<<<<<<"
+            );
+            
+    // Test uninitialized case if this is the only TAPI app running
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+                          sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpDeviceID = (LPVARSTRING) AllocFromTestHeap(
+                          sizeof(VARSTRING));
+    lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->lpDeviceID = lpDeviceID;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = szDeviceClass;
+#endif
+    
+    // Test invalid line handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (-1)", dwTestCase + 1);
+ 
+
+    lpTapiLineTestInfo->hCall1 = 0;
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+//                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID = DWMINUSONE;
+
+    if (! DoLineGetID(
+                       lpTapiLineTestInfo,
+                       LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (dwNumAddresses)", dwTestCase + 1);
+ 
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineGetID(
+                       lpTapiLineTestInfo, 
+                       LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+	 lpTapiLineTestInfo->dwAddressID = 0;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    // Test invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+
+    // Test invalid lpDeviceID pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpDeviceID pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpDeviceID = (LPVARSTRING) gdwInvalidPointers[n];
+        if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lpDeviceID = &(lpTapiLineTestInfo->DeviceID);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+
+    // Test invalid lpszDeviceClass pointers
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDeviceClass = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDeviceClass = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = 
+            lpTapiLineTestInfo->lpwszDeviceClass_Orig;
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = 
+            lpTapiLineTestInfo->lpszDeviceClass_Orig;
+#endif
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = &(lpTapiLineTestInfo->DeviceID);
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpDeviceID->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetID(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpDeviceID->dwTotalSize = dwFixedSize;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid bit flag combinations for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGetID,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            LINEERR_INVALCALLSELECT,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test valid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid bit flag combinations for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGetID,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+/* XYD, NA and MUTEX should exchange the position
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+*/
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = &(lpTapiLineTestInfo->DeviceID);
+    lpTapiLineTestInfo->lpDeviceID->dwTotalSize = dwFixedSize;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetID(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+     fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    lpTapiLineTestInfo->lpDeviceID       = &(lpTapiLineTestInfo->DeviceID);
+    lpTapiLineTestInfo->lpDeviceID->dwTotalSize = dwFixedSize;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineGetID(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->lpDeviceID       = &(lpTapiLineTestInfo->DeviceID);
+    lpTapiLineTestInfo->lpDeviceID->dwTotalSize = dwFixedSize;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szDeviceClass;
+#endif
+
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_NODEVICE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineGetID(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetID: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetID  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itlglds.c b/private/tapi/qa/trapper/itest/line/itlglds.c
new file mode 100644
index 000000000..13ba8c35c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlglds.c
@@ -0,0 +1,546 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlglds.c
+
+Abstract:
+
+    This module contains the test functions for lineGetLineDevStatus
+
+Author:
+
+    Oliver Wallace (OliverW)    10-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetLineDevStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid hLines (test array of dwInvalidHandles in itest.h)
+//     3)  Invalid lpLineDevStatus pointers (test array of dwInvalidPointers
+//         in itest.h)
+//     4)  Test various combinations of allocation sizes and dwTotalSizes
+//         (see test case in this file for details)
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineGetLineDevStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    size_t DevStatusSize = sizeof(LINEDEVSTATUS);
+    size_t dwDevStatusTotalSize = DevStatusSize + 256;
+    LPLINEDEVSTATUS lpLineDevStatus;
+    DWORD dwFixedSize = sizeof(LINEDEVSTATUS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+    INT                 n;
+
+
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetLineDevStatus  <<<<<<<<"
+            );
+
+    // Test uninitialized case.
+    // Note:  It is assumed that the parameter fStandAlone correctly
+    //        indicates if there are any other TAPI apps or threads
+    //        currently running.
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineGetLineDevStatus(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED
+                ))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Allocate the minimum amount of memory needed for the
+    // LINEDEVSTATUS structure, so these initial tests don't fail
+    // because lpLineDevStatus hasn't been allocated
+    if (! (lpLineDevStatus =
+            (LPLINEDEVSTATUS) AllocFromTestHeap(DevStatusSize + 256)))
+    {
+        TLINE_FAIL();
+    }
+
+    lpLineDevStatus->dwTotalSize = DevStatusSize + 256;
+    lpTapiLineTestInfo->lpLineDevStatus = lpLineDevStatus;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+
+    
+    // Test some invalid hLines
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLines", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpLineDevStatus  = lpLineDevStatus;
+    lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = dwDevStatusTotalSize;    
+     
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineGetLineDevStatus(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test invalid lpLineDevStatus pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpLineDevStatus pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpLineDevStatus  = lpLineDevStatus;
+    lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = dwDevStatusTotalSize; 
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpLineDevStatus =
+                (LPLINEDEVSTATUS) gdwInvalidPointers[n];
+        if (! DoLineGetLineDevStatus(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineDevStatus  = lpLineDevStatus;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSizes", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpLineDevStatus  = (LPLINEDEVSTATUS) AllocFromTestHeap(
+          dwFixedSize);
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = dwFixedSize;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test valid state and params
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid params and state", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpLineDevStatus  = lpLineDevStatus;
+    lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = dwDevStatusTotalSize;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    if (lpTapiLineTestInfo->lpLineDevStatus->dwNeededSize >
+            lpTapiLineTestInfo->lpLineDevStatus->dwUsedSize
+            )
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Reallocating and trying valid case again with\r\n" \
+                ">> allocation of lpLineDevStatus->dwTotalSize == dwNeededSize"
+                );
+
+        // Reallocate and try again with enough memory for TAPI and SP
+        // to fill all the fields in
+        lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS)
+                AllocFromTestHeap((size_t) lpLineDevStatus->dwNeededSize);
+        lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize =
+                lpLineDevStatus->dwNeededSize;
+        if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    
+    // Free test resources allocated from the test heap during the tests
+    FreeTestHeap();
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+        sizeof(LINEDEVSTATUS));
+    lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS);
+
+    if ( ! DoLineGetLineDevStatus(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALLINEHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+        sizeof(LINEDEVSTATUS));
+    lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS);
+
+    if ( ! DoLineGetLineDevStatus(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetLineDevStatus: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetLineDevStatus  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgnc.c b/private/tapi/qa/trapper/itest/line/itlgnc.c
new file mode 100644
index 000000000..bdc2b65bb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgnc.c
@@ -0,0 +1,954 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgnc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetNewCalls
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define DWNUMCALLS 1
+#define NUMTOTALSIZES 5
+#define ALL_DWSELECT   (LINECALLSELECT_LINE | \
+								LINECALLSELECT_ADDRESS)
+
+
+
+//  lineGetNewCalls
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hLines
+//     3)  Invalid dwAddressID (-1, dwNumAddresses)
+//     4)  Test invalid bit flags for dwSelect
+//     5)  Test valid bit flags for dwSelect
+//     6)  Invalid lpCallList pointers
+//     7)  Test combinations of allocation sizes and dwTotalSizes for
+//         lpCallList (some valid, some invalid -- See test case below
+//         for details)
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineGetNewCalls(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    LPLINECALLLIST      lpCallList;
+    INT                 n;
+    BOOL                fResult;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+    DWORD dwFixedSize = sizeof(LINECALLLIST);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+    DWORD dwZeroCallSize;
+    DWORD dwOneCallSize;
+ 
+	 InitTestNumber();
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+
+
+    // Allocate more than enough to store a call handle
+    dwZeroCallSize = dwFixedSize;
+    dwOneCallSize = dwFixedSize + sizeof(HCALL);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            dwOneCallSize);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwOneCallSize;
+    lpCallList = lpTapiLineTestInfo->lpCallList;
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetNewCalls  <<<<<<<<"
+            );
+            
+    // Test that lineGetNewCalls returns LINEERR_UNINITIALIZED when
+    // there are no lines are initialized.
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineGetNewCalls(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    // Setup and make a call
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid params and state", dwTestCase + 1
+            );
+	
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // try valid case of having a monitor acquire a handle to existing call
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+           ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid hLines
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLines", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineGetNewCalls(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid dwAddressID (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (-1)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Try dwAddressID == -1
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID = 0xFFFFFFFF;
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid dwAddressID (dwNumAddresses)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (dwNumAddresses)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Try dwAddressID == dwNumAddresses
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID = 
+            lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid lpCallList pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallList pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Try invalid lpCallList pointers
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) gdwInvalidPointers[n];
+        if (! DoLineGetNewCalls(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallList = lpCallList;
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpCallList = lpCallList;
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetNewCalls(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwOneCallSize;
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpCallList = lpCallList;
+
+    if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGetNewCalls,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            LINEERR_INVALCALLSELECT,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DWSELECT,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpCallList = lpCallList;
+
+    if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGetNewCalls,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_DWSELECT,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            dwOneCallSize);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwOneCallSize;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify only room for one call", dwTestCase + 1
+            );
+	
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // try valid case of having a monitor acquire a handle to existing call
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "dwTotalSize = %lx, dwNeededSize = %lx, dwUsedSize = %lx",
+       lpTapiLineTestInfo->lpCallList->dwTotalSize,
+       lpTapiLineTestInfo->lpCallList->dwNeededSize,
+       lpTapiLineTestInfo->lpCallList->dwUsedSize);
+        
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "hCall2 = %lx", 
+       (LPBYTE) lpTapiLineTestInfo->lpCallList + 
+					 lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+	 if(lpTapiLineTestInfo->lpCallList->dwNeededSize ==
+       lpTapiLineTestInfo->lpCallList->dwTotalSize)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+
+       fTestPassed = ShowTestCase(fTestPassed);
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDEALLOCATECALL | LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+           ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            dwZeroCallSize);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwZeroCallSize;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify only room for zero call", dwTestCase + 1
+            );
+	
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open the same line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // try valid case of having a monitor acquire a handle to existing call
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "dwTotalSize = %lx, dwNeededSize = %lx, dwUsedSize = %lx",
+       lpTapiLineTestInfo->lpCallList->dwTotalSize,
+       lpTapiLineTestInfo->lpCallList->dwNeededSize,
+       lpTapiLineTestInfo->lpCallList->dwUsedSize);
+        
+
+    // Drop the call, deallocate the monitor and owner, and close both
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    if(! DoLineDeallocateCall (lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+    {
+        TLINE_FAIL();
+    }
+ 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Close the owner
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+           ))
+    {
+        TLINE_FAIL();
+    }
+
+
+   // Free the memory taken from the heap
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetNewCalls: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+      TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetNewCalls  <<<<<<<<"
+            );
+            
+
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgnr.c b/private/tapi/qa/trapper/itest/line/itlgnr.c
new file mode 100644
index 000000000..9724c9bc9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgnr.c
@@ -0,0 +1,434 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgnr.c
+
+Abstract:
+
+    This module contains the test functions for lineGetNumRings
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define NUMNUMRINGS 11
+
+
+//  lineGetNumRings
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid hLines
+//     3)  Invalid dwAddressID (-1, dwNumAddresses)
+//     4)  Invalid lpdwNumRings
+//     5)  Test several valid lineSetNumRings/lineGetNumRings
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineGetNumRings(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+    DWORD dwNumRings[NUMNUMRINGS] = {
+            0,
+            1,
+            10,
+            100,
+            1000,
+            10000,
+            0x7FFF,
+            0x8000,
+            0x8001,
+            0xFFFFFFFE,
+            0xFFFFFFFF
+            };
+
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    CHAR szTestFunc[] = "lineGetNumRings";
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineGetNumRings");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetNumRings  <<<<<<<<"
+            );
+            
+    // Test uninitialized state
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineGetNumRings(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    // Test some invalid hLines
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLines", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineGetNumRings(
+                      lpTapiLineTestInfo,
+                      LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test invalid lpdwNumRings pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwNumRings pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwNumRings = (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineGetNumRings(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lpdwNumRings = &lpTapiLineTestInfo->dwNumRings;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test invalid dwAddressID (dwNumAddresses)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (dwNumAddresses)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID =
+            lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineGetNumRings(lpTapiLineTestInfo, LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test invalid dwAddressID (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (-1)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID = DWMINUSONE;
+    if (! DoLineGetNumRings(lpTapiLineTestInfo, LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test SetNumRings/GetNumRings combinations to verify that it's
+    // working properly
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid Set/GetNumRings combinations", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwNumRings_Orig = *lpTapiLineTestInfo->lpdwNumRings;
+    for (n = 0; n < NUMNUMRINGS; n++)
+    {
+        *lpTapiLineTestInfo->lpdwNumRings = dwNumRings[n];
+        if (! DoLineSetNumRings(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        if (! DoLineGetNumRings(lpTapiLineTestInfo, TAPISUCCESS) ||
+                *lpTapiLineTestInfo->lpdwNumRings != dwNumRings[n])
+        {
+            TLINE_FAIL();
+        }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp       = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes     = LINEMEDIAMODE_DATAMODEM;
+    
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwNumRings_Orig = *lpTapiLineTestInfo->lpdwNumRings;
+    for (n = 0; n < NUMNUMRINGS; n++)
+    {
+        *lpTapiLineTestInfo->lpdwNumRings = dwNumRings[n];
+        if (! DoLineSetNumRings(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        lpTapiLineTestInfo->dwNumRings = 0;
+        lpTapiLineTestInfo->lpdwNumRings = &lpTapiLineTestInfo->dwNumRings;
+        if (! DoLineGetNumRings(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        if(*lpTapiLineTestInfo->lpdwNumRings == dwNumRings[n])
+          fTestPassed = TRUE;
+        else
+          fTestPassed = FALSE;
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetNumRings: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetNumRings  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgpl.c b/private/tapi/qa/trapper/itest/line/itlgpl.c
new file mode 100644
index 000000000..eb0f0578f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgpl.c
@@ -0,0 +1,168 @@
+G/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgpl.c
+
+Abstract:
+
+    This module contains the test functions for lineGetProviderList
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+//  lineGetProviderList
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//     1)  Valid test case
+//
+
+BOOL TestLineGetProviderList(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    DWORD               dwProviderListSize  = sizeof(LINEPROVIDERLIST);
+    INT                 n;
+    BOOL                fResult;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed         = TRUE;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_UNKNOWN;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetProviderList  <<<<<<<<"
+            );
+            
+    // Try a valid test case under initialized conditions
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state under initialized conditions", dwTestCase + 1);
+
+    // Initialize a line app
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Allocating and testing fixed size for LPLINEPROVIDERLIST");
+
+    lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST)
+            AllocFromTestHeap(dwProviderListSize);
+    lpTapiLineTestInfo->lpProviderList->dwTotalSize = dwProviderListSize;
+    if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check the needed size versus the used size.
+    // If the needed size is greater than the used size, reallocate enough
+    // to store the entire provider list and call lineGetProviderList again.
+    if (lpTapiLineTestInfo->lpProviderList->dwNeededSize >
+            lpTapiLineTestInfo->lpProviderList->dwUsedSize)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Reallocating and testing based on dwNeededSize");
+
+        dwProviderListSize = lpTapiLineTestInfo->lpProviderList->dwNeededSize;
+        lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST)
+                AllocFromTestHeap(dwProviderListSize);
+        lpTapiLineTestInfo->lpProviderList->dwTotalSize = dwProviderListSize;
+        if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+// TODO:  Check the provider list with what's currently in the registry.
+//        Display the list and describe any descrepencies.
+// Note:  The checking can only be guaranteed to be accurate when
+//        this is the only TAPI thread/app running or if this operation
+//        is atomic.
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Free the memory taken from the heap
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetProviderList: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetProviderList  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/line/itlgsm.c b/private/tapi/qa/trapper/itest/line/itlgsm.c
new file mode 100644
index 000000000..8570968f2
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlgsm.c
@@ -0,0 +1,505 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgsm.c
+
+Abstract:
+
+    This module contains the test functions for lineGetStatusMessages
+
+Author:
+
+    Oliver Wallace (OliverW)    10-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define ALL_LINEDEVSTATES        (LINEDEVSTATE_OTHER            | \
+                                  LINEDEVSTATE_RINGING          | \
+                                  LINEDEVSTATE_CONNECTED        | \
+                                  LINEDEVSTATE_DISCONNECTED     | \
+                                  LINEDEVSTATE_MSGWAITON        | \
+                                  LINEDEVSTATE_INSERVICE        | \
+                                  LINEDEVSTATE_OUTOFSERVICE     | \
+                                  LINEDEVSTATE_MAINTENANCE      | \
+                                  LINEDEVSTATE_OPEN             | \
+                                  LINEDEVSTATE_CLOSE            | \
+                                  LINEDEVSTATE_NUMCALLS         | \
+                                  LINEDEVSTATE_NUMCOMPLETIONS   | \
+                                  LINEDEVSTATE_TERMINALS        | \
+                                  LINEDEVSTATE_ROAMMODE         | \
+                                  LINEDEVSTATE_BATTERY          | \
+                                  LINEDEVSTATE_SIGNAL           | \
+                                  LINEDEVSTATE_DEVSPECIFIC      | \
+                                  LINEDEVSTATE_REINIT           | \
+                                  LINEDEVSTATE_LOCK             | \
+                                  LINEDEVSTATE_CAPSCHANGE       | \
+                                  LINEDEVSTATE_CONFIGCHANGE     | \
+                                  LINEDEVSTATE_TRANSLATECHANGE  | \
+                                  LINEDEVSTATE_COMPLCANCEL      | \
+                                  LINEDEVSTATE_REMOVED)
+
+#define ALL_ADDRESSSTATES        (LINEADDRESSSTATE_OTHER        | \
+                                  LINEADDRESSSTATE_DEVSPECIFIC  | \
+                                  LINEADDRESSSTATE_INUSEZERO    | \
+                                  LINEADDRESSSTATE_INUSEONE     | \
+                                  LINEADDRESSSTATE_INUSEMANY    | \
+                                  LINEADDRESSSTATE_NUMCALLS     | \
+                                  LINEADDRESSSTATE_FORWARD      | \
+                                  LINEADDRESSSTATE_TERMINALS    | \
+                                  LINEADDRESSSTATE_CAPSCHANGE)
+
+
+//  lineGetStatusMessages
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hLines
+//     3)  Test invalid dwLineStates pointers
+//     4)  Test invalid dwAddressStates pointers
+//     5)  Solicit SPI errors (NOMEM, OPERATIONFAILED, RESOURCEUNAVAIL,
+//         OPERATIONUNAVAIL) (not implemented here)
+//     6)  Perform a couple of lineSetStatusMessages/lineGetStatusMessages
+//         combinations (eventually, more combinations should be tested)
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineGetStatusMessages(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT                 n;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+    CHAR                szTestFunc[]      = "lineGetStatusMessages";
+    DWORD dwLineStates;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+    strcpy(lpTapiLineTestInfo->szTestFunc, szTestFunc);
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+            (DWORD) GetCallbackParams();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetStatusMessages  <<<<<<<<"
+            );
+
+            
+    // Call lineGetStatusMessages before any lines are initialized
+    // Note:  This test must be run in a stand-alone mode
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineGetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//            lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwLineStates    = 0x00000000;
+    lpTapiLineTestInfo->dwAddressStates = 0x00000000;
+
+
+    // Test invalid line handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLines", dwTestCase + 1
+            );
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Store the valid line handle and try some invalid ones
+    lpTapiLineTestInfo->hLine_Orig      = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineGetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_INVALLINEHANDLE
+                ))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore valid line handle
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test invalid lpdwLineStates pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwLineStates pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//            lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwLineStates    = 0x00000000;
+    lpTapiLineTestInfo->dwAddressStates = 0x00000000;
+    lpTapiLineTestInfo->lpdwAddressStates =
+            &lpTapiLineTestInfo->dwAddressStates;
+
+    // XYD add 2/27/96
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwLineStates = (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineGetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_INVALPOINTER
+                ))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpdwLineStates pointer
+    lpTapiLineTestInfo->lpdwLineStates = &lpTapiLineTestInfo->dwLineStates;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpdwLineStates == lpdwAddressStates", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwLineStates    = 0x00000000;
+    lpTapiLineTestInfo->dwAddressStates = 0x00000000;
+    lpTapiLineTestInfo->lpdwAddressStates =
+            &lpTapiLineTestInfo->dwAddressStates;
+
+    // XYD add 2/27/96
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 
+   lpTapiLineTestInfo->lpdwLineStates = (LPDWORD) lpTapiLineTestInfo->lpdwAddressStates;
+   if (! DoLineGetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_INVALPOINTER
+                ))
+        {
+            TLINE_FAIL();
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpdwLineStates pointer
+    lpTapiLineTestInfo->lpdwLineStates = &lpTapiLineTestInfo->dwLineStates;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    // Test invalid lpdwAddressStates pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwAddressStates pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//            lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwLineStates    = 0x00000000;
+    lpTapiLineTestInfo->dwAddressStates = 0x00000000;
+    lpTapiLineTestInfo->lpdwLineStates =
+            &lpTapiLineTestInfo->dwLineStates;
+
+    // XYD add 2/27/96
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwAddressStates =
+                (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineGetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_INVALPOINTER
+                ))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpdwAddressStates pointer 
+    lpTapiLineTestInfo->lpdwAddressStates =
+            &lpTapiLineTestInfo->dwAddressStates;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Perform a sanity check by performing a couple of Get/SetStatusMessages
+    // calls.
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid Get/SetStatusMessages combinations and verify\r\n" \
+            ">> the returned data", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//            lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    lpTapiLineTestInfo->dwLineStates    = LINEDEVSTATE_DISCONNECTED |
+                                          LINEDEVSTATE_CONNECTED;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_NUMCALLS;
+ 
+    // XYD add 2/27/96
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the values used
+    lpTapiLineTestInfo->dwLineStates_Orig = lpTapiLineTestInfo->dwLineStates;
+    lpTapiLineTestInfo->dwAddressStates_Orig = 
+            lpTapiLineTestInfo->dwAddressStates;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // XYD, add REINIT to dwLineStates
+    if(! (lpTapiLineTestInfo->dwLineStates_Orig & LINEDEVSTATE_REINIT))
+		dwLineStates = lpTapiLineTestInfo->dwLineStates_Orig | LINEDEVSTATE_REINIT;
+
+    // Verify the results by calling lineGetStatusMessages
+    if (! DoLineGetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS) ||
+            *lpTapiLineTestInfo->lpdwAddressStates !=
+                    lpTapiLineTestInfo->dwAddressStates_Orig       ||
+            *lpTapiLineTestInfo->lpdwLineStates !=
+    //                lpTapiLineTestInfo->dwLineStates_Orig
+                      dwLineStates
+            )
+    {
+        TLINE_FAIL();
+    }
+
+
+   TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"Set: dwAddressState = %lx, dwLineStates = %lx",
+		lpTapiLineTestInfo->dwAddressStates_Orig, 
+		lpTapiLineTestInfo->dwLineStates_Orig);
+
+   TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"Get: dwAddressState = %lx, dwLineStates = %lx",
+		*lpTapiLineTestInfo->lpdwAddressStates, 
+		*lpTapiLineTestInfo->lpdwLineStates);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid Get/SetStatusMessages combinations and verify\r\n" \
+            ">> the returned data", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwLineStates    = ALL_LINEDEVSTATES;
+    lpTapiLineTestInfo->dwAddressStates = ALL_ADDRESSSTATES;
+    // Store the values used
+    lpTapiLineTestInfo->dwLineStates_Orig = lpTapiLineTestInfo->dwLineStates;
+    lpTapiLineTestInfo->dwAddressStates_Orig = 
+            lpTapiLineTestInfo->dwAddressStates;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    // Verify the results by calling lineGetStatusMessages
+    if (! DoLineGetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS) ||
+            *lpTapiLineTestInfo->lpdwAddressStates !=
+                    lpTapiLineTestInfo->dwAddressStates_Orig       ||
+            *lpTapiLineTestInfo->lpdwLineStates !=
+                    lpTapiLineTestInfo->dwLineStates_Orig
+            )
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    	
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetStatusMessages: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetStatusMessages  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itli.c b/private/tapi/qa/trapper/itest/line/itli.c
new file mode 100644
index 000000000..14b7a6d67
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itli.c
@@ -0,0 +1,561 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itli.c
+
+Abstract:
+
+    This module contains the test functions for lineInitialize
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "tcore.h"
+#include "doline.h"
+#include "tline.h"
+
+
+#define ESPDEVSPECIFIC_KEY  ((DWORD) 'DPSE')
+
+#define ESP_DEVSPEC_MSG     1
+
+//  lineInitialize
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//    1)  Invalid lphLineApp pointers
+//    2)  Invalid lpdwNumDevs pointers
+//    3)  Invalid lpfnCallback pointers
+//    3)  Invalid hInstance handles
+//    4)  Null lpszAppName
+//    5)  Invalid lpszAppName strings
+//    6)  Verify hLineApp can be used
+//    7)  Verify 0..dwNumDevs can be used
+//    8)  Verify valid params: lphLineApp, hInstance, lpfnCallback, lpwszAppName, lpdwNumDevs
+//
+
+BOOL
+TestLineInitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT                 n;
+/*
+#ifdef WUNICODE
+    WCHAR                wszValidAppName[] = L"ValidApp";
+    LPWSTR               lpwszAppName = wszValidAppName;
+#else
+*/
+    CHAR                szValidAppName[] = "ValidApp";
+    LPSTR               lpszAppName = szValidAppName;
+//#endif
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed   = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams;
+    TAPIRESULT lastTapiResult;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams   = GetCallbackParams();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineInitialize  <<<<<<<<"
+            );
+            
+    // test a valid case
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state -- lpwszAppName not null", dwTestCase + 1);
+#else
+*/
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state -- lpszAppName not null", dwTestCase + 1);
+//#endif
+    if (! DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shut it down
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check invalid lphLineApp pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphLineApp pointers", dwTestCase + 1);
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lphLineApp =
+            (LPHLINEAPP) gdwInvalidPointers[n];
+        if (! DoLineInitialize(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lphLineApp pointer
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lphLineApp == lpdwNumDevs", dwTestCase + 1);
+    lpTapiLineTestInfo->lphLineApp = (LPHLINEAPP)lpTapiLineTestInfo->lpdwNumDevs;
+    if (! DoLineInitialize(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+        TLINE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+          { 
+            TLINE_FAIL();
+          }
+        }
+        }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lphLineApp pointer
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams   = GetCallbackParams();
+
+ 
+    // Check invalid lpfnCallback pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpfnCallback pointers", dwTestCase + 1);
+    lpTapiLineTestInfo->lpfnCallback_Orig = lpTapiLineTestInfo->lpfnCallback;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpfnCallback =
+            (LINECALLBACK) gdwInvalidPointers[n];
+        if (! DoLineInitialize(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpfnCallback pointer
+    lpTapiLineTestInfo->lpfnCallback = lpTapiLineTestInfo->lpfnCallback_Orig;
+
+    // Test an invalid lpdwNumDevs pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwNumDevs pointers", dwTestCase + 1);
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwNumDevs =
+            (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineInitialize(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpdwNumDevs pointer
+    lpTapiLineTestInfo->lpdwNumDevs = &(lpTapiLineTestInfo->dwNumDevs);
+
+    // test invalid instance handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hInstance values", dwTestCase + 1);
+    lpTapiLineTestInfo->hInstance_Orig = lpTapiLineTestInfo->hInstance;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        lpTapiLineTestInfo->hInstance = (HINSTANCE) gdwInvalidHandles[n];
+        if(n == 0)  // XYD, it is allowed hInstance = NULL
+        {       
+        if (! DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        { 
+            TLINE_FAIL();
+        }
+        }
+        else
+        {
+         if (! DoLineInitialize(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore original hInstance
+    lpTapiLineTestInfo->hInstance = lpTapiLineTestInfo->hInstance_Orig;
+
+// TODO:  Pass it bogus strings (e.g. a BINARY)
+//  // test an invalid app name
+//  lpTapiLineTestInfo->lpszAppName = INVLD_APPNAME;
+//  if (! DoLineInitialize(lpTapiLineTestInfo, LINEERR_INVALAPPNAME))
+//  {
+//      TLINE_FAIL();
+//  }
+//  lpTapiLineTestInfo->lpszAppName = lpszAppName;
+
+    // test a null app name (should work)
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state -- lpwszAppName null", dwTestCase + 1);
+    lpTapiLineTestInfo->lpwszAppName = NULL;
+#else
+*/
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state -- lpszAppName null", dwTestCase + 1);
+    lpTapiLineTestInfo->lpszAppName = NULL;
+//#endif
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+    if (! DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpszAppName pointer
+/*
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppName = lpwszAppName;
+#else
+*/
+    lpTapiLineTestInfo->lpszAppName = lpszAppName;
+//#endif
+
+    // Verify that the initialized line app instance can be used
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verifying hLineApp can be used", dwTestCase + 1);
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Initialize another line and verify that 0..dwNumDevs can be used
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verifying 0..dwNumDevs can be used", dwTestCase + 1);
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp2);
+    if (! DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID_Orig  = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    for (n = *lpTapiLineTestInfo->lpdwNumDevs - 1; n >= 0; n--)
+    {
+        lpTapiLineTestInfo->dwDeviceID = n;
+        if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+    }
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown the hLineApp
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown down the other initialized hLineApp
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test invalid app name pointers
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppName pointers", dwTestCase + 1);
+#else
+*/
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppName pointers", dwTestCase + 1);
+//#endif
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+         TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "n= %ld", n);
+/*
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAppName =
+            (LPWSTR) gdwInvalidPointers[n];
+#else
+*/
+         lpTapiLineTestInfo->lpszAppName =
+            (LPSTR) gdwInvalidPointers[n];
+//#endif
+
+        // Okay.  It's expensive to check every time for the NULL value
+        // in the array of pointer values to test, but efficiency isn't the
+        // point of these tests.  Doing it this way allows the NULL pointer
+        // value to be in the array without having to worry about where it
+        // is in the array of bad pointers.
+/*
+#ifdef WUNICODE
+        if (lpTapiLineTestInfo->lpwszAppName && ! DoLineInitialize(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+#else
+*/
+        if (lpTapiLineTestInfo->lpszAppName && ! DoLineInitialize(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+//#endif
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpszAppName pointer
+/*
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppName = lpwszAppName;
+#else
+*/
+    lpTapiLineTestInfo->lpszAppName = lpszAppName;
+//#endif
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Force REINIT & verify lineInit Fail", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    if(! DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+         TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_LINEDEVSTATE;
+    info.u.EspMsg.dwParam1 = LINEDEVSTATE_REINIT;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+	 lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+    lpTapiLineTestInfo->hCall1 = 0;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_REINIT;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine1,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_REINIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+            );
+
+    if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TLINE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "TestLineInitailize: Did not receive REINIT message.");
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+
+    if(! DoLineInitialize(lpTapiLineTestInfo, LINEERR_REINIT))
+      {
+         TLINE_FAIL();
+          GetLastTapiResult(&lastTapiResult);
+
+          if(lastTapiResult.lActual == TAPISUCCESS)
+           {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+           }
+       }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+/***********************(javedr - start)**********************************/
+// Most of these cases are covered above by isolating each parameter.
+// This case just tests the lineInitialize parameteres in one shot.
+// Check valid lphLineApp pointers
+// Test valid hInstance handles
+// Check valid lpfnCallback pointers - N/A (see below)
+// Test valid app name - lpszAppName
+// Test valid lpdwNumDevs
+
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params test: lphLineApp, hInstance, lpfnCallback, lpwszAppName, lpdwNumDevs", dwTestCase + 1);
+#else
+*/
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params test: lphLineApp, hInstance, lpfnCallback, lpszAppName, lpdwNumDevs", dwTestCase + 1);
+//#endif
+	// Initailize args to isolate test case
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams   = GetCallbackParams();
+
+	// Set all args to valid values
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+	lpTapiLineTestInfo->hInstance = NULL; //default value is NULL
+	// No need to do this since TapiLineTestInit() in tcore.c is already doing this.
+	// lpTapiLineTestInfo->lpfnCallback = TapiCallback;
+/*
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppName = lpwszAppName;
+#else
+*/
+    lpTapiLineTestInfo->lpszAppName = lpszAppName;
+//#endif
+	lpTapiLineTestInfo->lpdwNumDevs = &(lpTapiLineTestInfo->dwNumDevs);
+    if (! DoLineInitialize(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // // Shutdown to isolate the test case
+    if (!DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+/*************************(javedr - end)********************************/
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineInitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineInitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/line/itlmc.c b/private/tapi/qa/trapper/itest/line/itlmc.c
new file mode 100644
index 000000000..9813f7748
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlmc.c
@@ -0,0 +1,1198 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmc.c
+
+Abstract:
+
+    This module contains the test functions for lineMakeCall
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tline.h"
+
+#define DESTADDRESSSIZE 20
+#define NUMTOTALSIZES 5
+
+
+
+//  lineMakeCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized
+//     2)  Invalid hLines (test array of gdwInvalidHandles in itest.h)
+//     3)  Invalid lphCall pointers (test array of gdwInvalidPointers
+//         in itest.h)
+//     4)  Invalid lpCallParams pointers (test array of gdwInvalidPointers
+//         in itest.h)
+//     5)  Test combinations of allocation sizes and dwTotalSize values
+//         (see test case in this file for list)
+//     6)  Verify hCall is invalid if lineMakeCall fails (try lineDrop)
+//     7)  Verify LINE_CALLSTATE messages are sent to monitors when a call
+//         is made.
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineMakeCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+
+    BOOL fResult;
+    INT CallParamsSize = sizeof(LINECALLPARAMS);
+    INT nAllocIndex;
+    INT nTotalSizeIndex;
+    INT nCallParamsIndex;
+    INT nAddressIndex;
+    INT n;
+    DWORD dwAllocSize, dwTotalSize;
+    DWORD adwTotalSizes[] = {
+                       0,
+                       0x4,
+                       0x8,
+                       0xC,
+                       0x10,
+                       CallParamsSize - 1,
+                       CallParamsSize,
+                       CallParamsSize + 1,
+                       0x7FFFFFFF,
+                       0xFFFFFFFF
+                       };
+    LPLINECALLPARAMS alpCallParams[] = {
+            NULL
+ //           alpTapiLineTestInfo->lpCallParams
+            };
+#ifdef WUNICODE
+    LPWSTR alpwszAddresses[] = {
+            NULL,
+            L"55555"
+            };
+#else
+    LPSTR alpszAddresses[] = {
+            NULL,
+            "55555"
+            };
+#endif
+
+    INT nNumTotalSizes = sizeof(adwTotalSizes)  / sizeof(adwTotalSizes[0]);
+#ifdef WUNICODE
+    INT nNumAddresses  = sizeof(alpwszAddresses) / sizeof(alpwszAddresses[0]);
+#else
+    INT nNumAddresses  = sizeof(alpszAddresses) / sizeof(alpszAddresses[0]);
+#endif
+    INT nNumCallParams = sizeof(alpCallParams)  / sizeof(alpCallParams[0]);
+
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwFixedSize = sizeof(LINECALLPARAMS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+#else
+    CHAR szValidAddress[] = "55555";
+#endif
+    
+ 
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineMakeCall  <<<<<<<<"
+            );
+            
+    // Test uninitialized case.
+    // Note:  It is assumed that the parameter fStandAlone correctly
+    //        indicates if there are any other TAPI apps or threads
+    //        currently running.
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Initialize a line and open it
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with owner privilege
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Try some invalid hLines
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: invalid line handles", dwTestCase + 1
+        );
+    lpTapiLineTestInfo->hLine2 = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+
+        if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the original valid line handle
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine2;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Try some invalid call handle pointers
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid call handle pointers", dwTestCase + 1
+            );
+            
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lphCall = (LPHCALL) gdwInvalidPointers[n];
+
+        if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Perform a valid test
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCountryCode, -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+ 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->dwCountryCode = 0xffffffff;
+ 
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    // Drop the call, deallocate it, and start over.
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    // Test invalid pointer values for lpCallParams
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: invalid lpCallParams pointers", dwTestCase + 1
+        );
+        
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        // Skip the null case (because it's valid)
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         if ((LPLINECALLPARAMS) gdwInvalidPointers[n] != NULL)
+        {
+            lpTapiLineTestInfo->lpCallParams =
+                    (LPLINECALLPARAMS) gdwInvalidPointers[n];
+            if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lpCallParams
+    lpTapiLineTestInfo->lpCallParams = &lpTapiLineTestInfo->CallParams;
+
+    // Verify the call handle is invalid when lineMakeCall fails
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Verifying call handle is invalid when lineMakeCall fails",
+        dwTestCase +1
+        );
+   
+	 lpTapiLineTestInfo->lpCallStatus = (LPLINECALLSTATUS) AllocFromTestHeap(
+            sizeof(LINECALLSTATUS));
+    lpTapiLineTestInfo->lpCallStatus->dwTotalSize = sizeof(LINECALLSTATUS);
+
+    if (! DoLineGetCallStatus(
+            lpTapiLineTestInfo,
+            LINEERR_INVALCALLHANDLE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad dwTotalSize",	dwTestCase + 1
+        );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineMakeCall(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = dwFixedSize;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test Case 7: combinations of NULL and valid lpCallParams & lpszDestAddress
+    // Note:  All test cases are valid
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Testing combinations of lpCallParams and destination addresses",
+        dwTestCase + 1
+        );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (nCallParamsIndex = 0;
+         nCallParamsIndex < nNumCallParams;
+         nCallParamsIndex++)
+    {
+        for (nAddressIndex = 0; nAddressIndex < nNumAddresses; nAddressIndex++)
+        {
+            lpTapiLineTestInfo->lpCallParams = alpCallParams[nCallParamsIndex];
+#ifdef WUNICODE
+            lpTapiLineTestInfo->lpwszDestAddress = alpwszAddresses[nAddressIndex];
+#else
+            lpTapiLineTestInfo->lpszDestAddress = alpszAddresses[nAddressIndex];
+#endif
+            if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+                TLINE_FAIL();
+            }
+
+            // Go ahead and drop the call to free the line
+            if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+                TLINE_FAIL();
+            }
+
+            // Deallocate the call handle
+            if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+/*
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwOrigAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+            lpTapiLineTestInfo->lpwszDestAddress = alpwszAddresses[nAddressIndex];
+#else
+            lpTapiLineTestInfo->lpszDestAddress = alpszAddresses[nAddressIndex];
+#endif
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+            lpTapiLineTestInfo->lpwszDestAddress = alpwszAddresses[nAddressIndex];
+#else
+            lpTapiLineTestInfo->lpszDestAddress = alpszAddresses[nAddressIndex];
+#endif
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+            lpTapiLineTestInfo->lpwszDestAddress = alpwszAddresses[nAddressIndex];
+#else
+            lpTapiLineTestInfo->lpszDestAddress = alpszAddresses[nAddressIndex];
+#endif
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = BIGBUFSIZE;
+
+#ifdef WUNICODE
+            lpTapiLineTestInfo->lpwszDestAddress = alpwszAddresses[nAddressIndex];
+#else
+            lpTapiLineTestInfo->lpszDestAddress = alpszAddresses[nAddressIndex];
+#endif
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0xffffffff, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+            lpTapiLineTestInfo->lpwszDestAddress = alpwszAddresses[nAddressIndex];
+#else
+            lpTapiLineTestInfo->lpszDestAddress = alpszAddresses[nAddressIndex];
+#endif
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+*/
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineMakeCall(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_CALLUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineMakeCall(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineMakeCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineMakeCall  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlmc1.c b/private/tapi/qa/trapper/itest/line/itlmc1.c
new file mode 100644
index 000000000..735f1fe74
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlmc1.c
@@ -0,0 +1,8931 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmc1.c
+
+Abstract:
+
+    This module contains the test functions for lineMakeCall Addtion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)         7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "tline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineMakeCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//
+
+BOOL TestLineMakeCall1(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams = NULL;
+    DWORD dwAllocSize, dwTotalSize;
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+#else
+    CHAR szValidAddress[] = "55555";
+#endif
+
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+	DBUG_SHOW_PASS,
+	"\n****************************************************");
+
+    OutputTAPIDebugInfo(
+	DBUG_SHOW_PASS,
+	">> Test lineMakeCall");
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwOrigAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+ 
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDisplayableAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwCalledPartyAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwComment Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwUserUserInfo Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwHighLevelComp Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwLowLevelComp Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDevSpecificAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+/*
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwTargetAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwSendingFlowspec Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwReceivingFlowspec Offset value");
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDeviceClass Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDeviceConfig Offset value");
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwCallData Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwCallingPartyID Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+*/
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"@@ LineMakeCall1: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+	dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+	dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	">>>>>>>>  End testing LineMakeCall  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+	fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlmc2.c b/private/tapi/qa/trapper/itest/line/itlmc2.c
new file mode 100644
index 000000000..4185bb33c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlmc2.c
@@ -0,0 +1,8932 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmc2.c
+
+Abstract:
+
+    This module contains the test functions for lineMakeCall Addtion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)         7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "tline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineMakeCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//
+
+BOOL TestLineMakeCall2(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams = NULL;
+    DWORD dwAllocSize, dwTotalSize;
+#ifdef WUNICODE
+    WCHAR wszValidAddress[] = L"55555";
+#else
+    CHAR szValidAddress[] = "55555";
+#endif
+
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+	DBUG_SHOW_PASS,
+	"\n****************************************************");
+
+    OutputTAPIDebugInfo(
+	DBUG_SHOW_PASS,
+	">> Test lineMakeCall");
+
+/*
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwOrigAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+ 
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDisplayableAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwCalledPartyAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwComment Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwUserUserInfo Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwHighLevelComp Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwLowLevelComp Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDevSpecificAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+*/
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwTargetAddress Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwSendingFlowspec Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwReceivingFlowspec Offset value");
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDeviceClass Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwDeviceConfig Offset value");
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwCallData Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case: Test lpCallParam dwCallingPartyID Offset value");
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwAllocSize + 16;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"#### Test Case %ld: Offset value = 0XFFFFFFFF",
+	dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+	 (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+	 sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+	 sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+	 LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+	0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+	    sizeof(LINEDEVCAPS)
+	    );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+	 BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = 0xffffffff;
+
+#ifdef WUNICODE
+	    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+	 TLINE_FAIL();
+      }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"@@ LineMakeCall1: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+	dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	"@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+	dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+	DBUG_SHOW_PASS,
+	">>>>>>>>  End testing LineMakeCall  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+	fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlnapiv.c b/private/tapi/qa/trapper/itest/line/itlnapiv.c
new file mode 100644
index 000000000..f73d6ffe7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlnapiv.c
@@ -0,0 +1,625 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlnapiv.c
+
+Abstract:
+
+    This module contains the test functions for lineNegotiateAPIVersion
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+
+//  lineNegotiateAPIVersion
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized
+//     2)  Valid (low == too low, high = valid high)
+//     3)  Valid (low == valid low, high = too high)
+//     4)  Valid (low == too low, high = too high)
+//     5)  Invalid (low == too high, high = too low)
+//     6)  Invalid (low == too high, high = way too high)
+//     7)  Invalid (low == too low, high = way too low)
+//     8)  Invalid hLineApps
+//     9)  Invalid lpExtensionID pointers
+//    10)  Invalid lpdwAPIVersion pointers
+//    11)  Invalid dwDeviceID (-1, dwNumDevs)
+//
+//  * = Stand-alone test case
+//
+
+BOOL TestLineNegotiateAPIVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed = TRUE;
+    CHAR szTestFunc[]                 = "lineNegotiateAPIVersion";
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    
+    strcpy(lpTapiLineTestInfo->szTestFunc, szTestFunc);
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineNegotiateAPIVersion  <<<<<<<<"
+            );
+
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized state", dwTestCase + 1);
+        if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+            
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test a valid negotiation
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid version range that overlaps with valid version", dwTestCase + 1);
+
+    // Initialize another hLineApp
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Test a version range that overlaps with existing versions of TAPI
+    lpTapiLineTestInfo->dwAPILowVersion = TOOLOW_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid range that overlaps on the high end", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+        
+    // Test a range that is exceedingly high (but still overlaps
+    // with a compatible version
+    lpTapiLineTestInfo->dwAPIHighVersion = TOOHIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid API version range", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    // Initialize a line app instance
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test an incompatible version range (for all versions of the API)
+    lpTapiLineTestInfo->dwAPILowVersion  = TOOHIGH_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = WAYTOOHIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(
+                   lpTapiLineTestInfo,
+                   LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: high version too low and low version too high", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Flip high and low and see if the result is an incompatible version
+    // and make sure both values are incompatible versions
+    lpTapiLineTestInfo->dwAPILowVersion  = TOOHIGH_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = TOOLOW_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(
+                   lpTapiLineTestInfo,
+                   LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // TODO: Test for specific versions
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwDeviceID (-2)", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check bad device ID (-2)   0xFFFFFFFF is valid in TAPI 2.0
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = 0xFFFFFFFE;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwDeviceID (dwNumDevs)", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check bad device ID (dwNumDevs)
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = *lpTapiLineTestInfo->lpdwNumDevs;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLineApp handles", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check invalid line app handles
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLineApp = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineNegotiateAPIVersion(
+                lpTapiLineTestInfo,
+                LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the valid line app handle
+    *lpTapiLineTestInfo->lphLineApp = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwAPIVersion pointers", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check invalid lpdwAPIVersion pointers
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwAPIVersion =
+                (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineNegotiateAPIVersion(
+                lpTapiLineTestInfo,
+                LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the lpdwAPIVersion pointer
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpdwAPIVersion == lpExtensionID", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpdwAPIVersion = (LPDWORD) lpTapiLineTestInfo->lpExtID;
+    if (! DoLineNegotiateAPIVersion(
+                lpTapiLineTestInfo,
+                LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore the lpdwAPIVersion pointer
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionID pointers", dwTestCase + 1);
+    
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check invalid lpExtensionID pointers
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtID =
+                (LPLINEEXTENSIONID) gdwInvalidPointers[n];
+        if (! DoLineNegotiateAPIVersion(
+                lpTapiLineTestInfo,
+                LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Restore the extension ID pointer
+    lpTapiLineTestInfo->lpExtID = &lpTapiLineTestInfo->ExtID;
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT; 
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+ 				);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, info.u.EspResult.lResult))
+       {
+          TLINE_FAIL();
+       }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap(); 
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_NODEVICE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineNegotiateAPIVersion: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+ 	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineNegotiateAPIVersion  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itlo.c b/private/tapi/qa/trapper/itest/line/itlo.c
new file mode 100644
index 000000000..a35756560
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlo.c
@@ -0,0 +1,1129 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlo.c
+
+Abstract:
+
+    This module contains the test functions for lineOpen
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+#define ESPDEVSPECIFIC_KEY  ((DWORD) 'DPSE')
+
+#define ESP_DEVSPEC_MSG     1
+
+#define NUMTOTALSIZES            6
+
+
+//  lineOpen
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized
+//     2)  Invalid hLineApps
+//     3)  Invalid dwDeviceID (-1, dwNumDevs)
+//     4)  Invalid lphLine pointers
+//     5)  Invalid API version (too low, too high)
+//     6)  Test Invalid bit flag combinations for dwPrivileges
+//     7)  Test Valid bit flag combinations for dwPrivileges
+//     8)  Verify hLine is invalid if lineOpen fails (try closing hLine)
+//     9)  Invalid lpCallParams pointers (when dwDeviceID == LINEMAPPER)
+//    10)  Test different allocation sizes and dwTotalSize values for
+//         lpCallParams (when dwDeviceID == LINEMAPPER)
+//    11)  Invalid extension version (not tested here yet...will be tested
+//         in SP specific tests)
+//    12)  Verify dwMediaModes is ignored if line not opened as owner
+//    13)  Test invalid bit flag combinations for dwMediaModes
+//         where SP returns 0 for the extension ID
+//    14)  Test invalid bit flag combinations for dwMediaModes
+//         where SP returns a valid extension ID (when privilege
+//         is owner)
+//    15)  Test valid bit flag combinations for dwMediaModes
+//         when privilege is monitor
+//    16)  Test valid bit flag combinations for dwMediaModes
+//         when privilege is owner
+//
+
+BOOL TestLineOpen(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+    BOOL fStepPassed;
+    ESPDEVSPECIFICINFO   info;
+    TAPIRESULT lastTapiResult;
+    DWORD lResult;
+
+    BOOL fTestPassed                  = TRUE;
+    LINECALLPARAMS CallParams;
+    LPCALLBACKPARAMS lpCallbackParams;
+    size_t CallParamsSize = sizeof(LINECALLPARAMS);
+    DWORD dwAllMediaModes;
+    DWORD dwAllPrivileges;
+    DWORD dwResult;
+    DWORD dwFixedSize = sizeof(LINECALLPARAMS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+									0x4,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams   = GetCallbackParams();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineOpen");
+    lpTapiLineTestInfo->lpExtID          = (LPLINEEXTENSIONID)
+            AllocFromTestHeap(sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->lpCallParams     = &(lpTapiLineTestInfo->CallParams);
+//    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineOpen  <<<<<<<<"
+            );
+            
+    // Test for LINEERR_UNINITIALIZED if this is the only TAPI app running
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+        if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    // Prepare a line for testing
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Assign the unions of all the valid bit flags for the media modes
+    // and the privileges.  These unions will be used for testing valid
+    // and invalid bit flag combinations.
+    //
+    // TODO:  All media modes should be tested, but for this set of
+    //        general tests it might be better to only test valid media
+    //        modes as those that are supported by the device.
+    //        The remaining media modes could be tested elsewhere,
+    //        such as in the set of SP/device specific test dll.
+    dwAllMediaModes = (LINEMEDIAMODE_UNKNOWN          |
+                       LINEMEDIAMODE_INTERACTIVEVOICE |
+                       LINEMEDIAMODE_AUTOMATEDVOICE   |
+                       LINEMEDIAMODE_DATAMODEM        |
+                       LINEMEDIAMODE_G3FAX            |
+                       LINEMEDIAMODE_TDD              |
+                       LINEMEDIAMODE_G4FAX            |
+                       LINEMEDIAMODE_DIGITALDATA      |
+                       LINEMEDIAMODE_TELETEX          |
+                       LINEMEDIAMODE_VIDEOTEX         |
+                       LINEMEDIAMODE_TELEX            |
+                       LINEMEDIAMODE_MIXED            |
+                       LINEMEDIAMODE_ADSI);
+    if (*(lpTapiLineTestInfo->lpdwAPIVersion) >= TAPI_VERSION1_4)
+    {
+        // version 1.4 added voice view media mode
+        dwAllMediaModes |= LINEMEDIAMODE_VOICEVIEW;
+    }
+
+    dwAllPrivileges = (LINECALLPRIVILEGE_NONE         |
+                       LINECALLPRIVILEGE_MONITOR      |
+                       LINECALLPRIVILEGE_OWNER);
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check some invalid lphLine pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphLine pointers", dwTestCase + 1);
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+        lpTapiLineTestInfo->lphLine =
+            (LPHLINE) gdwInvalidPointers[n];
+        if (! DoLineOpen(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore lphLine pointer
+    lpTapiLineTestInfo->lphLine = &(lpTapiLineTestInfo->hLine1);
+
+    // test invalid hLineApps
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLineApps", dwTestCase + 1);
+    lpTapiLineTestInfo->hLineApp_Orig = *(lpTapiLineTestInfo->lphLineApp);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore original hLineApp
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Check bad device ID (-2) (Don't test -1 because LINEMAPPER == -1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad dwDeviceID (-2)", dwTestCase + 1);
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = 0xFFFFFFFE;
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Check bad device ID (dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad dwDeviceID (dwNumDevs)", dwTestCase + 1);
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Check incompatible API version (too low)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    lpTapiLineTestInfo->dwAPIVersion_Orig =
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lpdwAPIVersion = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Check incompatible API version (too high)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    lpTapiLineTestInfo->dwAPIVersion_Orig =
+            *(lpTapiLineTestInfo->lpdwAPIVersion);
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOHIGH_APIVERSION;
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Check incompatible extension version
+//  dwExtVersion_Orig = *(TapiLineTestInfo->lpdwExtVersion);
+//  *(TapiLineTestInfo->lpdwExtVersion) = BAD_EXTVERSION;
+//  if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INCOMPATIBLEEXTVERSION))
+//  {
+//      TLINE_FAIL();
+//  }
+//  *(lpTapiLineTestInfo->lpdwExtVersion) = dwExtVersion_Orig;
+
+    // Make sure dwMediaModes is ignored when LINECALLPRIVILEGE_MONITOR is set
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify dwMediaModes is ignored when LINECALLPRIVILEGE_MONITOR", dwTestCase + 1);
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwMediaModes_Orig = lpTapiLineTestInfo->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges_Orig = lpTapiLineTestInfo->dwPrivileges;
+    lpTapiLineTestInfo->dwPrivileges      = LINECALLPRIVILEGE_MONITOR;
+    if (! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineOpen,
+            (LPDWORD)&lpTapiLineTestInfo->dwMediaModes,
+            FIELDTYPE_UNION,
+            FIELDTYPE_UNION,
+            FIELDSIZE_24,
+            dwAllMediaModes,
+            ~dwBitVectorMasks[(int)FIELDSIZE_24],
+            0x00000000,
+            0x00000000,
+            TRUE ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwMediaModes = lpTapiLineTestInfo->dwMediaModes_Orig;
+    lpTapiLineTestInfo->dwPrivileges = lpTapiLineTestInfo->dwPrivileges_Orig;
+
+    // Make sure dwMediaModes is ignored when LINECALLPRIVILEGE_NONE is set
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify dwMediaModes is ignored when LINECALLPRIVILEGE_NONE", dwTestCase + 1);
+    lpTapiLineTestInfo->dwMediaModes_Orig = lpTapiLineTestInfo->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges_Orig = lpTapiLineTestInfo->dwPrivileges;
+    lpTapiLineTestInfo->dwPrivileges      = LINECALLPRIVILEGE_NONE;
+    if (! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineOpen,
+            (LPDWORD)&lpTapiLineTestInfo->dwMediaModes,
+            FIELDTYPE_UNION,
+            FIELDTYPE_UNION,
+            FIELDSIZE_24,
+            dwAllMediaModes,
+            ~dwBitVectorMasks[(int)FIELDSIZE_24],
+            0x00000000,
+            0x00000000,
+            TRUE ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwMediaModes = lpTapiLineTestInfo->dwMediaModes_Orig;
+    lpTapiLineTestInfo->dwPrivileges = lpTapiLineTestInfo->dwPrivileges_Orig;
+
+    // Check for invalid media mode when LINECALLPRIVILEGE_OWNER is set
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid media modes when LINECALLPRIVILEGE_OWNER", dwTestCase + 1);
+    lpTapiLineTestInfo->dwPrivileges_Orig = lpTapiLineTestInfo->dwPrivileges;
+    lpTapiLineTestInfo->dwMediaModes_Orig = lpTapiLineTestInfo->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges      = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes      = 0x0;
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INVALMEDIAMODE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore dwMediaModes and dwPrivileges
+    lpTapiLineTestInfo->dwMediaModes = lpTapiLineTestInfo->dwMediaModes_Orig;
+    lpTapiLineTestInfo->dwPrivileges = lpTapiLineTestInfo->dwPrivileges_Orig;
+
+    // Check invalid privilege selection
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwPrivileges", dwTestCase + 1);
+    lpTapiLineTestInfo->dwPrivileges_Orig = lpTapiLineTestInfo->dwPrivileges;
+    if (! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineOpen,
+            (LPDWORD)&lpTapiLineTestInfo->dwPrivileges,
+            LINEERR_INVALPRIVSELECT,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            dwAllPrivileges,
+            ~dwBitVectorMasks[(int)FIELDSIZE_32],
+            0x00000000,
+            LINECALLPRIVILEGE_OWNER | LINECALLPRIVILEGE_NONE,
+            TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwPrivileges = lpTapiLineTestInfo->dwPrivileges_Orig;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest for dwPrivileges", dwTestCase + 1);
+    lpTapiLineTestInfo->dwPrivileges_Orig = lpTapiLineTestInfo->dwPrivileges;
+    if (! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineOpen,
+            (LPDWORD)&lpTapiLineTestInfo->dwPrivileges,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            dwAllPrivileges,
+            ~dwBitVectorMasks[(int)FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwPrivileges = lpTapiLineTestInfo->dwPrivileges_Orig;
+
+
+// BUGBUG??  What generates a LINEMAPPERFAILED error?
+#if 0
+    // Test Case : Check invalid CallParams when LINEMAPPER set as the deviceID
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = LINEMAPPER;
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS);
+    lpTapiLineTestInfo->dwPrivileges_Orig = lpTapiLineTestInfo->dwPrivileges;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes_Orig = 
+            lpTapiLineTestInfo->lpCallParams->dwMediaMode;
+    lpTapiLineTestInfo->lpCallParams->dwMediaMode = LINECALLPRIVILEGE_OWNER |
+                                                    LINECALLPRIVILEGE_MONITOR |
+                                                    LINECALLPRIVILEGE_NONE;
+    lpTapiLineTestInfo->lpCallParams->dwAddressID =
+            lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_LINEMAPPERFAILED))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+    lpTapiLineTestInfo->lpCallParams->dwMediaMode =
+            lpTapiLineTestInfo->dwMediaModes_Orig;
+    lpTapiLineTestInfo->dwPrivileges = lpTapiLineTestInfo->dwPrivileges_Orig;
+
+    // Verify that the line cannot be used if lineOpen failed
+    if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#endif
+
+    // Try the set of invalid media modes
+    // TODO:  Right now there is no hook to set the extension ID.
+    //        Whether or not this value is 0 has an impact on
+    //        how the media modes are tested.  For now, only
+    //        test invalid media modes if no extensionID bits are set.
+    lpTapiLineTestInfo->dwMediaModes_Orig = lpTapiLineTestInfo->dwMediaModes;
+    if (DoExtensionIDsMatch(
+            lpTapiLineTestInfo->lpExtID,
+            &lpTapiLineTestInfo->ExtIDZero))
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: invalid media modes (including extensions)", dwTestCase + 1);
+      //  if (! TestInvalidBitFlags(
+        dwResult = TestInvalidBitFlags(
+                        lpTapiLineTestInfo,
+                        DoLineOpen,
+                        &lpTapiLineTestInfo->dwMediaModes,
+                        LINEERR_INVALMEDIAMODE,
+                        FIELDTYPE_UNION,
+                        FIELDTYPE_UNION,
+                        FIELDSIZE_24,
+                        dwAllMediaModes,
+                        0x00000000,
+                        0x00000000,
+                        0x00000000,
+                        TRUE);
+        if(!dwResult)
+        {
+          // XYD, it is hard to change TestInvalidBitFlags for special case
+          // So force it to be Success.  when dwMediaMode >= 1000000 for ESP
+          // lineOpen return Success
+          if(IsESPLineDevice(lpTapiLineTestInfo) )
+          {
+            fTestPassed = TRUE;
+            dwResult = TRUE;
+          }
+        }
+        if(!dwResult)
+        {
+ 
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Test invalid lpCallParams pointers (only useful when using LINEMAPPER)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallParams when dwDeviceID == LINEMAPPER", dwTestCase + 1);
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID_Orig;
+    lpTapiLineTestInfo->dwDeviceID      = LINEMAPPER;
+    lpTapiLineTestInfo->lpCallParams = &lpTapiLineTestInfo->CallParams;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpCallParams =
+            (LPLINECALLPARAMS) gdwInvalidPointers[n];
+        if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lpCallParams    = &lpTapiLineTestInfo->CallParams;
+    lpTapiLineTestInfo->dwDeviceID      = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize & verify hLine can't be used", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID      = LINEMAPPER;
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineOpen(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = dwFixedSize;
+        if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwExtVersion", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->dwExtVersion = BAD_EXTVERSION;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_INCOMPATIBLEEXTVERSION))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwExtVersion = 0x00000000;
+
+
+    // Shutdown the lineApp instance
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, open as monitor", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Stress test, call continue in a loop", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for(n=0; n< 1000; n++)
+    {
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Force a REINIT msg", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {	  
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_LINEDEVSTATE;
+    info.u.EspMsg.dwParam1 = LINEDEVSTATE_REINIT;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+	 lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+    lpTapiLineTestInfo->hCall1 = 0;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_REINIT;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    AddMessage(
+            LINE_LINEDEVSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine1,
+            (DWORD) lpCallbackParams,
+            LINEDEVSTATE_REINIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+            );
+
+    if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TLINE_FAIL();
+    }
+
+	 lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_REINIT))
+       {
+          TLINE_FAIL();
+        
+          GetLastTapiResult(&lastTapiResult);
+
+          if(lastTapiResult.lActual == TAPISUCCESS)
+           {
+            if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+           }
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+//    lpTapiLineTestInfo->hLine_Orig  = lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_NONE;
+    lpTapiLineTestInfo->dwExtVersion = 0x0;
+    lResult = DoLineOpen(lpTapiLineTestInfo, info.u.EspResult.lResult);
+    if(!lResult)
+      {
+          TLINE_FAIL();
+      }
+    else
+      {
+      if ( ! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+      }  
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+   
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d, dwExtVer = 0",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_NODRIVER;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwDeviceID = 1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+//    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_NONE;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = dwAllMediaModes;
+    lpTapiLineTestInfo->dwExtVersion = 0x0;
+    if(! DoLineOpen(lpTapiLineTestInfo, info.u.EspResult.lResult))
+       {
+        TLINE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+       }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+		  
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d, dwExtVer = 1",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INCOMPATIBLEEXTVERSION;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwDeviceID = 1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_NONE;
+    lpTapiLineTestInfo->dwExtVersion = 0x1;
+    if(! DoLineOpen(lpTapiLineTestInfo, info.u.EspResult.lResult))
+       {
+          TLINE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+       }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+		  
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d, OWNER, INTERACTIVEVOICE",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_NODRIVER;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwExtVersion = 0x0;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_INTERACTIVEVOICE;
+
+    if(! DoLineOpen(lpTapiLineTestInfo, info.u.EspResult.lResult))
+       {
+          TLINE_FAIL();
+       }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+		  
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineOpen: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineOpen  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line/itls.c b/private/tapi/qa/trapper/itest/line/itls.c
new file mode 100644
index 000000000..00509ccd8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itls.c
@@ -0,0 +1,993 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itls.c
+
+Abstract:
+
+    This module contains the test functions for lineShutdown
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tline.h"
+
+
+//  lineShutdown
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hLineApps
+//     3)  Verify hLineApp can't be reused (no other hLineApps exist)
+//     4)  Verify hLineApp can't be reused (1 other hLineApp exists)
+//     5)  Shutdown hLineApp after lineInitialize fails
+//     6)  Verify LINECALLINFO/NUMMONITORS msg sent when hLineApp shutdown
+//         (2 call clients [one owner, one monitor] on 2 different hLineApps)
+//     7)  Verify LINECALLINFO/NUMOWNERDECR msg sent when hLineApp shutdown
+//         (2 call clients [both owners] on 2 different hLineApps)
+//     8)  Verify LINECALLINFO/NUMMONITORS msg sent when hLineApp shutdown
+//         (2 call clients [both monitors] on 2 different hLineApps)
+//     9)  Shutdown while a call is in progress and verify
+//         that the call handle, line handle, and line app handle are
+//         no longer valid
+//    10)  Shutdown while a line is open with owner privilege and verify
+//         line handle is invalid
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineShutdown(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT                 n;
+    BOOL                fResult;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+    HCALL hCall;
+ 	 LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+	 LONG lret;
+	 LPTAPIMSG lpMsg;
+    LINEINITIALIZEEXPARAMS 	lineInitializeExParams1;
+    LINEINITIALIZEEXPARAMS 	lineInitializeExParams2;
+
+
+    InitTestNumber();
+	 TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineShutdown");
+    
+    lpTapiLineTestInfo->dwCallbackInstance  =
+            (DWORD) GetCallbackParams();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineShutdown  <<<<<<<<"
+            );
+            
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: invalid hLineApp handles", dwTestCase + 1
+            );
+            
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Test bad line app handles (uses &lpTapiLineTestInfo->hLineApp1)
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Use &hLineApp2 to test invalid handles
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp2);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+   
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Restore lpTapiLineTestInfo->lphLineApp to point to &hLineApp1
+    // Note:  hLineApp1 is a valid initialized handle
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+
+    // Might as well test valid shutdown now
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: Success, valid params and state (no active calls)", dwTestCase + 1
+            );
+            
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Test that shutdown fails when there are no line handles initialized
+    // no lines are initialized (hLineApp should be invalid)
+    // If this is a stand-alone test (no other TAPI apps are running)
+    // then LINEERR_UNINITIALIZED will be the expected return value.
+    // Otherwise, LINEERR_INVALAPPHANDLE should be returned.
+    if (fStandAloneTest)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: uninitialized state", dwTestCase + 1
+            );
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+/*
+    else
+    {
+    
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">>  Test Case %ld: invalid hLineApp handle", dwTestCase + 1
+                );
+            
+        if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+*/
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: hLineApp can't be shutdown if lineInitialize fails", dwTestCase + 1
+            );
+            
+    // Initialize a valid line app instance to prevent the possibility
+    // of receiving an UNINITIALIZED error during the next test
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp3;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    // Backup the hLineApp and use a different one for the next test
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+
+    // Verify that an app handle can't be used in a shutdown call
+    // if lineInitialize returned an error prior to shutdown attempt
+    lpTapiLineTestInfo->lpdwNumDevs = NULL;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lpdwNumDevs = &(lpTapiLineTestInfo->dwNumDevs);
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: hLineApp can't be used after shutdown (>= 1 hLineApps)", dwTestCase + 1
+            );
+            
+    // Verify that an app handle can't be reused after it's been
+    // shutdown by another line abstraction in use
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the initialized app handle
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+
+    // Initialize another app handle
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown a handle
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown another handle
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp2);
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // make sure app handle can't be reused (1 other hLineApp exists).
+    // Test first app handle shutdown
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+    if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Prepare to open a line, make a call, and try shutting it down.
+    // Next verify that the hCall, the hLine, and the hLineApp
+    // are no longer valid after the shutdown.
+
+    // First, initialize a spare hLineApp to prevent UNINITIALIZED errors
+    // from being returned if this is the only TAPI app running.
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: hLine, hCall, and hLineApp are invalid after shutdown", dwTestCase + 1
+            );
+
+                        
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Negotiate the API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Allocate lpLineDevCaps
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Call handle should be invalid
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    // The line should be closed
+    if (! DoLineClose(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    // The line app instance should be invalid
+    if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: valid shutdown of opened line with owner privilege", dwTestCase + 1
+            );
+            
+    // Take the remaining hLineApp, open a line with owner privilege,
+    // and shutdown (Verifies NT BUG #10179 is fixed)
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp3;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Currently, there should be no lines initialized from this thread.
+    // First, initialize a couple of different line app instances.
+    // Open the same line device for each hLineApp (one as owner and
+    // one as monitor).  Next, make a call with the owner.  After the
+    // call proceeds to the connected state, shutdown the monitor.
+    // The owner should receive a LINE_CALLINFO/NUMMONITORS message
+    // to indicate that the number of monitors has decremented.
+    //
+    // Note:  To be sure that this message is sent as a result of the
+    //        shutdown in this thread, no other threads or applications
+    //        can be using the device during the test.
+    //
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: LINE_CALLINFO/NUMMONITORS message sent to owner\r\n" \
+            ">>  (same hLineApp)", dwTestCase + 1
+            );
+            
+    // Initialize 2 hLineApps
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLineApp2 = *(lpTapiLineTestInfo->lphLineApp);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the API version (It's been done before, but doing it again
+    // removes dependencies from previous test results).
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Allocate a new lpLineDevCaps pointer
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line device as monitor (dwMediaModes is ignored)
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with a different line app registration as owner with
+    // dwMediaModes set equal to what the line device can accomodate
+    lpTapiLineTestInfo->lphLineApp   = &(lpTapiLineTestInfo->hLineApp2);
+    lpTapiLineTestInfo->lphLine      = &(lpTapiLineTestInfo->hLine2);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+// BUGBUG
+//          lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Make a call on the line opened as owner
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown the monitor and verify that the owner receives a message
+    // indicating the number of monitors on the line has changed
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp1);
+    fResult = DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS);
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    // Add the expected LINE_CALLINFO message to the list of
+    // expected TAPI messages and wait for it
+    // Note:  The lpCallbackParams value will make this expected message
+    //        unique.  Therefore, if another app is monitoring this line
+    //        and it is closed, the message will not precisely match.
+    if (fResult)
+    {
+        AddMessage(
+            LINE_CALLINFO,
+            (DWORD) *lpTapiLineTestInfo->lphCall,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+    }
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Drop the call by closing the line (lpTapiLineTestInfo->lphLine
+    // still points to the line handle of the owner)
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Next open the same line device on two different app registrations.
+    // Initially, open one as owner, and the other as a monitor.  Make a
+    // call via the owner.  Set the call privilege of the monitor to owner.
+    // Go ahead and verify that a LINE_CALLINFO/NUMOWNERINCR message is
+    // sent.  Shutdown one of the owners and verify that a LINE_CALLINFO/
+    // NUMOWNERDECR message is sent to the other owner after the shutdown.
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: LINE_CALLINFO/NUMOWNERINCR & DECR msgs are sent\r\n" \
+            ">>  (different hLineApps)", dwTestCase + 1
+            );
+
+	 TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+ 
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lpLineInitializeExParams = &lineInitializeExParams1;
+
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lpLineInitializeExParams = &lineInitializeExParams2;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine      = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine      = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    fResult = DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE);
+ 
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    lpMsg = AddMessage(LINE_CALLSTATE, 0, 0, 0, 0, 0, TAPIMSG_DWMSG);
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+     }
+
+   lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp2;
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_CALLSTATE;
+	lpMatch->dwParam1 = 0;
+   lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+	if(FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE))
+	{
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+ 	*lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+	}
+   else
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    fResult = DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS);
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Add the messages only if lineSetCallPrivilege succeeded
+    if (fResult)
+    {
+        AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERDECR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1 |
+//                    TAPIMSG_HDEVCALL
+            );
+    }
+
+    // Wait for the unsolicited messages to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    fResult = DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS);
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+
+    if (fResult)
+    {
+        AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERINCR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG 
+//| TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1 |
+//                    TAPIMSG_HDEVCALL
+            );
+    }
+
+    // Wait for the unsolicited messages to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMOWNERDECR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG 
+// | TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1 |
+//                    TAPIMSG_HDEVCALL
+            );
+
+    // Wait for the unsolicited messages to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + sizeof(HCALL) );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) + sizeof(HCALL);
+
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+ 
+     GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+     AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG 
+// | TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1 |
+//                    TAPIMSG_HDEVCALL
+            );
+
+    // Wait for the unsolicited messages to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+ 	 lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG 
+// | TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1 |
+//                    TAPIMSG_HDEVCALL
+            );
+
+    // Wait for the unsolicited messages to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+ 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	 FreeTestHeap();
+
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: LINE_CALLINFO/NUMOWNERINCR & DECR msgs are sent\r\n" \
+            ">>  (different hLineApps)", dwTestCase + 1
+            );
+
+	 TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+ 
+    lpTapiLineTestInfo->lphLineApp   = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine      = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Initialize a second line app (lpTapiLineTestInfo->hLineApp2).
+    lpTapiLineTestInfo->lphLineApp = &(lpTapiLineTestInfo->hLineApp2);
+    lpTapiLineTestInfo->lphLine    = &(lpTapiLineTestInfo->hLine2);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open as a monitor (assume the device caps haven't changed, and
+    // the same device is being used as in the previous test).
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+    // Make a call with the owner
+    lpTapiLineTestInfo->lphLine = &(lpTapiLineTestInfo->hLine1);
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    fResult = DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE);
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    if (fResult)
+    {
+        // Add an expected message for the monitor to receive a LINE_CALLSTATE
+        // message informing the app that an outbound call has been established
+        // on the line
+        lpMsg = AddMessage(
+            LINE_CALLSTATE,
+            0x00000000,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_UNKNOWN,
+            0x00000000,
+            LINECALLPRIVILEGE_MONITOR,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST | 
+                    TAPIMSG_DWPARAM1 |
+                    TAPIMSG_DWPARAM3
+                );
+      lpMsg = AddMessage(LINE_CALLSTATE, 0, 0, 0, 0, 0, TAPIMSG_DWMSG);
+    }
+
+    // Wait for the asynchronous reply to the owner and the callstate
+    // message to the monitor.
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+     }
+
+
+    // Change the call privilege of the monitor to owner and see if
+    // LINE_CALLINFO/NUMMONITORS and LINE_CALLINFO/NUMOWNERINCR messages
+    // are received.
+
+    // Store the call handle for the owner with hLine2 and hLineApp2
+    lpTapiLineTestInfo->hCall2 = *(lpTapiLineTestInfo->lphCall);
+ 
+    // Get the call handle from the LINECALLSTATE message that the monitor
+    // received.
+     XYD
+    *lpTapiLineTestInfo->lphCall = (HCALL) CallbackParamsGetDevCallHandle(
+            lpCallbackParams,
+            LINE_CALLSTATE
+            );
+    
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_CALLSTATE;
+	lpMatch->dwParam1 = LINECALLSTATE_DIALING;
+	lpMatch->dwParam3 = LINECALLPRIVILEGE_MONITOR;
+	lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM3;
+
+	if(FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE))
+	{
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+ 	*lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+	}
+   else
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Take ownership of the call (After this is called, there will be two
+    // owners of the call on different line app registrations.).
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    fResult = DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS);
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Add the messages only if lineSetCallPrivilege succeeded
+    if (fResult)
+    {
+        // Add an expected message for the original owner to receive a
+        // LINE_CALLINFOSTATE message informing the app that the number of
+        // monitors on the line has changed (decremented by 1) and the
+        // number of owners has increased.
+        AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERINCR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST | TAPIMSG_DWPARAM1 |
+                    TAPIMSG_HDEVCALL
+            );
+    }
+
+    // Wait for the unsolicited messages to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown one of the line apps and see if the other owner receives
+    // a LINE_CALLINFOSTATE message informing the app that the number of
+    // owners has decreased.
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    fResult = DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS);
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    // Only add the message if the shutdown succeeded
+    if (fResult)
+    {
+        AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMOWNERDECR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_ALL
+            );
+    }
+
+    // Wait for the unsolicited message to be sent
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown the other line app
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Free the memory taken from the heap
+    FreeTestHeap();
+*/ 
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineShutdown: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineShutdown  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/line/itlscp.c b/private/tapi/qa/trapper/itest/line/itlscp.c
new file mode 100644
index 000000000..8898a4325
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlscp.c
@@ -0,0 +1,548 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscp.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallPrivilege
+
+Author:
+
+    Oliver Wallace (OliverW)    10-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+#define    ALL_LINECALLPRIVILEGES  (LINECALLPRIVILEGE_NONE         | \
+                                    LINECALLPRIVILEGE_MONITOR      | \
+                                    LINECALLPRIVILEGE_OWNER)
+
+#define    ALL_LINECALLPRIVILEGE   (LINECALLPRIVILEGE_MONITOR      | \
+                                    LINECALLPRIVILEGE_OWNER)
+
+#define    DWNUMCALLS  1
+
+
+//  lineSetCallPrivilege
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hCalls
+//     3)  Test invalid bit flag combinations for dwCallPrivilege
+//     4)  Test valid bit flag combinations for dwCallPrivilege
+//     5)  Attempt to set call privilege to monitor when sole owner
+//         and not in the IDLE state
+//     6)  Verify LINE_CALLINFO/NUMMONITORS sent when monitor added
+//     7)  Verify LINE_CALLINFO/NUMOWNERINCR and NUMMONITORS sent when
+//         a monitor is changed to an owner with lineSetCallPrivilege
+//     8)  Verify LINE_CALLINFO/NUMOWNERDECR and NUMMONITORS sent when
+//         an owner is changed to a monitor with lineSetCallPrivilege
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineSetCallPrivilege(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT                 n;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+    strcpy(lpTapiLineTestInfo->szTestFunc, "lineSetCallPrivilege");
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+            (DWORD) GetCallbackParams();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetCallPrivilege  <<<<<<<<"
+            );
+            
+    // Call lineSetCallPrivilege before any lines are initialized
+    // Note:  This test must be run in a stand-alone mode
+           
+    if (fStandAloneTest)
+    {
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: uninitialized state", dwTestCase + 1
+            );
+         if (! DoLineSetCallPrivilege(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld:  call privilege can't be changed to\r\n" \
+            ">>  monitor when sole owner and not idle", dwTestCase + 1
+            );
+            
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (!DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+//            lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Make a call (as owner)
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    // Try setting the call privilege from owner to monitor when the
+    // sole owner of the call and not in the idle state
+//    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+//    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, LINEERR_INVALCALLSTATE))
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: invalid call handles", dwTestCase + 1
+            );
+            
+    // Pass some invalid call handles
+    lpTapiLineTestInfo->hCall_Orig = *lpTapiLineTestInfo->lphCall;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[n];
+
+        if (! DoLineSetCallPrivilege(
+                lpTapiLineTestInfo,
+                LINEERR_INVALCALLHANDLE)) 
+        {
+            TLINE_FAIL();
+        }
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphCall = lpTapiLineTestInfo->hCall_Orig;
+
+    // Try some invalid dwPrivileges
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: invalid dwPrivileges values", dwTestCase + 1
+            );
+            
+    if (! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetCallPrivilege,
+            (LPDWORD) &lpTapiLineTestInfo->dwCallPrivilege,
+            LINEERR_INVALCALLPRIVILEGE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_LINECALLPRIVILEGES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: valid dwPrivileges values", dwTestCase + 1
+            );
+
+/*            
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+     if (! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetCallPrivilege,
+            (LPDWORD) &lpTapiLineTestInfo->dwCallPrivilege,
+/* XYD, NA and MUTEX should exchange postion, bug!
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+*/
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+// XYD, NONE can't be used, MONITOR returns INVALCALLSTATE
+// so, change all to OWNER  ALL_LINECALLPRIVILEGES,
+//            LINECALLPRIVILEGE_OWNER,
+            ALL_LINECALLPRIVILEGE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+
+    // Deallocate the call
+    if (! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown the line app instance
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: Success", dwTestCase + 1
+            );
+ 
+
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (!DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+//            lpTapiLineTestInfo->lpLineDevCaps->dwMediaModes;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Make a call (as owner)
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown the line app instance
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMMONITORS msg sent when monitor added", dwTestCase +1);
+
+
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (!DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Make a call (as owner)
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 8;
+
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+ 
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMOWNERINCR msg sent when monitor added", dwTestCase +1);
+
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERINCR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineSetAppSpecific(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMOWNERDECR msg sent when monitor added", dwTestCase +1);
+
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS | LINECALLINFOSTATE_NUMOWNERDECR,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown the line app instance
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+  
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetCallPrivilege: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetCallPrivilege  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itlsnr.c b/private/tapi/qa/trapper/itest/line/itlsnr.c
new file mode 100644
index 000000000..e4eb2c8e2
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlsnr.c
@@ -0,0 +1,255 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsnr.c
+
+Abstract:
+
+    This module contains the test functions for lineSetNumRings
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define VALID_DWNUMRINGS   0x00000005
+
+
+//  lineSetNumRings
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//                                   
+//  *  1)  Uninitialized
+//     2)  Invalid hLines
+//     3)  Invalid dwAddressID (-1, dwNumAddresses)
+//
+//  * = Stand-alone test case
+//
+//  Note:  lineSetNumRings/lineGetNumRings testing is performed
+//         in the tests for lineGetNumRings.
+//
+//         One lineSetNumRings case is performed here as a sanity check.
+//
+
+BOOL TestLineSetNumRings(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT n;
+    BOOL fResult;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetNumRings  <<<<<<<<"
+            );
+            
+    // Test for LINEERR_UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+        TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: uninitialized state", dwTestCase + 1);
+
+        if (! DoLineSetNumRings(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    }
+
+    // Setup an open line
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    // Prep linedevcaps
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    // Assign valid low and high values for negotiating the API version
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Set media modes and privileges for lineOpen
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    // Start tests by checking invalid hLines
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1);
+
+    lpTapiLineTestInfo->hLine_Orig = *lpTapiLineTestInfo->lphLine;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineSetNumRings(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Test invalid dwAddressID (dwNumAddresses)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (dwNumAddresses)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID =
+            lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+    if (! DoLineSetNumRings(lpTapiLineTestInfo, LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+
+    // Test invalid dwAddressID (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid dwAddressID (-1)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwAddressID_Orig = lpTapiLineTestInfo->dwAddressID;
+    lpTapiLineTestInfo->dwAddressID = DWMINUSONE;
+    if (! DoLineSetNumRings(lpTapiLineTestInfo, LINEERR_INVALADDRESSID))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAddressID = lpTapiLineTestInfo->dwAddressID_Orig;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwNumRings", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwNumRings = 0xffffffff;
+    if (! DoLineSetNumRings(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwNumRings = 0;
+    lpTapiLineTestInfo->lpdwNumRings = &lpTapiLineTestInfo->dwNumRings;
+
+    if (! DoLineGetNumRings(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwNumRings = %lx",
+      lpTapiLineTestInfo->dwNumRings);
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwNumRings = 0;
+
+ 
+    // Test one valid case (several more valid SetNumRings calls are located
+    // in the lineGetNumRings tests)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid params and state", dwTestCase + 1);
+
+    *lpTapiLineTestInfo->lpdwNumRings = VALID_DWNUMRINGS;
+    if (! DoLineSetNumRings(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verifying dwNumRings was set properly", dwTestCase + 1);
+
+    if (! DoLineGetNumRings(lpTapiLineTestInfo, TAPISUCCESS) ||
+            *lpTapiLineTestInfo->lpdwNumRings != VALID_DWNUMRINGS)
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Close up and shutdown
+    fResult = DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            );
+
+    if (! fResult)
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetNumRings: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetNumRings  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/itlssm.c b/private/tapi/qa/trapper/itest/line/itlssm.c
new file mode 100644
index 000000000..d5fd005d3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/itlssm.c
@@ -0,0 +1,681 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlssm.c
+
+Abstract:
+
+    This module contains the test functions for lineSetStatusMessages
+
+Author:
+
+    Oliver Wallace (OliverW)    10-Sep-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "tline.h"
+
+
+#define ALL_LINEDEVSTATES        (LINEDEVSTATE_OTHER            | \
+                                  LINEDEVSTATE_RINGING          | \
+                                  LINEDEVSTATE_CONNECTED        | \
+                                  LINEDEVSTATE_DISCONNECTED     | \
+                                  LINEDEVSTATE_MSGWAITON        | \
+                                  LINEDEVSTATE_MSGWAITOFF       | \
+                                  LINEDEVSTATE_INSERVICE        | \
+                                  LINEDEVSTATE_OUTOFSERVICE     | \
+                                  LINEDEVSTATE_MAINTENANCE      | \
+                                  LINEDEVSTATE_OPEN             | \
+                                  LINEDEVSTATE_CLOSE            | \
+                                  LINEDEVSTATE_NUMCALLS         | \
+                                  LINEDEVSTATE_NUMCOMPLETIONS   | \
+                                  LINEDEVSTATE_TERMINALS        | \
+                                  LINEDEVSTATE_ROAMMODE         | \
+                                  LINEDEVSTATE_BATTERY          | \
+                                  LINEDEVSTATE_SIGNAL           | \
+                                  LINEDEVSTATE_DEVSPECIFIC      | \
+                                  LINEDEVSTATE_REINIT           | \
+                                  LINEDEVSTATE_LOCK             | \
+                                  LINEDEVSTATE_CAPSCHANGE       | \
+                                  LINEDEVSTATE_CONFIGCHANGE     | \
+                                  LINEDEVSTATE_TRANSLATECHANGE  | \
+                                  LINEDEVSTATE_COMPLCANCEL      | \
+                                  LINEDEVSTATE_REMOVED)
+
+#define ALL_LINEADDRESSSTATES    (LINEADDRESSSTATE_OTHER        | \
+                                  LINEADDRESSSTATE_DEVSPECIFIC  | \
+                                  LINEADDRESSSTATE_INUSEZERO    | \
+                                  LINEADDRESSSTATE_INUSEONE     | \
+                                  LINEADDRESSSTATE_INUSEMANY    | \
+                                  LINEADDRESSSTATE_NUMCALLS     | \
+                                  LINEADDRESSSTATE_FORWARD      | \
+                                  LINEADDRESSSTATE_TERMINALS    | \
+                                  LINEADDRESSSTATE_CAPSCHANGE)
+
+/*
+#define ALL_LINEADDRESSSTATES_20  (LINEADDRESSSTATE_OTHER        | \
+                                  LINEADDRESSSTATE_DEVSPECIFIC  | \
+                                  LINEADDRESSSTATE_INUSEZERO    | \
+                                  LINEADDRESSSTATE_INUSEONE     | \
+                                  LINEADDRESSSTATE_INUSEMANY    | \
+                                  LINEADDRESSSTATE_NUMCALLS     | \
+                                  LINEADDRESSSTATE_FORWARD      | \
+                                  LINEADDRESSSTATE_TERMINALS    | \
+                                  LINEADDRESSSTATE_CAPSCHANGE   | \
+                                  LINEADDRESSSTATE_AGENT        | \
+                                  LINEADDRESSSTATE_AGENTSTATE   | \
+                                  LINEADDRESSSTATE_AGENTACTIVITY)
+*/
+
+//  lineSetStatusMessages
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Invalid hLines
+//     3)  Test invalid bit flag combinations for dwLineStates
+//     4)  Test invalid bit flag combinations for dwAddressStates
+//     5)  Test valid bit flag combinations for dwLineStates
+//     6)  Test valid bit flag combinations for dwAddressStates
+//     7)  Solicit SPI errors (NOMEM, OPERATIONFAILED, RESOURCEUNAVAIL,
+//         OPERATIONUNAVAIL) (not implemented here)
+//     8)  Verify status message filtering is occuring on the set hLine
+//         (not implemented yet)
+//     9)  Verify status message filtering doesn't occur across
+//         different hLines (not implemented yet)
+//
+//  *  =   Stand-alone test
+
+BOOL TestLineSetStatusMessages(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT                 n;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed       = TRUE;
+    CHAR                szTestFunc[]      = "lineSetStatusMessages";
+    DWORD dwAllAddressStates;
+
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+    strcpy(lpTapiLineTestInfo->szTestFunc, szTestFunc);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetStatusMessages  <<<<<<<<"
+            );
+            
+    // Call lineSetStatusMessages before any lines are initialized
+    // Note:  This test must be run in a stand-alone mode
+    if (fStandAloneTest)
+    {
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: uninitialized state", dwTestCase + 1
+            );
+            
+        if (! DoLineSetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_UNINITIALIZED))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with owner privilege
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the valid line handle and try some invalid ones
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: invalid hLine handles", dwTestCase + 1
+            );
+            
+    lpTapiLineTestInfo->hLine_Orig      = *lpTapiLineTestInfo->lphLine;
+    lpTapiLineTestInfo->dwLineStates    = 0x00000000;
+    lpTapiLineTestInfo->dwAddressStates = 0x00000000;
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineSetStatusMessages(
+                lpTapiLineTestInfo,
+                LINEERR_INVALLINEHANDLE
+                ))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Restore valid line handle
+    *lpTapiLineTestInfo->lphLine = lpTapiLineTestInfo->hLine_Orig;
+
+    // Test invalid line states
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: invalid line states", dwTestCase + 1
+            );
+            
+    if (! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetStatusMessages,
+            (LPDWORD) &lpTapiLineTestInfo->dwLineStates,
+            LINEERR_INVALLINESTATE,
+            FIELDTYPE_NA,
+            FIELDTYPE_UNION,
+            FIELDSIZE_32,
+            ALL_LINEDEVSTATES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xFFFFFFFF,
+// XYD           0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Test invalid address states
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: invalid address states", dwTestCase + 1
+            );
+            
+/*
+    if(lpTapiLineTestInfo->dwAPIVersion >= 20000)
+    	{
+       dwAllAddressStates = ALL_LINEADDRESSSTATES_20;
+      }
+    else
+*/
+     {
+       dwAllAddressStates = ALL_LINEADDRESSSTATES;
+      }
+       
+    if (! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetStatusMessages,
+            (LPDWORD) &lpTapiLineTestInfo->dwAddressStates,
+            LINEERR_INVALADDRESSSTATE,
+            FIELDTYPE_NA,
+            FIELDTYPE_UNION,
+            FIELDSIZE_32,
+            dwAllAddressStates,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+//XYD            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Test valid line states
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: valid line states", dwTestCase + 1
+            );
+            
+    if (! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetStatusMessages,
+            (LPDWORD) &lpTapiLineTestInfo->dwLineStates,
+/* XYD, should NA exchange with UNION?
+            FIELDTYPE_NA,
+            FIELDTYPE_UNION,
+*/
+            FIELDTYPE_UNION,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_LINEDEVSTATES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Test Valid address states
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>  Test Case %ld: valid address states", dwTestCase + 1
+            );
+            
+    if (! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetStatusMessages,
+            (LPDWORD) &lpTapiLineTestInfo->dwAddressStates,
+/* XYD, should NA exchange with UNION?
+            FIELDTYPE_NA,
+            FIELDTYPE_UNION,
+*/
+            FIELDTYPE_UNION,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_LINEADDRESSSTATES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown the line app instance
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid Get/SetStatusMessages combinations and verify\r\n" \
+            ">> the returned data", dwTestCase + 1
+            );
+
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with owner privilege
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->dwLineStates    = ALL_LINEDEVSTATES;
+    lpTapiLineTestInfo->dwAddressStates = ALL_LINEADDRESSSTATES;
+    // Store the values used
+    lpTapiLineTestInfo->dwLineStates_Orig = lpTapiLineTestInfo->dwLineStates;
+    lpTapiLineTestInfo->dwAddressStates_Orig = 
+            lpTapiLineTestInfo->dwAddressStates;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    // Verify the results by calling lineGetStatusMessages
+    if (! DoLineGetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS) ||
+            *lpTapiLineTestInfo->lpdwAddressStates !=
+                    lpTapiLineTestInfo->dwAddressStates_Orig       ||
+            *lpTapiLineTestInfo->lpdwLineStates !=
+                    lpTapiLineTestInfo->dwLineStates_Orig
+            )
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    	
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify status msg filtering acroos different hLine",
+            dwTestCase + 1
+            );
+
+    // Initialize a line app instance
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Negotiate the current API version
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with owner privilege
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwLineStates    = ALL_LINEDEVSTATES;
+    lpTapiLineTestInfo->dwAddressStates = ALL_LINEADDRESSSTATES;
+    // Store the values used
+    lpTapiLineTestInfo->dwLineStates_Orig = lpTapiLineTestInfo->dwLineStates;
+    lpTapiLineTestInfo->dwAddressStates_Orig = 
+            lpTapiLineTestInfo->dwAddressStates;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    if (! DoLineGetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS) ||
+            *lpTapiLineTestInfo->lpdwAddressStates ==
+                    lpTapiLineTestInfo->dwAddressStates_Orig       ||
+            *lpTapiLineTestInfo->lpdwLineStates ==
+                    lpTapiLineTestInfo->dwLineStates_Orig
+            )
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    	
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+    if ( ! DoLineSetStatusMessages(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+    if ( ! DoLineSetStatusMessages(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetStatusMessages: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetStatusMessages  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/line/line.inc b/private/tapi/qa/trapper/itest/line/line.inc
new file mode 100644
index 000000000..00d36b034
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/line.inc
@@ -0,0 +1,82 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+DLLDEF=..\tline.def
+DLLBASE=0x60000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..
+
+USE_CRTDLL=1
+
+SOURCES=..\tline.c  \
+	..\itlc.c \
+	..\itlgac.c \
+	..\itlgdc.c \
+	..\itlgnr.c \
+	..\itlsnr.c \
+	..\itlglds.c \
+	..\itlgas.c \
+	..\itldial.c \
+	..\itldrop.c \
+	..\itli.c \
+	..\itlo.c \
+	..\itls.c \
+	..\itldc.c \
+	..\itlmc.c \
+	..\itlmc1.c \
+	..\itlmc2.c \
+	..\itlgid.c \
+	..\itlnapiv.c \
+	..\itlscp.c \
+	..\itlgsm.c \
+	..\itlssm.c \
+	..\itlgci.c \
+	..\itlgcs.c \
+	..\itlgnc.c \
+	..\itlgaid.c \
+	..\uline.c \
+	..\tline.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1 
+
+
+UMTYPE=windows
+
+DLLENTRY=TlineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/line/linea/makefile b/private/tapi/qa/trapper/itest/line/linea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/linea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/line/linea/sources b/private/tapi/qa/trapper/itest/line/linea/sources
new file mode 100644
index 000000000..0abb24fe5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/linea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\line.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/line/linew/makefile b/private/tapi/qa/trapper/itest/line/linew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/linew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/line/linew/sources b/private/tapi/qa/trapper/itest/line/linew/sources
new file mode 100644
index 000000000..4a2bc248a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/linew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\line.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/line/tline.c b/private/tapi/qa/trapper/itest/line/tline.c
new file mode 100644
index 000000000..9add6199b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/tline.c
@@ -0,0 +1,409 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "tline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTlineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TlineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTlineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAddressCaps(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetDevCaps(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineInitialize(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMakeCall(TRUE, FALSE));
+}
+
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMakeCall1(TRUE, FALSE));
+}
+
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMakeCall2(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineNegotiateAPIVersion(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineOpen(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineShutdown(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineClose(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetID(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetNumRings(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetNumRings(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDeallocateCall(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test16(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDial(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test17(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDrop(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test18(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetLineDevStatus(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test19(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAddressStatus(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test20(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallPrivilege(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test21(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetStatusMessages(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test22(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetStatusMessages(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test23(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetCallInfo(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test24(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetCallStatus(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test25(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetNewCalls(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test26(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAddressID(TRUE, FALSE));
+}
diff --git a/private/tapi/qa/trapper/itest/line/tline.def b/private/tapi/qa/trapper/itest/line/tline.def
new file mode 100644
index 000000000..0c44b3311
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/tline.def
@@ -0,0 +1,36 @@
+LIBRARY         tline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
+        Test16
+        Test17
+        Test18
+        Test19
+        Test20
+        Test21
+        Test22
+        Test23
+        Test24
+        Test25
+        Test26
diff --git a/private/tapi/qa/trapper/itest/line/tline.h b/private/tapi/qa/trapper/itest/line/tline.h
new file mode 100644
index 000000000..726f21929
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/tline.h
@@ -0,0 +1,446 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef TLINE_H
+#define TLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineClose(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDeallocateCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDial(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDrop(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAddressCaps(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAddressStatus(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetDevCaps(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineGetID(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetLineDevStatus(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetNumRings(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineInitialize(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMakeCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMakeCall1(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMakeCall2(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineNegotiateAPIVersion(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+BOOL
+TestLineOpen(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetNumRings(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineShutdown(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineSetCallPrivilege(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetStatusMessages(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineSetStatusMessages(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetCallInfo(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetCallStatus(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetNewCalls(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetAddressID(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetProviderList(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test16(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test17(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test18(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test19(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test20(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test21(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test22(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test23(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test24(
+    HINSTANCE   hAppInst
+    );
+
+BOOL
+WINAPI
+Test25(
+    HINSTANCE   hAppInst
+    );
+
+BOOL
+WINAPI
+Test26(
+    HINSTANCE   hAppInst
+    );
+
+
+#endif  // TLINE_H
diff --git a/private/tapi/qa/trapper/itest/line/tline.rc b/private/tapi/qa/trapper/itest/line/tline.rc
new file mode 100644
index 000000000..1c0a2d653
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/tline.rc
@@ -0,0 +1,12 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI TLine API test Library"
+#define VER_INTERNALNAME_STR        "tline.dll"
+#define VER_ORIGINALFILENAME_STR    "tline.dll"
+
+#include "common.ver"
+
+
diff --git a/private/tapi/qa/trapper/itest/line/uline.c b/private/tapi/qa/trapper/itest/line/uline.c
new file mode 100644
index 000000000..5e3f8f6e1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line/uline.c
@@ -0,0 +1,390 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tline.h"
+
+
+#define DWNUMCALLS 1
+
+// Macro for handling unexpected failures during the tests
+#define ITLC_FAIL()    {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                       }
+
+
+
+char szApiName[23][48] = 
+		{
+		"lineClose",
+		"lineDeallocateCall",
+		"lineDial",
+		"lineDrop",
+ 		"lineGetAddressCaps",
+  		"lineGetAddressID",
+		"lineGetAddressStatus",
+		"lineGetCallInfo",
+		"lineGetCallStatus",
+		"lineGetDevCaps",
+		"lineGetID",
+		"lineGetLineDevStatus",
+		"lineGetNewCalls",
+		"lineGetNumRings",
+		"lineGetProviderList",
+		"lineGetStatusMessage",
+//		"lineHold",
+		"lineMakeCall",
+		"lineNegotiateAPIVersion",
+		"lineOpen",
+//		"lineSetAppSpecific",
+		"lineSetCallPrivilege",
+		"lineSetNumRings",
+		"lineSetStatusMessages",
+		"lineShutdown",
+//		"lineUnhold"
+	};		
+
+
+BOOL TestLineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+	 InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 23; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+          if (! DoLineClose(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 1:       
+          if (! DoLineDeallocateCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 2: 
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+          lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+          if (! DoLineDial(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 4:       
+		    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+      		      sizeof(LINEADDRESSCAPS));
+		    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+          if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 5:
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwsAddress = L"55555";
+#else
+          lpTapiLineTestInfo->lpsAddress = "55555";
+#endif
+          lpTapiLineTestInfo->dwAddressMode = LINEADDRESSMODE_DIALABLEADDR;
+          lpTapiLineTestInfo->dwSize = 16;
+          if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 6:       
+          lpTapiLineTestInfo->lpLineAddressStatus = (LPLINEADDRESSSTATUS) AllocFromTestHeap (
+						sizeof(LINEADDRESSSTATUS));
+          lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = sizeof(LINEADDRESSSTATUS);
+          if (! DoLineGetAddressStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 7:       
+          lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap (
+  			          sizeof(LINECALLINFO));
+          lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+          if (! DoLineGetCallInfo(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 8:       
+          if (! DoLineGetCallStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 9:       
+ 			 lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+													  sizeof (LINEDEVCAPS));
+		    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+          if (! DoLineGetDevCaps(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 10:      
+			 lpTapiLineTestInfo->lpDeviceID = (LPVARSTRING)AllocFromTestHeap(
+   						sizeof(VARSTRING));
+          lpTapiLineTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+          lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+          if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 11:      
+          lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap (
+							sizeof(LINEDEVSTATUS));
+	       lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS); 
+          if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 12:      
+			 lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+         		   sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+		            );
+			 lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+         	   (DWNUMCALLS) * sizeof(HCALL) + 8;
+          if (! DoLineGetNewCalls(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 13:       
+          if (! DoLineGetNumRings(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 14:      
+          lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap (
+                sizeof(LINEPROVIDERLIST));
+          lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST); 
+          lpTapiLineTestInfo->dwAPIVersion = 0x20000;
+          if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 15:       
+          if (! DoLineGetStatusMessages(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        /*
+        case 16:       
+          if (! DoLineHold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+        */
+
+        case 16:       
+          if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 17:       
+          if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 18:       
+          if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        /*
+        case 20:       
+          if (! DoLineSetAppSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+	      */
+     
+        case 19:      
+ 			 lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+          if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 20:       
+          if (! DoLineSetNumRings(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 21:       
+          if (! DoLineSetStatusMessages(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 22:       
+          if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        /*
+        case 25:       
+          if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+         */
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlas.c b/private/tapi/qa/trapper/itest/line20/itlas.c
new file mode 100644
index 000000000..c1e3ee6a2
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlas.c
@@ -0,0 +1,192 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlas.c
+
+Abstract:
+
+    This module contains the test functions for lineAgentSpecific
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		21-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineAgentSpecific
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAgentSpecific(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineAgentSpecific");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAgentSpecific unimodem didn't support");
+		return fTestPassed;
+		}
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+   *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+	lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+	lpTapiLineTestInfo->dwSize = 0;
+
+   if (! DoLineAgentSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+   lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	 if(lret == 1)
+	 { 
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+   // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAgentSpecific Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineAgentSpecific Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlgaal.c b/private/tapi/qa/trapper/itest/line20/itlgaal.c
new file mode 100644
index 000000000..d988b834b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlgaal.c
@@ -0,0 +1,211 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgaal.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentActivityList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineGetAgentActivityList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentActivityList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAgentActivityList");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentActivityList unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER | 
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTACTIVITYLIST)
+            );
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = sizeof(LINEAGENTACTIVITYLIST);
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	 
+    if(lret == 1)
+	{
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwNeededSize =
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwTotalSize;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwNumEntries = 2;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"## dwTotalSize = %lx, dwNeededSize = %lx, dwNumEntries = %lx",
+      lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize,
+      lpTapiLineTestInfo->lpAgentActivityList->dwNeededSize,
+      lpTapiLineTestInfo->lpAgentActivityList->dwNumEntries);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentActivityList Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentActivityList Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlgac.c b/private/tapi/qa/trapper/itest/line20/itlgac.c
new file mode 100644
index 000000000..8bd8993bd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlgac.c
@@ -0,0 +1,208 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgac.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		21-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineGetAgentCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAgentCaps");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentCaps unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+	lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	
+    if(lret == 1)
+    { 
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentCaps.AgentCaps.dwNeededSize =
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentCaps.AgentCaps.dwTotalSize;
+	 lpTapiLineTestInfo->lpProxyRequest->GetAgentCaps.AgentCaps.dwFeatures = LINEAGENTFEATURE_GETAGENTGROUP;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+    }
+  
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"## dwTotalSize = %lx, dwNeededSize = %lx, dwFeatures = %lx",
+		lpTapiLineTestInfo->lpAgentCaps->dwTotalSize,
+		lpTapiLineTestInfo->lpAgentCaps->dwNeededSize,
+		lpTapiLineTestInfo->lpAgentCaps->dwFeatures);
+
+	if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+	{
+		TLINE_FAIL();
+	}
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentCaps Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentCaps Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlgagl.c b/private/tapi/qa/trapper/itest/line20/itlgagl.c
new file mode 100644
index 000000000..1690f5ada
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlgagl.c
@@ -0,0 +1,212 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgagl.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentGroupList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineGetAgentGroupList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentGroupList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAgentGroupList");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentGroupList unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER | 
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    // Get the line device capabilities
+	lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	
+    if(lret == 1)
+    { 
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentGroupList.GroupList.dwNeededSize =
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentGroupList.GroupList.dwTotalSize;
+	 lpTapiLineTestInfo->lpProxyRequest->GetAgentGroupList.GroupList.dwNumEntries = 2;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+    }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"## dwTotalSize = %lx, dwNeededSize = %lx, dwNumEntries = %lx",
+      lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize,
+      lpTapiLineTestInfo->lpAgentGroupList->dwNeededSize,
+      lpTapiLineTestInfo->lpAgentGroupList->dwNumEntries);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentGroupList Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentGroupList Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlgas.c b/private/tapi/qa/trapper/itest/line20/itlgas.c
new file mode 100644
index 000000000..aa4673aa7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlgas.c
@@ -0,0 +1,212 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgas.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentStatus
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineGetAgentStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAgentStatus");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentStatus unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER | 
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    // Get the line device capabilities
+	lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	 
+	 if(lret == 1)
+    {
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentStatus.AgentStatus.dwNeededSize =
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentStatus.AgentStatus.dwTotalSize;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentStatus.AgentStatus.dwActivityID = 1;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+    }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"## dwTotalSize = %lx, dwNeededSize = %lx, dwActivityID = %lx",
+      lpTapiLineTestInfo->lpAgentStatus->dwTotalSize,
+      lpTapiLineTestInfo->lpAgentStatus->dwNeededSize,
+      lpTapiLineTestInfo->lpAgentStatus->dwActivityID);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentStatus Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentStatus Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlgm.c b/private/tapi/qa/trapper/itest/line20/itlgm.c
new file mode 100644
index 000000000..9d7329e6c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlgm.c
@@ -0,0 +1,151 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgm.c
+
+Abstract:
+
+    This module contains the test functions for lineGetMessage
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineGetMessage
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetMessage(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetMessage");
+
+	// Initialize a line app
+   
+   lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+   lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->lpLineInitializeExParams = 
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =  
+         sizeof(LINEINITIALIZEEXPARAMS);
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions = 
+         LINEINITIALIZEEXOPTION_USEEVENT;
+ 
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+  
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE) AllocFromTestHeap (
+        sizeof(LINEMESSAGE));
+   
+	if(! DoLineGetMessage (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+   TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "lpMessage: hDevice = %lx, dwMessageID = %lx, dwCallbackInst = %lx",
+        lpTapiLineTestInfo->lpMessage->hDevice,
+        lpTapiLineTestInfo->lpMessage->dwMessageID,
+        lpTapiLineTestInfo->lpMessage->dwCallbackInstance);
+
+   TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "lpMessage: dwParam1 = %lx, dwParam2 = %lx, dwParam3 = %lx",
+        lpTapiLineTestInfo->lpMessage->dwParam1,
+        lpTapiLineTestInfo->lpMessage->dwParam2,
+        lpTapiLineTestInfo->lpMessage->dwParam3);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_PASS,
+			"## lineGetMessage Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_PASS,
+			"## lineGetMessage Test Failed");
+
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlie.c b/private/tapi/qa/trapper/itest/line20/itlie.c
new file mode 100644
index 000000000..0624088a7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlie.c
@@ -0,0 +1,102 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlie.c
+
+Abstract:
+
+    This module contains the test functions for lineInitializeEx
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineInitializeEx
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineInitializeEx(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineInitializeEx");
+
+	// Initialize a line app
+   lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+   lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->lpLineInitializeExParams = 
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =  
+         sizeof(LINEINITIALIZEEXPARAMS);
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions = 
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+   
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineInitializeEx Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineInitializeEx Test Failed");
+
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlpm.c b/private/tapi/qa/trapper/itest/line20/itlpm.c
new file mode 100644
index 000000000..14f1288fc
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlpm.c
@@ -0,0 +1,176 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpm.c
+
+Abstract:
+
+    This module contains the test functions for lineProxyMessage
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineProxyMessage
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineProxyMessage(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineProxyMessage");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineProxyMessage unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER | 
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineProxyMessage for go/no-go");
+
+   lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+   lpTapiLineTestInfo->dwParam1 = 0;
+   lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+   lpTapiLineTestInfo->dwParam3 = 0;
+
+	if (! DoLineProxyMessage(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineProxyMessage Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineProxyMessage Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlpr.c b/private/tapi/qa/trapper/itest/line20/itlpr.c
new file mode 100644
index 000000000..71d0bf1dd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlpr.c
@@ -0,0 +1,201 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpr.c
+
+Abstract:
+
+    This module contains the test functions for lineProxyResponse
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineProxyResponse
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineProxyResponse(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineProxyResponse");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineProxyResponse unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+   
+
+		 // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	    // Get the line Agent capabilities
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+   lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+ 	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+   if (! DoLineGetAgentCaps(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	
+    if(lret == 1)
+   { 
+	  lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+	  lpTapiLineTestInfo->dwResult = 0;
+
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineProxyResponse Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineProxyResponse Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlsaa.c b/private/tapi/qa/trapper/itest/line20/itlsaa.c
new file mode 100644
index 000000000..3c43b3d65
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlsaa.c
@@ -0,0 +1,198 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgaal.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAgentActivity
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineSetAgentActivity
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAgentActivity(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetAgentActivity");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentActivity unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+   
+
+		 // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER | 
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_SETAGENTACTIVITY;
+
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    // Set the line device capabilities
+	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->dwActivityID = 1;
+
+    if (! DoLineSetAgentActivity(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	 
+	 if(lret == 1)
+    {
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentActivity Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentActivity Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlsag.c b/private/tapi/qa/trapper/itest/line20/itlsag.c
new file mode 100644
index 000000000..e9f5adda9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlsag.c
@@ -0,0 +1,201 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsag.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAgentGroup
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineSetAgentGroup
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAgentGroup(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetAgentGroup");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentGroup unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_SETAGENTGROUP;
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    // Set the line device capabilities
+	lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	
+    if(lret == 1)
+    { 
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentGroup Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentGroup Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/itlsas.c b/private/tapi/qa/trapper/itest/line20/itlsas.c
new file mode 100644
index 000000000..2c1a92c19
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/itlsas.c
@@ -0,0 +1,200 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsas.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAgentState
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineSetAgentState
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAgentState(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetAgentState");
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentState unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    // Set the line device capabilities
+	lpTapiLineTestInfo->dwAddressID = 0;
+
+	lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+	lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    if (! DoLineSetAgentState(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	 
+ 	 if(lret == 1)
+    {
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentState Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetAgentState Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/line20.c b/private/tapi/qa/trapper/itest/line20/line20.c
new file mode 100644
index 000000000..09fd45744
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/line20.c
@@ -0,0 +1,310 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    line20.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "line20.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghline20Dll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+line20DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghline20Dll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAgentSpecific(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentCaps(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentActivityList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentGroupList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentStatus(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineProxyMessage(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineProxyResponse(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAgentActivity(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAgentGroup(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAgentState(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineInitializeEx(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetMessage(TRUE, FALSE));
+}
+
+
+
+
+BOOL
+ShouldTapiPhoneTestAbort(BOOL fQuiteMode)
+{
+	return FALSE;
+}
diff --git a/private/tapi/qa/trapper/itest/line20/line20.def b/private/tapi/qa/trapper/itest/line20/line20.def
new file mode 100644
index 000000000..50af093a7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/line20.def
@@ -0,0 +1,22 @@
+LIBRARY         line20
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
diff --git a/private/tapi/qa/trapper/itest/line20/line20.h b/private/tapi/qa/trapper/itest/line20/line20.h
new file mode 100644
index 000000000..52cd3f078
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/line20.h
@@ -0,0 +1,248 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    line20.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding 	(XiaoD) 29-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef LINE20_H
+#define LINE20_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineAgentSpecific(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentCaps(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentActivityList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentGroupList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentStatus(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineProxyMessage(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineProxyResponse(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineSetAgentActivity(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAgentGroup(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAgentState(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineInitializeEx(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineGetMessage(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    );
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    );
+
+
+
+#endif  // LINE20_H
diff --git a/private/tapi/qa/trapper/itest/line20/line20.rc b/private/tapi/qa/trapper/itest/line20/line20.rc
new file mode 100644
index 000000000..b2bfef31b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/line20.rc
@@ -0,0 +1,13 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI Line2.0 API test Library"
+#define VER_INTERNALNAME_STR        "line20.dll"
+#define VER_ORIGINALFILENAME_STR    "line20.dll"
+
+#include "common.ver"
+
+
+
diff --git a/private/tapi/qa/trapper/itest/line20/makefile b/private/tapi/qa/trapper/itest/line20/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/line20/sources b/private/tapi/qa/trapper/itest/line20/sources
new file mode 100644
index 000000000..23118425b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/line20/sources
@@ -0,0 +1,70 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=line20
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x69000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=line20.c \
+		itlas.c	 \
+		itlgac.c \
+		itlgaal.c \
+		itlgagl.c \
+		itlgas.c \
+		itlpm.c \
+		itlpr.c \
+		itlsaa.c \
+		itlsag.c \
+		itlsas.c \
+		itlie.c  \
+		itlgm.c  \
+		line20.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=line20DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/phone/itpc.c b/private/tapi/qa/trapper/itest/phone/itpc.c
new file mode 100644
index 000000000..54c679e2f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpc.c
@@ -0,0 +1,140 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpc.c
+
+Abstract:
+
+    This module contains the test functions for phoneClose
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneClose
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneClose(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneClose");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneClose for go/no-go ");
+
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneClose Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneClose Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpcd.c b/private/tapi/qa/trapper/itest/phone/itpcd.c
new file mode 100644
index 000000000..d6f068a91
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpcd.c
@@ -0,0 +1,120 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpcd.c
+
+Abstract:
+
+    This module contains the test functions for phoneConfigDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+#define DLG_TITLE_ESP        "TUISPI_phoneConfigDialog"
+
+
+//  phoneConfigDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneConfigDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test phoneConfigDialog");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneConfigDialog for go/no-go");
+
+   strcpy(szTitle, DLG_TITLE_ESP);
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+	// Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+   FreeTestHeap();
+ 
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneConfigDialog Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneConfigDialog Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpds.c b/private/tapi/qa/trapper/itest/phone/itpds.c
new file mode 100644
index 000000000..3cacdb5de
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpds.c
@@ -0,0 +1,152 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpds.c
+
+Abstract:
+
+    This module contains the test functions for phoneDevSpecific
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneDevSpecific
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneDevSpecific(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	PHONEBUTTONINFO		TapiTestPhoneButtonInfo;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneDevSpecific");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneDevSpecfic for go/no-go");
+
+	lpTapiPhoneTestInfo->lpParams = (LPVOID)&TapiTestPhoneButtonInfo;
+   lpTapiPhoneTestInfo->dwSize = sizeof(PHONEBUTTONINFO);
+
+	if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+ 
+   // Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneDevSpecific Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneDevSpecific Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgbi.c b/private/tapi/qa/trapper/itest/phone/itpgbi.c
new file mode 100644
index 000000000..4b09e0f5c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgbi.c
@@ -0,0 +1,165 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgbi.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetButtonInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+//  phoneGetButtonInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetButtonInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetButtonInfo");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetButtonInfo for go/no-go for OWNER");
+
+ 	lpTapiPhoneTestInfo->dwButtonLampID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+		0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+	lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+   lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+	if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwNeededSize = %lx",
+		lpTapiPhoneTestInfo->lpButtonInfo->dwNeededSize);
+
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwButtonMode = %lx", lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode);
+
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetButtonInfo Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetButtonInfo Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgd.c b/private/tapi/qa/trapper/itest/phone/itpgd.c
new file mode 100644
index 000000000..fdddbefbd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgd.c
@@ -0,0 +1,152 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgd.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetData
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+//  phoneGetData
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetData(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetData");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetData for go/no-go for OWNER");
+
+ 	lpTapiPhoneTestInfo->dwDataID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+		0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+	lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+   lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+	if (! DoPhoneGetData(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetData Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetData Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgdc.c b/private/tapi/qa/trapper/itest/phone/itpgdc.c
new file mode 100644
index 000000000..1f738f4a0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgdc.c
@@ -0,0 +1,141 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgdc.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetDevCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetDevCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetDevCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetDevCaps");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetDevCaps for go/no-go ");
+
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetDevCaps Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetDevCaps Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgdp.c b/private/tapi/qa/trapper/itest/phone/itpgdp.c
new file mode 100644
index 000000000..e10134936
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgdp.c
@@ -0,0 +1,159 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgdp.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetDiaplay
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+//  phoneGetDisplay
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetDisplay(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwNumRows, dwNumColumns;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetDisplay");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetDisplay for go/no-go for OWNER");
+
+
+	dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+	dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumRows = %lx, dwNumColumns = %lx", dwNumRows, dwNumColumns);
+
+   lpTapiPhoneTestInfo->lpDisplay = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING));
+	lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING);
+
+	if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetDisplay Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetDisplay Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgg.c b/private/tapi/qa/trapper/itest/phone/itpgg.c
new file mode 100644
index 000000000..19055b9c5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgg.c
@@ -0,0 +1,151 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgg.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetGain
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetGain
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetGain(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetGain");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetGain for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+	lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+ 
+	if (! DoPhoneGetGain(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwGain = x%lx", lpTapiPhoneTestInfo->dwGain);
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetGain Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetGain Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpghs.c b/private/tapi/qa/trapper/itest/phone/itpghs.c
new file mode 100644
index 000000000..3e5c6115d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpghs.c
@@ -0,0 +1,154 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpghs.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetHookSwitch
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+
+//  phoneGetHookSwitch
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetHookSwitch(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetHookSwitch");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetHookSwitch for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+	if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwHookSwitchMode = %lx", lpTapiPhoneTestInfo->dwHookSwitchMode);
+
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetHookSwitch Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetHookSwitch Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgi.c b/private/tapi/qa/trapper/itest/phone/itpgi.c
new file mode 100644
index 000000000..eb34e8bf1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgi.c
@@ -0,0 +1,148 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgi.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetIcon
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+
+//  phoneGetIcon
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetIcon(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetIcon");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+
+	// Negotiate the API Version
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+	lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetIcon for go/no-go");
+
+	lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+
+	if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+ 
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetIcon Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetIcon Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgid.c b/private/tapi/qa/trapper/itest/phone/itpgid.c
new file mode 100644
index 000000000..bb5f4e8fe
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgid.c
@@ -0,0 +1,152 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgid.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetID
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetID
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetID(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetID");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+	lpTapiPhoneTestInfo->lpDeviceID =  &(lpTapiPhoneTestInfo->DeviceID);
+	lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetID for go/no-go");
+
+	if (! DoPhoneGetID(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+ 	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### passedSize = %lx, dwNeededSize = %lx",
+		sizeof(lpTapiPhoneTestInfo->DeviceID), lpTapiPhoneTestInfo->lpDeviceID->dwNeededSize);
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetID Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetID Test Failed");
+
+     return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgl.c b/private/tapi/qa/trapper/itest/phone/itpgl.c
new file mode 100644
index 000000000..0a85387fd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgl.c
@@ -0,0 +1,155 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgl.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetLamp
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetLamp
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetLamp(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetLamp");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetLamp for go/no-go for OWNER");
+
+ 	lpTapiPhoneTestInfo->dwButtonLampID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+		0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+	lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+
+	if (! DoPhoneGetLamp(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+ 
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwLampMode = %lx", lpTapiPhoneTestInfo->dwLampMode);
+
+
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetLamp Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetLamp Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgm.c b/private/tapi/qa/trapper/itest/phone/itpgm.c
new file mode 100644
index 000000000..731bf0949
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgm.c
@@ -0,0 +1,151 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgm.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetMessage
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetMessage
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetMessage(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetMessage");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetMessage for go/no-go ");
+
+	// InitializeEx a phone app
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+//           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+         PHONEINITIALIZEEXOPTION_USEEVENT;
+ 	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	lpTapiPhoneTestInfo->dwButtonLampID = 0;
+	lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+	lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+	if (! DoPhoneSetLamp(lpTapiPhoneTestInfo, TAPISUCCESS, FALSE))
+       {
+           TPHONE_FAIL();
+       }
+	
+   WaitForAllMessages();
+
+   lpTapiPhoneTestInfo->lpMessage = (LPPHONEMESSAGE) AllocFromTestHeap (
+        sizeof(PHONEMESSAGE));
+	if(! DoPhoneGetMessage (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+   TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "lpMessage: hDevice = %lx, dwMessageID = %lx, dwCallbackInst = %lx",
+        lpTapiPhoneTestInfo->lpMessage->hDevice,
+        lpTapiPhoneTestInfo->lpMessage->dwMessageID,
+        lpTapiPhoneTestInfo->lpMessage->dwCallbackInstance);
+
+   TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "lpMessage: dwParam1 = %lx, dwParam2 = %lx, dwParam3 = %lx",
+        lpTapiPhoneTestInfo->lpMessage->dwParam1,
+        lpTapiPhoneTestInfo->lpMessage->dwParam2,
+        lpTapiPhoneTestInfo->lpMessage->dwParam3);
+
+   // Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+ 
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+   FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetMessage Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetMessage Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgr.c b/private/tapi/qa/trapper/itest/phone/itpgr.c
new file mode 100644
index 000000000..8a03e3640
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgr.c
@@ -0,0 +1,158 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgr.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetRing
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetRing
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetRing(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwVolume;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetRing");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetRing for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+	lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+	if (! DoPhoneGetRing(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwRingMode = %lx", lpTapiPhoneTestInfo->dwRingMode);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwVolume = %lx", lpTapiPhoneTestInfo->dwVolume);
+
+ 
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetRing Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetRing Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgs.c b/private/tapi/qa/trapper/itest/phone/itpgs.c
new file mode 100644
index 000000000..b3aa39569
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgs.c
@@ -0,0 +1,155 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgs.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetStatus
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetStatus");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetStatus for go/no-go for OWNER");
+
+   lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+			sizeof(PHONESTATUS));
+	lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS);
+
+	if (! DoPhoneGetStatus(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpPhoneStatus->dwNeededSize = %lx", lpTapiPhoneTestInfo->lpPhoneStatus->dwNeededSize);
+
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetStatus Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetStatus Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgsm.c b/private/tapi/qa/trapper/itest/phone/itpgsm.c
new file mode 100644
index 000000000..ad03c3340
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgsm.c
@@ -0,0 +1,162 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgsm.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetStatusMessages
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetStatusMessages
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetStatusMessages(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetStatusMessages");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetStatusMessages for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->lpdwPhoneStates = &(lpTapiPhoneTestInfo->dwPhoneStates);
+	lpTapiPhoneTestInfo->lpdwButtonModes = &(lpTapiPhoneTestInfo->dwButtonModes);
+	lpTapiPhoneTestInfo->lpdwButtonStates = &(lpTapiPhoneTestInfo->dwButtonStates);
+ 
+	if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwPhoneStates = %lx", lpTapiPhoneTestInfo->dwPhoneStates);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwButtonMode = %lx", lpTapiPhoneTestInfo->dwButtonModes);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwButtonStates = %lx", lpTapiPhoneTestInfo->dwButtonStates);
+
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetStatusMessage Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetStatusMessage Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpgv.c b/private/tapi/qa/trapper/itest/phone/itpgv.c
new file mode 100644
index 000000000..2a74d786b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpgv.c
@@ -0,0 +1,151 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgv.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetVolume
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetVolume
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetVolume(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetVolume");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetVolume for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+	lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+ 
+	if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwVolume = %lx", lpTapiPhoneTestInfo->dwVolume);
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetVolume Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetVolume Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpi.c b/private/tapi/qa/trapper/itest/phone/itpi.c
new file mode 100644
index 000000000..509e04275
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpi.c
@@ -0,0 +1,94 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpi.c
+
+Abstract:
+
+    This module contains the test functions for phoneInitialize
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneInitialize
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneInitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneInitialize");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneInitialize for go/no-go ");
+
+	// Initialize a phone app
+	if(! DoPhoneInitialize (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitialize Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitialize Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpie.c b/private/tapi/qa/trapper/itest/phone/itpie.c
new file mode 100644
index 000000000..f6e199283
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpie.c
@@ -0,0 +1,105 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpie.c
+
+Abstract:
+
+    This module contains the test functions for phoneInitializeEx
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneInitializeEx
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneInitializeEx(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneInitializeEx");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneInitializeEx for go/no-go ");
+
+	// InitializeEx a phone app
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+   
+   FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitializeEx Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitializeEx Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpnav.c b/private/tapi/qa/trapper/itest/phone/itpnav.c
new file mode 100644
index 000000000..b6032cafd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpnav.c
@@ -0,0 +1,116 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpnav.c
+
+Abstract:
+
+    This module contains the test functions for phoneNegotiateAPIVersion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneNegotiateAPIVersion
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneNegotiateAPIVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneNegotiateAPIVersion");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneNegotiateAPIVersion for go/no-go");
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+   FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneNegotiaAPIVersion Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneNegotiaAPIVersion Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpne.c b/private/tapi/qa/trapper/itest/phone/itpne.c
new file mode 100644
index 000000000..a97b77c52
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpne.c
@@ -0,0 +1,138 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpnev.c
+
+Abstract:
+
+    This module contains the test functions for phoneNegotiateExtVersion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneNegotiateExtVersion
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneNegotiateExtVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneNegotiateExtVersion");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneNegotiateExtVersion for go/no-go for OWNER");
+
+	
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+	if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwExtVersion = %lx", lpTapiPhoneTestInfo->dwExtVersion);
+   
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneNegotiateExtVersion Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneNegotiateExtVersion Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpo.c b/private/tapi/qa/trapper/itest/phone/itpo.c
new file mode 100644
index 000000000..74fb0f07b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpo.c
@@ -0,0 +1,140 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpo.c
+
+Abstract:
+
+    This module contains the test functions for phoneOpen
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneOpen
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneOpen(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneOpen");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneOpen for go/no-go");
+
+		if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneOpen Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneOpen Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itps.c b/private/tapi/qa/trapper/itest/phone/itps.c
new file mode 100644
index 000000000..b82c69fd0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itps.c
@@ -0,0 +1,105 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itps.c
+
+Abstract:
+
+    This module contains the test functions for phoneShutdown
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneShutdown
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneShutdown(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneShutdown");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneShutdown for go/no-go");
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+   FreeTestHeap();
+
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneShutdown Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneShutDown Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsbi.c b/private/tapi/qa/trapper/itest/phone/itpsbi.c
new file mode 100644
index 000000000..72386427f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsbi.c
@@ -0,0 +1,187 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsbi.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetButtonInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetButtonInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetButtonInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetButtonInfo");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetButtonInfo for go/no-go for OWNER");
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### The dwNumButtonLamps = %lx", 
+				lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps);
+
+
+	lpTapiPhoneTestInfo->dwButtonLampID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+			0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+//	lpTapiPhoneTestInfo->dwButtonLampID = 0;
+   lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+
+	// Do set all field in ButtonInfo here
+   lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+	lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+	if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+ 
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetButtonInfo for verify");
+
+
+	if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwNeededSize = %lx",
+		lpTapiPhoneTestInfo->lpButtonInfo->dwNeededSize);
+
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwButtonMode = %lx", lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode);
+
+
+
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetButtonInfo Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetButtonInfo Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsd.c b/private/tapi/qa/trapper/itest/phone/itpsd.c
new file mode 100644
index 000000000..90e7ffc5f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsd.c
@@ -0,0 +1,176 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsd.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetData
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetData
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetData(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwData;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetData");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetData for go/no-go for OWNER");
+
+ 	lpTapiPhoneTestInfo->dwDataID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+		0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+	lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+	dwData = 0x5;
+	lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData;
+   lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwDataID = %lx ", lpTapiPhoneTestInfo->dwDataID);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpdwData = %lx, dwData = %lx", lpTapiPhoneTestInfo->lpData, dwData);
+
+	if (! DoPhoneSetData(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+
+	if (! DoPhoneGetData(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetData for verify");
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwDataID = %lx, lpData = %lx, dwData = %lx", lpTapiPhoneTestInfo->dwDataID,
+		lpTapiPhoneTestInfo->lpData, dwData);
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetData Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetData Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsdp.c b/private/tapi/qa/trapper/itest/phone/itpsdp.c
new file mode 100644
index 000000000..9ae5fe9b9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsdp.c
@@ -0,0 +1,188 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsdp.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetDiaplay
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetDisplay
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetDisplay(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwNumRows, dwNumColumns;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetDisplay");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetDisplay for go/no-go for OWNER");
+
+	dwNumRows = 1;
+   lpTapiPhoneTestInfo->dwRow = 0;
+	dwNumColumns = lpTapiPhoneTestInfo->dwColumn = 10;
+   lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			sizeof(dwNumRows*dwNumColumns));
+	lpTapiPhoneTestInfo->lpsDisplay = "this is a test";
+	lpTapiPhoneTestInfo->dwSize = sizeof(lpTapiPhoneTestInfo->lpsDisplay);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwRow = %lx, dwColumn = %lx, dwSize = %lx",
+		dwNumRows, dwNumColumns, lpTapiPhoneTestInfo->dwSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"lpsDisplay = %s", lpTapiPhoneTestInfo->lpsDisplay);
+
+	if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetDisplay for verify");
+
+   lpTapiPhoneTestInfo->lpDisplay = (LPVARSTRING)AllocFromTestHeap(
+			sizeof(VARSTRING));
+	lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpDisplay->dwTotalSize = %lx, neededSize = %lx",
+			(DWORD) lpTapiPhoneTestInfo->lpDisplay->dwTotalSize,
+			lpTapiPhoneTestInfo->lpDisplay->dwNeededSize);
+
+	if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpDisplay->dwTotalSize = %lx, neededSize = %lx",
+			(DWORD) lpTapiPhoneTestInfo->lpDisplay->dwTotalSize,
+			lpTapiPhoneTestInfo->lpDisplay->dwNeededSize);
+    
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetDisplay Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetDisplay Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsg.c b/private/tapi/qa/trapper/itest/phone/itpsg.c
new file mode 100644
index 000000000..3d0543c05
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsg.c
@@ -0,0 +1,162 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsg.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetGain
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetGain
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetGain(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetGain");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetGain for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+	lpTapiPhoneTestInfo->dwGain = 0x2;
+ 
+	if (! DoPhoneSetGain(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+
+   
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetGain for verify");
+
+ 
+	if (! DoPhoneGetGain(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwGain = x%lx", lpTapiPhoneTestInfo->dwGain);
+
+ 
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetGain Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetGain Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpshs.c b/private/tapi/qa/trapper/itest/phone/itpshs.c
new file mode 100644
index 000000000..a6cf17490
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpshs.c
@@ -0,0 +1,170 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpshs.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetHookSwitch
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetHookSwitch
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetHookSwitch(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetHookSwitch");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetHookSwitch for go/no-go for OWNER");
+
+
+	lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+	lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+	lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+	if (! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+
+   
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetHookSwitch for verify");
+
+
+	if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwHookSwitchDevs = %lx", lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwHookSwitchMode = %lx", lpTapiPhoneTestInfo->dwHookSwitchMode);
+
+
+ 
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetHookSwitch Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetHookSwitch Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsl.c b/private/tapi/qa/trapper/itest/phone/itpsl.c
new file mode 100644
index 000000000..0535fdd5b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsl.c
@@ -0,0 +1,166 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsl.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetLamp
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetLamp
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetLamp(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetLamp");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetLamp for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->dwButtonLampID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+		0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+	lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+	lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+	if (! DoPhoneSetLamp(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetLamp for verify");
+
+
+	if (! DoPhoneGetLamp(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+ 
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwLampMode = %lx", lpTapiPhoneTestInfo->dwLampMode);
+
+
+ 
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetLamp Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetLamp Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsr.c b/private/tapi/qa/trapper/itest/phone/itpsr.c
new file mode 100644
index 000000000..501d66318
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsr.c
@@ -0,0 +1,170 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsr.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetRing
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetRing
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetRing(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetRing");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetRing for go/no-go for OWNER");
+
+
+	lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+	lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+	lpTapiPhoneTestInfo->dwRingMode = lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+	lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+	if (! DoPhoneSetRing(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+ 
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetRing for verify");
+
+	if (! DoPhoneGetRing(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwRingMode = %lx", lpTapiPhoneTestInfo->dwRingMode);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwVolume = %lx", lpTapiPhoneTestInfo->dwVolume);
+
+ 
+ 
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetRing Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetRing Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpssm.c b/private/tapi/qa/trapper/itest/phone/itpssm.c
new file mode 100644
index 000000000..2d581567a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpssm.c
@@ -0,0 +1,174 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpssm.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetStatusMessages
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetStatusMessages
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetStatusMessages(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetStatusMessages");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetStatusMessages for go/no-go for OWNER");
+
+ 	lpTapiPhoneTestInfo->lpdwPhoneStates = &(lpTapiPhoneTestInfo->dwPhoneStates);
+	lpTapiPhoneTestInfo->lpdwButtonModes = &(lpTapiPhoneTestInfo->dwButtonModes);
+	lpTapiPhoneTestInfo->lpdwButtonStates = &(lpTapiPhoneTestInfo->dwButtonStates);
+	lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+	lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+	lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+ 
+	if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetStatusMessages for verify");
+
+
+	if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwPhoneStates = %lx", lpTapiPhoneTestInfo->dwPhoneStates);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwButtonMode = %lx", lpTapiPhoneTestInfo->dwButtonModes);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwButtonStates = %lx", lpTapiPhoneTestInfo->dwButtonStates);
+
+    
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetStatusMessage Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetStatusMessage Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/itpsv.c b/private/tapi/qa/trapper/itest/phone/itpsv.c
new file mode 100644
index 000000000..d7e164c74
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/itpsv.c
@@ -0,0 +1,167 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsv.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetVolume
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetVolume
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetVolume(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetVolume");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+           PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetVolume for go/no-go for OWNER");
+
+	lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+	lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+	lpTapiPhoneTestInfo->dwVolume = 0x7;
+ 
+	if (! DoPhoneSetVolume(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetVolume for verify");
+
+ 
+	if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwHookSwitchDev = %lx", lpTapiPhoneTestInfo->dwHookSwitchDev);
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpTapiPhoneTestInfo->dwVolume = %lx", lpTapiPhoneTestInfo->dwVolume);
+
+
+ 
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetVolume Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetVolume Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/phone/makefile b/private/tapi/qa/trapper/itest/phone/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/phone/sources b/private/tapi/qa/trapper/itest/phone/sources
new file mode 100644
index 000000000..944660795
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/sources
@@ -0,0 +1,91 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tphone
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x60000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=tphone.c \
+		itpcd.c	 \
+		itpds.c	 \
+		itpgbi.c \
+		itpgd.c	 \
+		itpgdp.c \
+		itpgg.c	 \
+		itpghs.c \
+		itpgi.c	 \
+		itpgid.c \
+		itpgl.c	 \
+		itpgr.c	 \
+		itpgs.c	 \
+		itpgsm.c \
+		itpgv.c	 \
+		itpsbi.c \
+		itpsd.c	 \
+		itpsdp.c \
+		itpsg.c	 \
+		itpshs.c \
+		itpsl.c	 \
+		itpsr.c	 \
+		itpssm.c \
+		itpsv.c	 \
+		itpne.c	 \
+		itpc.c	\
+		itpgdc.c \
+		itpi.c	\
+		itpnav.c  \
+		itpo.c	\
+		itps.c	\
+		itpie.c \
+		itpgm.c \
+		tphone.rc
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=TphoneDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/phone/tphone.c b/private/tapi/qa/trapper/itest/phone/tphone.c
new file mode 100644
index 000000000..1c5dd0e75
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/tphone.c
@@ -0,0 +1,491 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tphone.c
+
+Abstract:
+
+    This module contains functions for testing Telephony phone device APIs.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTphoneDll   = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TphoneDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTphoneDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+
+BOOL
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneConfigDialog(TRUE, TRUE));
+}
+
+
+BOOL
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneDevSpecific(TRUE, TRUE));
+}
+
+
+BOOL
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneNegotiateExtVersion(TRUE, TRUE));
+}
+
+
+BOOL
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetIcon(TRUE, TRUE));
+}
+
+
+BOOL
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetID(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetStatus(TRUE, TRUE));
+}
+
+
+BOOL
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetButtonInfo(TRUE, TRUE));
+}
+
+
+BOOL
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetButtonInfo(TRUE, TRUE));
+}
+
+
+BOOL
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetData(TRUE, TRUE));
+}
+
+BOOL
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetData(TRUE, TRUE));
+}
+
+
+BOOL
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetDisplay(TRUE, TRUE));
+}
+
+
+BOOL
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetDisplay(TRUE, TRUE));
+}
+
+
+BOOL
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetGain(TRUE, TRUE));
+}
+
+
+BOOL
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetGain(TRUE, TRUE));
+}
+
+
+BOOL
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetHookSwitch(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test16(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetHookSwitch(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test17(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetLamp(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test18(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetLamp(TRUE, TRUE));
+}
+
+
+
+
+
+BOOL
+Test19(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetRing(TRUE, TRUE));
+}
+
+
+BOOL
+Test20(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetRing(TRUE, TRUE));
+}
+
+
+
+
+
+
+BOOL
+Test21(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetStatusMessages(TRUE, TRUE));
+}
+
+
+BOOL
+Test22(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetStatusMessages(TRUE, TRUE));
+}
+
+
+
+
+BOOL
+Test23(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetVolume(TRUE, TRUE));
+}
+
+
+BOOL
+Test24(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetVolume(TRUE, TRUE));
+}
+
+
+BOOL
+Test25(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneClose(TRUE, TRUE));
+}
+
+
+BOOL
+Test26(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetDevCaps(TRUE, TRUE));
+}
+
+BOOL
+Test27(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneInitialize(TRUE, TRUE));
+}
+
+BOOL
+Test28(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneNegotiateAPIVersion(TRUE, TRUE));
+}
+
+BOOL
+Test29(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneOpen(TRUE, TRUE));
+}
+
+BOOL
+Test30(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneShutdown(TRUE, TRUE));
+}
+
+
+
+BOOL
+WINAPI
+Test31(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestPhoneInitializeEx(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test32(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestPhoneGetMessage(TRUE, FALSE));
+}
+
+
+
+
+
+BOOL
+ShouldTapiPhoneTestAbort(BOOL fQuiteMode)
+{
+	return FALSE;
+}
diff --git a/private/tapi/qa/trapper/itest/phone/tphone.def b/private/tapi/qa/trapper/itest/phone/tphone.def
new file mode 100644
index 000000000..0f2f4208c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/tphone.def
@@ -0,0 +1,42 @@
+LIBRARY         tphone
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
+        Test16
+        Test17
+        Test18
+        Test19
+        Test20
+        Test21
+        Test22
+        Test23
+        Test24
+        Test25
+        Test26
+        Test27
+        Test28
+        Test29
+        Test30
+        Test31
+        Test32
diff --git a/private/tapi/qa/trapper/itest/phone/tphone.h b/private/tapi/qa/trapper/itest/phone/tphone.h
new file mode 100644
index 000000000..a72225f5e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/tphone.h
@@ -0,0 +1,293 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tphone.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI phone device functions.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef TPHONE_H
+#define TPHONE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+// Macro for handling failures
+#define TPHONE_FAIL()  {                                                      \
+                           if (ShouldTapiPhoneTestAbort(fQuietMode))          \
+                           {                                                  \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp1); \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp2); \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp3); \
+                               return FALSE;                                  \
+                           }                                                  \
+                           fTestPassed = FALSE;                               \
+                       }
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+ShouldTapiPhoneTestAbort(
+	BOOL fQuiteMode
+	);
+
+
+BOOL
+TestPhoneConfigDialog(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+
+BOOL
+TestPhoneDevSpecific(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetButtonInfo(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetData(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetDisplay(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetGain(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetHookSwitch(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetIcon(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetID(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetLamp(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+
+BOOL
+TestPhoneGetRing(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetStatus(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetStatusMessages(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneGetVolume(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneNegotiateExtVersion(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetButtonInfo(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneSetData(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneSetDisplay(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetGain(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetHookSwitch(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetLamp(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetRing(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneSetStatusMessages(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetVolume(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneClose(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneGetDevCaps(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneInitialize(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneNegotiateAPIVersion(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneOpen(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneShutdown(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneInitializeEx(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestPhoneGetMessage(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+
+
+#endif  // TPHONE_H
+
diff --git a/private/tapi/qa/trapper/itest/phone/tphone.rc b/private/tapi/qa/trapper/itest/phone/tphone.rc
new file mode 100644
index 000000000..13ed29149
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/phone/tphone.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI Phone API test Library"
+#define VER_INTERNALNAME_STR        "tphone.dll"
+#define VER_ORIGINALFILENAME_STR    "tphone.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlgad.c b/private/tapi/qa/trapper/itest/sline/itlgad.c
new file mode 100644
index 000000000..5b904bd8b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlgad.c
@@ -0,0 +1,183 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgat.c
+
+Abstract:
+
+    This module contains the test functions for lineGatherDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define PULSESIZE	16
+#define DTMFSIZE	16
+
+
+//  lineGatherDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGatherDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD	dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGatherDigits");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	dwSize = PULSESIZE;
+	lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+   lpTapiLineTestInfo->dwNumDigits = 2;
+	lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### lpsDigits = %s",
+		lpTapiLineTestInfo->lpsDigits);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGatherDigits Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGatherDigits Test Failed");
+		
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlgap.c b/private/tapi/qa/trapper/itest/sline/itlgap.c
new file mode 100644
index 000000000..da81184df
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlgap.c
@@ -0,0 +1,158 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgap.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAppPriority
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineGetAppPriority
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAppPriority(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwPrioritySav;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAppPriority");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetAppPriority for go/no-go");
+
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+	dwPrioritySav = *lpTapiLineTestInfo->lpdwPriority;
+	lpTapiLineTestInfo->dwPriority = !dwPrioritySav;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetAppPriority Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetAppPriority Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlmod.c b/private/tapi/qa/trapper/itest/sline/itlmod.c
new file mode 100644
index 000000000..33b6cf47d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlmod.c
@@ -0,0 +1,170 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmod.c
+
+Abstract:
+
+    This module contains the test functions for lineMonitorDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  lineMonitorDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineMonitorDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineMonitorDigits");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineMonitorDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineMonitorDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineMonitorDigits Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineMonitorDigits Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlmom.c b/private/tapi/qa/trapper/itest/sline/itlmom.c
new file mode 100644
index 000000000..ff54dbec9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlmom.c
@@ -0,0 +1,171 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmom.c
+
+Abstract:
+
+    This module contains the test functions for lineMonitorMedia
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  lineMonitorMedia
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineMonitorMedia(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineMonitorMedia");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+ 	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+//	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_TELETEX;
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineMonitorMedia(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineMonitorMedia(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineMonitorMedia Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineMonitorMedia Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlmot.c b/private/tapi/qa/trapper/itest/sline/itlmot.c
new file mode 100644
index 000000000..606f980a3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlmot.c
@@ -0,0 +1,171 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmot.c
+
+Abstract:
+
+    This module contains the test functions for lineMonitorTones
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  lineMonitorTones
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineMonitorTones(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineMonitorTones");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+		sizeof(LINEMONITORTONE));
+	lpTapiLineTestInfo->dwNumEntries = 1;
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineMonitorTones(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineMonitorTones(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineMonitorTones Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineMonitorTones Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlpak.c b/private/tapi/qa/trapper/itest/sline/itlpak.c
new file mode 100644
index 000000000..a75ad10c0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlpak.c
@@ -0,0 +1,176 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpk.c
+
+Abstract:
+
+    This module contains the test functions for linePark
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  linePark
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePark(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test linePark");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+	lpTapiLineTestInfo->lpszDirAddress = "55555";
+	lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap (
+		sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLinePark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLinePark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePark Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePark Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlpk.c b/private/tapi/qa/trapper/itest/sline/itlpk.c
new file mode 100644
index 000000000..70589ca39
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlpk.c
@@ -0,0 +1,162 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpk.c
+
+Abstract:
+
+    This module contains the test functions for linePickup
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  linePickup
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePickup(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test linePickup");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->lpszGroupID = "55555";
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePickup Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePickup Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlsap.c b/private/tapi/qa/trapper/itest/sline/itlsap.c
new file mode 100644
index 000000000..611b47666
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlsap.c
@@ -0,0 +1,158 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsap.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAppPriority
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetAppPriority
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAppPriority(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwPrioritySav;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetAppPriority");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetAppPriority for go/no-go");
+
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+	dwPrioritySav = *lpTapiLineTestInfo->lpdwPriority;
+	lpTapiLineTestInfo->dwPriority = !dwPrioritySav;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetAppPriority Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetAppPriority Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlscd.c b/private/tapi/qa/trapper/itest/sline/itlscd.c
new file mode 100644
index 000000000..cf9bdd5f9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlscd.c
@@ -0,0 +1,201 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscd.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallData
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetCallData
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallData(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPBYTE lpszCallData;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetCallData");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"Before: lpCallInfo->dwCallDataSize = %lx, dwCallDataOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataSize,
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataOffset
+		);
+	
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetCallData for go/no-go");
+
+	lpszCallData = "This is a test";
+	lpTapiLineTestInfo->lpCallData = (LPVOID)lpszCallData;
+   lpTapiLineTestInfo->dwSize = strlen(lpszCallData);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallData(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	 if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: lpCallInfo->dwCallDataSize = %lx, dwCallDataOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataSize,
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataOffset
+		);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCallData Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCallData Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlscl.c b/private/tapi/qa/trapper/itest/sline/itlscl.c
new file mode 100644
index 000000000..160a031af
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlscl.c
@@ -0,0 +1,184 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscl.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCurrentLocation
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetCurrentLocation
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCurrentLocation(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPLINELOCATIONENTRY lpLineLocationEntry;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetCurrentLocation");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	if(! DoLineNegotiateAPIVersion (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetCurrentLocation for go/no-go");
+
+	// Call lineGetTranslateCaps to get LocationID
+
+	lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+			BIGBUFSIZE);
+	lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumLocations = %lx, dwCurrentLocationID = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID);
+
+
+	if(lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations <= 1)
+	{
+	   lpTapiLineTestInfo->dwLocation = lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID;
+	}
+	else 
+	{
+      if(lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations == 
+         lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID)
+         lpTapiLineTestInfo->dwLocation =
+            lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations -1;
+      else
+         lpTapiLineTestInfo->dwLocation =
+            lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations;
+    }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwLocationID = %lx",
+		lpTapiLineTestInfo->dwLocation);
+
+
+ 	 if(lpTapiLineTestInfo->dwLocation == 0)
+    {
+    if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, LINEERR_INVALLOCATION))
+      {
+          TLINE_FAIL();
+      }
+    }
+    else
+    {
+ 	 if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+    }
+
+	// Call lineGetTranslateCaps to verify LocationID
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumLocations = %lx, dwCurrentLocationID = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID);
+
+
+ 
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCurrentLocation Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCurrentLocation Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlscqs.c b/private/tapi/qa/trapper/itest/sline/itlscqs.c
new file mode 100644
index 000000000..0df0778e4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlscqs.c
@@ -0,0 +1,235 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscqs.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallQualityOfService
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "winsock2.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetCallQualityOfService
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallQualityOfService(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPFLOWSPEC 	lpSendingFlowspec, lpReceivingFlowspec;
+	LPQOS		  	lpQos;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetCallQualityOfService");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+ 
+   if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS)NULL;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"Before: dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecOffset
+		);
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"Before: dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecOffset
+		);
+		
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetCallQualityOfService for go/no-go");
+
+	lpQos = (LPQOS) AllocFromTestHeap ( sizeof(QOS));
+	lpSendingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpSendingFlowspec->LevelOfGuarantee = GuaranteedService;
+	lpTapiLineTestInfo->lpSendingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec);
+
+	lpReceivingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpTapiLineTestInfo->lpReceivingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwReceivingFlowspecSize = sizeof(lpQos->ReceivingFlowspec);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	 if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+   /*
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecOffset
+		);
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecOffset
+		);
+	  */
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCallQualityOfService Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCallQualityOfService Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlsct.c b/private/tapi/qa/trapper/itest/sline/itlsct.c
new file mode 100644
index 000000000..5d5e74a6b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlsct.c
@@ -0,0 +1,226 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsct.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallTreatment
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetCallTreatment
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallTreatment(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetCallTreatment");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+ 
+   if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS)NULL;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	/*
+	lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+
+ 	
+	lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+		sizeof(LINEADDRESSCAPS));
+	lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEADDRESSCAPS);
+
+	if(!DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+
+	
+   lpTapiLineTestInfo->dwTreatment = (lpTapiLineTestInfo->lpLineAddressCaps->dwNumCallTreatments == 0 ?
+		0 : lpTapiLineTestInfo->lpLineAddressCaps->dwNumCallTreatments - 1);
+	*/
+	
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"Before: lpCallInfo->dwTreatment = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallTreatment);
+	
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetCallTreatment for go/no-go");
+
+	lpTapiLineTestInfo->dwTreatment = LINECALLTREATMENT_SILENCE;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	 if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: lpCallInfo->dwTreatment = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallTreatment);
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCallTreatment Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetCallTreatment Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlslds.c b/private/tapi/qa/trapper/itest/sline/itlslds.c
new file mode 100644
index 000000000..d69359b3f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlslds.c
@@ -0,0 +1,189 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlslds.c
+
+Abstract:
+
+    This module contains the test functions for lineSetLineDevStatus
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetLineDevStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetLineDevStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetLineDevStatus");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+ 
+   if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+		sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before: lpLineDevStatus->dwDevStatusFlags = %lx", 
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+		
+    // Set the line device capabilities
+	lpTapiLineTestInfo->dwStatusToChange = LINEDEVSTATUSFLAGS_CONNECTED;
+	lpTapiLineTestInfo->fStatus = TRUE;
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetLineDevStatus for go/no-go");
+
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+		{
+	    if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+   	 {
+      	  TLINE_FAIL();
+	    }
+		}
+	 else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+	    if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+	    {
+   	     TLINE_FAIL();
+	    }
+		}
+
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After: lpLineDevStatus->dwDevStatusFlags = %lx", 
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+		
+ 
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetLineDevStatus Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetLineDevStatus Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlucc.c b/private/tapi/qa/trapper/itest/sline/itlucc.c
new file mode 100644
index 000000000..ce25abf1a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlucc.c
@@ -0,0 +1,210 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlucc.c
+
+Abstract:
+
+    This module contains the test functions for lineUncompleteCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineUncompleteCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineUncompleteCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineUncompleteCall");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	lpTapiLineTestInfo->dwMessageID = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->dwCompletionID);		
+	
+	// call linecallinfo to verify the comepletion
+   
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap (
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCompletionID);		
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineUncompleteCall for go/no-go");
+
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineUncompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+		
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineUncompleteCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineUncompleteCall Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/itlupak.c b/private/tapi/qa/trapper/itest/sline/itlupak.c
new file mode 100644
index 000000000..f55fcdb10
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/itlupak.c
@@ -0,0 +1,166 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlupak.c
+
+Abstract:
+
+    This module contains the test functions for lineUnpark
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  lineUnpark
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineUnpark(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineUnpark");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineUnpark for go/no-go");
+
+
+	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineUnpark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineUnpark Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineUnpark Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/makefile b/private/tapi/qa/trapper/itest/sline/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/sline/sline.c b/private/tapi/qa/trapper/itest/sline/sline.c
new file mode 100644
index 000000000..c62ccd4a2
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/sline.c
@@ -0,0 +1,337 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    sline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "sline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghSLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+SLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghSLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGatherDigits(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMonitorDigits(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMonitorMedia(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMonitorTones(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePark(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUnpark(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePickup(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUncompleteCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAppPriority(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAppPriority(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCurrentLocation(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallData(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallQualityOfService(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallTreatment(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetLineDevStatus(TRUE, FALSE));
+}
+
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/sline.def b/private/tapi/qa/trapper/itest/sline/sline.def
new file mode 100644
index 000000000..8ddcc7861
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/sline.def
@@ -0,0 +1,25 @@
+LIBRARY         sline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
diff --git a/private/tapi/qa/trapper/itest/sline/sline.h b/private/tapi/qa/trapper/itest/sline/sline.h
new file mode 100644
index 000000000..3349c574d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/sline.h
@@ -0,0 +1,294 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    sline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef SLINE_H
+#define SLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineGatherDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMonitorDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMonitorMedia(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMonitorTones(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePark(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineUnpark(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePickup(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineUncompleteCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAppPriority(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAppPriority(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCurrentLocation(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCallData(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCallQualityOfService(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCallTreatment(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetLineDevStatus(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    );
+
+#endif  // SLINE_H
diff --git a/private/tapi/qa/trapper/itest/sline/sline.rc b/private/tapi/qa/trapper/itest/sline/sline.rc
new file mode 100644
index 000000000..85eca83e5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/sline.rc
@@ -0,0 +1,13 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI SLine API test Library"
+#define VER_INTERNALNAME_STR        "sline.dll"
+#define VER_ORIGINALFILENAME_STR    "sline.dll"
+
+#include "common.ver"
+
+
+
diff --git a/private/tapi/qa/trapper/itest/sline/sources b/private/tapi/qa/trapper/itest/sline/sources
new file mode 100644
index 000000000..2179e63d6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/sline/sources
@@ -0,0 +1,74 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=sline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x67000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	sline.c \
+		itlgad.c  \
+		itlmod.c  \
+		itlmom.c  \
+		itlmot.c  \
+		itlpak.c  \
+		itlupak.c \
+		itlucc.c  \
+		itlpk.c  \
+		itlgap.c  \
+		itlsap.c  \
+		itlscl.c  \
+		itlscd.c  \
+		itlscqs.c \
+		itlsct.c \
+		itlslds.c \
+     		sline.rc
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=SLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tcline/cline.c b/private/tapi/qa/trapper/itest/tcline/cline.c
new file mode 100644
index 000000000..a41e57ca9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/cline.c
@@ -0,0 +1,328 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    cline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "cline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTCLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TCLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTCLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninitialize(TRUE, TRUE));
+}
+
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAddToConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetConfRelatedCalls(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePrepareAddToConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRemoveFromConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetupConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineCompleteCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRedirect(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSecureCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSwapHold(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiGetLocationInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestDrop(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestMakeCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestMediaCall(TRUE, FALSE));
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/cline.def b/private/tapi/qa/trapper/itest/tcline/cline.def
new file mode 100644
index 000000000..5654240bb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/cline.def
@@ -0,0 +1,25 @@
+LIBRARY         tcline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+
diff --git a/private/tapi/qa/trapper/itest/tcline/cline.h b/private/tapi/qa/trapper/itest/tcline/cline.h
new file mode 100644
index 000000000..10fa65067
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/cline.h
@@ -0,0 +1,189 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    cline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding 		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef CLINE_H
+#define CLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+BOOL
+TestLineUninitialize(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+BOOL
+TestLineAddToConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetConfRelatedCalls(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePrepareAddToConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRemoveFromConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetupConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineCompleteCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRedirect(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineSecureCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSwapHold(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestTapiGetLocationInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTapiRequestDrop(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestTapiRequestMakeCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestTapiRequestMediaCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+
+#endif  // CLINE_H
diff --git a/private/tapi/qa/trapper/itest/tcline/cline.rc b/private/tapi/qa/trapper/itest/tcline/cline.rc
new file mode 100644
index 000000000..f6c6b8cdd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/cline.rc
@@ -0,0 +1,13 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI TCLine API test Library"
+#define VER_INTERNALNAME_STR        "tcline.dll"
+#define VER_ORIGINALFILENAME_STR    "tcline.dll"
+
+#include "common.ver"
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/dirs b/private/tapi/qa/trapper/itest/tcline/dirs
new file mode 100644
index 000000000..d4281cd08
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/dirs
@@ -0,0 +1,2 @@
+DIRS= tclinea\
+      tclinew
diff --git a/private/tapi/qa/trapper/itest/tcline/itlatc.c b/private/tapi/qa/trapper/itest/tcline/itlatc.c
new file mode 100644
index 000000000..699bbb5b5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlatc.c
@@ -0,0 +1,1663 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlatc.c
+
+Abstract:
+
+    This module contains the test functions for lineAddToConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineAddToConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAddToConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+   HCALL hConfCall = NULL, hConsultCall = NULL;
+   LONG lret;
+   LPTAPIMSG lpTapiMsg = NULL;
+   LPTAPIMSG lpMatch;
+   INT i;
+   DWORD dwNumCalls;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineAddToConference  <<<<<<<<"
+            );
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+		  
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hConfCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+	
+//   lpTapiLineTestInfo->lphCall = NULL;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+	
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphConfCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphConfCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphConfCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad hConfCall = hConsultCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+	
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphConfCall);
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConsultCall1;
+    if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCONFCALLHANDLE, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphConfCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hConsultCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+		
+   lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphConsultCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphConsultCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphConsultCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad hConsultCall = hConfCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+	
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphConsultCall);
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConfCall1;
+    if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphConsultCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no owner for hConfCall", dwTestCase + 1
+            );
+
+/*
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/ 
+   lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+   lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->lpLineInitializeExParams = 
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =  
+         sizeof(LINEINITIALIZEEXPARAMS);
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions = 
+         LINEINITIALIZEEXOPTION_USEEVENT;
+ 
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+  
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+   lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+
+   lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE) AllocFromTestHeap (
+        sizeof(LINEMESSAGE));
+   
+   for(i=0; i<10; i++)
+   {
+	if(! DoLineGetMessage (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+   if(lpTapiLineTestInfo->lpMessage->dwMessageID == LINE_CALLSTATE)
+     { 
+      if(lpTapiLineTestInfo->lpMessage->dwParam1 == LINECALLSTATE_ONHOLDPENDCONF &&
+         lpTapiLineTestInfo->lpMessage->hDevice != (DWORD)(*lpTapiLineTestInfo->lphConfCall))
+         hConfCall = (HCALL)lpTapiLineTestInfo->lpMessage->hDevice;
+      if(lpTapiLineTestInfo->lpMessage->dwParam1 == LINECALLSTATE_DIALTONE && 
+         lpTapiLineTestInfo->lpMessage->hDevice != (DWORD)(*lpTapiLineTestInfo->lphConsultCall))
+         hConsultCall = (HCALL)lpTapiLineTestInfo->lpMessage->hDevice;
+      if(hConfCall != 0 && hConsultCall != 0)
+        {
+         fTestPassed = TRUE;
+         break;
+        }
+		   }	  
+     }
+
+   if(hConfCall != 0 && hConsultCall != 0)
+      fTestPassed = TRUE;
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##hConfCall = %lx, hConsCall = %lx", 
+        hConfCall, hConsultCall);
+
+    lpTapiLineTestInfo->lphConfCall = &hConfCall;
+    lpTapiLineTestInfo->lphConsultCall = &hConsultCall;
+
+    if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+      {
+        TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+      BIGBUFSIZE);
+   lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### Before Add: lpCallList->dwCallsNumEntries = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries);
+
+   dwNumCalls = lpTapiLineTestInfo->lpCallList->dwCallsNumEntries;  
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### After Add: lpCallList->dwCallsNumEntries = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries);
+
+   if(lpTapiLineTestInfo->lpCallList->dwCallsNumEntries >
+      dwNumCalls)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Re-add hConsultCall to conference", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLSTATE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hCall (same hLineApp, hLine, id) not get from SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hCall (same hLineApp, diff hLine, same id) not get from SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+
+   lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine2;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hCall (same hLineApp, diff hLine, diff id) not get from SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwDeviceID = 0;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+
+   lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine2;
+   lpTapiLineTestInfo->dwDeviceID = 1;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+/* diff same hLine is not make sence, temp remove it, late to check
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hCall (diff hLineApp, same hLine, same id) not get from SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hCall (diff hLineApp, diff hLine, same id) not get from SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+ 	lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;		       
+//   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+	*lpTapiLineTestInfo->lphConsultCall = lpTapiLineTestInfo->hCall2;
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hCall (diff hLineApp, diff hLine, diff id) not get from SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwDeviceID = 0;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwDeviceID = 1;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+ 	lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;		       
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+  
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hConfCall (same hLineApp, hLine) get from another SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->hCall2 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+	lpTapiLineTestInfo->lphConfCall = &hConfCall;
+	lpTapiLineTestInfo->lphConsultCall = &hConsultCall;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   *lpTapiLineTestInfo->lphConfCall = hConfCall;
+   *lpTapiLineTestInfo->lphConsultCall = lpTapiLineTestInfo->hConsultCall1;
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+ 
+ 
+   lpTapiLineTestInfo->lphConfCall = &hConfCall;
+   lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLSTATE, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hConsultCall (same hLineApp, same hLine) get from another SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+   
+
+   lpTapiLineTestInfo->hCall2 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+	lpTapiLineTestInfo->lphConfCall = &hConfCall;
+	lpTapiLineTestInfo->lphConsultCall = &hConsultCall;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+//	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+//       {
+//           TLINE_FAIL();
+//       }
+ 
+   *lpTapiLineTestInfo->lphConfCall = hConfCall;
+   *lpTapiLineTestInfo->lphConsultCall = lpTapiLineTestInfo->hConsultCall1;
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*     
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Add hConfCall (diff hLineApp, same hLine) get from another SetupConf", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    lpTapiLineTestInfo->lphLine  = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1; 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->hCall2 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+	lpTapiLineTestInfo->lphConfCall = &hConfCall;
+	lpTapiLineTestInfo->lphConsultCall = &hConsultCall;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   WaitForAllMessages();
+
+   lpTapiLineTestInfo->lphConfCall = hConfCall;
+   lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests													  
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp1;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lphLineApp = &lpTapiLineTestInfo->hLineApp2;
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+*/
+       
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+	 lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	 lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	 lpTapiLineTestInfo->dwNumParties = 8;
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	 if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+    WaitForAllMessages();
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineAddToConference(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+	 lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	 lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	 lpTapiLineTestInfo->dwNumParties = 8;
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	 if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+    WaitForAllMessages();
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_CONFERENCEFULL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineAddToConference(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineAddToConference: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineAddToConference  <<<<<<<<"
+            );
+ 
+	return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlcc.c b/private/tapi/qa/trapper/itest/tcline/itlcc.c
new file mode 100644
index 000000000..93c9cb195
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlcc.c
@@ -0,0 +1,1057 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcc.c
+
+Abstract:
+
+    This module contains the test functions for lineCompleteCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+#define   ALL_CALLCOMPLMODES    (LINECALLCOMPLMODE_CAMPON   | \
+											LINECALLCOMPLMODE_CALLBACK | \
+											LINECALLCOMPLMODE_INTRUDE  | \
+											LINECALLCOMPLMODE_MESSAGE)
+
+
+//  lineCompleteCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineCompleteCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fEsp;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams                        = GetCallbackParams();
+
+	
+   OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineCompleteCall  <<<<<<<<"
+            );
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpdwCompletionID ", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpdwCompletionID = 
+                 (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+   
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwCompletionMode", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     lpTapiLineTestInfo->dwDeviceID = 0;
+  	  if(IsESPLineDevice(lpTapiLineTestInfo))
+        fEsp = TRUE;
+     else
+        fEsp = FALSE;
+
+
+     if(fEsp)
+     {
+       if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineCompleteCall,
+            (LPDWORD) &lpTapiLineTestInfo->dwCompletionMode,
+            LINEERR_INVALCALLCOMPLMODE,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_CALLCOMPLMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+       {
+          TLINE_FAIL();
+       }
+      }
+      else
+      {
+       if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineCompleteCall,
+            (LPDWORD) &lpTapiLineTestInfo->dwCompletionMode,
+            LINEERR_OPERATIONUNAVAIL,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_CALLCOMPLMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+       {
+          TLINE_FAIL();
+       }
+      }
+    
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamest for dwCompletionMode", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     lpTapiLineTestInfo->dwDeviceID = 0;
+  	  if(IsESPLineDevice(lpTapiLineTestInfo))
+        fEsp = TRUE;
+     else
+        fEsp = FALSE;
+
+     if(fEsp)
+     {
+     if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineCompleteCall,
+            (LPDWORD) &lpTapiLineTestInfo->dwCompletionMode,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_CALLCOMPLMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+//            0xffffffff,
+            FALSE
+            ))
+      {
+          TLINE_FAIL();
+      }
+     }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, dwMessageID, 0", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_MESSAGE;
+	lpTapiLineTestInfo->dwMessageID = 0x0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, dwMessageID, dwNumMessags - 1", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+            sizeof(LINEADDRESSCAPS));
+    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+    
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_MESSAGE;
+	lpTapiLineTestInfo->dwMessageID = 
+     lpTapiLineTestInfo->lpLineAddressCaps->dwNumCompletionMessages - 1;
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwMessageID, dwNumMessags", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetAddressCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+    
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_MESSAGE;
+	lpTapiLineTestInfo->dwMessageID = 
+       lpTapiLineTestInfo->lpLineAddressCaps->dwNumCompletionMessages;
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if ( DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_INVALMESSAGEID, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         LINEERR_INVALMESSAGEID,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwMessageID, -1", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_MESSAGE;
+	lpTapiLineTestInfo->dwMessageID = 0xffffffff;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if ( DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_INVALMESSAGEID, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         LINEERR_INVALMESSAGEID,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+  
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	lpTapiLineTestInfo->dwMessageID = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->dwCompletionID);		
+	
+	// call linecallinfo to verify the comepletion
+   
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap (
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCompletionID);		
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+    lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	 lpTapiLineTestInfo->dwMessageID = 0;
+
+    if ( ! DoLineCompleteCall(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+    lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	 lpTapiLineTestInfo->dwMessageID = 0;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineCompleteCall(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+	
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineCompleteCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineCompleteCall  <<<<<<<<"
+            );
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlgcrc.c b/private/tapi/qa/trapper/itest/tcline/itlgcrc.c
new file mode 100644
index 000000000..e8ff42006
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlgcrc.c
@@ -0,0 +1,927 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgcrc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetConfRelatedCalls
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+#define NUMTOTALSIZES 7
+#define PAGESIZE      4096
+
+
+//  lineGetConfRelatedCalls
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetConfRelatedCalls(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   HCALL hCall1, hCall2;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+   DWORD dwNumCalls;
+   DWORD dwFixedSize = sizeof(LINECALLLIST);
+   DWORD dwOneCallSize = dwFixedSize + sizeof(HCALL);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+									10,
+                           (DWORD) dwFixedSize - 1,
+ 									(DWORD) dwFixedSize,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetConfRelatedCalls  <<<<<<<<"
+            );
+
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+		  
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }	 
+	
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+/*
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+*/
+	
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: hCall not in conf statet", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, LINEERR_NOCONFERENCE))
+      {
+         TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpCallList ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+ 
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;	
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) gdwInvalidPointers[n];
+        if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: hCall not in conference state", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, LINEERR_NOCONFERENCE))
+      {
+        TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }				 
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpCallList->dwTotalSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       dwFixedSize);
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else if(dwTotalSizes[n] >= dwFixedSize && dwTotalSizes[n] < PAGESIZE)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwFixedSize;
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 	 FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+		
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+        TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	 FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify only one space", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+		
+    dwNumCalls = 1;
+    dwSize = sizeof(LINECALLLIST) + dwNumCalls * sizeof(HCALL);    
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       dwSize);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+        TLINE_FAIL();
+      }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+	   "dwFixedSize = %lx, dwTotalSize = %lx", 
+      dwFixedSize, dwSize);
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+   
+   if(lpTapiLineTestInfo->lpCallList->dwCallsNumEntries == 0)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+	 FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify no room for one call", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+		
+    dwNumCalls = 0;
+    dwSize = sizeof(LINECALLLIST) + dwNumCalls * sizeof(HCALL);    
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       dwSize);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+        TLINE_FAIL();
+      }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+	   "dwFixedSize = %lx, dwTotalSize = %lx", 
+      dwFixedSize, dwSize);
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+   
+   if(lpTapiLineTestInfo->lpCallList->dwCallsNumEntries == 0)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+	 FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify return data, 2 calls", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+		
+    dwNumCalls = 2;
+    dwSize = sizeof(LINECALLLIST) + dwNumCalls * sizeof(HCALL);    
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+       dwSize);
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+        TLINE_FAIL();
+      }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+	   "dwFixedSize = %lx, dwTotalSize = %lx", 
+      dwFixedSize, dwSize);
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+   
+   if(lpTapiLineTestInfo->lpCallList->dwCallsNumEntries == 2)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+
+   n=0;
+   hCall1 = *((LPHCALL) ((LPBYTE)lpTapiLineTestInfo->lpCallList +
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+ n*sizeof(HCALL)));
+   n=1;
+   hCall2 = *((LPHCALL) ((LPBYTE)lpTapiLineTestInfo->lpCallList +
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+ n*sizeof(HCALL)));
+	
+   if(hCall1 == *lpTapiLineTestInfo->lphConfCall &&
+		hCall2 == *lpTapiLineTestInfo->lphConsultCall)
+      fTestPassed = TRUE;
+    else
+      fTestPassed = FALSE;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, using hConfCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall = &hCall1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+	 lpTapiLineTestInfo->dwCountryCode = 0;
+ 
+    if(! DoLineDial(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+
+
+/* Need check Intel tset code to find out how to do this test case.  Now
+   temp moved out 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify LINE_CALLINFO/NUMMONITORS msg send", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+		
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+        TLINE_FAIL();
+      }
+
+    AddMessage(
+            LINE_CALLINFO,
+            (DWORD) *lpTapiLineTestInfo->lphCall,
+            (DWORD) lpCallbackParams,
+            LINECALLINFOSTATE_NUMMONITORS,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    // If the wait succeeds, then the LINE_CALLINFO message was received
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+  
+   FreeTestHeap(); 
+  
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetConfRelatedCalls: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetConfRelatedCalls  <<<<<<<<"
+            );
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlpatc.c b/private/tapi/qa/trapper/itest/tcline/itlpatc.c
new file mode 100644
index 000000000..1971292b0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlpatc.c
@@ -0,0 +1,950 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpatc.c
+
+Abstract:
+
+    This module contains the test functions for linePrepareAddToConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+#define DWNUMCALLS 2
+#define NUMTOTALSIZES 5
+
+
+//  linePrepareAddToConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePrepareAddToConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+   HCALL hConfCall;
+   HCALL hConsultCall;
+   DWORD dwFixedSize = sizeof(LINECALLPARAMS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+ 
+	
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing linePrepareAddToConference  <<<<<<<<"
+            );
+
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+		  
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: No owner for hConfCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;   
+	lpTapiLineTestInfo->lphConfCall = &hConfCall;
+	lpTapiLineTestInfo->lphConsultCall = &hConsultCall;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    // Open another line with MONITOR
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 8;
+
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hConfCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset+4
+            );
+
+    lpTapiLineTestInfo->lphConfCall    = &lpTapiLineTestInfo->hConfCall1;	
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+	 if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+ 	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hConfCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+   lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphConfCall);
+
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *lpTapiLineTestInfo->lphConfCall = (HCALL) gdwInvalidHandles[n];
+        if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphConfCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphConsultCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+//	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+	
+   for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lphConsultCall = (LPHCALL) gdwInvalidHandles[n];
+        if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallParams values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpCallParams = 
+            (LPLINECALLPARAMS) gdwInvalidPointers[n];
+        if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad hConfCall, non-conf call values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+	
+	 lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+	
+    if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_INVALCONFCALLHANDLE, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+       sizeof(LINECALLPARAMS));
+   lpTapiLineTestInfo->lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS);
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify hConsultCall can't be used", dwTestCase + 1
+            );
+
+/*
+    if(! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+*/
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if(! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = dwFixedSize;			 
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpCallParams = NULL", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+	if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+	for(n=0; n< (INT) lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+			
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpCallParams = valid", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+       sizeof(LINECALLPARAMS));
+   lpTapiLineTestInfo->lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS);
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+	if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+	for(n=0; n< (INT) lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+			
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+		
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->hCall1 = NULL;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	 lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	 lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	 lpTapiLineTestInfo->dwNumParties = 8;
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	 if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLinePrepareAddToConference(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->hCall1 = NULL;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	 lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	 lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	 lpTapiLineTestInfo->dwNumParties = 8;
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	 if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_CONFERENCEFULL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLinePrepareAddToConference(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ linePrepareAddToConference: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing linePrepareAddToConference  <<<<<<<<"
+            );
+ 
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlrd.c b/private/tapi/qa/trapper/itest/tcline/itlrd.c
new file mode 100644
index 000000000..90edac64d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlrd.c
@@ -0,0 +1,564 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrd.c
+
+Abstract:
+
+    This module contains the test functions for lineRedirect
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/2/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineRedirect
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRedirect(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[]  = L"55555";
+   WCHAR wszValidDestAddress[] = L"64738";
+#else
+   CHAR szValidAddress[]  = "55555";
+   CHAR szValidDestAddress[] = "64738";
+#endif
+
+	InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineRedirect  <<<<<<<<"
+            );
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpszAddress ", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDestAddress = 
+                 (LPWSTR) gdwInvalidPointers[n];
+#else
+        lpTapiLineTestInfo->lpszDestAddress = 
+                 (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineRedirect(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    FreeTestHeap();
+
+	
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+
+    if ( ! DoLineRedirect(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineRedirect(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineRedirect: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineRedirect  <<<<<<<<"
+            );
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlrfc.c b/private/tapi/qa/trapper/itest/tcline/itlrfc.c
new file mode 100644
index 000000000..d0fdfd6d5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlrfc.c
@@ -0,0 +1,653 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrfc.c
+
+Abstract:
+
+    This module contains the test functions for lineRemoveFromConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+#define DWNUMCALLS 2
+
+
+//  lineRemoveFromConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRemoveFromConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+   DWORD dwNumCalls;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+	InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineRemoveFromConference  <<<<<<<<"
+            );
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+		  
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+    }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineRemoveFromConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad hCall, non-conf call values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+   lpTapiLineTestInfo->dwCountryCode = 0;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+	
+    if (! DoLineRemoveFromConference(lpTapiLineTestInfo, LINEERR_INVALCALLSTATE, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: No owner for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;   
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	
+    // Open another line with MONITOR
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (DWNUMCALLS) * sizeof(HCALL) + 8;
+
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall1,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    lpTapiLineTestInfo->lphCall    = &lpTapiLineTestInfo->hCall1;	
+
+   if (! DoLineRemoveFromConference(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+	 if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+ 	
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+      BIGBUFSIZE);
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail (
+	   DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+   dwNumCalls = lpTapiLineTestInfo->lpCallList->dwCallsNumEntries;
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+	if (! DoLineRemoveFromConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	 TapiLogDetail (
+	    DBUG_SHOW_DETAIL,
+		 "### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		 lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		 lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+    if(lpTapiLineTestInfo->lpCallList->dwCallsNumEntries < dwNumCalls)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	 lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    if ( ! DoLineRemoveFromConference(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	 lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineRemoveFromConference(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineRemoveFromConference: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineRemoveFromConference  <<<<<<<<"
+            );
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlsc.c b/private/tapi/qa/trapper/itest/tcline/itlsc.c
new file mode 100644
index 000000000..0662f9c7c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlsc.c
@@ -0,0 +1,476 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsc.c
+
+Abstract:
+
+    This module contains the test functions for lineSecureCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineSecureCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSecureCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[]  = L"55555";
+#else
+   CHAR szValidAddress[]  = "55555";
+#endif
+
+	InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSecureCall  <<<<<<<<"
+            );
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSecureCall(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineSecureCall(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineSecureCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSecureCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	// how to verify the call be secured?
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 FreeTestHeap();
+
+	
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineSecureCall(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSecureCall(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSecureCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSecureCall  <<<<<<<<"
+            );
+ 
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/itlsh.c b/private/tapi/qa/trapper/itest/tcline/itlsh.c
new file mode 100644
index 000000000..521d32551
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlsh.c
@@ -0,0 +1,765 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsh.c
+
+Abstract:
+
+    This module contains the test functions for lineSwapHold
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  lineSwapHold
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSwapHold(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[]  = L"55555";
+#else
+   CHAR szValidAddress[]  = "55555";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSwapHold  <<<<<<<<"
+            );
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hActiveCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hActiveCall;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hActiveCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hActiveCall;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hHeldCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hActiveCall;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hHeldCall;
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+       fEsp = TRUE;
+    else
+		 fEsp = FALSE;
+	
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->hHeldCall = (HCALL) gdwInvalidHandles[n];
+        if(fEsp)
+     	  {
+        if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+        }
+        else
+		  {
+        if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hHeldCall = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hHeldCall", dwTestCase + 1
+            );
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+ 	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported it (can'r make two calls), return.");
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    return fTestPassed;
+    }
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else										
+    lpTapiLineTestInfo->lpszDestAddress  = "55555" ;
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	// Make second call at same line
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 	
+
+	if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+		 
+   // Close the Active line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported it, return.");
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   return fTestPassed;
+   }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  "55555";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	// Make second call at same line
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+	lpTapiLineTestInfo->lpCallStatus = (LPLINECALLSTATUS) AllocFromTestHeap (
+		sizeof(LINECALLSTATUS));
+	lpTapiLineTestInfo->lpCallStatus->dwTotalSize = sizeof(LINECALLSTATUS);
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Before: Active: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+	
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Before: Hold: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+	
+	if(fEsp)
+	{	
+	if (! DoLineSwapHold(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	// Verify the swap
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hActiveCall;
+
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: Active: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+   
+   if(lpTapiLineTestInfo->lpCallStatus->dwCallState == LINECALLSTATE_ONHOLD)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+ 	
+	
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+
+	if (! DoLineGetCallStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### After: Hold: lpCallStatus->dwCallState = %lx",
+		lpTapiLineTestInfo->lpCallStatus->dwCallState);
+ 	
+   if(lpTapiLineTestInfo->lpCallStatus->dwCallState == LINECALLSTATE_CONNECTED)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+ 	}
+	else
+	{	
+	if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+		
+
+		 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hActiveCall;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+	 lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+
+	 if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+        TLINE_FAIL();
+     }
+	
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineSwapHold(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hActiveCall;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+	 lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hHeldCall;
+	 
+	 if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSwapHold(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSwapHold: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSwapHold  <<<<<<<<"
+            );
+     return fTestPassed;
+} 
diff --git a/private/tapi/qa/trapper/itest/tcline/itlsuc.c b/private/tapi/qa/trapper/itest/tcline/itlsuc.c
new file mode 100644
index 000000000..45cbb4103
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/itlsuc.c
@@ -0,0 +1,1291 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsuc.c
+
+Abstract:
+
+    This module contains the test functions for lineSetupConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+#define NUMTOTALSIZES 7
+#define PAGESIZE      4096
+#define NUMPARTIES    8
+
+
+//  lineSetupConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetupConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+   HCALL hConfCall, hConsultCall;
+   DWORD dwFixedSize = sizeof(LINECALLPARAMS);
+   DWORD lExpected;
+   DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+									10,
+                           (DWORD) dwFixedSize - 1,
+ 									(DWORD) dwFixedSize,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetupConference  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+    }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+	
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;	
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphConfCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+//	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lphConfCall = (LPHCALL) gdwInvalidHandles[n];
+        if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lphConfCall == lphConsultCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   lpTapiLineTestInfo->lphConfCall = 
+        (LPHCALL) lpTapiLineTestInfo->lphConsultCall;
+   if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+      {
+         TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphConsultCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+//	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+	
+   for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lphConsultCall = (LPHCALL) gdwInvalidHandles[n];
+        if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallParams values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpCallParams = 
+            (LPLINECALLPARAMS) gdwInvalidPointers[n];
+        if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: verify hConsultCall can't be used", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+	 lpTapiLineTestInfo->dwCountryCode = 0;
+ 
+    if(! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+	 lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpCallParams->dwTotalSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+   lpTapiLineTestInfo->hCall1 = NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+       sizeof(LINECALLPARAMS));
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+                        dwTotalSizes[n];
+        if(IsESPLineDevice(lpTapiLineTestInfo))
+        {
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else if(dwTotalSizes[n] >= dwFixedSize && dwTotalSizes[n] < PAGESIZE)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        }
+        else
+        {
+        if(dwTotalSizes[n] < PAGESIZE)
+           lExpected = LINEERR_OPERATIONUNAVAIL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        }
+           
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineSetupConference(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+   lpTapiLineTestInfo->lpCallParams->dwTotalSize = dwFixedSize;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, hCall = NULL & valid hLine", dwTestCase + 1
+            );
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+	WaitForAllMessages();
+   }
+   else
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "hConfCall = %lx, hConsultCall = %lx",
+      *lpTapiLineTestInfo->lphConfCall,
+      *lpTapiLineTestInfo->lphConsultCall);
+
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: verify hConsultCall is valid", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+	 lpTapiLineTestInfo->dwCountryCode = 0;
+ 
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if(! DoLineDial(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    }
+    else
+    {
+    if(! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+	
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, hLine ignor when valid hCall", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+ 
+	if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hLine1 = 0;
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+	WaitForAllMessages();
+   }
+   else
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_CALLSTATE msg sent to part", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+   lpTapiLineTestInfo->hLine1 = 0;
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+	WaitForAllMessages();
+   }
+   else
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+
+    AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) *lpTapiLineTestInfo->lphConsultCall,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_DIALTONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) *lpTapiLineTestInfo->lphConfCall,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_ONHOLDPENDCONF,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+  
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_CALLSTATE msg sent to monitor", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hCall1 = 0x00000000;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+	WaitForAllMessages();
+   }
+   else
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+
+    AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) *lpTapiLineTestInfo->lphConsultCall,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_DIALTONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) *lpTapiLineTestInfo->lphConfCall,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_ONHOLDPENDCONF,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (2) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (2) * sizeof(HCALL) + 8;
+
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "dwCalls = %lx, dwOffset = %lx",
+      lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,
+      lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &hConfCall,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &hConsultCall,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset+ 4
+            );
+
+    TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "hConfCall = %lx, hConsultCall = %lx",
+      (HCALL)hConfCall, (HCALL)hConsultCall);
+ 
+   AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) hConsultCall,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_DIALTONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) hConfCall,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_ONHOLDPENDCONF,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+ 
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: hCall already conference member", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+   lpTapiLineTestInfo->hLine1 = 0;
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+ 
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+	WaitForAllMessages();
+   }
+   else
+   {
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+
+   hConfCall = *lpTapiLineTestInfo->lphConfCall;
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineAddToConference(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+   else 
+   {
+	if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, FALSE))
+       {
+           TLINE_FAIL();
+       }
+   }
+ 	
+   *lpTapiLineTestInfo->lphCall = hConfCall;
+   lpTapiLineTestInfo->hLine1 = 0;
+   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, FALSE))
+       {
+           TLINE_FAIL();
+       }
+	
+    if (! WaitForAllMessages())
+       {
+           TLINE_FAIL();
+       }
+		
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+	 FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if ( ! DoLineSetupConference(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+   lpTapiLineTestInfo->hConfCall1 = 0x00000000;
+   lpTapiLineTestInfo->hConsultCall1 = 0x00000000;
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetupConference(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetupConference: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetupConference  <<<<<<<<"
+            );
+ 
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/ittgli.c b/private/tapi/qa/trapper/itest/tcline/ittgli.c
new file mode 100644
index 000000000..ce6074a65
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/ittgli.c
@@ -0,0 +1,278 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittgli.c
+
+Abstract:
+
+    This module contains the test functions for tapiGetLocationInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/2/96	added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiGetLocationInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiGetLocationInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+   DWORD dwCountrySize, dwCitySize;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing tapiGetLocationInfo  <<<<<<<<"
+            );
+
+#ifdef WUNICODE
+   dwCountrySize = 16*sizeof(WCHAR);
+   dwCitySize = 16*sizeof(WCHAR);
+   lpTapiLineTestInfo->lpwszCountryCode = AllocFromTestHeap(dwCountrySize);
+   lpTapiLineTestInfo->lpwszCityCode = AllocFromTestHeap(dwCitySize);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszCountryCode pointers", dwTestCase + 1
+            );
+
+#else
+   dwCountrySize = 16;
+   dwCitySize = 16;
+   lpTapiLineTestInfo->lpszCountryCode = AllocFromTestHeap(dwCountrySize);
+   lpTapiLineTestInfo->lpszCityCode = AllocFromTestHeap(dwCitySize);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszCountryCode pointers", dwTestCase + 1
+            );
+
+#endif
+
+
+
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszCountryCode =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszCountryCode =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiGetLocationInfo(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+  TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszCityCode pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszCityCode pointers", dwTestCase + 1
+            );
+#endif
+
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszCityCode =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszCityCode =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiGetLocationInfo(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+   FreeTestHeap();
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszCountryCode = AllocFromTestHeap(dwCountrySize);
+   lpTapiLineTestInfo->lpwszCityCode = AllocFromTestHeap(dwCitySize);
+#else
+   lpTapiLineTestInfo->lpszCountryCode = AllocFromTestHeap(dwCountrySize);
+   lpTapiLineTestInfo->lpszCityCode = AllocFromTestHeap(dwCitySize);
+#endif
+
+	if (! DoTapiGetLocationInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+
+
+#ifdef WUNICODE
+	(lpTapiLineTestInfo->lpwszCountryCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCountryCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCountryCode = %ws, length = %lx",
+			lpTapiLineTestInfo->lpwszCountryCode,
+         wcslen(lpTapiLineTestInfo->lpwszCountryCode));		
+ 
+	(lpTapiLineTestInfo->lpwszCityCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCityCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCityCode = %ws, length = %lx",
+			lpTapiLineTestInfo->lpwszCityCode,
+         wcslen(lpTapiLineTestInfo->lpwszCityCode));
+#else
+	(lpTapiLineTestInfo->lpszCountryCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCountryCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCountryCode = %s, length = %lx",
+			lpTapiLineTestInfo->lpszCountryCode,
+         strlen(lpTapiLineTestInfo->lpszCountryCode));
+ 
+	(lpTapiLineTestInfo->lpszCityCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCityCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCityCode = %s, length = %lx",
+			lpTapiLineTestInfo->lpszCityCode,
+         strlen(lpTapiLineTestInfo->lpszCityCode));
+#endif
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify length of CountryCode", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+    if(wcslen(lpTapiLineTestInfo->lpwszCountryCode) == 1)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+#else
+    if(strlen(lpTapiLineTestInfo->lpszCountryCode) == 1)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify length of CityCode", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+    if(wcslen(lpTapiLineTestInfo->lpwszCityCode) == 3)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+#else
+    if(strlen(lpTapiLineTestInfo->lpszCityCode) == 3)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    FreeTestHeap();
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ tapiGetLocationInfo: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing tapiGetLocationInfo  <<<<<<<<"
+            );
+ 		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/ittrd.c b/private/tapi/qa/trapper/itest/tcline/ittrd.c
new file mode 100644
index 000000000..80150d1a3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/ittrd.c
@@ -0,0 +1,123 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrd.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestDrop
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiRequestDrop
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestDrop(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing tapiRequestDrop  <<<<<<<<"
+            );
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwnd handles", dwTestCase + 1);
+    
+ 
+   for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwnd = (HWND) gdwInvalidHandles[n];
+        if (! DoTapiRequestDrop(lpTapiLineTestInfo, TAPIERR_INVALWINDOWHANDLE))
+        {
+			fTestPassed = FALSE;
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: return REQUESTFAILED", dwTestCase + 1
+            );
+
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+
+	if (! DoTapiRequestDrop(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+       {
+			fTestPassed = FALSE;
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ tapiRequestDrop: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing tapiRequestDrop  <<<<<<<<"
+            );
+ 	
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/ittrmc.c b/private/tapi/qa/trapper/itest/tcline/ittrmc.c
new file mode 100644
index 000000000..07110d5b5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/ittrmc.c
@@ -0,0 +1,616 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrmc.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestMakeCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/2/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+#define NUMREQUEST   20
+
+//  tapiRequestMakeCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestMakeCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n,i;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing tapiRequestMakeCall  <<<<<<<<"
+            );
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: No make call recipient", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->dwMediaMode = 0;
+	lpTapiLineTestInfo->dwRequestMode =  LINEREQUESTMODE_MAKECALL;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"tcline.dll";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "tcline.dll";
+#endif
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+        sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwPriority = 0;
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+	
+	if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_NOREQUESTRECIPIENT))
+       {
+			fTestPassed = FALSE;
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+*/
+
+/*
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"btcline.dll";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "btcline.dll";
+#endif
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+        sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwPriority = 1;
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+*/
+	
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDestAddress pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDestAddress pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+
+    
+
+	for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDestAddress =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDestAddress =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_INVALDESTADDRESS))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwsztapiAppName pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpsztapiAppName pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+
+	
+    
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwsztapiAppName =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpsztapiAppName =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszCalledParty pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+   lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszCalledParty pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+   lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+
+   
+	 
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszCalledParty =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszCalledParty =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszComment pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszComment pointers", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+#endif
+
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszComment =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszComment =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpwszDestAddress, wcslen > TAPIMAXDEST", dwTestCase + 1
+            );
+
+
+	lpTapiLineTestInfo->lpwszDestAddress =
+       L"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmonpqrstuvwxyzabcdefg";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpszDestAddress, strlen > TAPIMAXDEST", dwTestCase + 1
+            );
+
+
+	lpTapiLineTestInfo->lpszDestAddress =
+       (LPSTR)"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmonpqrstuvwxyzabcdefg";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+
+  
+   if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_INVALDESTADDRESS))
+      {
+         TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, valid appname, party, comment", dwTestCase + 1
+            );
+
+/*
+   lpTapiLineTestInfo->dwMediaMode = 0;
+	lpTapiLineTestInfo->dwRequestMode =  LINEREQUESTMODE_MAKECALL;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"ctcline.dll";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "ctcline.dll";
+#endif
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+        sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwPriority = 1;
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+*/
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)L"tcline.dll";
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)L"Trapper.exe";
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)L"Tapi Api Interface Test";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)"tcline.dll";
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)"Trapper.exe";
+	lpTapiLineTestInfo->lpszComment = (LPSTR)"Tapi Api Interface Test";
+#endif
+	
+	if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, appname, party, comment are = null", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+	
+	if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	
+	 FreeTestHeap();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, wcslen > TAPIMAX", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR)L"55555";
+	lpTapiLineTestInfo->lpwsztapiAppName = 
+       L"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+   lpTapiLineTestInfo->lpwszCalledParty = 
+       L"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+   lpTapiLineTestInfo->lpwszComment = 
+       L"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmonpqrstuvwxyzabcdefg";
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, strlen > TAPIMAX", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = 
+       "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+   lpTapiLineTestInfo->lpszCalledParty = 
+       "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+   lpTapiLineTestInfo->lpszComment = 
+       "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmonpqrstuvwxyzabcdefg";
+#endif
+
+   if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+         TLINE_FAIL();
+      }
+
+
+    // Call lineGetRequest to verify tructed
+	 lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL));
+
+
+    for(i=0; i< 5; i++)
+    {
+    DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS);
+#ifdef WUNICODE
+    if(wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szAppName) ==
+		(TAPIMAXAPPNAMESIZE-1))
+      break;
+#else
+    if(strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szAppName) ==
+		(TAPIMAXAPPNAMESIZE-1))
+      break;
+#endif
+    }
+
+      fTestPassed = TRUE;
+
+
+#ifdef WUNICODE
+   TapiLogDetail(
+   DBUG_SHOW_DETAIL,
+   "length = %ld, wszAppName = %ws",
+   wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szAppName),
+   ((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szAppName); 
+
+   TapiLogDetail(
+   DBUG_SHOW_DETAIL,
+   "length = %ld, wszCalledParty = %ws",
+   wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szCalledParty),
+   ((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szCalledParty); 
+
+   TapiLogDetail(
+   DBUG_SHOW_DETAIL,
+   "length = %ld, wszComment = %ws",
+   wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szComment),
+   ((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szComment); 
+
+   if(wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szAppName) ==
+		(TAPIMAXAPPNAMESIZE - 1)  &&
+      wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szCalledParty) ==
+		(TAPIMAXCALLEDPARTYSIZE - 1) &&
+      wcslen(((LPLINEREQMAKECALLW)lpTapiLineTestInfo->lpRequestBuffer)->szComment) ==
+		(TAPIMAXCOMMENTSIZE - 1) )
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+#else
+   TapiLogDetail(
+   DBUG_SHOW_DETAIL,
+   "length = %ld, szAppName = %s",
+   strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szAppName),
+   ((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szAppName); 
+
+   TapiLogDetail(
+   DBUG_SHOW_DETAIL,
+   "length = %ld, szCalledParty = %s",
+   strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szCalledParty),
+   ((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szCalledParty); 
+
+   TapiLogDetail(
+   DBUG_SHOW_DETAIL,
+   "length = %ld, szComment = %s",
+   strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szComment),
+   ((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szComment); 
+
+   if(strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szAppName) ==
+		(TAPIMAXAPPNAMESIZE-1) &&
+      strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szCalledParty) ==
+		(TAPIMAXCALLEDPARTYSIZE-1) &&
+      strlen(((LPLINEREQMAKECALL)lpTapiLineTestInfo->lpRequestBuffer)->szComment) ==
+		(TAPIMAXCOMMENTSIZE-1) )
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+#endif
+	 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+	FreeTestHeap();
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Exhaust request queue, then clean it up", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)L"tcline.dll";
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)L"Trapper.exe";
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)L"Tapi Api Interface Test";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)"tcline.cll";
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)"Trapper.exe";
+	lpTapiLineTestInfo->lpszComment = (LPSTR)"Tapi Api Interface Test";
+#endif
+	
+   for(n=0; n < NUMREQUEST; n++)
+   {
+	if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+   }
+
+   for(n=0; n < NUMREQUEST; n++)
+   {
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+   }
+    if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOREQUEST))
+      {
+ 		TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+*/
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ linetapiRequestMakeCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing tapiRequestMakeCall  <<<<<<<<"
+            );
+ 		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/ittrmec.c b/private/tapi/qa/trapper/itest/tcline/ittrmec.c
new file mode 100644
index 000000000..72cfe2a01
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/ittrmec.c
@@ -0,0 +1,408 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrmec.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestMediaCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/2/96	added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "cline.h"
+
+
+
+//  tapiRequestMediaCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestMediaCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing tapiRequestMediaCall  <<<<<<<<"
+            );
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwnd handles", dwTestCase + 1);
+    
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+   lpTapiLineTestInfo->dwSize = 0;
+   lpTapiLineTestInfo->dwSecure = 0;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"line/tapi";
+   lpTapiLineTestInfo->lpwszDeviceID = NULL;
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+   lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+   lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "line/tapi";
+   lpTapiLineTestInfo->lpszDeviceID = NULL;
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+   lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+   lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+	
+	 
+   for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwnd = (HWND) gdwInvalidHandles[n];
+        if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALWINDOWHANDLE))
+        {
+			fTestPassed = FALSE;
+        }
+    }
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+            );
+#endif
+
+	for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDeviceClass = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDeviceClass = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALDEVICECLASS))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDeviceID pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDeviceID pointers", dwTestCase + 1
+            );
+#endif
+
+   lpTapiLineTestInfo->dwSize = 1;
+	for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDeviceID = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDeviceID = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALDEVICEID))
+        {
+            TLINE_FAIL();
+        }
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceID = NULL;
+#else
+    lpTapiLineTestInfo->lpszDeviceID = NULL;
+#endif
+    lpTapiLineTestInfo->dwSize = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDestAddress pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDestAddress pointers", dwTestCase + 1
+            );
+#endif
+
+	for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDestAddress =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDestAddress =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALDESTADDRESS))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwsztapiAppName pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpsztapiAppName pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+
+#endif
+
+	
+    
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwsztapiAppName =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpsztapiAppName =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+#else
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+    fTestPassed = ShowTestCase(fTestPassed);
+#endif
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszCalledParty pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszCalledParty pointers", dwTestCase + 1
+            );
+#endif
+
+   
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+      lpTapiLineTestInfo->lpwszCalledParty =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+      lpTapiLineTestInfo->lpszCalledParty =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+    if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+#else
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+#ifdef WUNICODE
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszComment pointers", dwTestCase + 1
+            );
+#else
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszComment pointers", dwTestCase + 1
+            );
+#endif
+
+    
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszComment =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszComment =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+      if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: return REQUESTFAILED", dwTestCase + 1
+            );
+
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+   lpTapiLineTestInfo->dwSize = 0;
+   lpTapiLineTestInfo->dwSecure = 0;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"line/tapi";
+   lpTapiLineTestInfo->lpwszDeviceID = NULL;
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+//	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)"xxx";
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "line/tapi";
+   lpTapiLineTestInfo->lpszDeviceID = NULL;
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+//	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)"xxx";
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+	
+	if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+       {
+			fTestPassed = FALSE;
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ tapiRequestMediaCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing tapiRequestMediaCall  <<<<<<<<"
+            );
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tcline/tcline.def b/private/tapi/qa/trapper/itest/tcline/tcline.def
new file mode 100644
index 000000000..5654240bb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/tcline.def
@@ -0,0 +1,25 @@
+LIBRARY         tcline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+
diff --git a/private/tapi/qa/trapper/itest/tcline/tcline.inc b/private/tapi/qa/trapper/itest/tcline/tcline.inc
new file mode 100644
index 000000000..a2f3b6922
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/tcline.inc
@@ -0,0 +1,73 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tcline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+DLLDEF=..\tcline.def
+DLLBASE=0x66000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	..\cline.c \
+		..\itlatc.c \
+		..\itlgcrc.c \
+		..\itlpatc.c  \
+		..\itlrfc.c  \
+		..\itlsuc.c \
+		..\itlcc.c	\
+		..\itlrd.c \
+		..\itlsc.c	\
+		..\itlsh.c	\
+		..\ittgli.c  \
+		..\ittrd.c  \
+		..\ittrmc.c  \
+		..\ittrmec.c \
+		..\uline.c \
+		..\cline.rc
+		
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_0=1 -DTAPI_1_1=1 -DTAPI_2_0=1 
+
+
+UMTYPE=windows
+
+DLLENTRY=TCLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tcline/tclinea/makefile b/private/tapi/qa/trapper/itest/tcline/tclinea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/tclinea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tcline/tclinea/sources b/private/tapi/qa/trapper/itest/tcline/tclinea/sources
new file mode 100644
index 000000000..01ffd1231
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/tclinea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tcline.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/tcline/tclinew/makefile b/private/tapi/qa/trapper/itest/tcline/tclinew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/tclinew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tcline/tclinew/sources b/private/tapi/qa/trapper/itest/tcline/tclinew/sources
new file mode 100644
index 000000000..b0116b4b9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/tclinew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tcline.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tcline/uline.c b/private/tapi/qa/trapper/itest/tcline/uline.c
new file mode 100644
index 000000000..905a3ebd7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tcline/uline.c
@@ -0,0 +1,188 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "cline.h"
+
+
+char szApiName[9][48] = 
+		{
+		"lineAddToConference",
+		"lineCompleteCall",
+		"lineGetConfRelatedCalls",
+		"linePrepareAddToConference",
+ 		"lineRedirect",
+  		"lineRemoveFromConference",
+		"lineSecureCall",
+		"lineSetupConference",
+		"lineSwapHold"
+	};		
+
+
+BOOL TestLineUninitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+	 lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+        sizeof(LINECALLLIST));
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  "55555";
+#endif
+
+     
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 9; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+          if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 1:       
+	      if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 2:       
+          if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+          if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+          if (! DoLineRemoveFromConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 6:       
+          if (! DoLineSecureCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 7:       
+          if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:     
+          if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/testapp/dirs b/private/tapi/qa/trapper/itest/testapp/dirs
new file mode 100644
index 000000000..d4880da75
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/dirs
@@ -0,0 +1,2 @@
+DIRS = testappa \
+       testappw
diff --git a/private/tapi/qa/trapper/itest/testapp/testapp.c b/private/tapi/qa/trapper/itest/testapp/testapp.c
new file mode 100644
index 000000000..3bfb8f674
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testapp.c
@@ -0,0 +1,365 @@
+
+/*
+ * testapp.c --
+ * Xiao Ying Ding
+ * 1/20/96
+ */
+
+#include <windows.h>
+#include <commdlg.h>
+#include <stdlib.h>
+#include <string.h>
+#include "tapi.h"
+#include "testapp.h"
+
+#define LOW_VERSION		0X10003
+#define	HIGH_VERSION	0X20000
+
+LONG APIENTRY	MainWndProc(HWND, UINT, UINT, LONG);
+int  APIENTRY	WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
+
+BOOL APIENTRY  MainWndMenuProc(HWND, UINT, UINT, LONG);
+void TAPPSendMessage(void);
+VOID TappConverRetVal(LONG, char *);
+BOOL DoLineInit(void);
+BOOL DoLineNegotiateAPIVersion(void);
+BOOL DoLineOpen(void);
+BOOL DoLineClose(void);
+BOOL DoLineShutdown(void);
+VOID WINAPI TapiCallback(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
+
+
+char *szMainWnd = "Tapi App";
+char *szTAPPAppClass = "TAPPAppsClass";
+char *szTappMenu = "TappMenu";
+
+HINSTANCE hInst;
+HWND	hwndMain, hwndEdit;
+HMENU hmenu;
+
+LONG  lRet  = 0L;
+char szDebugString[128];
+char szRetBuf[128];
+
+LPHLINEAPP		lphLineApp;
+HLINEAPP		hLineApp;
+HINSTANCE		hInstance;
+LINECALLBACK	lpfnCallBack;
+LPSTR 			szAppName;
+LPTSTR			lpszAppName;
+DWORD			dwNumDevs;
+LPDWORD			lpdwNumDevs;
+DWORD			dwDeviceID;
+DWORD			dwAPILowVersion;
+DWORD			dwAPIHighVersion;
+LPDWORD			lpdwAPIVersion;
+DWORD			dwAPIVersion;
+LPLINEEXTENSIONID	lpExtensionID;
+LINEEXTENSIONID		ExtensionID;
+LPHLINE			lphLine;
+HLINE			hLine;
+DWORD			dwExtVersion;
+DWORD			dwCallbackInstance;
+DWORD			dwPriviledge;
+DWORD			dwMediaModes;
+LPLINECALLPARAMS	lpCallParams;
+
+	
+
+int APIENTRY						// ret errorlevel 0 if successful, else 1
+WinMain(							// Windows entry point
+	HINSTANCE hInstance,			// instance handle
+	HINSTANCE hPrevInstance,	// previous instance if any
+	LPSTR lpszCmdLine,	// pointer to command line string
+	int cmdShow)				// ShowWindow parameter
+{
+	MSG msg;
+	WNDCLASS wc;
+	RECT rect;
+
+   if (!hPrevInstance)
+      {
+      wc.style = CS_VREDRAW | CS_HREDRAW ;
+      wc.lpfnWndProc = (WNDPROC)MainWndProc;
+      wc.cbClsExtra = 0;
+      wc.cbWndExtra = 0;
+      wc.hInstance = hInstance ; 
+      wc.hIcon =     LoadIcon((HANDLE)hInstance, NULL);
+ 		wc.hCursor =   LoadCursor((HANDLE)NULL, IDC_ARROW);
+      wc.hbrBackground = GetStockObject(WHITE_BRUSH);
+      wc.lpszMenuName = (LPSTR)szTappMenu;
+      wc.lpszClassName = (LPSTR)szTAPPAppClass ;
+
+		if(!RegisterClass(&wc))
+			return FALSE;
+      }
+
+
+	hInst = hInstance;
+
+	hwndMain = CreateWindow(
+		(LPCTSTR)szTAPPAppClass, 
+		(LPCTSTR)szMainWnd,	  
+		WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,
+//	   CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
+		100, 100, 200, 120,
+		(HWND)HWND_DESKTOP,
+		(HMENU)NULL,
+    	(HANDLE)hInstance,
+		(LPVOID)NULL);
+
+	if(!hwndMain)
+		{
+		return FALSE;
+		}
+
+	GetClientRect(hwndMain, &rect);
+
+	hwndEdit = CreateWindow(
+			"edit",											    
+			"",
+			WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL | ES_MULTILINE | ES_READONLY,
+			rect.left+10, rect.top+10, rect.right-20, rect.bottom-20,
+			(HWND)hwndMain,
+			(HMENU)NULL,
+			(HANDLE)hInstance,
+			(LPVOID)NULL);
+
+	if(!hwndEdit)
+		{
+		return FALSE;
+		}
+
+	ShowWindow(hwndMain, cmdShow);
+	UpdateWindow(hwndMain);
+
+	wsprintf((LPTSTR)szDebugString, "Tapi App Start.");
+//   SendMessage(hwndEdit, EM_SETSEL, (WPARAM)0, (LPARAM)-1);
+//	SendMessage(hwndEdit, EM_REPLACESEL, 0, (LPARAM) (LPCSTR)szDebugString);
+	SendMessage(hwndEdit, WM_SETTEXT, 0, (LPARAM) (LPCSTR)szDebugString);
+	DoLineInit();
+	DoLineNegotiateAPIVersion();
+	DoLineOpen();
+
+    while (GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0) )
+       {
+       TranslateMessage((LPMSG)&msg);
+       DispatchMessage((LPMSG)&msg);
+       }
+
+   return msg.wParam;
+}
+
+
+
+LONG APIENTRY MainWndProc(
+   HWND hwnd,        /* Window handle */ 
+   UINT message,     /* Message */ 
+   UINT wParam,    /* Varies */ 
+   LONG lParam)    /* Varies */ 
+{
+	lRet = 0L;
+
+   switch (message)
+      {
+
+		case WM_CREATE:
+			wsprintf((LPTSTR)szDebugString, "&Tapi App start. \r\n");
+			TAPPSendMessage();
+		//	DoLineInit();
+			break;
+
+		case WM_COMMAND:
+			wsprintf((LPTSTR)szDebugString, "# Tapi App start. \r\n");
+			TAPPSendMessage();
+
+	//		DoLineInit();
+			MainWndMenuProc(hwnd, message, wParam, lParam);
+			break;
+
+		case WM_SIZE:
+			{
+			int x, y, dx, dy;
+
+			x = XEditWnd(0);
+			y = YEditWnd(0);
+			dx = DxEditWnd(LOWORD(lParam));
+			dy = DyEditWnd(HIWORD(lParam));
+			MoveWindow(hwndEdit, x, y, dx, dy, TRUE);
+			break;
+			}
+   
+      case WM_KEYDOWN:
+         SendMessage(hwnd, WM_DESTROY, 0, 0);
+         break;
+  
+		case WM_DESTROY:
+			DoLineClose();
+			DoLineShutdown();
+			PostQuitMessage(0);
+			return 0;
+
+		default:
+   	   lRet = DefWindowProc(hwnd, message, wParam, lParam);
+			break;
+		}
+
+	return lRet;
+}
+
+BOOL APIENTRY CALLBACK MainWndMenuProc(HWND hwnd, UINT message, UINT wParam, LONG lParam)
+{
+
+	wsprintf((LPTSTR)szDebugString, "Tapi App start. \r\n");
+	TAPPSendMessage();
+	
+	hmenu = GetMenu(hwndMain);
+		
+	switch(wParam)
+		{
+		case TAPP_Init:
+//			DoLineInit();
+			break;
+
+		case TAPP_Exit:
+			DoLineClose();
+			DoLineShutdown();
+         DestroyWindow(hwndMain);
+			break;
+		}
+	return TRUE;
+}
+
+
+
+BOOL DoLineInit(void)
+{
+ 
+	lphLineApp = &hLineApp;
+//	hInstance = (HINSTANCE) NULL;
+	lpfnCallBack = (LINECALLBACK)TapiCallback;
+	szAppName = "tapi app";
+	lpdwNumDevs = &dwNumDevs;
+	lpszAppName = &szAppName[0];
+
+	hInstance = (HINSTANCE) GetModuleHandle("testapp.exe");
+
+	lRet = lineInitialize(lphLineApp, hInstance, lpfnCallBack, (LPCSTR)szAppName, lpdwNumDevs);
+	
+	TappConverRetVal(lRet, szRetBuf);
+
+	wsprintf((LPTSTR)szDebugString, "lineItialize: lRet = %lx\r\n", lRet);
+	TAPPSendMessage();
+
+
+	return TRUE;
+}
+
+
+BOOL DoLineNegotiateAPIVersion(void)
+{
+	dwDeviceID = 0;
+	dwAPILowVersion = LOW_VERSION;
+	dwAPIHighVersion = HIGH_VERSION;
+	lpdwAPIVersion = &dwAPIVersion;
+	lpExtensionID = &ExtensionID;
+
+	lRet = lineNegotiateAPIVersion(	hLineApp, 
+									dwDeviceID,	
+									dwAPILowVersion,
+									dwAPIHighVersion,
+									lpdwAPIVersion,
+									lpExtensionID
+									);
+	wsprintf((LPTSTR)szDebugString, "lineNegotiateAPIVersion: lRet = %lx\r\n", lRet);
+	TAPPSendMessage();
+
+	return TRUE;
+}
+
+
+BOOL DoLineOpen(void)
+{
+	lphLine = &hLine;
+	dwCallbackInstance = 0;
+	dwPriviledge = LINECALLPRIVILEGE_OWNER;
+	dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	lRet = lineOpen(hLineApp,
+					dwDeviceID,
+					lphLine,
+					dwAPIVersion,
+					dwExtVersion,
+					dwCallbackInstance,
+					dwPriviledge,
+					dwMediaModes,
+					lpCallParams
+					);
+
+	wsprintf((LPTSTR)szDebugString, "lineOpen: lRet = %lx\r\n", lRet);
+	TAPPSendMessage();
+
+	return TRUE;
+}
+
+
+
+BOOL DoLineClose(void)
+{
+	lRet = lineClose(*lphLine);
+
+	wsprintf((LPTSTR)szDebugString, "lineClose: lRet = %lx\r\n", lRet);
+	TAPPSendMessage();
+
+	return TRUE;
+}
+
+BOOL DoLineShutdown(void)
+{
+	lRet = lineShutdown(*lphLineApp);
+
+	wsprintf((LPTSTR)szDebugString, "lineShutdown: lRet = %lx\r\n", lRet);
+	TAPPSendMessage();
+
+	return TRUE;
+}
+
+
+void TAPPSendMessage(void)					 
+{
+//  SendMessage(hwndEdit, EM_SETSEL, (WPARAM)-1, (LPARAM)0);
+//SendMessage(hwndEdit, EM_REPLACESEL, 0, (LPARAM) (LPCTSTR) szDebugString);
+
+SendMessage(hwndEdit, WM_SETTEXT, 0, (LPARAM) (LPCSTR)szDebugString);
+}
+
+
+VOID TappConverRetVal(LONG lret, char *szRetBuf)
+{
+
+	switch(lret)
+	{
+	case LINEERR_INVALAPPNAME:
+		strcpy((LPTSTR)szRetBuf, "LINEERR_INVALAPPNAME");
+		break;
+
+	case LINEERR_INIFILECORRUPT:
+		strcpy((LPTSTR)szRetBuf, "LINEERR_INIFILECORRUPT");
+		break;
+
+	}
+}
+
+VOID
+WINAPI
+TapiCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    )
+{
+}
diff --git a/private/tapi/qa/trapper/itest/testapp/testapp.def b/private/tapi/qa/trapper/itest/testapp/testapp.def
new file mode 100644
index 000000000..38365c096
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testapp.def
@@ -0,0 +1,25 @@
+NAME		TESTAPP
+
+DESCRIPTION	'Microsoft Multi Network Provider Test Tool: Version 1.0'
+EXETYPE		WINDOWS
+PROTMODE
+STUB		'WINSTUB.EXE'
+
+CODE 		MOVEABLE DISCARDABLE LOADONCALL PURE
+DATA 		PRELOAD MOVEABLE MULTIPLE
+
+HEAPSIZE	3072
+STACKSIZE	8096
+
+SEGMENTS
+	_TEXT	PRELOAD
+
+EXPORTS
+	MainWndProc		 @1
+	MainWndMenuProc		 @2
+IMPORTS
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/testapp/testapp.h b/private/tapi/qa/trapper/itest/testapp/testapp.h
new file mode 100644
index 000000000..fa6b9a161
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testapp.h
@@ -0,0 +1,16 @@
+/*
+ * testapp.h
+ * Xiao Ying Ding
+ * 1/20/96
+ */
+
+
+#define TAPP_Init		11
+#define TAPP_Exit		12
+
+#define menuMPRT     1
+
+#define XEditWnd(dxParent) (dxParent+10)
+#define YEditWnd(dyParent) (dyParent+10)
+#define DxEditWnd(dxParent) (dxParent-20)
+#define DyEditWnd(dyParent) (dyParent-20)
diff --git a/private/tapi/qa/trapper/itest/testapp/testapp.inc b/private/tapi/qa/trapper/itest/testapp/testapp.inc
new file mode 100644
index 000000000..9c30f61b5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testapp.inc
@@ -0,0 +1,56 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=testapp
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=PROGRAM
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=        ..\testapp.c \
+		..\testapp.rc
+
+#C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1 
+
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/testapp/testapp.rc b/private/tapi/qa/trapper/itest/testapp/testapp.rc
new file mode 100644
index 000000000..557642fff
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testapp.rc
@@ -0,0 +1,24 @@
+/*
+ * testapp.rc
+ * Xiao Ying Ding
+ * 1/20/96
+ */
+
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI XLine API test Library"
+#define VER_INTERNALNAME_STR        "xline.dll"
+#define VER_ORIGINALFILENAME_STR    "xline.dll"
+
+#include "common.ver"
+#include "testapp.h"
+  
+TappMenu MENU
+BEGIN
+	MENUITEM "&lineInitialize",  TAPP_Init, CHECKED
+	MENUITEM "&Exit",     	    TAPP_Exit
+END
+	
diff --git a/private/tapi/qa/trapper/itest/testapp/testappa/makefile b/private/tapi/qa/trapper/itest/testapp/testappa/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testappa/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/testapp/testappa/sources b/private/tapi/qa/trapper/itest/testapp/testappa/sources
new file mode 100644
index 000000000..f9f0c178e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testappa/sources
@@ -0,0 +1,45 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+    Add the following line under the "SOURCES" section if build for the
+    TAPI-lite on Daytona (may want to chg TARGETNAME too):
+
+        C_DEFINES=-DDAYTONA
+
+Revision History:
+
+!ENDIF
+
+!include ..\testapp.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/testapp/testappw/makefile b/private/tapi/qa/trapper/itest/testapp/testappw/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testappw/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/testapp/testappw/sources b/private/tapi/qa/trapper/itest/testapp/testappw/sources
new file mode 100644
index 000000000..58f8a66d4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/testapp/testappw/sources
@@ -0,0 +1,43 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+    Add the following line under the "SOURCES" section if build for the
+    TAPI-lite on Daytona (may want to chg TARGETNAME too):
+
+        C_DEFINES=-DDAYTONA
+
+Revision History:
+
+!ENDIF
+
+!include ..\testapp.inc
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tiline/dirs b/private/tapi/qa/trapper/itest/tiline/dirs
new file mode 100644
index 000000000..3c3f47c72
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/dirs
@@ -0,0 +1,2 @@
+DIRS= ilinea\
+      ilinew
diff --git a/private/tapi/qa/trapper/itest/tiline/iline.c b/private/tapi/qa/trapper/itest/tiline/iline.c
new file mode 100644
index 000000000..e861e347c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/iline.c
@@ -0,0 +1,362 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    iline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "iline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTILineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TILineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTILineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninitialize(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAccept(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAnswer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineBlindTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineForward(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineForward1(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineForward2(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineReleaseUserUserInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSendUserUserInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetupTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineCompleteTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineNegotiateExtVersion(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineHold(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUnhold(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAppSpecific(TRUE, FALSE));
+}
+
+
+
+
+/*
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTest(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTestX(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test16(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTestY(TRUE, FALSE));
+}
+
+*/
diff --git a/private/tapi/qa/trapper/itest/tiline/iline.h b/private/tapi/qa/trapper/itest/tiline/iline.h
new file mode 100644
index 000000000..932f3929f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/iline.h
@@ -0,0 +1,218 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    iline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef ILINE_H
+#define ILINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineAccept(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineAnswer(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineBlindTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineForward(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineForward1(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineForward2(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineReleaseUserUserInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSendUserUserInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetupTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineCompleteTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineNegotiateExtVersion(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineHold(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineUnhold(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineSetAppSpecific(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineUninitialize(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+/*
+BOOL
+TestLineTest(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineTestX(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineTestY(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+*/
+
+
+
+
+#endif  // ILINE_H
diff --git a/private/tapi/qa/trapper/itest/tiline/ilinea/makefile b/private/tapi/qa/trapper/itest/tiline/ilinea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/ilinea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tiline/ilinea/sources b/private/tapi/qa/trapper/itest/tiline/ilinea/sources
new file mode 100644
index 000000000..8e7586a6e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/ilinea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tiline.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/tiline/ilinew/makefile b/private/tapi/qa/trapper/itest/tiline/ilinew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/ilinew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tiline/ilinew/sources b/private/tapi/qa/trapper/itest/tiline/ilinew/sources
new file mode 100644
index 000000000..70e3f5e5a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/ilinew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tiline.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tiline/itlac.c b/private/tapi/qa/trapper/itest/tiline/itlac.c
new file mode 100644
index 000000000..fc1530a60
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlac.c
@@ -0,0 +1,1653 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlac.c	 -   lineAccept
+
+Abstract:
+
+    This module contains the test functions for lineAccept
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineAccept
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized
+//     2)  hCall without owner privilege
+//     3)  Invalid hCalls (test array of gdwInvalidHandles)
+//     4)  Invalid lpsUserUserInfo pointers (test array of gdwInvalidPointers)
+//     5)  Bad dwSize
+//
+
+
+BOOL TestLineAccept(BOOL fQuietMode, BOOL fStandAlone)
+{
+
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed    = TRUE;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    LONG lret;
+    LPTAPIMSG lpMsg;
+    DWORD dwFixedSize = BIGBUFSIZE;
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n************************************************************");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  Begin testing lineAccept  <<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:lineAccept for go/no-go",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineAccept(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+    if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+    {
+        TapiLogDetail (
+            DBUG_SHOW_DETAIL,
+            "#### lpUserUserInfo = %s",
+            ((LPBYTE)lpTapiLineTestInfo->lpCallInfo) +
+            lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+    }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: No owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif				
+
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    lpMsg = AddMessage (LINE_CALLSTATE,
+                        LINECALLSTATE_OFFERING,
+                        0,
+                        0,
+                        0,
+                        0,
+                        TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineAccept(lpTapiLineTestInfo, LINEERR_NOTOWNER, FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hCall",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        //
+        // save previous handles
+        //
+
+        lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+        for(i=0; i < NUMINVALIDHANDLES; i++)
+        {
+            *lpTapiLineTestInfo->lphCall = (HCALL)gdwInvalidHandles[i];
+            if (! DoLineAccept(lpTapiLineTestInfo,
+                               LINEERR_INVALCALLHANDLE,
+                               FALSE))
+            {
+                TLINE_FAIL();
+            }
+        }
+
+        //
+        // restore original handle
+        //
+
+        lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpUserInfo.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpUserInfo",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        for(i=0; i < NUMINVALIDPOINTERS; i++)
+        {
+            lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR)gdwInvalidPointers[i];
+            if(i == 0)
+            {
+                //
+                // this is a valid case
+                //
+                if (! DoLineAccept(lpTapiLineTestInfo,
+                                   TAPISUCCESS,
+                                   TRUE))
+                {
+                    TLINE_FAIL();
+                }
+
+            }
+            else
+            {
+                if (! DoLineAccept(lpTapiLineTestInfo,
+                                   LINEERR_INVALPOINTER,
+                                   FALSE))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwSize",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    for (i = 0; i < NUMTOTALSIZES; i++)
+        {
+        lpTapiLineTestInfo->dwSize =
+                        dwTotalSizes[i];
+	     if(dwTotalSizes[i] < dwFixedSize)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[i]);
+        if (! DoLineAccept(lpTapiLineTestInfo, lExpected, FALSE))
+           {
+              TLINE_FAIL();
+           }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+   
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    //  Test Case: Success for lpsUserUserInfo = NULL
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAccept
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Success, lpsUserUserInfo = NULL",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineAccept(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+    if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+    {
+        TapiLogDetail (
+            DBUG_SHOW_DETAIL,
+            "#### lpUserUserInfo = %s",
+            ((LPBYTE)lpTapiLineTestInfo->lpCallInfo) +
+            lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+    }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAccept did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+//    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    {
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMsg = AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+	 lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+	
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+ 
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    if ( ! DoLineAccept(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineAccept(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineAccept: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineAccept  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlas.c b/private/tapi/qa/trapper/itest/tiline/itlas.c
new file mode 100644
index 000000000..00149d011
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlas.c
@@ -0,0 +1,1620 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlas.c
+
+Abstract:
+
+    This module contains the test functions for lineAnswer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineAnswer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. No owner privilege for hCall
+// 3. Bad hCall
+// 4. Bad lpUserInfo
+// 5. Bad dwSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAnswer(BOOL fQuietMode, BOOL fStandAlone)
+{
+
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    DWORD dwFixedSize = BIGBUFSIZE;
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 	
+ 	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n****************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineAnswer");
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAnswer did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+	TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAnswer
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:lineAnswer for go/no-go",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineAnswer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+    if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+    {
+        TapiLogDetail (
+            DBUG_SHOW_DETAIL,
+            "#### lpUserUserInfo = %s",
+            ((LPBYTE)lpTapiLineTestInfo->lpCallInfo) +
+            lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+    }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: No owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAnswer did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAnswer
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineAnswer(lpTapiLineTestInfo, LINEERR_NOTOWNER, FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAnswer did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAnswer
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hCall",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        //
+        // save previous handles
+        //
+
+        lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+        for(i=0; i < NUMINVALIDHANDLES; i++)
+        {
+            *lpTapiLineTestInfo->lphCall = (HCALL)gdwInvalidHandles[i];
+            if (! DoLineAnswer(lpTapiLineTestInfo,
+                               LINEERR_INVALCALLHANDLE,
+                               FALSE))
+            {
+                TLINE_FAIL();
+            }
+        }
+
+        //
+        // restore original handle
+        //
+
+        lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpUserInfo.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAnswer did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAnswer
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpUserInfo",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        for(i=0; i < NUMINVALIDPOINTERS; i++)
+        {
+            lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR)gdwInvalidPointers[i];
+            if(i == 0)
+            {
+                //
+                // this is a valid case
+                //
+                if (! DoLineAnswer(lpTapiLineTestInfo,
+                                   TAPISUCCESS,
+                                   TRUE))
+                {
+                    TLINE_FAIL();
+                }
+
+            }
+            else
+            {
+                if (! DoLineAnswer(lpTapiLineTestInfo,
+                                   LINEERR_INVALPOINTER,
+                                   FALSE))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAnswer did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+//	lret = FindReceivedMsgs(lppTapiMsg, lpMatch, TRUE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAnswer
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwSize",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) "This is a test";
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    for (i = 0; i < NUMTOTALSIZES; i++)
+        {
+        lpTapiLineTestInfo->dwSize =
+                        dwTotalSizes[i];
+	     if(dwTotalSizes[i] < dwFixedSize)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[i]);
+        if (! DoLineAnswer(lpTapiLineTestInfo, lExpected, FALSE))
+           {
+              TLINE_FAIL();
+           }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // Test Case: Success, lpsUserUserInfo = NULL
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "lineAnswer did not work for Unimodem.  Please manualy test it");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Open a line
+    //
+
+//  lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+	TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+
+    lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+									
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    //
+    // Get hDevCall from LINECALL_STATUS msg to pass to lineAnswer
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Success, lpsUserUserInfo = NULL",
+        dwTestCase+1);
+
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+		
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineAnswer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+	
+    if(lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize)
+    {
+        TapiLogDetail (
+            DBUG_SHOW_DETAIL,
+            "#### lpUserUserInfo = %s",
+            ((LPBYTE)lpTapiLineTestInfo->lpCallInfo) +
+            lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+    }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+
+ 
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+//    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    AddMessage (LINE_CALLSTATE, LINECALLSTATE_OFFERING, 0, 0, 0, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM1);
+	 lret = WaitForAllMessages();
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "hCall = %lx", *lpTapiLineTestInfo->lphCall);
+	
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_CALLSTATE;
+    lpMatch->dwParam1 = LINECALLSTATE_OFFERING;
+    lpMatch->dwFlags = TAPIMSG_DWMSG | TAPIMSG_DWPARAM1;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    if(lret == 1)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)(lpTapiMsg->hDevCall);
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "lret = %lx, New hCall = %lx",
+        lret,
+        *lpTapiLineTestInfo->lphCall);
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineAnswer(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTapiMsgList(&lpTapiMsg);
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+
+    _itow(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpwszDestAddress,
+          10*2);
+
+#else
+    lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+
+    _itoa(lpTapiLineTestInfo->dwDeviceID,
+          lpTapiLineTestInfo->lpszDestAddress,
+          10);
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineAnswer(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineAnswer: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineAnswer  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlbt.c b/private/tapi/qa/trapper/itest/tiline/itlbt.c
new file mode 100644
index 000000000..0c2d82a1f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlbt.c
@@ -0,0 +1,856 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlbt.c
+
+Abstract:
+
+    This module contains the test functions for lineBlindTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineBlindTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. No owner privilege for hCall
+// 3. Bad hCall
+// 4. Bad lpszDestAddress
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineBlindTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n************************************************************");
+
+    OutputTAPIDebugInfo(
+		DBUG_SHOW_PASS,
+		">> Test lineBlindTransfer");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:lineBlindTransfer for go/no-go",
+        dwTestCase+1);
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineBlindTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineBlindTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: No owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+    if (! DoLineBlindTransfer(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+      {
+        TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hCall",
+        dwTestCase+1);
+
+    //
+    // save original hCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+       *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[i];
+
+       if (! DoLineBlindTransfer(lpTapiLineTestInfo,
+                                 LINEERR_INVALCALLHANDLE,
+                                 FALSE))
+         {
+           TLINE_FAIL();
+         }
+    }
+
+    //
+    // restore original hCall
+    //
+
+    lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpszDestAddress.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpszDestAddress",
+        dwTestCase+1);
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) gdwInvalidPointers[i];
+#else
+        lpTapiLineTestInfo->lpszDestAddress = (LPSTR) gdwInvalidPointers[i];
+#endif
+        if (! DoLineBlindTransfer(lpTapiLineTestInfo,
+                                  LINEERR_INVALPOINTER,
+                                  FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineBlindTransfer(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCOUNTRYCODE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineBlindTransfer(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+ 
+   //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineBlindTransfer: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineBlindTransfer  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlct.c b/private/tapi/qa/trapper/itest/tiline/itlct.c
new file mode 100644
index 000000000..6538be619
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlct.c
@@ -0,0 +1,1748 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlct.c
+
+Abstract:
+
+    This module contains the test functions for lineCompleteTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineCompleteTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. No owner privilege for hCall
+// 3. Bad hCall
+// 4. Bad lpdwCompletionID
+// 5. BitVectorParamErrorTest for completion mode
+// 6. Verify LINECALLSTATE_CONFERENCED message sent to monitors when
+//    successful transfer completion occurs that is resolved as a
+//    3-way conference.
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineCompleteTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS lpCallbackParams=NULL;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    BOOL fEspFlag, fUnimdmFlag;
+    LONG lExpected;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineCompleteTransfer");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineCompleteTransfer for go/no-go",
+        dwTestCase+1);
+
+    //lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+    if(fEspFlag)
+    {
+        if (! DoLineCompleteTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: No owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+    if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_NOTOWNER, FALSE))
+      {
+        TLINE_FAIL();
+      }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hCall",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+    //
+    // save original hCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[i];
+        if (! DoLineCompleteTransfer(lpTapiLineTestInfo,
+                                     LINEERR_INVALCALLHANDLE,
+                                     FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    //
+    // restore original hCall
+    //
+
+    lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad hConsultCall
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hConsultCall",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+    //
+    // save original hConsultCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hConsultCall1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphConsultCall = (HCALL) gdwInvalidHandles[i];
+        if(fEspFlag)
+        {
+            if (! DoLineCompleteTransfer(lpTapiLineTestInfo,
+                                         LINEERR_INVALCONSULTCALLHANDLE,
+                                         FALSE))
+            {
+                TLINE_FAIL();
+            }
+        }
+        else if(fUnimdmFlag)
+        {
+            if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+
+    //
+    // restore original hConsultCall
+    //
+
+    lpTapiLineTestInfo->hConsultCall1 = lpTapiLineTestInfo->hCall_Orig;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lphConfCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lphConfCall",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_CONFERENCE;
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lphConfCall = (LPHCALL)gdwInvalidPointers[i];
+
+        if (! DoLineCompleteTransfer(lpTapiLineTestInfo,
+                                     LINEERR_INVALPOINTER,
+                                     FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: BitVectorParamErrorTest for dwTransferModes.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: BitVectorParamErrorTest for dwTransferMode",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = 0;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+      lExpected = LINEERR_INVALTRANSFERMODE;
+    else
+      lExpected = LINEERR_OPERATIONUNAVAIL;
+
+    if(! TestInvalidBitFlagsAsy(
+                   lpTapiLineTestInfo,
+                   DoLineCompleteTransfer,
+                   (LPDWORD) &lpTapiLineTestInfo->dwTransferMode,
+                   lExpected,
+                   FIELDTYPE_NA,
+                   FIELDTYPE_MUTEX,
+                   FIELDSIZE_32,
+                   (LINETRANSFERMODE_TRANSFER|LINETRANSFERMODE_CONFERENCE),
+                   ~dwBitVectorMasks[(int) FIELDSIZE_32],
+                   0x00000000,
+                   0x00000000,
+                   TRUE
+                   ))
+      {
+        TLINE_FAIL();
+      }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: BitVectorParamValidTest for dwTransferMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: BitVectorParamValidTest for dwTransferMode.",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+    if(fEspFlag)
+    {
+        if(! TestValidBitFlagsAsy(
+                lpTapiLineTestInfo,
+                DoLineCompleteTransfer,
+                (LPDWORD) &lpTapiLineTestInfo->dwTransferMode,
+                FIELDTYPE_MUTEX,
+                FIELDTYPE_MUTEX,
+                FIELDSIZE_32,
+                (LINETRANSFERMODE_TRANSFER|LINETRANSFERMODE_CONFERENCE),
+                ~dwBitVectorMasks[(int) FIELDSIZE_32],
+                0x00000000,
+                0x00000000,
+                FALSE
+                ))
+        {
+            TLINE_FAIL();
+        }
+    }
+    /*
+    else if(fUnimdmFlag)
+    {
+        if(! TestValidBitFlagsAsy(
+                lpTapiLineTestInfo,
+                DoLineCompleteTransfer,
+                (LPDWORD) &lpTapiLineTestInfo->dwTransferMode,
+                FIELDTYPE_MUTEX,
+                FIELDTYPE_MUTEX,
+                FIELDSIZE_32,
+                (LINETRANSFERMODE_TRANSFER|LINETRANSFERMODE_CONFERENCE),
+                ~dwBitVectorMasks[(int) FIELDSIZE_32],
+                0x00000000,
+                0x00000000,
+                FALSE
+                ))
+        {
+            TLINE_FAIL();
+        }
+    }	*/
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case:  Bad lphConfCall succeeds for LINETRANSFERMODE_TRANSFER.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lphConfCall succeeds for LINETRANSFERMODE_TRANSFER",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lphConfCall = (LPHCALL)gdwInvalidPointers[i];
+
+        if(fEspFlag)
+        {
+            if (! DoLineCompleteTransfer(lpTapiLineTestInfo,
+                                         TAPISUCCESS,
+                                         TRUE))
+            {
+                TLINE_FAIL();
+            }
+        }
+        else if(fUnimdmFlag)
+        {
+            if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: Verify LINECALLSTATE_CONFEREnCED msg is sent
+    //               after transfering call in CONFERENCED mode
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = TRUE;
+        fUnimdmFlag = FALSE;
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = TRUE;
+    }
+    else
+    {
+        fEspFlag = FALSE;
+        fUnimdmFlag = FALSE;
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif				
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(fEspFlag)
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify LINECALLSTATE_CONFERENCED message"
+        " is sent after completing transfer of a 3-way transfer",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_CONFERENCE;
+    
+    //
+    // Add the LINECALLSTATE_CONFERENCED message to the list of expected
+    // messages.
+    //
+
+    AddMessage(
+               LINE_CALLSTATE,
+               (DWORD) lpTapiLineTestInfo->hLine1,
+               (DWORD) lpCallbackParams,
+               LINECALLSTATE_CONFERENCED,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1)
+              );
+   
+
+    if (! DoLineCompleteTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        fTestPassed = FALSE;
+
+    }
+    }
+    else if(fUnimdmFlag)
+    {
+        if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+    if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+ 
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineCompleteTransfer(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+    if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+ 
+    lpTapiLineTestInfo->dwTransferMode = LINETRANSFERMODE_TRANSFER;
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineCompleteTransfer(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineCompleteTransfer: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineCompleteTransfer  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlfw.c b/private/tapi/qa/trapper/itest/tiline/itlfw.c
new file mode 100644
index 000000000..cd06548e0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlfw.c
@@ -0,0 +1,13814 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlfw.c
+
+Abstract:
+
+    This module contains the test functions for lineForward
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineForward
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad lpForwardList
+// 4. Bad lphConsultCall
+// 5. Bad lpCallParams
+// 6. Bad lpCallParams->dwTotalSize
+// 7. Bad lpForwardList->dwTotalSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineForward(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams = NULL;
+    DWORD dwAllocSize, dwTotalSize, dwSize1;
+    DWORD dwForwardListFixedSize = sizeof(LINEFORWARDLIST);
+    DWORD lExpected;
+    DWORD dwForwardListTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwForwardListFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+    DWORD dwCallParamFixedSize = sizeof(LINECALLPARAMS);
+    DWORD dwCallParamTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwCallParamFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+      
+
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n****************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineForward");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:lineForward for go/no-go",
+        dwTestCase+1);
+
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // restore the original line
+    //
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    //
+    // Add the message LINE_APPNEWCALL for which we are waiting for.
+    // This Go/No-go test also takes care of another test case in which we
+    // have to verify if LINE_APPNEWCALL msg is sent a consultation
+    // call is created on lineForward.
+    //
+
+    AddMessage(
+               LINE_APPNEWCALL,
+               (DWORD) lpTapiLineTestInfo->hLine2,
+               (DWORD) lpCallbackParams,
+               0x00000000,
+               0x00000000,
+               LINECALLPRIVILEGE_MONITOR,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_HDEVCALL|
+                TAPIMSG_DWPARAM3)
+              );
+
+   if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+
+	
+    lpTapiLineTestInfo->lpLineAddressStatus = (LPLINEADDRESSSTATUS) AllocFromTestHeap (
+			sizeof(LINEADDRESSSTATUS));
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = sizeof(LINEADDRESSSTATUS);
+
+    if (! DoLineGetAddressStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+	if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        fTestPassed = FALSE;
+
+    }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    /*
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode =
+        LINEFORWARDMODE_UNCOND;
+    */
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hLine",
+        dwTestCase+1);
+    //
+    // save original hline
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_INVALLINEHANDLE,
+                            FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    //
+    // restore original hline
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpForwardList.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    /*
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode =
+        LINEFORWARDMODE_UNCOND;
+    */
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpForwardList",
+        dwTestCase+1);
+
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST)gdwInvalidPointers[i];
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_INVALPOINTER,
+                            FALSE))
+         {
+            TLINE_FAIL();
+         }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lphConsultCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    /*
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode =
+        LINEFORWARDMODE_UNCOND;
+    */
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lphConsultCall",
+        dwTestCase+1);
+
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lphConsultCall = (LPHCALL)gdwInvalidPointers[i];
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_INVALPOINTER,
+                            FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: hConsultCall Can't be used",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpCallParams.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    /*
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode =
+        LINEFORWARDMODE_UNCOND;
+    */
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams",
+        dwTestCase+1);
+
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS)gdwInvalidPointers[i];
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_INVALPOINTER,
+                            FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpCallParams->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    /*
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode =
+        LINEFORWARDMODE_UNCOND;
+    */
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+        sizeof(LINECALLPARAMS));
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams->dwTotalSize",
+        dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = 0;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_STRUCTURETOOSMALL,
+                            FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams->dwTotalSize=fixedSize-1 ",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS)-1;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_STRUCTURETOOSMALL,
+                            FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams->dwTotalSize=realBig ",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = 0x7FFFFFFF;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_INVALPOINTER,
+                            FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+*/
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+                        dwCallParamTotalSizes[n];
+	     if(dwCallParamTotalSizes[n] < dwCallParamFixedSize)
+          {
+           if(IsESPLineDevice(lpTapiLineTestInfo))
+              lExpected = LINEERR_STRUCTURETOOSMALL;
+           else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+              lExpected = LINEERR_OPERATIONUNAVAIL;
+          }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwCallParamTotalSizes[n]);
+        if (! DoLineForward(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = dwCallParamFixedSize;
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad lpForwardList->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    /*
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode =
+        LINEFORWARDMODE_UNCOND;
+    */
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpForwardList->dwTotalSize",
+        dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = 0;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_STRUCTURETOOSMALL,
+                            FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpForwardList->dwTotalSize=fixedSize-1 ",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST)-1;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_STRUCTURETOOSMALL,
+                            FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpForwardList->dwTotalSize=realBig ",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = 0x7FFFFFFF;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            LINEERR_INVALPOINTER,
+                            FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+  */
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpForwardList->dwTotalSize = 
+                        dwForwardListTotalSizes[n];
+	     if(dwForwardListTotalSizes[n] < dwForwardListFixedSize)
+          {
+           if(IsESPLineDevice(lpTapiLineTestInfo))
+              lExpected = LINEERR_STRUCTURETOOSMALL;
+           else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+              lExpected = LINEERR_OPERATIONUNAVAIL;
+          }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwForwardListTotalSizes[n]);
+        if (! DoLineForward(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = dwForwardListFixedSize;
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: NULL lpForwardList.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpTapiLineTestInfo->hLine = %lx, dwMediaModes = %lx",
+        *lpTapiLineTestInfo->lphLine,
+        lpTapiLineTestInfo->dwMediaModes);
+
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+   
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Null lpForwardList",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpForwardList = NULL;
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo,
+                            TAPISUCCESS,
+                            TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Success, verify LINECALLSTATE_UNKNOWN msg send",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // restore the original line
+    //
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+				
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    AddMessage(
+               LINE_CALLSTATE,
+               (DWORD) lpTapiLineTestInfo->hConsultCall1,
+               (DWORD) lpCallbackParams,
+               LINECALLSTATE_CONNECTED,
+               0x00000000,
+               0X00000000,
+               TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+              );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+	
+    lpTapiLineTestInfo->lpLineAddressStatus = (LPLINEADDRESSSTATUS) AllocFromTestHeap (
+			sizeof(LINEADDRESSSTATUS));
+    lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = sizeof(LINEADDRESSSTATUS);
+
+    if (! DoLineGetAddressStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+	if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        fTestPassed = FALSE;
+
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Success, verify returned hConsultCall valid",
+        dwTestCase+1);
+
+    
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConsultCall1;
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    if (! DoLineDial(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Success, Cancel forwarding",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "hConsultCall = %lx",
+       *lpTapiLineTestInfo->lphConsultCall);
+
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) NULL;
+//    lpTapiLineTestInfo->lpForwardList->dwTotalSize = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+    if(*lpTapiLineTestInfo->lphConsultCall == NULL)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;   
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test ForwardList[0] Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "dwAllocSize = %lx, dwTotalSize = %lx, dwSize1 = %lx", 
+         dwAllocSize,
+         dwTotalSize,
+         dwSize1);
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressSize = %lx, [0].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize);
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressSize = %lx, [1].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize = -1",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 0XFFFFFFFF;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 0XFFFFFFFF;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressSize = %lx, [0].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize);
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressSize = %lx, [1].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Test Offset value, < dwTotalSize ",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwSize1 + 4;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwSize1 + 16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+ 
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Test Offset value, > dwAllocSize ",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwAllocSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwAllocSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+ 
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Test Offset value, 0xffffffff",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = 0xffffffff;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = 0xffffffff;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+ 
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test ForwardList[1] Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressSize = %lx, [0].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize);
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressSize = %lx, [1].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize = -1",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 0XFFFFFFFF;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwTotalSize + 3*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 0XFFFFFFFF;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwTotalSize + 4*16;  
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressSize = %lx, [0].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize);
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressSize = %lx, [1].dwDestSize = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Test Offset value, < dwTotalSize ",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwSize1 + 4;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwSize1 + 16;  
+
+ 
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Test Offset value, > dwAllocSize ",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;   
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = dwAllocSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  dwAllocSize + 2*16;  
+
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Test Offset value, 0xffffffff",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 2;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    dwAllocSize = lpTapiLineTestInfo->lpForwardList->dwTotalSize;
+    dwTotalSize = sizeof(LINEFORWARDLIST) + sizeof(LINEFORWARD);
+    dwSize1 = sizeof(LINEFORWARDLIST);
+
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset = dwTotalSize + 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset = dwTotalSize + 2*16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwForwardMode = LINEFORWARDMODE_UNCOND;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset = 0xffffffff;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestCountryCode = 0;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressSize = 16;
+    lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset =  0xffffffff;
+
+     TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[0].dwCallerAddressOffset = %lx, [0].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[0].dwDestAddressOffset);
+ 
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "[1].dwCallerAddressOffset = %lx, [1].dwDestOffset = %lx",
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwCallerAddressOffset,
+         lpTapiLineTestInfo->lpForwardList->ForwardList[1].dwDestAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+/*
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwOrigAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwOrigAddressSize = %lx, dwOrigAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwOrigAddressSize = %lx, dwOrigAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwOrigAddressSize = %lx, dwOrigAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwOrigAddressSize = %lx, dwOrigAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwOrigAddressSize = %lx, dwOrigAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDisplayableAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDisplayableAddressSize = %lx, dwDisplayableAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDisplayableAddressSize = %lx, dwDisplayableAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDisplayableAddressSize = %lx, dwDisplayableAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDisplayableAddressSize = %lx, dwDisplayableAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDisplayableAddressSize = %lx, dwDisplayableAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCalledPartyAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCalledPartySize = %lx, dwCalledPartyOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartySize,
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCalledPartySize = %lx, dwCalledPartyOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartySize,
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCalledPartySize = %lx, dwCalledPartyOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartySize,
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCalledPartySize = %lx, dwCalledPartyOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartySize,
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCalledPartySize = %lx, dwCalledPartyOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartySize,
+         lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwComment Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCommentSize = %lx, dwCommentOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCommentSize,
+         lpTapiLineTestInfo->lpCallParams->dwCommentOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCommentSize = %lx, dwCommentOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCommentSize,
+         lpTapiLineTestInfo->lpCallParams->dwCommentOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCommentSize = %lx, dwCommentOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCommentSize,
+         lpTapiLineTestInfo->lpCallParams->dwCommentOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCommentSize = %lx, dwCommentOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCommentSize,
+         lpTapiLineTestInfo->lpCallParams->dwCommentOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCommentSize = %lx, dwCommentOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCommentSize,
+         lpTapiLineTestInfo->lpCallParams->dwCommentOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwUserUserInfo Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwUserUserInfoSize = %lx, dwUserUserInfoOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize,
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwUserUserInfoSize = %lx, dwUserUserInfoOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize,
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwUserUserInfoSize = %lx, dwUserUserInfoOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize,
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwUserUserInfoSize = %lx, dwUserUserInfoOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize,
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwUserUserInfoSize = %lx, dwUserUserInfoOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize,
+         lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwHighLevelComp Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwHighLevelCompSize = %lx, dwHighLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwHighLevelCompSize = %lx, dwHighLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwHighLevelCompSize = %lx, dwHighLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwHighLevelCompSize = %lx, dwHighLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwHighLevelCompSize = %lx, dwHighLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwLowLevelComp Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwLowLevelCompSize = %lx, dwLowLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwLowLevelCompSize = %lx, dwLowLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwLowLevelCompSize = %lx, dwLowLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwLowLevelCompSize = %lx, dwLowLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwLowLevelCompSize = %lx, dwLowLevelCompOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize,
+         lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDevSpecificAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwTargetAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwTargetAddressSize = %lx, dwTargetAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwTargetAddressSize = %lx, dwTargetAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwTargetAddressSize = %lx, dwTargetAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwTargetAddressSize = %lx, dwTargetAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwTargetAddressSize = %lx, dwTargetAddressOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize,
+         lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwSendingFlowspec Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwReceivingFlowspec Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize,
+         lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDeviceClass Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceClassSize = %lx, dwDeviceClassOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceClassSize = %lx, dwDeviceClassOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceClassSize = %lx, dwDeviceClassOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceClassSize = %lx, dwDeviceClassOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceClassSize = %lx, dwDeviceClassOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDeviceConfig Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceConfigSize = %lx, dwDeviceConfigOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceConfigSize = %lx, dwDeviceConfigOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceConfigSize = %lx, dwDeviceConfigOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceConfigSize = %lx, dwDeviceConfigOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDeviceConfigSize = %lx, dwDeviceConfigOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize,
+         lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCallData Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallDataSize = %lx, dwCallDataOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallDataSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallDataOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallDataSize = %lx, dwCallDataOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallDataSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallDataOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallDataSize = %lx, dwCallDataOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallDataSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallDataOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallDataSize = %lx, dwCallDataOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallDataSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallDataOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallDataSize = %lx, dwCallDataOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallDataSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallDataOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCallingPartyID Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallingPartyIDSize = %lx, dwCallingPartyIDOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallingPartyIDSize = %lx, dwCallingPartyIDOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallingPartyIDSize = %lx, dwCallingPartyIDOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwAllocSize + 16;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallingPartyIDSize = %lx, dwCallingPartyIDOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwAllocSize = %lx, dwTotalSize = %lx", 
+         dwAllocSize,
+         dwTotalSize);
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwCallingPartyIDSize = %lx, dwCallingPartyIDOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize,
+         lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+*/
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if ( ! DoLineForward(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	 }
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineForward(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineForward: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineForward  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlfw1.c b/private/tapi/qa/trapper/itest/tiline/itlfw1.c
new file mode 100644
index 000000000..be5951ad1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlfw1.c
@@ -0,0 +1,9240 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlfw1.c
+
+Abstract:
+
+    This module contains the test functions for lineForward Addtion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineForward
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad lpForwardList
+// 4. Bad lphConsultCall
+// 5. Bad lpCallParams
+// 6. Bad lpCallParams->dwTotalSize
+// 7. Bad lpForwardList->dwTotalSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineForward1(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams = NULL;
+    DWORD dwAllocSize, dwTotalSize, dwSize1, dwSize2;
+
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n****************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineForward");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwOrigAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDisplayableAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCalledPartyAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwComment Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwUserUserInfo Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwHighLevelComp Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwLowLevelComp Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDevSpecificAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+/*
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwTargetAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwSendingFlowspec Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwReceivingFlowspec Offset value");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDeviceClass Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDeviceConfig Offset value");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCallData Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCallingPartyID Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+*/
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineForward1: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineForward  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlfw2.c b/private/tapi/qa/trapper/itest/tiline/itlfw2.c
new file mode 100644
index 000000000..7ad26c8b3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlfw2.c
@@ -0,0 +1,9236 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlfw2.c
+
+Abstract:
+
+    This module contains the test functions for lineForward Addtion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineForward
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad lpForwardList
+// 4. Bad lphConsultCall
+// 5. Bad lpCallParams
+// 6. Bad lpCallParams->dwTotalSize
+// 7. Bad lpForwardList->dwTotalSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineForward2(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    LPCALLBACKPARAMS lpCallbackParams = NULL;
+    DWORD dwAllocSize, dwTotalSize, dwSize1, dwSize2;
+
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n****************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineForward");
+
+/*
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwOrigAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwOrigAddressOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDisplayableAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDisplayableAddressOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCalledPartyAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartySize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCalledPartyOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwComment Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCommentSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCommentOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwUserUserInfo Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwUserUserInfoOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwHighLevelComp Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwHighLevelCompOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwLowLevelComp Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwLowLevelCompOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDevSpecificAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 0xffffffff;
+
+    TapiLogDetail(
+         DBUG_SHOW_DETAIL,
+         "dwDevSpecificSize = %lx, dwDevSpecificOffset = %lx",
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize,
+         lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+ 
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+*/
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwTargetAddress Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwTargetAddressOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwSendingFlowspec Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwSendingFlowspecOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwReceivingFlowspec Offset value");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwReceivingFlowspecOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDeviceClass Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceClassOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwDeviceConfig Offset value");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwDeviceConfigOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCallData Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallDataSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallDataOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: Test lpCallParam dwCallingPartyID Offset value");
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = BIGBUFSIZE;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value between dwTotalSize & dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 0xffffffff;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwTotalSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = dwAllocSize + 16;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Offset value = 0XFFFFFFFF",
+        dwTestCase+1);
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    lpTapiLineTestInfo->bAllAddresses = TRUE;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+    lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+    lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+    lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+         BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize = BIGBUFSIZE;
+
+    dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(LINECALLPARAMS);
+
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDSize = 16;
+    lpTapiLineTestInfo->lpCallParams->dwCallingPartyIDOffset = 0xffffffff;
+
+    if (! DoLineForward(lpTapiLineTestInfo, LINEERR_INVALCALLPARAMS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineForward1: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineForward  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlh.c b/private/tapi/qa/trapper/itest/tiline/itlh.c
new file mode 100644
index 000000000..b7febc4e6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlh.c
@@ -0,0 +1,477 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlh.c
+
+Abstract:
+
+    This module contains the test functions for lineHold
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/3/96	Added Interface tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "iline.h"
+
+
+//  lineHold
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized case (testcase in uline.c)
+//     2)  Valid Case
+//	   3)  No owner priveledge for hCall
+//	   4)  Invalid hCall
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//
+
+BOOL TestLineHold(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT                 n;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed = TRUE;
+    BOOL				fEspFlag = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_UNKNOWN;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwAPILowVersion     = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion    = HIGH_APIVERSION;
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_NONE;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineHold  <<<<<<<<"
+            );
+
+    //
+    // Initialize and Negotiate, then find an ESP device that
+    // supports lineHold
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+
+    if (!FindESPLineDevice(lpTapiLineTestInfo))
+    {
+       fEspFlag = FALSE;
+       lpTapiLineTestInfo->dwDeviceID = 0;
+       TLINE_FAIL();
+       fTestPassed = TRUE;   //check why this is being done
+	   //also check whether it might not be a bad idea to 'return' here
+	}
+
+    // Shutdown
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN))
+    {
+        TLINE_FAIL();
+    }
+
+	//test valid case
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params.",
+            dwTestCase+1
+            );
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN | LMAKECALL))
+    {
+        TLINE_FAIL();
+    }
+    if(fEspFlag)
+    {
+		if (!DoLineHold(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+		{
+			TLINE_FAIL();
+		}
+	}
+	else
+    {
+		if (!DoLineHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+		{
+			TLINE_FAIL();
+		}
+    }
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // invalid hCall
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN | LMAKECALL))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+
+		  if (! DoLineHold(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, FALSE))
+			{
+				TLINE_FAIL();
+			}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	// no owner priveledges for hCall
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN | LMAKECALL))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+
+	if (! DoLineHold(lpTapiLineTestInfo, LINEERR_NOTOWNER, FALSE))
+		{
+			TLINE_FAIL();
+		}
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineHold(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineHold(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 //logging test results
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineHold: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+	 TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineHold  <<<<<<<<"
+            );
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlnev.c b/private/tapi/qa/trapper/itest/tiline/itlnev.c
new file mode 100644
index 000000000..6b6b45498
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlnev.c
@@ -0,0 +1,609 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlnev.c
+
+Abstract:
+
+    This module contains the test functions for lineNegotiateExtVersion
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Aug-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/3/96	Added Interface tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "iline.h"
+
+
+//  lineNegotiateExtVersion
+//
+//  The following tests are made:
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized case (testcase in uline.c)
+//     2)  Valid Case
+//	   3)  Invalid hLineApp
+//	   4)  Invalid dwDeviceId
+//	   5)  Invalid dwAPIVersion
+//	   6)  Bad dwExtLowVersion  &  dwExtHighVersion
+//	   7)  Bad lpdwExtVersion
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//  --------------------------------------------------------------------------
+//
+
+BOOL TestLineNegotiateExtVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+
+    int i, n;
+    ESPDEVSPECIFICINFO info;
+	 BOOL fTestPassed    = TRUE;
+    BOOL fEspFlag, fUnimdm;
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_PASS,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_PASS,
+		">> Test lineNegotiateExtVersion");
+
+	//test valid case
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Go/No-Go Test", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwAPIVersion         = TAPI_VERSION1_4;
+	 lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+	{
+		TLINE_FAIL();
+	}
+   }
+   else
+   {
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+	{
+		TLINE_FAIL();
+	}
+   }
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+
+
+	 lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(lpTapiLineTestInfo, LINITIALIZEEX))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    for (i = 0; i < NUMINVALIDHANDLES; i++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[i];
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+		{
+			TLINE_FAIL();
+		}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try a bad device id (= dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (= dwNumDevs)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs( lpTapiLineTestInfo, LINITIALIZEEX))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+		{
+			TLINE_FAIL();
+		}
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try bad device id (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs( lpTapiLineTestInfo, LINITIALIZEEX ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+		{
+			TLINE_FAIL();
+		}
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try invalid higher version...valid low version
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid ext version", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(lpTapiLineTestInfo, LINITIALIZEEX ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwExtVersion  = 0x00000000;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+      {
+       fEspFlag = TRUE;
+       fUnimdm = FALSE;
+      }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+      {
+       fEspFlag = FALSE;
+       fUnimdm = TRUE;
+      }
+    else
+      {
+       fEspFlag = FALSE;
+       fUnimdm = FALSE;
+      }
+    
+
+
+    lpTapiLineTestInfo->dwExtHighVersion = BAD_EXTVERSION;
+    if(fEspFlag)
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_INCOMPATIBLEEXTVERSION))
+		{
+			TLINE_FAIL();
+		}
+     }
+    else
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+		{
+			TLINE_FAIL();
+		}
+     }
+	
+    // Make the high parameter too low to be valid and the low too high.
+    // This checks that the low is being checked as the low version and the
+    // high is being checked as the high version.
+    lpTapiLineTestInfo->dwExtLowVersion  = BAD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = BAD_EXTVERSION;
+    if(fEspFlag)
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo,LINEERR_INCOMPATIBLEEXTVERSION))
+		{
+			TLINE_FAIL();
+		}
+     }
+    else
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo,LINEERR_OPERATIONUNAVAIL))
+		{
+			TLINE_FAIL();
+		}
+     }
+  
+    lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check bad lpdwExtVersion pointer
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad lpdwExtVersion pointer", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(lpTapiLineTestInfo, LINITIALIZEEX ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpdwExtVersion = (LPDWORD) gdwInvalidPointers[i];
+
+			if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+			{
+				TLINE_FAIL();
+			}
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpdwExtVersion = &(lpTapiLineTestInfo->dwExtVersion);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible High API Version", dwTestCase + 1);
+
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(lpTapiLineTestInfo, LINITIALIZEEX ))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	//high API version
+    lpTapiLineTestInfo->dwAPIVersion_Orig = lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TOOHIGH_APIVERSION;
+    if(fEspFlag)
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo,
+						   LINEERR_INCOMPATIBLEAPIVERSION))
+		{
+			TLINE_FAIL();
+		}
+     }
+    else
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo,LINEERR_OPERATIONUNAVAIL))
+		{
+			TLINE_FAIL();
+		}
+     }
+  
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible Low API Version", dwTestCase + 1);
+	//low API version
+    lpTapiLineTestInfo->dwAPIVersion = TOOLOW_APIVERSION;
+    if(fEspFlag)
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo,
+						   LINEERR_INCOMPATIBLEAPIVERSION))
+		{
+			TLINE_FAIL();
+		}
+     }
+    else
+     {
+		if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo,LINEERR_OPERATIONUNAVAIL))
+		{
+			TLINE_FAIL();
+		}
+     }
+  
+
+	lpTapiLineTestInfo->dwAPIVersion = lpTapiLineTestInfo->dwAPIVersion_Orig;
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Free the memory from heap
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+ 
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+    if ( ! DoLineNegotiateExtVersion(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+ 
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+    if ( ! DoLineNegotiateExtVersion(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+
+	 //logging test results
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineNegotiateExtVersion: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineNegotiateExtVersion  <<<<<<<<"
+            );
+
+    return fTestPassed;	
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlruui.c b/private/tapi/qa/trapper/itest/tiline/itlruui.c
new file mode 100644
index 000000000..4228a72d4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlruui.c
@@ -0,0 +1,730 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlruui.c
+
+Abstract:
+
+    This module contains the test functions for lineReleaseUserUserInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineReleaseUserUserInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. No owner privilege for hCall
+// 3. Bad hCall
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineReleaseUserUserInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n**************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineReleaseUserUserInfo");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineReleaseUserUserInfo for go/no-go",
+        dwTestCase+1);
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: No owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+    if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, LINEERR_NOTOWNER, FALSE))
+      {
+        TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hCall",
+        dwTestCase+1);
+
+    //
+    // save original hCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[i];
+        if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo,
+                                        LINEERR_INVALCALLHANDLE,
+                                        FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    //
+    // restore original hCall
+    //
+
+    lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineReleaseUserUserInfo: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineReleaseUserUserInfo  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlsas.c b/private/tapi/qa/trapper/itest/tiline/itlsas.c
new file mode 100644
index 000000000..eea48e663
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlsas.c
@@ -0,0 +1,467 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsas.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAppSpecific
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	4/3/96	Added Interface tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "ttest.h"
+#include "doline.h"
+#include "tcore.h"
+#include "iline.h"
+
+
+#define DWAPPSPECIFICVALUE 0x12349876
+
+
+//  lineSetAppSpecific
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized case (testcase included in uline.c)
+//     2)  Valid testcase
+//     3)  No owner priveledges for hCall
+//	   4)  Invalid hCall values
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//
+
+BOOL TestLineSetAppSpecific(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT                 n;
+    BOOL                fResult;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_UNKNOWN;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetAppSpecific  <<<<<<<<"
+            );
+            
+    // Try a valid test case
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid params and state",
+            dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with LINECALLPRIVILEGE_OWNER
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAppSpecific = DWAPPSPECIFICVALUE;
+    if (! DoLineSetAppSpecific(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+	//Invalid hCall values
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Invalid hCall values",
+            dwTestCase + 1);
+
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line with LINECALLPRIVILEGE_OWNER
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+
+		if (! DoLineSetAppSpecific(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+		{
+			TLINE_FAIL();
+		}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	//testcase with no owner privileges
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no owner privileges for hCall",
+            dwTestCase + 1);
+
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+// BUGBUG
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+//set monitor privileges
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+
+	if (! DoLineSetAppSpecific(lpTapiLineTestInfo, LINEERR_NOTOWNER))
+	{
+		TLINE_FAIL();
+	}
+
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	//--------------------------------------------
+
+	FreeTestHeap();
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwAppSpecific = DWAPPSPECIFICVALUE;
+    if ( ! DoLineSetAppSpecific(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwAppSpecific = DWAPPSPECIFICVALUE;
+    if ( ! DoLineSetAppSpecific(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+
+	 //logging test results
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetAppSpecific: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetAppSpecific  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itlst.c b/private/tapi/qa/trapper/itest/tiline/itlst.c
new file mode 100644
index 000000000..61f6c4b8b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlst.c
@@ -0,0 +1,1340 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlst.c
+
+Abstract:
+
+    This module contains the test functions for lineSetupTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineSetupTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. No owner privilege for hCall
+// 3. Bad hCall
+// 4. Bad lphConsultCall
+// 5. Bad lpCallParams
+// 6. Bad lpCallParams->dwTotalSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetupTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS lpCallbackParams=NULL;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwCallParamFixedSize = sizeof(LINECALLPARAMS);
+    DWORD lExpected;
+    DWORD dwCallParamTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwCallParamFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+ 
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n**************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineSetupTransfer");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+    lpCallbackParams = GetCallbackParams();
+    
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // restore hLine1
+    //
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineSetupTransfer for go/no-go",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    //
+    // Add the message LINE_CALLSTATE for which we are waiting for.
+    // This Go/No-go test also takes care of another test case in which we
+    // have to verify if LINE_CALLSTATE msg is sent.
+    //
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    AddMessage(LINE_CALLSTATE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               LINECALLSTATE_ONHOLD,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1)
+              );
+
+    if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    if(! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+
+    }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }    
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif    			
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+   if (! DoLineSetupTransfer(lpTapiLineTestInfo,
+                             LINEERR_NOTOWNER,
+                             FALSE))
+      {
+       TLINE_FAIL();
+      }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif    			
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hCall",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    //
+    // save original hCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[i];
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo,
+                                  LINEERR_INVALCALLHANDLE,
+                                  FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    //
+    // restore original hCall
+    //
+
+    lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lphConsultCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif    			
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lphConsultCall",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lphConsultCall = (LPHCALL) gdwInvalidPointers[i];
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo,
+                                  LINEERR_INVALPOINTER,
+                                  FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpCallParams.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif    			
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) gdwInvalidPointers[i];
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo,
+                                  LINEERR_INVALPOINTER,
+                                  FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpCallParams->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif    			
+    lpTapiLineTestInfo->dwCountryCode = 0;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams->dwTotalSize",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+        sizeof(LINECALLPARAMS));
+
+/*
+   lpTapiLineTestInfo->lpCallParams->dwTotalSize=0;
+
+    if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL, FALSE))
+     {
+       TLINE_FAIL();
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams->dwTotalSize=fixedSize-1",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+        sizeof(LINECALLPARAMS));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize=sizeof(LINECALLPARAMS)-1;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL, FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpCallParams->dwTotalSize=real big",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap(
+        sizeof(LINECALLPARAMS));
+   lpTapiLineTestInfo->lpCallParams->dwTotalSize=0x7fffffff;
+
+   if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_INVALPOINTER, FALSE))
+     {
+       TLINE_FAIL();
+     }
+*/
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+                        dwCallParamTotalSizes[n];
+	     if(dwCallParamTotalSizes[n] < dwCallParamFixedSize)
+          {
+           if(IsESPLineDevice(lpTapiLineTestInfo))
+              lExpected = LINEERR_STRUCTURETOOSMALL;
+           else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+              lExpected = LINEERR_OPERATIONUNAVAIL;
+          }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwCallParamTotalSizes[n]);
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+   
+	
+   fTestPassed = ShowTestCase(fTestPassed);
+   lpTapiLineTestInfo->lpCallParams->dwTotalSize = dwCallParamFixedSize;
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+    
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Verify LINECALLSTATE_UNKNOWN msg sent to monitors on
+    //               success
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+  
+
+	TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify LINECALLSTATE_DIALTONE msg sent"
+        " to monitors on success",
+        dwTestCase+1);
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    //
+    // Add the LINECALLSTATE_UNKNOWN message to the list of expected
+    // messages.
+    //
+
+    AddMessage(
+               LINE_CALLSTATE,
+               (DWORD) lpTapiLineTestInfo->hLine1,
+               (DWORD) lpCallbackParams,
+               LINECALLSTATE_DIALTONE,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1)
+              );
+     if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    //
+    // Wait for the LINECALLSTATE_UNKNOWN message
+    //
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }    
+	 }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if ( ! DoLineSetupTransfer(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALRATE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetupTransfer(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineSetupTransfer: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineSetupTransfer  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tiline/itlsuui.c b/private/tapi/qa/trapper/itest/tiline/itlsuui.c
new file mode 100644
index 000000000..b3306e245
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itlsuui.c
@@ -0,0 +1,1220 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlruui.c
+
+Abstract:
+
+    This module contains the test functions for lineSendUserUserInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineSendUserUserInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. No owner privilege for hCall
+// 3. Bad hCall
+// 4. Bad lpsUseruserInfo
+// 5. Bad dwSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSendUserUserInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    ESPDEVSPECIFICINFO info;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwFixedSize = BIGBUFSIZE;
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+ 
+	 InitTestNumber();
+
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n**************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineSendUserUserInfo");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineSendUserUserInfo for go/no-go",
+        dwTestCase+1);
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: No owner privilege for hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+         TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No owner privilege for hCall",
+        dwTestCase+1);
+
+    if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_NOTOWNER, FALSE))
+      {
+        TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hCall.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hCall",
+        dwTestCase+1);
+
+    //
+    // save original hCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL) gdwInvalidHandles[i];
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo,
+                                     LINEERR_INVALCALLHANDLE,
+                                     FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+
+    //
+    // restore original hCall
+    //
+
+    lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpsUserUserInfo.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpsUserUserInfo",
+        dwTestCase+1);
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) gdwInvalidPointers[i];
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo,
+                                     LINEERR_INVALPOINTER,
+                                     FALSE))
+          {
+            TLINE_FAIL();
+          }
+    }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwSize",
+        dwTestCase+1);
+
+
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    { 	  
+    for (i = 0; i < NUMTOTALSIZES; i++)
+        {
+        lpTapiLineTestInfo->dwSize =
+                        dwTotalSizes[i];
+	     if(dwTotalSizes[i] < dwFixedSize)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[i]);
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, lExpected, FALSE))
+           {
+              TLINE_FAIL();
+           }
+         }
+     }
+     else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+       {
+           TLINE_FAIL();
+       }
+     }
+ 
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### After: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Null lpsUserUserInfo(Success case).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }	
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+//  lpTapiLineTestInfo->lpCallParams = &(lpTapiLineTestInfo->CallParams);
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+			BIGBUFSIZE);
+    lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+    if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "### Before: dwUserUserInfoSize = %lx, Offset = %lx",
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoSize,
+        lpTapiLineTestInfo->lpCallInfo->dwUserUserInfoOffset);
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Null lpsUserUserInfo(Success case)",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) NULL;
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo,
+                                     TAPISUCCESS,
+                                     TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    if ( ! DoLineSendUserUserInfo(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->lpsUserUserInfo = (LPSTR) AllocFromTestHeap(128);
+    lpTapiLineTestInfo->dwSize = sizeof(lpTapiLineTestInfo->lpsUserUserInfo);
+    lpTapiLineTestInfo->lpsUserUserInfo = "This is a test";
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSendUserUserInfo(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineSendUserUserInfo: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineSendUserUserInfo  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/itluh.c b/private/tapi/qa/trapper/itest/tiline/itluh.c
new file mode 100644
index 000000000..1ae52d884
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/itluh.c
@@ -0,0 +1,510 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itluh.c
+
+Abstract:
+
+    This module contains the test functions for lineUnhold
+
+Author:
+
+    Oliver Wallace (OliverW)    27-Oct-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/3/96	Added Interface tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "iline.h"
+
+
+//  lineUnhold
+//
+//  The following tests are made:
+//
+//  -------------------------------------------------------------------------
+//
+//  *  1)  Uninitialized (called before any lines are initialized)
+//     2)  Valid Case
+//	   3)  No owner priveledge for hCall
+//	   4)  Invalid hCall
+//
+//  *  =   Stand-alone test -- executed only when this is the only TAPI app
+//         or thread running
+//
+
+BOOL TestLineUnhold(BOOL fQuietMode, BOOL fStandAloneTest)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    INT                 n;
+    ESPDEVSPECIFICINFO info;
+    BOOL                fTestPassed = TRUE;
+    BOOL fEspFlag = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    TapiLineTestInit();
+
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+    lpTapiLineTestInfo->lpExtID             = (LPLINEEXTENSIONID)
+                                              AllocFromTestHeap(
+                                                  sizeof(LINEEXTENSIONID)
+                                                  );
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwAPILowVersion     = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion    = HIGH_APIVERSION;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineUnhold  <<<<<<<<"
+            );
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld : valid params",
+            dwTestCase+1);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+
+    if (!FindESPLineDevice(lpTapiLineTestInfo))
+    {
+       fEspFlag = FALSE;
+       lpTapiLineTestInfo->dwDeviceID = 0;
+       TLINE_FAIL();
+       fTestPassed = TRUE;
+	}
+
+    // Open a line with LINECALLPRIVILEGE_OWNER
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL))
+    {
+        TLINE_FAIL();
+    }
+
+    // Put the call on hold
+    if(fEspFlag)
+    {
+		if (!DoLineHold(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+		{
+			TLINE_FAIL();
+		}
+		else		
+		{	// Retrieve the held call
+			if (! DoLineUnhold(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+			{
+				TLINE_FAIL();
+			}
+		}
+	}
+	else
+    {
+		if (!DoLineHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+		{
+			TLINE_FAIL();
+		}
+    }
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE |LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    // invalid hCall
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |LMAKECALL))
+    {
+        TLINE_FAIL();
+    }
+
+		if(fEspFlag)
+		{
+			if (! DoLineHold(lpTapiLineTestInfo, TAPISUCCESS , TRUE))
+			{
+				TLINE_FAIL();
+			}
+			else
+			{
+				lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+				for (n = 0; n < NUMINVALIDHANDLES; n++)
+				{
+					TapiLogDetail(
+						DBUG_SHOW_DETAIL,
+						"n= %ld", n);
+					*(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+
+						// Retrieve the held call
+					if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE , FALSE))
+					{
+						TLINE_FAIL();
+					}
+				}
+			}
+		}	
+ 		else
+		{
+			if (!DoLineHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+			{
+				TLINE_FAIL();
+			}
+		}
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	// no owner priveledges for hCall
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN | LMAKECALL))
+    {
+        TLINE_FAIL();
+    }
+
+
+   if(fEspFlag)
+   {
+		if (! DoLineHold(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+		{
+			TLINE_FAIL();
+		}
+		else
+		{
+		   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+		   {
+				 TLINE_FAIL();
+		   }
+		   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+		   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+		   {
+				 TLINE_FAIL();
+		   }
+		   if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_NOTOWNER , FALSE))
+		   {
+				TLINE_FAIL();
+		   }
+		}
+   }
+   else
+   {
+		if (!DoLineHold(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, FALSE))
+		{
+			TLINE_FAIL();
+		}
+   }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Free the memory from heap
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLineUnhold(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineUnhold(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 //logging test results
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineUnhold: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineUnhold  <<<<<<<<"
+            );
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/test.c b/private/tapi/qa/trapper/itest/tiline/test.c
new file mode 100644
index 000000000..79ec889f5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/test.c
@@ -0,0 +1,170 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    test.c
+
+Abstract:
+
+    This module contains the test functions for lineTest
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+VOID
+WINAPI
+TestCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    );
+
+
+
+//  lineTest
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTest(BOOL fQuietMode, BOOL fStandAlone)
+{
+	HLINEAPP 	hLineApp;
+	LPHLINEAPP	lphLineApp;
+	HINSTANCE   hInstance;
+	LINECALLBACK 	lpfnCallback;
+	LPTSTR		lpszAppName;
+	DWORD			dwNumDevs;
+	LPDWORD		lpdwNumDevs;
+	DWORD			dwAPILowVersion;
+	DWORD			dwAPIHighVersion;
+	DWORD			dwAPIVersion;
+	LPDWORD		lpdwAPIVersion;
+	LINEEXTENSIONID	ExtensionID;
+	LPLINEEXTENSIONID	lpExtensionID;
+	DWORD			dwDeviceID;
+   BOOL fTestPassed                  = TRUE;
+	LONG lRet;
+	char szAppName[10];
+
+	
+   hInstance = (HINSTANCE) GetModuleHandle("trapper.exe");
+	strcpy(szAppName, "tcore.dll");
+	lphLineApp = &hLineApp;
+	lpfnCallback = TestCallback;
+	lpszAppName = &szAppName[0];
+	lpdwNumDevs = &dwNumDevs;
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineInitalize");
+
+	// Initialize a line app
+	lRet = lineInitialize (lphLineApp, hInstance, lpfnCallback, lpszAppName, lpdwNumDevs);
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			" lRet = %lx", lRet);
+	if(lRet != 0)
+	{	
+	fTestPassed = FALSE;
+	}	
+
+	
+	dwDeviceID = 0;
+	dwAPILowVersion = LOW_APIVERSION;
+	dwAPIHighVersion = HIGH_APIVERSION;
+	lpdwAPIVersion = &dwAPIVersion;
+	lpExtensionID = &ExtensionID;
+
+
+    // Negotiate the API Version
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> lineNegotiateAPIVersion");
+
+	
+    lRet = lineNegotiateAPIVersion(
+					hLineApp,
+					dwDeviceID,
+					dwAPILowVersion,
+					dwAPIHighVersion,
+					lpdwAPIVersion,
+					lpExtensionID);
+	
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			" lRet = %lx", lRet);
+	if(lRet != 0)
+	{	
+	fTestPassed = FALSE;
+	}	
+
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> lineShutdown");
+
+	    // Shutdown and end the tests
+    lRet = lineShutdown(hLineApp);
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			" lRet = %lx", lRet);
+	if(lRet != 0)
+	{	
+	fTestPassed = FALSE;
+	}	
+
+
+
+     return fTestPassed;
+}
+
+VOID
+WINAPI
+TestCallback(
+    DWORD   hDevice,
+    DWORD   dwMsg,
+    DWORD   dwCallbackInstance,
+    DWORD   dwParam1,
+    DWORD   dwParam2,
+    DWORD   dwParam3
+    )
+{
+ 
+;
+}
diff --git a/private/tapi/qa/trapper/itest/tiline/testx.c b/private/tapi/qa/trapper/itest/tiline/testx.c
new file mode 100644
index 000000000..a65b2a78f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/testx.c
@@ -0,0 +1,83 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    test.c
+
+Abstract:
+
+    This module contains the test functions for lineTest
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineTest
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTestX(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineTest");
+
+	// Initialize a line app
+	if(! DoLineInitialize (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/testy.c b/private/tapi/qa/trapper/itest/tiline/testy.c
new file mode 100644
index 000000000..b5a62dc30
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/testy.c
@@ -0,0 +1,95 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    test.c
+
+Abstract:
+
+    This module contains the test functions for lineTest
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "iline.h"
+
+
+
+//  lineTest
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTestY(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineTest");
+
+	// Initialize a line app
+	if(! DoLineInitialize (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+   {
+       TLINE_FAIL();
+   }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/tiline.def b/private/tapi/qa/trapper/itest/tiline/tiline.def
new file mode 100644
index 000000000..46c5ff13f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/tiline.def
@@ -0,0 +1,25 @@
+LIBRARY         tiline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
diff --git a/private/tapi/qa/trapper/itest/tiline/tiline.inc b/private/tapi/qa/trapper/itest/tiline/tiline.inc
new file mode 100644
index 000000000..b1f7c106a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/tiline.inc
@@ -0,0 +1,69 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tiline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+DLLDEF=   ..\tiline.def
+DLLBASE=0x68000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..		
+
+USE_CRTDLL=1
+
+SOURCES=..\iline.c \
+		..\itlac.c \
+		..\itlas.c	\
+		..\itlbt.c	\
+		..\itlfw.c	\
+		..\itlfw1.c	\
+		..\itlfw2.c	\
+		..\itlruui.c \
+		..\itlsuui.c \
+		..\itlst.c	\
+		..\itlct.c \
+        ..\itlnev.c \
+        ..\itlh.c \
+        ..\itluh.c \
+        ..\itlsas.c \
+		..\uline.c \
+		..\version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=TILineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tiline/uline.c b/private/tapi/qa/trapper/itest/tiline/uline.c
new file mode 100644
index 000000000..56e823f93
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/uline.c
@@ -0,0 +1,217 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the uninitialized testcases for all the iline apis
+
+Author:
+
+	Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+    Rama Koneru (a-ramako) 4-3-96  modified this for the ILINE set of APIs
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "iline.h"
+
+
+char szApiName[12][48] =
+		{
+		"lineAccept",
+		"lineAnswer",
+		"lineBlindTransfer",
+		"lineCompleteTransfer",
+		"lineForward",
+		"lineReleaseUserUserInfo",
+		"lineSendUserUserInfo",
+		"lineNegotiateExtVersion",
+		"lineSetupTransfer",
+		"lineHold",
+		"lineSetAppSpecific",
+		"lineUnhold"
+	};
+
+
+BOOL TestLineUninitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+
+    //
+    // Allocate more than enough to store a call handle
+    //
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  Begin testing Uninitialized Cases  <<<<<<<<"
+	    );
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+        sizeof(LINECALLLIST));
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  "55555";
+#endif
+
+    //
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    //
+
+    if (fStandAlone)
+    {
+        for(n = 0; n < 12; n++)
+        {
+            strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+	
+            TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized %s",
+                dwTestCase + 1, szApiName[n]);
+
+            switch (n)
+            {
+            case 0:
+	            if (! DoLineAnswer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 1:
+	            if (! DoLineAccept(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 2:
+	            if (! DoLineBlindTransfer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 3:
+	            if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+                break;
+
+
+	        case 4:
+	            if (! DoLineForward(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 5:
+	            if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 6:
+	            if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 7:
+	            if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 8:
+	            if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 9:
+	            if (! DoLineHold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 10:
+	            if (! DoLineSetAppSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 11:
+	            if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+            }
+
+            fTestPassed = ShowTestCase(fTestPassed);
+        }
+
+    }
+
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+	    );
+	
+    return fTestPassed;
+}
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tiline/version.rc b/private/tapi/qa/trapper/itest/tiline/version.rc
new file mode 100644
index 000000000..95300ae2d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tiline/version.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI ILINE Library"
+#define VER_INTERNALNAME_STR        "tiline.dll"
+#define VER_ORIGINALFILENAME_STR    "tiline.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/tline20/dirs b/private/tapi/qa/trapper/itest/tline20/dirs
new file mode 100644
index 000000000..45c8c70cb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/dirs
@@ -0,0 +1,2 @@
+DIRS= tline20a \
+      tline20w
diff --git a/private/tapi/qa/trapper/itest/tline20/itlas.c b/private/tapi/qa/trapper/itest/tline20/itlas.c
new file mode 100644
index 000000000..33358ce5c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlas.c
@@ -0,0 +1,917 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlas.c
+
+Abstract:
+
+    This module contains the test functions for lineAgentSpecific
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		21-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineAgentSpecific
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad dwAgentExtensionIDIndex
+// 4. Bad lpParams
+// 5. Bad dwSize
+// 6. Open with no PROXY request
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAgentSpecific(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+
+    DWORD dwFixedSize = BIGBUFSIZE;
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineAgentSpecific");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineAgentSpecific unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+    lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineAgentSpecific go/no-go test",
+        dwTestCase+1);
+
+    if (! DoLineAgentSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest =
+            (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->dwResult = 0;
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+                    );
+        WaitForAllMessages();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    //
+    // close line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+     if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineAgentSpecific unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+    lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hLine",
+        dwTestCase+1);
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineAgentSpecific(lpTapiLineTestInfo,
+                                  LINEERR_INVALLINEHANDLE,
+                                  FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwAgentExtensionIDIndex.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+     if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineAgentSpecific unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+    lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwAgentExtensionIDIndex",
+        dwTestCase+1);
+
+    //
+    //  Bad dwAgentExtensionIDIndex
+    //
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = (DWORD)-1;
+
+    if (! DoLineAgentSpecific(lpTapiLineTestInfo,
+                              TAPISUCCESS,//LINEERR_INVALAGENTID,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpParams.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+     if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineAgentSpecific unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+    lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+    lpTapiLineTestInfo->dwSize = 0x100;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpParam",
+        dwTestCase+1);
+
+    //
+    //  Bad lpParam
+    //
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiLineTestInfo->lpParams = (LPVOID)gdwInvalidPointers[i];
+
+        if (! DoLineAgentSpecific(lpTapiLineTestInfo,
+                                  LINEERR_INVALPOINTER,
+                                  FALSE))
+        {
+                TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineAgentSpecific unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+/*
+    lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+*/
+    lpTapiLineTestInfo->lpParams = (LPVOID) AllocFromTestHeap(BIGBUFSIZE);
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwSize",
+        dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->dwSize = 0x7FFFFFFF;
+
+    if (! DoLineAgentSpecific(lpTapiLineTestInfo,
+                              LINEERR_INVALPOINTER,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+*/
+    for (i = 0; i < NUMTOTALSIZES; i++)
+        {
+        lpTapiLineTestInfo->dwSize =
+                        dwTotalSizes[i];
+	     if(dwTotalSizes[i] < dwFixedSize)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[i]);
+        if (! DoLineAgentSpecific(lpTapiLineTestInfo, lExpected, FALSE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwSize = dwFixedSize;
+
+    //
+    // close line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Open with no PROXY request.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineAgentSpecific unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER ;//|
+													//LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+    lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+    lpTapiLineTestInfo->dwSize = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Open with no PROXY request",
+        dwTestCase+1);
+
+    //
+    //  Bad lpParam
+    //
+
+    if (! DoLineAgentSpecific(lpTapiLineTestInfo,
+                              LINEERR_OPERATIONUNAVAIL,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineAgentSpecific: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineAgentSpecific  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlgaal.c b/private/tapi/qa/trapper/itest/tline20/itlgaal.c
new file mode 100644
index 000000000..dc9f5bd7b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlgaal.c
@@ -0,0 +1,974 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgaal.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentActivityList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetAgentActivityList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad dwAddressID
+// 4. Bad lpAgentGroupList
+// 5. Bad dwTotalSize
+// 6. Open with no proxy request
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentActivityList(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    DWORD dwFixedSize = sizeof(LINEAGENTACTIVITYLIST);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+ 	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineGetAgentActivityList");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go / No Go test",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = sizeof(LINEAGENTACTIVITYLIST);
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL, "##lret = %lx", lret);
+	
+    if(lret == 1)
+	{
+        lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwNeededSize =
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwTotalSize;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwNumEntries = 2;
+        lpTapiLineTestInfo->dwResult = 0;
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+         WaitForAllMessages();
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "## dwTotalSize = %lx, dwNeededSize = %lx, dwNumEntries = %lx",
+        lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize,
+        lpTapiLineTestInfo->lpAgentActivityList->dwNeededSize,
+        lpTapiLineTestInfo->lpAgentActivityList->dwNumEntries);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize =
+        sizeof(LINEAGENTACTIVITYLIST);
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                         LINEERR_INVALLINEHANDLE,
+                                         FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwAddressID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize =
+        sizeof(LINEAGENTACTIVITYLIST);
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID = -1",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = (DWORD)-1;
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                     LINEERR_INVALADDRESSID,
+                                     FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID = dwNumAddress",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID =
+        lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                     LINEERR_INVALADDRESSID,
+                                     FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpAgentActivityList.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentActivityList",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpAgentActivityList =
+            (LPLINEAGENTACTIVITYLIST) gdwInvalidPointers[i];
+        if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                         LINEERR_INVALPOINTER,
+                                         FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpAgentActivityList->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentActivityList->dwTotalSiz",
+                  dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = 0;
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                     LINEERR_STRUCTURETOOSMALL,
+                                     FALSE))
+    {
+            TLINE_FAIL();
+    }
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentActivityList->dwTotalSize=fixedSize-1",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize =
+        sizeof(LINEAGENTACTIVITYLIST)-1;
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                     LINEERR_STRUCTURETOOSMALL,
+                                     FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentActivityList->dwTotalSize=realBig",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                     LINEERR_INVALPOINTER,
+                                     FALSE))
+    {
+            TLINE_FAIL();
+    }
+*/
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetAgentActivityList(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: open with no proxy request.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Open with no Proxy request",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = sizeof(LINEAGENTACTIVITYLIST);
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo,
+                                     LINEERR_OPERATIONUNAVAIL,
+                                     TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineGetAgentActivityList: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineGetAgentActivityList  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlgac.c b/private/tapi/qa/trapper/itest/tline20/itlgac.c
new file mode 100644
index 000000000..352cb5172
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlgac.c
@@ -0,0 +1,1307 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgac.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		21-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+#define NUMTOTALSIZES 5
+
+
+
+//  lineGetAgentCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLineApp
+// 3. Bad dwDeviceID
+// 4. Bad dwAddressID
+// 5. Bad dwAppAPIVersion
+// 6. Bad lpAgentCaps
+// 7. Bad dwTotalSize
+// 8. Open with no proxy request
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    DWORD dwFixedSize = sizeof(LINEAGENTCAPS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineGetAgentCaps");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go / No Go test",
+                  dwTestCase+1);
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentCaps.AgentCaps.dwNeededSize =
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentCaps.AgentCaps.dwTotalSize;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentCaps.AgentCaps.dwFeatures = LINEAGENTFEATURE_GETAGENTGROUP;
+        lpTapiLineTestInfo->dwResult = 0;
+
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "## dwTotalSize = %lx, dwNeededSize = %lx, dwFeatures = %lx",
+        lpTapiLineTestInfo->lpAgentCaps->dwTotalSize,
+        lpTapiLineTestInfo->lpAgentCaps->dwNeededSize,
+        lpTapiLineTestInfo->lpAgentCaps->dwFeatures);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLineApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLineApp",
+                  dwTestCase+1);
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    //
+    // save previous hLineApp
+    //
+
+    lpTapiLineTestInfo->hLineApp_Orig = lpTapiLineTestInfo->hLineApp1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLineApp = (HLINEAPP)gdwInvalidHandles[i];
+        if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                                 LINEERR_INVALAPPHANDLE,
+                                 FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLineApp1 = lpTapiLineTestInfo->hLineApp_Orig;
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwDeviceID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    //
+    // Bad dwDeviceID
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwDeviceID=-1",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwDeviceID = (DWORD)-1;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_BADDEVICEID,
+                             FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwDeviceID=dwNumDevs",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_BADDEVICEID,
+                             FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwAddressID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    //
+    // Bad dwAddressID
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID=-1",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = (DWORD)-1;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_INVALADDRESSID,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID= dwNumAddress",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID =
+        lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_INVALADDRESSID,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwAppAPIVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAPIVersion(high)",
+                  dwTestCase+1);
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+
+    //
+    //
+    // Bad dwAPIVersion
+    //
+    //
+
+    lpTapiLineTestInfo->dwAppAPIVersion = WAYTOOHIGH_APIVERSION;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_INCOMPATIBLEAPIVERSION,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAPIVersion(low)",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->dwAppAPIVersion = TOOLOW_APIVERSION;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_INCOMPATIBLEAPIVERSION,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpAgentCaps.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentCaps",
+                  dwTestCase+1);
+
+    //
+    //
+    // Bad lpAgentCaps
+    //
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS)gdwInvalidPointers[i];
+        if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER,
+                                 FALSE))
+        {
+                TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad lpAgentCaps->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+
+
+    //
+    //
+    // Bad lpAgentCaps->dwTotalSize
+    //
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentCaps->dwTotalSize",
+                  dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = 0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_STRUCTURETOOSMALL,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentCaps->dwTotalSize=fixed_size-1",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS)-1;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_STRUCTURETOOSMALL,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentCaps->dwTotalSize=real big",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+*/
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetAgentCaps(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = dwFixedSize;
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Open with no Proxy request.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Open with no proxy request",
+                  dwTestCase+1);
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_OPERATIONUNAVAIL,
+                             TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineGetAgentCaps: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineGetAgentCaps  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlgagl.c b/private/tapi/qa/trapper/itest/tline20/itlgagl.c
new file mode 100644
index 000000000..37cf9d82f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlgagl.c
@@ -0,0 +1,982 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgagl.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentGroupList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetAgentGroupList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad dwAddressID
+// 4. Bad lpAgentGroupList
+// 5. Bad dwTotalSize
+// 6. Open with no Proxy request
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentGroupList(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    DWORD dwFixedSize = sizeof(LINEAGENTGROUPLIST);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+ 	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineGetAgentGroupList");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go/No Go Test",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentGroupList.GroupList.dwNeededSize =
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentGroupList.GroupList.dwTotalSize;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentGroupList.GroupList.dwNumEntries = 2;
+        lpTapiLineTestInfo->dwResult = 0;
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "## dwTotalSize = %lx, dwNeededSize = %lx, dwNumEntries = %lx",
+        lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize,
+        lpTapiLineTestInfo->lpAgentGroupList->dwNeededSize,
+        lpTapiLineTestInfo->lpAgentGroupList->dwNumEntries);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                                      LINEERR_INVALLINEHANDLE,
+                                      FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwAddressID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID=-1",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = (DWORD)-1;
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                                  LINEERR_INVALADDRESSID,
+                                  FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID= dwNumAddress",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID =
+        lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                                  LINEERR_INVALADDRESSID,
+                                  FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpAgentGroupList.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentGroupList",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiLineTestInfo->lpAgentGroupList =
+            (LPLINEAGENTGROUPLIST)gdwInvalidPointers[i];
+        if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER,
+                                 FALSE))
+        {
+                TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwTotalSize",
+                  dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 0;
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                             LINEERR_STRUCTURETOOSMALL,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwTotalSize=fixed_size-1",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize =
+        sizeof(LINEAGENTGROUPLIST)-1;
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                             LINEERR_STRUCTURETOOSMALL,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwTotalSize=real big",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER,
+                             FALSE))
+    {
+            TLINE_FAIL();
+    }
+*/
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetAgentGroupList(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = dwFixedSize;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Open with no Proxy request.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER ;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTGROUPLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Open with no Proxy request",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineGetAgentGroupList: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineGetAgentGroupList  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlgas.c b/private/tapi/qa/trapper/itest/tline20/itlgas.c
new file mode 100644
index 000000000..5a505fcf4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlgas.c
@@ -0,0 +1,879 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgas.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentStatus
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineGetAgentStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad dwAddressID
+// 4. Bad lpAgentStatus
+// 5. Bad dwTotalSizw
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    DWORD dwFixedSize = sizeof(LINEAGENTSTATUS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+ 	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineGetAgentStatus");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go/No Go Test",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL, "##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentStatus.AgentStatus.dwNeededSize =
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentStatus.AgentStatus.dwTotalSize;
+        lpTapiLineTestInfo->lpProxyRequest->GetAgentStatus.AgentStatus.dwActivityID = 1;
+        lpTapiLineTestInfo->dwResult = 0;
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    TapiLogDetail (
+        DBUG_SHOW_DETAIL,
+        "## dwTotalSize = %lx, dwNeededSize = %lx, dwActivityID = %lx",
+        lpTapiLineTestInfo->lpAgentStatus->dwTotalSize,
+        lpTapiLineTestInfo->lpAgentStatus->dwNeededSize,
+        lpTapiLineTestInfo->lpAgentStatus->dwActivityID);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                                   LINEERR_INVALLINEHANDLE,
+                                   FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwAddressID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID=-1",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = (DWORD)-1;
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_INVALADDRESSID,
+                               FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwAddressID= dwNumAddress",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID =
+        lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_INVALADDRESSID,
+                               FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpAgentStatus.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpAgentStatus",
+                  dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiLineTestInfo->lpAgentStatus =
+            (LPLINEAGENTSTATUS)gdwInvalidPointers[i];
+        if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                                   LINEERR_INVALPOINTER,
+                                   FALSE))
+        {
+                TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineGetAgentActivityList unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get lineDevCaps
+    //
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwTotalSize",
+                  dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = 0;
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_STRUCTURETOOSMALL,
+                               FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwTotalSize=fixed_size-1",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize =
+        sizeof(LINEAGENTSTATUS)-1;
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_STRUCTURETOOSMALL,
+                               FALSE))
+    {
+            TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwTotalSize=real big",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_INVALPOINTER,
+                               FALSE))
+    {
+            TLINE_FAIL();
+    }
+*/
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetAgentStatus(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = dwFixedSize;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineGetAgentStatus: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineGetAgentStatus  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlgm.c b/private/tapi/qa/trapper/itest/tline20/itlgm.c
new file mode 100644
index 000000000..9ed7cceac
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlgm.c
@@ -0,0 +1,366 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgm.c
+
+Abstract:
+
+    This module contains the test functions for lineGetMessage
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineGetMessage
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLineApp
+// 3. Bad lpMessage
+//
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetMessage(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n*********************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineGetMessage");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEEVENT;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress =  L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress =  "55555";
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+    if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    WaitForAllMessages();
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go/No-Go Test",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE) AllocFromTestHeap (
+        sizeof(LINEMESSAGE));
+
+    if(! DoLineGetMessage (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "lpMessage: hDevice = %lx, dwMessageID = %lx, dwCallbackInst = %lx",
+        lpTapiLineTestInfo->lpMessage->hDevice,
+        lpTapiLineTestInfo->lpMessage->dwMessageID,
+        lpTapiLineTestInfo->lpMessage->dwCallbackInstance);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "lpMessage: dwParam1 = %lx, dwParam2 = %lx, dwParam3 = %lx",
+        lpTapiLineTestInfo->lpMessage->dwParam1,
+        lpTapiLineTestInfo->lpMessage->dwParam2,
+        lpTapiLineTestInfo->lpMessage->dwParam3);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLineApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEEVENT;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLineApp",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE) AllocFromTestHeap (
+        sizeof(LINEMESSAGE));
+
+    //
+    // save previous hLineApp
+    //
+
+    lpTapiLineTestInfo->hLineApp_Orig = lpTapiLineTestInfo->hLineApp1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLineApp = (HLINEAPP)gdwInvalidHandles[i];
+        if (! DoLineGetMessage(lpTapiLineTestInfo,
+                               LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLineApp1 = lpTapiLineTestInfo->hLineApp_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpMessage.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEEVENT;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpMessage",
+                  dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE)gdwInvalidPointers[i];
+
+        if (! DoLineGetMessage(lpTapiLineTestInfo,LINEERR_INVALPOINTER))
+        {
+                TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineGetMessage: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineGetMessage  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlie.c b/private/tapi/qa/trapper/itest/tline20/itlie.c
new file mode 100644
index 000000000..4bff161fc
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlie.c
@@ -0,0 +1,1898 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlie.c
+
+Abstract:
+
+    This module contains the test functions for lineInitializeEx
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+#define NUMTOTALSIZES 5
+
+
+//  lineInitializeEx
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLineApp
+// 3. Bad hInstance
+// 4. Bad lpfnCallback
+// 5. Bad lpszFriendlyName
+// 6. Inval lpszFriendlyAppName
+// 7. Bad lpdwNumDevs
+// 8. Bad lpdwAPIVersion
+// 9. Bad lpLineInitializeExparams
+// 10. Bad dwTotalSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineInitializeEx(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    BOOL fTestPassed                  = TRUE;
+    TAPIRESULT         lastTapiResult;
+    DWORD dwFixedSize = sizeof(LINEINITIALIZEEXPARAMS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+ 	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n**************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineInitializeEx");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Go/No-Go test",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLineApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad hLineApp",
+                  dwTestCase+1);
+
+    //
+    // Test invalid hLineApp
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lphLineApp = (LPHLINEAPP)gdwInvalidPointers[i];
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: hLineApp == lpdwNumDevs
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: hLineApp == lpdwNumDevs",
+                  dwTestCase+1);
+
+    //
+    // Test invalid hLineApp
+    //
+
+    lpTapiLineTestInfo->lphLineApp = 
+        (LPHLINEAPP)lpTapiLineTestInfo->lpdwNumDevs;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: hLineApp == lpdwAPIVersion
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: hLineApp == lpdwAPIVersion",
+                  dwTestCase+1);
+
+    //
+    // Test invalid hLineApp
+    //
+
+    lpTapiLineTestInfo->lphLineApp = 
+        (LPHLINEAPP)lpTapiLineTestInfo->lpdwAPIVersion;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: hLineApp == lpLineInitializeExParams
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: hLineApp == lpLineInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid hLineApp
+    //
+
+    lpTapiLineTestInfo->lphLineApp = 
+        (LPHLINEAPP)lpTapiLineTestInfo->lpLineInitializeExParams;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad hInstance.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad hInstance",
+                  dwTestCase+1);
+
+    //
+    // save previous hInstance
+    //
+
+    lpTapiLineTestInfo->hInstance_Orig = lpTapiLineTestInfo->hInstance;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 1;  i < NUMINVALIDHANDLES; i++)
+    {
+        lpTapiLineTestInfo->hInstance = (HINSTANCE)gdwInvalidHandles[i];
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    //
+    // Reset hInstance
+    //
+
+    lpTapiLineTestInfo->hInstance = lpTapiLineTestInfo->hInstance_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad lpfnCallback.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpfnCallback",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpfnCallback
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpfnCallback =
+            (LINECALLBACK)gdwInvalidPointers[i];
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Bad lpszFriendlyAppName.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+#ifdef WUNICODE
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpwszFriendlyAppName",
+                  dwTestCase+1);
+#else
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpszFriendlyAppName",
+                  dwTestCase+1);
+#endif
+
+    //
+    // Test invalid lpszFriendlyAppName
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszFriendlyAppName =
+            (LPWSTR)gdwInvalidPointers[i];
+#else
+        lpTapiLineTestInfo->lpszFriendlyAppName =
+            (LPSTR)gdwInvalidPointers[i];
+#endif
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: Bad lpszFriendlyAppName.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+#ifdef WUNICODE
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpwszFriendlyAppName",
+                  dwTestCase+1);
+#else
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpszFriendlyAppName",
+                  dwTestCase+1);
+#endif
+
+    //
+    // Test invalid lpszAppName
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszFriendlyAppName =
+            (LPWSTR)gdwInvalidPointers[i];
+#else
+        lpTapiLineTestInfo->lpszFriendlyAppName =
+            (LPSTR)gdwInvalidPointers[i];
+#endif
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 10. Test Case: Bad lpdwNumDevs.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpdwNumDevs",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwNumDevs
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpdwNumDevs =
+            (LPDWORD)gdwInvalidPointers[i];
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 11. Test Case: lpdwNumDevs == lpdwAPIVersion
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: lpdwNumDevs == lpdwAPIVersion",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwNumDevs
+    //
+
+    lpTapiLineTestInfo->lpdwNumDevs =
+            (LPDWORD) lpTapiLineTestInfo->lpdwAPIVersion;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER))
+       {
+          TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 12. Test Case: lpdwNumDevs == lpLineInitializeExParams
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: lpdwNumDevs == lpLineInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwNumDevs
+    //
+
+    lpTapiLineTestInfo->lpdwNumDevs =
+            (LPDWORD) lpTapiLineTestInfo->lpLineInitializeExParams;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER))
+       {
+          TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 13. Test Case: Bad lpdwAPIVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpdwAPIVersion",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwAPIVersion
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpdwAPIVersion =
+            (LPDWORD)gdwInvalidPointers[i];
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 14. Test Case: lpdwAPIVersion == lpLineInitializeExParams
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: lpdwAPIVersion == lpLineInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwAPIVersion
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion =
+            (LPDWORD) lpTapiLineTestInfo->lpLineInitializeExParams;
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+ 
+    // ===================================================================
+    // ===================================================================
+    //
+    // 15. Test Case: Bad lpLineInitializeExParams.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpLineInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpLineInitializeExParams
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpLineInitializeExParams =
+            (LPLINEINITIALIZEEXPARAMS)gdwInvalidPointers[i];
+        if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                                 LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+
+            //
+            // if we initialized successfully,i.e lineInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                {
+                    TLINE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 16. Test Case: Bad dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+//    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+//         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize",
+                  dwTestCase+1);
+
+/*
+
+
+    //
+    // lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize = 0;
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize = 0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+    {
+        TLINE_FAIL();
+
+        //
+        // if we initialized successfully,i.e lineInitializeEx returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=fixedSize-1",
+                  dwTestCase+1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+        sizeof(LINEINITIALIZEEXPARAMS)-1;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+    {
+        TLINE_FAIL();
+
+        //
+        // if we initialized successfully,i.e lineInitializeEx returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=real big",
+                  dwTestCase+1);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize = 0x7FFFFFFF;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+    {
+        TLINE_FAIL();
+
+        //
+        // if we initialized successfully,i.e lineInitializeEx returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+    }
+
+*/
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineInitializeEx(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+              GetLastTapiResult(&lastTapiResult);
+
+              if(lastTapiResult.lActual == TAPISUCCESS)
+              {
+                if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+                  {
+                    TLINE_FAIL();
+                  }
+              }
+            }
+        }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize = dwFixedSize;
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 17. Test Case:Null (valid) lpLineInitializeExParams.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Null (valid) lpLineInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test valid Null lpLineInitializeExParams
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams = NULL;
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 18. Test Case: forward compatibility
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020001;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0xfffffffc & LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Forward compatibility",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "dwAPIVersion = %lx",
+        lpTapiLineTestInfo->dwAPIVersion);
+
+    if(lpTapiLineTestInfo->dwAPIVersion == 0x00020000)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+ 
+ 
+   if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 19. Test Case: verify 3 options in lpLineInitParam
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0xfffffffc & LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Verify 3 options: USECOMPLETIONPORT",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+ 
+ 
+   if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 20. Test Case: verify 3 options in lpLineInitParam
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0xfffffffc & LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Verify 3 options: USEHIDDENWINDOW",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+ 
+ 
+   if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 21. Test Case: verify 3 options in lpLineInitParam
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0xfffffffc & LINEINITIALIZEEXOPTION_USEEVENT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Verify 3 options: USEEVENT",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+ 
+ 
+   if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 22. Test Case: verify uppart bits in options ignor
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0xfffffff0;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Verify uppart bits in options ignor",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+ 
+ 
+   if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    //
+    // 23. Test Case: verify uppart bits in options ignor
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0x0000fff1;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Verify uppart bits in options ignor",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             TAPISUCCESS))
+    {
+        TLINE_FAIL();
+
+    }
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+ 
+ 
+   if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 24. Test Case: options 4, in lpLineInitParam should fail
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions = 4;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: options 4 should fail",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPARAM))
+    {
+        TLINE_FAIL();
+
+        GetLastTapiResult(&lastTapiResult);
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 25. Test Case: options 15, in lpLineInitParam should fail
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions = 15;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: options 15 should fail",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INVALPARAM))
+    {
+        TLINE_FAIL();
+
+        GetLastTapiResult(&lastTapiResult);
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+     // ===================================================================
+    // ===================================================================
+    //
+    // 26. Test Case: Anything < 20000 should fail
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = 0x00010004;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+        (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS) + 1);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS) + 1;
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         0xfffffffc & LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Anything < 2000 should fail",
+                  dwTestCase+1);
+
+    if (! DoLineInitializeEx(lpTapiLineTestInfo,
+                             LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+
+        GetLastTapiResult(&lastTapiResult);
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+        }
+     }
+     
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineInitializeEx: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineInitializeEx  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlpm.c b/private/tapi/qa/trapper/itest/tline20/itlpm.c
new file mode 100644
index 000000000..7dacf67d1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlpm.c
@@ -0,0 +1,800 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpm.c
+
+Abstract:
+
+    This module contains the test functions for lineProxyMessage
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineProxyMessage
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad hCall
+// 4. Bad dwMsg
+// 5. Bad dwParam1
+// 6. Bad dwParam2
+// 7. Bad dwParam3
+// 8. Open with no PROXY request
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineProxyMessage(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineProxyMessage");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## ProxyMessage: unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: lineProxyMessage for go/no-go",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+       TLINE_FAIL();
+    }
+
+    AddMessage (LINE_REPLY,
+                0,
+                0,
+                0,
+                lpTapiLineTestInfo->dwResult,
+                0,
+                TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+    WaitForAllMessages();
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## ProxyMessage: unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: Bad hLine",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineProxyMessage(lpTapiLineTestInfo,
+                                 LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwMsg
+    // 4.            Bad dwParam1
+    // 5.            Bad dwParam2
+    // 6.            Bad dwParam3
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## ProxyMessage: unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: Bad dwMsg",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = (DWORD)~LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+    {
+       TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: Bad dwParam1",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0xFFFFFFFF;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+    {
+       TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: Bad dwParam2",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = (DWORD)~0x1FF;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+    {
+       TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: Bad dwParam3",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_STATE;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+    {
+       TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Open with no proxy request
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## ProxyMessage: unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER ;//|
+												   // LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: open with no PROXY request",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo, LINEERR_NOTREGISTERED))
+    {
+       TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Bad hCall
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## ProxyMessage: unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		"#### Test Case %ld: Bad hCall",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSPECIFIC;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = 0;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    //
+    // save previous hCall
+    //
+
+    lpTapiLineTestInfo->hCall_Orig = lpTapiLineTestInfo->hCall1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 1;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphCall = (HCALL)gdwInvalidHandles[i];
+        if (! DoLineProxyMessage(lpTapiLineTestInfo,
+                                 LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hCall
+    //
+
+    lpTapiLineTestInfo->hCall1 = lpTapiLineTestInfo->hCall_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the line
+    //
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineProxyMessage: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineProxyMessage  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlpr.c b/private/tapi/qa/trapper/itest/tline20/itlpr.c
new file mode 100644
index 000000000..ddcea7638
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlpr.c
@@ -0,0 +1,689 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpr.c
+
+Abstract:
+
+    This module contains the test functions for lineProxyResponse
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineProxyResponse
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad lpProxyBuffer
+// 4. Bad dwResult
+// 5. Call second with same lpProxyBuffer
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineProxyResponse(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineProxyResponse");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineProxyResponse unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go / No Go test",
+                  dwTestCase+1);
+
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest =
+            (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->dwResult = 0;
+
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineProxyResponse unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+    //
+    // Get the line device capabilities
+    //
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        if (! DoLineGetAgentCaps(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+            TLINE_FAIL();
+        }
+        lpTapiMsg = NULL;
+        lpMatch->dwMsg = LINE_PROXYREQUEST;
+//      lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+        lpMatch->dwParam2 = 0;
+        lpMatch->dwParam3 = 0;
+        lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+        lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+        TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+        if(lret == 1)
+        {
+            lpTapiLineTestInfo->lpProxyRequest =
+                (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+            lpTapiLineTestInfo->dwResult = 0;
+
+            //
+            // save previous hLine
+            //
+
+            lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+            //
+            // Test invalid handles
+            //
+
+            *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+
+            if (! DoLineProxyResponse(lpTapiLineTestInfo,
+                                      LINEERR_INVALLINEHANDLE))
+            {
+                TLINE_FAIL();
+            }
+
+            AddMessage (LINE_REPLY,
+                        0,
+                        0,
+                        0,
+                        lpTapiLineTestInfo->dwResult,
+                        0,
+                        TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+
+            WaitForAllMessages();
+
+            //
+            // Reset hLine
+            //
+
+            lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpProxyBuffer.
+    //
+    // ===================================================================
+    // ===================================================================
+
+/*
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineProxyResponse unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpProxyBuffer",
+                  dwTestCase+1);
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+    lpTapiLineTestInfo->lpProxyRequest =
+            (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->dwResult = 0;
+
+    //
+    // Test bad lpProxy Buffer
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiLineTestInfo->lpProxyRequest =
+            (LPLINEPROXYREQUEST)gdwInvalidPointers[i];
+        if (! DoLineProxyResponse(lpTapiLineTestInfo,
+                                  LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+*/
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwResult.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## lineProxyResponse unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_GETAGENTCAPS;
+
+	
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwResult",
+                  dwTestCase+1);
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lpTapiLineTestInfo->lpProxyRequest =
+            (LPLINEPROXYREQUEST)  AllocFromTestHeap (sizeof(LINEPROXYREQUEST));
+    lpTapiLineTestInfo->lpProxyRequest->dwSize = sizeof(LINEPROXYREQUEST);
+    lpTapiLineTestInfo->dwResult = 0;
+
+
+
+    //
+    // Test bad dwResult
+    //
+    //
+    // a positive value is a bad dwResult  value
+    //
+
+    lpTapiLineTestInfo->dwResult = 0x100;
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineProxyResponse: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineProxyResponse  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlsaa.c b/private/tapi/qa/trapper/itest/tline20/itlsaa.c
new file mode 100644
index 000000000..9097ce4f5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlsaa.c
@@ -0,0 +1,627 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgaal.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAgentActivity
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+
+
+//  lineSetAgentActivity
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad dwAddressId
+// 4. Bad dwActivity
+// 5. Open with no Proxy Request
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAgentActivity(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test LineSetAgentActivity");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentActivity unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTACTIVITY;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go / No Go test",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->dwActivityID = 1;
+
+    if (! DoLineSetAgentActivity(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest =
+            (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->dwResult = 0;
+
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentActivity unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTACTIVITY;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->dwActivityID = 1;
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineSetAgentActivity(lpTapiLineTestInfo,
+                                     LINEERR_INVALLINEHANDLE,
+                                     FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwActivityID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentActivity unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTACTIVITY;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad dwActivityID",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    //
+    // Bad dwActivityID
+    //
+
+	lpTapiLineTestInfo->dwActivityID = (DWORD)-1;
+
+    if (! DoLineSetAgentActivity(lpTapiLineTestInfo,
+                                 TAPISUCCESS,//LINEERR_INVALAGENTACTIVITY,
+                                 TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Open with No Proxy Request.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentActivity unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER ;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+		            lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTACTIVITY;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Open with no proxy request",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->dwActivityID = 1;
+
+    if (! DoLineSetAgentActivity(lpTapiLineTestInfo,
+                                 LINEERR_OPERATIONUNAVAIL,
+                                 TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if(! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineSetAgentActivity: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineSetAgentActivity  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlsag.c b/private/tapi/qa/trapper/itest/tline20/itlsag.c
new file mode 100644
index 000000000..3748a3015
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlsag.c
@@ -0,0 +1,828 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsag.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAgentGroup
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineSetAgentGroup
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. Bad lpAgentGroupList
+// 4. Bad dwTotalSize
+// 5. Set dwOffSet To different Value
+// 6. Open wirh no Proxy Request
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAgentGroup(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i, n;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+    DWORD dwFixedSize = sizeof(LINEAGENTGROUPLIST);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+  	 InitTestNumber();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test LineSetAgentGroup");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentGroup unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTGROUP;
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Go/No-Go Test",
+                  dwTestCase+1);
+	//
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->dwResult = 0;
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentGroup unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTGROUP;
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                                  LINEERR_INVALLINEHANDLE,
+                                  FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpAgentGroupList.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentGroup unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTGROUP;
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpAgentGroupList",
+                  dwTestCase+1);
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiLineTestInfo->lpAgentGroupList =
+            (LPLINEAGENTGROUPLIST)gdwInvalidPointers[i];
+        if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                                  LINEERR_INVALPOINTER,
+                                  FALSE))
+        {
+                TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentGroup unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTGROUP;
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	//
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize",
+                  dwTestCase+1);
+
+/*
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 0;
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                              LINEERR_STRUCTURETOOSMALL,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize =
+        sizeof(LINEAGENTGROUPLIST)-1;
+
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=fixedSize-1",
+                  dwTestCase+1);
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                              LINEERR_STRUCTURETOOSMALL,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 0x7FFFFFFF;
+
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=realbig",
+                  dwTestCase+1);
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                              LINEERR_INVALPOINTER,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineSetAgentGroup(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Open with no proxy request.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentGroup unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTGROUP;
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Open with no proxy request",
+                  dwTestCase+1);
+	//
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                              LINEERR_OPERATIONUNAVAIL,
+                              TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineSetAgentGroup: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineSetAgentGroup  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/itlsas.c b/private/tapi/qa/trapper/itest/tline20/itlsas.c
new file mode 100644
index 000000000..d16c911c7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/itlsas.c
@@ -0,0 +1,949 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsas.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAgentState
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+#define ALLAGENTSTATE (LINEAGENTSTATE_LOGGEDOFF          |       \
+                       LINEAGENTSTATE_NOTREADY           |       \
+                       LINEAGENTSTATE_READY              |       \
+                       LINEAGENTSTATE_BUSYACD            |       \
+                       LINEAGENTSTATE_BUSYINCOMING       |       \
+                       LINEAGENTSTATE_BUSYOUTBOUND       |       \
+                       LINEAGENTSTATE_BUSYOTHER          |       \
+                       LINEAGENTSTATE_WORKINGAFTERCALL   |       \
+                       LINEAGENTSTATE_UNKNOWN            |       \
+                       LINEAGENTSTATE_UNAVAIL)
+
+
+//  lineSetAgentState
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hLine
+// 3. BitVectorParamErrorTest for dwAgentState
+// 4. BitVectorParamErrorTest for dwNextAgentState
+// 5. BitVectorParamValidTest for dwAgentState
+// 6. BitVectorParamValidTest for dwNextAgentState
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAgentState(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+    LPDWORD	lpRequestBuf;
+    LONG lret;
+    LPTAPIMSG lpTapiMsg = NULL;
+    LPTAPIMSG lpMatch;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test LineSetAgentState");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentState unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Go/No-Go Test",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+    lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    if (! DoLineSetAgentState(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+    lpMatch->dwMsg = LINE_PROXYREQUEST;
+//  lpMatch->dwParam1 = (DWORD) lpProxyBuffer;
+    lpMatch->dwParam2 = 0;
+    lpMatch->dwParam3 = 0;
+    lpMatch->dwFlags = TAPIMSG_DWMSG;
+
+    lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+    TapiLogDetail(DBUG_SHOW_DETAIL,"##lret = %lx", lret);
+	
+    if(lret == 1)
+    {
+        lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+        lpTapiLineTestInfo->dwResult = 0;
+        TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+        if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+
+        AddMessage (LINE_REPLY,
+                    0,
+                    0,
+                    0,
+                    lpTapiLineTestInfo->dwResult,
+                    0,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+        WaitForAllMessages();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hLine.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentState unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad hLine",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+    lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    //
+    // save previous hLine
+    //
+
+    lpTapiLineTestInfo->hLine_Orig = lpTapiLineTestInfo->hLine1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiLineTestInfo->lphLine = (HLINE)gdwInvalidHandles[i];
+        if (! DoLineSetAgentState(lpTapiLineTestInfo,
+                                  LINEERR_INVALLINEHANDLE,
+                                  FALSE))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    //
+    // Reset hLine
+    //
+
+    lpTapiLineTestInfo->hLine1 = lpTapiLineTestInfo->hLine_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: BitVectorParamErrorTest for dwAgentState.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentState unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld:BitVectorParamErrorTest for dwAgentState",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = 0;
+    lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    //
+    // BitVectorParamErrorTest for dwAgentState
+    //
+
+    if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetAgentState,
+            (LPDWORD) &lpTapiLineTestInfo->dwAgentState,
+            LINEERR_INVALAGENTSTATE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_16,
+            ALLAGENTSTATE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_16],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: BitVectorParamErrorTest for dwNextAgentState.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentState unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld:BitVectorParamErrorTest for dwNextAgentState",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+    lpTapiLineTestInfo->dwNextAgentState = 0;
+
+    //
+    // BitVectorParamErrorTest for dwNextAgentState
+    //
+
+    if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetAgentState,
+            (LPDWORD) &lpTapiLineTestInfo->dwNextAgentState,
+            LINEERR_INVALAGENTSTATE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_16,
+            ALLAGENTSTATE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_16],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: BitVectorParamValidTest for dwAgentState.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentState unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld:BitVectorParamValidTest for dwAgentState",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = 0;
+    lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    //
+    // BitVectorParamValidTest for dwAgentState
+    //
+
+    if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetAgentState,
+            (LPDWORD) &lpTapiLineTestInfo->dwAgentState,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALLAGENTSTATE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: BitVectorParamValidTest for dwNextAgentState.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+
+    //
+    // Initialize a line app
+    //
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID =
+        (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "## LineSetAgentState unimodem didn't support");
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    //
+    // Negotiate the API Ext Version
+    //
+
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    //
+    // Open a line
+    //
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+													LINEOPENOPTION_PROXY;
+    lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+    lpTapiLineTestInfo->lpCallParams->dwTotalSize =
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize =
+						sizeof(DWORD);
+    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset =
+						sizeof(LINECALLPARAMS);
+    lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  +
+                    lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+    *lpRequestBuf = LINEPROXYREQUEST_SETAGENTSTATE;
+
+		
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld:BitVectorParamValidTest for dwNextAgentState",
+                  dwTestCase+1);
+
+    //
+    // Set the line device capabilities
+    //
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+    lpTapiLineTestInfo->dwNextAgentState = 0;
+
+    //
+    // BitVectorParamValidTest for dwNextAgentState
+    //
+
+    if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetAgentState,
+            (LPDWORD) &lpTapiLineTestInfo->dwNextAgentState,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALLAGENTSTATE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineSetAgentState: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineSetAgentState  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tline20/line20.c b/private/tapi/qa/trapper/itest/tline20/line20.c
new file mode 100644
index 000000000..124ed2c88
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/line20.c
@@ -0,0 +1,440 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    line20.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "line20.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTline20Dll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+Tline20DllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTline20Dll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninitialize(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAgentSpecific(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentCaps(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentActivityList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentGroupList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentStatus(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineProxyMessage(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineProxyResponse(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAgentActivity(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAgentGroup(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAgentState(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineInitializeEx(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetMessage(TRUE, FALSE));
+}
+
+
+
+VOID
+TapiShowProxyBuffer( LPLINEPROXYREQUEST lpProxyBuffer)
+{
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## lpProxyBuffer = %lx",
+			lpProxyBuffer);
+
+		TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"## dwSize = %lx, dwRequestType = %lx",
+		lpProxyBuffer->dwSize,
+		lpProxyBuffer->dwRequestType);
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## dwClientMachineNameSize = %lx, dwClientMachineNameOffset = %lx",
+			lpProxyBuffer->dwClientMachineNameSize,
+			lpProxyBuffer->dwClientMachineNameOffset);
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## dwClientUserNameSize = %lx, dwClientUserNameOffset = %lx",
+			lpProxyBuffer->dwClientUserNameSize,
+			lpProxyBuffer->dwClientUserNameOffset);
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## dwClientAppAPIVersion = %lx", 
+			lpProxyBuffer->dwClientAppAPIVersion);
+		
+		/*
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"username= %ls",
+			((LPBYTE)lpProxyBuffer)+lpProxyBuffer->dwClientUserNameOffset);
+		*/
+
+		TapiShowAgent(lpProxyBuffer);
+}
+
+
+VOID 
+TapiShowAgent(LPLINEPROXYREQUEST lpProxyBuffer)
+{
+	switch(lpProxyBuffer->dwRequestType)
+	{
+		case LINEPROXYREQUEST_SETAGENTGROUP:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->SetAgentGroup.GroupList.dwTotalSize,
+			lpProxyBuffer->SetAgentGroup.GroupList.dwNeededSize);
+				break;
+
+		case LINEPROXYREQUEST_SETAGENTSTATE:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwAgentState = %lx, dwNextAgentState = %lx",
+			lpProxyBuffer->SetAgentState.dwAgentState,
+			lpProxyBuffer->SetAgentState.dwNextAgentState);
+				break;
+
+		case LINEPROXYREQUEST_SETAGENTACTIVITY:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwAddressID = %lx, dwActivityID = %lx",
+			lpProxyBuffer->SetAgentActivity.dwAddressID,
+			lpProxyBuffer->SetAgentActivity.dwActivityID);
+			break;
+
+
+		case LINEPROXYREQUEST_GETAGENTCAPS:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentCaps.AgentCaps.dwTotalSize,
+			lpProxyBuffer->GetAgentCaps.AgentCaps.dwNeededSize);
+			break;
+
+		case LINEPROXYREQUEST_GETAGENTSTATUS:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentStatus.AgentStatus.dwTotalSize,
+			lpProxyBuffer->GetAgentStatus.AgentStatus.dwNeededSize);
+				break;
+
+		case LINEPROXYREQUEST_AGENTSPECIFIC:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwAgentExtensionIDIndex = %lx",
+			lpProxyBuffer->AgentSpecific.dwAgentExtensionIDIndex);
+				break;
+
+		case LINEPROXYREQUEST_GETAGENTACTIVITYLIST:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentActivityList.ActivityList.dwTotalSize,
+			lpProxyBuffer->GetAgentActivityList.ActivityList.dwNeededSize);
+
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwNumentries = %lx",
+			lpProxyBuffer->GetAgentActivityList.ActivityList.dwNumEntries);
+			
+		break;
+
+		case LINEPROXYREQUEST_GETAGENTGROUPLIST:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentGroupList.GroupList.dwTotalSize,
+			lpProxyBuffer->GetAgentGroupList.GroupList.dwNeededSize);
+				break;
+
+	}
+	
+}
+
+
+BOOL
+ShouldTapiPhoneTestAbort(BOOL fQuiteMode)
+{
+	return FALSE;
+}
diff --git a/private/tapi/qa/trapper/itest/tline20/line20.h b/private/tapi/qa/trapper/itest/tline20/line20.h
new file mode 100644
index 000000000..e698d4c2a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/line20.h
@@ -0,0 +1,266 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    line20.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding 	(XiaoD) 29-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef LINE20_H
+#define LINE20_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineAgentSpecific(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentCaps(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentActivityList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentGroupList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAgentStatus(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineProxyMessage(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineProxyResponse(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineSetAgentActivity(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAgentGroup(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAgentState(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineInitializeEx(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineGetMessage(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL 
+TestLineUninitialize(
+    BOOL fQuietMode, 
+    BOOL fStandAlone
+    );
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    );
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    );
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    );
+
+VOID
+TapiShowProxyBuffer( LPLINEPROXYREQUEST);
+
+VOID 
+TapiShowAgent(LPLINEPROXYREQUEST );
+
+
+
+#endif  // LINE20_H
diff --git a/private/tapi/qa/trapper/itest/tline20/tline20.def b/private/tapi/qa/trapper/itest/tline20/tline20.def
new file mode 100644
index 000000000..1f5fc2791
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/tline20.def
@@ -0,0 +1,23 @@
+LIBRARY         tline20
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
diff --git a/private/tapi/qa/trapper/itest/tline20/tline20.inc b/private/tapi/qa/trapper/itest/tline20/tline20.inc
new file mode 100644
index 000000000..914f58c54
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/tline20.inc
@@ -0,0 +1,69 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tline20
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+DLLDEF=..\tline20.def
+DLLBASE=0x69000000
+
+INCLUDES=..\..;..;..\..\..\..\tcore;..\..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=..\line20.c \
+		..\itlas.c	 \
+		..\itlgac.c \
+		..\itlgaal.c \
+		..\itlgagl.c \
+		..\itlgas.c \
+		..\itlpm.c \
+		..\itlpr.c \
+		..\itlsaa.c \
+		..\itlsag.c \
+		..\itlsas.c \
+		..\itlie.c  \
+		..\itlgm.c  \
+        ..\uline.c  \
+        ..\version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=Tline20DllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tline20/tline20a/makefile b/private/tapi/qa/trapper/itest/tline20/tline20a/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/tline20a/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tline20/tline20a/sources b/private/tapi/qa/trapper/itest/tline20/tline20a/sources
new file mode 100644
index 000000000..21e4d3e10
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/tline20a/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tline20.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/tline20/tline20w/makefile b/private/tapi/qa/trapper/itest/tline20/tline20w/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/tline20w/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tline20/tline20w/sources b/private/tapi/qa/trapper/itest/tline20/tline20w/sources
new file mode 100644
index 000000000..9a7595268
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/tline20w/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tline20.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tline20/uline.c b/private/tapi/qa/trapper/itest/tline20/uline.c
new file mode 100644
index 000000000..c7b0e3313
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/uline.c
@@ -0,0 +1,431 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpr.c
+
+Abstract:
+
+    This module contains the test functions for lineProxyResponse
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "line20.h"
+
+//
+// UnInitialize tests
+//
+
+BOOL TestLineUninitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineUninitialize");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: lineAgentSpecific uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineAgentSpecific uninit test",
+        dwTestCase+1);
+
+    if (! DoLineAgentSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: LineGetAgentActivityList uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentActivityList uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize =
+        sizeof(LINEAGENTACTIVITYLIST);
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: LineGetAgentCaps uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentCaps uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_UNINITIALIZED,
+                             FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: LineGetAgentGroupList uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentGroupList uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList =
+        (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize =
+        sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                                  LINEERR_UNINITIALIZED,
+                                  FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: LineGetAgentStatus uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentStatus uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_UNINITIALIZED,
+                               FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: LineGetMessage uninit test(returns INVALAPPHANDLE).
+    //               see raid bug #33177(4/10/1996)
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetMessage uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE) AllocFromTestHeap (
+        sizeof(LINEMESSAGE));
+
+    if (! DoLineGetMessage(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: LineProxyMessage uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineProxyMessage uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo,
+                             LINEERR_UNINITIALIZED))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: LineProxyResponse uninit test(returns INVALPOINTER).
+    //               see raid bug #33177(4/10/1996)
+    //
+    // ===================================================================
+    // ===================================================================
+    
+/*
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineProxyResponse uninit test",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) AllocFromTestHeap(
+        sizeof(LINEPROXYREQUEST));
+    lpTapiLineTestInfo->lpProxyRequest->dwSize =  sizeof(LINEPROXYREQUEST);
+    if (! DoLineProxyResponse(lpTapiLineTestInfo,
+                              LINEERR_INVALPOINTER))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+*/
+    
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: LineSetAgentActivity uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+    
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineSetAgentActivity uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->dwActivityID = 1;
+
+    if (! DoLineSetAgentActivity(lpTapiLineTestInfo,
+                                 LINEERR_UNINITIALIZED,
+                                 FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+    // ===================================================================
+    // ===================================================================
+    //
+    // 10. Test Case: LineSetAgentGroup uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineSetAgentGroup uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                              LINEERR_UNINITIALIZED,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 11. Test Case: LineSetAgentState uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineSetAgentState uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+    lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    if (! DoLineSetAgentState(lpTapiLineTestInfo,
+                              LINEERR_UNINITIALIZED,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineUnitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineUnitialize  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tline20/version.rc b/private/tapi/qa/trapper/itest/tline20/version.rc
new file mode 100644
index 000000000..420f96b38
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tline20/version.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI Line 2.0 API test Library"
+#define VER_INTERNALNAME_STR        "tline20.dll"
+#define VER_ORIGINALFILENAME_STR    "tline20.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/tphone/dirs b/private/tapi/qa/trapper/itest/tphone/dirs
new file mode 100644
index 000000000..ce1caddd0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/dirs
@@ -0,0 +1,2 @@
+DIRS= tphonea \
+      tphonew 
diff --git a/private/tapi/qa/trapper/itest/tphone/itpc.c b/private/tapi/qa/trapper/itest/tphone/itpc.c
new file mode 100644
index 000000000..f30e1b55e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpc.c
@@ -0,0 +1,1553 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpc.c
+
+Abstract:
+
+    This module contains the test functions for phoneClose
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+     pgopi           March 1996                Added additional tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneClose
+//
+//  The following tests are made:
+//
+//    Test
+//  -----------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. *Verify Closed hPhone No longer Valid
+// 3. Bad hPhone
+// 4. Verify PHONESTATE_MONITOR msgs sent to other monitor on same hPhoneApp
+// 5. Verify PHONESTATE_MONITOR msgs sent to owner on different hPhoneApp
+// 6. Verify PHONESTATE_OWNER msgs sent to other monitor on same hPhoneApp
+// 7. Verify PHONESTATE_MONITOR msgs sent to monitor on different hPhoneApp
+// 8. Verify PHONESTATE_MONITOR msgs sent to owner on different hPhoneApp
+// 9. Verify PHONESTATE_OWNER msgs sent to monitor on different hPhoneApp
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneClose(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT n;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+
+
+    BOOL fTestPassed                  = TRUE;
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>>> Test phoneClose <<<<<<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go tests
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go Test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld for go/no-go ",
+        dwTestCase+1);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: This next test, tests if phoneClose returns
+    // PHONEERR_INVALPHONEHANDLE when an already closed handle is closed
+    // again(without doing a open).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld : Verify closed hPhone no"
+        " longer valid(try phoneClose agaian). ",
+        dwTestCase+1);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, PHONEERR_INVALPHONEHANDLE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: The next test tries to close an invalid hPhone.
+    // phoneClose should return  PHONEERR_INVALPHONEHANDLE.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    {
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            "#### Test case %ld :  Bad hPhone",
+            dwTestCase+1);
+        //
+        // Try the close of a hPhone which is invalid.
+        // lphPhone is initialized to point to hPhone1, so set it to an invalid
+        // value (e.g. the hPhoneApp value).
+        //
+
+        lpTapiPhoneTestInfo->hPhone1 =
+            (HPHONE) *lpTapiPhoneTestInfo->lphPhoneApp;
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+        fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Verify PHONESTATE_MONITOR msgs sent to other
+    // monitor on same hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    if(fStandAlone)
+    {
+        TapiPhoneTestInit();
+        lpTapiPhoneTestInfo = GetPhoneTestInfo();
+        lpCallbackParams = GetCallbackParams();
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            "#### Test case %ld : Verify PHONESTATE_MONITOR msgs sent"
+            " to other monitor on same hPhoneApp.",
+            dwTestCase+1);
+
+        //
+        // Initialize a phone app
+        //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Negotiate the API Version
+        //
+
+        lpTapiPhoneTestInfo->dwDeviceID =
+            (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+            0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+        lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+        lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Get the phone device capabilities
+        //
+
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+                                            sizeof(PHONECAPS)
+                                            );
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a phone
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Set the status messages to allow hphone1 to receive
+        // PHONESTATE_OWNER/MONITORS msgs.
+        //
+
+        lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_MONITORS |
+                                              PHONESTATE_OWNER;
+        lpTapiPhoneTestInfo->dwButtonModes  = 0;
+        lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+        if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a second monitor on with the same hPhoneApp.Save the original
+        // hPhone in hPhone2.
+        //
+
+        lpTapiPhoneTestInfo->hPhone2 = *lpTapiPhoneTestInfo->lphPhone;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Now close the second monitor and verify that PHONESTATE_MONITORS
+        // status message is sent to the first monitor.
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Restore the saved hPhone2 to hPhone1.
+        //
+
+        lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone2;
+
+        //
+        // Add the PHONESTATE_MONITORS message to the list of expected
+        // messages.
+        //
+
+        AddMessage(
+            PHONE_STATE,
+            (DWORD) lpTapiPhoneTestInfo->hPhone2,
+            (DWORD) lpCallbackParams,
+            PHONESTATE_MONITORS,
+            0x00000000,
+            0x00000000,
+            (TAPIMSG_DWMSG |
+             TAPIMSG_HDEVCALL |
+             TAPIMSG_DWCALLBACKINST |
+             TAPIMSG_DWPARAM1)
+            );
+
+        //
+        // Wait for the PHONESTATE_MONITORS message
+        //
+
+        if (! WaitForAllMessages())
+        {
+            TPHONE_FAIL();
+        }
+
+
+        fTestPassed = ShowTestCase(fTestPassed);
+
+        //
+        // Now close the first monitor .
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown to isolate the test case
+        //
+
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        FreeTestHeap();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Verify PHONESTATE_MONITOR msgs sent to
+    // owner on same hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    if(fStandAlone)
+    {
+        TapiPhoneTestInit();
+        lpTapiPhoneTestInfo = GetPhoneTestInfo();
+        lpCallbackParams = GetCallbackParams();
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            "#### Test case %ld : Verify PHONESTATE_MONITOR msgs sent"
+            " to owner on same hPhoneApp.",
+            dwTestCase+1);
+
+        //
+        // Initialize a phone app
+        //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Negotiate the API Version
+        //
+
+        lpTapiPhoneTestInfo->dwDeviceID =
+            (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+            0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+        lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+        lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Get the phone device capabilities
+        //
+
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+                                            sizeof(PHONECAPS)
+                                            );
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a phone with owner privilege
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Set the status messages to allow hphone1 to receive
+        // PHONESTATE_OWNER/MONITORS msgs.
+        //
+
+        lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_MONITORS |
+                                              PHONESTATE_OWNER;
+        lpTapiPhoneTestInfo->dwButtonModes  = 0;
+        lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+        if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a  monitor on  the same hPhoneApp.Save the original
+        // hPhone in hPhone2.
+        //
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+        lpTapiPhoneTestInfo->hPhone2 = *lpTapiPhoneTestInfo->lphPhone;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Now close the  monitor and verify that PHONESTATE_MONITORS
+        // status message is sent to the owner.
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Restore the saved hPhone2 to hPhone1.
+        //
+
+        lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone2;
+
+        //
+        // Add the PHONESTATE_MONITORS message to the list of expected
+        // messages.
+        //
+
+        AddMessage(
+            PHONE_STATE,
+            (DWORD) lpTapiPhoneTestInfo->hPhone2,
+            (DWORD) lpCallbackParams,
+            PHONESTATE_MONITORS,
+            0x00000000,
+            0x00000000,
+            (TAPIMSG_DWMSG |
+             TAPIMSG_HDEVCALL |
+             TAPIMSG_DWCALLBACKINST |
+             TAPIMSG_DWPARAM1)
+            );
+
+        //
+        // Wait for the PHONESTATE_MONITORS message
+        //
+
+        if (! WaitForAllMessages())
+        {
+            TPHONE_FAIL();
+        }
+
+
+        fTestPassed = ShowTestCase(fTestPassed);
+
+        //
+        // Now close the owner .
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown
+        //
+
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        FreeTestHeap();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Verify PHONESTATE_OWNER msgs sent to a
+    // monitor on same hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    if(fStandAlone)
+    {
+        TapiPhoneTestInit();
+        lpTapiPhoneTestInfo = GetPhoneTestInfo();
+        lpCallbackParams = GetCallbackParams();
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            "#### Test case %ld : Verify PHONESTATE_OWNER msgs sent "
+            "to a monitor on same hPhoneApp.",
+            dwTestCase+1);
+
+        //
+        // Initialize a phone app
+        //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Negotiate the API Version
+        //
+
+        lpTapiPhoneTestInfo->dwDeviceID =
+            (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+            0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+        lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+        lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Get the phone device capabilities
+        //
+
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+                                            sizeof(PHONECAPS)
+                                            );
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a phone
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Set the status messages to allow hphone1 to receive
+        // PHONESTATE_OWNER/MONITORS msgs.
+        //
+
+        lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_MONITORS |
+                                              PHONESTATE_OWNER;
+        lpTapiPhoneTestInfo->dwButtonModes  = 0;
+        lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+        if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a owner on  the same hPhoneApp.Save the original
+        // hPhone in hPhone2.
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+        lpTapiPhoneTestInfo->hPhone2 = *lpTapiPhoneTestInfo->lphPhone;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Now close the owner and verify that PHONESTATE_OWNER
+        // status message is sent to the  monitor.
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Restore the saved hPhone2 to hPhone1.
+        //
+
+        lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone2;
+
+        //
+        // Add the PHONESTATE_OWNER message to the list of expected
+        // messages.
+        //
+
+        AddMessage(
+            PHONE_STATE,
+            (DWORD) lpTapiPhoneTestInfo->hPhone2,
+            (DWORD) lpCallbackParams,
+            PHONESTATE_OWNER,
+            0x00000000,
+            0x00000000,
+            (TAPIMSG_DWMSG |
+             TAPIMSG_HDEVCALL |
+             TAPIMSG_DWCALLBACKINST |
+             TAPIMSG_DWPARAM1)
+            );
+
+        //
+        // Wait for the PHONESTATE_OWNER message
+        //
+
+        if (! WaitForAllMessages())
+        {
+            TPHONE_FAIL();
+        }
+
+
+        fTestPassed = ShowTestCase(fTestPassed);
+
+        //
+        // Now close the first monitor .
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown to isolate the test case
+        //
+
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        FreeTestHeap();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Verify PHONESTATE_MONITORS msgs sent to
+    // monitor on different hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    if(fStandAlone)
+    {
+        TapiPhoneTestInit();
+        lpTapiPhoneTestInfo = GetPhoneTestInfo();
+        lpCallbackParams = GetCallbackParams();
+
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "#### Test case %ld : Verify PHONESTATE_MONITOR msgs sent "
+           "to monitor on different hPhoneApp.",
+           dwTestCase+1);
+
+        //
+        // Initialize a phone app
+        //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Initialize another phoneApp, save the previous one in
+        // hPhoneApp2.
+        //
+
+        lpTapiPhoneTestInfo->hPhoneApp2 = *lpTapiPhoneTestInfo->lphPhoneApp;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+	     {
+	         TPHONE_FAIL();
+        }
+
+        lpTapiPhoneTestInfo->dwDeviceID =
+            (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+            0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+        lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+        lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+        //
+        // Negotiate the API Version
+        //
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Get the phone device capabilities
+        //
+
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+                                            sizeof(PHONECAPS)
+                                            );
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a phone on hPhoneApp1
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Set the status messages to allow hphone1 to receive
+        // PHONESTATE_OWNER/MONITORS msgs.
+        //
+
+        lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_MONITORS |
+                                              PHONESTATE_OWNER;
+        lpTapiPhoneTestInfo->dwButtonModes  = 0;
+        lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+        if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a second monitor on  the different phone app (hPhoneApp2).
+        //
+
+        lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Now close the second monitor and verify that PHONESTATE_MONITORS
+        // status message is sent to the first monitor.
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Reset the handles to hPhone1 and hPhoneApp1.
+        //
+
+        lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+
+
+        //
+        // Add the PHONESTATE_MONITORS message to the list of expected
+        // messages.
+        //
+
+        AddMessage(
+            PHONE_STATE,
+            (DWORD) lpTapiPhoneTestInfo->hPhone1,
+            (DWORD) lpCallbackParams,
+            PHONESTATE_MONITORS,
+            0x00000000,
+            0x00000000,
+            (TAPIMSG_DWMSG |
+             TAPIMSG_HDEVCALL |
+             TAPIMSG_DWCALLBACKINST |
+             TAPIMSG_DWPARAM1)
+            );
+
+        //
+        // Wait for the PHONESTATE_MONITORS message
+        //
+
+        if (! WaitForAllMessages())
+        {
+            TPHONE_FAIL();
+        }
+
+
+        fTestPassed = ShowTestCase(fTestPassed);
+
+        //
+        // Now close the first monitor .
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown hPhoneApp1.
+        //
+
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown hPhoneApp2.
+        //
+
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        FreeTestHeap();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Verify PHONESTATE_MONITORS msgs sent to
+    // owner on different hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    if(fStandAlone)
+    {
+        TapiPhoneTestInit();
+        lpTapiPhoneTestInfo = GetPhoneTestInfo();
+        lpCallbackParams = GetCallbackParams();
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            "#### Test case %ld : Verify PHONESTATE_MONITOR msgs sent "
+            "to owner on different hPhoneApp.",
+            dwTestCase+1);
+
+        //
+        // Initialize a phone app
+        //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Initialize another phoneApp, save the previous one in
+        // hPhoneApp2.
+        //
+
+        lpTapiPhoneTestInfo->hPhoneApp2 = *lpTapiPhoneTestInfo->lphPhoneApp;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Negotiate the API Version
+        //
+
+        lpTapiPhoneTestInfo->dwDeviceID =
+            (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+            0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+        lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+        lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Get the phone device capabilities
+        //
+
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+                                            sizeof(PHONECAPS)
+                                            );
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a phone on hPhoneApp1 with owner privilege.
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Set the status messages to allow hphone1 to receive
+        // PHONESTATE_OWNER/MONITORS msgs.
+        //
+
+        lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_MONITORS |
+                                              PHONESTATE_OWNER;
+        lpTapiPhoneTestInfo->dwButtonModes  = 0;
+        lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+        if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a  monitor on  a different phone app (hPhoneApp2).
+        //
+
+        lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Now close the  monitor and verify that PHONESTATE_MONITORS
+        // status message is sent to the owner.
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Reset the handles to hPhone1 and hPhoneApp1.
+        //
+
+        lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+
+
+        //
+        // Add the PHONESTATE_MONITORS message to the list of expected
+        // messages.
+        //
+
+        AddMessage(
+            PHONE_STATE,
+            (DWORD) lpTapiPhoneTestInfo->hPhone1,
+            (DWORD) lpCallbackParams,
+            PHONESTATE_MONITORS,
+            0x00000000,
+            0x00000000,
+            (TAPIMSG_DWMSG |
+             TAPIMSG_HDEVCALL |
+             TAPIMSG_DWCALLBACKINST |
+             TAPIMSG_DWPARAM1)
+            );
+
+        //
+        // Wait for the PHONESTATE_MONITORS message
+        //
+
+        if (! WaitForAllMessages())
+        {
+            TPHONE_FAIL();
+        }
+
+
+        fTestPassed = ShowTestCase(fTestPassed);
+
+        //
+        // Now close the  owner .
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown hPhoneApp1.
+        //
+
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown hPhoneApp2.
+        //
+
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        FreeTestHeap();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: Verify PHONESTATE_OWNER msgs sent to
+    // monitor on different hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    fTestPassed                  = TRUE;
+
+    if(fStandAlone)
+    {
+        TapiPhoneTestInit();
+        lpTapiPhoneTestInfo = GetPhoneTestInfo();
+        lpCallbackParams = GetCallbackParams();
+
+        TapiLogDetail(
+            DBUG_SHOW_PASS,
+            "#### Test case %ld : Verify PHONESTATE_OWNER msgs sent "
+            "to monitor on different hPhoneApp.",
+            dwTestCase+1);
+
+        //
+        // Initialize a phone app
+        //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Initialize another phoneApp, save the previous one in
+        // hPhoneApp2.
+        //
+
+        lpTapiPhoneTestInfo->hPhoneApp2 = *lpTapiPhoneTestInfo->lphPhoneApp;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+        if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Negotiate the API Version
+        //
+
+	    lpTapiPhoneTestInfo->dwDeviceID =
+            (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+            0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+        lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+        lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Get the phone device capabilities
+        //
+
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+                                            sizeof(PHONECAPS)
+                                            );
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a phone on hPhoneApp1
+        //
+
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Set the status messages to allow hphone1 to receive
+        // PHONESTATE_OWNER/MONITORS msgs.
+        //
+
+        lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_MONITORS |
+                                              PHONESTATE_OWNER;
+        lpTapiPhoneTestInfo->dwButtonModes  = 0;
+        lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+        if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Open a second monitor on  the different phone app (hPhoneApp2).
+        //
+        lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+        lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Now close the second monitor and verify that PHONESTATE_OWNER
+        // status message is sent to the first monitor.
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Reset the handles to hPhone1 and hPhoneApp1.
+        //
+
+        lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+
+
+        //
+        // Add the PHONESTATE_OWNER message to the list of expected
+        // messages.
+        //
+
+        AddMessage(
+            PHONE_STATE,
+            (DWORD) lpTapiPhoneTestInfo->hPhone1,
+            (DWORD) lpCallbackParams,
+            PHONESTATE_OWNER,
+            0x00000000,
+            0x00000000,
+            (TAPIMSG_DWMSG |
+             TAPIMSG_HDEVCALL |
+             TAPIMSG_DWCALLBACKINST |
+             TAPIMSG_DWPARAM1)
+            );
+
+        //
+        // Wait for the PHONESTATE_OWNER message
+        //
+
+        if (! WaitForAllMessages())
+        {
+            TPHONE_FAIL();
+        }
+
+
+        fTestPassed = ShowTestCase(fTestPassed);
+
+        //
+        // Now close the first monitor .
+        //
+
+        if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown hPhoneApp1.
+        //
+
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        //
+        // Shutdown hPhoneApp2.
+        //
+
+        lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+        if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+        {
+            TPHONE_FAIL();
+        }
+
+        FreeTestHeap();
+    }
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 10. Test Case: generate a PHONE_CLOSE message and try to open
+    //                the phone device again.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld : Generate PHONE_CLOSE msg and try to open"
+        " hPhone -- should succeed",
+        dwTestCase+1);
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = PHONE_CLOSE;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiPhoneTestInfo->lpParams = &info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the PHONESTATE_CLOSE message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_CLOSE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               0x00000000,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG));
+
+    if(!DoPhoneDevSpecific(lpTapiPhoneTestInfo,TAPISUCCESS,TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TPHONE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "TestPhoneClose: Did not receive PHONE_CLOSE message.");
+    }
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, PHONEERR_INVALPHONEHANDLE))
+    {
+        TPHONE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+    
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneClose: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    TapiLogDetail(DBUG_SHOW_PASS,">>>>>>>>  End testing PhoneClose  <<<<<<");
+
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tphone/itpcd.c b/private/tapi/qa/trapper/itest/tphone/itpcd.c
new file mode 100644
index 000000000..146f49bac
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpcd.c
@@ -0,0 +1,740 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpcd.c
+
+Abstract:
+
+    This module contains the test functions for phoneConfigDialog
+
+Author:
+
+    Xiao Ying Ding                  (XiaoD)     05-Dec-1995
+
+
+Revision History:
+
+    pgopi        March 1996          added additional tests
+	a-ramako	 5-April-96			 added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+// extern HANDLE ghTphoneDll;
+
+
+//  phoneConfigDialog
+//
+//  The following tests are made:
+//
+//   Test                                              Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad hwndOwner
+// 4. Bad lpszDeviceClass
+// 5. Invalid lpszDeviceclass
+// 6. NULL lpszDeviceClass
+// 7. Empty lpszDeviceClass string("").
+// * = Stand-alone test case
+//
+//
+void
+CALLBACK
+AutoDismissTranslateDlgTimerProc(
+    HWND    hwnd,
+    UINT    msg,
+    UINT    idTimer,
+    DWORD   dwTime
+    );
+
+BOOL
+PrepareToAutoDismissTranslateDlg(
+    LPTAPIPHONETESTINFO    lpTapiPhoneTestInfo,
+    BOOL bEnable
+    );
+
+#define DLG_TITLE "TUISPI_phoneConfigDialog"
+#define TIMEOUT   1000
+
+UINT uiTimer;
+
+BOOL TestPhoneConfigDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    BOOL fTestPassed                  = TRUE;
+    
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+		  "****************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+		  ">>>>>>>>>>>>>>>>> Test phoneConfigDialog <<<<<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go / No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+	    "#### Test case %ld: phoneConfigDialog for go/no-go",
+        dwTestCase+1);
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, TRUE);
+
+    if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, FALSE);
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad deviceId.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad deviceId(-1)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDeviceID =  (DWORD)-1;
+
+    //
+    // Call phoneConfigDialog
+    //
+
+    if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad deviceId(numDevs)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDeviceID =  *(lpTapiPhoneTestInfo->lpdwNumDevs);
+
+    //
+    // Call phoneConfigDialog
+    //
+
+    if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hwndOwner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+    //
+    // Choose an invalid handle to window owner
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hwndOwner",
+        dwTestCase+1);
+
+    //
+    // zero is a valid hwndOwner, so we start from index 1 as
+    // gdwInvalidHandles[0] is equal to 0.
+    //
+
+    for(i=1; i < NUMINVALIDHANDLES; i++)
+    {
+        lpTapiPhoneTestInfo->hwndOwner = (HWND)gdwInvalidHandles[i];
+
+        if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo,
+                                  PHONEERR_INVALPARAM))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpszDeviceClass.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpwszDeviceClass",
+        dwTestCase+1);
+#else
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpszDeviceClass",
+        dwTestCase+1);
+#endif
+
+    //
+    // Give a bad pointer to lpszDeviceClass(Null is  valid value so we
+    // start the index fom 1 since,  gdwInvalidPointers[0] is a null value)
+    //
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiPhoneTestInfo->lpwszDeviceClass = (LPWSTR) gdwInvalidPointers[i];
+#else
+        lpTapiPhoneTestInfo->lpszDeviceClass = (LPSTR) gdwInvalidPointers[i];
+#endif
+
+        if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo,
+                                  PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Invalid Device Class
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"junk-device-class";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "junk-device-class";
+#endif
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Invalid Device Class",
+        dwTestCase+1);
+
+    //
+    // Call phoneConfigDialog
+    //
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, TRUE);
+
+    if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, FALSE);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: NULL lpszDeviceClass .
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+    //
+    // empty string
+    //
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = NULL;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: NULL lpwszDeviceClass",
+        dwTestCase+1);
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = NULL;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: NULL lpszDeviceClass",
+        dwTestCase+1);
+#endif
+
+    //
+    // Call phoneConfigDialog
+    //
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, TRUE);
+
+    if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, FALSE);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: empty lpszDeviceClass string("").
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+    //
+    // empty string
+    //
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: empty lpwszDeviceClass string",
+        dwTestCase+1);
+
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "";
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: empty lpszDeviceClass string",
+        dwTestCase+1);
+
+#endif
+
+    //
+    // Call phoneConfigDialog
+    //
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, TRUE);
+
+    if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    PrepareToAutoDismissTranslateDlg (lpTapiPhoneTestInfo, FALSE);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneConfigDialog: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneConfigDialog  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+void
+CALLBACK
+AutoDismissTranslateDlgTimerProc(
+    HWND    hwnd,
+    UINT    msg,
+    UINT    idTimer,
+    DWORD   dwTime
+    )
+{
+    HWND hwndChild = GetWindow (GetDesktopWindow(), GW_CHILD);
+
+
+    while (hwndChild)
+    {
+        char buf[32];
+
+
+        GetWindowText (hwndChild, buf, 31);
+
+        if (strcmp (buf, DLG_TITLE) == 0)
+        {
+            break;
+        }
+
+        hwndChild = GetWindow (hwndChild, GW_HWNDNEXT);
+    }
+
+    if (hwndChild)
+    {
+        //
+        // We found the right hwnd, so nuke the timer, post a
+        // <ENTER> key msg to dismiss the dlg, & reset the global
+        // uiTimer to zero so we don't try to kill the timer again
+        //
+
+        KillTimer ((HWND) NULL, idTimer);
+        PostMessage (hwndChild, WM_KEYDOWN, 0x0D, 0x00010001); // <ENTER> key
+        uiTimer = 0;
+    }
+}
+
+
+BOOL
+PrepareToAutoDismissTranslateDlg(
+    LPTAPIPHONETESTINFO    lpTapiPhoneTestInfo,
+    BOOL bEnable
+    )
+{
+    if (bEnable)
+    {
+        if (!(uiTimer = SetTimer(
+                (HWND) NULL,
+                0,
+                TIMEOUT,
+                (TIMERPROC) AutoDismissTranslateDlgTimerProc
+                )))
+        {
+            TapiLogDetail(
+                DBUG_SHOW_FAILURE,
+                0,
+                (LPCSTR)"[TestPhoneConfigDialog] SetTimer failed"
+                );
+
+            return FALSE;
+        }
+    }
+    else if (uiTimer)
+    {
+        KillTimer ((HWND) NULL, uiTimer);
+    }
+
+    return TRUE;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpds.c b/private/tapi/qa/trapper/itest/tphone/itpds.c
new file mode 100644
index 000000000..6bfd5d424
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpds.c
@@ -0,0 +1,776 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpds.c
+
+Abstract:
+
+    This module contains the test functions for phoneDevSpecific
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi          March 1996           Added additional tests
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneDevSpecific
+//
+//  The following tests are made:
+//
+//   Test
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpParams
+// 4. Bad dwSize
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneDevSpecific(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i, n;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    BOOL fTestPassed                  = TRUE;
+    PHONEBUTTONINFO		TapiTestPhoneButtonInfo;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneDevSpecific <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go / No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneDevSpecfic for go/no-go",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&TapiTestPhoneButtonInfo;
+    lpTapiPhoneTestInfo->dwSize = sizeof(PHONEBUTTONINFO);
+
+    if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&TapiTestPhoneButtonInfo;
+    lpTapiPhoneTestInfo->dwSize = sizeof(PHONEBUTTONINFO);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPHONEHANDLE,
+                                 FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpParams(NULL).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpParams",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwSize = sizeof(PHONEBUTTONINFO);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpParams = (LPVOID)gdwInvalidPointers[i];
+
+        if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER,
+                                 FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+    //
+    // Negotiate the API Version
+    //
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwSize(0)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpParams = &TapiTestPhoneButtonInfo;
+
+    //
+    // give a bad dwSize
+    //
+
+    lpTapiPhoneTestInfo->dwSize = 0;
+
+    if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwSize(real big)", dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpParams = &TapiTestPhoneButtonInfo;
+
+    //
+    // give a bad dwSize
+    //
+
+    lpTapiPhoneTestInfo->dwSize = 0x7FFFFFFF;
+
+    if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPOINTER,
+                             FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    if ( ! DoPhoneDevSpecific(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 }
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneDevSpecific(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+    }
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneDevSpecific: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneDevSpecific  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgbi.c b/private/tapi/qa/trapper/itest/tphone/itpgbi.c
new file mode 100644
index 000000000..cd4ad5922
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgbi.c
@@ -0,0 +1,901 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgbi.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetButtonInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi          March 1996           added additional tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+//  phoneGetButtonInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. bad hPhone
+// 3. Bad lpButtonInfo
+// 4. Bad lpButtonInfo->dwTotalSize
+// 5. Success using hPhone with MONITOR privilege
+// 6. Verify returned data for hPhone with OWNER privilege
+//    (see tests for phoneSetButtonInfo)
+//
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetButtonInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    int i, n;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "*****************************************************************");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetButtonInfo <<<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go / No-Go test for OWNER.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetButtonInfo for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo =
+        (LPPHONEBUTTONINFO) AllocFromTestHeap(sizeof(PHONEBUTTONINFO));
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+    if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo =
+        (LPPHONEBUTTONINFO) AllocFromTestHeap(sizeof(PHONEBUTTONINFO));
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpButtonInfo(NULL).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpButtonInfo(NULL) for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+
+    //
+    // Bad lpButtonInfo
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpParams = (LPVOID)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo,
+                                  PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpButtonInfo->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo =
+        (LPPHONEBUTTONINFO) AllocFromTestHeap(sizeof(PHONEBUTTONINFO));
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpButtonInfo->dwTotalSize(0)",
+        dwTestCase+1);
+
+    //
+    // Bad lpButtonInfo->dwTotalSize(0).
+    //
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = 0;
+
+    if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo,
+                               PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpButtonInfo->dwTotalSize(fixed_size-1)",
+        dwTestCase+1);
+
+    //
+    // Bad lpButtonInfo->dwTotalSize(fixed_size-1).
+    //
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+        sizeof(PHONEBUTTONINFO)-1;
+
+    if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo,
+                               PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpButtonInfo->dwTotalSize(real big)",
+        dwTestCase+1);
+
+    //
+    // Bad lpButtonInfo->dwTotalSize(realbig).
+    //
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = 0x7FFFFFFF;
+
+    if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo,
+                               PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Go / No-Go test for MONITOR.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetButtonInfo for go/no-go for MONITOR",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo =
+        (LPPHONEBUTTONINFO) AllocFromTestHeap(sizeof(PHONEBUTTONINFO));
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+    if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo =
+        (LPPHONEBUTTONINFO) AllocFromTestHeap(sizeof(PHONEBUTTONINFO));
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+    if ( ! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo =
+        (LPPHONEBUTTONINFO) AllocFromTestHeap(sizeof(PHONEBUTTONINFO));
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+    if ( ! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetButtonInfo: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetButtonInfo  <<<<<<<<");
+
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+
+	 return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgd.c b/private/tapi/qa/trapper/itest/tphone/itpgd.c
new file mode 100644
index 000000000..6b4f2097e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgd.c
@@ -0,0 +1,895 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgd.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetData
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi            March 1996                Additional tests.
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+//  phoneGetData
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpData
+// 4. Bad dwSize
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetData(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetData <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go / No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: phoneGetData for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(sizeof(DWORD));
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    //
+    // Get Data
+    //
+
+    if (! DoPhoneGetData(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(sizeof(DWORD));
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetData(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpData.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: bad lpData",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    //
+    // Bad lpData
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpData = (LPVOID)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetData(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad  dwSize(0).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(sizeof(DWORD));
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: bad dwSize(0)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwSize = 0;
+
+    //
+    // Get Data
+    //
+
+    if (! DoPhoneGetData(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: bad dwSize(real big)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwSize = 0x7FFFFFFF;
+
+    //
+    // Get Data
+    //
+
+    if (! DoPhoneGetData(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+	 if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwDataId.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(sizeof(DWORD));
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    //
+    // Bad dwDataId
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad dwDataId=-1",
+        dwTestCase+1);
+    lpTapiPhoneTestInfo->dwDataID = (DWORD)-1;
+    if (! DoPhoneGetData(lpTapiPhoneTestInfo,
+                         PHONEERR_INVALDATAID))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Bad dwDataId
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad dwDataId=lpPhoneCaps->dwNumGetData",
+        dwTestCase+1);
+    lpTapiPhoneTestInfo->dwDataID =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData;
+    if (! DoPhoneGetData(lpTapiPhoneTestInfo,
+                         PHONEERR_INVALDATAID))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(sizeof(DWORD));
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    if ( ! DoPhoneGetData(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumGetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(sizeof(DWORD));
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    if ( ! DoPhoneGetData(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetData: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetData  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+
+
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgdc.c b/private/tapi/qa/trapper/itest/tphone/itpgdc.c
new file mode 100644
index 000000000..afa7a2ad4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgdc.c
@@ -0,0 +1,961 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgdc.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetDevCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+
+Revision History:
+
+     pgopi                      March 1996         Additional Tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetDevCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhoneApp
+// 3. Bad dwDeviceId
+// 4. Bad dwAPIVersion
+// 5. Bad lpPhoneCaps
+// 6. Bad lpPhoneCaps->dwTotalSize
+// 7. Bad dwExtVersion
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetDevCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwSaveAPIVersion = 0;
+    DWORD dwSaveExtVersion = 0;
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetDevCaps <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetDevCaps for go/no-go ",
+        dwTestCase+1);
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhoneApp ",
+        dwTestCase+1);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp_Orig  = lpTapiPhoneTestInfo->hPhoneApp1;
+
+
+    //
+    // bad hPhoneApp (zero is a valid app handle, so we start the index
+    // at 1, as gdwInvalidHandles[0] is = 0).
+    //
+
+    for(i=1; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhoneApp = (HPHONEAPP)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALAPPHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp1 = lpTapiPhoneTestInfo->hPhoneApp_Orig;
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwDeviceId.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwDeviceID(=numDevs) ",
+        dwTestCase+1);
+
+    //
+    // Bad DeviceId
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = *(lpTapiPhoneTestInfo->lpdwNumDevs);
+
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwDeviceID(=-1) ",
+        dwTestCase+1);
+
+    //
+    // Bad DeviceId
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = (DWORD)-1;
+
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Reset deviceId
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwAPIVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwAPIVersion ",
+        dwTestCase+1);
+
+    //
+    // Bad dwAPIVersion
+    //
+
+    dwSaveAPIVersion = lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = WAYTOOHIGH_APIVERSION;
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo,
+                            PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Reset dwAPIVersion
+    //
+
+    lpTapiPhoneTestInfo->dwAPIVersion =  dwSaveAPIVersion;
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpPhoneCaps(NULL).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Bad lpPhoneCaps
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpPhoneCaps ",
+        dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad dwTotalSize(0).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = 0;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwTotalSize(0) ",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = 0;
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwTotalSize(fixed_size-1) ",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS)-1;
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwTotalSize(real big) ",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = 0x7FFFFFFF;
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad dwExtVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwExtVersion ",
+        dwTestCase+1);
+
+    //
+    // Bad dwExtVersion
+    //
+
+    dwSaveExtVersion = lpTapiPhoneTestInfo->dwExtVersion;
+    lpTapiPhoneTestInfo->dwExtVersion = BAD_EXTVERSION;
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo,
+                            PHONEERR_INCOMPATIBLEEXTVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Reset dwExtVersion
+    //
+
+    lpTapiPhoneTestInfo->dwExtVersion =  dwSaveExtVersion;
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    if ( ! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    if ( ! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetDevCaps: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetDevCaps  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgdp.c b/private/tapi/qa/trapper/itest/tphone/itpgdp.c
new file mode 100644
index 000000000..6443d26ea
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgdp.c
@@ -0,0 +1,772 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgdp.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetDiaplay
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996             Additional tests.
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+//  phoneGetDisplay
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpDisplay
+// 4. Bad dwTotalSize
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetDisplay(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwNumRows, dwNumColumns;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetDisplay <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Go / No-Go test",
+        dwTestCase+1);
+
+
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+    lpTapiPhoneTestInfo->lpDisplay =
+        (LPVARSTRING) AllocFromTestHeap(sizeof(VARSTRING));
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING);
+
+	
+
+    //
+    // phoneGetDisplay
+    //
+
+    if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone test
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+    lpTapiPhoneTestInfo->lpDisplay =
+        (LPVARSTRING) AllocFromTestHeap(sizeof(VARSTRING));
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+    //
+    // phoneCLose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpDisplay.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpDisplay",
+        dwTestCase+1);
+
+
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpDisplay = (LPVARSTRING)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+    lpTapiPhoneTestInfo->lpDisplay = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING));
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwTotalSize=0",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = 0;
+
+    //
+    // phoneGetDisplay
+    //
+
+    if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwTotalSize=fixed_size-1",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING)-1;
+
+    //
+    // phoneGetDisplay
+    //
+
+    if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwTotalSize=(real big)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = 0x7FFFFFFF;
+
+    //
+    // phoneGetDisplay
+    //
+
+    if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+     n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+    lpTapiPhoneTestInfo->lpDisplay =
+        (LPVARSTRING) AllocFromTestHeap(sizeof(VARSTRING));
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING);
+
+	 if ( ! DoPhoneGetDisplay(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+
+    lpTapiPhoneTestInfo->lpDisplay =
+        (LPVARSTRING) AllocFromTestHeap(sizeof(VARSTRING));
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize = sizeof(VARSTRING);
+
+	 if ( ! DoPhoneGetDisplay(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetDisplay: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetDisplay  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgg.c b/private/tapi/qa/trapper/itest/tphone/itpgg.c
new file mode 100644
index 000000000..bd5bcb42e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgg.c
@@ -0,0 +1,888 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgg.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetGain
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+     pgopi                      March 1996             Additional Tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetGain
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. BitVectorParamErrorTest Invalid for dwHookSwitchDev
+// 4. BitVectorParamErrorTest Valid for dwHookSwitchDev
+// 5. Bad lpdwGain
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetGain(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetGain <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetGain for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+    if (! DoPhoneGetGain(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+           TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown.
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetGain(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown.
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: BitVectorParamErrorTest (Invalid).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: BitVectorParamErrorTest",
+        dwTestCase+1);
+
+    //
+    // BitVectorParamErrorTest for dwHookSwitchDev
+    //
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+
+    lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+    if(! TestPhoneInvalidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneGetGain,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            PHONEERR_INVALHOOKSWITCHDEV,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+             PHONEHOOKSWITCHDEV_SPEAKER|
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown.
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: BitVectorParamErrorTest (Valid).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: BitVectorParamValidTest",
+        dwTestCase+1);
+
+    //
+    // BitVectorParamValidTest for dwHookSwitchDev
+    //
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+
+    lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+    if(! TestPhoneValidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneGetGain,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+             PHONEHOOKSWITCHDEV_SPEAKER|
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown.
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: lpdwGain.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+    //
+    // phoneGetDevCaps
+    //
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: lpdwGain",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+
+    //
+    // Bad lpdwGain
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwGain = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetGain(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown.
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+   if ( ! DoPhoneGetGain(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+
+    }
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+    if ( ! DoPhoneGetGain(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetGain: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetGain  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpghs.c b/private/tapi/qa/trapper/itest/tphone/itpghs.c
new file mode 100644
index 000000000..cd1a16a0f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpghs.c
@@ -0,0 +1,612 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpghs.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetHookSwitch
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996              Additional Tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+
+//  phoneGetHookSwitch
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpdwHookSwitchDevs
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetHookSwitch(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    int i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetHookSwitch <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetHookSwitch for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+        &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+    if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+        &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpdwHookSwitchDev.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpdwHookSwitchDevs",
+        dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+            (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+        &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+
+    if ( ! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+        &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+    if ( ! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetHookSwitch: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetHookSwitch  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgi.c b/private/tapi/qa/trapper/itest/tphone/itpgi.c
new file mode 100644
index 000000000..63b5e169b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgi.c
@@ -0,0 +1,943 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgi.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetIcon
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+    pgopi                       March 1996           Additional Tests
+	a-ramako					5-April-96			 Added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+
+
+//  phoneGetIcon
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad dwDeviceId
+// 3. Bad lpszDeviceClass
+// 4. Bad lphIcon
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetIcon(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    int i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetIcon <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+
+    lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: phoneGetIcon for go/no-go",
+        dwTestCase+1);
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+    //
+    // phoneGetIcon
+    //
+
+    if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: phoneGetIcon for go/no-go(null lpwszDeviceClass)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpwszDeviceClass = NULL;
+#else
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: phoneGetIcon for go/no-go(null lpszDeviceClass)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpszDeviceClass = NULL;
+#endif
+
+    //
+    // phoneGetIcon
+    //
+
+    if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: phoneGetIcon for go/no-go(empty string for "
+        "lpwszDeviceClass)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"";
+#else
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: phoneGetIcon for go/no-go(empty string for "
+        "lpszDeviceClass)",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpszDeviceClass = "";
+#endif
+
+    //
+    // phoneGetIcon
+    //
+
+    if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad dwDeviceID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad dwDeviceID(-1)",
+        dwTestCase+1);
+
+    //
+    // Bad dwDeviceID
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =  (DWORD)-1;
+
+    //
+    // phoneGetIcon
+    //
+
+    if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad dwDeviceID(numDevs)",
+        dwTestCase+1);
+
+    //
+    // Bad dwDeviceID
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =  *(lpTapiPhoneTestInfo->lpdwNumDevs);
+
+    //
+    // phoneGetIcon
+    //
+
+    if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore dwDeviceID
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpszDeviceClass .
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad lpwszDeviceClass",
+        dwTestCase+1);
+#else
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad lpszDeviceClass",
+        dwTestCase+1);
+#endif
+
+    lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+
+    //
+    // NULL is a valid value for lpszDeviceClass, so we start the index at 1
+    // as gldwInvalidHandles[0] has the value zero.
+    //
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiPhoneTestInfo->lpwszDeviceClass = (LPWSTR)gdwInvalidPointers[i];
+#else
+        lpTapiPhoneTestInfo->lpszDeviceClass = (LPSTR)gdwInvalidPointers[i];
+#endif
+
+        if (! DoPhoneGetIcon(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case:Bad  lphIcon.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Bad lphIcon",
+        dwTestCase+1);
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lphIcon = (LPHICON)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetIcon(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Invalid lpszDeviceClass .
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Invalid lpwszDeviceClass",
+        dwTestCase+1);
+#else
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld: Invalid lpszDeviceClass",
+        dwTestCase+1);
+#endif
+
+    lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+
+    //
+    // when testing with esp32.tsp, always use "tapi/InvalidDeviceClass"
+    // as your invalid device class, because esp32.tsp passes every other
+    // device class name as a valid device class.
+    //
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/InvalidDeviceClass";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/InvalidDeviceClass";
+#endif
+
+    if (! DoPhoneGetIcon(lpTapiPhoneTestInfo,PHONEERR_INVALDEVICECLASS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+
+    if ( ! DoPhoneGetIcon(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+
+    if ( ! DoPhoneGetIcon(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetIcon: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetIcon  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgid.c b/private/tapi/qa/trapper/itest/tphone/itpgid.c
new file mode 100644
index 000000000..49820816f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgid.c
@@ -0,0 +1,759 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgid.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetID
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996           Additional tests
+	 a-ramako					5-April-96			 Added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetID
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpDeviceID
+// 4. Bad lpszDeviceClass
+// 5. Bad lpDeviceID->dwTotalSize
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetID(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    int i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetID <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+    lpTapiPhoneTestInfo->lpDeviceID =  &(lpTapiPhoneTestInfo->DeviceID);
+    lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetID for go/no-go",
+        dwTestCase+1);
+
+    //
+    // phoneGetID
+    //
+
+    if (! DoPhoneGetID(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### passedSize = %lx, dwNeededSize = %lx",
+        sizeof(lpTapiPhoneTestInfo->DeviceID),
+        lpTapiPhoneTestInfo->lpDeviceID->dwNeededSize);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+    lpTapiPhoneTestInfo->lpDeviceID =  &(lpTapiPhoneTestInfo->DeviceID);
+    lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetID(lpTapiPhoneTestInfo,
+                           PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpDeviceID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+	
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpDeviceID",
+        dwTestCase+1);
+
+    //
+    // phoneGetID
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpDeviceID = (LPVARSTRING)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetID(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpszDeviceClass.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    lpTapiPhoneTestInfo->lpDeviceID =  &(lpTapiPhoneTestInfo->DeviceID);
+    lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpwszDeviceClass(NULL)",
+        dwTestCase+1);
+#else
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpszDeviceClass(NULL)",
+        dwTestCase+1);
+#endif
+
+    //
+    // phoneGetID
+    //
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiPhoneTestInfo->lpwszDeviceClass = (LPWSTR)gdwInvalidPointers[i];
+#else
+        lpTapiPhoneTestInfo->lpszDeviceClass = (LPSTR)gdwInvalidPointers[i];
+#endif
+
+        if (! DoPhoneGetID(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpDeviceID->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+    lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+    lpTapiPhoneTestInfo->lpDeviceID =  &(lpTapiPhoneTestInfo->DeviceID);
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpDeviceID->dwTotalSize=0",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = 0;
+
+    //
+    // phoneGetID
+    //
+
+    if (! DoPhoneGetID(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpDeviceID->dwTotalSize=real big",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = 0x7FFFFFFF;
+
+    //
+    // phoneGetID
+    //
+
+    if (! DoPhoneGetID(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpDeviceID->dwTotalSize=fixed_size-1",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING)-1;
+
+    //
+    // phoneGetID
+    //
+
+    if (! DoPhoneGetID(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetID: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetID  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgl.c b/private/tapi/qa/trapper/itest/tphone/itpgl.c
new file mode 100644
index 000000000..268d90289
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgl.c
@@ -0,0 +1,648 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgl.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetLamp
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996         Additional tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetLamp
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpdwLampMode
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetLamp(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    int i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetLamp <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetLamp for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+
+    //
+    // phoneGetLamp
+    //
+
+    if (! DoPhoneGetLamp(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwLampMode = %lx",
+        lpTapiPhoneTestInfo->dwLampMode);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetLamp(lpTapiPhoneTestInfo,
+                           PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwLampMode = %lx",
+        lpTapiPhoneTestInfo->dwLampMode);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpdwLampMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpdwLampMode",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = NULL;
+
+    //
+    // phoneGetLamp
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwLampMode = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetLamp(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwLampMode = %lx",
+        lpTapiPhoneTestInfo->dwLampMode);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+
+
+    if ( ! DoPhoneGetLamp(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+
+
+    if ( ! DoPhoneGetLamp(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhonGetLamp: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetLamp  <<<<<<<<" );
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgm.c b/private/tapi/qa/trapper/itest/tphone/itpgm.c
new file mode 100644
index 000000000..b08c71c8d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgm.c
@@ -0,0 +1,363 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgm.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetMessage
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetMessage
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhoneApp
+// 3. Bad lpMessage
+//
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetMessage(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n*********************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test phoneGetMessage");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEEVENT;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwButtonLampID = 0;
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    if (! DoPhoneSetLamp(lpTapiPhoneTestInfo, TAPISUCCESS, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    WaitForAllMessages();
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Go/No-Go Test",
+                  dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpMessage = (LPPHONEMESSAGE) AllocFromTestHeap (
+        sizeof(PHONEMESSAGE));
+
+    if(! DoPhoneGetMessage (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "lpMessage: hDevice = %lx, dwMessageID = %lx, dwCallbackInst = %lx",
+        lpTapiPhoneTestInfo->lpMessage->hDevice,
+        lpTapiPhoneTestInfo->lpMessage->dwMessageID,
+        lpTapiPhoneTestInfo->lpMessage->dwCallbackInstance);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "lpMessage: dwParam1 = %lx, dwParam2 = %lx, dwParam3 = %lx",
+        lpTapiPhoneTestInfo->lpMessage->dwParam1,
+        lpTapiPhoneTestInfo->lpMessage->dwParam2,
+        lpTapiPhoneTestInfo->lpMessage->dwParam3);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEEVENT;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad hPhoneApp",
+                  dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpMessage = (LPPHONEMESSAGE) AllocFromTestHeap (
+        sizeof(PHONEMESSAGE));
+
+    //
+    // save previous hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp_Orig = lpTapiPhoneTestInfo->hPhoneApp1;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 0;  i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhoneApp = (HPHONEAPP)gdwInvalidHandles[i];
+        if (! DoPhoneGetMessage(lpTapiPhoneTestInfo,
+                               PHONEERR_INVALAPPHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    //
+    // Reset hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp1 = lpTapiPhoneTestInfo->hPhoneApp_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpMessage.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEEVENT;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">>Test Case %ld: Bad lpMessage",
+                  dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiPhoneTestInfo->lpMessage = (LPPHONEMESSAGE)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetMessage(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+                TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    //
+    // +----------------------edit above this phone-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetMessage: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetMessage  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgr.c b/private/tapi/qa/trapper/itest/tphone/itpgr.c
new file mode 100644
index 000000000..670aed87f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgr.c
@@ -0,0 +1,840 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgr.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetRing
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996              Additional Tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetRing
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpdwRingMode
+// 4. Bad lpdwVolume
+//
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetRing(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwVolume;
+    int i;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetRing <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetRing for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    if (! DoPhoneGetRing(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwRingMode = %lx",
+        lpTapiPhoneTestInfo->dwRingMode);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwVolume = %lx",
+        lpTapiPhoneTestInfo->dwVolume);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetRing(lpTapiPhoneTestInfo,
+                           PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpdwRingMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpdwRingMode.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwRingMode = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetRing(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: lpdwRingMode == lpdwVolume
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: lpdwRingMode == lpdwVolume.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->lpdwRingMode = 
+         (LPDWORD) lpTapiPhoneTestInfo->lpdwVolume;
+
+    if (! DoPhoneGetRing(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+       {
+          TPHONE_FAIL();
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+     // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpdwVolume.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpdwVolume.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwVolume = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetRing(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	//
+	// Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    if ( ! DoPhoneGetRing(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    if ( ! DoPhoneGetRing(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+ 
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetRing: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetRing  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgs.c b/private/tapi/qa/trapper/itest/tphone/itpgs.c
new file mode 100644
index 000000000..d9b32a891
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgs.c
@@ -0,0 +1,774 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgs.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetStatus
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996           Additional Tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpPhoneStatus
+// 4. Bad lpPhoneStatus->dwTotalSize
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    int i;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetStatus <<<<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: phoneGetStatus for go/no-go for OWNER",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+			sizeof(PHONESTATUS));
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS);
+
+    //
+    // phoneGetStatus
+    //
+
+    if (! DoPhoneGetStatus(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpPhoneStatus->dwNeededSize = %lx",
+        lpTapiPhoneTestInfo->lpPhoneStatus->dwNeededSize);
+
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad hPhone",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+			sizeof(PHONESTATUS));
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetStatus(lpTapiPhoneTestInfo,
+                           PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpPhoneStatus.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	 TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad lpPhoneStatus",
+         dwTestCase+1);
+
+    //
+    // phoneGetStatus
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpPhoneStatus =
+            (LPPHONESTATUS)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetStatus(lpTapiPhoneTestInfo,PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpPhoneStatus->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+        sizeof(PHONESTATUS));
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad lpPhoneStatus->dwTotalSize=0",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = 0;
+
+    //
+    // phoneGetStatus
+    //
+
+    if (! DoPhoneGetStatus(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad lpPhoneStatus->dwTotalSize=fixedSize-1",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS)-1;
+
+    //
+    // phoneGetStatus
+    //
+
+    if (! DoPhoneGetStatus(lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad lpPhoneStatus->dwTotalSize=real big",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = 0x7FFFFFFF;
+
+    //
+    // phoneGetStatus
+    //
+
+    if (! DoPhoneGetStatus(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+			sizeof(PHONESTATUS));
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS);
+
+
+    if ( ! DoPhoneGetStatus(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+			sizeof(PHONESTATUS));
+    lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS);
+
+
+    if ( ! DoPhoneGetStatus(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetStatus: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetStatus  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgsm.c b/private/tapi/qa/trapper/itest/tphone/itpgsm.c
new file mode 100644
index 000000000..c93cbca28
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgsm.c
@@ -0,0 +1,1067 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgsm.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetStatusMessages
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+    pgopi   20-Mar-1996       Additional  parameter tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetStatusMessages
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. Bad lpdwPhoneStates
+// 4. Bad lpdwButtonModes
+// 5. Bad lpdwButtonStates
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetStatusMessages(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    int i;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetStatusMessages <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: phoneGetStatusMessages for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+
+    //
+    // phoneGetStatusMessages
+    //
+
+    if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwPhoneStates = %lx",
+        lpTapiPhoneTestInfo->dwPhoneStates);
+
+    TapiLogDetail(
+		  DBUG_SHOW_DETAIL,
+		  " #### lpTapiPhoneTestInfo->dwButtonMode = %lx",
+        lpTapiPhoneTestInfo->dwButtonModes);
+
+    TapiLogDetail(
+		  DBUG_SHOW_DETAIL,
+		  " #### lpTapiPhoneTestInfo->dwButtonStates = %lx",
+        lpTapiPhoneTestInfo->dwButtonStates);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                           PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lpdwPhoneStates
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:  Bad lpdwPhoneStates",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+
+    //
+    // phoneGetStatusMessages
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwPhoneStates = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                       PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case:  lpdwPhoneStates == lpdwButtonModes
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:  lpdwPhoneStates == lpdwButtonModes",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+
+    //
+    // phoneGetStatusMessages
+    //
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates = 
+         (LPDWORD) lpTapiPhoneTestInfo->lpdwButtonModes;
+
+    if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPOINTER))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpdwPhoneStates == lpdwButtonStates
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:  lpdwPhoneStates == lpdwButtonStates",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+
+    //
+    // phoneGetStatusMessages
+    //
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates = 
+         (LPDWORD) lpTapiPhoneTestInfo->lpdwButtonStates;
+
+    if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPOINTER))
+      {
+         TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpdwButtonModes.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:  Bad lpdwButtonModes",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+
+    //
+    // phoneGetStatusMessages
+    //
+
+    for(i= 0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwButtonModes = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                       PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad lpdwButtonStates.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:  Bad lpdwButtonStates",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+
+
+    //
+    // phoneGetStatusMessages
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwButtonStates = (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                       PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: lpdwButtonStates == lpdwButtonModes
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:  Bad lpdwButtonStates == lpdwButtonModes",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+
+
+    //
+    // phoneGetStatusMessages
+    //
+
+     lpTapiPhoneTestInfo->lpdwButtonStates = 
+        (LPDWORD)lpTapiPhoneTestInfo->lpdwButtonModes;
+					  
+     if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                    PHONEERR_INVALPOINTER))
+       {
+           TPHONE_FAIL();
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+     //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetStatusMessages: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetStatusMessages  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpgv.c b/private/tapi/qa/trapper/itest/tphone/itpgv.c
new file mode 100644
index 000000000..742815004
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpgv.c
@@ -0,0 +1,877 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpgv.c
+
+Abstract:
+
+    This module contains the test functions for phoneGetVolume
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996             Additional Param Test
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneGetVolume
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. BitVectorParamErrorTest
+// 4. Bad lpdwVolume
+// 5. BitVectorParamValidTest.
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetVolume(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    int i = 0;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneGetVolume <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: phoneGetVolume for go/no-go for OWNER",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    //
+    // phoneGetVolume
+    //
+
+    if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        " #### lpTapiPhoneTestInfo->dwVolume = %lx",
+        lpTapiPhoneTestInfo->dwVolume);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case:Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad hPhone",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+    //
+    // bad hPhone for phoneGetVolume
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, PHONEERR_INVALPHONEHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // close phone
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: BitVectorParameErrorTest.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: BitVectorParamErrorTest",
+         dwTestCase+1);
+
+    //
+    // BitVectorParamErrorTest
+    //
+
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+
+    if(! TestPhoneInvalidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneGetVolume,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            PHONEERR_INVALHOOKSWITCHDEV,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+             PHONEHOOKSWITCHDEV_SPEAKER|
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpdwVolume.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test case %ld: Bad lpdwVolume",
+         dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    //
+    // Bad lpdwVolumne for phoneGetVolume
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwVolume = (LPDWORD)gdwInvalidPointers[i];
+
+	     if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Valid BitVectorParamValidTest.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get Device Capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: BitVectorParamValidTest",
+        dwTestCase+1);
+
+    //
+    // BitVectorParamValidTest
+    //
+
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+
+    if(! TestPhoneValidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneGetVolume,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+             PHONEHOOKSWITCHDEV_SPEAKER|
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close phone
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    if ( ! DoPhoneGetVolume(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+
+    if ( ! DoPhoneGetVolume(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneGetVolume: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneGetVolume  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpi.c b/private/tapi/qa/trapper/itest/tphone/itpi.c
new file mode 100644
index 000000000..af88986f5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpi.c
@@ -0,0 +1,712 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpi.c
+
+Abstract:
+
+    This module contains the test functions for phoneInitialize
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+     pgopi                      March 1996           Additional Param Test
+	 a-ramako					5-April-96			 Added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneInitialize
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad lpPhoneApp
+// 3. Bad hInstance
+// 4. Bad lpfnCallback
+// 5. Bad lpszAppName
+// 6. Bad lpdwNumDevs
+// 7. Go/No-Go test(empty appName).
+// 8. Force a REINIT message & verify that attempts to phoneInitialize
+//    fail with REINIT
+// * = Stand-alone test case
+//
+//
+
+
+
+BOOL TestPhoneInitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    TAPIRESULT         lastTapiResult;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneInitialize <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:phoneInitialize for go/no-go ",
+        dwTestCase+1);
+
+    //
+    // Initialize a phone app
+    //
+
+    if(! DoPhoneInitialize (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad lphPhoneApp test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lphPhoneApp ",
+        dwTestCase+1);
+
+    //
+    // Bad lpPhoneApp for phoneinitialize
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lphPhoneApp = (LPHPHONEAPP)gdwInvalidPointers[i];
+
+        if(! DoPhoneInitialize (lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully, i.e phoneInitialize returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    //
+    // 3. Test Case: lphPhoneApp == lpdwNumDevs
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: lphPhoneApp == lpdwNumDevs",
+        dwTestCase+1);
+
+    //
+    // Bad lpPhoneApp for phoneinitialize
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = 
+            (LPHPHONEAPP) lpTapiPhoneTestInfo->lpdwNumDevs;
+
+    if(! DoPhoneInitialize (lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+      {
+         TPHONE_FAIL();
+
+            //
+            // if we initialized successfully, i.e phoneInitialize returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad hInstance test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad hInstance ",
+        dwTestCase+1);
+
+    //
+    // Bad hInstance for phoneinitialize
+    //
+
+    //
+    // hInstance=0 seems to be a valid hInstance, so we start the test
+    // from 1. gdwInvalidHandles[0] has the value 0, so we start the
+    // index at 1.
+    //
+
+    for(i=1; i < NUMINVALIDHANDLES; i++)
+    {
+        lpTapiPhoneTestInfo->hInstance = (HINSTANCE)gdwInvalidHandles[i];
+
+        if(! DoPhoneInitialize (lpTapiPhoneTestInfo, PHONEERR_INVALPARAM))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully, i.e phoneInitialize returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpfnCallback test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad lpfnCallback ",
+        dwTestCase+1);
+
+    //
+    // Bad lpfnCallback for phoneinitialize
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpfnCallback =
+            (PHONECALLBACK)gdwInvalidPointers[i];
+
+        if(! DoPhoneInitialize (lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully, i.e phoneInitialize returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpszAppName test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad lpwszAppName ",
+        dwTestCase+1);
+#else
+*/
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad lpszAppName ",
+        dwTestCase+1);
+//#endif
+
+    //
+    // invalid lpszAppName test
+    //
+
+    //
+    // gldwInvalidPointer[0] is NULL and a valid value for lpszAppName,
+    // so we start the test from index 1.
+    //
+
+    for(i=1; i < NUMINVALIDPOINTERS; i++)
+    {
+/*
+#ifdef WUNICODE
+        lpTapiPhoneTestInfo->lpwszAppName = (LPWSTR)gdwInvalidPointers[i];
+#else
+*/
+        lpTapiPhoneTestInfo->lpszAppName = (LPSTR)gdwInvalidPointers[i];
+//#endif
+
+        //
+        // Initialize a phone app
+        //
+
+        if(! DoPhoneInitialize (lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully, i.e phoneInitialize returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpdwNumDevs test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad lpdwNumDevs ",
+        dwTestCase+1);
+
+    //
+    // invalid lpszAppName test
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+
+        lpTapiPhoneTestInfo->lpdwNumDevs = (LPDWORD)gdwInvalidPointers[i];
+
+        //
+        // Initialize a phone app
+        //
+
+        if(! DoPhoneInitialize (lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully, i.e phoneInitialize returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Go/No-Go test(empty appName).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:phoneInitialize for go/no-go( empty appName) ",
+        dwTestCase+1);
+
+/*
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszAppName = L"";
+#else
+*/
+    lpTapiPhoneTestInfo->lpszAppName = "";
+//#endif
+
+    //
+    // Initialize a phone app
+    //
+
+    if(! DoPhoneInitialize (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Force a REINIT message and verify that
+    //               phoneInitialize returns REINIT error.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:Force a REINIT message & verify that"
+        " phoneInitialize returns reinit error",
+        dwTestCase+1);
+
+/*
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszAppName = L"";
+#else
+*/
+    lpTapiPhoneTestInfo->lpszAppName = "";
+//#endif
+
+    //
+    // Initialize a phone app
+    //
+
+    if(! DoPhoneInitialize (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for owner
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = PHONE_STATE;
+    info.u.EspMsg.dwParam1 = PHONESTATE_REINIT;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiPhoneTestInfo->lpParams = &info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the PHONESTATE_REINIT message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_STATE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               PHONESTATE_REINIT,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1));
+
+    if(!DoPhoneDevSpecific(lpTapiPhoneTestInfo,TAPISUCCESS,TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TPHONE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "TestPhoneInitailize: Did not receive REINIT message.");
+    }
+
+    //
+    // Initialize  hPhonepp2.
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+    
+    if(! DoPhoneInitialize (lpTapiPhoneTestInfo, PHONEERR_REINIT))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if we initialized successfully, i.e phoneInitialize returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+    
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneInitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneInitialize  <<<<<<<<");
+    
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+
+}
diff --git a/private/tapi/qa/trapper/itest/tphone/itpie.c b/private/tapi/qa/trapper/itest/tphone/itpie.c
new file mode 100644
index 000000000..f74185389
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpie.c
@@ -0,0 +1,1619 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpie.c
+
+Abstract:
+
+    This module contains the test functions for phoneInitializeEx
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+	a-ramako					5-April-96			 Added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneInitializeEx
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad lphPhoneApp
+// 3. Bad hInstance
+// 4. Bad lpfnCallback
+// 5. Bad lpszFriendlyName
+// 6. Bad lpdwNumDevs
+// 7. Bad lpdwAPIVersion
+// 8. Bad lpPhoneInitializeParams
+// 9. Bad dwTotalSize
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneInitializeEx(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    TAPIRESULT         lastTapiResult;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>>>> Test phoneInitializeEx <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:phoneInitializeEx for go/no-go ",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad lphPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad lphPhoneApp ",
+        dwTestCase+1);
+    //
+    // Test invalid hPhoneApp
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lphPhoneApp = (LPHPHONEAPP)gdwInvalidPointers[i];
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    //
+    // 3. Test Case: Bad lphPhoneApp == lpdwNumDevs
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: lphPhoneApp == lpdwNumDevs",
+        dwTestCase+1);
+    //
+    // Test invalid hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = 
+        (LPHPHONEAPP) lpTapiPhoneTestInfo->lpdwNumDevs;
+    if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                              PHONEERR_INVALPOINTER))
+       {
+          TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lphPhoneApp == lpdwAPIVersion
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: lphPhoneApp == lpdwAPIVersion",
+        dwTestCase+1);
+    //
+    // Test invalid hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = 
+        (LPHPHONEAPP) lpTapiPhoneTestInfo->lpdwAPIVersion;
+    if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                              PHONEERR_INVALPOINTER))
+       {
+          TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lphPhoneApp == lpPhoneInitializeExParams;
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:  lphPhoneApp == lpPhoneInitializeExParams",
+        dwTestCase+1);
+    //
+    // Test invalid hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = 
+        (LPHPHONEAPP) lpTapiPhoneTestInfo->lpPhoneInitializeExParams;
+    if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                              PHONEERR_INVALPOINTER))
+       {
+          TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad hInstance.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad hInstance ",
+        dwTestCase+1);
+
+    //
+    // save previous hInstance
+    //
+
+    lpTapiPhoneTestInfo->hInstance_Orig = lpTapiPhoneTestInfo->hInstance;
+
+    //
+    // Test invalid handles
+    //
+
+    for(i = 1;  i < NUMINVALIDHANDLES; i++)
+    {
+        lpTapiPhoneTestInfo->hInstance = (HINSTANCE)gdwInvalidHandles[i];
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPARAM))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    //
+    // Reset hInstance
+    //
+
+    lpTapiPhoneTestInfo->hInstance = lpTapiPhoneTestInfo->hInstance_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad lpfnCallback.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Bad lpfnCallback ",
+        dwTestCase+1);
+
+    //
+    // Test invalid lpfnCallback
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpfnCallback =
+            (PHONECALLBACK)gdwInvalidPointers[i];
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Bad lpszFriendlyName.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+
+#ifdef WUNICODE
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpwszFriendlyAppName",
+                  dwTestCase+1);
+#else
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpszFriendlyAppName",
+                  dwTestCase+1);
+#endif
+
+    //
+    // Test invalid lpszFriendlyAppName
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+#ifdef WUNICODE
+        lpTapiPhoneTestInfo->lpwszFriendlyAppName =
+            (LPWSTR)gdwInvalidPointers[i];
+#else
+        lpTapiPhoneTestInfo->lpszFriendlyAppName =
+            (LPSTR)gdwInvalidPointers[i];
+#endif
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: Bad lpdwNumDevs.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpdwNumDevs",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwNumDevs
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwNumDevs =
+            (LPDWORD)gdwInvalidPointers[i];
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 10. Test Case: lpdwNumDevs == lpdwAPIVersion
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: lpdwNumDevs == lpdwAPIVersion",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwNumDevs
+    //
+
+        lpTapiPhoneTestInfo->lpdwNumDevs =
+            (LPDWORD) lpTapiPhoneTestInfo->lpdwAPIVersion;
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 11. Test Case: lpdwNumDevs == lpPhoneInitializeExParams
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: lpdwNumDevs == lpPhoneInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwNumDevs
+    //
+
+        lpTapiPhoneTestInfo->lpdwNumDevs =
+            (LPDWORD) lpTapiPhoneTestInfo->lpPhoneInitializeExParams;
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 12. Test Case: Bad lpdwAPIVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpdwAPIVersion",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwAPIVersion
+    //
+
+    for(i = 0;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwAPIVersion =
+            (LPDWORD)gdwInvalidPointers[i];
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 13. Test Case:  lpdwAPIVersion == lpPhoneInitializeExParams
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: lpdwAPIVersion == lpPhoneInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpdwAPIVersion
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion =
+            (LPDWORD)lpTapiPhoneTestInfo->lpPhoneInitializeExParams;
+    if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                              PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+     // ===================================================================
+    // ===================================================================
+    //
+    // 14. Test Case:  Bad lpPhoneInitializeExParams..
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad lpPhoneInitializeExParams",
+                  dwTestCase+1);
+
+    //
+    // Test invalid lpPhoneInitializeExParams
+    //
+
+    for(i = 1;  i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+            (LPPHONEINITIALIZEEXPARAMS)gdwInvalidPointers[i];
+        if (! DoPhoneInitializeEx(lpTapiPhoneTestInfo,
+                                 PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if we initialized successfully,i.e phoneInitializeEx returned 0,
+            // then we better shutdown.
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    //
+    // 15. Test Case: Bad dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+        (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+//    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+//         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=0",
+                  dwTestCase+1);
+
+    //
+    // lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize = 0;
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize = 0;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if we initialized successfully,i.e phoneInitializeEx returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=fixedSize-1",
+                  dwTestCase+1);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+        sizeof(PHONEINITIALIZEEXPARAMS)-1;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_STRUCTURETOOSMALL))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if we initialized successfully,i.e phoneInitializeEx returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    TapiLogDetail(DBUG_SHOW_PASS,
+                  ">> Test Case %ld: Bad dwTotalSize=real big",
+                  dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize = 0x7FFFFFFF;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if we initialized successfully,i.e phoneInitializeEx returned 0,
+        // then we better shutdown.
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+        sizeof(PHONEINITIALIZEEXPARAMS);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 16. Test Case: Go/No-Go test with non-empty lpszFriendlyAppName.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:go/no-go, non-empty lpszFriendlyAppName",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 17. Test Case: Verify 3 options
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:Verify 3 options: USECOMPLETIONPORT",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 18. Test Case: Verify 3 options
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:Verify 3 options: USEHIDDENWINDOW",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 19. Test Case: Verify 3 options
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:Verify 3 options: USEEVENT",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEEVENT;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 20. Test Case: Verify uppart bits ignor
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:Verify uppart bits ignor",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         0xfffffff1;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 21. Test Case: Verify uppart bits ignor
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld:Verifyuppart bits ignor",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         0x0000fff1;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 22. Test Case: Verify option > 3 & < 16 should fail
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Verify options 4 should fail",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 4;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_INVALPARAM))
+    {
+        TPHONE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+          {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+              {
+                TPHONE_FAIL();
+              }
+          }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 23. Test Case: Verify option > 3 & < 16 should fail
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Verify option 15 should fail",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = 0x00020000;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 15;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_INVALPARAM))
+    {
+        TPHONE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+          {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+              {
+                TPHONE_FAIL();
+              }
+          }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 24. Test Case: Anything < 20000 should fail
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+		  "#### Test case %ld: Anything less than 2000 should fail",
+        dwTestCase+1);
+
+    //
+    // InitializeEx a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = 0x00010004;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEEVENT;
+
+#ifdef WUNICODE
+    lpTapiPhoneTestInfo->lpwszFriendlyAppName = L"TestApp";
+#else
+    lpTapiPhoneTestInfo->lpszFriendlyAppName = "TestApp";
+#endif
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+          {
+            if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+              {
+                TPHONE_FAIL();
+              }
+          }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+
+
+
+    //
+    // +----------------------edit above this phone-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneInitializeEx: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneInitializeEx  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpnav.c b/private/tapi/qa/trapper/itest/tphone/itpnav.c
new file mode 100644
index 000000000..c767a3603
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpnav.c
@@ -0,0 +1,640 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpnav.c
+
+Abstract:
+
+    This module contains the test functions for phoneNegotiateAPIVersion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+     pgopi                      March 1996        Additional param tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneNegotiateAPIVersion
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhoneApp
+// 3. Bad dwDeviceId
+// 4. Bad dwAPILowVersion
+// 5. Bad dwAPIHighVersion
+// 6. Bad lpdwAPIVersion
+// 7. Bad lpExtensionID
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneNegotiateAPIVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneNegotiateAPIVersion <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:phoneNegotiateAPIVersion for go/no-go",
+        dwTestCase+1);
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+	 if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad hPhoneApp",
+        dwTestCase+1);
+
+    //
+    // save original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp_Orig = lpTapiPhoneTestInfo->hPhoneApp1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhoneApp = (HPHONEAPP)gdwInvalidHandles[i];
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                         PHONEERR_INVALAPPHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // restore original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp1 = lpTapiPhoneTestInfo->hPhoneApp_Orig;
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwDeviceID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad dwDeviceID",
+        dwTestCase+1);
+
+    //
+    // use bad dwDeviceId of -1
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = (DWORD)-1;
+
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // use bad dwDeviceId of dwNumDevs
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = *(lpTapiPhoneTestInfo->lpdwNumDevs);
+
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwLowAPIVersion.
+    //
+    // 5. Test Case: Bad dwHighAPIVersion
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+
+    //
+    // use bad dwLowAPIVersion
+    //
+
+    lpTapiPhoneTestInfo->dwAPILowVersion = TOOHIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:Bad dwLowAPIVersion",
+        dwTestCase+1);
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+
+    //
+    // use bad dwHighAPIVersion
+    //
+
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = TOOLOW_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:Bad dwHighAPIVersion",
+        dwTestCase+1);
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpdwAPIVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+	 if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Bad lpdwAPIVersion",
+        dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwAPIVersion = (LPDWORD) gdwInvalidPointers[i];
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                         PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    //
+    // 7. Test Case: lpdwAPIVersion == lpExtensionID
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+	 if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: lpdwAPIVersion == lpExtensionID",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = 
+        (LPDWORD) lpTapiPhoneTestInfo->lpExtensionID;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_INVALPOINTER))
+       {
+          TPHONE_FAIL();
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: Bad lpExtensionID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld:Bad lpExtensionID",
+        dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpExtensionID =
+            (LPPHONEEXTENSIONID) gdwInvalidPointers[i];
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                         PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneNegotiateAPIVersion: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneNegotiateAPIVersion  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpne.c b/private/tapi/qa/trapper/itest/tphone/itpne.c
new file mode 100644
index 000000000..8b959950d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpne.c
@@ -0,0 +1,839 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpnev.c
+
+Abstract:
+
+    This module contains the test functions for phoneNegotiateExtVersion
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996           Additional param tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneNegotiateExtVersion
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhoneApp
+// 3. Bad dwDeviceID
+// 4. Bad dwAPIVersion
+// 5. Bad dwExtLowVersion
+// 6. Bad dwExtHighVersion
+// 7. Bad lpdwExtVersion
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneNegotiateExtVersion(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneNegotiateExtVersion <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		  0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+         DBUG_SHOW_PASS,
+         "#### Test Case %ld:phoneNegotiateExtVersion for go/no-go for OWNER",
+         dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+    if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hPhoneApp",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+    //
+    // save original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp_Orig = lpTapiPhoneTestInfo->hPhoneApp1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhoneApp = (HPHONEAPP)gdwInvalidHandles[i];
+
+        if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                         PHONEERR_INVALAPPHANDLE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // restore original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp1 = lpTapiPhoneTestInfo->hPhoneApp_Orig;
+	
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad dwDeviceId.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwDeviceID",
+        dwTestCase+1);
+
+    //
+    // use bad dwDeviceID of -1
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = (DWORD)-1;
+
+    if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // use bad dwDeviceID of dwNumDevs
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = *(lpTapiPhoneTestInfo->lpdwNumDevs);
+
+	 if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad dwAPIVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwAPIVersion",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+    //
+    // Use a Bad dwAPIVersion = TOOLOW_APIVERSION
+    //
+
+    lpTapiPhoneTestInfo->dwAPIVersion = TOOLOW_APIVERSION;
+
+    if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Use a Bad dwAPIVersion = TOOHIGH_APIVERSION
+    //
+
+    lpTapiPhoneTestInfo->dwAPIVersion = TOOHIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwExtLowVersion & dwExtHighVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwExtLowVersion & dwExtHighVersion",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+    lpTapiPhoneTestInfo->dwExtHighVersion = BAD_EXTVERSION;
+    lpTapiPhoneTestInfo->dwExtLowVersion = BAD_EXTVERSION;
+    if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                     PHONEERR_INCOMPATIBLEEXTVERSION))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lpdwExtVersion.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpdwExtVersion",
+        dwTestCase+1);
+
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpdwExtVersion = (LPDWORD) gdwInvalidPointers[i];
+
+        if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                         PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+    if ( ! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwExtVersion = &(lpTapiPhoneTestInfo->dwExtVersion);
+
+    if ( ! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneNegotiateExtVersion: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneNegotiateExtVersion  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpo.c b/private/tapi/qa/trapper/itest/tphone/itpo.c
new file mode 100644
index 000000000..5f878a0e4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpo.c
@@ -0,0 +1,1672 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpo.c
+
+Abstract:
+
+    This module contains the test functions for phoneOpen
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+     pgopi                      March 1996         Additional param tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+
+//  phoneOpen
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1.  Go/No-Go test for onwer
+// 2.  Verify Cannot open same phone as owner.
+// 3.  Test Case: Go/No-Go for Monitor.
+// 4.  Bad hPhoneApp
+// 5.  Bad dwDeviceId
+// 6.  Bad lphPhone
+// 7.  Bad dwAPIVersion(OWNER)
+// 8.  Bad dwAPIVersion(MONITOR)
+// 9.  BitVectorErrorParamTest for dwPrivilege
+// 10. Bad dwExtVersion(MONITOR)
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneOpen(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo=NULL;
+    INT i=0;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    TAPIRESULT         lastTapiResult;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneOpen <<<<<<<<<<<<<<<<<");
+/*
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+   lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+ 
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+    lpTapiPhoneTestInfo->dwExtVersion = 0x0;
+    lpTapiPhoneTestInfo->dwDeviceID = 0;
+
+    if ( ! DoPhoneOpen(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+*/
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    // 2. Test Case: Verify Cannot open same phone as owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for owner
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: phoneOpen for go/no-go for owner",
+        dwTestCase+1);
+
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // verify cannot open same phone as owner
+    //
+
+    fTestPassed = TRUE;
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: verify cannot open same phone as owner",
+        dwTestCase+1);
+
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_INVALPRIVILEGE))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // restore lphPhone
+    //
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+
+    //
+    // phone close
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+           TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Go/No-Go for Monitor.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for monitor
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: phoneOpen for go/no-go for monitor",
+        dwTestCase+1);
+
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phone close
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+           TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hPhoneApp",
+        dwTestCase+1);
+
+    //
+    // save original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp_Orig = lpTapiPhoneTestInfo->hPhoneApp1;
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhoneApp = (HPHONEAPP)gdwInvalidHandles[i];
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_INVALAPPHANDLE))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+            // better do a phoneCLose
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // restore original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp1 = lpTapiPhoneTestInfo->hPhoneApp_Orig;
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwDeviceID.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwDeviceID",
+        dwTestCase+1);
+
+    //
+    // use bad dwDeviceID of -1
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = (DWORD)-1;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    //
+    // use bad dwDeviceID of dwNumDevs
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = *(lpTapiPhoneTestInfo->lpdwNumDevs);
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Bad lphPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lphPhone",
+        dwTestCase+1);
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lphPhone = (LPHPHONE) gdwInvalidPointers[i];
+
+        if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+        {
+            TPHONE_FAIL();
+
+            //
+            // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+            // better do a phoneCLose
+            //
+
+            GetLastTapiResult(&lastTapiResult);
+
+            if(lastTapiResult.lActual == TAPISUCCESS)
+            {
+                if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+                {
+                    TPHONE_FAIL();
+                }
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Bad dwAPIVersion for OWNER.
+    // 8. Test Case: Bad dwAPIVersion for MONITOR.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for owner
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwAPIVersion for OWNER",
+        dwTestCase+1);
+
+    //
+    // Use a bad dwAPIVersion to phone open
+    //
+
+    lpTapiPhoneTestInfo->dwAPIVersion = WAYTOOHIGH_APIVERSION;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwAPIVersion for MONITOR",
+        dwTestCase+1);
+
+    //
+    // Use a bad dwAPIVersion to phone open
+    //
+
+    lpTapiPhoneTestInfo->dwAPIVersion = WAYTOOHIGH_APIVERSION;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: BitVectorParamErrorTest.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: BitVectorParamErrorTest",
+        dwTestCase+1);
+
+    //
+    // BitVectorParamErrorTest
+    //
+
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwPrivilege = 0;
+
+    if(! TestPhoneInvalidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneOpen,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwPrivilege,
+            PHONEERR_INVALPRIVILEGE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEPRIVILEGE_OWNER | PHONEPRIVILEGE_MONITOR),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 10. Test Case: Bad dwExtVersion for MONITOR.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for monitor
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwextVersion for MONITOR",
+        dwTestCase+1);
+
+    //
+    // Use a bad dwExtVersion to phone open
+    //
+
+    lpTapiPhoneTestInfo->dwExtVersion = BAD_EXTVERSION;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_INCOMPATIBLEEXTVERSION))
+    {
+        TPHONE_FAIL();
+
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 11. Test Case: Verify hPhone invalid if phoneOpen returns error
+    //                (try phoneClose).
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:  Verify hPhone invalid if phoneOpen returns"
+        " error(try phoneClose)",
+        dwTestCase+1);
+
+    //
+    // use bad dwDeviceID of -1
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID = (DWORD)-1;
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_BADDEVICEID))
+    {
+        TPHONE_FAIL();
+
+    }
+
+    //
+    // try a phoneClose of the bad hPhone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, PHONEERR_INVALPHONEHANDLE))
+    {
+        TPHONE_FAIL();
+
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+    
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 12. Test Case: Force REINIT message and verify PhoneOpen returns
+    //                REINIT error
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test case %ld: Force REINIT message and verify phoneOpen returns"
+        " PHONEERR_REINIT error",
+        dwTestCase+1);
+    
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    //
+    // try a phoneOpen of the another hPhone with privilege
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = PHONE_STATE;
+    info.u.EspMsg.dwParam1 = PHONESTATE_REINIT;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiPhoneTestInfo->lpParams = &info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the PHONESTATE_REINIT message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_STATE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               PHONESTATE_REINIT,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1));
+
+    if(!DoPhoneDevSpecific(lpTapiPhoneTestInfo,TAPISUCCESS,TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+    
+    //
+    // try a phoneOpen of the another hPhone with privilege
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_REINIT))
+    {
+        TPHONE_FAIL();
+        
+        //
+        // if phoneOpen succeeded, i.e. returns SUCCESS, then we
+        // better do a phoneCLose
+        //
+
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+    }
+
+    
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // close the phone
+    //
+    
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lphPhone          = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+ 
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+    lpTapiPhoneTestInfo->dwDeviceID = 0;
+ 
+    if ( ! DoPhoneOpen(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+        TPHONE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege        = PHONEPRIVILEGE_OWNER;
+ 
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+    lpTapiPhoneTestInfo->dwExtVersion = 0x0;
+    lpTapiPhoneTestInfo->dwDeviceID = 0;
+
+    if ( ! DoPhoneOpen(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+        GetLastTapiResult(&lastTapiResult);
+
+        if(lastTapiResult.lActual == TAPISUCCESS)
+        {
+            if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+                TPHONE_FAIL();
+            }
+        }
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneOpen: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneOpen  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tphone/itps.c b/private/tapi/qa/trapper/itest/tphone/itps.c
new file mode 100644
index 000000000..6284df503
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itps.c
@@ -0,0 +1,813 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itps.c
+
+Abstract:
+
+    This module contains the test functions for phoneShutdown
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+
+     pgopi                      March 1996           Additional param tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneShutdown
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhoneApp
+// 3. Verify hPhoneApp can't be used after successful shutdown(try
+//    phoneShutdown again) with no other existing hPhoneApps.
+// 4. Verify hPhoneApp can't be used after successful shutdown(try
+//    phoneShutdown again) when other hPhoneApps exists.
+// 5. Verify hPhoneApp can't be used after (try phoneShutdown again)
+//    when phoneInitialize returns error.
+// 6. Verify expected PHONE_STATE/OWNER,MONITOR msgs sent when
+//    hPhoneApp shutdown.
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneShutdown(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    LPCALLBACKPARAMS  lpCallbackParams=NULL;
+    
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneShutdown <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: phoneShutdown for go/no-go",
+        dwTestCase+1);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhoneApp.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hPhoneApp",
+        dwTestCase+1);
+
+    //
+    // Save original hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp_Orig = lpTapiPhoneTestInfo->hPhoneApp1;
+
+    //
+    // bad hPhoneApp
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhoneApp = (HPHONEAPP)gdwInvalidHandles[i];
+
+	     if (! DoPhoneShutdown(lpTapiPhoneTestInfo,
+                               PHONEERR_INVALAPPHANDLE))
+         {
+            TPHONE_FAIL();
+         }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhoneApp
+    //
+
+    lpTapiPhoneTestInfo->hPhoneApp1 = lpTapiPhoneTestInfo->hPhoneApp_Orig;
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Verify hPhoneApp can't be used after successful
+    //               shutdown(try phoneShutdown again) with no other
+    //               existing hPhoneApps.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify hPhoneApp can't be used after successful"
+        " shutdown(try phoneShutdown again)with no other existing hPhoneApps.",
+        dwTestCase+1);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown  again
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, PHONEERR_UNINITIALIZED))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Verify hPhoneApp can't be used after successful
+    //               shutdown(try phoneShutdown again) when other
+    //               hPhoneApps exist.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize phone app  1
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Initialize phone app  2
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify hPhoneApp can't be used after successful"
+        " shutdown(try phoneShutdown again)when other hPhoneApps exist.",
+        dwTestCase+1);
+
+
+    //
+    // Shutdown phone app 2
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown  phone app 2 again
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, PHONEERR_INVALAPPHANDLE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Shutdown phone app 1
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Verify hPhoneApp can't be used after (try
+    //               phoneShutdown again) when phoneInitialize returns
+    //               error.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    lpTapiPhoneTestInfo->lpdwNumDevs = (LPDWORD)gdwInvalidPointers[0];
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify hPhoneApp can't be used after (try"
+        " phoneShutdown again) when phoneInitialize returns error.",
+        dwTestCase+1);
+
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, PHONEERR_UNINITIALIZED))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Verify expected PHONESTATE_OWNER/MONITOR msgs
+    //               sent when hPhoneApp shutdown.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for owner
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify expected PHONESTATE_MONITOR "
+        "msgs are sent when hPhoneApp is shutdown .",
+        dwTestCase+1);
+
+    //
+    // Set the status messages to allow hphone1 to receive
+    // PHONESTATE_OWNER/MONITOR msgs.
+    //
+
+    lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_OWNER|
+                                          PHONESTATE_MONITORS;
+    lpTapiPhoneTestInfo->dwButtonModes  = 0;
+    lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+    if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Add the PHONESTATE_OWNER/MONITOR message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_STATE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               PHONESTATE_MONITORS,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1));
+
+    //
+    // Initialize
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+    
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for MONITOR on  hPhoneApp2.
+    //
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+    
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+	
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // shutdown
+    //
+
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Wait for the PHONESTATE_OWNER message
+    //
+
+    if (! WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+    
+    //
+    // shutdown
+    //
+    
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: Verify expected PHONESTATE_OWNER/MONITOR msgs
+    //               sent when hPhoneApp shutdown.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for owner
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+	
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Verify expected PHONESTATE_OWNER "
+        "msgs are sent when hPhoneApp is shutdown .",
+        dwTestCase+1);
+
+    //
+    // Set the status messages to allow hphone1 to receive
+    // PHONESTATE_OWNER/MONITOR msgs.
+    //
+
+    lpTapiPhoneTestInfo->dwPhoneStates  = PHONESTATE_OWNER|
+                                          PHONESTATE_MONITORS;
+    lpTapiPhoneTestInfo->dwButtonModes  = 0;
+    lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+    if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Add the PHONESTATE_OWNER/MONITOR message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_STATE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               PHONESTATE_OWNER,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1));
+
+    //
+    // Initialize
+    //
+
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp2;
+    
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone for OWNER on  hPhoneApp2.
+    //
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone2;
+    
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+    //
+    // phone open
+    //
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // shutdown
+    //
+
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Wait for the PHONESTATE_OWNER message
+    //
+
+    if (! WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    lpTapiPhoneTestInfo->lphPhoneApp = &lpTapiPhoneTestInfo->hPhoneApp1;
+    
+    //
+    // shutdown
+    //
+    
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+    
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneShutdown: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneShutdown  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsbi.c b/private/tapi/qa/trapper/itest/tphone/itpsbi.c
new file mode 100644
index 000000000..9a9f3f82d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsbi.c
@@ -0,0 +1,2218 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsbi.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetButtonInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                       March 1996          Additional param tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetButtonInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No owner privilege for hPhone
+// 4. Bad lpButtonInfo
+// 5. Bad lpButtonInfo->dwTotalSize
+//
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetButtonInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    PHONEBUTTONINFO        buttonInfo;
+    char* lpVoid=NULL;
+    DWORD dwAllocSize, dwTotalSize;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetButtonInfo <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: phoneSetButtonInfo for go/no-go for OWNER",
+        dwTestCase+1);
+
+	
+
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO) + (128 *sizeof(WCHAR))
+			);
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO) + (128*sizeof(char))
+			);
+    }
+    else
+    {
+    }
+
+    //
+    // Do set all field in ButtonInfo here
+    //
+
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+            sizeof(PHONEBUTTONINFO)+(128 *sizeof(WCHAR));
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+            sizeof(PHONEBUTTONINFO)+(128 *sizeof(char));
+    }
+    else
+    {
+    }
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+    //
+    // also use the dwButtonTextSize fields for code coverage
+    //
+
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize= wcslen(L"Test String")+1;
+        lpVoid = (char*)(lpTapiPhoneTestInfo->lpButtonInfo);
+        lpVoid += sizeof(PHONEBUTTONINFO);
+        wcscpy((WCHAR*)lpVoid, L"Test String");
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize= strlen("Test String")+1;
+        lpVoid = (char*)(lpTapiPhoneTestInfo->lpButtonInfo);
+        lpVoid += sizeof(PHONEBUTTONINFO);
+        strcpy((char*)lpVoid, "Test String");
+    }
+    else
+    {
+    }
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextOffset = sizeof(PHONEBUTTONINFO);
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // copy the original value of PHONEBUTTONINFO
+    //
+
+    memcpy(&buttonInfo,
+           lpTapiPhoneTestInfo->lpButtonInfo,
+           sizeof(PHONEBUTTONINFO));
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetButtonInfo for verify");
+
+
+    if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // compare the retrieved value and original set value of
+    // PHONEBUTTONINFO
+    //
+
+    if(buttonInfo.dwButtonMode !=
+       lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode)
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+	
+
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+
+    //
+    // Do set all field in ButtonInfo here
+    //
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPHONEHANDLE,
+                                   FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No OWNER privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone with MONITOR privilege
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No OWNER privilege for hPhone",
+        dwTestCase+1);
+
+	
+
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+
+    //
+    // Do set all field in ButtonInfo here
+    //
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpButtonInfo.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpButtonInfo",
+        dwTestCase+1);
+
+	
+
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+
+    //
+    // Do set all field in ButtonInfo here
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo =
+            (LPPHONEBUTTONINFO)gdwInvalidPointers[i];
+
+        if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPOINTER,
+                                   FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad lpButtonInfo->dwTotalSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Bad lpButtonInfo->dwTotalSize=0",
+        dwTestCase+1);
+
+	
+
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+    //
+    // lpButtonInfo->dwTotalSize =0
+    //
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = 0;
+
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo,
+                               PHONEERR_STRUCTURETOOSMALL,
+                               FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // lpButtonInfo->dwTotalSize = fixed_size-1
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Bad lpButtonInfo->dwTotalSize=fixedSize-1",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+        sizeof(PHONEBUTTONINFO)-1;
+
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo,
+                               PHONEERR_STRUCTURETOOSMALL,
+                               FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // lpButtonInfo->dwTotalSize = real big
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld:Bad lpButtonInfo->dwTotalSize=realBig",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = 0x7FFFFFFF;
+
+
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo,
+                               PHONEERR_INVALPOINTER,
+                               TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: phoneButtonInfo->dwButtonText Offset value");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwButtonTextOffset between dwTotalSize and dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize = 16;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextOffset = dwTotalSize + 16;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwButtonTextOffset between dwTotalSize and dwAllocSize, bad dwSize not test for bug postphone");
+
+
+/*
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwButtonTextOffset between dwTotalSize and dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize = BIGBUFSIZE;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextOffset = dwTotalSize + 16;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, LINEERR_INVALPARAM, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+*/
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwButtonTextOffset between dwTotalSize and dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize = 0xffffffff;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextOffset = dwTotalSize + 16;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, LINEERR_INVALPARAM, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwButtonTextOffset > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize = 16;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextOffset = BIGBUFSIZE;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, LINEERR_INVALPARAM, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwButtonTextOffset = -1, good dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextSize = 16;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonTextOffset = 0xffffffff;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, LINEERR_INVALPARAM, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+		
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case: phoneButtonInfo->dwDevSpecificText Offset value");
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwDevSpecificButtonTextOffset between dwTotalSize and dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize = 16;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = dwTotalSize + 16;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwDevSpecificOffset between dwTotalSize and dwAllocSize, bad dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize = BIGBUFSIZE;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = dwTotalSize + 16;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, PHONEERR_OPERATIONFAILED, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwDevSpecificOffset between dwTotalSize and dwAllocSize, bad dwSize(-1)",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize = 0xffffffff;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = dwTotalSize + 16;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, PHONEERR_OPERATIONFAILED, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwDevSpecificOffset > dwAllocSize, good dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize = 16;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = BIGBUFSIZE;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, PHONEERR_OPERATIONFAILED, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: dwDevSpecificOffset = -1, good dwSize",
+        dwTestCase+1);
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	 dwAllocSize = BIGBUFSIZE;
+    dwTotalSize = sizeof(PHONEBUTTONINFO);
+    lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+         dwAllocSize);
+    lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = dwAllocSize;
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize = 16;
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = 0xffffffff;
+   
+    if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, PHONEERR_OPERATIONFAILED, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+		
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO) + (128 *sizeof(WCHAR))
+			);
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO) + (128*sizeof(char))
+			);
+    }
+    else
+    {
+    }
+
+    //
+    // Do set all field in ButtonInfo here
+    //
+
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+            sizeof(PHONEBUTTONINFO)+(128 *sizeof(WCHAR));
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+            sizeof(PHONEBUTTONINFO)+(128 *sizeof(char));
+    }
+    else
+    {
+    }
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+    //
+    // also use the dwDevSpecificSize fields for code coverage
+    //
+
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize= wcslen(L"Test String")+1;
+        lpVoid = (char*)(lpTapiPhoneTestInfo->lpButtonInfo);
+        lpVoid += sizeof(PHONEBUTTONINFO);
+        wcscpy((WCHAR*)lpVoid, L"Test String");
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize= strlen("Test String")+1;
+        lpVoid = (char*)(lpTapiPhoneTestInfo->lpButtonInfo);
+        lpVoid += sizeof(PHONEBUTTONINFO);
+        strcpy((char*)lpVoid, "Test String");
+    }
+    else
+    {
+    }
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = sizeof(PHONEBUTTONINFO);
+ 
+    if ( ! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO) + (128 *sizeof(WCHAR))
+			);
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO) + (128*sizeof(char))
+			);
+    }
+    else
+    {
+    }
+
+    //
+    // Do set all field in ButtonInfo here
+    //
+
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+            sizeof(PHONEBUTTONINFO)+(128 *sizeof(WCHAR));
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+            sizeof(PHONEBUTTONINFO)+(128 *sizeof(char));
+    }
+    else
+    {
+    }
+
+    lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+    //
+    // also use the dwDevSpecificSize fields for code coverage
+    //
+
+    if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize= wcslen(L"Test String")+1;
+        lpVoid = (char*)(lpTapiPhoneTestInfo->lpButtonInfo);
+        lpVoid += sizeof(PHONEBUTTONINFO);
+        wcscpy((WCHAR*)lpVoid, L"Test String");
+    }
+    else if(lpTapiPhoneTestInfo->lpPhoneCaps->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificSize= strlen("Test String")+1;
+        lpVoid = (char*)(lpTapiPhoneTestInfo->lpButtonInfo);
+        lpVoid += sizeof(PHONEBUTTONINFO);
+        strcpy((char*)lpVoid, "Test String");
+    }
+    else
+    {
+    }
+    lpTapiPhoneTestInfo->lpButtonInfo->dwDevSpecificOffset = sizeof(PHONEBUTTONINFO);
+ 
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetButtonInfo: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetButtonInfo  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsd.c b/private/tapi/qa/trapper/itest/tphone/itpsd.c
new file mode 100644
index 000000000..7300df3f6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsd.c
@@ -0,0 +1,973 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsd.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetData
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996           additional param test
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetData
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No Onwer privilege for hPhone
+// 4. Bad lpData
+// 5. Bad dwSize
+//
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetData(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwData1, dwData2;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetData <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: phoneSetData for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    //
+    // save dwData1 in dwData2
+    //
+
+    dwData1 = 0x5;
+    dwData2 = dwData1;
+
+    //
+    // lpTapiPhoneTestInfo->lpData points to dwData1
+    //
+
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    if (! DoPhoneSetData(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetData(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // compare set data and retrieved data
+    //
+
+    if(dwData2 !=  *((LPDWORD)lpTapiPhoneTestInfo->lpData))
+    {
+       fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    dwData1 = 0x5;
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneSetData(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPHONEHANDLE,
+                             FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No OWNER privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: No OWNER privilege for hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+		  0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    dwData1 = 0x5;
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    if (! DoPhoneSetData(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpData.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad lpData",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    dwData1 = 0x5;
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    //
+    // Bad lpData
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpData =
+            (LPDWORD)gdwInvalidPointers[i];
+
+        if (! DoPhoneSetData(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPOINTER,
+                             FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+	
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	 if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwSize=0",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    dwData1 = 0x5;
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = 0;
+
+    //
+    // Bad dwSize=0 is valid, so we expect success returned
+    //
+
+    if (! DoPhoneSetData(lpTapiPhoneTestInfo, TAPISUCCESS, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: Bad dwSize=realBig",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwSize = 0x7FFFFFFF;
+
+    if (! DoPhoneSetData(lpTapiPhoneTestInfo, PHONEERR_INVALPOINTER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    //
+    // save dwData1 in dwData2
+    //
+
+    dwData1 = 0x5;
+    dwData2 = dwData1;
+
+    //
+    // lpTapiPhoneTestInfo->lpData points to dwData1
+    //
+
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+     if ( ! DoPhoneSetData(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwDataID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumSetData-1);
+    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+			sizeof(DWORD));
+
+    //
+    // save dwData1 in dwData2
+    //
+
+    dwData1 = 0x5;
+    dwData2 = dwData1;
+
+    //
+    // lpTapiPhoneTestInfo->lpData points to dwData1
+    //
+
+    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData1;
+    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetData(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetData: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetData  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsdp.c b/private/tapi/qa/trapper/itest/tphone/itpsdp.c
new file mode 100644
index 000000000..77da417a6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsdp.c
@@ -0,0 +1,1000 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsdp.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetDisplay
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+     pgopi                      March 1996       additional param tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include <stdlib.h>
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetDisplay
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No owner privilege for hPhone
+// 4. Bad lpDisplay
+// 5. Bad dwSize
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetDisplay(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    LPSTR        lpsTestStr;
+    DWORD dwNumColumns;
+    DWORD dwNumRows;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetDisplay <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: phoneSetDisplay for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = (dwNumRows*dwNumColumns)*sizeof(char);
+
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### dwRow = %lx, dwColumn = %lx, dwSize = %lx",
+        dwNumRows, dwNumColumns, lpTapiPhoneTestInfo->dwSize);
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "lpsDisplay = %s",
+        lpTapiPhoneTestInfo->lpsDisplay);
+
+    if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetDisplay for verify");
+    //
+    // since we can expect a unicode string, we will allocate twice the
+    // amount of bytes for the string.
+    //
+
+    lpTapiPhoneTestInfo->lpDisplay = (LPVARSTRING)AllocFromTestHeap(
+			sizeof(VARSTRING)+(2*(dwNumRows*dwNumColumns)*sizeof(char)));
+    lpTapiPhoneTestInfo->lpDisplay->dwTotalSize =
+        2*(dwNumRows*dwNumColumns)*sizeof(char)+ sizeof(VARSTRING);
+    lpTapiPhoneTestInfo->lpDisplay->dwStringSize =
+        2*(dwNumRows*dwNumColumns)*sizeof(char);
+    lpTapiPhoneTestInfo->lpDisplay->dwStringOffset = sizeof(VARSTRING);
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpDisplay->dwTotalSize = %lx, neededSize = %lx",
+        (DWORD) lpTapiPhoneTestInfo->lpDisplay->dwTotalSize,
+        lpTapiPhoneTestInfo->lpDisplay->dwNeededSize);
+
+    if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+	
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### lpDisplay->dwTotalSize = %lx, neededSize = %lx",
+        (DWORD) lpTapiPhoneTestInfo->lpDisplay->dwTotalSize,
+        lpTapiPhoneTestInfo->lpDisplay->dwNeededSize);
+
+    lpsTestStr = (LPSTR)lpTapiPhoneTestInfo->lpDisplay;
+
+    //
+    // see raid bug #30836 (4/10/1996) for reason.
+    // we set dwStringFormat to STRINGFORMAT_ASCII even though
+    // phoneGetDisplay says it returning STRINGFORMAT_UNICODE
+    //
+
+    lpTapiPhoneTestInfo->lpDisplay->dwStringFormat = STRINGFORMAT_ASCII;
+    if(lpTapiPhoneTestInfo->lpDisplay->dwStringFormat == STRINGFORMAT_ASCII)
+    {
+        if(strcmp(lpTapiPhoneTestInfo->lpsDisplay,
+                  lpsTestStr+sizeof(VARSTRING)))
+        {
+            fTestPassed = FALSE;
+        }
+    }
+    else if(lpTapiPhoneTestInfo->lpDisplay->dwStringFormat == STRINGFORMAT_UNICODE)
+    {
+        LPSTR lpsAsciiStr = (LPSTR)AllocFromTestHeap
+            (lpTapiPhoneTestInfo->lpDisplay->dwStringSize/2);
+        wcstombs(lpsAsciiStr,
+                 (WCHAR*)(lpsTestStr+sizeof(VARSTRING)),
+                 wcslen((WCHAR*)(lpsTestStr+sizeof(VARSTRING)))+1);
+        if(strcmp(lpTapiPhoneTestInfo->lpsDisplay,
+                  lpsTestStr))
+        {
+            fTestPassed = FALSE;
+        }
+    }
+    else
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneCLose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = (dwNumRows*dwNumColumns)*sizeof(char);
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+        if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPHONEHANDLE,
+                                FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+
+    //
+    // phoneCLose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No Owner privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: No Owner privilege for hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = (dwNumRows*dwNumColumns)*sizeof(char);
+
+    if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo,
+                            PHONEERR_NOTOWNER,
+                            FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneCLose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Bad lpsDisplay.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	 if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad lpsDisplay",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = (dwNumRows*dwNumColumns)*sizeof(char);
+
+    //
+    // invalid pointer test for lpsDisplay
+    //
+
+    for(i=0; i < NUMINVALIDPOINTERS; i++)
+    {
+        lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)gdwInvalidPointers[i];
+
+        if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPOINTER,
+                                FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneCLose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: Bad dwSize.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad dwSize",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = 0;
+
+    //
+    // bad dwSize
+    //
+
+    if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo,
+                            TAPISUCCESS,
+                            FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneCLose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Shutdown and end the tests
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = (dwNumRows*dwNumColumns)*sizeof(char);
+
+
+    if ( ! DoPhoneSetDisplay(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwRow = 0;
+    dwNumRows = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumRows;
+    lpTapiPhoneTestInfo->dwColumn = 0;
+    dwNumColumns = lpTapiPhoneTestInfo->lpPhoneCaps->dwDisplayNumColumns;
+    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+			(dwNumRows*dwNumColumns)*sizeof(char));
+    strcpy(lpTapiPhoneTestInfo->lpsDisplay,"this is a test");
+    lpTapiPhoneTestInfo->dwSize = (dwNumRows*dwNumColumns)*sizeof(char);
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetDisplay(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetDisplay: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetDisplay  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsg.c b/private/tapi/qa/trapper/itest/tphone/itpsg.c
new file mode 100644
index 000000000..50b544506
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsg.c
@@ -0,0 +1,1017 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsg.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetGain
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetGain
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+//	2. Verify Setting Gain that exceed maximum and that 0x0000FFFF is returned
+//    from phoneSetGain.
+// 3. Bad hPhone
+// 4. No Owner privilege for hPhone
+// 5. BitVectorParamErrorTest for dwHookSwitchDevs
+// 6. BitVectorParamValidTest for dwHookSwitchDevs
+//
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetGain(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    DWORD  dwSaveSetGain;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetGain <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld:  phoneSetGain for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+    dwSaveSetGain = lpTapiPhoneTestInfo->dwGain ;
+
+    if (! DoPhoneSetGain(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetGain for verify");
+
+
+    if (! DoPhoneGetGain(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(dwSaveSetGain != lpTapiPhoneTestInfo->dwGain)
+        fTestPassed = FALSE;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Verify Setting Gain that exceed maximum and that
+    //               0x0000FFFF is returned  from phoneSetGain.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld:Verify Setting Gain that exceed maximum"
+        " and that 0x0000FFFF is returned from phoneSetGain.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwGain = 0x7FFFFFFF;
+
+
+    if (! DoPhoneSetGain(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetGain for verify");
+
+
+    if (! DoPhoneGetGain(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(0x0000FFFF != lpTapiPhoneTestInfo->dwGain)
+        fTestPassed = FALSE;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneSetGain(lpTapiPhoneTestInfo,
+                             PHONEERR_INVALPHONEHANDLE,
+                             FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: No owner privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld:  phoneSetGain for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+
+    if (! DoPhoneSetGain(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetGain for verify");
+
+
+    if (! DoPhoneGetGain(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: BitVectorParamErrorTest for dwHookSwitchDevs.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld:  BitVectorParamErrorTest for dwHookSwitchDevs",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+
+    //
+    // BitVectorParamErrorTest for dwHookSwitchDevs
+    //
+
+    if(! TestPhoneInvalidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetGain,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            PHONEERR_INVALHOOKSWITCHDEV,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET |
+             PHONEHOOKSWITCHDEV_SPEAKER |
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: BitVectorParamValidTest for dwHookSwitchDevs.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld:  BitVectorParamValidTest for dwHookSwitchDevs",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+
+    //
+    // BitVectorParamvalidTest for dwHookSwitchDevs
+    //
+
+    if(! TestPhoneValidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetGain,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+             PHONEHOOKSWITCHDEV_SPEAKER|
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+    dwSaveSetGain = lpTapiPhoneTestInfo->dwGain ;
+
+     if ( ! DoPhoneSetGain(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwGain = 0x2;
+    dwSaveSetGain = lpTapiPhoneTestInfo->dwGain ;
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetGain(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetGain: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetGain  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpshs.c b/private/tapi/qa/trapper/itest/tphone/itpshs.c
new file mode 100644
index 000000000..8a0db389d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpshs.c
@@ -0,0 +1,1157 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpshs.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetHookSwitch
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetHookSwitch
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No owner privilege for hPhone
+// 4. BitVectorErrorTest for dwHookSwitchDev
+// 5. BitVectorErrorTest for dwHookSwitchMode
+// 6. BitVectorValidTest for dwHookSwitchDevs
+// 7. BitVectorValidTest for dwHookSwitchMode
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetHookSwitch(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetHookSwitch <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: phoneSetHookSwitch for go/no-go for OWNER",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    if (! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(DBUG_SHOW_DETAIL, "#### Call phoneGetHookSwitch for verify");
+
+
+    if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if((lpTapiPhoneTestInfo->dwHookSwitchMode !=  PHONEHOOKSWITCHMODE_ONHOOK)&&
+       (lpTapiPhoneTestInfo->dwHookSwitchDevs !=  PHONEHOOKSWITCHDEV_HANDSET))
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo,
+                                   PHONEERR_INVALPHONEHANDLE,
+                                   FALSE))
+        {
+            TPHONE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No owner privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: No owner privilege for hPhone",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    if (! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: BitVectorParamErrorTest for dwHookSwitchDev.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: BitVectorParamErrorTest for dwHookSwitchDev",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = 0;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    //
+    // BitVectorParamErrorTest for dwHookSwitchDevs
+    //
+
+    if(! TestPhoneInvalidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetHookSwitch,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            PHONEERR_INVALHOOKSWITCHDEV,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET |
+             PHONEHOOKSWITCHDEV_SPEAKER |
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: BitVectorParamErrorTest for dwHookSwitchMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: BitVectorParamErrorTest for dwHookSwitchMode",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = 0;
+
+    //
+    // BitVectorParamErrorTest for dwHookSwitchMode
+    //
+
+    if(! TestPhoneInvalidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetHookSwitch,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchMode,
+            PHONEERR_INVALHOOKSWITCHMODE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHMODE_ONHOOK |
+             PHONEHOOKSWITCHMODE_MIC |
+             PHONEHOOKSWITCHMODE_SPEAKER |
+             PHONEHOOKSWITCHMODE_MICSPEAKER),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: BitVectorParamValidTest for dwHookSwitchDev.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: BitVectorParamValidTest for dwHookSwitchDev",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    //
+    // BitVectorParamValidTest for dwHookSwitchDevs
+    //
+
+    if(! TestPhoneValidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetHookSwitch,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+             PHONEHOOKSWITCHDEV_SPEAKER|
+             PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: BitVectorParamValidTest for dwHookSwitchMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: BitVectorParamValidTest for dwHookSwitchDev",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    //
+    // BitVectorParamValidTest for dwHookSwitchMode
+    //
+
+    if(! TestPhoneValidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetHookSwitch,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchMode,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHMODE_ONHOOK |
+             PHONEHOOKSWITCHMODE_MIC |
+             PHONEHOOKSWITCHMODE_SPEAKER |
+             PHONEHOOKSWITCHMODE_MICSPEAKER),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // phoneClose
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    if ( ! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwHookSwitchDevs = &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+    lpTapiPhoneTestInfo->dwHookSwitchDevs = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->dwHookSwitchMode = PHONEHOOKSWITCHMODE_ONHOOK;
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetHookSwitch: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetHookSwitch  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsl.c b/private/tapi/qa/trapper/itest/tphone/itpsl.c
new file mode 100644
index 000000000..65dd67c0f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsl.c
@@ -0,0 +1,922 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsl.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetLamp
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetLamp
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No owner privilege for hPhone
+// 4. BitVectorParamErrorTest for dwLampMode
+// 5. BitVectorParamValidTest for dwLampMode
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetLamp(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetLamp <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: phoneSetLamp for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    if (! DoPhoneSetLamp(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(DBUG_SHOW_DETAIL,"#### Call phoneGetLamp for verify");
+
+
+    if (! DoPhoneGetLamp(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpTapiPhoneTestInfo->dwLampMode != PHONELAMPMODE_FLUTTER)
+        fTestPassed = FALSE;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneSetLamp(lpTapiPhoneTestInfo,
+                              PHONEERR_INVALPHONEHANDLE,
+                              FALSE))
+         {
+            TPHONE_FAIL();
+         }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No owner privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: phoneSetLamp for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    if (! DoPhoneSetLamp(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: BitVectorParamErrorTest for dwLampMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: BitVectorParamErrorTest for dwLampMode",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    //
+    // BitVectorParamErrorTest for dwLampMode
+    //
+
+    if(! TestPhoneInvalidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetLamp,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwLampMode,
+            PHONEERR_INVALLAMPMODE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONELAMPMODE_BROKENFLUTTER|
+             PHONELAMPMODE_FLASH|
+             PHONELAMPMODE_FLUTTER |
+             PHONELAMPMODE_OFF|
+             PHONELAMPMODE_STEADY|
+             PHONELAMPMODE_WINK|
+             PHONELAMPMODE_DUMMY),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: BitVectorParamValidTest for dwLampMode.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+        sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: BitVectorParamValidTest for dwLampMode",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    //
+    // BitVectorParamValidTest for dwLampMode
+    //
+
+    if(! TestPhoneValidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetLamp,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwLampMode,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONELAMPMODE_BROKENFLUTTER|
+             PHONELAMPMODE_FLASH|
+             PHONELAMPMODE_FLUTTER |
+             PHONELAMPMODE_OFF|
+             PHONELAMPMODE_STEADY|
+             PHONELAMPMODE_WINK|
+             PHONELAMPMODE_DUMMY),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    if ( ! DoPhoneSetLamp(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwButtonLampID =
+        (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+        0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+    lpTapiPhoneTestInfo->lpdwLampMode = &(lpTapiPhoneTestInfo->dwLampMode);
+    lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetLamp(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	//
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetLamp: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetLamp  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsr.c b/private/tapi/qa/trapper/itest/tphone/itpsr.c
new file mode 100644
index 000000000..08c2e10a2
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsr.c
@@ -0,0 +1,789 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsr.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetRing
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetRing
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No owner privilege for hPhone
+// 4. Verify setting ring volume that exceeds maximum and that 0x0000FFFF is
+//    returned from phoneGetRing
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetRing(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetRing <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: phoneSetRing for go/no-go for OWNER",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwRingMode =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+    lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+    if (! DoPhoneSetRing(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetRing for verify");
+
+    if (! DoPhoneGetRing(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpTapiPhoneTestInfo->dwVolume != 0x3)
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Bad hPhone",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwRingMode =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+    lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneSetRing(lpTapiPhoneTestInfo,
+                              PHONEERR_INVALPHONEHANDLE,
+                              FALSE))
+         {
+            TPHONE_FAIL();
+         }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No owner privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: No owner privilege for hPhone. ",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwRingMode =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+    lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+    if (! DoPhoneSetRing(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: Verify setting ring volume that exceeds maximum and
+    // that 0x0000FFFF is returned from phoneGetRing.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Verify setting ring volume that exceeds maximum"
+        " and that 0x0000FFFF is returned from phoneGetRing",
+        dwTestCase+1);
+
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwRingMode =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+    lpTapiPhoneTestInfo->dwVolume = 0x7FFFFFFF;
+
+    if (! DoPhoneSetRing(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetRing for verify");
+
+    if (! DoPhoneGetRing(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpTapiPhoneTestInfo->dwVolume != 0x0000FFFF)
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwRingMode =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+    lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+ 
+    if ( ! DoPhoneSetRing(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwRingMode = &(lpTapiPhoneTestInfo->dwRingMode);
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwRingMode =
+        lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+    lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetRing(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetRing: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetRing  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+	
+	
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpssm.c b/private/tapi/qa/trapper/itest/tphone/itpssm.c
new file mode 100644
index 000000000..4d9a87718
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpssm.c
@@ -0,0 +1,1646 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpssm.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetStatusMessages
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetStatusMessages
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Baf hPhone
+// 3. BitVectorParamErrorTest for dwPhoneStates
+// 4. BitVectorParamErrorTest for dwButtonModes
+// 5. BitVectorParamErrorTest for dwButtonStates
+// 6. BitVectorParamValidTest for dwPhoneStates
+// 7. BitVectorParamValidTest for dwButtonModes
+// 8. BitVectorParamValidTest for dwButtonStates
+// 9. Verify that PHONE_STATE and PHONE_BUTTON msgs sent and filetered
+//    correctly.
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetStatusMessages(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+    DWORD dwVariation=0;
+    
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetStatusMessages <<<<<<<<<<<<<<<<<");
+    
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  phoneSetStatusMessages for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetStatusMessages for verify");
+
+
+    if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // REINIT cannot be masked so we have to take care of that into account
+    // when we do the verification
+    //
+
+    if((lpTapiPhoneTestInfo->dwPhoneStates != ( PHONESTATE_REINIT| PHONESTATE_CONNECTED)) ||
+       (lpTapiPhoneTestInfo->dwButtonModes != PHONEBUTTONMODE_CALL) ||
+       (lpTapiPhoneTestInfo->dwButtonStates != PHONEBUTTONSTATE_UP))
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo,
+                                        PHONEERR_INVALPHONEHANDLE))
+         {
+            TPHONE_FAIL();
+         }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: BitVectorParamErrorTest for dwPhoneStates.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  BitVectorParamErrorTest for dwPhoneStates.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = 0;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    //
+    // BitVectorParamErrorTest for dwPhoneStates
+    //
+
+    if(! TestPhoneInvalidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetStatusMessages,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwPhoneStates,
+            PHONEERR_INVALPHONESTATE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONESTATE_OTHER|
+            PHONESTATE_CONNECTED|
+            PHONESTATE_DISCONNECTED|
+            PHONESTATE_OWNER|
+            PHONESTATE_MONITORS|
+            PHONESTATE_DISPLAY|
+            PHONESTATE_LAMP|
+            PHONESTATE_RINGMODE|
+            PHONESTATE_RINGVOLUME|
+            PHONESTATE_HANDSETHOOKSWITCH|
+            PHONESTATE_HANDSETVOLUME|
+            PHONESTATE_HANDSETGAIN|
+            PHONESTATE_SPEAKERHOOKSWITCH|
+            PHONESTATE_SPEAKERVOLUME|
+            PHONESTATE_SPEAKERGAIN|
+            PHONESTATE_HEADSETHOOKSWITCH|
+            PHONESTATE_HEADSETVOLUME|
+            PHONESTATE_HEADSETGAIN|
+            PHONESTATE_SUSPEND|
+            PHONESTATE_RESUME|
+            PHONESTATE_DEVSPECIFIC|
+            PHONESTATE_REINIT|
+            PHONESTATE_CAPSCHANGE|
+            PHONESTATE_REMOVED),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xFFFFFFFF,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: BitVectorParamErrorTest for dwButtonModes.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  BitVectorParamErrorTest for dwButtonModes.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = 0;//PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    //
+    // BitVectorParamErrorTest for dwButtonModes
+    //
+
+    if(! TestPhoneInvalidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetStatusMessages,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwButtonModes,
+            PHONEERR_INVALBUTTONMODE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEBUTTONMODE_CALL|
+            PHONEBUTTONMODE_FEATURE|
+            PHONEBUTTONMODE_KEYPAD|
+            PHONEBUTTONMODE_LOCAL|
+            PHONEBUTTONMODE_DISPLAY),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x0000001F,
+            0xFFFFFFFF,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: BitVectorParamErrorTest for dwButtonStates.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  BitVectorParamErrorTest for dwButtonStates.",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = 0;//PHONEBUTTONSTATE_UP;
+
+    //
+    // BitVectorParamErrorTest for dwButtonStates
+    //
+
+    if(! TestPhoneInvalidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetStatusMessages,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwButtonStates,
+            PHONEERR_INVALBUTTONSTATE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEBUTTONSTATE_UP|
+            PHONEBUTTONSTATE_DOWN|
+            PHONEBUTTONSTATE_UNKNOWN|
+            PHONEBUTTONSTATE_UNAVAIL),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xFFFFFFFF,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: BitVectorParamValidTest for dwPhoneStates.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  BitVectorParamValidTest for dwPhoneStates",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    //
+    // BitVectorParamValidTest for dwPhoneSTates
+    //
+
+    if(! TestPhoneValidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetStatusMessages,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwPhoneStates,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONESTATE_OTHER|
+            PHONESTATE_CONNECTED|
+            PHONESTATE_DISCONNECTED|
+            PHONESTATE_OWNER|
+            PHONESTATE_MONITORS|
+            PHONESTATE_DISPLAY|
+            PHONESTATE_LAMP|
+            PHONESTATE_RINGMODE|
+            PHONESTATE_RINGVOLUME|
+            PHONESTATE_HANDSETHOOKSWITCH|
+            PHONESTATE_HANDSETVOLUME|
+            PHONESTATE_HANDSETGAIN|
+            PHONESTATE_SPEAKERHOOKSWITCH|
+            PHONESTATE_SPEAKERVOLUME|
+            PHONESTATE_SPEAKERGAIN|
+            PHONESTATE_HEADSETHOOKSWITCH|
+            PHONESTATE_HEADSETVOLUME|
+            PHONESTATE_HEADSETGAIN|
+            PHONESTATE_SUSPEND|
+            PHONESTATE_RESUME|
+            PHONESTATE_DEVSPECIFIC|
+            PHONESTATE_REINIT|
+            PHONESTATE_CAPSCHANGE|
+            PHONESTATE_REMOVED),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: BitVectorParamValidTest for dwButtonModes.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  BitVectorParamValidTest for dwButtonModes",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    //
+    // BitVectorParamValidTest for dwButtonModes
+    //
+
+    if(! TestPhoneValidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetStatusMessages,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwButtonModes,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEBUTTONMODE_CALL|
+            PHONEBUTTONMODE_FEATURE|
+            PHONEBUTTONMODE_KEYPAD|
+            PHONEBUTTONMODE_LOCAL|
+            PHONEBUTTONMODE_DISPLAY),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: BitVectorParamValidTest for dwButtonStates.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  BitVectorParamValidTest for dwButtonStates",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    //
+    // BitVectorParamValidTest for dwButtonStates
+    //
+
+    if(! TestPhoneValidBitFlags(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetStatusMessages,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwButtonStates,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEBUTTONSTATE_UP|
+            PHONEBUTTONSTATE_DOWN|
+            PHONEBUTTONSTATE_UNKNOWN|
+            PHONEBUTTONSTATE_UNAVAIL),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case:Verify PHONE_STATE and PHONE_BUTTON msgs sent and
+    //              filtered correctly.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+    
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test case %ld:  Verify PHONE_STATE and PHONE_BUTTON msgs are"
+        " sent and filtered correctly",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_DISPLAY;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_DISPLAY;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = PHONE_STATE;
+    info.u.EspMsg.dwParam1 = PHONESTATE_DISPLAY;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiPhoneTestInfo->lpParams = &info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the PHONESTATE_DISPLAY message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_STATE,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               PHONESTATE_DISPLAY,
+               0x00000000,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM1));
+
+    if(!DoPhoneDevSpecific(lpTapiPhoneTestInfo,TAPISUCCESS,TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TPHONE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "PHONESTATE_DISPLAY msg not received");
+        dwVariation++;
+        
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = PHONE_BUTTON;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = PHONEBUTTONMODE_DISPLAY;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiPhoneTestInfo->lpParams = &info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the PHONESTATE_DISPLAY message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_BUTTON,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               0x00000000,
+               PHONEBUTTONMODE_DISPLAY,
+               0x00000000,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM2));
+
+    if(!DoPhoneDevSpecific(lpTapiPhoneTestInfo,TAPISUCCESS,TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TPHONE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "PHONEBUTTONMODE_DISPLAY msg not received");
+        dwVariation++;
+        
+    }
+
+    //
+    // Use a hook to generate an ESP event using phoneDevSpecific.
+    // look in tcore\devspec.h for details
+    //
+    
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+    
+    //
+    // make sure to use the SPI (not API) msg params here (not
+    // necessarily the same)
+    //
+
+    info.u.EspMsg.dwMsg    = PHONE_BUTTON;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = PHONEBUTTONSTATE_UP;
+
+    lpTapiPhoneTestInfo->lpParams = &info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+
+    //
+    // Add the PHONESTATE_DISPLAY message to the list of expected
+    // messages.
+    //
+
+    AddMessage(PHONE_BUTTON,
+               0x00000000,
+               (DWORD) lpCallbackParams,
+               0x00000000,
+               0x00000000,
+               PHONEBUTTONSTATE_UP,
+               (TAPIMSG_DWMSG |
+                TAPIMSG_DWPARAM3));
+
+    if(!DoPhoneDevSpecific(lpTapiPhoneTestInfo,TAPISUCCESS,TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpCallbackParams->lpExpTapiMsgs != NULL)
+    {
+        TPHONE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "PHONEBUTTONSTATE_UP msg not received");
+        dwVariation++;
+        
+    }
+
+    if(dwVariation != 0)
+        fTestPassed = FALSE;
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+ 
+    if ( ! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->lpdwPhoneStates =
+        &(lpTapiPhoneTestInfo->dwPhoneStates);
+    lpTapiPhoneTestInfo->lpdwButtonModes =
+        &(lpTapiPhoneTestInfo->dwButtonModes);
+    lpTapiPhoneTestInfo->lpdwButtonStates =
+        &(lpTapiPhoneTestInfo->dwButtonStates);
+    lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+    lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+    lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+    if ( ! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, info.u.EspResult.lResult))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+ 
+   //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetStatusMessage: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetStatusMessage  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+	
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/itpsv.c b/private/tapi/qa/trapper/itest/tphone/itpsv.c
new file mode 100644
index 000000000..6a4a656a3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/itpsv.c
@@ -0,0 +1,1018 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpsv.c
+
+Abstract:
+
+    This module contains the test functions for phoneSetVolume
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+
+//  phoneSetVolume
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// 1. Go/No-Go test
+// 2. Bad hPhone
+// 3. No owner privilege for hPhone
+// 4. BitVectorParamErrorTest for dwHookSwitchDev
+// 5. BitVectorParamValidTest for dwHookSwitchDev
+// 6. Verify Setting volume that exceeds maximum and that 0x0000FFFF is
+//    returned by phoneGetVolume
+//
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetVolume(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    INT i;
+    LPCALLBACKPARAMS lpCallbackParams;
+    ESPDEVSPECIFICINFO   info;
+    INT n;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+	
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>>>>>>>>>> Test phoneSetVolume <<<<<<<<<<<<<<<<<");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: Go/No-Go test for owner.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld:  phoneSetVolume for go/no-go for OWNER",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+    if (! DoPhoneSetVolume(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetVolume for verify");
+
+
+    if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpTapiPhoneTestInfo->dwVolume != 0x7)
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: Bad hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld:  Bad hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+    //
+    // save the original  hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone_Orig  = lpTapiPhoneTestInfo->hPhone1;
+
+
+    //
+    // bad hPhone
+    //
+
+    for(i=0; i < NUMINVALIDHANDLES; i++)
+    {
+        *lpTapiPhoneTestInfo->lphPhone = (HPHONE)gdwInvalidHandles[i];
+
+	     if (! DoPhoneSetVolume(lpTapiPhoneTestInfo,
+                                PHONEERR_INVALPHONEHANDLE,
+                                FALSE))
+         {
+            TPHONE_FAIL();
+         }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Restore hPhone
+    //
+
+    lpTapiPhoneTestInfo->hPhone1 = lpTapiPhoneTestInfo->hPhone_Orig;
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: No owner privilege for hPhone.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_MONITOR;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld:  No owner privilege for hPhone",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+    if (! DoPhoneSetVolume(lpTapiPhoneTestInfo, PHONEERR_NOTOWNER, FALSE))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: BitVectorParamErrorTest for dwHookSwitchDev.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld:  BitVectorParamErrorTest for dwHookSwitchDev",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = 0;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+    //
+    // BitVectorParamErrorTest for dwHookSwitchDev
+    //
+
+    if(! TestPhoneInvalidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetVolume,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            PHONEERR_INVALHOOKSWITCHDEV,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+            PHONEHOOKSWITCHDEV_SPEAKER|
+            PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: BitVectorParamValidTest for dwHookSwitchDev.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld:  BitVectorParamValidTest for dwHookSwitchDev",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+    //
+    // BitVectorParamValidTest for dwHookSwitchDev
+    //
+
+    if(! TestPhoneValidBitFlagsAsy(
+            lpTapiPhoneTestInfo,
+            DoPhoneSetVolume,
+            (LPDWORD) &lpTapiPhoneTestInfo->dwHookSwitchDev,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            (PHONEHOOKSWITCHDEV_HANDSET|
+            PHONEHOOKSWITCHDEV_SPEAKER|
+            PHONEHOOKSWITCHDEV_HEADSET),
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: Verify Setting volume that exceeds maximum and that
+    //               0x0000FFFF is returned by phoneGetVolume.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    fTestPassed                  = TRUE;
+
+    //
+    // Initialize a phone app
+    //
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+    TapiLogDetail(
+		DBUG_SHOW_PASS,
+		">> Test Case %ld:  Verify Setting volume that exceeds maximum"
+        " and that 0x0000FFFF is returned by phoneGetVolume",
+        dwTestCase+1);
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7FFFFFFF;
+
+    if (! DoPhoneSetVolume(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+    {
+        TPHONE_FAIL();
+    }
+
+    TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "#### Call phoneGetVolume for verify");
+
+
+    if (! DoPhoneGetVolume(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if(lpTapiPhoneTestInfo->dwVolume != 0x0000FFFF)
+    {
+        fTestPassed = FALSE;
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //
+    // Close the phone
+    //
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Shutdown
+    //
+
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    FreeTestHeap();
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+
+    if ( ! DoPhoneSetVolume(lpTapiPhoneTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo                      = GetPhoneTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->lphPhone = &lpTapiPhoneTestInfo->hPhone1;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = PHONEERR_RESOURCEUNAVAIL;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+    lpTapiPhoneTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoPhoneDevSpecific(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+      {
+          TPHONE_FAIL();
+      }
+
+    lpTapiPhoneTestInfo->dwHookSwitchDev = PHONEHOOKSWITCHDEV_HANDSET;
+    lpTapiPhoneTestInfo->lpdwVolume = &(lpTapiPhoneTestInfo->dwVolume);
+    lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+
+    lpTapiPhoneTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoPhoneSetVolume(lpTapiPhoneTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TPHONE_FAIL();
+      }
+
+    AddMessage(
+         PHONE_REPLY,
+         0x00000000,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TPHONE_FAIL();
+    }
+
+    
+    lpTapiPhoneTestInfo->fCompletionModeSet = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ PhoneSetVolume: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing PhoneSetVolume  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;	
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/msgphone.c b/private/tapi/qa/trapper/itest/tphone/msgphone.c
new file mode 100644
index 000000000..579157673
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/msgphone.c
@@ -0,0 +1,504 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    msgphone.c
+
+Abstract:
+
+    This module contains the test functions for all message sent test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 5-9-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "tphone.h"
+
+#define NUMMSGS  5
+#define NUMMSG   5
+
+
+#define 	ITP_BUTTON          0
+#define 	ITP_CLOSE 			  1
+#define 	ITP_CREATE			  2
+#define 	ITP_DEVSPECIFIC	  3
+#define 	ITP_STATE			  4
+
+
+typedef struct _MSGLIST
+{
+      char  szMsg[32];
+      DWORD dwMsg;
+} MSGLIST, *PMSGLIST;
+
+ESPDEVSPECIFICINFO info;
+DWORD  dwHandle;
+
+
+DWORD MsgPhoneCommFunc(LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo, BOOL fQuietMode);
+
+
+BOOL TestPhoneMessages(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+    LONG lResult;
+    DWORD dwParam;    
+    DWORD dwParam1;    
+    DWORD dwMsg;
+	 LPDWORD	lpRequestBuf;
+	 LONG lret;
+	 LPTAPIMSG lpTapiMsg = NULL;
+	 LPTAPIMSG lpMatch;
+  
+    MSGLIST MsgList[] =
+		{
+		{ "PHONE_BUTTON",		    PHONE_BUTTON },
+		{ "PHONE_CLOSE",         PHONE_CLOSE },
+		{ "PHONE_CREATE",        PHONE_CREATE },
+		{ "PHONE_DEVSPECIFIC",	 PHONE_DEVSPECIFIC },
+		{ "PHONE_STATE",		    PHONE_STATE }
+	};		
+
+
+
+    InitTestNumber();
+    TapiPhoneTestInit();
+    lpTapiPhoneTestInfo = GetPhoneTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiPhoneTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing phone messages  <<<<<<<<"
+            );
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    for(n = 0; n< NUMMSG; n++)
+    {
+            
+       TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Test %s message", 
+                    dwTestCase + 1, MsgList[n].szMsg);
+
+       info.u.EspMsg.dwMsg = MsgList[n].dwMsg;
+
+       switch (n)
+        {
+        case ITP_BUTTON:
+          for(dwParam = PHONEBUTTONMODE_DUMMY; dwParam <= PHONEBUTTONMODE_DISPLAY; )
+          {
+           for(dwParam1 = PHONEBUTTONSTATE_UP; dwParam1 <= PHONEBUTTONSTATE_UNAVAIL;)
+           {
+           TapiPhoneTestInit();
+          lpTapiPhoneTestInfo = GetPhoneTestInfo();
+          lpCallbackParams = GetCallbackParams();
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = dwParam;
+          info.u.EspMsg.dwParam3 = dwParam1;
+          fTestPassed = MsgPhoneCommFunc(lpTapiPhoneTestInfo, TRUE);
+          lpTapiPhoneTestInfo->lpdwPhoneStates =
+              &(lpTapiPhoneTestInfo->dwPhoneStates);
+          lpTapiPhoneTestInfo->lpdwButtonModes =
+              &(lpTapiPhoneTestInfo->dwButtonModes);
+          lpTapiPhoneTestInfo->lpdwButtonStates =
+              &(lpTapiPhoneTestInfo->dwButtonStates);
+          lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_DEVSPECIFIC;
+          lpTapiPhoneTestInfo->dwButtonModes = dwParam;
+          lpTapiPhoneTestInfo->dwButtonStates = dwParam1;
+
+          if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+          {
+              TPHONE_FAIL();
+          }
+
+			 dwHandle = (DWORD) lpTapiPhoneTestInfo->hPhone1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2 | TAPIMSG_DWPARAM3
+                    );
+
+           lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+           lpTapiPhoneTestInfo->dwSize = sizeof(info);
+           if(! DoPhoneDevSpecific (lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+             {
+                TPHONE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TPHONE_FAIL();
+             }
+
+          if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+              TPHONE_FAIL();
+            }
+          (INT) dwParam1 <<= 1;
+          }
+          (INT) dwParam <<= 1;
+          }
+          FreeTestHeap();
+          break;
+
+        case ITP_CLOSE:       
+          TapiPhoneTestInit();
+          lpTapiPhoneTestInfo = GetPhoneTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgPhoneCommFunc(lpTapiPhoneTestInfo, TRUE);
+          dwHandle = 0;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+           lpTapiPhoneTestInfo->dwSize = sizeof(info);
+           if(! DoPhoneDevSpecific (lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+             {
+                TPHONE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TPHONE_FAIL();
+             }
+
+
+          if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+              TPHONE_FAIL();
+            }
+          FreeTestHeap();
+          break;
+
+        case ITP_CREATE:       
+          TapiPhoneTestInit();
+          lpTapiPhoneTestInfo = GetPhoneTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgPhoneCommFunc(lpTapiPhoneTestInfo, TRUE);
+     		 dwHandle = (DWORD) lpTapiPhoneTestInfo->hPhone1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+           lpTapiPhoneTestInfo->dwSize = sizeof(info);
+           if(! DoPhoneDevSpecific (lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+             {
+                TPHONE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TPHONE_FAIL();
+             }
+
+
+          if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+              TPHONE_FAIL();
+            }
+           FreeTestHeap();
+           break;
+
+        case ITP_DEVSPECIFIC:       
+          TapiPhoneTestInit();
+          lpTapiPhoneTestInfo = GetPhoneTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgPhoneCommFunc(lpTapiPhoneTestInfo, TRUE);
+			 dwHandle = (DWORD) lpTapiPhoneTestInfo->hPhone1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+           lpTapiPhoneTestInfo->dwSize = sizeof(info);
+           if(! DoPhoneDevSpecific (lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+             {
+                TPHONE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TPHONE_FAIL();
+             }
+
+
+          if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+              TPHONE_FAIL();
+            }
+          FreeTestHeap();
+           break;
+
+        case ITP_STATE:       
+          for(dwParam = PHONESTATE_OTHER; dwParam <= PHONESTATE_REMOVED; )
+          {
+TapiLogDetail(
+DBUG_SHOW_DETAIL,
+"dwParam = %lx", dwParam);
+          info.u.EspMsg.dwParam1 = dwParam;
+          if(info.u.EspMsg.dwParam1 >= PHONESTATE_HANDSETHOOKSWITCH &&
+              info.u.EspMsg.dwParam1 <= PHONESTATE_HEADSETVOLUME) 
+          for(dwParam1 = PHONEHOOKSWITCHMODE_ONHOOK; 
+              dwParam1 <= PHONEHOOKSWITCHMODE_UNKNOWN;)
+          {         
+          info.u.EspMsg.dwParam2 = dwParam1;
+          info.u.EspMsg.dwParam3 = 0;
+          TapiPhoneTestInit();
+          lpTapiPhoneTestInfo = GetPhoneTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          fTestPassed = MsgPhoneCommFunc(lpTapiPhoneTestInfo, TRUE);
+			 dwHandle = (DWORD) lpTapiPhoneTestInfo->hPhone1;
+          lpTapiPhoneTestInfo->lpdwPhoneStates =
+              &(lpTapiPhoneTestInfo->dwPhoneStates);
+          lpTapiPhoneTestInfo->lpdwButtonModes =
+              &(lpTapiPhoneTestInfo->dwButtonModes);
+          lpTapiPhoneTestInfo->lpdwButtonStates =
+              &(lpTapiPhoneTestInfo->dwButtonStates);
+          lpTapiPhoneTestInfo->dwPhoneStates = dwParam;
+          lpTapiPhoneTestInfo->dwButtonModes = 0;
+          lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+          if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+          {
+              TPHONE_FAIL();
+          }
+
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+                    );
+
+           lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+           lpTapiPhoneTestInfo->dwSize = sizeof(info);
+           if(! DoPhoneDevSpecific (lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+             {
+                TPHONE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TPHONE_FAIL();
+             }
+          if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+              TPHONE_FAIL();
+            }
+          (INT) dwParam1 <<= 1;
+          }
+          else
+          {
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          TapiPhoneTestInit();
+          lpTapiPhoneTestInfo = GetPhoneTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          fTestPassed = MsgPhoneCommFunc(lpTapiPhoneTestInfo, TRUE);
+			 dwHandle = (DWORD) lpTapiPhoneTestInfo->hPhone1;
+          lpTapiPhoneTestInfo->lpdwPhoneStates =
+              &(lpTapiPhoneTestInfo->dwPhoneStates);
+          lpTapiPhoneTestInfo->lpdwButtonModes =
+              &(lpTapiPhoneTestInfo->dwButtonModes);
+          lpTapiPhoneTestInfo->lpdwButtonStates =
+              &(lpTapiPhoneTestInfo->dwButtonStates);
+          lpTapiPhoneTestInfo->dwPhoneStates = dwParam;
+          lpTapiPhoneTestInfo->dwButtonModes = 0;
+          lpTapiPhoneTestInfo->dwButtonStates = 0;
+
+          if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo, TAPISUCCESS))
+          {
+              TPHONE_FAIL();
+          }
+
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiPhoneTestInfo->lpParams = (LPVOID)&info;
+           lpTapiPhoneTestInfo->dwSize = sizeof(info);
+           if(! DoPhoneDevSpecific (lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+             {
+                TPHONE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TPHONE_FAIL();
+             }
+
+          if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+            {
+              TPHONE_FAIL();
+            }
+          }
+          (INT) dwParam <<= 1;
+          }
+          FreeTestHeap();
+          break;
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	  }
+    
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ phone Messages test: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing phone messages  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+DWORD MsgPhoneCommFunc(LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo, BOOL fQuietMode)
+{
+    BOOL fTestPassed  = TRUE;
+
+
+    lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+    lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams =
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =
+         sizeof(PHONEINITIALIZEEXPARAMS);
+    lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions =
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Negotiate the API Version
+    //
+
+    lpTapiPhoneTestInfo->dwDeviceID =
+        (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+    lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Get the phone device capabilities
+    //
+
+    lpTapiPhoneTestInfo->lpPhoneCaps =
+        (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    //
+    // Open a phone
+    //
+
+    lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+    if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    return fTestPassed;
+}
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/tphone.c b/private/tapi/qa/trapper/itest/tphone/tphone.c
new file mode 100644
index 000000000..0fac2d93f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphone.c
@@ -0,0 +1,510 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tphone.c
+
+Abstract:
+
+    This module contains functions for testing Telephony phone device APIs.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "tphone.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTphoneDll   = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TTphoneDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTphoneDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+
+BOOL
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestPhoneUninit(TRUE, TRUE));
+}
+
+
+BOOL
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneDevSpecific(TRUE, TRUE));
+}
+
+
+BOOL
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneNegotiateExtVersion(TRUE, TRUE));
+}
+
+
+BOOL
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetIcon(TRUE, TRUE));
+}
+
+
+BOOL
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetID(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetStatus(TRUE, TRUE));
+}
+
+
+BOOL
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetButtonInfo(TRUE, TRUE));
+}
+
+
+BOOL
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetButtonInfo(TRUE, TRUE));
+}
+
+
+BOOL
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetData(TRUE, TRUE));
+}
+
+BOOL
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetData(TRUE, TRUE));
+}
+
+
+BOOL
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetDisplay(TRUE, TRUE));
+}
+
+
+BOOL
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetDisplay(TRUE, TRUE));
+}
+
+
+BOOL
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetGain(TRUE, TRUE));
+}
+
+
+BOOL
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetGain(TRUE, TRUE));
+}
+
+
+BOOL
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetHookSwitch(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test16(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetHookSwitch(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test17(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetLamp(TRUE, TRUE));
+}
+
+
+
+BOOL
+Test18(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetLamp(TRUE, TRUE));
+}
+
+
+
+
+
+BOOL
+Test19(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetRing(TRUE, TRUE));
+}
+
+
+BOOL
+Test20(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetRing(TRUE, TRUE));
+}
+
+
+
+
+
+
+BOOL
+Test21(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetStatusMessages(TRUE, TRUE));
+}
+
+
+BOOL
+Test22(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetStatusMessages(TRUE, TRUE));
+}
+
+
+
+
+BOOL
+Test23(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetVolume(TRUE, TRUE));
+}
+
+
+BOOL
+Test24(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetVolume(TRUE, TRUE));
+}
+
+
+BOOL
+Test25(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneClose(TRUE, TRUE));
+}
+
+
+BOOL
+Test26(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetDevCaps(TRUE, TRUE));
+}
+
+BOOL
+Test27(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneInitialize(TRUE, TRUE));
+}
+
+BOOL
+Test28(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneNegotiateAPIVersion(TRUE, TRUE));
+}
+
+BOOL
+Test29(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneOpen(TRUE, TRUE));
+}
+
+BOOL
+Test30(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneShutdown(TRUE, TRUE));
+}
+
+
+
+BOOL
+WINAPI
+Test31(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestPhoneInitializeEx(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test32(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestPhoneGetMessage(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test33(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneConfigDialog(TRUE, TRUE));
+}
+
+
+BOOL
+WINAPI
+Test34(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneMessages(TRUE, FALSE));
+}
+
+
+
+
+BOOL
+ShouldTapiPhoneTestAbort(BOOL fQuiteMode)
+{
+	return FALSE;
+}
diff --git a/private/tapi/qa/trapper/itest/tphone/tphone.h b/private/tapi/qa/trapper/itest/tphone/tphone.h
new file mode 100644
index 000000000..10fc4f446
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphone.h
@@ -0,0 +1,305 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    tphone.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI phone device functions.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef TPHONE_H
+#define TPHONE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+// Macro for handling failures
+#define TPHONE_FAIL()  {                                                      \
+                           if (ShouldTapiPhoneTestAbort(fQuietMode))          \
+                           {                                                  \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp1); \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp2); \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp3); \
+                               return FALSE;                                  \
+                           }                                                  \
+                           fTestPassed = FALSE;                               \
+                       }
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+ShouldTapiPhoneTestAbort(
+	BOOL fQuiteMode
+	);
+
+
+BOOL
+TestPhoneConfigDialog(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+
+BOOL
+TestPhoneDevSpecific(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetButtonInfo(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetData(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetDisplay(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetGain(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetHookSwitch(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetIcon(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetID(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetLamp(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+
+BOOL
+TestPhoneGetRing(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetStatus(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+BOOL
+TestPhoneGetStatusMessages(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneGetVolume(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneNegotiateExtVersion(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetButtonInfo(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneSetData(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneSetDisplay(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetGain(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetHookSwitch(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetLamp(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetRing(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneSetStatusMessages(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneSetVolume(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneClose(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+BOOL
+TestPhoneGetDevCaps(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneInitialize(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneNegotiateAPIVersion(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneOpen(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+
+
+BOOL
+TestPhoneShutdown(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+BOOL
+TestPhoneInitializeEx(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestPhoneGetMessage(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestPhoneUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestPhoneMessages(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+#endif  // TPHONE_H
+
diff --git a/private/tapi/qa/trapper/itest/tphone/tphone.inc b/private/tapi/qa/trapper/itest/tphone/tphone.inc
new file mode 100644
index 000000000..5834818e0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphone.inc
@@ -0,0 +1,90 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=Ttphone
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib 
+
+
+DLLDEF= ..\ttphone.def
+DLLBASE=0x6a000000
+
+INCLUDES=..\..;..;..\..\..\..\tcore;..\..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=..\tphone.c \
+		..\itpcd.c	 \
+		..\itpds.c	 \
+		..\itpgbi.c \
+		..\itpgd.c	 \
+		..\itpgdp.c \
+		..\itpgg.c	 \
+		..\itpghs.c \
+		..\itpgi.c	 \
+		..\itpgid.c \
+		..\itpgl.c	 \
+		..\itpgr.c	 \
+		..\itpgs.c	 \
+		..\itpgsm.c \
+		..\itpgv.c	 \
+		..\itpsbi.c \
+		..\itpsd.c	 \
+		..\itpsdp.c \
+		..\itpsg.c	 \
+		..\itpshs.c \
+		..\itpsl.c	 \
+		..\itpsr.c	 \
+		..\itpssm.c \
+		..\itpsv.c	 \
+		..\itpne.c	 \
+		..\itpc.c	\
+		..\itpgdc.c \
+		..\itpi.c	\
+		..\itpnav.c  \
+		..\itpo.c	\
+		..\itps.c	\
+		..\itpie.c \
+		..\itpgm.c \
+        ..\uline.c \
+        ..\msgphone.c \
+        ..\version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=TTphoneDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tphone/tphonea/makefile b/private/tapi/qa/trapper/itest/tphone/tphonea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphonea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tphone/tphonea/sources b/private/tapi/qa/trapper/itest/tphone/tphonea/sources
new file mode 100644
index 000000000..6a831b846
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphonea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tphone.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/tphone/tphonew/makefile b/private/tapi/qa/trapper/itest/tphone/tphonew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphonew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tphone/tphonew/sources b/private/tapi/qa/trapper/itest/tphone/tphonew/sources
new file mode 100644
index 000000000..cf622b33b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/tphonew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tphone.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tphone/ttphone.def b/private/tapi/qa/trapper/itest/tphone/ttphone.def
new file mode 100644
index 000000000..7b5d404c8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/ttphone.def
@@ -0,0 +1,44 @@
+LIBRARY         tphone
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
+        Test16
+        Test17
+        Test18
+        Test19
+        Test20
+        Test21
+        Test22
+        Test23
+        Test24
+        Test25
+        Test26
+        Test27
+        Test28
+        Test29
+        Test30
+        Test31
+        Test32
+        Test33
+        Test34
diff --git a/private/tapi/qa/trapper/itest/tphone/uline.c b/private/tapi/qa/trapper/itest/tphone/uline.c
new file mode 100644
index 000000000..cf8860c14
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/uline.c
@@ -0,0 +1,543 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the test functions for all  uninitialize
+    phone APIs test
+
+Author:
+
+    Palamalai Gopalakrishnan (pgopi) 3-8-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "tphone.h"
+
+
+#define DWNUMCALLS 1
+
+#define DWNUMAPIS  29
+
+char szApiName[DWNUMAPIS][48] =
+{
+    "phoneClose",
+    "phoneConfigDialog",
+    "phoneDevSpecific",
+    "phoneGetButtonInfo",
+    "phoneGetData",
+    "phoneGetDevCaps",
+    "phoneGetDisplay",
+    "phoneGetGain",
+    "phoneGetHookSwitch",
+    "phoneGetIcon",
+    "phoneGetId",
+    "phoneGetLamp",
+    "phoneGetRing",
+    "phoneGetStatus",
+    "phoneGetStatusMessages",
+    "phoneGetVolume",
+    "phoneNegotiateAPIVersion",
+    "phoneNegotiateExtVersion",
+    "phoneOpen",
+    "phoneSetButtonInfo",
+    "phoneSetData",
+    "phoneSetDisplay",
+    "phoneSetGain",
+    "phoneSetHookSwitch",
+    "phoneSetLamp",
+    "phoneSetRing",
+    "phoneSetStatusMessages",
+    "phoneSetVolume",
+    "phoneShutdown"
+};
+
+
+BOOL TestPhoneUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT i=0;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "***************************************************************");
+
+	 OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>>> Test phoneXXX Unintialize tests <<<<<<<<<<<<<<<");
+    //
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    //
+
+    if (fStandAlone)
+    {
+        for(i = 0; i < DWNUMAPIS; i++)
+        {
+            TapiPhoneTestInit();
+            lpTapiPhoneTestInfo = GetPhoneTestInfo();
+            lpCallbackParams = GetCallbackParams();
+            lpTapiPhoneTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+            fTestPassed  = TRUE;
+
+            TapiLogDetail(
+                          DBUG_SHOW_PASS,
+                          ">> Test Case %ld: Uninitialized %s",
+                          dwTestCase + 1, szApiName[i]);
+
+            switch (i)
+            {
+            case 0:
+
+                if(! DoPhoneClose(lpTapiPhoneTestInfo,
+                                    PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+
+            break;
+            case 1:
+
+                lpTapiPhoneTestInfo->dwDeviceID =
+                    (*(lpTapiPhoneTestInfo->lpdwNumDevs)== 0 ?
+                    0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+                lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+#ifdef WUNICODE
+                lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+                lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+                if(! DoPhoneConfigDialog(lpTapiPhoneTestInfo,
+                                         PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+
+            break;
+            case 2:
+
+                {
+                    PHONEBUTTONINFO         TapiTestPhoneButtonInfo;
+                    lpTapiPhoneTestInfo->lpParams =
+                        (LPVOID)&TapiTestPhoneButtonInfo;
+                    lpTapiPhoneTestInfo->dwSize = sizeof(PHONEBUTTONINFO);
+
+                    if (! DoPhoneDevSpecific(lpTapiPhoneTestInfo,
+                                             PHONEERR_UNINITIALIZED,
+                                             TRUE))
+                    {
+                        TPHONE_FAIL();
+                    }
+                }
+
+                break;
+            case 3:
+                lpTapiPhoneTestInfo->dwButtonLampID = 0;
+                lpTapiPhoneTestInfo->lpButtonInfo =
+                        (LPPHONEBUTTONINFO) AllocFromTestHeap(
+                                           sizeof(PHONEBUTTONINFO)
+                                           );
+                lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+                        sizeof(PHONEBUTTONINFO);
+
+                if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo,
+                                           PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 4:
+                lpTapiPhoneTestInfo->dwDataID =  0;
+                lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+                                                       sizeof(DWORD));
+                lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+
+                if (! DoPhoneGetData(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 5:
+                lpTapiPhoneTestInfo->lpPhoneCaps =
+                    (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+                lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize =
+                    sizeof(PHONECAPS);
+
+                if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo,
+                                        PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 6:
+                lpTapiPhoneTestInfo->lpDisplay =
+                    (LPVARSTRING) AllocFromTestHeap(sizeof(VARSTRING));
+                lpTapiPhoneTestInfo->lpDisplay->dwTotalSize =
+                    sizeof(VARSTRING);
+
+                if (! DoPhoneGetDisplay(lpTapiPhoneTestInfo,
+                                        PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 7:
+                lpTapiPhoneTestInfo->dwHookSwitchDev =
+                    PHONEHOOKSWITCHDEV_HANDSET;
+                lpTapiPhoneTestInfo->lpdwGain = &(lpTapiPhoneTestInfo->dwGain);
+
+                if (! DoPhoneGetGain(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 8:
+                lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+                    &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+
+                if (! DoPhoneGetHookSwitch(lpTapiPhoneTestInfo,
+                                           PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 9:
+                lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+#ifdef WUNICODE
+                lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+                lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+                if (! DoPhoneGetIcon(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 10:
+#ifdef WUNICODE
+                lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone";
+#else
+                lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+                lpTapiPhoneTestInfo->lpDeviceID =
+                    &(lpTapiPhoneTestInfo->DeviceID);
+                lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize =
+                    sizeof(VARSTRING);
+
+
+                if (! DoPhoneGetID(lpTapiPhoneTestInfo,
+                                   PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 11:
+                lpTapiPhoneTestInfo->dwButtonLampID = 0;
+                lpTapiPhoneTestInfo->lpdwLampMode =
+                    &(lpTapiPhoneTestInfo->dwLampMode);
+
+                if (! DoPhoneGetLamp(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 12:
+                lpTapiPhoneTestInfo->lpdwRingMode =
+                    &(lpTapiPhoneTestInfo->dwRingMode);
+                lpTapiPhoneTestInfo->lpdwVolume =
+                    &(lpTapiPhoneTestInfo->dwVolume);
+
+                if (! DoPhoneGetRing(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 13:
+                lpTapiPhoneTestInfo->lpPhoneStatus =
+                    (LPPHONESTATUS) AllocFromTestHeap(sizeof(PHONESTATUS));
+                lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize =
+                    sizeof(PHONESTATUS);
+
+                if (! DoPhoneGetStatus(lpTapiPhoneTestInfo,
+                                       PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 14:
+                lpTapiPhoneTestInfo->lpdwPhoneStates =
+                    &(lpTapiPhoneTestInfo->dwPhoneStates);
+                lpTapiPhoneTestInfo->lpdwButtonModes =
+                    &(lpTapiPhoneTestInfo->dwButtonModes);
+                lpTapiPhoneTestInfo->lpdwButtonStates =
+                    &(lpTapiPhoneTestInfo->dwButtonStates);
+
+                if (! DoPhoneGetStatusMessages(lpTapiPhoneTestInfo,
+                                               PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 15:
+                lpTapiPhoneTestInfo->dwHookSwitchDev =
+                    PHONEHOOKSWITCHDEV_HANDSET;
+                lpTapiPhoneTestInfo->lpdwVolume =
+                    &(lpTapiPhoneTestInfo->dwVolume);
+
+                if (! DoPhoneGetVolume(lpTapiPhoneTestInfo,
+                                       PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 16:
+                lpTapiPhoneTestInfo->dwDeviceID = 0;
+                lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+                lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+                if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo,
+                                                 PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 17:
+                lpTapiPhoneTestInfo->lpdwExtVersion =
+                    &(lpTapiPhoneTestInfo->dwExtVersion);
+
+                if (! DoPhoneNegotiateExtVersion(lpTapiPhoneTestInfo,
+                                                 PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 18:
+                lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+
+                if (! DoPhoneOpen(lpTapiPhoneTestInfo, PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 19:
+                lpTapiPhoneTestInfo->dwButtonLampID =  0;
+                lpTapiPhoneTestInfo->lpButtonInfo =
+                    (LPPHONEBUTTONINFO) AllocFromTestHeap(
+                        sizeof(PHONEBUTTONINFO));
+
+                // Do set all field in ButtonInfo here
+                lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize =
+                    sizeof(PHONEBUTTONINFO);
+                lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode =
+                    PHONEBUTTONMODE_CALL;
+
+                if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo,
+                                           PHONEERR_UNINITIALIZED,
+                                           TRUE))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 20:
+                {
+
+                    ULONG dwData = 0x5;
+                    lpTapiPhoneTestInfo->dwDataID = 0;
+                    lpTapiPhoneTestInfo->lpData = (LPVOID) AllocFromTestHeap(
+                                                           sizeof(DWORD));
+                    lpTapiPhoneTestInfo->lpData = (LPVOID) &dwData;
+                    lpTapiPhoneTestInfo->dwSize = sizeof(DWORD);
+                    if (! DoPhoneSetData(lpTapiPhoneTestInfo,
+                                         PHONEERR_UNINITIALIZED,
+                                         TRUE))
+                    {
+                        TPHONE_FAIL();
+                    }
+                }
+                break;
+            case 21:
+                {
+
+                    ULONG dwNumRows = lpTapiPhoneTestInfo->dwRow = 2;
+                    ULONG dwNumColumns = lpTapiPhoneTestInfo->dwColumn = 10;
+                    lpTapiPhoneTestInfo->lpsDisplay = (LPSTR)AllocFromTestHeap(
+                         sizeof(dwNumRows*dwNumColumns));
+                    lpTapiPhoneTestInfo->lpsDisplay = "this is a test";
+                    lpTapiPhoneTestInfo->dwSize =
+                        sizeof(lpTapiPhoneTestInfo->lpsDisplay);
+
+
+                    if (! DoPhoneSetDisplay(lpTapiPhoneTestInfo,
+                                            PHONEERR_UNINITIALIZED,
+                                            TRUE))
+                    {
+                        TPHONE_FAIL();
+                    }
+                }
+                break;
+            case 22:
+                lpTapiPhoneTestInfo->dwHookSwitchDev =
+                    PHONEHOOKSWITCHDEV_HANDSET;
+                lpTapiPhoneTestInfo->dwGain = 0x2;
+
+                if (! DoPhoneSetGain(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED,
+                                     TRUE))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 23:
+                lpTapiPhoneTestInfo->lpdwHookSwitchDevs =
+                    &(lpTapiPhoneTestInfo->dwHookSwitchDevs);
+                lpTapiPhoneTestInfo->dwHookSwitchDevs =
+                    PHONEHOOKSWITCHDEV_HANDSET;
+                lpTapiPhoneTestInfo->dwHookSwitchMode =
+                    PHONEHOOKSWITCHMODE_ONHOOK;
+
+                if (! DoPhoneSetHookSwitch(lpTapiPhoneTestInfo,
+                                           PHONEERR_UNINITIALIZED,
+                                           TRUE))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 24:
+                lpTapiPhoneTestInfo->dwButtonLampID = 0;
+                lpTapiPhoneTestInfo->lpdwLampMode =
+                    &(lpTapiPhoneTestInfo->dwLampMode);
+                lpTapiPhoneTestInfo->dwLampMode = PHONELAMPMODE_FLUTTER;
+
+                if (! DoPhoneSetLamp(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED,
+                                     TRUE))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 25:
+                lpTapiPhoneTestInfo->lpdwRingMode =
+                    &(lpTapiPhoneTestInfo->dwRingMode);
+                lpTapiPhoneTestInfo->lpdwVolume =
+                    &(lpTapiPhoneTestInfo->dwVolume);
+                lpTapiPhoneTestInfo->lpPhoneCaps =
+                    (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+                lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize =
+                    sizeof(PHONECAPS);
+                lpTapiPhoneTestInfo->dwRingMode =
+                    lpTapiPhoneTestInfo->lpPhoneCaps->dwNumRingModes;
+                lpTapiPhoneTestInfo->dwVolume = 0x3;
+
+                if (! DoPhoneSetRing(lpTapiPhoneTestInfo,
+                                     PHONEERR_UNINITIALIZED,
+                                     TRUE))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 26:
+
+                lpTapiPhoneTestInfo->lpdwPhoneStates =
+                    &(lpTapiPhoneTestInfo->dwPhoneStates);
+                lpTapiPhoneTestInfo->lpdwButtonModes =
+                    &(lpTapiPhoneTestInfo->dwButtonModes);
+                lpTapiPhoneTestInfo->lpdwButtonStates =
+                    &(lpTapiPhoneTestInfo->dwButtonStates);
+                lpTapiPhoneTestInfo->dwPhoneStates = PHONESTATE_CONNECTED;
+                lpTapiPhoneTestInfo->dwButtonModes = PHONEBUTTONMODE_CALL;
+                lpTapiPhoneTestInfo->dwButtonStates = PHONEBUTTONSTATE_UP;
+
+                if (! DoPhoneSetStatusMessages(lpTapiPhoneTestInfo,
+                                               PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 27:
+                lpTapiPhoneTestInfo->dwHookSwitchDev =
+                    PHONEHOOKSWITCHDEV_HANDSET;
+                lpTapiPhoneTestInfo->lpdwVolume =
+                    &(lpTapiPhoneTestInfo->dwVolume);
+                lpTapiPhoneTestInfo->dwVolume = 0x7;
+
+                if (! DoPhoneSetVolume(lpTapiPhoneTestInfo,
+                                       PHONEERR_UNINITIALIZED,
+                                       TRUE))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            case 28:
+                if (! DoPhoneShutdown(lpTapiPhoneTestInfo,
+                                      PHONEERR_UNINITIALIZED))
+                {
+                    TPHONE_FAIL();
+                }
+                break;
+            default:
+                TapiLogDetail(
+                              DBUG_SHOW_DETAIL,
+                              "TestPhoneUninit -- error in FOR loop limits");
+                break;
+            } // switch
+
+        fTestPassed = ShowTestCase(fTestPassed);
+        FreeTestHeap();
+
+	     }  // for
+
+    } // if
+
+
+    TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Phone Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing PhoneUninitialize  <<<<<<<<"
+            );
+
+    return fTestPassed;
+}
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tphone/version.rc b/private/tapi/qa/trapper/itest/tphone/version.rc
new file mode 100644
index 000000000..96117751b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tphone/version.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI Phone API test Library"
+#define VER_INTERNALNAME_STR        "ttphone.dll"
+#define VER_ORIGINALFILENAME_STR    "ttphone.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/tsline/dirs b/private/tapi/qa/trapper/itest/tsline/dirs
new file mode 100644
index 000000000..aad230aa8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/dirs
@@ -0,0 +1,2 @@
+DIRS = tslinea\
+       tslinew
diff --git a/private/tapi/qa/trapper/itest/tsline/itlgad.c b/private/tapi/qa/trapper/itest/tsline/itlgad.c
new file mode 100644
index 000000000..ed114d922
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlgad.c
@@ -0,0 +1,1509 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgat.c
+
+Abstract:
+
+    This module contains the test functions for lineGatherDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	4/8/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define PULSESIZE	16
+#define DTMFSIZE	16
+#define ALL_DIGITMODES    (LINEDIGITMODE_PULSE | \
+									LINEDIGITMODE_DTMF)
+
+
+//  lineGatherDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGatherDigits(BOOL fQuietMode, BOOL fStandAlone)
+	{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+	DWORD	dwSize;
+   DWORD dwErrorCode;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   LPCALLBACKPARAMS lpCallbackParams;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGatherDigits  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not support these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+			 */
+	
+    lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	 dwSize = PULSESIZE;
+    lpTapiLineTestInfo->dwNumDigits = 2;
+#ifdef WUNICODE
+	 lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+	 lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	 lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	 lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+	 lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	 lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_NOTOWNER))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwDigitModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+      dwErrorCode = LINEERR_INVALDIGITMODE;
+    else
+      dwErrorCode = LINEERR_OPERATIONUNAVAIL;
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGatherDigits,
+            (LPDWORD) &lpTapiLineTestInfo->dwDigitModes,
+//            LINEERR_INVALDIGITMODE,
+            dwErrorCode,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DIGITMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamTest for dwDigitModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGatherDigits,
+            (LPDWORD) &lpTapiLineTestInfo->dwDigitModes,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DIGITMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwsDigits pointer ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpsDigits pointer ", dwTestCase + 1
+            );
+#endif
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwsDigits =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpsDigits =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwNumDigits = 0", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	 lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	 lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+    lpTapiLineTestInfo->dwNumDigits = 0;
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+      {
+      if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+      }
+    else
+     {
+      if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+        {
+            TLINE_FAIL();
+        }
+      }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwNumDigits = -1", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwNumDigits = 0xffffffff;
+    if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+   lpTapiLineTestInfo->dwNumDigits = 2;
+
+   
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszTerminationDigits pointer ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszTerminationDigits pointer ", dwTestCase + 1
+            );
+#endif
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszTerminationDigits =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszTerminationDigits =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwFirstDigitTineout, -1", dwTestCase + 1
+            );
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+  
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = NULL;
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = NULL;
+#endif
+
+   lpTapiLineTestInfo->dwFirstDigitTimeout = 0xffffffff;
+   lpTapiLineTestInfo->dwInterDigitTimeout = 0xffffffff;
+
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	/*
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_GATHERDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGATHERTERM_TERMDIGIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       }        
+	  */
+
+#ifdef WUNICODE
+   if(lpTapiLineTestInfo->lpwsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpwsDigits = %ws",
+		   lpTapiLineTestInfo->lpwsDigits);
+#else
+   if(lpTapiLineTestInfo->lpsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpsDigits = %s",
+		   lpTapiLineTestInfo->lpsDigits);
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+	
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_GATHERDIGITS msg sent", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	dwSize = PULSESIZE;
+   lpTapiLineTestInfo->dwNumDigits = 2;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+	lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+	lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+ 
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_GATHERDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGATHERTERM_TERMDIGIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST 
+//            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+//                    TAPIMSG_DWPARAM1
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       }        
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+#ifdef WUNICODE
+   if(lpTapiLineTestInfo->lpwsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpwsDigits = %ws",
+		   lpTapiLineTestInfo->lpwsDigits);
+#else
+   if(lpTapiLineTestInfo->lpsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpsDigits = %s",
+		   lpTapiLineTestInfo->lpsDigits);
+#endif
+	
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_GATHERDIGITS msg filtered", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+   lpTapiLineTestInfo->hCall1 = 0;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (2) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (2) * sizeof(HCALL) + 8;
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	dwSize = PULSESIZE;
+   lpTapiLineTestInfo->dwNumDigits = 2;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+	lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+	lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+ 
+   if( ! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_GATHERDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGATHERTERM_TERMDIGIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST 
+//            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+//                    TAPIMSG_DWPARAM1
+            );
+
+        if ( WaitForAllMessages())
+          {
+           TLINE_FAIL();
+          }
+       }        
+   }
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+#ifdef WUNICODE
+   if(lpTapiLineTestInfo->lpwsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpwsDigits = %ws",
+		   lpTapiLineTestInfo->lpwsDigits);
+#else
+   if(lpTapiLineTestInfo->lpsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpsDigits = %s",
+		   lpTapiLineTestInfo->lpsDigits);
+#endif
+	
+   // Close the line
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+*/
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpwszTerminationDigits set to NULL", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpszTerminationDigits set to NULL", dwTestCase + 1
+            );
+#endif
+
+	// Initialize a line app
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+  
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = NULL;
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = NULL;
+#endif
+
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	/*
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_GATHERDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGATHERTERM_TERMDIGIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       }        
+	  */
+
+#ifdef WUNICODE
+   if(lpTapiLineTestInfo->lpwsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpwsDigits = %ws",
+		   lpTapiLineTestInfo->lpwsDigits);
+#else
+   if(lpTapiLineTestInfo->lpsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpsDigits = %s",
+		   lpTapiLineTestInfo->lpsDigits);
+#endif
+    fTestPassed = ShowTestCase(fTestPassed);
+	
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpwszTerminationDigits set to empty string", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpszTerminationDigits set to empty string", dwTestCase + 1
+            );
+#endif
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress =  L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = L"";
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = "";
+#endif
+
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+#ifdef WUNICODE
+   if(lpTapiLineTestInfo->lpwsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpwsDigits = %ws",
+		   lpTapiLineTestInfo->lpwsDigits);
+#else
+   if(lpTapiLineTestInfo->lpsDigits)
+	   TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### lpsDigits = %s",
+		   lpTapiLineTestInfo->lpsDigits);
+#endif
+	
+    /* 
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_GATHERDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGATHERTERM_TERMDIGIT,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       } 
+     */       
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	dwSize = PULSESIZE;
+   lpTapiLineTestInfo->dwNumDigits = 2;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+	lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+	lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+    if ( ! DoLineGatherDigits(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALTIMEOUT;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	dwSize = PULSESIZE;
+   lpTapiLineTestInfo->dwNumDigits = 2;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+	lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+	lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+   if ( ! DoLineGatherDigits(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGatherDigits: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGatherDigits  <<<<<<<<"
+            );
+		
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlgap.c b/private/tapi/qa/trapper/itest/tsline/itlgap.c
new file mode 100644
index 000000000..2d3e9e89f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlgap.c
@@ -0,0 +1,1142 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgap.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAppPriority
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+     Rama Koneru		(a-ramako)	4/8/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineGetAppPriority
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAppPriority(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed     = TRUE;
+	DWORD dwPrioritySav, dwPriority;
+#ifdef WUNICODE
+   WCHAR wszAppFilename[] = L"testapp.exe";
+#else
+   CHAR szAppFilename[] = "testapp.exe";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetAppPriority  <<<<<<<<"
+            );
+
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Test no initialized case  <<<<<<<<"
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+    lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap(
+         sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority; 
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename pointers", dwTestCase + 1
+            );
+#endif
+
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAppFilename =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAppFilename =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    lpTapiLineTestInfo->dwPriority = 0;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non excutable ", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lpwszAppFilename = L"readme.txt";    
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non excutable ", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lpszAppFilename = "readme.txt";    
+#endif
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+         TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwPriority = 0;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lpwszAppFilename = L"testsga";    
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lpszAppFilename = "testsga";    
+#endif
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+	 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad MediaMode > 1 bit set ", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM |
+												  LINEMEDIAMODE_INTERACTIVEVOICE;
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALMEDIAMODE))
+      {
+          TLINE_FAIL();
+      }
+    
+    lpTapiLineTestInfo->dwPriority = 0;
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionID", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtID =
+               (LPLINEEXTENSIONID) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    lpTapiLineTestInfo->dwPriority = 0;
+    fTestPassed = ShowTestCase(fTestPassed);
+*/
+ 
+    FreeTestHeap(); 
+  
+
+
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwRequestMode, for dwMediaMode = 0 ", dwTestCase + 1
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = 0;
+
+    for (n = 3; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->dwRequestMode = 
+               (DWORD) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALREQUESTMODE))
+         {
+            TLINE_FAIL();
+         }
+     }
+    
+    lpTapiLineTestInfo->dwPriority = 0;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+
+ 
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionName", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtensionName =
+               (LPVARSTRING) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+*/
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpExtensionName == lpdwPriority", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+     lpTapiLineTestInfo->lpExtensionName = 
+               (LPVARSTRING) lpTapiLineTestInfo->lpdwPriority;
+     if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+    FreeTestHeap();
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap(
+         sizeof(VARSTRING));
+//    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->dwPriority = 0;
+    lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = 0", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->lpExtensionName->dwTotalSize = 0;
+    
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+      {
+          TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = fixed -1", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING) -1;
+    
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+      {
+          TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+*/ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpdwPriority ", dwTestCase + 1
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwPriority =
+               (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+         {
+            TLINE_FAIL();
+         }
+     }
+ 
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPriority = 0;
+    lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+ 
+
+    FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+   lpTapiLineTestInfo->dwPriority = 0;
+	lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	dwPrioritySav = *lpTapiLineTestInfo->lpdwPriority;
+	lpTapiLineTestInfo->dwPriority = !dwPrioritySav;
+   dwPriority = *lpTapiLineTestInfo->lpdwPriority;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx, dwPrioritySav = %lx",
+		*lpTapiLineTestInfo->lpdwPriority,
+      dwPriority);
+
+    if(*lpTapiLineTestInfo->lpdwPriority == dwPriority)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+																		
+    FreeTestHeap();
+
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Test  initialized case  <<<<<<<<"
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+    lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap(
+         sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority; 
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAppFilename =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAppFilename =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    lpTapiLineTestInfo->dwPriority = 0;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non excutable ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non excutable ", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"readme.txt";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "readme.txt";    
+#endif
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+         TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testsga";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testsga";    
+#endif
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+	 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad MediaMode > 1 bit set ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM |
+												  LINEMEDIAMODE_INTERACTIVEVOICE;
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALMEDIAMODE))
+      {
+          TLINE_FAIL();
+      }
+    
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionID", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtID =
+               (LPLINEEXTENSIONID) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    lpTapiLineTestInfo->dwPriority = 0;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap(); 
+*/  
+
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap(
+         sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwRequestMode, for dwMediaMode = 0 ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = 0;
+
+    for (n = 3; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->dwRequestMode = 
+               (DWORD) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALREQUESTMODE))
+         {
+            TLINE_FAIL();
+         }
+     }
+    
+    lpTapiLineTestInfo->dwPriority = 0;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionName", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtensionName =
+               (LPVARSTRING) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    lpTapiLineTestInfo->dwPriority = 0;
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    FreeTestHeap();
+
+  
+/*  
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;    
+#endif
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap(
+         sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->dwPriority = 0;
+    lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lpExtensionName->dwTotalSize = 0;
+    
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+      {
+          TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = fixed -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING) -1;
+    
+    if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+      {
+          TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpdwPriority ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwPriority =
+               (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineGetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+         {
+            TLINE_FAIL();
+         }
+     }
+ 
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPriority = 0;
+    lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+   lpTapiLineTestInfo->dwPriority = 0;
+	lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	dwPrioritySav = *lpTapiLineTestInfo->lpdwPriority;
+	lpTapiLineTestInfo->dwPriority = !dwPrioritySav;
+   dwPriority = *lpTapiLineTestInfo->lpdwPriority;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   lpTapiLineTestInfo->dwPriority = 0;
+   lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx, dwPrioritySav = %lx",
+		*lpTapiLineTestInfo->lpdwPriority,
+      dwPriority);
+
+    if(*lpTapiLineTestInfo->lpdwPriority == dwPriority)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetAppPriority: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetAppPriority  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlmod.c b/private/tapi/qa/trapper/itest/tsline/itlmod.c
new file mode 100644
index 000000000..047376909
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlmod.c
@@ -0,0 +1,678 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmod.c
+
+Abstract:
+
+    This module contains the test functions for lineMonitorDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define ALL_DIGITMODES    (LINEDIGITMODE_PULSE | \
+									LINEDIGITMODE_DTMF  | \
+									LINEDIGITMODE_DTMFEND)
+
+
+
+//  lineMonitorDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineMonitorDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed    = TRUE;
+   LPCALLBACKPARAMS lpCallbackParams;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   LONG lExpected;
+   ESPDEVSPECIFICINFO   info;
+   TAPIRESULT lastTapiResult;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineMonitorDigits  <<<<<<<<"
+            );
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineMonitorDigits(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwDigitModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = LINEERR_INVALDIGITMODE;
+     else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineMonitorDigits,
+            (LPDWORD) &lpTapiLineTestInfo->dwDigitModes,
+            lExpected,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DIGITMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamTest for dwDigitModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineMonitorDigits,
+            (LPDWORD) &lpTapiLineTestInfo->dwDigitModes,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DIGITMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_MONITORDIGITS msg sent", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_MONITORDIGITS;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = LINEDIGITMODE_PULSE;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+    if (! DoLineMonitorDigits(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+      AddMessage(
+            LINE_MONITORDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            0x00000000,
+            LINEDIGITMODE_PULSE,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST 
+//                  | TAPIMSG_DWPARAM2
+            );
+
+      if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+           TLINE_FAIL();
+        }
+
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TLINE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINE_MONITORDIGIT msg not received");
+       } 
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify digit detection msg is filtered", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	 lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+    if (! DoLineMonitorDigits(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_MONITORDIGITS;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = LINEDIGITMODE_DTMF;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+      AddMessage(
+            LINE_MONITORDIGITS,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            0x00000000,
+            LINEDIGITMODE_DTMF,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM2
+            );
+
+      if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINEDIGITMODE_DTMF msg not received");
+       }
+      else
+        TLINE_FAIL();
+     }
+
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+    if ( ! DoLineMonitorDigits(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+    if ( ! DoLineMonitorDigits(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineMonitorDigits: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineMonitorDigits  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlmom.c b/private/tapi/qa/trapper/itest/tsline/itlmom.c
new file mode 100644
index 000000000..44dceddab
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlmom.c
@@ -0,0 +1,690 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmom.c
+
+Abstract:
+
+    This module contains the test functions for lineMonitorMedia
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define ALL_MEDIAMODES		  (LINEMEDIAMODE_INTERACTIVEVOICE   | \
+										LINEMEDIAMODE_AUTOMATEDVOICE     | \
+										LINEMEDIAMODE_DATAMODEM          | \
+										LINEMEDIAMODE_G3FAX              | \
+										LINEMEDIAMODE_TDD                | \
+										LINEMEDIAMODE_G4FAX              | \
+										LINEMEDIAMODE_DIGITALDATA        | \
+										LINEMEDIAMODE_TELETEX            | \
+										LINEMEDIAMODE_VIDEOTEX           | \
+										LINEMEDIAMODE_TELEX              | \
+										LINEMEDIAMODE_MIXED              | \
+										LINEMEDIAMODE_ADSI               | \
+										LINEMEDIAMODE_VOICEVIEW          | \
+										LINEMEDIAMODE_UNKNOWN)
+
+
+
+
+//  lineMonitorMedia
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineMonitorMedia(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+   LPCALLBACKPARAMS lpCallbackParams;
+   DWORD dwErrorCode;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   TAPIRESULT lastTapiResult;
+
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineMonitorMedia  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineMonitorMedia(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwMediaModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+       dwErrorCode = LINEERR_INVALMEDIAMODE;
+     else
+       dwErrorCode = LINEERR_OPERATIONUNAVAIL;
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineMonitorMedia,
+            (LPDWORD) &lpTapiLineTestInfo->dwMediaModes,
+//            LINEERR_INVALMEDIAMODE,
+				dwErrorCode,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_MEDIAMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamTest for dwMediaModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineMonitorMedia,
+            (LPDWORD) &lpTapiLineTestInfo->dwMediaModes,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_MEDIAMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_MONITORMEDIA msg sent", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	if (! DoLineMonitorMedia(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_MONITORMEDIA;
+    info.u.EspMsg.dwParam1 = LINEMEDIAMODE_DATAMODEM;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+      AddMessage(
+            LINE_MONITORMEDIA,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEMEDIAMODE_DATAMODEM,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST 
+                  | TAPIMSG_DWPARAM1
+            );
+
+      if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+           TLINE_FAIL();
+        }
+
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TLINE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINE_MONITORMEDIA msg not received");
+       } 
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify msg changed for a disabled mode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	if (! DoLineMonitorMedia(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_MONITORMEDIA;
+    info.u.EspMsg.dwParam1 = LINEMEDIAMODE_VIDEOTEX;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+      AddMessage(
+            LINE_MONITORMEDIA,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEMEDIAMODE_VIDEOTEX,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST 
+                  | TAPIMSG_DWPARAM1
+            );
+
+      if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+           TLINE_FAIL();
+        }
+
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINEMEDIAMODE_INTERACTIVE msg not received");
+       } 
+      else
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if ( ! DoLineMonitorMedia(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    if ( ! DoLineMonitorMedia(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineMonitorMedia: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineMonitorMedia  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlmot.c b/private/tapi/qa/trapper/itest/tsline/itlmot.c
new file mode 100644
index 000000000..bc6b57b66
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlmot.c
@@ -0,0 +1,832 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlmot.c
+
+Abstract:
+
+    This module contains the test functions for lineMonitorTones
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+#define NUMENTRIES		4
+#define PAGESIZE			16984
+
+
+
+//  lineMonitorTones
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineMonitorTones(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed    = TRUE;
+   LPCALLBACKPARAMS lpCallbackParams;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   ESPDEVSPECIFICINFO   info;
+   TAPIRESULT lastTapiResult;
+
+   DWORD dwNumEntries[NUMENTRIES] = {
+							 1,
+//							 500,
+//   						 1000,
+							 100000,
+							 0x7fffffff,
+							 0xffffffff
+							 };
+   DWORD dwNumBytes;
+   DWORD lExpected;
+   DWORD dwFixedSize = sizeof(LINEMONITORTONE);
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineMonitorTones  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+    lpTapiLineTestInfo->lpToneList = NULL;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineMonitorTones(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpToneList values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwNumEntries = 1;
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) gdwInvalidPointers[n];
+        if (! DoLineMonitorTones(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwNumEntries, fixed alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+        sizeof(LINEMONITORTONE));
+
+ 	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwNumEntries = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwFixedSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwNumEntries = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+    if(dwNumBytes < PAGESIZE)
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_INVALPOINTER;
+
+    if (! DoLineMonitorTones(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwNumEntries = 1;
+    lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) NULL;
+
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_MONITORTONE msg sent", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+        sizeof(LINEMONITORTONE));
+   lpTapiLineTestInfo->dwNumEntries = 1;
+
+	if (! DoLineMonitorTones(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_MONITORTONE;
+    info.u.EspMsg.dwParam1 = 0;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+      AddMessage(
+            LINE_MONITORTONE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            0x00000000,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST 
+            );
+
+      if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+           TLINE_FAIL();
+        }
+
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TLINE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINE_MONITORTONE msg not received");
+       } 
+    }
+
+
+/*
+	if (! DoLineMonitorTones(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_MONITORTONE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+//            LINEMEDIAMODE_DATAMODEM,
+            0x00000000,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST 
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       }        
+    }
+*/
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify dwNumTones ignor if lpToneList = null msg sent", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpToneList = NULL;
+   lpTapiLineTestInfo->dwNumEntries = 0xffffffff;
+
+	if (! DoLineMonitorTones(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_MONITORTONE msg filtered when call goes away", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (2) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (2) * sizeof(HCALL) + 8;
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+
+	lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+        sizeof(LINEMONITORTONE));
+   lpTapiLineTestInfo->dwNumEntries = 1;
+
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+ 	 if (! DoLineMonitorTones(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+    if( ! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+     }
+
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_MONITORTONE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+//            LINEMEDIAMODE_DATAMODEM,
+            0x00000000,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST 
+            );
+
+        if ( WaitForAllMessages())
+          {
+           TLINE_FAIL();
+          }
+       }        
+    }
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineMonitorTones(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+	 
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+    FreeTestHeap();
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+        sizeof(LINEMONITORTONE));
+   lpTapiLineTestInfo->dwNumEntries = 1;
+
+   if ( ! DoLineMonitorTones(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALTONE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+        sizeof(LINEMONITORTONE));
+    lpTapiLineTestInfo->dwNumEntries = 1;
+
+    if ( ! DoLineMonitorTones(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineMonitorTones: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineMonitorTones  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlpak.c b/private/tapi/qa/trapper/itest/tsline/itlpak.c
new file mode 100644
index 000000000..81b33fb06
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlpak.c
@@ -0,0 +1,1109 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpk.c
+
+Abstract:
+
+    This module contains the test functions for linePark
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+     Rama Koneru		(a-ramako)	4/8/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define ALL_PARKMODES    (LINEPARKMODE_DIRECTED | \
+								  LINEPARKMODE_NONDIRECTED)
+#define NUMTOTALSIZES 5
+
+
+//  linePark
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePark(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   DWORD dwFixedSize = sizeof(VARSTRING);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing linePark  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+	 lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDirAddress = L"444444";
+#else
+    lpTapiLineTestInfo->lpszDirAddress = "444444";
+#endif
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLinePark(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLinePark(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwParkModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDirAddress = L"444444";
+
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+          sizeof(VARSTRING) * sizeof(WCHAR));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING) * sizeof(WCHAR);
+#else
+    lpTapiLineTestInfo->lpszDirAddress = "444444";
+
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+          sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+#endif
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = LINEERR_INVALPARKMODE;
+     else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+
+     if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLinePark,
+            (LPDWORD) &lpTapiLineTestInfo->dwParkMode,
+            lExpected,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_PARKMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamTest for dwParkMode", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLinePark,
+            (LPDWORD) &lpTapiLineTestInfo->dwParkMode,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_PARKMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+       {
+        TLINE_FAIL();
+       }
+     }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDirAddress, when DIRECTED", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDirAddress, when DIRECTED", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDirAddress = (LPWSTR) gdwInvalidPointers[n];
+#else
+        lpTapiLineTestInfo->lpszDirAddress = (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLinePark(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszNonDirAddress, when NONDIRECTED", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszNonDirAddress, when NONDIRECTED", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_NONDIRECTED;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) gdwInvalidPointers[n];
+        if (! DoLinePark(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpNonDirAddress->dwTotalSize, when NONDIRECTED", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_NONDIRECTED;
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING));
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = 
+                        dwTotalSizes[n];
+        if(dwTotalSizes[n] < dwFixedSize)
+          {
+          if(IsESPLineDevice(lpTapiLineTestInfo))
+	         lExpected = LINEERR_STRUCTURETOOSMALL;
+          else
+           lExpected = LINEERR_OPERATIONUNAVAIL;
+          }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLinePark(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = dwFixedSize;
+  
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, when NONDIRECTED", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_NONDIRECTED;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING) * sizeof(WCHAR));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING) * sizeof(WCHAR);
+
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringSize = 16 * sizeof(WCHAR);
+#else
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringSize = 16;
+#endif
+  
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    if(lpTapiLineTestInfo->lpNonDirAddress->dwStringOffset > 0)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+
+    }
+    else
+    {
+    if (! DoLinePark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+ 
+    TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "dwTotalSize = %lx, dwNeededSize = %lx",
+       lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize,
+       lpTapiLineTestInfo->lpNonDirAddress->dwNeededSize);
+
+    TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "dwStringSize = %lx, dwStringOffset = %lx",
+       lpTapiLineTestInfo->lpNonDirAddress->dwStringSize,
+       lpTapiLineTestInfo->lpNonDirAddress->dwStringOffset);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "string1 (unicode)  = %ws, string2 (unicode) = %ws",
+       (LPBYTE)lpTapiLineTestInfo->lpNonDirAddress,
+       (LPBYTE)lpTapiLineTestInfo->lpNonDirAddress +
+       lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize);
+#else
+    TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "string1 = %s, string2 = %s",
+       (LPBYTE)lpTapiLineTestInfo->lpNonDirAddress,
+       (LPBYTE)lpTapiLineTestInfo->lpNonDirAddress +
+       lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize);
+#endif
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpNonDirAddress ignor when DIRECTED", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) NULL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDirAddress = L"44444";
+#else
+    lpTapiLineTestInfo->lpszDirAddress = "44444";
+#endif
+  
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+    else
+    {
+    if (! DoLinePark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpwszDirAddress ignor when NONDIRECTED", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpszDirAddress ignor when NONDIRECTED", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_NONDIRECTED;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+       sizeof(VARSTRING)*sizeof(WCHAR));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING)*sizeof(WCHAR);
+    lpTapiLineTestInfo->lpwszDirAddress = NULL;
+#else
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+       sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->lpszDirAddress = NULL;
+#endif
+  
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+    else
+    {
+    if (! DoLinePark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_NONDIRECTED;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING) * sizeof(WCHAR));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING) * sizeof(WCHAR);
+
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringSize = 16 * sizeof(WCHAR);
+#else
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringSize = 16;
+#endif
+ 
+    if ( ! DoLinePark(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALADDRESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_NONDIRECTED;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING) * sizeof(WCHAR));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING) * sizeof(WCHAR);
+
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringSize = 16 * sizeof(WCHAR);
+#else
+    lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap(
+        sizeof(VARSTRING));
+    lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+    lpTapiLineTestInfo->lpNonDirAddress->dwStringSize = 16;
+#endif
+ 
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLinePark(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+ TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ linePark: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing linePark  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlpk.c b/private/tapi/qa/trapper/itest/tsline/itlpk.c
new file mode 100644
index 000000000..83e778cf4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlpk.c
@@ -0,0 +1,879 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpk.c
+
+Abstract:
+
+    This module contains the test functions for linePickup
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+     Rama Koneru		(a-ramako)	4/8/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  linePickup
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePickup(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   BOOL fTestPassed    = TRUE;
+   BOOL fUnimdm;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing linePickup  <<<<<<<<"
+            );
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+    lpTapiLineTestInfo->lpwszGroupID = NULL;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+    lpTapiLineTestInfo->lpszGroupID = NULL;
+#endif
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwAddressID -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID = 0xffffffff;
+// SP didn't check dwAddressID
+//    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_INVALADDRESSID, TRUE))
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+    else
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwAddressID, dwNumAddressID ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS)
+            AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwAddressID = 
+          lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses;
+
+//    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_INVALADDRESSID, TRUE))
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+    else
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lphCall = (LPHCALL) gdwInvalidHandles[n];
+        if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->hCall1 = 0;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+      
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDestAddress values", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDestAddress values", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) gdwInvalidHandles[n];
+#else
+        lpTapiLineTestInfo->lpszDestAddress = (LPSTR) gdwInvalidHandles[n];
+#endif
+        if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+      
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszGroupID values", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszGroupID values", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszGroupID = (LPWSTR) gdwInvalidHandles[n];
+#else
+        lpTapiLineTestInfo->lpszGroupID = (LPSTR) gdwInvalidHandles[n];
+#endif
+        if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: verify hCall can't be used", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+          TLINE_FAIL();
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszGroupID = L"0";
+#else
+    lpTapiLineTestInfo->lpszGroupID = "0";
+#endif
+      
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_CALLSTATE|UNKNOWN msg sent", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    if(fTestPassed)
+     {
+        AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) lpTapiLineTestInfo->hLine1,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_OFFERING,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | 
+//          TAPIMSG_HDEVCALL | 
+            TAPIMSG_DWCALLBACKINST |
+            TAPIMSG_DWPARAM1
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       }        
+     }
+    else
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+      
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpwszGroupID = null", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpszGroupID = null", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+    lpTapiLineTestInfo->lpwszGroupID = NULL;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = "55555";
+    lpTapiLineTestInfo->lpszGroupID = NULL;
+#endif
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+    else
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpwszDestAddress = null", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, lpszDestAddress = null", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = NULL;
+    lpTapiLineTestInfo->lpwszGroupID = L"123";
+#else
+    lpTapiLineTestInfo->lpszDestAddress = NULL;
+    lpTapiLineTestInfo->lpszGroupID = "123";
+#endif
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+    else
+    {
+    if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    
+    }
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    if ( ! DoLinePickup(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLinePickup(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ linePickup: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing linePickup  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlsap.c b/private/tapi/qa/trapper/itest/tsline/itlsap.c
new file mode 100644
index 000000000..f713d79c3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlsap.c
@@ -0,0 +1,966 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsap.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAppPriority
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+     Rama Koneru		(a-ramako)	4/8/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineSetAppPriority
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAppPriority(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed     = TRUE;
+	DWORD dwPrioritySav, dwPriority;
+#ifdef WUNICODE
+   WCHAR wszAppFilename[] = L"testapp.exe";
+#else
+   CHAR szAppFilename[] = "testapp.exe";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetAppPriority  <<<<<<<<"
+            );
+
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Test no initialized case  <<<<<<<<"
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszMediaExtName = NULL;
+#else
+    lpTapiLineTestInfo->lpszMediaExtName = NULL;
+#endif
+    lpTapiLineTestInfo->dwPriority = 0;
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename pointers", dwTestCase + 1
+            );
+#endif
+
+// lpszAppFilename = null is allowed
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAppFilename =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAppFilename =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non executable ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpwszAppFilename = L"readme.txt";    
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non executable ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpszAppFilename = "readme.txt";    
+#endif
+
+    if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALAPPNAME))
+      {
+         TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpwszAppFilename = L"testsga";    
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpszAppFilename = "testsga";    
+#endif
+
+    if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALAPPNAME))
+      {
+          TLINE_FAIL();
+      }
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+*/
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+	 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad MediaMode > 1 bit set ", dwTestCase + 1
+            );
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM |
+												  LINEMEDIAMODE_INTERACTIVEVOICE;
+    if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALMEDIAMODE))
+      {
+          TLINE_FAIL();
+      }
+    
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionID", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtID =
+               (LPLINEEXTENSIONID) gdwInvalidPointers[n];
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    FreeTestHeap(); 
+  
+
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwRequestMode, for dwMediaMode = 0 ", dwTestCase + 1
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = 0;
+
+    for (n = 3; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->dwRequestMode = 
+               (DWORD) gdwInvalidPointers[n];
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALREQUESTMODE))
+         {
+            TLINE_FAIL();
+         }
+     }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszMediaExtName", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszMediaExtName", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+// lpszMediaExtName = null is allowed
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszMediaExtName =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszMediaExtName =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+ 
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPriority ", dwTestCase + 1
+            );
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";    
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+    for (n = 2; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->dwPriority =
+               (DWORD) gdwInvalidPointers[n];
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+         {
+            TLINE_FAIL();
+         }
+     }
+ 
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+
+   lpTapiLineTestInfo->dwPriority = 1;
+   dwPriority = lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"dwPriority = %lx, dwPrioritySav = %lx",
+		*lpTapiLineTestInfo->lpdwPriority,
+      dwPriority);
+
+    if(*lpTapiLineTestInfo->lpdwPriority == dwPriority)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    FreeTestHeap();
+
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Test initialized case  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+   lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszMediaExtName = NULL;
+#else
+    lpTapiLineTestInfo->lpszMediaExtName = NULL;
+#endif
+    lpTapiLineTestInfo->dwPriority = 0;
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAppFilename =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAppFilename =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non excutable ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non excutable ", dwTestCase + 1
+            );
+#endif
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"readme.txt";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "readme.txt";    
+#endif
+
+    if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALAPPNAME))
+      {
+         TLINE_FAIL();
+      }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAppFilename, non 8.3 format ", dwTestCase + 1
+            );
+#endif
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = L"testsga";    
+#else
+    lpTapiLineTestInfo->lpszAppFilename = "testsga";    
+#endif
+    if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALAPPNAME))
+      {
+          TLINE_FAIL();
+      }
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+*/
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAppFilename = wszAppFilename;
+#else
+    lpTapiLineTestInfo->lpszAppFilename = szAppFilename;
+#endif
+	 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad MediaMode > 1 bit set ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM |
+												  LINEMEDIAMODE_INTERACTIVEVOICE;
+    if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALMEDIAMODE))
+      {
+          TLINE_FAIL();
+      }
+    
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpExtensionID", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpExtID =
+               (LPLINEEXTENSIONID) gdwInvalidPointers[n];
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+ 
+    FreeTestHeap(); 
+  
+
+    lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap(
+         sizeof(LINEEXTENSIONID));
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwRequestMode, for dwMediaMode = 0 ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+    lpTapiLineTestInfo->dwMediaMode = 0;
+
+    for (n = 3; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->dwRequestMode = 
+               (DWORD) gdwInvalidPointers[n];
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALREQUESTMODE))
+         {
+            TLINE_FAIL();
+         }
+     }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszMediaExtName", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszMediaExtName", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+    lpTapiLineTestInfo->dwMediaMode = 0x01000000;
+    
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszMediaExtName =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszMediaExtName =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPriority ", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+    for (n = 2; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->dwPriority =
+               (DWORD) gdwInvalidPointers[n];
+        if (! DoLineSetAppPriority(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+         {
+            TLINE_FAIL();
+         }
+     }
+ 
+    
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPriority = 0;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+ 
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+
+   lpTapiLineTestInfo->dwPriority = 1;
+   dwPriority = lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"dwPriority = %lx, dwPrioritySav = %lx",
+		*lpTapiLineTestInfo->lpdwPriority,
+      dwPriority);
+
+    if(*lpTapiLineTestInfo->lpdwPriority == dwPriority)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetAppPriority: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetAppPriority  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlscd.c b/private/tapi/qa/trapper/itest/tsline/itlscd.c
new file mode 100644
index 000000000..cd1801189
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlscd.c
@@ -0,0 +1,714 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscd.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallData
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+#define NUMTOTALSIZES 5
+#define PAGESIZE      4096
+
+
+//  lineSetCallData
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallData(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+	LPBYTE lpszCallData;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   DWORD dwCallDataSize;
+   DWORD dwFixedSize = PAGESIZE;
+   DWORD lExpected;
+   DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetCallData  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+    lpTapiLineTestInfo->lpToneList = NULL;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallData values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwSize = 128;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpCallData = (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpszCallData = "This is a testA.";
+	lpTapiLineTestInfo->lpCallData = (LPVOID)lpszCallData;
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->dwSize = 
+                        dwTotalSizes[n];
+        if(dwTotalSizes[n] < dwFixedSize)
+        {
+        if(IsESPLineDevice(lpTapiLineTestInfo))
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_OPERATIONUNAVAIL;
+        }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineSetCallData(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+   lpTapiLineTestInfo->lpCallData = (LPVOID)NULL;
+   lpTapiLineTestInfo->dwSize = 0;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   lpTapiLineTestInfo->lpCallData = (LPVOID)NULL;
+   lpTapiLineTestInfo->dwSize = 0;
+   if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpszCallData = "This is a testA.";
+	lpTapiLineTestInfo->lpCallData = (LPVOID)lpszCallData;
+   lpTapiLineTestInfo->dwSize = strlen(lpszCallData);
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetCallData(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+   }
+   else
+   {
+	if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+   }
+  
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"Before: lpCallInfo->dwCallDataSize = %lx, dwCallDataOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataSize,
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataOffset
+		);
+   dwCallDataSize = lpTapiLineTestInfo->lpCallInfo->dwCallDataSize;
+	
+	lpszCallData = "This is a testA. The is a testB.";
+	lpTapiLineTestInfo->lpCallData = (LPVOID)lpszCallData;
+   lpTapiLineTestInfo->dwSize = strlen(lpszCallData);
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetCallData(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: lpCallInfo->dwCallDataSize = %lx, dwCallDataOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataSize,
+		lpTapiLineTestInfo->lpCallInfo->dwCallDataOffset
+		);
+	 
+    if(lpTapiLineTestInfo->lpCallInfo->dwCallDataSize !=
+       dwCallDataSize)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    }
+   else
+   {
+	if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+      {
+          TLINE_FAIL();
+      }
+   }
+ 
+   
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpszCallData = "This is a testA.";
+	 lpTapiLineTestInfo->lpCallData = (LPVOID)lpszCallData;
+    lpTapiLineTestInfo->dwSize = strlen(lpszCallData);
+
+
+    if ( ! DoLineSetCallData(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpszCallData = "This is a testA.";
+	 lpTapiLineTestInfo->lpCallData = (LPVOID)lpszCallData;
+    lpTapiLineTestInfo->dwSize = strlen(lpszCallData);
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetCallData(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetCallData: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetCallData  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlscl.c b/private/tapi/qa/trapper/itest/tsline/itlscl.c
new file mode 100644
index 000000000..82df5ebec
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlscl.c
@@ -0,0 +1,422 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscl.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCurrentLocation
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+#define  BIGBIGSIZE  4096
+
+
+//  lineSetCurrentLocation
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCurrentLocation(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPLINELOCATIONENTRY lpLineLocationEntry;
+   BOOL fUnimdm;
+   DWORD dwLocation;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetCurrentLocation  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLineApp values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+        BIGBIGSIZE);
+    lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = BIGBIGSIZE;
+
+    if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    lpTapiLineTestInfo->dwLocation = 
+        lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID;
+    lpTapiLineTestInfo->hLineApp_Orig = *(lpTapiLineTestInfo->lphLineApp);
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCurrentLocation, 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwLocation = 0;
+    if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, LINEERR_INVALLOCATION))
+      {
+          TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCurrentLocation, 10000, big number", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->dwLocation = 1000;
+    if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, LINEERR_INVALLOCATION))
+      {
+          TLINE_FAIL();
+      }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+  
+    
+    lpLineLocationEntry = (LPLINELOCATIONENTRY) 
+       (((LPBYTE) lpTapiLineTestInfo->lpTranslateCaps) +
+                 lpTapiLineTestInfo->lpTranslateCaps->dwLocationListOffset);
+    lpTapiLineTestInfo->dwLocation = lpLineLocationEntry->dwPermanentLocationID;
+
+    if(lpTapiLineTestInfo->dwLocation == 0)
+    {
+    if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, LINEERR_INVALLOCATION))
+      {
+          TLINE_FAIL();
+      }
+    }
+    else
+    {
+    if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+  
+    if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "dwCurrentLocationID = %lx, dwLocation = %lx",
+        lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+        lpTapiLineTestInfo->dwLocation);
+    if(lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID ==
+       lpTapiLineTestInfo->dwLocation)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+    }
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+ 
+
+    FreeTestHeap();
+ 
+/*
+OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetCurrentLocation");
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetCurrentLocation for go/no-go");
+
+	// Call lineGetTranslateCaps to get LocationID
+
+	lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+			sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumLocations = %lx, dwCurrentLocationID = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID);
+
+
+	if(lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations == 1)
+	{
+	   lpTapiLineTestInfo->dwLocation = lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID;
+	}
+	else if(lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations > 1)
+	{
+	lpLineLocationEntry = (LPLINELOCATIONENTRY)
+		((LPBYTE)lpTapiLineTestInfo->lpTranslateCaps + 
+				  lpTapiLineTestInfo->lpTranslateCaps->dwLocationListOffset);
+	lpTapiLineTestInfo->dwLocation = lpLineLocationEntry->dwPermanentLocationID;
+	}
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwLocationID = %lx",
+		lpTapiLineTestInfo->dwLocation);
+
+
+	if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	// Call lineGetTranslateCaps to verify LocationID
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumLocations = %lx, dwCurrentLocationID = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID);
+
+
+ 
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+*/	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetCurrentLocation: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetCurrentLocation  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlscqs.c b/private/tapi/qa/trapper/itest/tsline/itlscqs.c
new file mode 100644
index 000000000..3dc8d6e07
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlscqs.c
@@ -0,0 +1,955 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscqs.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallQualityOfService
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "winsock2.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+#define NUMTOTALSIZES 5
+#define FIXEDSIZE     1001
+
+
+//  lineSetCallQualityOfService
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallQualityOfService(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed     = TRUE;
+	LPFLOWSPEC 	lpSendingFlowspec, lpReceivingFlowspec;
+	LPQOS		  	lpQos;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   DWORD dwFixedSize = FIXEDSIZE;
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+  
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetCallQualityOfService  <<<<<<<<"
+            );
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpSendingFlowspec values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwSendingFlowspecSize = 128;
+    lpTapiLineTestInfo->dwReceivingFlowspecSize = 0;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpSendingFlowspec = (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpReceivingFlowspec values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwSendingFlowspecSize = 0;
+    lpTapiLineTestInfo->dwReceivingFlowspecSize = 128;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpReceivingFlowspec = (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+  
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSendingFlowspecSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpQos = (LPQOS) AllocFromTestHeap ( sizeof(QOS));
+	lpSendingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpSendingFlowspec->LevelOfGuarantee = GuaranteedService;
+	lpTapiLineTestInfo->lpSendingFlowspec = (LPVOID) lpQos;
+	lpReceivingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpTapiLineTestInfo->lpReceivingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwReceivingFlowspecSize = sizeof(lpQos->ReceivingFlowspec);
+
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->dwSendingFlowspecSize =
+                        dwTotalSizes[n];
+        if(dwTotalSizes[n] < dwFixedSize)
+        {
+        if(IsESPLineDevice(lpTapiLineTestInfo))
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_OPERATIONUNAVAIL;
+        }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwReceivingFlowspecSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec);
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->dwReceivingFlowspecSize =
+                        dwTotalSizes[n];
+        if(dwTotalSizes[n] < dwFixedSize)
+        {
+        if(IsESPLineDevice(lpTapiLineTestInfo))
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_OPERATIONUNAVAIL;
+        }
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, lExpected, TRUE))
+           {
+              TLINE_FAIL();
+           }
+        }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+   lpTapiLineTestInfo->dwReceivingFlowspecSize = sizeof(lpQos->ReceivingFlowspec);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad(?) dwSendingFlowspecSize, fixed-1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec) -1;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecOffset
+		);
+   if(lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize ==
+      lpTapiLineTestInfo->dwSendingFlowspecSize)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+
+    FreeTestHeap();
+   }
+   else
+   {
+	if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+  
+
+	fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"Before: dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecOffset
+		);
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"Before: dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecOffset
+		);
+
+	lpQos = (LPQOS) AllocFromTestHeap ( sizeof(QOS));
+	lpSendingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+//	lpQos->SendingFlowspec.buf = (char FAR *) lpSendingFlowspec;
+	lpSendingFlowspec->LevelOfGuarantee = GuaranteedService;
+//	lpQos->SendingFlowspec.len = sizeof(lpQos->SendingFlowspec.buf);
+	lpTapiLineTestInfo->lpSendingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec);
+
+	lpReceivingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+//	lpQos->ReceivingFlowspec.buf = (char FAR *) lpReceivingFlowspec;
+//	lpQos->ReceivingFlowspec.len = sizeof(lpQos->ReceivingFlowspec.buf);
+	lpTapiLineTestInfo->lpReceivingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwReceivingFlowspecSize = sizeof(lpQos->ReceivingFlowspec);
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: dwSendingFlowspecSize = %lx, dwSendingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecOffset
+		);
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: dwReceivingFlowspecSize = %lx, dwReceivingFlowspecOffset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecSize,
+		lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecOffset
+		);
+
+    if(lpTapiLineTestInfo->lpCallInfo->dwSendingFlowspecSize ==
+       lpTapiLineTestInfo->dwSendingFlowspecSize  &&
+       lpTapiLineTestInfo->lpCallInfo->dwReceivingFlowspecSize ==
+       lpTapiLineTestInfo->dwReceivingFlowspecSize)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;
+	}
+   else
+   {
+	if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpQos = (LPQOS) AllocFromTestHeap ( sizeof(QOS));
+	lpSendingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpSendingFlowspec->LevelOfGuarantee = GuaranteedService;
+	lpTapiLineTestInfo->lpSendingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec);
+
+	lpReceivingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpTapiLineTestInfo->lpReceivingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwReceivingFlowspecSize = sizeof(lpQos->ReceivingFlowspec);
+
+ 
+    if ( ! DoLineSetCallQualityOfService(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALRATE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpQos = (LPQOS) AllocFromTestHeap ( sizeof(QOS));
+	lpSendingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpSendingFlowspec->LevelOfGuarantee = GuaranteedService;
+	lpTapiLineTestInfo->lpSendingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwSendingFlowspecSize = sizeof(lpQos->SendingFlowspec);
+
+	lpReceivingFlowspec = (LPFLOWSPEC) AllocFromTestHeap (sizeof(FLOWSPEC));
+	lpTapiLineTestInfo->lpReceivingFlowspec = (LPVOID) lpQos;
+   lpTapiLineTestInfo->dwReceivingFlowspecSize = sizeof(lpQos->ReceivingFlowspec);
+
+ 
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetCallQualityOfService(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetCallQualityOfService: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetCallQualityOfService  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlsct.c b/private/tapi/qa/trapper/itest/tsline/itlsct.c
new file mode 100644
index 000000000..5234a5142
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlsct.c
@@ -0,0 +1,873 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsct.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallTreatment
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define ALL_CALLTREATMENT   (LINECALLTREATMENT_SILENCE | \
+									  LINECALLTREATMENT_RINGBACK | \
+									  LINECALLTREATMENT_BUSY     | \
+									  LINECALLTREATMENT_MUSIC)
+
+
+//  lineSetCallTreatment
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallTreatment(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+   DWORD dwErrorCode;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   BOOL fUnimdm;
+   DWORD dwCallTreatment;
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetCallTreatment  <<<<<<<<"
+            );
+
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+    lpTapiLineTestInfo->lpToneList = NULL;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   lpTapiLineTestInfo->lpCallData = (LPVOID)NULL;
+   lpTapiLineTestInfo->dwSize = 0;
+   if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwCallTreatment", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+       dwErrorCode = LINEERR_INVALPARAM;
+     else
+       dwErrorCode = LINEERR_OPERATIONUNAVAIL;
+
+     if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetCallTreatment,
+            (LPDWORD) &lpTapiLineTestInfo->dwTreatment,
+//            LINEERR_INVALPARAM,
+            dwErrorCode,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_CALLTREATMENT,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamTest for dwCallTreatment", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetCallTreatment,
+            (LPDWORD) &lpTapiLineTestInfo->dwTreatment,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_CALLTREATMENT,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+      {
+        TLINE_FAIL();
+      }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCallTreatment = 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->dwTreatment = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+ 
+   fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: dwCallTreatment = 0XFFFFFFFF", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->dwTreatment = 0xffffffff;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+ 
+   fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCallTreatment > MUSIC", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->dwTreatment = LINECALLTREATMENT_MUSIC + 1;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_INVALPARAM, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+ 
+   fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"Before: lpCallInfo->dwTreatment = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallTreatment);
+   dwCallTreatment = lpTapiLineTestInfo->lpCallInfo->dwCallTreatment;
+	
+	lpTapiLineTestInfo->dwTreatment = LINECALLTREATMENT_SILENCE;
+   dwCallTreatment = lpTapiLineTestInfo->dwTreatment;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"After: lpCallInfo->dwTreatment = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCallTreatment);
+	
+   if(dwCallTreatment == lpTapiLineTestInfo->lpCallInfo->dwCallTreatment)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwTreatment = LINECALLTREATMENT_SILENCE;
+    dwCallTreatment = lpTapiLineTestInfo->dwTreatment;
+
+    if ( ! DoLineSetCallTreatment(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	 lpTapiLineTestInfo->dwTreatment = LINECALLTREATMENT_SILENCE;
+    dwCallTreatment = lpTapiLineTestInfo->dwTreatment;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetCallTreatment(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetCallTreatment: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetCallTreatment  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlslds.c b/private/tapi/qa/trapper/itest/tsline/itlslds.c
new file mode 100644
index 000000000..84b898466
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlslds.c
@@ -0,0 +1,725 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlslds.c
+
+Abstract:
+
+    This module contains the test functions for lineSetLineDevStatus
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+#define ALL_STATUSTOCHANGE   (LINEDEVSTATUSFLAGS_CONNECTED | \
+										LINEDEVSTATUSFLAGS_MSGWAIT   | \
+										LINEDEVSTATUSFLAGS_INSERVICE | \
+										LINEDEVSTATUSFLAGS_LOCKED)
+
+
+//  lineSetLineDevStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetLineDevStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+   BOOL fUnimdm;
+   DWORD dwDevStatusFlags;
+   DWORD dwErrorCode;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetLineDevStatus  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+    lpTapiLineTestInfo->fStatus = TRUE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwStatusToChange", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+        dwErrorCode = LINEERR_INVALLINESTATE;
+     else
+        dwErrorCode = LINEERR_OPERATIONUNAVAIL;
+
+
+     if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetLineDevStatus,
+            (LPDWORD) &lpTapiLineTestInfo->dwStatusToChange,
+//            LINEERR_INVALLINESTATE,
+            dwErrorCode,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_STATUSTOCHANGE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+//            0xffffffff,
+//            FALSE
+				TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorValidParamTest for dwStatusToChange", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+     { 
+     if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetLineDevStatus,
+            (LPDWORD) &lpTapiLineTestInfo->dwStatusToChange,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_STATUSTOCHANGE,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, fStatus = TRUE, verify from GetLineDevStatue", dwTestCase + 1
+            );
+
+ 
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+ 
+   if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+		sizeof(BIGBUFSIZE));
+	lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = BIGBUFSIZE;
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before: lpLineDevStatus->dwDevStatusFlags = %lx", 
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+		
+    // Set the line device capabilities
+	lpTapiLineTestInfo->dwStatusToChange = LINEDEVSTATUSFLAGS_CONNECTED;
+	lpTapiLineTestInfo->fStatus = TRUE;
+
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+		{
+	    if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+   	 {
+      	  TLINE_FAIL();
+	    }
+		}
+	 else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+	    if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+	    {
+   	     TLINE_FAIL();
+	    }
+		}
+   dwDevStatusFlags = lpTapiLineTestInfo->dwStatusToChange;
+
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After: lpLineDevStatus->dwDevStatusFlags = %lx", 
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+
+	 if(dwDevStatusFlags & lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;	
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, fStatus = FALSE, verify from GetLineDevStatue", dwTestCase + 1
+            );
+
+ 
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+ 
+   if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before: lpLineDevStatus->dwDevStatusFlags = %lx", 
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+		
+    // Set the line device capabilities
+	lpTapiLineTestInfo->dwStatusToChange = LINEDEVSTATUSFLAGS_CONNECTED;
+	lpTapiLineTestInfo->fStatus = FALSE;
+
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+		{
+	    if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+   	 {
+      	  TLINE_FAIL();
+	    }
+   dwDevStatusFlags = lpTapiLineTestInfo->dwStatusToChange;
+
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After: lpLineDevStatus->dwDevStatusFlags = %lx", 
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+
+	 if(!(dwDevStatusFlags & lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags))
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;	
+
+		}
+	 else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+	    if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+	    {
+   	     TLINE_FAIL();
+	    }
+		}
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwStatusToChange = LINEDEVSTATUSFLAGS_CONNECTED;
+	 lpTapiLineTestInfo->fStatus = TRUE;
+
+    if ( ! DoLineSetLineDevStatus(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwStatusToChange = LINEDEVSTATUSFLAGS_CONNECTED;
+	 lpTapiLineTestInfo->fStatus = TRUE;
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetLineDevStatus(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetLineDevStatus: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetLineDevStatus  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlucc.c b/private/tapi/qa/trapper/itest/tsline/itlucc.c
new file mode 100644
index 000000000..19d63a3bf
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlucc.c
@@ -0,0 +1,710 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlucc.c
+
+Abstract:
+
+    This module contains the test functions for lineUncompleteCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+//  lineUncompleteCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineUncompleteCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+   BOOL fUnimdm;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineUncompleteCall  <<<<<<<<"
+            );
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwCompletionID = 0;
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	lpTapiLineTestInfo->dwMessageID = 0;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   } 
+   else
+    {
+    if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+ 
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		*lpTapiLineTestInfo->lpdwCompletionID);		
+	
+	// call linecallinfo to verify the comepletion
+   
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap (
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCompletionID);		
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineUncompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+   else
+    {
+    if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+		
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Different dwCompletionID from lineCompleteCall", dwTestCase + 1
+            );
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionMode = LINECALLCOMPLMODE_CALLBACK;
+	lpTapiLineTestInfo->dwMessageID = 0;
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineCompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+   else
+    {
+    if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		*lpTapiLineTestInfo->lpdwCompletionID);		
+	
+	// call linecallinfo to verify the comepletion
+   
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpCallInfo->dwCompleionID = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwCompletionID);		
+
+   lpTapiLineTestInfo->dwCompletionID += 1;
+
+// esp didn't check it, so it is not a test case
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineUncompleteCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+   else
+    {
+    if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+		
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCompletionID (-1)", dwTestCase + 1
+            );
+
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpdwCompletionID = &lpTapiLineTestInfo->dwCompletionID;
+   lpTapiLineTestInfo->dwCompletionID = 0xffffffff;
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_INVALCOMPLETIONID, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	AddMessage(
+	   LINE_REPLY,
+	   (DWORD) lpTapiLineTestInfo->hLine1,
+	   (DWORD) lpCallbackParams,
+	   0x00000000,
+	   (DWORD) LINEERR_INVALCOMPLETIONID,
+	   0x00000000,
+	   TAPIMSG_DWMSG | TAPIMSG_DWCALLBACKINST |
+          TAPIMSG_DWPARAM2
+	   );
+
+	if(WaitForAllMessages())
+     {
+      fTestPassed = TRUE;
+     }
+   else
+     {
+      fTestPassed = FALSE;
+      TLINE_FAIL();
+      }
+   }
+   else
+   {
+	if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+   }
+ 
+	fTestPassed = ShowTestCase(fTestPassed);
+		
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->dwCompletionID = 0;
+    if ( ! DoLineUncompleteCall(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCOMPLETIONID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineUncompleteCall(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineUncompleteCall: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineUncompleteCall  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/itlupak.c b/private/tapi/qa/trapper/itest/tsline/itlupak.c
new file mode 100644
index 000000000..07cd3f99f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/itlupak.c
@@ -0,0 +1,645 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlupak.c
+
+Abstract:
+
+    This module contains the test functions for lineUnpark
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+     Rama Koneru		(a-ramako)	4/8/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "sline.h"
+
+
+
+
+//  lineUnpark
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineUnpark(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   LPCALLBACKPARAMS    lpCallbackParams;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed    = TRUE;
+   BOOL fUnimdm;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineUnpark  <<<<<<<<"
+            );
+
+
+		  /*
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }		 */
+
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lphCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lphCall = (LPHCALL) gdwInvalidHandles[n];
+        if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hCall1 = 0;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDestAddress values", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDestAddress values", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) gdwInvalidHandles[n];
+#else
+        lpTapiLineTestInfo->lpszDestAddress = (LPSTR) gdwInvalidHandles[n];
+#endif
+        if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify hCall can't be used when fail", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = NULL;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = NULL;
+#endif
+    lpTapiLineTestInfo->hCall1 = 0;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+    if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+       {
+          TLINE_FAIL();
+       }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = wszValidAddress;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwCountryCode = 0;
+
+    if (! DoLineDial(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+       {
+          TLINE_FAIL();
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_CALLSTATE msg", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if (! DoLineUnpark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+          TLINE_FAIL();
+       }
+
+    if(fTestPassed)
+      {
+        AddMessage(
+            LINE_CALLSTATE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINECALLSTATE_ONHOLD,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+        if (! WaitForAllMessages())
+          {
+           TLINE_FAIL();
+           fTestPassed = FALSE;
+          }
+        else
+          fTestPassed = TRUE; 
+       }        
+    }
+    else
+    {
+    if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+          TLINE_FAIL();
+       }
+    }
+ 
+
+  
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    FreeTestHeap();
+ 
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    if ( ! DoLineUnpark(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineUnpark(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineUnpark: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineUnpark  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/sline.c b/private/tapi/qa/trapper/itest/tsline/sline.c
new file mode 100644
index 000000000..0ef044afe
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/sline.c
@@ -0,0 +1,347 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    sline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "sline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTSLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TSLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTSLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninitialize(TRUE, TRUE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGatherDigits(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMonitorDigits(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMonitorMedia(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMonitorTones(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePark(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUnpark(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePickup(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUncompleteCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAppPriority(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAppPriority(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCurrentLocation(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallData(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallQualityOfService(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallTreatment(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test16(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetLineDevStatus(TRUE, FALSE));
+}
+
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tsline/sline.h b/private/tapi/qa/trapper/itest/tsline/sline.h
new file mode 100644
index 000000000..14058f2ac
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/sline.h
@@ -0,0 +1,308 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    sline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	31-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef SLINE_H
+#define SLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+BOOL
+TestLineUninitialize(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+BOOL
+TestLineGatherDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMonitorDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMonitorMedia(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineMonitorTones(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePark(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineUnpark(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePickup(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineUncompleteCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetAppPriority(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAppPriority(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCurrentLocation(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCallData(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCallQualityOfService(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetCallTreatment(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetLineDevStatus(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    );
+
+BOOL
+WINAPI
+Test16(
+    HINSTANCE   hAppInst
+    );
+
+
+#endif  // SLINE_H
diff --git a/private/tapi/qa/trapper/itest/tsline/sline.rc b/private/tapi/qa/trapper/itest/tsline/sline.rc
new file mode 100644
index 000000000..ccd2ca737
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/sline.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI TSLine API test Library"
+#define VER_INTERNALNAME_STR        "tsline.dll"
+#define VER_ORIGINALFILENAME_STR    "tsline.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/tsline/tsline.def b/private/tapi/qa/trapper/itest/tsline/tsline.def
new file mode 100644
index 000000000..3e9deb9be
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/tsline.def
@@ -0,0 +1,26 @@
+LIBRARY         tsline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
+        Test16
diff --git a/private/tapi/qa/trapper/itest/tsline/tsline.inc b/private/tapi/qa/trapper/itest/tsline/tsline.inc
new file mode 100644
index 000000000..6e59ea859
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/tsline.inc
@@ -0,0 +1,73 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tsline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+DLLDEF=..\tsline.def
+DLLBASE=0x67000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	..\sline.c \
+		..\itlgad.c  \
+		..\itlmod.c  \
+		..\itlmom.c  \
+		..\itlmot.c  \
+		..\itlpak.c  \
+		..\itlupak.c \
+		..\itlucc.c  \
+		..\itlpk.c  \
+		..\itlgap.c  \
+		..\itlsap.c  \
+		..\itlscl.c  \
+		..\itlscd.c  \
+		..\itlscqs.c \
+		..\itlsct.c \
+		..\itlslds.c \
+ 		..\uline.c \
+		..\sline.rc
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=TSLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tsline/tslinea/makefile b/private/tapi/qa/trapper/itest/tsline/tslinea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/tslinea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tsline/tslinea/sources b/private/tapi/qa/trapper/itest/tsline/tslinea/sources
new file mode 100644
index 000000000..2052364c7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/tslinea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tsline.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/tsline/tslinew/makefile b/private/tapi/qa/trapper/itest/tsline/tslinew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/tslinew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tsline/tslinew/sources b/private/tapi/qa/trapper/itest/tsline/tslinew/sources
new file mode 100644
index 000000000..88960fede
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/tslinew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tsline.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tsline/uline.c b/private/tapi/qa/trapper/itest/tsline/uline.c
new file mode 100644
index 000000000..9369d0f6a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tsline/uline.c
@@ -0,0 +1,277 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "sline.h"
+
+
+char szApiName[15][48] = 
+		{
+		"lineGetAppPriority",
+		"lineGatherDigits",
+		"lineMonitorDigits",
+		"lineMonitorMedia",
+ 		"lineMonitorTones",
+  		"linePark",
+      "lineSetAppPriority",
+      "linePickup",
+		"lineUncompleteCall",
+		"lineSetCurrentLocation",
+		"lineSetCallData",
+      "lineSetCallQualityOfService",
+      "lineSetCallTreatment",
+      "lineSetLineDevStatus",
+      "lineUnpark"
+	};		
+
+
+BOOL TestLineUninitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+     
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 15; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:   
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+          lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+          lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+          lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			       sizeof(LINEEXTENSIONID));
+          lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+          lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			       sizeof(VARSTRING));
+	       lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	       lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+          if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+			 FreeTestHeap();
+          break;
+
+        case 1:       
+	      if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 2:       
+          if (! DoLineMonitorDigits(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineMonitorMedia(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+          if (! DoLineMonitorTones(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+	       lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszDirAddress = L"55555";
+#else
+	       lpTapiLineTestInfo->lpszDirAddress = "55555";
+#endif
+	       lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap (
+		       sizeof(VARSTRING));
+	       lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+#else
+	       lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+#endif
+          if (! DoLinePark(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+			 FreeTestHeap();
+          break;
+
+        case 6:       
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+          lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+          lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+          lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			       sizeof(LINEEXTENSIONID));
+          lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+          lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			       sizeof(VARSTRING));
+	       lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	       lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+           if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 7:       
+          if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:     
+          if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 9:     
+          lpTapiLineTestInfo->dwLocation = 1;
+          if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 10:     
+          if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 11:     
+          if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 12:     
+          if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 13:     
+          if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 14:     
+          lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+          lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+          if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+//     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/ttest.c b/private/tapi/qa/trapper/itest/ttest.c
new file mode 100644
index 000000000..6426b8c28
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttest.c
@@ -0,0 +1,2583 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ttest.c
+
+Abstract:
+
+    This module contains common extra functions that don't belong in the
+    core dll that are used by test dlls.
+
+Author:
+
+    Oliver Wallace (OliverW)    24-Nov-1995
+
+
+Revision History:
+    Palamalai (Gopi) Gopalakrishnan (pgopi) 18-Mar-1995
+        * Added new function TestPhoneValidBitFlags, TestPhoneinvalidBitFlags
+    Palamalai (Gopi) Gopalakrishnan (pgopi) 25-Mar-1995
+        *  Added new function TestPhoneValidBitFlagsAsy,
+           TestPhoneinvalidBitFlagsAsy
+	RamaKoneru (a-ramako)					03-Apr-1996
+		*	added unicode support for IsESPLineDevice, IsUNIMDMLineDevice,
+		    FindESPLineDevice, FindUNIMDMLineDevice, FindUnusedESPLineDevice
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "doline.h"
+#include "dophone.h"
+#include "vars.h"
+#include "ttest.h"
+
+
+#define LPLINEDEVCAPS_SIZE   1024
+
+#define LPLINEDEVCAPS_SIZE    1024
+#define LPLINEDEVSTATUS_SIZE  1024
+
+#define TIMEOUT               2000
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the tcore dll
+// should be loaded/freed during a process attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for ttest dll
+HANDLE ghTtestDll  = NULL;
+CHAR gszTcoreDll[] = "tcore";
+
+
+// Local function prototypes
+DWORD
+FindFirstBitInPattern(
+    DWORD BitPattern
+    );
+
+
+BOOL
+WINAPI
+TtestDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTtestDll = hDLL;
+
+            // Load the tcore dll if this is the first process
+            // to attach and if the dll hasn't already been mapped
+            // into this process's address space.
+//            if (glModuleUsage == 1)
+//            {
+//                if (GetModuleHandle(gszTcoreDll) == NULL);
+//                {
+//                    return (LoadLibrary(gszTcoreDll) == NULL);
+//                }
+//            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    return (FreeLibrary(hTcoreDll));
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+FindESPLineDevice(
+    LPTAPILINETESTINFO lpTapiLineInfo
+    )
+{
+    LPLINEDEVCAPS lpLineDevCaps;
+    LPLINEDEVCAPS lpLineDevCaps_Orig;
+    BOOL          fFoundESP;
+
+    lpLineDevCaps = (LPLINEDEVCAPS) ITAlloc(LPLINEDEVCAPS_SIZE);
+
+    // Use local lpLineDevCaps to guarantee pointer is valid and
+    // large enough to support any API version to date
+    lpLineDevCaps_Orig = lpTapiLineInfo->lpLineDevCaps;
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps;
+
+    for (lpTapiLineInfo->dwDeviceID = 0, fFoundESP = FALSE;
+        (lpTapiLineInfo->dwDeviceID < *lpTapiLineInfo->lpdwNumDevs) &&
+           !fFoundESP;
+        (lpTapiLineInfo->dwDeviceID)++)
+    {
+#ifdef WUNICODE
+        WCHAR *pwszProviderInfo;
+#else
+        char *pszProviderInfo;
+#endif
+
+        lpLineDevCaps->dwTotalSize = LPLINEDEVCAPS_SIZE;
+
+        if (! DoLineNegotiateAPIVersion(lpTapiLineInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+        if (! DoLineGetDevCaps(lpTapiLineInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+#ifdef WUNICODE
+        pwszProviderInfo = (WCHAR *)(((LPBYTE) lpTapiLineInfo->lpLineDevCaps) +
+                          lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %ws",
+		pwszProviderInfo);
+#else
+        pszProviderInfo = ((char *) lpTapiLineInfo->lpLineDevCaps) +
+                          lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset;
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %s",
+		pszProviderInfo);
+#endif
+
+        __try
+        {
+#ifdef WUNICODE
+            if (wcsstr(pwszProviderInfo, L"ESP"))
+            {
+                fFoundESP = TRUE;
+            }
+#else
+            if (strstr(pszProviderInfo, "ESP"))
+            {
+                fFoundESP = TRUE;
+            }
+#endif
+        }
+        __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+    }
+
+    // Restore lpLineDevCaps and free local lpLineDevCaps
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps_Orig;
+    ITFree(lpLineDevCaps);
+
+    if (fFoundESP == FALSE)
+    {
+        OutputTAPIDebugInfo(
+               DBUG_SHOW_PASS,
+               "  Unable to locate ESP line");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+FindUnimdmLineDevice(
+    LPTAPILINETESTINFO lpTapiLineInfo
+    )
+{
+    LPLINEDEVCAPS lpLineDevCaps;
+    LPLINEDEVCAPS lpLineDevCaps_Orig;
+    BOOL          fFoundUnimdm;
+
+    lpLineDevCaps = (LPLINEDEVCAPS) ITAlloc(LPLINEDEVCAPS_SIZE);
+
+    // Use local lpLineDevCaps to guarantee pointer is valid and
+    // large enough to support any API version to date
+    lpLineDevCaps_Orig = lpTapiLineInfo->lpLineDevCaps;
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps;
+
+    for (lpTapiLineInfo->dwDeviceID = 0, fFoundUnimdm = FALSE;
+        (lpTapiLineInfo->dwDeviceID < *lpTapiLineInfo->lpdwNumDevs) &&
+           !fFoundUnimdm;
+        (lpTapiLineInfo->dwDeviceID)++)
+    {
+#ifdef WUNICODE
+        WCHAR *pwszProviderInfo;
+#else
+        char *pszProviderInfo;
+#endif
+
+        lpLineDevCaps->dwTotalSize = LPLINEDEVCAPS_SIZE;
+
+        if (! DoLineNegotiateAPIVersion(lpTapiLineInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+        if (! DoLineGetDevCaps(lpTapiLineInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+#ifdef WUNICODE
+        pwszProviderInfo = (WCHAR *)(( (LPBYTE) lpTapiLineInfo->lpLineDevCaps) +
+                          lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %ws",
+		pwszProviderInfo);
+#else
+        pszProviderInfo = ((char *) lpTapiLineInfo->lpLineDevCaps) +
+                          lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset;
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %s",
+		pszProviderInfo);
+#endif
+
+        __try
+        {
+#ifdef WUNICODE
+            if (wcsstr(pwszProviderInfo, L"UNIMDM"))
+            {
+                fFoundUnimdm = TRUE;
+            }
+#else
+            if (strstr(pszProviderInfo, "UNIMDM"))
+            {
+                fFoundUnimdm = TRUE;
+            }
+#endif
+        }
+        __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+    }
+
+    // Restore lpLineDevCaps and free local lpLineDevCaps
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps_Orig;
+    ITFree(lpLineDevCaps);
+
+    if (fFoundUnimdm == FALSE)
+    {
+        OutputTAPIDebugInfo(
+               DBUG_SHOW_PASS,
+               "  Unable to locate Unimdm line");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+
+
+BOOL
+WINAPI
+FindUnusedESPLineDevice(
+    LPTAPILINETESTINFO lpTapiLineInfo
+    )
+{
+    LPLINEDEVCAPS lpLineDevCaps;
+    LPLINEDEVCAPS lpLineDevCaps_Orig;
+    LPLINEDEVSTATUS lpLineDevStatus;
+    LPLINEDEVSTATUS lpLineDevStatus_Orig;
+    LOGPROC       lpfnLogProc;
+    BOOL          fFoundESP;
+
+    lpfnLogProc     = GetLogProc();
+    lpLineDevCaps   = (LPLINEDEVCAPS) ITAlloc(LPLINEDEVCAPS_SIZE);
+    lpLineDevStatus = (LPLINEDEVSTATUS) ITAlloc(LPLINEDEVSTATUS_SIZE);
+
+    // Use local lpLineDevCaps to guarantee pointer is valid and
+    // large enough to support any API version to date
+    lpLineDevCaps_Orig = lpTapiLineInfo->lpLineDevCaps;
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps;
+    lpLineDevStatus_Orig = lpTapiLineInfo->lpLineDevStatus;
+    lpTapiLineInfo->lpLineDevStatus = lpLineDevStatus;
+
+    for (lpTapiLineInfo->dwDeviceID = 0, fFoundESP = FALSE;
+        (lpTapiLineInfo->dwDeviceID < *lpTapiLineInfo->lpdwNumDevs) &&
+           !fFoundESP;
+        (lpTapiLineInfo->dwDeviceID)++)
+    {
+#ifdef WUNICODE
+        WCHAR *pwszProviderInfo;
+#else
+        char *pszProviderInfo;
+#endif
+
+        lpLineDevCaps->dwTotalSize = LPLINEDEVCAPS_SIZE;
+
+        if (! DoLineNegotiateAPIVersion(lpTapiLineInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+        if (! DoLineGetDevCaps(lpTapiLineInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+#ifdef WUNICODE
+        pwszProviderInfo = (WCHAR *) (((LPBYTE)lpTapiLineInfo->lpLineDevCaps) +
+                          lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset);
+#else
+        pszProviderInfo = ((char *) lpTapiLineInfo->lpLineDevCaps) +
+                          lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset;
+#endif
+
+        __try
+        {
+#ifdef WUNICODE
+            if (wcsstr(pwszProviderInfo, L"ESP"))
+            {
+                if (DoLineGetLineDevStatus(lpTapiLineInfo, TAPISUCCESS))
+                {
+                    if (lpTapiLineInfo->lpLineDevStatus->dwNumOpens == 0)
+                    {
+                        fFoundESP = TRUE;
+                    }
+                }
+            }
+#else
+            if (strstr(pszProviderInfo, "ESP"))
+            {
+                if (DoLineGetLineDevStatus(lpTapiLineInfo, TAPISUCCESS))
+                {
+                    if (lpTapiLineInfo->lpLineDevStatus->dwNumOpens == 0)
+                    {
+                        fFoundESP = TRUE;
+                    }
+                }
+            }
+#endif
+        }
+        __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+    }
+
+    // Restore lpLineDevCaps and lpLineDevStatus
+    lpTapiLineInfo->lpLineDevCaps   = lpLineDevCaps_Orig;
+    lpTapiLineInfo->lpLineDevStatus = lpLineDevStatus_Orig;
+
+    // Free local lpLineDevCaps and lpLineDevStatus allocations
+    ITFree(lpLineDevCaps);
+    ITFree(lpLineDevStatus);
+
+    if (fFoundESP == FALSE)
+    {
+        (* lpfnLogProc)(
+               DBUG_SHOW_FAILURE,
+               "  Unable to locate ESP line");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+
+// FindLineDevWithExt searches for a line device that supports extensions.
+//
+// Assumes:  line has already been initialized and info is stored in
+//           lpTapiLineTestInfo structure
+//
+// Note   :  This function does not look for a device supported by a
+//           particular service provider
+//
+// Results:  dwDeviceID field will correspond to the first line device
+//           (search device IDs from 0 to NumDevs - 1) if a line device
+//           supporting extensions is found.  Otherwise the field will not
+//           be modified.
+
+BOOL
+WINAPI
+FindLineDevWithExt(LPTAPILINETESTINFO lpTapiLineTestInfo)
+{
+    LOGPROC pfnLogFunc;
+    DWORD dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    DWORD dwNumDevs       = *(lpTapiLineTestInfo->lpdwNumDevs);
+    BOOL fFoundExtDevice  = FALSE;
+
+    pfnLogFunc = GetLogProc();
+
+    for (lpTapiLineTestInfo->dwDeviceID = 0;
+         lpTapiLineTestInfo->dwDeviceID < dwNumDevs && ! fFoundExtDevice;
+         lpTapiLineTestInfo->dwDeviceID++)
+    {
+        if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            break;   // Error, no need to search any longer
+        }
+        if (memcmp(
+                   lpTapiLineTestInfo->lpExtID,
+                   &(lpTapiLineTestInfo->ExtIDZero),
+                   sizeof(LINEEXTENSIONID))
+                   != 0)
+        {
+            fFoundExtDevice = TRUE;
+        }
+        (*pfnLogFunc)(
+            DBUG_SHOW_PARAMS,
+            "  ExtResult=x%0lx%0lx%0lx%0lx",
+            lpTapiLineTestInfo->lpExtID->dwExtensionID0,
+            lpTapiLineTestInfo->lpExtID->dwExtensionID1,
+            lpTapiLineTestInfo->lpExtID->dwExtensionID2,
+            lpTapiLineTestInfo->lpExtID->dwExtensionID3
+            );
+    }
+
+    // Test to see if a device supporting extensions was found
+    if (! fFoundExtDevice)
+    {
+        (*pfnLogFunc)(
+            DBUG_SHOW_FAILURE,
+            "  %s tests FAILED",
+            lpTapiLineTestInfo->szTestFunc
+            );
+        (*pfnLogFunc)(
+            DBUG_SHOW_FAILURE,
+            "    No devices supporting extensions were found"
+            );
+
+        // Restore dwDeviceID field if line device supporting extensions
+        // found.
+        lpTapiLineTestInfo->dwDeviceID = dwDeviceID_Orig;
+    }
+
+    return fFoundExtDevice;
+}
+
+
+BOOL
+WINAPI
+ShouldTapiTestAbort(
+    LPCSTR lpszTestName,
+    BOOL fQuietMode
+    )
+{
+    LONG lResult;
+    char szTitleBuf[80];
+
+    if (fQuietMode == FALSE)
+    {
+        wsprintf( szTitleBuf, "%s:  Error", lpszTestName);
+        lResult = MessageBox(
+            ghTtestDll,
+            "Test step failed unexpectedly.\n\rContinue anyway?",
+            szTitleBuf,
+            MB_SETFOREGROUND | MB_TASKMODAL | MB_ICONQUESTION | MB_YESNO);
+
+        // Only abort test if IDYES was returned
+        if (lResult == IDYES)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+
+BOOL
+WINAPI
+TestInvalidBitFlags(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNC lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestInvalidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstValidReservedBit;
+    DWORD dwFirstValidExtBit;
+    DWORD dwFirstInvalidReservedBit;
+    DWORD dwFirstInvalidExtBit;
+    DWORD dwInvalidReservedBitsUnion;
+    DWORD dwInvalidExtBitsUnion;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+    dwInvalidReservedBitsUnion = ~dwValidReservedBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwReservedVectorField;
+    dwInvalidExtBitsUnion      = ~dwValidExtBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwExtVectorField;
+    dwValidReservedBitsUnion  &= ~dwExcludeBitFlags;
+    dwValidExtBitsUnion       &= ~dwExcludeBitFlags;
+
+    // Determine the first valid and invalid bits in
+    // the reserved and ext sections
+    dwFirstValidReservedBit   = FindFirstBitInPattern(dwValidReservedBitsUnion);
+    dwFirstValidExtBit        = FindFirstBitInPattern(dwValidExtBitsUnion);
+    dwFirstInvalidReservedBit = FindFirstBitInPattern(
+                                              dwInvalidReservedBitsUnion
+                                              );
+    dwFirstInvalidExtBit      = FindFirstBitInPattern(dwInvalidExtBitsUnion);
+
+
+    // Test special bit pattern
+    *lpdwTestParam = dwSpecialBitTest;
+    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+
+    // Test null bit pattern
+    if(fTestNullParam)
+    {
+    *lpdwTestParam = 0x00000000;
+    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+    }
+
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+        // Test the union of the valid bit flags if more than one bit set
+        if ( MultipleBitsSetInDWORD(dwValidReservedBitsUnion) )
+        {
+            *lpdwTestParam = dwValidReservedBitsUnion;
+            fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return (FALSE);
+            }
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (eExtFieldType == FIELDTYPE_MUTEX)
+            {
+                // Test one bit set in both the reserved and extension fields
+                if (dwFirstValidExtBit)
+                {
+                    *lpdwTestParam = dwFirstValidReservedBit |
+                                     dwFirstValidExtBit;
+
+                    fTestPassed    = lpfnTestLineFunc(
+                                               lpTestLineInfo,
+                                               lExpectedResult);
+                     *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+
+                // Test no bits set in reserved field and multiple bits
+                // set in the extension field
+                if ( MultipleBitsSetInDWORD(dwValidExtBitsUnion) )
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestLineFunc(
+                                               lpTestLineInfo,
+                                               lExpectedResult);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+            else
+            {
+                // Field type is union...Test no bits set in reserved field
+                // and one or more bits set in the extension field
+                if (dwValidExtBitsUnion)
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestLineFunc(
+                                               lpTestLineInfo,
+                                               lExpectedResult);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidReservedBit)
+    {
+        // Cycle through and test each invalid reserved bit set
+        while (dwTestVector & dwReservedVectorField)
+        {
+            if (dwTestVector & dwInvalidReservedBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the reserved field
+        dwTestVector = dwFirstValidReservedBit | dwFirstInvalidReservedBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidExtBit)
+    {
+        // Cycle through and test each invalid extension bit set
+        while (dwTestVector & dwExtVectorField)
+        {
+            if (dwTestVector & dwInvalidExtBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the extension field
+        dwTestVector = dwFirstValidExtBit | dwFirstInvalidExtBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+    return (TRUE);
+}
+
+
+BOOL
+TestValidBitFlags(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNC lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestValidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstReservedBit;
+    DWORD dwFirstExtBit;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+
+    if (dwCommonBitFlags)
+    {
+        // OR common set of bits into union
+        if (dwCommonBitFlags & dwReservedVectorField)
+        {
+            dwReservedBitsUnion |= dwCommonBitFlags;
+        }
+        else
+        {
+            (* lpfnLogProc)(
+                    DBUG_SHOW_FAILURE,
+                    "%s:  Invalid CommonBitFlags selected",
+                    lpszTestFunc);
+            return FALSE;
+        }
+    }
+
+    // Find the first bit to test
+    dwFirstReservedBit = FindFirstBitInPattern(dwReservedBitsUnion);
+    dwFirstExtBit      = FindFirstBitInPattern(dwExtBitsUnion);
+
+
+    // Do the special bit test
+    if (dwSpecialBitTest)
+    {
+        *lpdwTestParam = dwSpecialBitTest;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test the null param
+    if (fTestNullParam)
+    {
+        *lpdwTestParam = 0x00000000;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test each single bit
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+
+       dwTestVector = dwFirstReservedBit;
+        while (dwTestVector & dwReservedBitsUnion)
+        {
+            *lpdwTestParam = dwTestVector;
+            fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return FALSE;
+            }																
+        dwTestVector <<= 1;
+
+        }
+// XYD, wrong place, infinity loop        dwTestVector <<= 1;
+
+        // Test unused bits (if applicable)
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwTestVector = dwFirstExtBit)
+            {
+                while (dwTestVector & dwExtBitsUnion)
+                {
+                    if (eExtFieldType == FIELDTYPE_MUTEX)
+                    {
+                        *lpdwTestParam = dwTestVector;
+                    }
+                    else
+                    {
+                        *lpdwTestParam = dwTestVector | dwFirstReservedBit;
+                    }
+                    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                    dwTestVector <<= 1;
+                }
+            }
+            else if (eExtFieldType == FIELDTYPE_UNION)
+            {
+                if (dwExtBitsUnion)
+                {
+                    *lpdwTestParam = dwExtBitsUnion | dwFirstReservedBit;
+                    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    else if (eReservedFieldType == FIELDTYPE_UNION)
+    {
+        *lpdwTestParam = dwReservedBitsUnion;
+
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwExtBitsUnion)
+            {
+                *lpdwTestParam = dwCommonBitFlags | dwExtBitsUnion;
+
+                if (! lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS))
+                {
+                    *lpdwTestParam = dwParamValue;
+                    return (FALSE);
+                }
+
+                *lpdwTestParam |= dwReservedBitsUnion;
+                fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+        }
+    }
+    return (TRUE);
+}
+
+
+
+TestInvalidBitFlagsAsy(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNCASY lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestInvalidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstValidReservedBit;
+    DWORD dwFirstValidExtBit;
+    DWORD dwFirstInvalidReservedBit;
+    DWORD dwFirstInvalidExtBit;
+    DWORD dwInvalidReservedBitsUnion;
+    DWORD dwInvalidExtBitsUnion;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+    dwInvalidReservedBitsUnion = ~dwValidReservedBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwReservedVectorField;
+    dwInvalidExtBitsUnion      = ~dwValidExtBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwExtVectorField;
+    dwValidReservedBitsUnion  &= ~dwExcludeBitFlags;
+    dwValidExtBitsUnion       &= ~dwExcludeBitFlags;
+
+    // Determine the first valid and invalid bits in
+    // the reserved and ext sections
+    dwFirstValidReservedBit   = FindFirstBitInPattern(dwValidReservedBitsUnion);
+    dwFirstValidExtBit        = FindFirstBitInPattern(dwValidExtBitsUnion);
+    dwFirstInvalidReservedBit = FindFirstBitInPattern(
+                                              dwInvalidReservedBitsUnion
+                                              );
+    dwFirstInvalidExtBit      = FindFirstBitInPattern(dwInvalidExtBitsUnion);
+
+
+    // Test special bit pattern
+    *lpdwTestParam = dwSpecialBitTest;
+    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+
+    // Test null bit pattern
+    if(fTestNullParam)
+    {
+    *lpdwTestParam = 0x00000000;
+    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+    }
+
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+        // Test the union of the valid bit flags if more than one bit set
+        if ( MultipleBitsSetInDWORD(dwValidReservedBitsUnion) )
+        {
+            *lpdwTestParam = dwValidReservedBitsUnion;
+            fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return (FALSE);
+            }
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (eExtFieldType == FIELDTYPE_MUTEX)
+            {
+                // Test one bit set in both the reserved and extension fields
+                if (dwFirstValidExtBit)
+                {
+                    *lpdwTestParam = dwFirstValidReservedBit |
+                                     dwFirstValidExtBit;
+
+                    fTestPassed    = lpfnTestLineFunc(
+                                               lpTestLineInfo,
+                                               lExpectedResult, TRUE);
+                     *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+
+                // Test no bits set in reserved field and multiple bits
+                // set in the extension field
+                if ( MultipleBitsSetInDWORD(dwValidExtBitsUnion) )
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestLineFunc(
+                                               lpTestLineInfo,
+                                               lExpectedResult, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+            else
+            {
+                // Field type is union...Test no bits set in reserved field
+                // and one or more bits set in the extension field
+                if (dwValidExtBitsUnion)
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestLineFunc(
+                                               lpTestLineInfo,
+                                               lExpectedResult, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidReservedBit)
+    {
+        // Cycle through and test each invalid reserved bit set
+        while (dwTestVector & dwReservedVectorField)
+        {
+            if (dwTestVector & dwInvalidReservedBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the reserved field
+        dwTestVector = dwFirstValidReservedBit | dwFirstInvalidReservedBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidExtBit)
+    {
+        // Cycle through and test each invalid extension bit set
+        while (dwTestVector & dwExtVectorField)
+        {
+            if (dwTestVector & dwInvalidExtBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the extension field
+        dwTestVector = dwFirstValidExtBit | dwFirstInvalidExtBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, lExpectedResult, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+    return (TRUE);
+}
+
+
+BOOL
+TestValidBitFlagsAsy(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNCASY lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestValidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstReservedBit;
+    DWORD dwFirstExtBit;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+
+    if (dwCommonBitFlags)
+    {
+        // OR common set of bits into union
+        if (dwCommonBitFlags & dwReservedVectorField)
+        {
+            dwReservedBitsUnion |= dwCommonBitFlags;
+        }
+        else
+        {
+            (* lpfnLogProc)(
+                    DBUG_SHOW_FAILURE,
+                    "%s:  Invalid CommonBitFlags selected",
+                    lpszTestFunc);
+            return FALSE;
+        }
+    }
+
+    // Find the first bit to test
+    dwFirstReservedBit = FindFirstBitInPattern(dwReservedBitsUnion);
+    dwFirstExtBit      = FindFirstBitInPattern(dwExtBitsUnion);
+
+
+    // Do the special bit test
+    if (dwSpecialBitTest)
+    {
+        *lpdwTestParam = dwSpecialBitTest;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test the null param
+    if (fTestNullParam)
+    {
+        *lpdwTestParam = 0x00000000;
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test each single bit
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+
+       dwTestVector = dwFirstReservedBit;
+        while (dwTestVector & dwReservedBitsUnion)
+        {
+            *lpdwTestParam = dwTestVector;
+            fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return FALSE;
+            }																
+        dwTestVector <<= 1;
+
+        }
+// XYD, wrong place, infinity loop        dwTestVector <<= 1;
+
+        // Test unused bits (if applicable)
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwTestVector = dwFirstExtBit)
+            {
+                while (dwTestVector & dwExtBitsUnion)
+                {
+                    if (eExtFieldType == FIELDTYPE_MUTEX)
+                    {
+                        *lpdwTestParam = dwTestVector;
+                    }
+                    else
+                    {
+                        *lpdwTestParam = dwTestVector | dwFirstReservedBit;
+                    }
+                    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                    dwTestVector <<= 1;
+                }
+            }
+            else if (eExtFieldType == FIELDTYPE_UNION)
+            {
+                if (dwExtBitsUnion)
+                {
+                    *lpdwTestParam = dwExtBitsUnion | dwFirstReservedBit;
+                    fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    else if (eReservedFieldType == FIELDTYPE_UNION)
+    {
+        *lpdwTestParam = dwReservedBitsUnion;
+
+        fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwExtBitsUnion)
+            {
+                *lpdwTestParam = dwCommonBitFlags | dwExtBitsUnion;
+
+                if (! lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE))
+                {
+                    *lpdwTestParam = dwParamValue;
+                    return (FALSE);
+                }
+
+                *lpdwTestParam |= dwReservedBitsUnion;
+                fTestPassed = lpfnTestLineFunc(lpTestLineInfo, TAPISUCCESS, TRUE);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+        }
+    }
+    return (TRUE);
+}
+
+BOOL
+WINAPI
+TestPhoneInvalidBitFlags(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNC lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestPhoneInvalidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstValidReservedBit;
+    DWORD dwFirstValidExtBit;
+    DWORD dwFirstInvalidReservedBit;
+    DWORD dwFirstInvalidExtBit;
+    DWORD dwInvalidReservedBitsUnion;
+    DWORD dwInvalidExtBitsUnion;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+    dwInvalidReservedBitsUnion = ~dwValidReservedBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwReservedVectorField;
+    dwInvalidExtBitsUnion      = ~dwValidExtBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwExtVectorField;
+    dwValidReservedBitsUnion  &= ~dwExcludeBitFlags;
+    dwValidExtBitsUnion       &= ~dwExcludeBitFlags;
+
+    // Determine the first valid and invalid bits in
+    // the reserved and ext sections
+    dwFirstValidReservedBit   = FindFirstBitInPattern(dwValidReservedBitsUnion);
+    dwFirstValidExtBit        = FindFirstBitInPattern(dwValidExtBitsUnion);
+    dwFirstInvalidReservedBit = FindFirstBitInPattern(
+                                              dwInvalidReservedBitsUnion
+                                              );
+    dwFirstInvalidExtBit      = FindFirstBitInPattern(dwInvalidExtBitsUnion);
+
+
+    // Test special bit pattern
+    *lpdwTestParam = dwSpecialBitTest;
+    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+
+    // Test null bit pattern
+    if(fTestNullParam)
+    {
+    *lpdwTestParam = 0x00000000;
+    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+    }
+
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+        // Test the union of the valid bit flags if more than one bit set
+        if ( MultipleBitsSetInDWORD(dwValidReservedBitsUnion) )
+        {
+            *lpdwTestParam = dwValidReservedBitsUnion;
+            fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return (FALSE);
+            }
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (eExtFieldType == FIELDTYPE_MUTEX)
+            {
+                // Test one bit set in both the reserved and extension fields
+                if (dwFirstValidExtBit)
+                {
+                    *lpdwTestParam = dwFirstValidReservedBit |
+                                     dwFirstValidExtBit;
+
+                    fTestPassed    = lpfnTestPhoneFunc(
+                                               lpTestPhoneInfo,
+                                               lExpectedResult);
+                     *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+
+                // Test no bits set in reserved field and multiple bits
+                // set in the extension field
+                if ( MultipleBitsSetInDWORD(dwValidExtBitsUnion) )
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestPhoneFunc(
+                                               lpTestPhoneInfo,
+                                               lExpectedResult);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+            else
+            {
+                // Field type is union...Test no bits set in reserved field
+                // and one or more bits set in the extension field
+                if (dwValidExtBitsUnion)
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestPhoneFunc(
+                                               lpTestPhoneInfo,
+                                               lExpectedResult);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidReservedBit)
+    {
+        // Cycle through and test each invalid reserved bit set
+        while (dwTestVector & dwReservedVectorField)
+        {
+            if (dwTestVector & dwInvalidReservedBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the reserved field
+        dwTestVector = dwFirstValidReservedBit | dwFirstInvalidReservedBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidExtBit)
+    {
+        // Cycle through and test each invalid extension bit set
+        while (dwTestVector & dwExtVectorField)
+        {
+            if (dwTestVector & dwInvalidExtBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the extension field
+        dwTestVector = dwFirstValidExtBit | dwFirstInvalidExtBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+    return (TRUE);
+}
+
+
+BOOL
+TestPhoneValidBitFlags(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNC lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestPhoneValidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstReservedBit;
+    DWORD dwFirstExtBit;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+
+    if (dwCommonBitFlags)
+    {
+        // OR common set of bits into union
+        if (dwCommonBitFlags & dwReservedVectorField)
+        {
+            dwReservedBitsUnion |= dwCommonBitFlags;
+        }
+        else
+        {
+            (* lpfnLogProc)(
+                    DBUG_SHOW_FAILURE,
+                    "%s:  Invalid CommonBitFlags selected",
+                    lpszTestFunc);
+            return FALSE;
+        }
+    }
+
+    // Find the first bit to test
+    dwFirstReservedBit = FindFirstBitInPattern(dwReservedBitsUnion);
+    dwFirstExtBit      = FindFirstBitInPattern(dwExtBitsUnion);
+
+
+    // Do the special bit test
+    if (dwSpecialBitTest)
+    {
+        *lpdwTestParam = dwSpecialBitTest;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test the null param
+    if (fTestNullParam)
+    {
+        *lpdwTestParam = 0x00000000;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test each single bit
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+
+       dwTestVector = dwFirstReservedBit;
+        while (dwTestVector & dwReservedBitsUnion)
+        {
+            *lpdwTestParam = dwTestVector;
+            fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return FALSE;
+            }																
+        dwTestVector <<= 1;
+
+        }
+// XYD, wrong place, infinity loop        dwTestVector <<= 1;
+
+        // Test unused bits (if applicable)
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwTestVector = dwFirstExtBit)
+            {
+                while (dwTestVector & dwExtBitsUnion)
+                {
+                    if (eExtFieldType == FIELDTYPE_MUTEX)
+                    {
+                        *lpdwTestParam = dwTestVector;
+                    }
+                    else
+                    {
+                        *lpdwTestParam = dwTestVector | dwFirstReservedBit;
+                    }
+                    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                    dwTestVector <<= 1;
+                }
+            }
+            else if (eExtFieldType == FIELDTYPE_UNION)
+            {
+                if (dwExtBitsUnion)
+                {
+                    *lpdwTestParam = dwExtBitsUnion | dwFirstReservedBit;
+                    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    else if (eReservedFieldType == FIELDTYPE_UNION)
+    {
+        *lpdwTestParam = dwReservedBitsUnion;
+
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwExtBitsUnion)
+            {
+                *lpdwTestParam = dwCommonBitFlags | dwExtBitsUnion;
+
+                if (! lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS))
+                {
+                    *lpdwTestParam = dwParamValue;
+                    return (FALSE);
+                }
+
+                *lpdwTestParam |= dwReservedBitsUnion;
+                fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+        }
+    }
+    return (TRUE);
+}
+
+TestPhoneInvalidBitFlagsAsy(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNCASY lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestInvalidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstValidReservedBit;
+    DWORD dwFirstValidExtBit;
+    DWORD dwFirstInvalidReservedBit;
+    DWORD dwFirstInvalidExtBit;
+    DWORD dwInvalidReservedBitsUnion;
+    DWORD dwInvalidExtBitsUnion;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+    dwInvalidReservedBitsUnion = ~dwValidReservedBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwReservedVectorField;
+    dwInvalidExtBitsUnion      = ~dwValidExtBitsUnion &
+                                 ~dwExcludeBitFlags &
+                                 dwExtVectorField;
+    dwValidReservedBitsUnion  &= ~dwExcludeBitFlags;
+    dwValidExtBitsUnion       &= ~dwExcludeBitFlags;
+
+    // Determine the first valid and invalid bits in
+    // the reserved and ext sections
+    dwFirstValidReservedBit   = FindFirstBitInPattern(dwValidReservedBitsUnion);
+    dwFirstValidExtBit        = FindFirstBitInPattern(dwValidExtBitsUnion);
+    dwFirstInvalidReservedBit = FindFirstBitInPattern(
+                                              dwInvalidReservedBitsUnion
+                                              );
+    dwFirstInvalidExtBit      = FindFirstBitInPattern(dwInvalidExtBitsUnion);
+
+
+    // Test special bit pattern
+    *lpdwTestParam = dwSpecialBitTest;
+    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+
+    // Test null bit pattern
+    if(fTestNullParam)
+    {
+    *lpdwTestParam = 0x00000000;
+    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+    *lpdwTestParam = dwParamValue;
+    if (! fTestPassed)
+    {
+        return FALSE;
+    }
+    }
+
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+        // Test the union of the valid bit flags if more than one bit set
+        if ( MultipleBitsSetInDWORD(dwValidReservedBitsUnion) )
+        {
+            *lpdwTestParam = dwValidReservedBitsUnion;
+            fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return (FALSE);
+            }
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (eExtFieldType == FIELDTYPE_MUTEX)
+            {
+                // Test one bit set in both the reserved and extension fields
+                if (dwFirstValidExtBit)
+                {
+                    *lpdwTestParam = dwFirstValidReservedBit |
+                                     dwFirstValidExtBit;
+
+                    fTestPassed    = lpfnTestPhoneFunc(
+                                               lpTestPhoneInfo,
+                                               lExpectedResult, TRUE);
+                     *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+
+                // Test no bits set in reserved field and multiple bits
+                // set in the extension field
+                if ( MultipleBitsSetInDWORD(dwValidExtBitsUnion) )
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestPhoneFunc(
+                                               lpTestPhoneInfo,
+                                               lExpectedResult, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+            else
+            {
+                // Field type is union...Test no bits set in reserved field
+                // and one or more bits set in the extension field
+                if (dwValidExtBitsUnion)
+                {
+                    *lpdwTestParam = dwValidExtBitsUnion;
+                    fTestPassed    = lpfnTestPhoneFunc(
+                                               lpTestPhoneInfo,
+                                               lExpectedResult, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidReservedBit)
+    {
+        // Cycle through and test each invalid reserved bit set
+        while (dwTestVector & dwReservedVectorField)
+        {
+            if (dwTestVector & dwInvalidReservedBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the reserved field
+        dwTestVector = dwFirstValidReservedBit | dwFirstInvalidReservedBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+
+    if (dwTestVector = dwFirstInvalidExtBit)
+    {
+        // Cycle through and test each invalid extension bit set
+        while (dwTestVector & dwExtVectorField)
+        {
+            if (dwTestVector & dwInvalidExtBitsUnion)
+            {
+                *lpdwTestParam = dwTestVector;
+                fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+            dwTestVector <<= 1;
+        }
+
+        // Check a valid and invalid bit set in the extension field
+        dwTestVector = dwFirstValidExtBit | dwFirstInvalidExtBit;
+        *lpdwTestParam = dwTestVector;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, lExpectedResult, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+    }
+    return (TRUE);
+}
+
+
+BOOL
+TestPhoneValidBitFlagsAsy(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNCASY lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    )
+{
+    BOOL fTestPassed;
+    LPCSTR lpszTestFunc = "TestValidBitFlags";
+
+    DWORD dwParamValue = *lpdwTestParam;
+    DWORD dwReservedVectorField = dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwExtVectorField      = ~dwBitVectorMasks[(int)eReservedFieldSize];
+    DWORD dwFirstReservedBit;
+    DWORD dwFirstExtBit;
+    DWORD dwTestVector;
+
+    LOGPROC lpfnLogProc = GetLogProc();
+
+
+    if (dwCommonBitFlags)
+    {
+        // OR common set of bits into union
+        if (dwCommonBitFlags & dwReservedVectorField)
+        {
+            dwReservedBitsUnion |= dwCommonBitFlags;
+        }
+        else
+        {
+            (* lpfnLogProc)(
+                    DBUG_SHOW_FAILURE,
+                    "%s:  Invalid CommonBitFlags selected",
+                    lpszTestFunc);
+            return FALSE;
+        }
+    }
+
+    // Find the first bit to test
+    dwFirstReservedBit = FindFirstBitInPattern(dwReservedBitsUnion);
+    dwFirstExtBit      = FindFirstBitInPattern(dwExtBitsUnion);
+
+
+    // Do the special bit test
+    if (dwSpecialBitTest)
+    {
+        *lpdwTestParam = dwSpecialBitTest;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test the null param
+    if (fTestNullParam)
+    {
+        *lpdwTestParam = 0x00000000;
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return FALSE;
+        }
+    }
+
+    // Test each single bit
+    if (eReservedFieldType == FIELDTYPE_MUTEX)
+    {
+
+       dwTestVector = dwFirstReservedBit;
+        while (dwTestVector & dwReservedBitsUnion)
+        {
+            *lpdwTestParam = dwTestVector;
+            fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+            *lpdwTestParam = dwParamValue;
+            if (! fTestPassed)
+            {
+                return FALSE;
+            }																
+        dwTestVector <<= 1;
+
+        }
+// XYD, wrong place, infinity loop        dwTestVector <<= 1;
+
+        // Test unused bits (if applicable)
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwTestVector = dwFirstExtBit)
+            {
+                while (dwTestVector & dwExtBitsUnion)
+                {
+                    if (eExtFieldType == FIELDTYPE_MUTEX)
+                    {
+                        *lpdwTestParam = dwTestVector;
+                    }
+                    else
+                    {
+                        *lpdwTestParam = dwTestVector | dwFirstReservedBit;
+                    }
+                    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                    dwTestVector <<= 1;
+                }
+            }
+            else if (eExtFieldType == FIELDTYPE_UNION)
+            {
+                if (dwExtBitsUnion)
+                {
+                    *lpdwTestParam = dwExtBitsUnion | dwFirstReservedBit;
+                    fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+                    *lpdwTestParam = dwParamValue;
+                    if (! fTestPassed)
+                    {
+                        return (FALSE);
+                    }
+                }
+            }
+        }
+    }
+
+    else if (eReservedFieldType == FIELDTYPE_UNION)
+    {
+        *lpdwTestParam = dwReservedBitsUnion;
+
+        fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+        *lpdwTestParam = dwParamValue;
+        if (! fTestPassed)
+        {
+            return (FALSE);
+        }
+
+        if (eReservedFieldSize != FIELDSIZE_32)
+        {
+            if (dwExtBitsUnion)
+            {
+                *lpdwTestParam = dwCommonBitFlags | dwExtBitsUnion;
+
+                if (! lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE))
+                {
+                    *lpdwTestParam = dwParamValue;
+                    return (FALSE);
+                }
+
+                *lpdwTestParam |= dwReservedBitsUnion;
+                fTestPassed = lpfnTestPhoneFunc(lpTestPhoneInfo, TAPISUCCESS, TRUE);
+                *lpdwTestParam = dwParamValue;
+                if (! fTestPassed)
+                {
+                    return (FALSE);
+                }
+            }
+        }
+    }
+    return (TRUE);
+}
+
+
+
+// FindFirstBitInPattern() returns a DWORD with the first (lowest) bit
+// set in dwBitPattern.  If no bits are set, this function returns 0.
+DWORD
+FindFirstBitInPattern(
+    DWORD dwBitPattern
+    )
+{
+    DWORD dwFirstBit = 0x00000001;
+    if (dwBitPattern)
+    {
+        while (dwFirstBit && ! (dwFirstBit & dwBitPattern))
+        {
+            dwFirstBit <<= 1;
+        }
+        return dwFirstBit;
+    }
+    else
+    {
+        return (0x00000000);
+    }
+}
+
+
+BOOL
+WINAPI
+FindESPPhoneDevice(
+    LPTAPIPHONETESTINFO lpTapiPhoneInfo
+    )
+{
+    LPPHONECAPS lpPhoneCaps;
+    LPPHONECAPS lpPhoneCaps_Orig;
+    BOOL          fFoundESP;
+
+    lpPhoneCaps = (LPPHONECAPS) ITAlloc(sizeof(PHONECAPS));
+
+    // Use local lpPhoneCaps to guarantee pointer is valid and
+    // large enough to support any API version to date
+    lpPhoneCaps_Orig = lpTapiPhoneInfo->lpPhoneCaps;
+    lpTapiPhoneInfo->lpPhoneCaps = lpPhoneCaps;
+
+    for (lpTapiPhoneInfo->dwDeviceID = 0, fFoundESP = FALSE;
+        (lpTapiPhoneInfo->dwDeviceID < *lpTapiPhoneInfo->lpdwNumDevs) &&
+           !fFoundESP;
+        (lpTapiPhoneInfo->dwDeviceID)++)
+    {
+        char *pszProviderInfo;
+
+        lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+        if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+        if (! DoPhoneGetDevCaps(lpTapiPhoneInfo, TAPISUCCESS))
+        {
+            break;
+        }
+
+        pszProviderInfo = ((char *) lpTapiPhoneInfo->lpPhoneCaps) +
+                          lpTapiPhoneInfo->lpPhoneCaps->dwProviderInfoOffset;
+
+        __try
+        {
+            if (strstr(pszProviderInfo, "ESP"))
+            {
+                fFoundESP = TRUE;
+            }
+        }
+        __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+    }
+
+    // Restore lpPhoneCaps and free local lpPhoneCaps
+    lpTapiPhoneInfo->lpPhoneCaps = lpPhoneCaps_Orig;
+    ITFree(lpPhoneCaps);
+
+    if (fFoundESP == FALSE)
+    {
+        OutputTAPIDebugInfo(
+               DBUG_SHOW_FAILURE,
+               "  Unable to locate ESP line");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+
+
+BOOL
+WINAPI
+IsESPLineDevice(
+    LPTAPILINETESTINFO lpTapiLineInfo
+    )
+{
+    LPLINEDEVCAPS lpLineDevCaps;
+    LPLINEDEVCAPS lpLineDevCaps_Orig;
+    BOOL fFoundESP = FALSE;
+#ifdef WUNICODE
+    WCHAR *pwszProviderInfo;
+#else
+    char *pszProviderInfo;
+#endif
+
+    lpLineDevCaps = (LPLINEDEVCAPS) ITAlloc(LPLINEDEVCAPS_SIZE);
+    lpLineDevCaps_Orig = lpTapiLineInfo->lpLineDevCaps;
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps;
+
+    lpLineDevCaps->dwTotalSize = LPLINEDEVCAPS_SIZE;
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineInfo, TAPISUCCESS))
+       {
+           return FALSE;
+       }
+
+    if (! DoLineGetDevCaps(lpTapiLineInfo, TAPISUCCESS))
+       {
+           return FALSE;
+       }
+
+#ifdef WUNICODE
+    pwszProviderInfo = (WCHAR *)(((LPBYTE) lpTapiLineInfo->lpLineDevCaps) +
+                       lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %ws",
+		pwszProviderInfo);
+
+#else
+    pszProviderInfo = ((char *) lpTapiLineInfo->lpLineDevCaps) +
+                       lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset;
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %s",
+		pszProviderInfo);
+
+#endif
+
+     __try
+       {
+#ifdef WUNICODE
+        if (wcsstr(pwszProviderInfo, L"ESP"))
+          {
+             fFoundESP = TRUE;
+          }
+#else
+        if (strstr(pszProviderInfo, "ESP"))
+          {
+             fFoundESP = TRUE;
+          }
+#endif
+        }
+     __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+
+
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps_Orig;
+    ITFree(lpLineDevCaps);
+
+    if (fFoundESP == FALSE)
+    {
+        TapiLogDetail(
+               DBUG_SHOW_FAILURE,
+               "  Unable to locate ESP line for this %lx Device",
+					lpTapiLineInfo->dwDeviceID);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+IsUNIMDMLineDevice(
+    LPTAPILINETESTINFO lpTapiLineInfo
+    )
+{
+    LPLINEDEVCAPS lpLineDevCaps;
+    LPLINEDEVCAPS lpLineDevCaps_Orig;
+    BOOL          fFoundUNIMDM = FALSE;
+#ifdef WUNICODE
+    WCHAR *pwszProviderInfo;
+#else
+    char *pszProviderInfo;
+#endif
+
+   lpLineDevCaps = (LPLINEDEVCAPS) ITAlloc(LPLINEDEVCAPS_SIZE);
+    lpLineDevCaps_Orig = lpTapiLineInfo->lpLineDevCaps;
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps;
+
+    lpLineDevCaps->dwTotalSize = LPLINEDEVCAPS_SIZE;
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineInfo, TAPISUCCESS))
+       {
+           return FALSE;
+       }
+    if (! DoLineGetDevCaps(lpTapiLineInfo, TAPISUCCESS))
+       {
+           return FALSE;
+       }
+
+#ifdef WUNICODE
+    pwszProviderInfo = (WCHAR *)(((LPBYTE)lpTapiLineInfo->lpLineDevCaps) +
+                       lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %ws",
+		pwszProviderInfo);
+#else
+    pszProviderInfo = ((char *) lpTapiLineInfo->lpLineDevCaps) +
+                       lpTapiLineInfo->lpLineDevCaps->dwProviderInfoOffset;
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### ProviderInfo = %s",
+		pszProviderInfo);
+#endif
+
+     __try
+       {
+#ifdef WUNICODE
+        if (wcsstr(pwszProviderInfo, L"Modem"))
+          {
+             fFoundUNIMDM = TRUE;
+          }
+#else
+        if (strstr(pszProviderInfo, "Modem"))
+          {
+             fFoundUNIMDM = TRUE;
+          }
+#endif
+        }
+     __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
+               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+        {
+        }
+
+
+    lpTapiLineInfo->lpLineDevCaps = lpLineDevCaps_Orig;
+    ITFree(lpLineDevCaps);
+
+    if (fFoundUNIMDM == FALSE)
+    {
+        TapiLogDetail(
+               DBUG_SHOW_FAILURE,
+               "  Unable to locate UNIMDM line for this %lx Device",
+					lpTapiLineInfo->dwDeviceID);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+BOOL ShowTestCase(BOOL fPassed)
+{
+   if(fPassed)
+   {
+     TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld Passed", dwTestCase+1);
+     dwTestCasePassed++;
+     dwglTestCasePassed++;
+   }
+   else
+   {
+     TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld Failed", dwTestCase+1);
+     dwTestCaseFailed++;
+     dwglTestCaseFailed++;
+   }
+  dwTestCase++;
+  dwglTestCase++;
+  return TRUE;
+}
+
+
+VOID
+WINAPI
+InitTestNumber(VOID)
+{
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+}
+
+
+
+
+#if TAPI_2_0
+
+VOID
+TapiShowProxyBuffer( LPLINEPROXYREQUEST lpProxyBuffer)
+{
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## lpProxyBuffer = %lx",
+			lpProxyBuffer);
+
+		TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"## dwSize = %lx, dwRequestType = %lx",
+		lpProxyBuffer->dwSize,
+		lpProxyBuffer->dwRequestType);
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## dwClientMachineNameSize = %lx, dwClientMachineNameOffset = %lx",
+			lpProxyBuffer->dwClientMachineNameSize,
+			lpProxyBuffer->dwClientMachineNameOffset);
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## dwClientUserNameSize = %lx, dwClientUserNameOffset = %lx",
+			lpProxyBuffer->dwClientUserNameSize,
+			lpProxyBuffer->dwClientUserNameOffset);
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## dwClientAppAPIVersion = %lx",
+			lpProxyBuffer->dwClientAppAPIVersion);
+		
+		/*
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"username= %ls",
+			((LPBYTE)lpProxyBuffer)+lpProxyBuffer->dwClientUserNameOffset);
+		*/
+
+		TapiShowAgent(lpProxyBuffer);
+}
+
+
+VOID
+TapiShowAgent(LPLINEPROXYREQUEST lpProxyBuffer)
+{
+	switch(lpProxyBuffer->dwRequestType)
+	{
+		case LINEPROXYREQUEST_SETAGENTGROUP:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->SetAgentGroup.GroupList.dwTotalSize,
+			lpProxyBuffer->SetAgentGroup.GroupList.dwNeededSize);
+				break;
+
+		case LINEPROXYREQUEST_SETAGENTSTATE:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwAgentState = %lx, dwNextAgentState = %lx",
+			lpProxyBuffer->SetAgentState.dwAgentState,
+			lpProxyBuffer->SetAgentState.dwNextAgentState);
+				break;
+
+		case LINEPROXYREQUEST_SETAGENTACTIVITY:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwAddressID = %lx, dwActivityID = %lx",
+			lpProxyBuffer->SetAgentActivity.dwAddressID,
+			lpProxyBuffer->SetAgentActivity.dwActivityID);
+			break;
+
+
+		case LINEPROXYREQUEST_GETAGENTCAPS:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentCaps.AgentCaps.dwTotalSize,
+			lpProxyBuffer->GetAgentCaps.AgentCaps.dwNeededSize);
+			break;
+
+		case LINEPROXYREQUEST_GETAGENTSTATUS:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentStatus.AgentStatus.dwTotalSize,
+			lpProxyBuffer->GetAgentStatus.AgentStatus.dwNeededSize);
+				break;
+
+		case LINEPROXYREQUEST_AGENTSPECIFIC:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwAgentExtensionIDIndex = %lx",
+			lpProxyBuffer->AgentSpecific.dwAgentExtensionIDIndex);
+				break;
+
+		case LINEPROXYREQUEST_GETAGENTACTIVITYLIST:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentActivityList.ActivityList.dwTotalSize,
+			lpProxyBuffer->GetAgentActivityList.ActivityList.dwNeededSize);
+
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwNumentries = %lx",
+			lpProxyBuffer->GetAgentActivityList.ActivityList.dwNumEntries);
+			
+		break;
+
+		case LINEPROXYREQUEST_GETAGENTGROUPLIST:
+		TapiLogDetail (
+			DBUG_SHOW_DETAIL,
+			"## dwTotalSize = %lx, dwNeedSize = %lx",
+			lpProxyBuffer->GetAgentGroupList.GroupList.dwTotalSize,
+			lpProxyBuffer->GetAgentGroupList.GroupList.dwNeededSize);
+				break;
+
+	}
+	
+}
+
+#endif
+
+
+VOID
+CALLBACK
+AutoDismissDlgTimerProc(
+   HWND  hwnd,
+   UINT  msg,
+   UINT  idTimer,
+   DWORD dwTime
+   )
+{
+   HWND hwndChild;
+   char buf[32];
+
+
+   hwndChild = GetWindow(GetDesktopWindow(), GW_CHILD);
+ 
+   while(hwndChild)
+   {
+     GetWindowText(hwndChild, buf, 31);
+
+     if(strcmp(buf, szTitle) == 0)
+       {
+       break;
+       }
+     hwndChild = GetWindow(hwndChild, GW_HWNDNEXT);
+   }
+
+   if(hwndChild)
+     {
+     KillTimer( (HWND) NULL, idTimer);
+     PostMessage(hwndChild, WM_KEYDOWN, 0x0D, 0x00010028); //ENTRY key
+     dwTimer = 0;
+     }
+  
+} 
+
+
+BOOL 
+PrepareToAutoDismissDlg(
+   BOOL bEnable
+   )
+{
+   if(bEnable)
+   {
+     if( !(dwTimer = SetTimer(
+           (HWND) NULL,
+           0,
+			  TIMEOUT,
+           (TIMERPROC) AutoDismissDlgTimerProc
+           )))
+       {
+         TapiLogDetail (
+           DBUG_SHOW_FAILURE,
+           "SetTimer Failed");
+
+         return FALSE;
+       }
+    }
+    else if (dwTimer)
+    { 
+       KillTimer ((HWND) NULL, dwTimer);
+    }
+    return TRUE;
+}
+   
+
+VOID
+CALLBACK
+AutoDismissWinTimerProc(
+   HWND  hwnd,
+   UINT  msg,
+   UINT  idTimer,
+   DWORD dwTime
+   )
+{
+   HWND hwndChild;
+   char buf[32];
+
+
+   hwndChild = GetWindow(GetDesktopWindow(), GW_CHILD);
+ 
+   while(hwndChild)
+   {
+     GetWindowText(hwndChild, buf, 31);
+
+     if(strcmp(buf, szTitle) == 0)
+       {
+       break;
+       }
+     hwndChild = GetWindow(hwndChild, GW_HWNDNEXT);
+   }
+
+   if(hwndChild)
+     {
+     KillTimer( (HWND) NULL, idTimer);
+     PostMessage(hwndChild, WM_KEYDOWN, 0x0D, 0x00010028);   // ENTER key
+//     PostMessage(hwndChild, WM_DESTROY, 0x0D, 0x00010028);   // ENTER key
+     PostQuitMessage(WM_QUIT);
+     dwTimer = 0;
+     }
+  
+} 
+
+
+BOOL 
+PrepareToAutoDismissWin(
+   BOOL bEnable
+   )
+{
+   if(bEnable)
+   {
+     if( !(dwTimer = SetTimer(
+           (HWND) NULL,
+           0,
+			  TIMEOUT,
+           (TIMERPROC) AutoDismissWinTimerProc
+           )))
+       {
+         TapiLogDetail (
+           DBUG_SHOW_FAILURE,
+           "SetTimer Failed");
+
+         return FALSE;
+       }
+    }
+    else if (dwTimer)
+    { 
+       KillTimer ((HWND) NULL, dwTimer);
+    }
+    return TRUE;
+}
+   
+
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/ttest.def b/private/tapi/qa/trapper/itest/ttest.def
new file mode 100644
index 000000000..66bd8f9da
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttest.def
@@ -0,0 +1,30 @@
+LIBRARY         ttest
+
+DATA            READ WRITE
+
+EXPORTS
+        FindESPLineDevice
+        FindUnimdmLineDevice
+        FindUnusedESPLineDevice
+        FindLineDevWithExt
+        TestInvalidBitFlags
+        TestValidBitFlags
+        TestPhoneInvalidBitFlags
+        TestPhoneValidBitFlags
+        TestInvalidBitFlagsAsy
+        TestValidBitFlagsAsy
+        TestPhoneInvalidBitFlagsAsy
+        TestPhoneValidBitFlagsAsy
+        ShouldTapiTestAbort
+        FindESPPhoneDevice
+        IsESPLineDevice
+        IsUNIMDMLineDevice
+        ShowTestCase
+        InitTestNumber
+        TapiShowProxyBuffer
+	TapiShowAgent
+	AutoDismissDlgTimerProc
+        PrepareToAutoDismissDlg
+	AutoDismissWinTimerProc
+        PrepareToAutoDismissWin
+
diff --git a/private/tapi/qa/trapper/itest/ttest.h b/private/tapi/qa/trapper/itest/ttest.h
new file mode 100644
index 000000000..29baf8a23
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttest.h
@@ -0,0 +1,278 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ttest.h
+
+Abstract:
+
+    This module contains prototypes and data type definitions
+    used by the interface test dll.
+
+Author:
+
+    Oliver Wallace (OliverW)    13-July-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef TTEST_H
+#define TTEST_H
+
+
+#include "windows.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+// Common function declarations
+
+BOOL
+WINAPI
+FindESPLineDevice(
+    LPTAPILINETESTINFO lpTapiLineTestInfo
+    );
+
+BOOL
+WINAPI
+FindUnimdmLineDevice(
+    LPTAPILINETESTINFO lpTapiLineTestInfo
+    );
+
+
+BOOL
+WINAPI
+FindUnusedESPLineDevice(
+    LPTAPILINETESTINFO lpTapiLineTestInfo
+    );
+
+BOOL
+WINAPI
+FindLineDevWithExt(
+    LPTAPILINETESTINFO lpTapiLineTestInfo
+    );
+
+BOOL
+WINAPI
+TestInvalidBitFlags(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNC lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+BOOL
+WINAPI
+TestValidBitFlags(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNC lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+
+BOOL
+WINAPI
+TestPhoneInvalidBitFlags(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNC lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+BOOL
+WINAPI
+TestPhoneValidBitFlags(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNC lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+BOOL
+WINAPI
+TestInvalidBitFlagsAsy(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNCASY lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+
+BOOL
+WINAPI
+TestValidBitFlagsAsy(
+    LPTAPILINETESTINFO lpTestLineInfo,
+    LPFN_TAPILINETESTFUNCASY lpfnTestLineFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+
+BOOL
+WINAPI
+TestPhoneInvalidBitFlagsAsy(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNCASY lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    LONG lExpectedResult,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwValidReservedBitsUnion,
+    DWORD dwValidExtBitsUnion,
+    DWORD dwExcludeBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+
+BOOL
+WINAPI
+TestPhoneValidBitFlagsAsy(
+    LPTAPIPHONETESTINFO lpTestPhoneInfo,
+    LPFN_TAPIPHONETESTFUNCASY lpfnTestPhoneFunc,
+    LPDWORD lpdwTestParam,
+    BITFIELDTYPE eReservedFieldType,
+    BITFIELDTYPE eExtFieldType,
+    BITFIELDSIZE eReservedFieldSize,
+    DWORD dwReservedBitsUnion,
+    DWORD dwExtBitsUnion,
+    DWORD dwCommonBitFlags,
+    DWORD dwSpecialBitTest,
+    BOOL fTestNullParam
+    );
+
+
+BOOL
+WINAPI
+ShouldTapiTestAbort(
+    LPCSTR lpszTestName,
+    BOOL fQuietMode
+    );
+
+
+BOOL
+WINAPI
+FindESPPhoneDevice(
+    LPTAPIPHONETESTINFO lpTapiPhoneTestInfo
+    );
+
+
+BOOL
+WINAPI
+IsESPLineDevice(
+    LPTAPILINETESTINFO lpTapiLineTestInfo
+    );
+
+BOOL
+WINAPI
+IsUNIMDMLineDevice(
+    LPTAPILINETESTINFO lpTapiLineTestInfo
+    );
+
+
+BOOL
+WINAPI
+ShowTestCase(
+    BOOL  fTestPassed
+    );
+
+
+VOID
+WINAPI
+InitTestNumber(
+    VOID
+    );
+
+
+VOID
+CALLBACK
+AutoDismissDlgTimerProc(
+    HWND  hwnd,
+    UINT  msg,
+    UINT  idTimer,
+    DWORD dwTime
+    );
+
+BOOL PrepareToAutoDismissDlg(
+    BOOL bEnable
+    );
+
+VOID
+CALLBACK
+AutoDismissWinTimerProc(
+    HWND  hwnd,
+    UINT  msg,
+    UINT  idTimer,
+    DWORD dwTime
+    );
+
+BOOL PrepareToAutoDismissWin(
+    BOOL bEnable
+    );
+
+
+#if TAPI_2_0
+
+VOID
+TapiShowProxyBuffer( LPLINEPROXYREQUEST);
+
+VOID
+TapiShowAgent(LPLINEPROXYREQUEST );
+
+#endif  // TAPI_2_0
+
+#endif  // TTEST_H
+
+
diff --git a/private/tapi/qa/trapper/itest/ttest.inc b/private/tapi/qa/trapper/itest/ttest.inc
new file mode 100644
index 000000000..3b186372b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttest.inc
@@ -0,0 +1,54 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=ttest
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+DLLBASE=0x62000000
+
+INCLUDES=..\..;..;..\..\..\tcore
+
+USE_CRTDLL=1
+
+SOURCES=..\ttest.c  \
+        ..\version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_0=1 -DTAPI_1_1=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=TtestDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/ttesta/makefile b/private/tapi/qa/trapper/itest/ttesta/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttesta/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/ttesta/sources b/private/tapi/qa/trapper/itest/ttesta/sources
new file mode 100644
index 000000000..91dfa936a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttesta/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\ttest.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+DLLDEF= ..\ttest.def
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/ttestw/makefile b/private/tapi/qa/trapper/itest/ttestw/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttestw/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/ttestw/sources b/private/tapi/qa/trapper/itest/ttestw/sources
new file mode 100644
index 000000000..ff2834df5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/ttestw/sources
@@ -0,0 +1,37 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\ttest.inc
+
+DLLDEF= ..\ttest.def
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/txline/dirs b/private/tapi/qa/trapper/itest/txline/dirs
new file mode 100644
index 000000000..94c7d7753
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/dirs
@@ -0,0 +1,2 @@
+DIRS = txlinea\
+       txlinew
diff --git a/private/tapi/qa/trapper/itest/txline/itlcd.c b/private/tapi/qa/trapper/itest/txline/itlcd.c
new file mode 100644
index 000000000..6cda1e438
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlcd.c
@@ -0,0 +1,541 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcd.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)         19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)		3/29/96		Added UNICODE support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+#define DLG_TITLE_ESP        "TUISPI_lineConfigDialog"
+#define DLG_TITLE_UNIMDM     "Zoom VFX 28.8 Properties"
+
+//  lineConfigDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//      
+// * = Stand-alone test case
+// * 1. Bad dwDeviceID = dwNumDevs
+// * 2. Bad dwDeviceID = -1
+// * 3. Bad hwndOwner (34), with no NULL
+// * 4. Bad lpszDeviceClass (34), with no NULL
+// * 5. Success, valid lpszDeviceClass
+// * 6. Success, lpszDeviceClass = 0
+// * 7. Success, lpszDeviceClass = NULL
+//
+//
+
+BOOL TestLineConfigDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+   HWND hwndOwner;
+#ifdef WUNICODE
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+   LPWSTR lpwszTile;
+#else
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  Begin testing lineConfigDialog  <<<<<<<<"
+	    );
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1);
+
+    // do lineInitializeEx    
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+   // save dwDeviceID
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+
+   // call lineConfigDialog with bad dwDeviceID = dwNumDevs;
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    // Store the dwDeviceID
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    
+    // Try bad device id (-1)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    // Do lineInitializeEx
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    // dwDeviceID = -1
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+    // Check invalid hwndOwner handles
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    // Do lineInitializeEx
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+    hwndOwner = lpTapiLineTestInfo->hwndOwner;
+    // Test bad hwndOwner 
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+	lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+	{
+	    TLINE_FAIL();
+	}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+	    );
+#endif
+
+    // Do lineInitializeEx
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+    // Test bad lpszDeviceClass
+     for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+	TapiLogDetail(
+	DBUG_SHOW_DETAIL,
+	"n= %ld", n);
+#ifdef WUNICODE
+	 lpTapiLineTestInfo->lpwszDeviceClass = 
+	       (LPWSTR) gdwInvalidPointers[n];
+#else
+	 lpTapiLineTestInfo->lpszDeviceClass = 
+	       (LPSTR) gdwInvalidPointers[n];
+#endif
+
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+	{
+	    TLINE_FAIL();
+	}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Set valid szDeviceClass value back
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpwszDeviceClass = 0", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpszDeviceClass = 0", dwTestCase + 1
+	    );
+#endif
+
+    // lineInitializeEx
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+  
+   // Prepare dialog dismiss, get title for esp and unimdm
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+   // Set szDeviceClass empty
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"";
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "";
+#endif
+
+   // Dismiss dialog
+	PrepareToAutoDismissDlg(TRUE);
+   
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	   TLINE_FAIL();
+       }
+    
+	PrepareToAutoDismissDlg(FALSE);
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpwszDeviceClass = null", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpszDeviceClass = null", dwTestCase + 1
+	    );
+#endif
+   
+	// Test lpszDeviceClass = NULL
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = NULL;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = NULL;
+#endif
+
+   // Dismiss dialog
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	   TLINE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpwszDeviceClass = valid", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpszDeviceClass = valid", dwTestCase + 1
+	    );
+#endif
+
+   // Test lpszDeviceClass in valid value
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = (LPWSTR)wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = (LPSTR)szValidDeviceClass;
+#endif
+
+   // Dismiss dialog
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	   TLINE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: lineShutdown when lineConfigDialog is going", dwTestCase + 1
+	    );
+
+    // Do lineInitializeEx
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+  
+   // Get dialog title for esp and unimdm
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"";
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "";
+#endif
+
+   // prepare dismiss dialog
+	PrepareToAutoDismissDlg(TRUE);
+
+   // hwndOwner must set to NULL 
+	lpTapiLineTestInfo->hwndOwner = (HWND) NULL;
+   
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	      TLINE_FAIL();
+       }
+
+   if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	    TLINE_FAIL();
+    }
+
+   // Dismiss dialog after lineShutdown
+	PrepareToAutoDismissDlg(FALSE);
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: lineShutdown when multiple lineConfigDialog are going", dwTestCase + 1
+	    );
+
+    // lineInitializeEx
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+  
+   // Get dialog title for esp and unimdm
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"";
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "";
+#endif
+
+   // prepare dismiss dialog
+	PrepareToAutoDismissDlg(TRUE);
+   // hwndOwner must set to NULL
+	lpTapiLineTestInfo->hwndOwner = (HWND) NULL;
+   
+   // first lineConfigDialog
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	      TLINE_FAIL();
+       }
+
+   // prepare dismiss second dialog
+	PrepareToAutoDismissDlg(TRUE);
+   // second lineConfigDialog
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	      TLINE_FAIL();
+       }
+
+   // prepare dismiss third dialog
+	PrepareToAutoDismissDlg(TRUE);
+   // third lineConfigDialog
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	      TLINE_FAIL();
+       }
+
+
+   // call lineShutdown before all dialog dismiss
+   if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	    TLINE_FAIL();
+    }
+
+   // Dismiss all dialog 
+	PrepareToAutoDismissDlg(FALSE);
+	PrepareToAutoDismissDlg(FALSE);
+	PrepareToAutoDismissDlg(FALSE);
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+	FreeTestHeap();
+
+   // Display test results
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineConfigDialog: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  End testing lineConfigDialog  <<<<<<<<"
+	    );
+  
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlcde.c b/private/tapi/qa/trapper/itest/txline/itlcde.c
new file mode 100644
index 000000000..0aecfc79e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlcde.c
@@ -0,0 +1,617 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcde.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigDialogEdit
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_lineConfigDialogEdit"
+#define DLG_TITLE_UNIMDM     "Zoom VFX 28.8 Properties"
+
+
+//  lineConfigDialogEdit
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+// * 1. Bad dwDeviceID, dwNumDevs
+// * 2. Bad dwDeviceID = -1
+// * 3. Bad hwndOwner (34), with no NULL
+// * 4. Bad lpszDeviceClass (34), with no NULL
+// * 5. Bad lpDeviceConfigIn, make sure dwSize != 0
+// * 6. Bad lpDeviceConfigOut
+// * 7. Bad lpDeviceConfigOut->dwTotalSize = fixed -1
+// * 8. Bad lpDeviceConfigOut->dwTotalSize = 0
+// * 9. Success
+//
+//
+
+BOOL TestLineConfigDialogEdit(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+   HWND hwndOwner;
+#ifdef WUNICODE
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+
+   // Initialize test
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineConfigDialogEdit  <<<<<<<<"
+            );
+    // set parameters for lineInitialzeEx
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+   // Alloc space for some structures, and set dwTotalSize
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+	lpTapiLineTestInfo->lpDeviceConfigIn = 
+         (LPVOID) lpTapiLineTestInfo->lpDeviceConfig;
+
+	lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1);
+    
+    // do lineInitialzeEx and Negotiate
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+   // Set bad dwDeviceID = dwNumDevs
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+
+	if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+           TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    
+    // Try bad device id (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    // lineIntializeEx and Negotiate api version
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    // set bad dwDeviceID = -1
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+           TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check invalid hwndOwner handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    // lineIntializeEx and Negotiate api version
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    hwndOwner = lpTapiLineTestInfo->hwndOwner;
+    // Test bad hwndOwner
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+            );
+#endif
+
+    // lineIntializeEx and Negotiate api version
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test invalid lpszDeviceClass pointer    
+     for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDeviceClass = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDeviceClass = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpDeviceConfigIn pointers", dwTestCase + 1
+            );
+
+    // lineIntializeEx and Negotiate api version
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // test invalid lpDeviceConfigIn pointer, should set dwSize is nonzero
+    lpTapiLineTestInfo->dwSize = 128;
+     for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpDeviceConfigIn = 
+               (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpDeviceConfigOut->dwTotalSize = fixed -1", dwTestCase + 1
+            );
+
+    // lineIntializeEx and Negotiate api version
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set lpDeviceConfigOut->dwTotalSize = fixed (sizeof structure) - 1    
+    lpTapiLineTestInfo->dwSize = 0;
+	 lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize -= 1;
+    if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpDeviceConfigOut->dwTotalSize = 0", dwTestCase + 1
+            );
+
+    // lineIntializeEx and Negotiate api version
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set lpDeviceConfigOut->dwTotalSize = 0    
+    lpTapiLineTestInfo->dwSize = 0;
+	 lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = 0;
+    if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpDeviceConfigOut pointer", dwTestCase + 1
+            );
+
+    // lineIntializeEx and Negotiate api version
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // reset lpDeviceConfigOut->dwTotalSize = sizeof structure    
+	lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+   // set lpDeviceConfigOut to be invalid pointer value
+   for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpDeviceConfigOut = 
+               (LPVARSTRING) gdwInvalidPointers[n];
+        if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+   TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+   // Free all alloc, and reset all parameters
+	FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	 lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineIntializeEx and Negotiate api version
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // Alloc space for some parameters and set dwTotalSize  
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+   // Get dialog title for esp and unimdm
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+   // Test lineConfigDialogEdit should call lineGetDevConfig to get lpDeviceConfig
+
+	if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+/*
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx, dwNeededSize = %lx, dwStringSize = %lx", 
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwStringSize
+		);
+  */
+
+   // If lpDeviceConfig->dwTotalSize is not larger enough, should realloc again
+   // with dwNeededSize
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+	   lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\t: lpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+
+   // from loDeviceConfig get lpDeviceConfigIn
+	lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	lpTapiLineTestInfo->lpDeviceConfigIn = 
+ 			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+   // Alloc space for lpDeviceConfigOut and set dwTotalSize
+	lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+   // Display some log info
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfigIn->dwSize = %lx", 
+		lpTapiLineTestInfo->dwSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfigOut->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize
+		);
+	
+   // prepare dismiss dialog
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   // Dismiss dialog
+	PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tDeviceConfigOut->dwTotalSize = %lx, neededsize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize);
+
+   // If dwTotalSize is not large enough, realloc with dwNeededSize
+	if(lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize <
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize )
+	{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = dwSize;
+
+      // prepare dismiss dialog
+	   PrepareToAutoDismissDlg(TRUE);
+		if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+      // Dismiss dialog
+	   PrepareToAutoDismissDlg(FALSE);
+
+	}
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTestHeap();
+
+    
+	 // Display test results info
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineConfigDialogEdit: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineConfigDialogEdit  <<<<<<<<"
+            );
+ 	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlds.c b/private/tapi/qa/trapper/itest/txline/itlds.c
new file mode 100644
index 000000000..334516366
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlds.c
@@ -0,0 +1,885 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlds.c
+
+Abstract:
+
+    This module contains the test functions for lineDevSpecific
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define NUMTOTALSIZES 5
+
+
+//  lineDevSpecific
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineDevSpecific(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+   BOOL fUnimdm;
+	TAPILINETESTDEVSPEC	TapiLineTestDevSpec;
+   LPVARSTRING lpDeviceID;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+   LPCALLBACKPARAMS    lpCallbackParams;
+    DWORD dwFixedSize = sizeof(TAPILINETESTDEVSPEC);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineDevSpecific  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   // Because test this api need call lineNegotiateExtVersion, unimdm doesn't
+   // support it, so all test cases for lineDevSpecific can't tested
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+                          sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+     lpDeviceID = (LPVARSTRING) AllocFromTestHeap(
+                          sizeof(VARSTRING));
+    lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineIntializeEx and Negotiate api version
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+
+    // Test invalid line handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+  	// Call lineNegotiateExtVersion
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+   lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+	lpTapiLineTestInfo->dwAddressID = 0;
+
+   lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+   // set bad hLine
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "   n = %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Test invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+     lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+     lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+     lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineIntializeEx and Negotiate api version, get devcaps
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // call lineNegotiateExtVersion 
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    // open line and make call to get hCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    // set bad hCall
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "   n = %ld", n);
+         *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Test invalid lpParams pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpParams pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+     lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+     lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+     lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+   // lineIntializeEx, Negotiate api version, get devcaps, open, makecall   
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set bad lpParams and nonzero dwSize
+    lpTapiLineTestInfo->dwSize = 128;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpParams = (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test invalid bad dwSize
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+     lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+     lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+     lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+   // lineIntializeEx, Negotiate api version, get devcaps, open, makecall   
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+   // Test different bad dwSize: 0, dwFixed-1, 7000000, 7fffffff, ffffffff
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->dwSize =
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = TAPISUCCESS;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwSize = %lx", dwTotalSizes[n]);
+        if (! DoLineDevSpecific(lpTapiLineTestInfo, lExpected, TRUE))
+          {
+            TLINE_FAIL();
+          }
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // do lineInitializeEx, get dwNumDevs
+
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+
+ 	 if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+    if(*lpTapiLineTestInfo->lpdwNumDevs > 1)
+    {
+    // If dwNumDevs > 1, can do this test 
+    // Test valid hCall another hLise, same device id
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: hCall another hLine, same device id", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+     lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+     lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+     lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open second line (hLine2) and make call (hCall2)
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+  
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Same line, different hCall
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+  
+    fTestPassed = ShowTestCase(fTestPassed);
+     
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+    else
+    {
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+
+   
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+
+ 	 if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+    if(*lpTapiLineTestInfo->lpdwNumDevs > 1)
+    {
+    // Test valid hCall another hLise, different device id
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: hCall another hLine, different device id", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+     lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+     lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+     lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwDeviceID       = 0;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // different dwDiviceID (1)
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwDeviceID       = 1;
+  
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LOPEN | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+  
+    fTestPassed = ShowTestCase(fTestPassed);
+     
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine2;
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    }
+    else 
+    {
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwDeviceID       = 0;
+
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+     lpTapiLineTestInfo->lpwszDeviceClass  = L"tapi/line";
+#else
+     lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+     lpTapiLineTestInfo->lpszDeviceClass  = "tapi/line";
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+   // lineIntializeEx, Negotiate api version, get devcaps, open, makecall   
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+   if (! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+  
+    fTestPassed = ShowTestCase(fTestPassed);
+     
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+    FreeTestHeap();
+
+    // use DevSpecific test dirrent request return with Success case 
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // It is only ESP supported
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    // set esp devspecificinfo structure 
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    // Call lineDevSpecific to set it
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+    lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+	 lpTapiLineTestInfo->dwAddressID = 0;
+    if ( ! DoLineDevSpecific(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    // use DevSpecific test dirrent request return with Error case 
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Only esp supported
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    // Set esp devspecificinfo structure with error
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+    lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+	 lpTapiLineTestInfo->dwAddressID = 0;
+    // Set fCompletionModeSet to TRUE, that in tcore will deal with this special
+    // case: return positiveID but with a error index at dwParam2
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineDevSpecific(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+	 // Check message here
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // restore fComepletionModeSet    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+	
+    // Display test result log info
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineDevSpecific: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineDevSpecific  <<<<<<<<"
+            );
+ 		
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itldsf.c b/private/tapi/qa/trapper/itest/txline/itldsf.c
new file mode 100644
index 000000000..03d55d3a8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itldsf.c
@@ -0,0 +1,618 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpds.c
+
+Abstract:
+
+    This module contains the test functions for lineDevSpecificFeature
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineDevSpecificFeature
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineDevSpecificFeature(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	TAPILINETESTDEVSPEC	TapiLineTestDevSpec;
+	BOOL fUnimdm;
+   LPCALLBACKPARAMS    lpCallbackParams;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineDevSpecificFeature  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = 0;
+   lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+   lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+   // Test lineDevSpecifcFeature should call lineNegotiateExtVersion, this api 
+   // is not unimdm supported
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	 {
+    fUnimdm = TRUE;
+    }
+   else
+    fUnimdm = FALSE;
+
+   if(fUnimdm)
+     {
+    	TapiLogDetail(
+		   DBUG_SHOW_DETAIL,
+		   "### Unimdm does not supported these apis");
+
+      // Shutdown and end the tests
+      if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+          TLINE_FAIL();
+        }
+      return fTestPassed;
+	  }
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+                          sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+
+    // Test invalid line handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+   lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+   lpTapiLineTestInfo->dwFeature = PHONEBUTTONFUNCTION_NONE;
+
+   lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+   // set bad hLine
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "   n = %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Test invalid lpParams pointers
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpParams pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // call lineInitialzeEx, NegotiateApiVersion, GetDevCaps, Open line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set bad lpParams and nonzero dwSize
+    lpTapiLineTestInfo->dwSize = 128;
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpParams = (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test invalid bad dwSize
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize = -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // call lineInitialzeEx, NegotiateApiVersion, GetDevCaps, Open line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set dwSise = -1
+    lpTapiLineTestInfo->dwSize = 0xffffffff;
+     
+    if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_INVALPOINTER, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+   // restore dwSize
+   lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test bad dwDeature
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwFeature = 0X7FFFFFFF", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // call lineInitialzeEx, NegotiateApiVersion, GetDevCaps, Open line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set dwFeature to bad value
+    lpTapiLineTestInfo->dwFeature = 0X7FFFFFFF;
+     
+    if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_INVALFEATURE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   
+ 
+    // Test bad dwDeature
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwFeature = NONE+1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // call lineInitialzeEx, NegotiateApiVersion, GetDevCaps, Open line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set dwFeature to lastone + 1
+    lpTapiLineTestInfo->dwFeature = (DWORD) (PHONEBUTTONFUNCTION_NONE + 1);
+     
+    if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_INVALFEATURE, TRUE))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    // Test bad dwDeature
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // call lineInitialzeEx, NegotiateApiVersion, GetDevCaps, Open line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // set dwFeature to be any valid value
+    lpTapiLineTestInfo->dwFeature = (DWORD) (PHONEBUTTONFUNCTION_NONE);
+     
+	 if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+  	     TLINE_FAIL();
+      }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+
+    // For ESP use devSpecific test different request return mode for Success
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    // ESP support only
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    // Call lineDevSpecific with design parameters
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    // call partical api to get EspResult back
+    lpTapiLineTestInfo->dwFeature = (DWORD) (PHONEBUTTONFUNCTION_NONE);
+    if ( ! DoLineDevSpecificFeature(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+ 
+    // use DevSpecifc to test different request return for Error
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // ESP support only
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALLINEHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    // set fCompletionModeSet to TRUE, tcore will take care with this test case:
+    // return positiveID but error index with dwParam2
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    lpTapiLineTestInfo->dwFeature = (DWORD) (PHONEBUTTONFUNCTION_NONE);
+    if ( ! DoLineDevSpecificFeature(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    // Wait message here
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    // restore fCompletionModeSet value    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+    // Display test result log info 
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineDevSpecificFeature: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineDevSpecificFeature  <<<<<<<<"
+            );
+  	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlgdcf.c b/private/tapi/qa/trapper/itest/txline/itlgdcf.c
new file mode 100644
index 000000000..857b641fe
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlgdcf.c
@@ -0,0 +1,631 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdcf.c
+
+Abstract:
+
+    This module contains the test functions for lineGetDevConfig
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineGetDevConfig
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetDevConfig(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+#ifdef WUNICODE
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetDevConfig  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    // call lineInitialzeEx, NegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+   // set bad dwDeviceID = dwNumDevs
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+
+	if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+           TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try bad device id (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+    // call lineInitialzeEx, NegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    // Set bad dwDeviceID = -1
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+           TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    // call lineInitialzeEx, NegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    // Set bad lpszDeviceClass
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDeviceClass = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDeviceClass = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpDeviceConfig->dwTotalSize = fixed -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+   // call lineInitialzeEx, NegotiateApiVersion
+   if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    // set dwTotalSize = dwFixed -1
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize -= 1;
+    if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpDeviceConfig->dwTotalSize = 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    // call lineInitialzeEx, NegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    // set dwTotalSize = 0
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = 0;
+    if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_STRUCTURETOOSMALL))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpDeviceConfig->dwTotalSize = -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    // call lineInitialzeEx, NegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    // set dwTotalSize = -1    
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = 0xffffffff;
+    if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpDeviceConfig pointer", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    // call lineInitialzeEx, NegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+   // Set invalid lpDeviceConfig and nonzero dwTotalSize    
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+   for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpDeviceConfig = 
+               (LPVARSTRING) gdwInvalidPointers[n];
+        if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTestHeap();
+
+   TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+ 
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    // lineInitializeEx, lineNegotiateAoiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+   // Alloc space and dwTotalSize
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+	if (! DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   // Display log info
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx, dwNeededSize = %lx, dwStringSize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwStringSize);
+
+   // If not enough size, realloc again
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+	   lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\tlpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+    fTestPassed = ShowTestCase(fTestPassed);
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // For sync apis, only one return mode
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+     lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Esp support only
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    // set esp devspecificinfo parameters and call lineDevSpecific
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+    // Set valid parameters call lineGetDevConfig, it should return lResult
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+   lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+    if ( ! DoLineGetDevConfig(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+     lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Esp support only
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    // set DevSpecificInfo value with expected error 
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_NODEVICE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+    // lineGetDevConfig should return lResult
+    if ( ! DoLineGetDevConfig(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    // Display test result log info	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetDevConfig Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetDevConfig  <<<<<<<<"
+            );
+   
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlgr.c b/private/tapi/qa/trapper/itest/txline/itlgr.c
new file mode 100644
index 000000000..b42f39af5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlgr.c
@@ -0,0 +1,868 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgr.c
+
+Abstract:
+
+    This module contains the test functions for lineGetRequest
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define   ALL_REQUESMODES     (LINEREQUESTMODE_MAKECALL | \
+    									 LINEREQUESTMODE_MEDIACALL)
+
+//  lineGetRequest
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetRequest(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+
+#ifdef WUNICODE
+   LINEREQMAKECALLW	*lpLineReqMakeCallW;
+   LINEREQMEDIACALLW  *lpLineReqMediaCallW;
+	LPWSTR lpwszDestAddress;
+	LPWSTR lpwsztapiAppName;
+	LPWSTR lpwszCallParty;
+	LPWSTR lpwszComment;
+#else
+   LINEREQMAKECALL	*lpLineReqMakeCall;
+   LINEREQMEDIACALL  *lpLineReqMediaCall;
+	LPSTR lpszDestAddress;
+	LPSTR lpsztapiAppName;
+	LPSTR lpszCallParty;
+	LPSTR lpszComment;
+#endif
+	
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetRequest  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+	 lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	 lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+
+    // Set invalid hLineApp
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Check invalid lpRequestBuffer
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid  lpRequestBuffer pointers", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+    // Set invalid lpRequestBuffer   
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpRequestBuffer =
+            (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineGetRequest(
+                           lpTapiLineTestInfo,
+                           LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+	 lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+		lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid bit flag combinations for dwRequestMode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+  
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGetRequest,
+            (LPDWORD) &lpTapiLineTestInfo->dwRequestMode,
+            LINEERR_INVALREQUESTMODE,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_REQUESMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/  
+   
+ 
+   TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Get MAKECALL no registered", dwTestCase + 1);
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"dialer.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "dialer.exe";
+#endif
+
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+        sizeof(LINEEXTENSIONID));
+
+   // Set "dialer.exe" priority = 0
+   lpTapiLineTestInfo->dwPriority = 0;
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = FALSE;
+
+   // call lineRegisterRequestRecipient with bEnable = FALSE
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+	
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) L"55555";
+	lpTapiLineTestInfo->lpwsztapiAppName = L"tline test";
+	lpTapiLineTestInfo->lpwszCalledParty = L"";
+	lpTapiLineTestInfo->lpwszComment = L"";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "";
+	lpTapiLineTestInfo->lpszComment = "";
+#endif
+
+   // tapiRequestMakeCall will return NOREQUESTRECIPIENT 
+	if(! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPIERR_NOREQUESTRECIPIENT))
+       {
+           TLINE_FAIL();
+       }
+	
+   // lineGetRequest should return NOTREGISTERED
+	if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOTREGISTERED))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // close line and shutdown to isolate test
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: Get MAKECALL, registered, Success", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+     lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateAPiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // call lineRegisterRequestRecipient with bEnable = TRUE, should Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+		
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) L"55555";
+	lpTapiLineTestInfo->lpwsztapiAppName = L"tline test";
+	lpTapiLineTestInfo->lpwszCalledParty = L"This is Called Party";
+	lpTapiLineTestInfo->lpwszComment = L"This is Comment";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "This is Called Party";
+	lpTapiLineTestInfo->lpszComment = "This is Comment";
+#endif
+
+   // tapiRequestMakeCall will Success
+	if(! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	 lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+   // lineGetRequest should Success
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case: Success: verify LINEREQMAKECALL lpRequestBuffer");
+
+   // with this Success, verify lpRequestBuffer
+   // Unicode use wcscmp compare for all fields in buffer with passing parmeters 
+#ifdef WUNICODE
+   lpLineReqMakeCallW = (LPLINEREQMAKECALLW) lpTapiLineTestInfo->lpRequestBuffer;
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszDestAddress", dwTestCase + 1);
+
+	if(wcscmp(lpLineReqMakeCallW->szDestAddress, 
+                lpTapiLineTestInfo->lpwszDestAddress)   == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwsztapiAppName", dwTestCase + 1);
+
+	if(wcscmp(lpLineReqMakeCallW->szAppName,
+                lpTapiLineTestInfo->lpwsztapiAppName)   == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszCalledParty", dwTestCase + 1);
+
+	if(wcscmp(lpLineReqMakeCallW->szCalledParty, 
+                lpTapiLineTestInfo->lpwszCalledParty)   == 0 ) 
+       fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszComment", dwTestCase + 1);
+
+	if(wcscmp(lpLineReqMakeCallW->szComment, 
+                lpTapiLineTestInfo->lpwszComment)   == 0 ) 
+       fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+#else
+   // verify ASCII
+   lpLineReqMakeCall = (LPLINEREQMAKECALL) lpTapiLineTestInfo->lpRequestBuffer;
+TapiLogDetail(
+   DBUG_SHOW_PASS,
+   "lpBuffer->szDestAddress = %s, szAppName = %s",
+   lpLineReqMakeCall->szDestAddress,
+   lpLineReqMakeCall->szAppName);
+TapiLogDetail(
+   DBUG_SHOW_PASS,
+   "lpBuffer->szCalledParty = %s, szComment = %s",
+   lpLineReqMakeCall->szCalledParty,
+   lpLineReqMakeCall->szComment);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszDestAddress", dwTestCase + 1);
+
+   if(strcmp(lpLineReqMakeCall->szDestAddress,
+               lpTapiLineTestInfo->lpszDestAddress)   == 0 ) 
+       fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpsztapiAppName", dwTestCase + 1);
+
+	if(strcmp(lpLineReqMakeCall->szAppName, 
+               lpTapiLineTestInfo->lpsztapiAppName)   == 0 ) 
+       fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszCalledParty", dwTestCase + 1);
+
+	if(strcmp(lpLineReqMakeCall->szCalledParty,
+               lpTapiLineTestInfo->lpszCalledParty)   == 0 ) 
+        fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszComment", dwTestCase + 1);
+
+	if(strcmp(lpLineReqMakeCall->szComment,
+            	lpTapiLineTestInfo->lpszComment)  == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+#endif
+
+    // close and shutdown to isolate test
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Get MAKECALL, registered, not avil request", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // Test dwRequestMode = MAKECALL 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+   // Didn't call tapiRequestMakeCall, then call lineGetRequest should return NOREQUEST
+	if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOREQUEST))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    //close  and shutdown to isolate test
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Get MEDIACALL no registered", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   // test MEDIACALL
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MEDIACALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = FALSE;
+
+   // make bEnable FALSE, lineRegisterRequestRecipient fail
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+		
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+   lpTapiLineTestInfo->dwSize = 0;
+   lpTapiLineTestInfo->dwSecure = 0;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = L"line/tapi";
+	lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) L"55555";
+	lpTapiLineTestInfo->lpwsztapiAppName = L"tline test";
+	lpTapiLineTestInfo->lpwszCalledParty = L"This is Called Party";
+	lpTapiLineTestInfo->lpwszComment = L"This is Comment";
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = "line/tapi";
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "This is Called Party";
+	lpTapiLineTestInfo->lpszComment = "This is Comment";
+#endif
+
+   // tapiRequestMediaCall with valid parameters Success
+	if(! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // because lineRegisterRequestRecipient fail, so it should return NOREGISTERED
+	if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOTREGISTERED))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // close and shutdown to isolate test
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	 FreeTestHeap();
+    
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: Get MEDIACALL, registered, Success", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test MEDIACALL 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MEDIACALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, to make lineRegisterRequestRecipient Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+		
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) L"55555";
+	lpTapiLineTestInfo->lpwsztapiAppName = L"tline test";
+	lpTapiLineTestInfo->lpwszCalledParty = L"This is a Called Party";
+	lpTapiLineTestInfo->lpwszComment = L"This is Comment";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "This is a Called Party";
+	lpTapiLineTestInfo->lpszComment = "This is Comment";
+#endif
+
+   // with valid parameters, tapiRequestMediaCall return Success
+	if(! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	 lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMEDIACALL)
+		);
+   
+   // lineGetRequest should return Success 
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case: Success: verify LINEREQMEDIACALL lpRequestBuffer");
+
+
+   //  verify unicode    
+#ifdef WUNICODE
+   lpLineReqMediaCallW = (LPLINEREQMEDIACALLW) lpTapiLineTestInfo->lpRequestBuffer;
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszDestAddress", dwTestCase + 1);
+	if(wcscmp(lpLineReqMediaCallW->szDestAddress, 
+                lpTapiLineTestInfo->lpwszDestAddress)  == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszAppName", dwTestCase + 1);
+	if(wcscmp(lpLineReqMediaCallW->szAppName,
+                lpTapiLineTestInfo->lpwsztapiAppName)  == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszCalledParty", dwTestCase + 1);
+	if(wcscmp(lpLineReqMediaCallW->szCalledParty, 
+                lpTapiLineTestInfo->lpwszCalledParty)   == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpwszComment", dwTestCase + 1);
+	if(wcscmp(lpLineReqMediaCallW->szComment, 
+                lpTapiLineTestInfo->lpwszComment)   == 0 ) 
+     fTestPassed = TRUE;
+   else
+     fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+#else
+   // verify ASCII
+   lpLineReqMediaCall = (LPLINEREQMEDIACALL) lpTapiLineTestInfo->lpRequestBuffer;
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszDestAddress", dwTestCase + 1);
+	if(strcmp(lpLineReqMediaCall->szDestAddress,
+               lpTapiLineTestInfo->lpszDestAddress)   == 0 )
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszAppName", dwTestCase + 1);
+	if(strcmp(lpLineReqMediaCall->szAppName, 
+               lpTapiLineTestInfo->lpsztapiAppName)   == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszCalledParty", dwTestCase + 1);
+	if(strcmp(lpLineReqMediaCall->szCalledParty,
+               lpTapiLineTestInfo->lpszCalledParty)   == 0 ) 
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+   fTestPassed = ShowTestCase(fTestPassed);
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: verify lpszComment", dwTestCase + 1);
+   if(strcmp(lpLineReqMediaCall->szComment,
+            	lpTapiLineTestInfo->lpszComment)  == 0 ) 
+      fTestPassed = TRUE;										  
+   else
+      fTestPassed = FALSE;
+    fTestPassed = ShowTestCase(fTestPassed);
+#endif
+
+    // close and shutdown to isolate test 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Get MEDIACALL, registered, not avil request", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MEDIACALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+   
+   // bEnable lineRegisterRequestRecipient
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   // with no tapiRequestMediaCall, lineGetRequest fail return NOREQUEST
+	if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOREQUEST))
+       {
+           TLINE_FAIL();
+       }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // close and shutdown to isolate test
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    FreeTestHeap();
+
+    // display test result log info
+    TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetRequest: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetRequest  <<<<<<<<"
+            );
+      return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlrrr.c b/private/tapi/qa/trapper/itest/txline/itlrrr.c
new file mode 100644
index 000000000..b6a3ff540
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlrrr.c
@@ -0,0 +1,633 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrrr.c
+
+Abstract:
+
+    This module contains the test functions for lineRegisterRequestRecipient
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define   ALL_REQUESMODES     (LINEREQUESTMODE_MAKECALL | \
+    									 LINEREQUESTMODE_MEDIACALL)
+
+
+
+//  lineRegisterRequestRecipient
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRegisterRequestRecipient(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	LINEREQMAKECALL	LineReqMakeCall;
+#ifdef WUNICODE
+	LPWSTR lpwszDestAddress;
+	LPWSTR lpwsztapiAppName;
+	LPWSTR lpwszCallParty;
+	LPWSTR lpwszComment;
+#else
+	LPSTR lpszDestAddress;
+	LPSTR lpsztapiAppName;
+	LPSTR lpszCallParty;
+	LPSTR lpszComment;
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineRegisterRequestRecipient  <<<<<<<<"
+            );
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+	 lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	 lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+
+    // set bad hLineApp
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Test invalid bit flag combinations for dwRequestMode
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid bit flag combinations for dwRequestMode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     // test dwRequestMode all invalid bit set  
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineRegisterRequestRecipient,
+            (LPDWORD) &lpTapiLineTestInfo->dwRequestMode,
+            LINEERR_INVALREQUESTMODE,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_REQUESMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld Success: MAKECALL", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test MAKECALL 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE call lineRegisterRequestRecipient will Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) L"55555";
+	lpTapiLineTestInfo->lpwsztapiAppName = L"tline test";
+	lpTapiLineTestInfo->lpwszCalledParty = L"";
+	lpTapiLineTestInfo->lpwszComment = L"";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "";
+	lpTapiLineTestInfo->lpszComment = "";
+#endif
+
+   // call tapiRequestMakeCall with valid parameters, will Success
+	if(! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // lineGetRequest should Success
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+ 	 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: re-register fail: same request mode", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   // test MAKECALL RequestMode
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, lineRegisterRequestRecipient will Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	 
+   //re-register with same parameters, should fail
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: re-register fail: both request mode", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test both MAKECALL, MEDIACALL mode 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL |
+                                       LINEREQUESTMODE_MEDIACALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, lineRegisterRequestRecipient will Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // re-register with same mode and parameters should fail
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: re-register fail: same request mode, diff inst", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   // test MAKECALL mode 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, lineRegisterRequestRecipient will Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	 
+   // chanage dwRegistrationInstance and re-register should fail
+	lpTapiLineTestInfo->dwRegistrationInstance = 1234;
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: re-register fail: both request mode, diff inst", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   // test both mode
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL |
+                                       LINEREQUESTMODE_MEDIACALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // with bEnable TURE will success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // change Instance but keep same mode, re-register should fail 
+	lpTapiLineTestInfo->dwRegistrationInstance = 1234;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: verify dwRegistrationInstance ignor for de-regi", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitialzeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // call lineRegisterRequestRecipient with dwRegistrationInstance 1
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 1;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, register Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // change dwRegistrationInstance to 2 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 2;
+	lpTapiLineTestInfo->bEnable = FALSE;
+
+   // de-register (Enable FLASE), lineRegisterRequestRecipient Should Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // And lineGetRequest should fail
+	if(! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOTREGISTERED))
+       {
+           TLINE_FAIL();
+       }
+	fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: verify unregister fails when no registered", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, make register Success
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // bEnabel FALSE, make un-register (no-register) Success
+	lpTapiLineTestInfo->bEnable = FALSE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // unregister with a no-register should fail
+ 	lpTapiLineTestInfo->bEnable = FALSE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_OPERATIONFAILED))
+       {
+           TLINE_FAIL();
+       }
+	
+     fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: verify loop register/de-regester clear up ok", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	 lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps, lineOpen
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+
+   // loop register, and de-register
+   for(n = 1; n < 10; n++)
+   {
+   TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "n = %ld", n);
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+   // bEnable TRUE, make register
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+   // bEnable FALSE make de-register
+	lpTapiLineTestInfo->bEnable = FALSE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+   }
+	
+     fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    FreeTestHeap();
+
+	 // display test result log info
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineRegisterRequestRecipient: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineRegisterRequestRecipient  <<<<<<<<"
+            );
+      return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlscp.c b/private/tapi/qa/trapper/itest/txline/itlscp.c
new file mode 100644
index 000000000..b7995f9db
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlscp.c
@@ -0,0 +1,727 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscp.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallParams
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+#define MIN_RATE 	10
+#define MAX_RATE	1000
+
+#define ALL_BEARERMODES      (LINEBEARERMODE_VOICE             | \
+									   LINEBEARERMODE_SPEECH            | \
+									   LINEBEARERMODE_MULTIUSE          | \
+									   LINEBEARERMODE_DATA              | \
+									   LINEBEARERMODE_ALTSPEECHDATA     | \
+									   LINEBEARERMODE_NONCALLSIGNALING  | \
+									   LINEBEARERMODE_PASSTHROUGH)
+
+
+//  lineSetCallParams
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallParams(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+   DWORD dwAllBeareMode;
+   LPCALLBACKPARAMS    lpCallbackParams;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetCallParams  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	lpTapiLineTestInfo->lpDialParams = (LPLINEDIALPARAMS) NULL;
+   lpTapiLineTestInfo->dwMinRate = MIN_RATE;
+   lpTapiLineTestInfo->dwMaxRate = MAX_RATE;
+	lpTapiLineTestInfo->dwBearerMode = LINEBEARERMODE_DATA;
+   lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+   lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+     
+    // Test invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, linenegotiateApiVersion, lineGetDevCaps, lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+
+    // set bad hCall
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetCallParams(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+
+    // Test invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // open line with MONITOR
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   // call lineDrop to disconnect call
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+
+   // change call priviledge to MONITOR
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   // lineSetCallParams should return NOTOWNER   
+   if (! DoLineSetCallParams(lpTapiLineTestInfo, LINEERR_NOTOWNER, TRUE))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest fow dwBearerMode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps, 
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	  // set dwAllBeareMode with apiversion
+     if(lpTapiLineTestInfo->dwAPIVersion >= 0x00020000)
+       {
+       dwAllBeareMode =  ALL_BEARERMODES | LINEBEARERMODE_RESTRICTEDDATA;
+       }
+     else
+       {
+       dwAllBeareMode =  ALL_BEARERMODES;
+       }
+ 
+     // test dwBearerMode all invalid bit set
+     if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetCallParams,
+            (LPDWORD) &lpTapiLineTestInfo->dwBearerMode,
+            LINEERR_INVALBEARERMODE,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_16,
+            dwAllBeareMode,
+            ~dwBitVectorMasks[(int) FIELDSIZE_16],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest fow dwBearerMode & ext", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitialzieEx, lineNegotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+      if(lpTapiLineTestInfo->dwAPIVersion >= 0x00020000)
+       {
+       dwAllBeareMode =  ALL_BEARERMODES | LINEBEARERMODE_RESTRICTEDDATA;
+       }
+     else
+       {
+       dwAllBeareMode =  ALL_BEARERMODES;
+       }
+ 
+     // Esp supported only
+     // test dwBearerMode all valid bit set
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetCallParams,
+            (LPDWORD) &lpTapiLineTestInfo->dwBearerMode,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_16,
+            dwAllBeareMode,
+            ~dwBitVectorMasks[(int) FIELDSIZE_16],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps
+    // lineOpen, lineMakeCall 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+   // call lineGetCallInfo before call lineSetCallParams
+   lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwBearerMode = %lx, dwRate = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwBearerMode,
+		lpTapiLineTestInfo->lpCallInfo->dwRate);
+
+	
+   // call lineSetCallParams for some values
+	lpTapiLineTestInfo->dwBearerMode = LINEBEARERMODE_DATA;
+   lpTapiLineTestInfo->dwMinRate = MIN_RATE;
+   lpTapiLineTestInfo->dwMaxRate = MAX_RATE;
+	lpTapiLineTestInfo->lpDialParams = (LPLINEDIALPARAMS) NULL;
+	
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetCallParams(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+	if(lpTapiLineTestInfo->lpCallInfo->dwTotalSize <
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize)
+	{
+	dwSize = lpTapiLineTestInfo->lpCallInfo->dwNeededSize;
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		dwSize);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = dwSize;
+	}
+
+   // after call lineGetCallInfo again
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   // Display some log info
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwBearerMode = %lx, dwCallInfo->dwBearerMode = %lx",
+		lpTapiLineTestInfo->dwBearerMode,
+		lpTapiLineTestInfo->lpCallInfo->dwBearerMode);
+
+   // verify dwBearerMode get set
+   if(lpTapiLineTestInfo->lpCallInfo->dwBearerMode == lpTapiLineTestInfo->dwBearerMode)
+      fTestPassed = TRUE;
+   else
+      fTestPassed = FALSE;
+	 }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // use DevSpecific test different request return mode for Success and Error
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwBearerMode = LINEBEARERMODE_DATA;
+    lpTapiLineTestInfo->dwMinRate = MIN_RATE;
+    lpTapiLineTestInfo->dwMaxRate = MAX_RATE;
+	 lpTapiLineTestInfo->lpDialParams = (LPLINEDIALPARAMS) NULL;
+	 if ( ! DoLineSetCallParams(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+
+
+    info.u.EspResult.lResult = LINEERR_INVALRATE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwBearerMode = LINEBEARERMODE_DATA;
+    lpTapiLineTestInfo->dwMinRate = MIN_RATE;
+    lpTapiLineTestInfo->dwMaxRate = MAX_RATE;
+	 lpTapiLineTestInfo->lpDialParams = (LPLINEDIALPARAMS) NULL;
+
+	 lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetCallParams(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+	 // Display test result log info
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetCallParams: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetCallParams  <<<<<<<<"
+            );
+   
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlsdcf.c b/private/tapi/qa/trapper/itest/txline/itlsdcf.c
new file mode 100644
index 000000000..9bc1a1dea
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlsdcf.c
@@ -0,0 +1,649 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsdcf.c
+
+Abstract:
+
+    This module contains the test functions for lineSetDevConfig
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineSetDevConfig
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetDevConfig(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+#ifdef WUNICODE
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetDevConfig  <<<<<<<<"
+            );
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+
+   // test bad dwDeviceID = dwNumDevs
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+           TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Try bad device id (-1)
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+
+    // lineInitializeEx, lineNegotiateApiVersion 
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+
+    // set bad dwDeviceID = -1
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+           TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // set bad lpDeviceClass
+     for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszDeviceClass = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszDeviceClass = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpDeviceConfig pointer", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // set bad lpDeviceConfig pointer with nozero dwSize    
+   lpTapiLineTestInfo->dwSize = 128;
+   for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpDeviceConfig = 
+               (LPVOID) gdwInvalidPointers[n];
+        if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: dwSize = 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test dwSize = 0
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+   lpTapiLineTestInfo->dwSize = 0;
+
+   // Esp return Success, Unimdm return Invalpointer
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+    }
+    else
+   {
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+       {
+           TLINE_FAIL();
+       }
+    }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwSize = -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // bad dwSize = -1 	 
+   lpTapiLineTestInfo->dwSize = 0xffffffff;
+
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+       {
+           TLINE_FAIL();
+       }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNegotiateApiVersion
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 	 
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+   // call lineGetDevConfig first
+  	if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+   // if dwTotalSize is not big enough, realloc again with dwNeededSize
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\tlpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+	  
+
+	lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	lpTapiLineTestInfo->lpDeviceConfig = 
+			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx",
+		lpTapiLineTestInfo->dwSize);
+
+   // with all returned value, call lineSetDevConfig, should Success
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    // use DevSpecific test RETURNRESULTS completion mode for a synch api
+    // and ESP only
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+	 lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+	  	sizeof(VARSTRING)
+		);
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+  	 if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	 lpTapiLineTestInfo->lpDeviceConfig = 
+			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+
+    if ( ! DoLineSetDevConfig(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+   lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+	 lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+	  	sizeof(VARSTRING)
+		);
+	 lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+  	 if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_NODRIVER;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	 lpTapiLineTestInfo->lpDeviceConfig = 
+			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+
+    if ( ! DoLineSetDevConfig(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    // Display test result log info
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetDevConfig: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetDevConfig  <<<<<<<<"
+            );
+   
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlsmc.c b/private/tapi/qa/trapper/itest/txline/itlsmc.c
new file mode 100644
index 000000000..937f1832a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlsmc.c
@@ -0,0 +1,1543 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsmc.c
+
+Abstract:
+
+    This module contains the test functions for lineSetMediaControl
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+#define ALL_DWSELECTS    (LINECALLSELECT_LINE | \
+                          LINECALLSELECT_ADDRESS | \
+                          LINECALLSELECT_CALL)
+
+#define NUMENTRIES		3
+#define PAGESIZE			16384
+
+//  lineSetMediaControl
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetMediaControl(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   DWORD dwNumEntries[NUMENTRIES] = {
+							 1,
+//    						 10000,
+//							 100000,
+							 0x06ffffff,
+							 0x0effffff
+							 };
+   DWORD dwNumBytes;
+   DWORD lExpected;
+   DWORD dwDigitSize = sizeof(LINEMEDIACONTROLDIGIT);
+   DWORD dwMediaSize = sizeof(LINEMEDIACONTROLMEDIA);
+   DWORD dwToneSize = sizeof(LINEMEDIACONTROLTONE);
+   DWORD dwCallStateSize = sizeof(LINEMEDIACONTROLCALLSTATE);
+   LONG lRet;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetMediaControl  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+     lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+	
+    lpTapiLineTestInfo->dwTerminalModes  = LINETERMMODE_BUTTONS;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+
+    // set bad hLine 
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "   n = %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+  
+    // set bad hCall
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Test invalid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid bit flag combinations for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // Esp and unimdm will return different error
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = LINEERR_INVALCALLSELECT;
+    else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+
+    // test dwSelect all invalid bit set
+    if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetMediaControl,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            lExpected,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test valid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid bit flag combinations for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    // test dwSelect all valid bit set
+    if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetMediaControl,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Test invalid lpDigitList
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpDigitList", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNegotiateApiVersion, lineGetDevCaps
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // set bad lpMCDigitList with nonzero dwDigitNumEntries
+    lpTapiLineTestInfo->dwDigitNumEntries = 1;
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+        lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) gdwInvalidPointers[n];
+        if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwDigitNumEntries, fixed alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    lpTapiLineTestInfo->dwDigitNumEntries = 1;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwDigitNumEntries = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwDigitSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwDigitNumEntries = %lx, dwDigitSize = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwDigitSize, dwNumBytes);
+    lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) ITAlloc(
+        dwDigitSize);
+    if(dwNumBytes < PAGESIZE)
+    {
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+    }
+    else
+       lExpected = LINEERR_INVALPOINTER;
+
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCDigitList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDigitNumEntries = 0;
+    lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwDigitNumEntries", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwDigitNumEntries = dwNumEntries[n];
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwDigitNumEntries = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+    lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) ITAlloc(
+        lpTapiLineTestInfo->dwDigitNumEntries * sizeof(LINEMEDIACONTROLDIGIT));
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+	 {
+    if(lpTapiLineTestInfo->lpMCDigitList)
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_INVALPOINTER;
+    }
+    else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+   
+    if(lpTapiLineTestInfo->lpMCDigitList)
+       ITFree(lpTapiLineTestInfo->lpMCDigitList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDigitNumEntries = 0;
+    lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    // Test invalid lpMediaList
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpMediaList", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaNumEntries = 1;
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+        lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) gdwInvalidPointers[n];
+        if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwMediaNumEntries, fixed alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwMediaNumEntries = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwMediaSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwMediaNumEntries = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+    lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) ITAlloc(
+        dwMediaSize);
+    if(dwNumBytes < PAGESIZE)
+    {
+ 	 if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+    }
+    else
+       lExpected = LINEERR_INVALPOINTER;
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCMediaList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwMediaNumEntries = 0;
+    lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwMediaNumEntries", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwMediaNumEntries = dwNumEntries[n];
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwMediaNumEntries = %lx", dwNumEntries[n]);
+    lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) ITAlloc(
+        lpTapiLineTestInfo->dwMediaNumEntries * sizeof(LINEMEDIACONTROLMEDIA));
+
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCMediaList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwMediaNumEntries = 0;
+    lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+*/
+     // Test invalid lpToneList
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpToneList", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwToneNumEntries = 1;
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+        lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) gdwInvalidPointers[n];
+        if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwToneNumEntries, fixed alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwToneNumEntries = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwToneSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwToneNumEntries = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+    lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) ITAlloc(
+        dwToneSize);
+    if(dwNumBytes < PAGESIZE)
+    {
+	 if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+    }
+    else
+       lExpected = LINEERR_INVALPOINTER;
+
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCToneList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwToneNumEntries = 0;
+    lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwToneNumEntries", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwToneNumEntries = dwNumEntries[n];
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwToneNumEntries = %lx", dwNumEntries[n]);
+    lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) ITAlloc(
+        lpTapiLineTestInfo->dwToneNumEntries * sizeof(LINEMEDIACONTROLTONE));
+
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCToneList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwToneNumEntries = 0;
+    lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+*/
+
+    // Test invalid lpCallStateList
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCallStateList", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwCallStateNumEntries = 1;
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+        lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) gdwInvalidPointers[n];
+        if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCallStateNumEntries, fixed alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwCallStateNumEntries = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwCallStateSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwCallStateNumEntries = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+      
+    lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) ITAlloc(
+        dwCallStateSize);
+    if(dwNumBytes < PAGESIZE)
+      {
+	    if(IsESPLineDevice(lpTapiLineTestInfo))
+          lExpected = TAPISUCCESS;
+       else
+          lExpected = LINEERR_OPERATIONUNAVAIL;
+		}
+    else
+      lExpected = LINEERR_INVALPOINTER;
+
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCCallStateList);
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->dwCallStateNumEntries = 0;
+    lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+/*   
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCallStateNumEntries", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwCallStateNumEntries = dwNumEntries[n];
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwCallStateNumEntries = %lx", dwNumEntries[n]);
+    lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) ITAlloc(
+        lpTapiLineTestInfo->dwCallStateNumEntries * sizeof(LINEMEDIACONTROLCALLSTATE));
+
+    if (! DoLineSetMediaControl(lpTapiLineTestInfo, TAPISUCCESS))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpMCCallStateList);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwCallStateNumEntries = 0;
+    lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+*/   
+ 
+    // Test Success
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success with all valid lpXXXXList", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams =(LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+	lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+	lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) AllocFromTestHeap(
+		sizeof (LINEMEDIACONTROLDIGIT));
+	lpTapiLineTestInfo->lpMCDigitList->dwDigit = 0;
+	lpTapiLineTestInfo->lpMCDigitList->dwDigitModes = LINEDIGITMODE_PULSE;
+	lpTapiLineTestInfo->lpMCDigitList->dwMediaControl = LINEMEDIACONTROL_RATEUP;
+	lpTapiLineTestInfo->dwDigitNumEntries = 1;
+	lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLMEDIA));
+	lpTapiLineTestInfo->lpMCMediaList->dwMediaModes = LINEMEDIAMODE_UNKNOWN;
+	lpTapiLineTestInfo->lpMCMediaList->dwDuration = 10;
+	lpTapiLineTestInfo->lpMCMediaList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	lpTapiLineTestInfo->dwMediaNumEntries = 1;
+	lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLTONE));
+	lpTapiLineTestInfo->dwToneNumEntries = 1;
+	lpTapiLineTestInfo->lpMCToneList->dwAppSpecific = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwDuration = 10;
+	lpTapiLineTestInfo->lpMCToneList->dwFrequency1 = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwFrequency2 = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwFrequency3 = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLCALLSTATE));
+	lpTapiLineTestInfo->dwCallStateNumEntries = 1;
+	lpTapiLineTestInfo->lpMCCallStateList->dwCallStates = LINECALLSTATE_IDLE;
+	lpTapiLineTestInfo->lpMCCallStateList->dwMediaControl = LINEMEDIACONTROL_NONE;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetMediaControl(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    // Test Success
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success with all NULL lpXXXXList", dwTestCase + 1
+            );
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams =(LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+	lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+	lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) NULL;
+	lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) NULL;
+	lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) NULL;
+	lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) NULL;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetMediaControl(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+	 lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+	 lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) AllocFromTestHeap(
+		sizeof (LINEMEDIACONTROLDIGIT));
+	 lpTapiLineTestInfo->lpMCDigitList->dwDigit = 0;
+	 lpTapiLineTestInfo->lpMCDigitList->dwDigitModes = LINEDIGITMODE_PULSE;
+	 lpTapiLineTestInfo->lpMCDigitList->dwMediaControl = LINEMEDIACONTROL_RATEUP;
+	 lpTapiLineTestInfo->dwDigitNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLMEDIA));
+	 lpTapiLineTestInfo->lpMCMediaList->dwMediaModes = LINEMEDIAMODE_UNKNOWN;
+	 lpTapiLineTestInfo->lpMCMediaList->dwDuration = 10;
+	 lpTapiLineTestInfo->lpMCMediaList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	 lpTapiLineTestInfo->dwMediaNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLTONE));
+	 lpTapiLineTestInfo->dwToneNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCToneList->dwAppSpecific = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwDuration = 10;
+	 lpTapiLineTestInfo->lpMCToneList->dwFrequency1 = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwFrequency2 = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwFrequency3 = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	 lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLCALLSTATE));
+	 lpTapiLineTestInfo->dwCallStateNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCCallStateList->dwCallStates = LINECALLSTATE_IDLE;
+	 lpTapiLineTestInfo->lpMCCallStateList->dwMediaControl = LINEMEDIACONTROL_NONE;
+
+    if ( ! DoLineSetMediaControl(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALADDRESSID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+	 lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+	 lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) AllocFromTestHeap(
+		sizeof (LINEMEDIACONTROLDIGIT));
+	 lpTapiLineTestInfo->lpMCDigitList->dwDigit = 0;
+	 lpTapiLineTestInfo->lpMCDigitList->dwDigitModes = LINEDIGITMODE_PULSE;
+	 lpTapiLineTestInfo->lpMCDigitList->dwMediaControl = LINEMEDIACONTROL_RATEUP;
+	 lpTapiLineTestInfo->dwDigitNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLMEDIA));
+	 lpTapiLineTestInfo->lpMCMediaList->dwMediaModes = LINEMEDIAMODE_UNKNOWN;
+	 lpTapiLineTestInfo->lpMCMediaList->dwDuration = 10;
+	 lpTapiLineTestInfo->lpMCMediaList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	 lpTapiLineTestInfo->dwMediaNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLTONE));
+	 lpTapiLineTestInfo->dwToneNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCToneList->dwAppSpecific = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwDuration = 10;
+	 lpTapiLineTestInfo->lpMCToneList->dwFrequency1 = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwFrequency2 = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwFrequency3 = 0;
+	 lpTapiLineTestInfo->lpMCToneList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	 lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLCALLSTATE));
+	 lpTapiLineTestInfo->dwCallStateNumEntries = 1;
+	 lpTapiLineTestInfo->lpMCCallStateList->dwCallStates = LINECALLSTATE_IDLE;
+	 lpTapiLineTestInfo->lpMCCallStateList->dwMediaControl = LINEMEDIACONTROL_NONE;
+
+    if ( ! DoLineSetMediaControl(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetMediaControl: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetMediaControl  <<<<<<<<"
+            );
+   
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlsmm.c b/private/tapi/qa/trapper/itest/txline/itlsmm.c
new file mode 100644
index 000000000..d67630c74
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlsmm.c
@@ -0,0 +1,766 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsmm.c
+
+Abstract:
+
+    This module contains the test functions for lineSetMediaMode
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+#define ALL_MEDIAMODE		  (LINEMEDIAMODE_INTERACTIVEVOICE   | \
+										LINEMEDIAMODE_AUTOMATEDVOICE     | \
+										LINEMEDIAMODE_DATAMODEM          | \
+										LINEMEDIAMODE_G3FAX              | \
+										LINEMEDIAMODE_TDD                | \
+										LINEMEDIAMODE_G4FAX              | \
+										LINEMEDIAMODE_DIGITALDATA        | \
+										LINEMEDIAMODE_TELETEX            | \
+										LINEMEDIAMODE_VIDEOTEX           | \
+										LINEMEDIAMODE_TELEX              | \
+										LINEMEDIAMODE_MIXED              | \
+										LINEMEDIAMODE_ADSI               | \
+										LINEMEDIAMODE_VOICEVIEW)
+
+//  lineSetMediaMode
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetMediaMode(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+   DWORD dwAllMediaModes;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetMediaMode  <<<<<<<<"
+            );
+ 
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+   lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+   lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+ 
+    // Test invalid call handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+
+    // set bad hCall
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetMediaMode(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest fow dwMediaMode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+     dwAllMediaModes = ALL_MEDIAMODE | LINEMEDIAMODE_UNKNOWN;
+
+     // test dwMediaMode all invalid bit set
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetMediaMode,
+            (LPDWORD) &lpTapiLineTestInfo->dwMediaMode,
+            LINEERR_INVALMEDIAMODE,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_24,
+            dwAllMediaModes,
+            ~dwBitVectorMasks[(int) FIELDSIZE_24],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest for dwMediaMode, no known", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     // test dwMediaMode all valid bit set no KNOWN
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+        dwAllMediaModes = ALL_MEDIAMODE;
+     if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetMediaMode,
+            (LPDWORD) &lpTapiLineTestInfo->dwMediaMode,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            dwAllMediaModes,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+      {
+        TLINE_FAIL();
+      }
+     }
+     else
+     {
+      dwAllMediaModes = LINEMEDIAMODE_INTERACTIVEVOICE ;
+	   if (! DoLineSetMediaMode(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+      dwAllMediaModes = LINEMEDIAMODE_DATAMODEM;
+	   if (! DoLineSetMediaMode(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest for dwMediaMode, with known", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     // test dwMediaMode valid bit set with UNKNOWN
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     dwAllMediaModes = ALL_MEDIAMODE | LINEMEDIAMODE_UNKNOWN;
+
+     if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetMediaMode,
+            (LPDWORD) &lpTapiLineTestInfo->dwMediaMode,
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            dwAllMediaModes,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: With a 1.3 app & VOICEVIEW media", dwTestCase + 1
+            );
+
+  
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    // lineNogotiateApiVersion with a 1.3 version
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+   // dwMediaMode = VOICEVIEW
+	lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_VOICEVIEW;
+				
+   // lineSetMediaMode should fail
+	if (! DoLineSetMediaMode(lpTapiLineTestInfo, LINEERR_INVALMEDIAMODE))
+       {
+           TLINE_FAIL();
+       }
+
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+  
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+   // call lineGetCallInfo before call lineSetMediaMode	
+   if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"lpCallInfo->dwMedialMode = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwMediaMode);
+ 
+	lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+   // call lineSetMediaMode with some value				
+	if (! DoLineSetMediaMode(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+	
+   // call lineGetCallInfo again after
+   if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tAfter: lpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwMedialMode = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwMediaMode);
+
+   // verify dwMediaMode did get set
+   if(lpTapiLineTestInfo->dwMediaModes = 
+      lpTapiLineTestInfo->lpCallInfo->dwMediaMode)
+      fTestPassed = TRUE;
+    else
+      fTestPassed = FALSE;
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    // Use DevSpecific espinfo test RETURNRESULT completion mode for a Synch api
+    // for Success and force a error
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    if ( ! DoLineSetMediaMode(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLHANDLE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    if ( ! DoLineSetMediaMode(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+  
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetMediaMode: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetMediaMode  <<<<<<<<"
+            );
+  	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlst.c b/private/tapi/qa/trapper/itest/txline/itlst.c
new file mode 100644
index 000000000..1a6fe9a72
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlst.c
@@ -0,0 +1,870 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlst.c
+
+Abstract:
+
+    This module contains the test functions for lineSetTerminal
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define ALL_DWSELECTS    (LINECALLSELECT_LINE | \
+                          LINECALLSELECT_ADDRESS | \
+                          LINECALLSELECT_CALL)
+
+#define ALL_DWTERMMODES  (LINETERMMODE_BUTTONS         | \
+								  LINETERMMODE_LAMPS           | \
+								  LINETERMMODE_DISPLAY         | \
+								  LINETERMMODE_RINGER          | \
+								  LINETERMMODE_HOOKSWITCH      | \
+								  LINETERMMODE_MEDIATOLINE     | \
+								  LINETERMMODE_MEDIAFROMLINE   | \
+								  LINETERMMODE_MEDIABIDIRECT)
+
+
+
+//  lineSetTerminal
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetTerminal(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+   DWORD dwTerminalMode;
+   LPCALLBACKPARAMS    lpCallbackParams;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetTerminal  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+     lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hLine values", dwTestCase + 1
+            );
+
+	
+    lpTapiLineTestInfo->dwTerminalModes  = LINETERMMODE_BUTTONS;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hLine_Orig = *(lpTapiLineTestInfo->lphLine);
+
+	 // set bad hLine
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+    TapiLogDetail(
+       DBUG_SHOW_DETAIL,
+       "   n = %ld", n);
+        *(lpTapiLineTestInfo->lphLine) = (HLINE) gdwInvalidHandles[n];
+        if (! DoLineSetTerminal(lpTapiLineTestInfo, LINEERR_INVALLINEHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLine) = lpTapiLineTestInfo->hLine_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+
+    // set bad hCall
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineSetTerminal(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE, TRUE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    // Test invalid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid bit flag combinations for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+//    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test dwSelect all invalid bit set
+   // Esp and unimdm return differet error
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetTerminal,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            LINEERR_INVALCALLSELECT,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+   else
+    {
+    if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetTerminal,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+            LINEERR_OPERATIONUNAVAIL,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test valid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid bit flag combinations for dwSelect", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+//    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test dwSelect all valid bit set
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+    if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetTerminal,
+            (LPDWORD) &lpTapiLineTestInfo->dwSelect,
+/* XYD, NA and MUTEX should exchange the position
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+*/
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    // Test invalid bit flag combinations for dwTerminalMode
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid bit flag combinations for dwTerminalMode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+//    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test dwTerminalModes all invalid bit set
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+    if(! TestInvalidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetTerminal,
+            (LPDWORD) &lpTapiLineTestInfo->dwTerminalModes,
+            LINEERR_INVALTERMINALMODE,
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DWTERMMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // Test valid bit flag combinations for dwSelect
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: valid bit flag combinations for dwTerminalModes", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+//    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   // test dwTerminalModes all valid bit set
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+    if(! TestValidBitFlagsAsy(
+            lpTapiLineTestInfo,
+            DoLineSetTerminal,
+            (LPDWORD) &lpTapiLineTestInfo->dwTerminalModes,
+/* XYD, NA and MUTEX should exchange the position
+            FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+*/
+            FIELDTYPE_MUTEX,
+            FIELDTYPE_NA,
+            FIELDSIZE_32,
+            ALL_DWSELECTS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+
+    // Test Success
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+//    lpTapiLineTestInfo->lpDeviceID       = lpDeviceID;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_ADDRESS;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    // lineOpen, lineMakeCall
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;	
+	lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+	lpTapiLineTestInfo->dwTerminalID = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+ 
+
+   // test Succes with some valid parameters
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetTerminal(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetTerminal(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+ 	}
+
+ 
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+   // call lineGetCallInfo to get value 
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+	
+	if(lpTapiLineTestInfo->lpCallInfo->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize)
+	{
+	dwSize = lpTapiLineTestInfo->lpCallInfo->dwNeededSize;
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		dwSize);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = dwSize;
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+   // Display info
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTerminalModesSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTerminalModesSize,
+		lpTapiLineTestInfo->lpCallInfo->dwTerminalModesOffset);
+
+   dwTerminalMode = *((LPBYTE)lpTapiLineTestInfo->lpCallInfo+
+         lpTapiLineTestInfo->lpCallInfo->dwTerminalModesOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwTerminalModes = %lx",
+      dwTerminalMode);
+	
+    fTestPassed = ShowTestCase(fTestPassed);
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    for(n = ESP_RESULT_CALLCOMPLPROCSYNC; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+	 lpTapiLineTestInfo->dwTerminalID = 0;
+	 lpTapiLineTestInfo->bEnable = TRUE;
+    if ( ! DoLineSetTerminal(lpTapiLineTestInfo, info.u.EspResult.lResult, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+    for(n = ESP_RESULT_RETURNRESULT; n <= ESP_RESULT_CALLCOMPLPROCASYNC; n++)
+    {
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+    lpCallbackParams                        = GetCallbackParams();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALTERMINALID;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+	 lpTapiLineTestInfo->dwTerminalID = 0;
+	 lpTapiLineTestInfo->bEnable = TRUE;
+    lpTapiLineTestInfo->fCompletionModeSet = TRUE;
+    if ( ! DoLineSetTerminal(lpTapiLineTestInfo, info.u.EspResult.lResult, FALSE))
+      {
+          TLINE_FAIL();
+      }
+
+    AddMessage(
+         LINE_REPLY,
+         (DWORD) lpTapiLineTestInfo->hCall1,
+         (DWORD) lpCallbackParams,
+         0x00000000,
+         info.u.EspResult.lResult,
+         0x00000000,
+         TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+         );
+
+    if( !WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+
+    
+    lpTapiLineTestInfo->fCompletionModeSet = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+    }
+
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetTerminal: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetTerminal  <<<<<<<<"
+            );
+   
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/itlstl.c b/private/tapi/qa/trapper/itest/txline/itlstl.c
new file mode 100644
index 000000000..52366982f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/itlstl.c
@@ -0,0 +1,627 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlstl.c
+
+Abstract:
+
+    This module contains the test functions for lineSetTollList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+#define ALL_TOLLLISTOPTION     (LINETOLLLISTOPTION_ADD | \
+										  LINETOLLLISTOPTION_REMOVE)
+
+
+//  lineSetTollList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetTollList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   ESPDEVSPECIFICINFO info;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddressIn[] = L"+1 (206) 123-4738";
+   WCHAR wszValidAddressIn1[] = L"+1 (206) 111-1234";
+   WCHAR wszAddressIn1[] = L"+1 (206) 444 4738";
+   WCHAR wszAddressIn2[] = L"66666";
+   WCHAR wszPrefix1[] = L"111";
+   WCHAR *pwszPrefix;
+#else
+   CHAR szValidAddressIn[] = "+1 (206) 123-4738";
+   CHAR szValidAddressIn1[] = "+1 (206) 111-1234";
+   CHAR szPrefix1[] = "111";
+   CHAR *pszPrefix;
+   CHAR szAddressIn1[] = "+1 (206) 101 4738";
+   CHAR szAddressIn2[] = "66666";
+#endif
+   DWORD dwLocationListSize = 0;
+
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineSetTollList  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lpLineDevCaps = 
+            (LPLINEDEVCAPS) AllocFromTestHeap(sizeof(LINEDEVCAPS));
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+#ifdef WUNICODE 
+	lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn;
+#else
+	lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn;
+#endif
+	 lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_ADD;
+	
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    // hLineApp = 0 is  valid
+    // set bad hLineApp
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineSetTollList(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (dwNumDevs)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+
+   // set bad dwDeviceID = dwNumDevs
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+	if (! DoLineSetTollList(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    
+    // Try bad device id (-1)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwPrivileges     = LINECALLPRIVILEGE_MONITOR;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	   TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+
+    // set bad dwDeviceID (-1)
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineSetTollList(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	      TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	   TLINE_FAIL();
+    }
+
+    // Test invalid lpszAddressIn pointers
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAddressIn pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAddressIn pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszAddressIn = (LPWSTR) gdwInvalidPointers[n];
+#else
+        lpTapiLineTestInfo->lpszAddressIn = (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineSetTollList(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn;
+#endif
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Test valid lpszAddressIn non-canonical
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpwszAddressIn non-canonical", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: lpszAddressIn non-canonical", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszAddressIn1;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szAddressIn1;
+#endif
+
+    if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszAddressIn2;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szAddressIn2;
+#endif
+
+    if (! DoLineSetTollList(lpTapiLineTestInfo, LINEERR_INVALADDRESS))
+     {
+         TLINE_FAIL();
+     }
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn;
+#endif
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwTollListOption", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn;
+#endif
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineSetTollList,
+            (LPDWORD) &lpTapiLineTestInfo->dwTollListOption,
+            LINEERR_INVALPARAM,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_TOLLLISTOPTION,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, LINETOLLLISTOPTION_ADD", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // lineInitializeEx, lineNogotiateApiVersion, lineGetDevCaps,
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap (
+          10*BIGBUFSIZE);
+   lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = BIGBUFSIZE*10;
+
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "Befor Add: dwLocationListSize = %lx", 
+       lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize);
+   dwLocationListSize = lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize;   
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn1;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn1;
+TapiLogDetail(
+DBUG_SHOW_PASS,
+"addressin = %s",
+lpTapiLineTestInfo->lpszAddressIn);
+#endif
+	lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_ADD;
+
+/*
+	if (DoLineSetTollList(lpTapiLineTestInfo, LINEERR_INIFILECORRUPT))
+		{
+			lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+			if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+		       {
+      	     TLINE_FAIL();
+		       }
+		}
+	else*/
+     if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+   
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   {
+   LPLINELOCATIONENTRY lpLocationEntry;
+   INT i;
+
+   lpLocationEntry = (LPLINELOCATIONENTRY) (((LPBYTE) lpTapiLineTestInfo->lpTranslateCaps) +
+                      lpTapiLineTestInfo->lpTranslateCaps->dwLocationListOffset);
+   for( i = 0; i < (INT)lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations; i++)
+      {
+      if(lpLocationEntry->dwPermanentLocationID ==
+         lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID)
+      break;
+      lpLocationEntry++;
+      }
+
+   TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "dwCurLoc = %lx, dwPerID = %lx, dwName = %lx, ListSize = %lx, ListOffset = %lx",
+       lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+       lpLocationEntry->dwPermanentLocationID,
+       lpLocationEntry->dwLocationNameSize,
+       lpLocationEntry->dwTollPrefixListSize,
+       lpLocationEntry->dwTollPrefixListOffset);
+
+   TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "After Add: dwLocationListSize = %lx", 
+       lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize);
+
+#ifdef WUNICODE
+   pwszPrefix = (WCHAR *) (((LPBYTE) lpTapiLineTestInfo->lpTranslateCaps) +
+       lpLocationEntry->dwTollPrefixListOffset);
+   TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "pwzPrefix = %ws", pwszPrefix);
+   if(wcsstr( pwszPrefix, wszPrefix1))
+       fTestPassed = TRUE;
+    else 
+       fTestPassed = FALSE;
+#else
+   pszPrefix =  (CHAR *) (((LPBYTE) lpTapiLineTestInfo->lpTranslateCaps) +
+       lpLocationEntry->dwTollPrefixListOffset);
+   TapiLogDetail(
+       DBUG_SHOW_PASS,
+       "pszPrefix = %s", pszPrefix);
+   if(strstr( pszPrefix, szPrefix1))
+       fTestPassed = TRUE;
+    else 
+       fTestPassed = FALSE;
+#endif
+
+    }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, LINETOLLLISTOPTION_REMOVE", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   /*
+   lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap (
+        sizeof(LINETRANSLATECAPS));
+   lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+//   lpLocationEntry = (LPLINELOCATIONENTRY) ((LPBYTE)lpTapiLineTestInfo->lpTranslateCaps +
+//             lpTapiLineTestInfo->lpTranslateCaps->dwLocationListOffset;
+   TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "Befor Remove: dwLocationListSize = %lx", 
+       lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize);
+   dwLocationListSize = lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize;   
+   */
+
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn1;
+#else
+    lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn1;
+#endif
+
+	lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_REMOVE;
+
+	if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   /*
+	if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+   TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "After Remove: dwLocationListSize = %lx", 
+       lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize);
+
+    if(lpTapiLineTestInfo->lpTranslateCaps->dwLocationListSize <
+       dwLocationListSize)
+       fTestPassed = TRUE;
+    else 
+       fTestPassed = FALSE;
+    */
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineSetTollList: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineSetTollList  <<<<<<<<"
+            );
+      return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/msgline.c b/private/tapi/qa/trapper/itest/txline/msgline.c
new file mode 100644
index 000000000..250d7c903
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/msgline.c
@@ -0,0 +1,1422 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    msgline.c
+
+Abstract:
+
+    This module contains the test functions for all message sent test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 5-9-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "xline.h"
+
+#define NUMMSGS  20
+#define NUMMSG   20
+
+#define PULSESIZE	16
+#define DTMFSIZE	16
+
+#define 	ITL_ADDRESSSTATE        0
+#define 	ITL_CALLINFO			   1
+#define 	ITL_CALLSTATE				2
+#define 	ITL_CLOSE					3
+#define 	ITL_CREATE					4
+#define 	ITL_DEVSPECIFIC			5
+#define 	ITL_DEVSPECIFICFEATURE	6
+#define 	ITL_GATHERDIGITS			7
+#define 	ITL_GENERATEDIGIT			8
+#define 	ITL_GENERATETONE			9
+#define 	ITL_LINEDEVSTATE			10
+#define 	ITL_MONITORDIGITS			11
+#define 	ITL_MONITORMEDIA			12
+#define 	ITL_MONITORTONE			13
+#define 	ITL_AGENTSPECIFIC			14
+#define 	ITL_AGENTSTATUS			15
+#define 	ITL_APPNEWCALL				16
+#define 	ITL_PROXYREQUEST			17
+#define 	ITL_REMOVE					18
+#define  ITL_REPLY					19
+
+
+typedef struct _MSGLIST
+{
+      char  szMsg[32];
+      DWORD dwMsg;
+} MSGLIST, *PMSGLIST;
+
+ESPDEVSPECIFICINFO info;
+DWORD  dwHandle;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+
+
+DWORD MsgLineCommFunc(LPTAPILINETESTINFO  lpTapiLineTestInfo, BOOL fQuietMode);
+
+
+BOOL TestLineMessages(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+    LONG lResult;
+    DWORD dwParam;    
+    DWORD dwMsg;
+	 LPDWORD	lpRequestBuf;
+	 LONG lret;
+	 LPTAPIMSG lpTapiMsg = NULL;
+	 LPTAPIMSG lpMatch;
+  
+    MSGLIST MsgList[] =
+		{
+		{ "LINE_ADDRESSSTATE",		LINE_ADDRESSSTATE },
+		{ "LINE_CALLINFO",         LINE_CALLINFO },
+		{ "LINE_CALLSTATE",        LINE_CALLSTATE },
+		{ "LINE_CLOSE",		      LINE_CLOSE },
+		{ "LINE_CREATE",		      LINE_CREATE },
+		{ "LINE_DEVSPECIFIC",		LINE_DEVSPECIFIC },
+		{ "LINE_DEVSPECIFICFEATURE",		LINE_DEVSPECIFICFEATURE },
+		{ "LINE_GATHERDIGITS",		LINE_GATHERDIGITS },
+		{ "LINE_GENERATEDIGIT",		LINE_GENERATE },
+		{ "LINE_GENERATETONE",		LINE_GENERATE },
+		{ "LINE_LINEDEVSTATE",		LINE_LINEDEVSTATE },
+		{ "LINE_MONITORDIGITS",	   LINE_MONITORDIGITS },
+		{ "LINE_MONITORMEDIA",		LINE_MONITORMEDIA },
+		{ "LINE_MONITORTONE",		LINE_MONITORTONE },
+      { "LINE_AGENTSPECIFIC",    LINE_AGENTSPECIFIC },
+      { "LINE_AGENTSTATUS",      LINE_AGENTSTATUS },
+      { "LINE_APPNEWCALL",       LINE_APPNEWCALL },
+		{ "LINE_PROXYREQUEST",		LINE_PROXYREQUEST },
+      { "LINE_REMOVE",           LINE_REMOVE	 },
+      { "LINE_REPLY",            LINE_REPLY	 }
+	};		
+
+
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+ 
+    if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+        0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+    if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "MSGs did not work for Unimodem.  Return here.");
+        //
+        // Shutdown and end the tests
+        //
+
+        if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+        return fTestPassed;
+    }
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line messages  <<<<<<<<"
+            );
+
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    for(n = 0; n< NUMMSG; n++)
+    {
+            
+       TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Test %s message", 
+                    dwTestCase + 1, MsgList[n].szMsg);
+
+       info.u.EspMsg.dwMsg = MsgList[n].dwMsg;
+
+       switch (n)
+        {
+        case ITL_ADDRESSSTATE:       
+          for(dwParam = LINEADDRESSSTATE_OTHER; dwParam <= LINEADDRESSSTATE_CAPSCHANGE; )
+          {
+           TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = dwParam;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+          lpTapiLineTestInfo->dwAddressStates = dwParam;
+
+          if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+             TLINE_FAIL();
+            }
+ 			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+        case ITL_CALLINFO:       
+          for(dwParam = LINECALLINFOSTATE_OTHER; dwParam <= LINECALLINFOSTATE_CALLDATA; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+ 			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+        case ITL_CALLSTATE:       
+          for(dwParam = LINECALLSTATE_IDLE; dwParam <= LINECALLSTATE_UNKNOWN; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+ 			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+        case ITL_CLOSE:       
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          dwHandle = 0;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          break;
+
+/*
+        case ITL_CREATE:       
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+     		 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+*/
+
+        case ITL_DEVSPECIFIC:       
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+
+        case ITL_DEVSPECIFICFEATURE:       
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+
+        case ITL_GATHERDIGITS:       
+          for(dwParam = LINEGATHERTERM_BUFFERFULL; dwParam <= LINEGATHERTERM_CANCEL; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+ 			 lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+          lpTapiLineTestInfo->dwNumDigits = 2;
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+	       lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE * sizeof(WCHAR));
+#else
+	       lpTapiLineTestInfo->lpszTerminationDigits = "3";
+	       lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+#endif
+	       lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	       lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+          if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+
+        case ITL_GENERATEDIGIT:       
+          for(dwParam = LINEGENERATETERM_DONE; dwParam <= LINEGENERATETERM_CANCEL; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+ 	       lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	       lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	       lpTapiLineTestInfo->dwDuration = 0;
+
+          if (! DoLineGenerateDigits(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+
+        case ITL_GENERATETONE:       
+          for(dwParam = LINEGENERATETERM_DONE; dwParam <= LINEGENERATETERM_CANCEL; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 1;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+          lpTapiLineTestInfo->dwToneMode = LINETONEMODE_BEEP;
+          lpTapiLineTestInfo->dwDuration = 0;
+
+          if (! DoLineGenerateTone(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+
+        case ITL_LINEDEVSTATE:       
+          for(dwParam = LINEDEVSTATE_OTHER; dwParam <= LINEDEVSTATE_REMOVED; )
+          {
+          if(dwParam != LINEDEVSTATE_REINIT)                                                 
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->dwLineStates = dwParam;
+          lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+          if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+ 			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM1
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+        case ITL_MONITORDIGITS:      
+          for(dwParam = LINEDIGITMODE_PULSE; dwParam <= LINEDIGITMODE_DTMFEND; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = dwParam;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+ 	       lpTapiLineTestInfo->dwDigitModes = info.u.EspMsg.dwParam2;
+          if (! DoLineMonitorDigits(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+        case ITL_MONITORMEDIA:      
+          for(dwParam = LINEMEDIAMODE_UNKNOWN; dwParam <= LINEMEDIAMODE_VOICEVIEW; )
+          {
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = dwParam;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+// 	       lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+          lpTapiLineTestInfo->dwMediaModes = dwParam;
+	       if (! DoLineMonitorMedia(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG | TAPIMSG_DWPARAM2
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+          (INT) dwParam <<= 1;
+          }
+          break;
+
+        case ITL_MONITORTONE:
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+          lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+          lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_LINE;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+          lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+          if (! DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+ 	       lpTapiLineTestInfo->lpToneList = (LPLINEMONITORTONE) AllocFromTestHeap(
+              sizeof(LINEMONITORTONE));
+          lpTapiLineTestInfo->dwNumEntries = 1;
+
+	       if (! DoLineMonitorTones(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+                TLINE_FAIL();
+            }
+
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hCall1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           FreeTestHeap();
+           break;
+
+/*
+        case ITL_AGENTSPECIFIC:
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          lpTapiLineTestInfo->lpLineInitializeExParams =
+                (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+                sizeof(LINEINITIALIZEEXPARAMS));
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+                sizeof(LINEINITIALIZEEXPARAMS);
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+                LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+          lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+          lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+         if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+
+	       lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	       lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+
+          if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+	      lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+         lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+			        										LINEOPENOPTION_PROXY;
+	      lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			      sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	      lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			      sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	      lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+					sizeof(DWORD);
+	      lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+					sizeof(LINECALLPARAMS);
+	      lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+											  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+         *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+	      if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+    if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+        TLINE_FAIL();
+       }
+ 
+	      lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+	      lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+	      lpTapiLineTestInfo->dwSize = 0;
+
+         if (! DoLineAgentSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+          {
+              TLINE_FAIL();
+          }
+
+ 			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+         if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+			FreeTestHeap();
+         break;
+
+        case ITL_AGENTSTATUS:
+           TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          lpTapiLineTestInfo->lpLineInitializeExParams =
+                (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+                sizeof(LINEINITIALIZEEXPARAMS));
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+                sizeof(LINEINITIALIZEEXPARAMS);
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+                LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+          lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+          lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+         if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+          lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	       lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+
+          if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+	      lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+         lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+			        										LINEOPENOPTION_PROXY;
+	      lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			      sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	      lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			      sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	      lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+					sizeof(DWORD);
+	      lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+					sizeof(LINECALLPARAMS);
+	      lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+											  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+         *lpRequestBuf = LINEPROXYREQUEST_GETAGENTSTATUS;
+
+	      if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+	      lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+	      lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+	      lpTapiLineTestInfo->dwSize = 0;
+
+         if (! DoLineGetAgentStatus(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+          {
+              TLINE_FAIL();
+          }
+
+         lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	      lpMatch->dwMsg = LINE_PROXYREQUEST;
+         lpMatch->dwParam1 = 0;
+	      lpMatch->dwParam2 = 0;
+	      lpMatch->dwParam3 = 0;
+	      lpMatch->dwFlags = TAPIMSG_DWMSG;
+	      lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+ 			if(lret == 1)
+            fTestPassed = TRUE;
+         else
+            fTestPassed = FALSE;
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+         FreeTestHeap(); 
+         break;
+*/
+
+        case ITL_APPNEWCALL:
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          lpTapiLineTestInfo->lpLineInitializeExParams =
+                (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+                sizeof(LINEINITIALIZEEXPARAMS));
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+                sizeof(LINEINITIALIZEEXPARAMS);
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+                LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+          lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+          lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+         if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+
+	       lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	       lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+
+          if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+           {
+               TLINE_FAIL();
+           }
+
+	       lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	       lpTapiLineTestInfo->dwMediaModes = TAPI_LINEMEDIAMODE_ALL;
+
+	       if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+           {
+               TLINE_FAIL();
+           }
+
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) AllocFromTestHeap (16*2);
+          _itow(lpTapiLineTestInfo->dwDeviceID,
+                lpTapiLineTestInfo->lpwszDestAddress,
+                10*2);
+#else
+	       lpTapiLineTestInfo->lpszDestAddress = (LPSTR) AllocFromTestHeap (16);
+	       _itoa(lpTapiLineTestInfo->dwDeviceID, 
+		         lpTapiLineTestInfo->lpszDestAddress,
+		         10);	 
+#endif
+
+	       lpTapiLineTestInfo->dwCountryCode = 0;
+	       lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	       if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+           {
+               TLINE_FAIL();
+           }
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage (LINE_APPNEWCALL, 0, 0, 0, 0, 0, TAPIMSG_DWMSG);
+
+          if(!WaitForAllMessages())
+            {
+              TLINE_FAIL();
+            }
+ 
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+
+        case ITL_PROXYREQUEST:
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          lpTapiLineTestInfo->lpLineInitializeExParams =
+                (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+                sizeof(LINEINITIALIZEEXPARAMS));
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+                sizeof(LINEINITIALIZEEXPARAMS);
+          lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+                LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+          lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+          lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+         if (! DoLineInitializeEx(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+
+          lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	       lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+
+          if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+	      lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+         lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER |
+			        										LINEOPENOPTION_PROXY;
+	      lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			      sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	      lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			      sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	      lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+					sizeof(DWORD);
+	      lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+					sizeof(LINECALLPARAMS);
+	      lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+											  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+         *lpRequestBuf = LINEPROXYREQUEST_AGENTSPECIFIC;
+
+	      if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+              TLINE_FAIL();
+          }
+
+	      lpTapiLineTestInfo->dwAgentExtensionIDIndex = 1;
+	      lpTapiLineTestInfo->lpParams = (LPVOID) NULL;
+	      lpTapiLineTestInfo->dwSize = 0;
+
+         if (! DoLineAgentSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+          {
+              TLINE_FAIL();
+          }
+
+         lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	      lpMatch->dwMsg = LINE_PROXYREQUEST;
+         lpMatch->dwParam1 = 0;
+	      lpMatch->dwParam2 = 0;
+	      lpMatch->dwParam3 = 0;
+	      lpMatch->dwFlags = TAPIMSG_DWMSG;
+	      lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+ 			if(lret == 1)
+            fTestPassed = TRUE;
+         else
+            fTestPassed = FALSE;
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+
+/*
+        case ITL_REMOVE:
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+			 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+*/
+
+        case ITL_REPLY:       
+          TapiLineTestInit();
+          lpTapiLineTestInfo = GetLineTestInfo();
+          lpCallbackParams = GetCallbackParams();
+
+          info.u.EspMsg.dwParam1 = 0;
+          info.u.EspMsg.dwParam2 = 0;
+          info.u.EspMsg.dwParam3 = 0;
+          fTestPassed = MsgLineCommFunc(lpTapiLineTestInfo, TRUE);
+     		 dwHandle = (DWORD) lpTapiLineTestInfo->hLine1;
+	       lpTapiLineTestInfo->dwAddressID = 0;
+	       lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;	
+	       lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+	       lpTapiLineTestInfo->dwTerminalID = 0;
+	       lpTapiLineTestInfo->bEnable = TRUE;
+ 
+          if (! DoLineSetTerminal(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+            {
+              TLINE_FAIL();
+            }
+			 /*
+          AddMessage(
+                    info.u.EspMsg.dwMsg,
+                    (DWORD) dwHandle,
+                    (DWORD) lpCallbackParams,
+                    info.u.EspMsg.dwParam1,
+                    info.u.EspMsg.dwParam2,
+                    info.u.EspMsg.dwParam3,
+                    TAPIMSG_DWMSG 
+                    );
+
+           lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+           lpTapiLineTestInfo->dwSize = sizeof(info);
+           if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+             {
+                TLINE_FAIL();
+             }
+			  */
+
+           if(lpCallbackParams->lpExpTapiMsgs != NULL)
+             {
+                TLINE_FAIL();
+             }
+
+          if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+            {
+              TLINE_FAIL();
+            }
+           break;
+
+
+       }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+	  }
+    
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Messages test: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line messages  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+DWORD MsgLineCommFunc(LPTAPILINETESTINFO  lpTapiLineTestInfo, BOOL fQuietMode)
+{
+    BOOL fTestPassed  = TRUE;
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LOPEN 
+// | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   return fTestPassed;
+}
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/txline.def b/private/tapi/qa/trapper/itest/txline/txline.def
new file mode 100644
index 000000000..f21b7a894
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/txline.def
@@ -0,0 +1,25 @@
+LIBRARY         txline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
diff --git a/private/tapi/qa/trapper/itest/txline/txline.inc b/private/tapi/qa/trapper/itest/txline/txline.inc
new file mode 100644
index 000000000..84cc4ab8a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/txline.inc
@@ -0,0 +1,73 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=txline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+
+DLLDEF=..\txline.def
+DLLBASE=0x64000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=        ..\xline.c \
+		..\itlcd.c  \
+		..\itlcde.c  \
+		..\itlds.c  \
+		..\itldsf.c  \
+		..\itlgdcf.c  \
+		..\itlgr.c \
+		..\itlrrr.c  \
+		..\itlscp.c  \
+		..\itlsdcf.c  \
+		..\itlsmm.c  \
+		..\itlst.c  \
+		..\itlstl.c \
+		..\itlsmc.c \
+		..\uline.c  \
+                ..\msgline.c \
+		..\xline.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1 
+
+
+UMTYPE=windows
+
+DLLENTRY=TXLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/txline/txlinea/makefile b/private/tapi/qa/trapper/itest/txline/txlinea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/txlinea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/txline/txlinea/sources b/private/tapi/qa/trapper/itest/txline/txlinea/sources
new file mode 100644
index 000000000..7e527092d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/txlinea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\txline.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/txline/txlinew/makefile b/private/tapi/qa/trapper/itest/txline/txlinew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/txlinew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/txline/txlinew/sources b/private/tapi/qa/trapper/itest/txline/txlinew/sources
new file mode 100644
index 000000000..3baf670fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/txlinew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\txline.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/txline/uline.c b/private/tapi/qa/trapper/itest/txline/uline.c
new file mode 100644
index 000000000..3402dbdeb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/uline.c
@@ -0,0 +1,242 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "xline.h"
+
+
+char szApiName[13][48] = 
+		{
+		"lineConfigDialog",
+		"lineConfigDialogEdit",
+		"lineDevSpecific",
+		"lineDevSpecificFeature",
+ 		"lineGetDevConfig",
+  		"lineGetRequest",
+		"lineRegisterRequestRecipient",
+		"lineSetCallParams",
+		"lineSetDevConfig",
+		"lineSetMediaControl",
+		"lineSetMediaMode",
+		"lineSetTerminal",
+		"lineSetTollList"
+	};		
+
+
+BOOL TestLineUninitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->hwndOwner = (HWND)NULL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+  	 lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			       sizeof(VARSTRING)
+         			);
+    lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+ 
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 13; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+          if (! DoLineConfigDialog(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 1:       
+	      lpTapiLineTestInfo->lpDeviceConfigIn = 
+ 			      (LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+	      lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+         		sizeof(VARSTRING)
+	          	);
+	      lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+	      if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 2:       
+          if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+          if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+	       lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		          sizeof(LINEREQMAKECALL)
+		           );
+
+          if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 6:       
+          if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 7:       
+          if (! DoLineSetCallParams(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:       
+          if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 9:       
+	       lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+          if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 10:      
+	       lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+          if (! DoLineSetMediaMode(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 11:      
+	       lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;	
+	       lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+          if (! DoLineSetTerminal(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 12:
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszAddressIn = L"+1 (206) 936-4738";
+#else
+	       lpTapiLineTestInfo->lpszAddressIn = "+1 (206) 936-4738";
+#endif
+	       lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_ADD;
+          if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/xline.c b/private/tapi/qa/trapper/itest/txline/xline.c
new file mode 100644
index 000000000..9c964f22e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/xline.c
@@ -0,0 +1,335 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    xline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	26-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "xline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTXLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TXLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTXLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninitialize(TRUE, TRUE));
+}
+
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigDialog(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigDialogEdit(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDevSpecific(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDevSpecificFeature(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetDevConfig(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetRequest(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRegisterRequestRecipient(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallParams(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetDevConfig(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetMediaControl(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetMediaMode(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetTerminal(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetTollList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineMessages(TRUE, FALSE));
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/txline/xline.def b/private/tapi/qa/trapper/itest/txline/xline.def
new file mode 100644
index 000000000..f21b7a894
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/xline.def
@@ -0,0 +1,25 @@
+LIBRARY         txline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
+        Test14
+        Test15
diff --git a/private/tapi/qa/trapper/itest/txline/xline.h b/private/tapi/qa/trapper/itest/txline/xline.h
new file mode 100644
index 000000000..a950a6f85
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/xline.h
@@ -0,0 +1,193 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    xline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef XLINE_H
+#define XLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+
+BOOL
+TestLineUninitialize(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineConfigDialog(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineConfigDialogEdit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDevSpecific(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDevSpecificFeature(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetDevConfig(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetRequest(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRegisterRequestRecipient(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineSetCallParams(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetDevConfig(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetMediaControl(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetMediaMode(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetTerminal(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetTollList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineMessages(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+#endif  // XLINE_H
diff --git a/private/tapi/qa/trapper/itest/txline/xline.rc b/private/tapi/qa/trapper/itest/txline/xline.rc
new file mode 100644
index 000000000..c101af485
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/txline/xline.rc
@@ -0,0 +1,12 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI TXLine API test Library"
+#define VER_INTERNALNAME_STR        "txline.dll"
+#define VER_ORIGINALFILENAME_STR    "txline.dll"
+
+#include "common.ver"
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/dirs b/private/tapi/qa/trapper/itest/tyline/dirs
new file mode 100644
index 000000000..edbbca874
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/dirs
@@ -0,0 +1,2 @@
+DIRS=tylinea\
+     tylinew
diff --git a/private/tapi/qa/trapper/itest/tyline/itlap.c b/private/tapi/qa/trapper/itest/tyline/itlap.c
new file mode 100644
index 000000000..56d79304d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlap.c
@@ -0,0 +1,694 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlap.c
+
+Abstract:
+
+    This module contains the test functions for lineAddProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+#define DLG_TITLE_ESP        "TUISPI_providerConfig"
+#define DLG_TITLE_UNIMDM     "Modems Properties"
+#define DLG_TITLE            "ESP32.TSP"
+
+
+
+//  lineAddProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAddProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp;
+   BOOL fUnimdm;
+   HWND hwndOwner;
+#ifdef WUNICODE
+   WCHAR wszProviderFilename[] = L"some.tsp";
+   WCHAR wszEspProviderFilename[] = L"esp32.tsp";
+   WCHAR wszUnimdmProviderFilename[] = L"unimdm.tsp";
+#else
+   CHAR szProviderFilename[] = "some.tsp";
+   CHAR szEspProviderFilename[] = "esp32.tsp";
+   CHAR szUnimdmProviderFilename[] = "unimdm.tsp";
+#endif
+   DWORD dwNumProviders;
+   BOOL  fAddProvider;
+   DWORD dwPermanentProviderID;
+   LINEPROVIDERENTRY *lpProviderEntry;
+   LPSTR lpszProviderName;
+  
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineAddProvider  <<<<<<<<"
+            );
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineAddProvider with initialize");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+ 
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = L"some.tsp";
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = "some.tsp";
+#endif
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+#ifdef WUNICODE
+   TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszProviderFilename pointers", dwTestCase + 1
+            );
+#else
+   TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszProviderFilename pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszProviderFilename = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszProviderFilename = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    // Check invalid hwndOwner handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = L"some.tsp";
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = "some.tsp";
+#endif
+
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+ 	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwPermanentProviderID pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = L"some.tsp";
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = "some.tsp";
+#endif
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwPermanentProviderID = 
+               (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+        BUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+   dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+   
+	if(FindESPLineDevice(lpTapiLineTestInfo))
+     {
+     fEsp = TRUE; 
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+     }
+	else if(FindUnimdmLineDevice(lpTapiLineTestInfo))
+     {
+     fEsp = FALSE;
+     fUnimdm = TRUE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+   else
+     {
+     fEsp = FALSE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+	
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+  
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+   else
+        fAddProvider = TRUE;
+   dwPermanentProviderID = lpTapiLineTestInfo->dwPermanentProviderID;
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+
+   TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, list all providers", dwTestCase + 1
+            );
+
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+   lpProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE)lpTapiLineTestInfo->lpProviderList) +
+							 lpTapiLineTestInfo->lpProviderList->dwProviderListOffset);
+   
+   for(n=0; n < (INT)lpTapiLineTestInfo->lpProviderList->dwNumProviders; n++)
+     {
+      lpszProviderName = (LPSTR) (((LPBYTE)lpTapiLineTestInfo->lpProviderList) +
+											lpProviderEntry->dwProviderFilenameOffset);
+      TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "dwPermanetID = %lx, Provider = %s", 
+        lpProviderEntry->dwPermanentProviderID,
+        lpszProviderName);
+      lpProviderEntry++;
+     }
+    
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+   if(fAddProvider == TRUE)
+     {
+       if(lpTapiLineTestInfo->lpProviderList->dwNumProviders ==
+           dwNumProviders + 1) 
+           fTestPassed = TRUE;
+       else
+           fTestPassed = FALSE;
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, provider should not be add twice", dwTestCase + 1
+            );
+
+
+   strcpy(szTitle, DLG_TITLE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_NOMULTIPLEINSTANCE))
+    {
+        TLINE_FAIL();
+    }
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_PASS,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->dwPermanentProviderID = dwPermanentProviderID;
+
+   if(fAddProvider)
+   {
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   PrepareToAutoDismissDlg(FALSE);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+	}
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+   FreeTestHeap();
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineAddProvider with NO initialize");
+
+
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = L"some.tsp";
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = "some.tsp";
+#endif
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+   fAddProvider = FALSE;
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszProviderFilename pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszProviderFilename pointers", dwTestCase + 1
+            );
+#endif
+
+
+     for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszProviderFilename = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszProviderFilename = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+
+        if (! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = wszProviderFilename;
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = szProviderFilename;
+#endif
+ 
+    // Check invalid hwndOwner handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = wszProviderFilename;
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = szProviderFilename;
+#endif
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpdwPermanentProviderID pointers", dwTestCase + 1
+            );
+
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = wszProviderFilename;
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = szProviderFilename;
+#endif
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpdwPermanentProviderID = 
+               (LPDWORD) gdwInvalidPointers[n];
+        if (! DoLineAddProvider(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+   
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+   dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszProviderFilename = wszProviderFilename;
+#else
+   lpTapiLineTestInfo->lpszProviderFilename = szProviderFilename;
+#endif
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+	if(fEsp)
+     {
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+     }
+	else if(fUnimdm)
+     {
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+   else
+     {
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+   
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+   else
+        fAddProvider = TRUE;
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+   if(fAddProvider == TRUE)
+     {
+       if(lpTapiLineTestInfo->lpProviderList->dwNumProviders ==
+           dwNumProviders + 1) 
+           fTestPassed = TRUE;
+       else
+           fTestPassed = FALSE;
+     }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+				   
+   if(fAddProvider)
+   {
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   PrepareToAutoDismissDlg(FALSE);
+
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+	}
+
+
+   FreeTestHeap();
+  
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineAddProvider: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineAddProvider  <<<<<<<<"
+            );
+ 		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tyline/itlcp.c b/private/tapi/qa/trapper/itest/tyline/itlcp.c
new file mode 100644
index 000000000..e00cecd51
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlcp.c
@@ -0,0 +1,549 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcp.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_providerConfig"
+#define DLG_TITLE_UNIMDM     "Modems Properties"
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+
+
+
+//  lineConfigProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineConfigProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n=1;
+   BOOL fTestPassed                  = TRUE;
+   HWND hwndOwner;
+   DWORD dwNumProviders;
+   BOOL fUnimdm;
+   MSG msg;
+   LPLINEPROVIDERENTRY lpProviderEntry;
+   LPSTR lpszProviderName;
+#ifdef WUNICODE
+   WCHAR wszEspProviderFilename[] = L"esp32.tsp";
+   WCHAR wszUnimdmProviderFilename[] = L"unimdm.tsp";
+#else
+   CHAR szEspProviderFilename[] = "esp32.tsp";
+   CHAR szUnimdmProviderFilename[] = "unimdm.tsp";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineConfigProvider  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+  TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineConfigProvider with initialize");
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BIGBUFSIZE);
+//		sizeof(LINEPROVIDERLIST));
+//	lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+   lpProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+      					lpTapiLineTestInfo->lpProviderList->dwProviderListOffset);
+
+   
+   TapiLogDetail(
+     DBUG_SHOW_PASS,
+     "ProviderID = %lx, NameSize= %lx",
+     (LPBYTE)lpTapiLineTestInfo->lpProviderList + 
+      lpTapiLineTestInfo->lpProviderList->dwProviderListOffset,
+     (LPBYTE)lpTapiLineTestInfo->lpProviderList + 
+      lpTapiLineTestInfo->lpProviderList->dwProviderListOffset + sizeof(DWORD));
+    
+     // Check invalid hwndOwner handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+
+   // hwndOwner can be NULL, so from n=1
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineConfigProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+ 	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0;
+   if (! DoLineConfigProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0xffffffff;
+   if (! DoLineConfigProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+  
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+/*	
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     fUnimdm = TRUE;
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+  */
+
+    
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	for(n = 1; n <= (INT)lpTapiLineTestInfo->lpProviderList->dwNumProviders; n++)
+	{
+	lpTapiLineTestInfo->dwPermanentProviderID = lpProviderEntry->dwPermanentProviderID;
+   lpszProviderName = (LPSTR) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+							  lpProviderEntry->dwProviderFilenameOffset);
+   if(strstr(lpszProviderName, "unimdm"))
+     {
+      fUnimdm = TRUE;
+      strcpy(szTitle, DLG_TITLE_UNIMDM);
+	   PrepareToAutoDismissWin(TRUE);
+	   if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+      while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+       {
+          TranslateMessage((LPMSG)&msg);
+          DispatchMessage ((LPMSG)&msg);
+       }
+	   PrepareToAutoDismissWin(FALSE);
+      }
+      else if(strstr(lpszProviderName, "esp"))
+       {
+       fUnimdm = FALSE;
+       strcpy(szTitle, DLG_TITLE_ESP);
+	    PrepareToAutoDismissDlg(TRUE);
+	    if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+         TLINE_FAIL();
+        }
+	    PrepareToAutoDismissDlg(FALSE);
+       }
+      lpProviderEntry++;
+	  }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Remove a provider is configing", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwDeviceID = 0;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BIGBUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    
+   lpProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+      					lpTapiLineTestInfo->lpProviderList->dwProviderListOffset);
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) NULL;
+
+	for(n = 1; n <= (INT)lpTapiLineTestInfo->lpProviderList->dwNumProviders; n++)
+	{
+	lpTapiLineTestInfo->dwPermanentProviderID = lpProviderEntry->dwPermanentProviderID;
+   lpszProviderName = (LPSTR) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+							  lpProviderEntry->dwProviderFilenameOffset);
+   if(strstr(lpszProviderName, "unimdm"))
+     {
+      strcpy(szTitle, DLG_TITLE_UNIMDM);
+	   PrepareToAutoDismissWin(TRUE);
+	   if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+	   if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+      while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+       {
+          TranslateMessage((LPMSG)&msg);
+          DispatchMessage ((LPMSG)&msg);
+       }
+	   PrepareToAutoDismissWin(FALSE);
+      
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+	   if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+         TLINE_FAIL();
+       }
+       }
+      else if(strstr(lpszProviderName, "esp"))
+       {
+       strcpy(szTitle, DLG_TITLE_ESP);
+	    PrepareToAutoDismissDlg(TRUE);
+	    if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+         TLINE_FAIL();
+        }
+       strcpy(szTitle, DLG_TITLE_REMOVE);
+	    PrepareToAutoDismissDlg(TRUE);
+	   if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+ 	    PrepareToAutoDismissDlg(FALSE);
+ 	    PrepareToAutoDismissDlg(FALSE);
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+       strcpy(szTitle, DLG_TITLE_ADD);
+	    PrepareToAutoDismissDlg(TRUE);
+ 
+	   if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+         TLINE_FAIL();
+       }
+	    PrepareToAutoDismissDlg(FALSE);
+       }
+     lpProviderEntry++; 
+     }
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTestHeap();
+
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineConfigProvider with NO initialize");
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BIGBUFSIZE);
+//		sizeof(LINEPROVIDERLIST));
+//	lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+   
+   lpProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+      					lpTapiLineTestInfo->lpProviderList->dwProviderListOffset);
+
+ 
+    // Check invalid hwndOwner handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineConfigProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = 0", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0;
+   if (! DoLineConfigProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = -1", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0xffffffff;
+   if (! DoLineConfigProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	for(n = 1; n <= (INT)lpTapiLineTestInfo->lpProviderList->dwNumProviders; n++)
+	{
+	lpTapiLineTestInfo->dwPermanentProviderID = lpProviderEntry->dwPermanentProviderID;
+   lpszProviderName = (LPSTR) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+							  lpProviderEntry->dwProviderFilenameOffset);
+   if(strstr(lpszProviderName, "unimdm"))
+     {
+      fUnimdm = TRUE;
+      strcpy(szTitle, DLG_TITLE_UNIMDM);
+	   PrepareToAutoDismissWin(TRUE);
+	   if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+      while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+       {
+          TranslateMessage((LPMSG)&msg);
+          DispatchMessage ((LPMSG)&msg);
+       }
+	   PrepareToAutoDismissWin(FALSE);
+     }
+   else if(strstr(lpszProviderName, "esp"))
+     {
+      fUnimdm = FALSE;
+      strcpy(szTitle, DLG_TITLE_ESP);
+	   PrepareToAutoDismissDlg(TRUE);
+	   if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+        TLINE_FAIL();
+       }
+	  PrepareToAutoDismissDlg(FALSE);
+     }
+   lpProviderEntry++;
+	}
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+	FreeTestHeap();
+
+ 	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineConfigProvider: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineConfigProvider  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tyline/itlgc.c b/private/tapi/qa/trapper/itest/tyline/itlgc.c
new file mode 100644
index 000000000..552e55f47
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlgc.c
@@ -0,0 +1,703 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetCountry
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define NUMTOTALSIZES 5
+
+
+
+//  lineGetCountry
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetCountry(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+   LPLINECOUNTRYENTRY lpLineCountryEntry;
+#ifdef WUNICODE 
+   LPWSTR  lpwszCountryName;
+#else
+   LPSTR   lpszCountryName;
+#endif
+
+    DWORD dwFixedSize = sizeof(LINECOUNTRYLIST);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetCountry  <<<<<<<<"
+          );
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineGetCountry with initialize");
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCountry pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpLineCountryList =
+               (LPLINECOUNTRYLIST) gdwInvalidPointers[n];
+        if (! DoLineGetCountry(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+     lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap (
+        sizeof(LINECOUNTRYLIST));
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetCountry(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = dwFixedSize;
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 FreeTestHeap();
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCountryID (-1)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwCountryID = 0xffffffff;
+	lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+		sizeof(LINECOUNTRYLIST));
+	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST);
+
+
+    if (! DoLineGetCountry(lpTapiLineTestInfo, LINEERR_INVALCOUNTRYCODE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+ 
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCountryID (2)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwCountryID = 2;
+
+    if (! DoLineGetCountry(lpTapiLineTestInfo, LINEERR_INVALCOUNTRYCODE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwCountryID = 1;
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineGetCountry(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineGetCountry(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST);
+
+   if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"####  lpLineCountryList->dwNumCounties = %lx",
+		lpTapiLineTestInfo->lpLineCountryList->dwNumCountries);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+	 FreeTestHeap();
+    
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Get entire country list", dwTestCase + 1
+            );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+   lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+       BIGBUFSIZE);
+ 	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"####  lpLineCountryList->dwNumCounties = %lx, dwTotal = %lx, dwNeeded = %lx",
+		lpTapiLineTestInfo->lpLineCountryList->dwNumCountries,
+      lpTapiLineTestInfo->lpLineCountryList->dwTotalSize,
+      lpTapiLineTestInfo->lpLineCountryList->dwNeededSize);
+
+   lpLineCountryEntry = (LPLINECOUNTRYENTRY) (((LPBYTE) lpTapiLineTestInfo->lpLineCountryList) +
+         lpTapiLineTestInfo->lpLineCountryList->dwCountryListOffset);
+   
+   for(n = 0; n < (INT)lpTapiLineTestInfo->lpLineCountryList->dwNumCountries; n++)
+      {
+      TapiLogDetail(
+          DBUG_SHOW_PASS,
+          "dwCountryID = %lx, dwCountryCode = %lx, NameSize = %lx",
+          lpLineCountryEntry->dwCountryID,
+          lpLineCountryEntry->dwCountryCode,
+          lpLineCountryEntry->dwCountryNameSize);
+
+#ifdef WUNICODE
+      lpwszCountryName =  (LPWSTR) (((LPBYTE) lpTapiLineTestInfo->lpLineCountryList) +
+                         lpLineCountryEntry->dwCountryNameOffset);
+      TapiLogDetail(
+          DBUG_SHOW_PASS,
+          "CountryName = %ws",
+          lpwszCountryName);
+#else
+      lpszCountryName =  (LPSTR) (((LPBYTE) lpTapiLineTestInfo->lpLineCountryList) +
+                         lpLineCountryEntry->dwCountryNameOffset);
+      TapiLogDetail(
+          DBUG_SHOW_PASS,
+          "CountryName = %s",
+          lpszCountryName);
+#endif
+      lpLineCountryEntry++;
+     }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   FreeTestHeap();
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineGetCountry with NO initialize");
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpCountry pointers", dwTestCase + 1
+            );
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpLineCountryList =
+               (LPLINECOUNTRYLIST) gdwInvalidPointers[n];
+        if (! DoLineGetCountry(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+ 
+    
+     lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap (
+        sizeof(LINECOUNTRYLIST));
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_DETAIL,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetCountry(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = dwFixedSize;
+
+	 FreeTestHeap();
+
+/*
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+*/
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCountryID (-1)", dwTestCase + 1
+            );
+
+    
+    lpTapiLineTestInfo->dwCountryID = 0xffffffff;
+	lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+		sizeof(LINECOUNTRYLIST));
+	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST);
+
+
+    if (! DoLineGetCountry(lpTapiLineTestInfo, LINEERR_INVALCOUNTRYCODE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCountryID (2)", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwCountryID = 2;
+
+    if (! DoLineGetCountry(lpTapiLineTestInfo, LINEERR_INVALCOUNTRYCODE))
+        {
+            TLINE_FAIL();
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwCountryID = 1;
+ 
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineGetCountry(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineGetCountry(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+ 	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST);
+
+   if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"####  lpLineCountryList->dwNumCounties = %lx",
+		lpTapiLineTestInfo->lpLineCountryList->dwNumCountries);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    FreeTestHeap();
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Get entire country list", dwTestCase + 1
+            );
+
+/*
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+*/
+    
+   lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+       BIGBUFSIZE);
+ 	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"####  lpLineCountryList->dwNumCounties = %lx, dwTotal = %lx, dwNeeded = %lx",
+		lpTapiLineTestInfo->lpLineCountryList->dwNumCountries,
+      lpTapiLineTestInfo->lpLineCountryList->dwTotalSize,
+      lpTapiLineTestInfo->lpLineCountryList->dwNeededSize);
+
+   lpLineCountryEntry = (LPLINECOUNTRYENTRY) (((LPBYTE) lpTapiLineTestInfo->lpLineCountryList) +
+         lpTapiLineTestInfo->lpLineCountryList->dwCountryListOffset);
+   
+   for(n = 0; n < (INT)lpTapiLineTestInfo->lpLineCountryList->dwNumCountries; n++)
+      {
+      TapiLogDetail(
+          DBUG_SHOW_PASS,
+          "dwCountryID = %lx, dwCountryCode = %lx, NameSize = %lx",
+          lpLineCountryEntry->dwCountryID,
+          lpLineCountryEntry->dwCountryCode,
+          lpLineCountryEntry->dwCountryNameSize);
+
+#ifdef WUNICODE
+      lpwszCountryName =  (LPWSTR) (((LPBYTE) lpTapiLineTestInfo->lpLineCountryList) +
+                         lpLineCountryEntry->dwCountryNameOffset);
+      TapiLogDetail(
+          DBUG_SHOW_PASS,
+          "CountryName = %ws",
+          lpwszCountryName);
+#else
+      lpszCountryName =  (LPSTR) (((LPBYTE) lpTapiLineTestInfo->lpLineCountryList) +
+                         lpLineCountryEntry->dwCountryNameOffset);
+      TapiLogDetail(
+          DBUG_SHOW_PASS,
+          "CountryName = %s",
+          lpszCountryName);
+#endif
+      lpLineCountryEntry++;
+     }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+ 
+    FreeTestHeap();
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetCountry: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetCountry  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itlgdt.c b/private/tapi/qa/trapper/itest/tyline/itlgdt.c
new file mode 100644
index 000000000..590602a80
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlgdt.c
@@ -0,0 +1,903 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdt.c
+
+Abstract:
+
+    This module contains the test functions for lineGenerateDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define   ALL_DIGITMODES     (LINEDIGITMODE_PULSE | \
+										LINEDIGITMODE_DTMF)
+
+
+//  lineGenerateDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGenerateDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+   DWORD dwDigitModes;
+   LPCALLBACKPARAMS lpCallbackParams;
+   BOOL fMsgSend = FALSE;
+   LONG lExpected;
+   ESPDEVSPECIFICINFO   info;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGenerateDigits  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+     lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	lpTapiLineTestInfo->dwDuration = 0;
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_NOTOWNER))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszDigits pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszDigits pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+#ifdef WUNICODE
+        lpTapiLineTestInfo->lpwszDigits = 
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+        lpTapiLineTestInfo->lpszDigits = 
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+     }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwDigitModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = LINEERR_INVALDIGITMODE;
+     else
+       lExpected = LINEERR_OPERATIONUNAVAIL;
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGenerateDigits,
+            (LPDWORD) &lpTapiLineTestInfo->dwDigitMode,
+            lExpected,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DIGITMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwDigitModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+
+      if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGenerateDigits,
+            (LPDWORD) &lpTapiLineTestInfo->dwDigitMode,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_DIGITMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_GENERATE msg sent", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	lpTapiLineTestInfo->dwDuration = 0;
+
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_GENERATE;
+    info.u.EspMsg.dwParam1 = LINEGENERATETERM_DONE;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+
+   if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+   if(fTestPassed)
+     {
+      AddMessage(
+            LINE_GENERATE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGENERATETERM_DONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_DWPARAM1 
+//         | TAPIMSG_DWPARAM3
+//          HDEVCALL | TAPIMSG_DWCALLBACKINST 
+//          TAPIMSG_DWPARAM1 | TAPIMSG_DWPARAM3
+            );
+
+      if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+           TLINE_FAIL();
+        }
+  
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TLINE_FAIL();
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINE_GENERATE msg not received");
+       } 
+    }
+   }
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+		
+          
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_GENERATE msg filtered when call goes away", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (2) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (2) * sizeof(HCALL) + 8;
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+//    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	lpTapiLineTestInfo->dwDuration = 0;
+
+//   lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   if( ! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+         TLINE_FAIL();
+    }
+
+    info.dwKey  = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_MSG;
+
+    info.u.EspMsg.dwMsg    = LINE_GENERATE;
+    info.u.EspMsg.dwParam1 = LINEGENERATETERM_DONE;
+    info.u.EspMsg.dwParam2 = 0;
+    info.u.EspMsg.dwParam3 = 0;
+
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+
+    lpTapiLineTestInfo->dwLineStates = LINEDEVSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->dwAddressStates = LINEADDRESSSTATE_DEVSPECIFIC;
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+
+   if (! DoLineSetStatusMessages(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    if(fTestPassed)
+     {
+      AddMessage(
+            LINE_GENERATE,
+            (DWORD) lpTapiLineTestInfo->hCall2,
+            (DWORD) lpCallbackParams,
+            LINEGENERATETERM_DONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG  |
+//| TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1 
+            );
+	  
+
+    if(! DoLineDevSpecific (lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+         TLINE_FAIL();
+      }
+
+      if(lpCallbackParams->lpExpTapiMsgs != NULL)
+       {
+        TapiLogDetail(DBUG_SHOW_FAILURE,
+                      "LINE_GENERATE msg not received");
+       } 
+      else
+        TLINE_FAIL();
+     }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+    fTestPassed = ShowTestCase(fTestPassed);
+
+/*
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE 
+            ))
+    {
+        TLINE_FAIL();
+    }
+  */
+		
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	lpTapiLineTestInfo->dwDuration = 0;
+
+    if ( ! DoLineGenerateDigits(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALCALLSTATE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	lpTapiLineTestInfo->dwDuration = 0;
+
+    if ( ! DoLineGenerateDigits(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGenerateDigits: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGenerateDigits  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itlgi.c b/private/tapi/qa/trapper/itest/tyline/itlgi.c
new file mode 100644
index 000000000..a046c1edb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlgi.c
@@ -0,0 +1,596 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgi.c
+
+Abstract:
+
+    This module contains the test functions for lineGetIcon
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		11-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+
+//  lineGetIcon
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetIcon(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+   WCHAR wszInvalidDeviceClass[] = L"tapi/InvalidDeviceClass";
+#else
+   CHAR szValidDeviceClass[] = "tapi/line";
+   CHAR szInvalidDeviceClass[] = "tapi/InvalidDeviceClass";
+#endif
+   ESPDEVSPECIFICINFO info;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetIcon  <<<<<<<<"
+            );
+
+
+    // Try bad device id (dwNumDevs)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad Device ID (dwNumDevs)", dwTestCase + 1);
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+	if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    
+    // Try bad device id (-1)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpwszDeviceClass pointers", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lpszDeviceClass pointers", dwTestCase + 1
+	    );
+#endif
+
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+     for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+	TapiLogDetail(
+	DBUG_SHOW_DETAIL,
+	"n= %ld", n);
+#ifdef WUNICODE
+	 lpTapiLineTestInfo->lpwszDeviceClass = 
+	       (LPWSTR) gdwInvalidPointers[n];
+#else
+	 lpTapiLineTestInfo->lpszDeviceClass = 
+	       (LPSTR) gdwInvalidPointers[n];
+#endif
+	if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+	{
+	    TLINE_FAIL();
+	}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Bad lpszDeviceClass", dwTestCase + 1
+	    );
+
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	    TLINE_FAIL();
+    }
+    
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = wszInvalidDeviceClass;
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = szInvalidDeviceClass;
+#endif
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_INVALDEVICECLASS))
+	{
+	    TLINE_FAIL();
+	}
+   }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+   {
+	if (! DoLineGetIcon(lpTapiLineTestInfo, TAPISUCCESS))
+	{
+	    TLINE_FAIL();
+	}
+   }
+ 
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = wszValidDeviceClass;
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = szValidDeviceClass;
+#endif
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: invalid lphIcon pointers", dwTestCase + 1
+	    );
+
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+     for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+	TapiLogDetail(
+	DBUG_SHOW_DETAIL,
+	"n= %ld", n);
+	 lpTapiLineTestInfo->lphIcon = 
+	       (LPHICON) gdwInvalidPointers[n];
+	if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+	{
+	    TLINE_FAIL();
+	}
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   lpTapiLineTestInfo->lphIcon = &lpTapiLineTestInfo->hIcon;
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpwszDeviceClass = 0", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpszDeviceClass = 0", dwTestCase + 1
+	    );
+#endif
+
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "";
+#endif
+
+	if (! DoLineGetIcon(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	   TLINE_FAIL();
+       }
+    
+//   AutoDismissDlg();
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpwszDeviceClass = null", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpszDeviceClass = null", dwTestCase + 1
+	    );
+#endif
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = NULL;
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = NULL;
+#endif
+
+	if (! DoLineGetIcon(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+#ifdef WUNICODE
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpwszDeviceClass = valid", dwTestCase + 1
+	    );
+#else
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: Success, lpszDeviceClass = valid", dwTestCase + 1
+	    );
+#endif
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = (LPWSTR) wszValidDeviceClass;
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = (LPSTR) szValidDeviceClass;
+#endif
+
+	if (! DoLineGetIcon(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+   
+
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+    
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "";
+#endif
+
+    if ( ! DoLineGetIcon(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_NODEVICE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "";
+#endif
+
+    if ( ! DoLineGetIcon(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetIcon: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetIcon  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itlgpl.c b/private/tapi/qa/trapper/itest/tyline/itlgpl.c
new file mode 100644
index 000000000..43cd86c46
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlgpl.c
@@ -0,0 +1,438 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgpl.c
+
+Abstract:
+
+    This module contains the test functions for lineGetProviderList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineGetProviderList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetProviderList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetProviderList  <<<<<<<<"
+            );
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineGetProviderList with initialize");
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpProviderList pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpProviderList =
+               (LPLINEPROVIDERLIST) gdwInvalidPointers[n];
+        if (! DoLineGetProviderList(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BUFSIZE);
+//		sizeof(LINEPROVIDERLIST));
+//	lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = Fixed-1", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+	 lpTapiLineTestInfo->lpProviderList->dwTotalSize = 
+            sizeof(LINEPROVIDERLIST) - 1;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_STRUCTURETOOSMALL))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = 0", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->lpProviderList->dwTotalSize = 0;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_STRUCTURETOOSMALL))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"####  lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineGetProviderList with NO initialize");
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpProviderList pointers", dwTestCase + 1
+            );
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpProviderList =
+               (LPLINEPROVIDERLIST) gdwInvalidPointers[n];
+        if (! DoLineGetProviderList(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BUFSIZE);
+//		sizeof(LINEPROVIDERLIST));
+//	lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAPIVersion = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TOOLOW_APIVERSION;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwAPIVersion =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = Fixed-1", dwTestCase + 1);
+    
+	 lpTapiLineTestInfo->lpProviderList->dwTotalSize = 
+            sizeof(LINEPROVIDERLIST) - 1;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_STRUCTURETOOSMALL))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize = 0", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpProviderList->dwTotalSize = 0;
+    if (! DoLineGetProviderList(
+                       lpTapiLineTestInfo,
+                       LINEERR_STRUCTURETOOSMALL))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"####  lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+		
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetProviderList: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetProviderList  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tyline/itlgtc.c b/private/tapi/qa/trapper/itest/tyline/itlgtc.c
new file mode 100644
index 000000000..419f4608a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlgtc.c
@@ -0,0 +1,357 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgtc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetTranslateCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define NUMTOTALSIZES 5
+
+
+
+//  lineGetTranslateCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetTranslateCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+    DWORD dwFixedSize = sizeof(LINETRANSLATECAPS);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGetTranslateCaps  <<<<<<<<"
+            );
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpTranslateCaps pointers", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpTranslateCaps =
+               (LPLINETRANSLATECAPS) gdwInvalidPointers[n];
+        if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    // Check invalid line app handles
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+        	 sizeof(LINETRANSLATECAPS));
+	 lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = 
+            sizeof(LINETRANSLATECAPS) ;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    // hLineApp = 0 is valid 
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineGetTranslateCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineGetTranslateCaps(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = dwFixedSize;
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = 
+          sizeof(LINETRANSLATECAPS);
+    if (! DoLineGetTranslateCaps(
+                       lpTapiLineTestInfo,
+							  TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGetTranslateCaps: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGetTranslateCaps  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itlgtn.c b/private/tapi/qa/trapper/itest/tyline/itlgtn.c
new file mode 100644
index 000000000..34a964175
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlgtn.c
@@ -0,0 +1,1030 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgtn.c
+
+Abstract:
+
+    This module contains the test functions for lineGenerateTone
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define ALL_TONEMODES    (LINETONEMODE_CUSTOM | \
+								  LINETONEMODE_RINGBACK | \
+								  LINETONEMODE_BUSY | \
+								  LINETONEMODE_BEEP | \
+								  LINETONEMODE_BILLING )
+
+#define NUMENTRIES		6
+#define PAGESIZE			4000
+
+//  lineGenerateTone
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGenerateTone(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+   WCHAR wszValidDeviceClass[] = L"tapi/line";
+#else
+   CHAR szValidAddress[] = "55555";
+   CHAR szValidDeviceClass[] = "tapi/line";
+#endif
+   DWORD dwToneModes;
+   LPCALLBACKPARAMS lpCallbackParams;
+   BOOL fMsgSend = FALSE;
+   ESPDEVSPECIFICINFO info;
+
+   DWORD dwNumEntries[NUMENTRIES] = {
+							 1,
+//							 500,
+ //   						 1000,
+//							 100000,
+							 0x7fffffff,
+							 0xffffffff
+							 };
+   DWORD dwNumBytes;
+   DWORD lExpected;
+   DWORD dwFixedSize = sizeof(LINEGENERATETONE);
+ 
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineGenerateTone  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+     lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+	lpTapiLineTestInfo->dwDuration = 0;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_NOTOWNER))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwToneModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+     if(IsESPLineDevice(lpTapiLineTestInfo))
+       lExpected = LINEERR_INVALTONEMODE;
+     else
+ 		 lExpected = LINEERR_OPERATIONUNAVAIL;
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGenerateTone,
+            (LPDWORD) &lpTapiLineTestInfo->dwToneMode,
+            lExpected,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_TONEMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwDigitNumEntries, fixed alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_CUSTOM;
+ 	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwNumTones = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwFixedSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwNumTones = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+    lpTapiLineTestInfo->lpTones = (LPLINEGENERATETONE) ITAlloc(
+        dwFixedSize);
+    if(dwNumBytes < PAGESIZE)
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_INVALPOINTER;
+
+    if (! DoLineGenerateTone(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    ITFree(lpTapiLineTestInfo->lpTones);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwNumTones = 1;
+    lpTapiLineTestInfo->lpTones = (LPLINEGENERATETONE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwDigitNumEntries, var alloc size", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_CUSTOM;
+ 	 for(n=0; n< NUMENTRIES; n++)
+    {
+    lpTapiLineTestInfo->dwNumTones = dwNumEntries[n];
+    dwNumBytes = dwNumEntries[n] * dwFixedSize;
+    TapiLogDetail(
+      DBUG_SHOW_DETAIL,
+      "dwNumTones = %lx, dwNumBytes = %lx", 
+      dwNumEntries[n], dwNumBytes);
+    lpTapiLineTestInfo->lpTones = (LPLINEGENERATETONE) ITAlloc(
+        dwNumBytes);
+    if(lpTapiLineTestInfo->lpTones)
+       lExpected = TAPISUCCESS;
+    else
+       lExpected = LINEERR_INVALPOINTER;
+
+    if (! DoLineGenerateTone(lpTapiLineTestInfo, lExpected))
+      {
+          TLINE_FAIL();
+      }
+    if(lpTapiLineTestInfo->lpTones)
+      ITFree(lpTapiLineTestInfo->lpTones);
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwNumTones = 1;
+    lpTapiLineTestInfo->lpTones = (LPLINEGENERATETONE) NULL;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LDROP | LDEALLOCATECALL | LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad lpTones when LINETONEMODE_CUSTOM", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_CUSTOM;
+   lpTapiLineTestInfo->dwNumTones = 1;
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpTones = 
+                 (LPLINEGENERATETONE) gdwInvalidPointers[n];
+        if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Verify lpTones ignor when not LINETONEMODE_CUSTOM", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        lpTapiLineTestInfo->lpTones = 
+                 (LPLINEGENERATETONE) gdwInvalidPointers[n];
+        if (! DoLineGenerateTone(lpTapiLineTestInfo, TAPISUCCESS))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest for dwToneModes", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+   lpTapiLineTestInfo->dwNumTones = 0;
+      if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineGenerateTone,
+            (LPDWORD) &lpTapiLineTestInfo->dwToneMode,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_TONEMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+// All msgs tests in txline, msgline.c
+/*
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_GENERATE msg sent", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+	lpTapiLineTestInfo->dwDuration = 0;
+
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   if(fTestPassed)
+     {
+      AddMessage(
+            LINE_GENERATE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGENERATETERM_DONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | 
+            TAPIMSG_DWPARAM1
+            );
+
+       if (! WaitForAllMessages())
+          {
+            TLINE_FAIL();
+            fMsgSend = FALSE;
+           }
+       else
+  		     fMsgSend = TRUE;
+      }
+
+    if(fMsgSend)
+       fTestPassed = TRUE;
+    else
+       fTestPassed = FALSE;       
+ 	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+		
+   
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify LINE_GENERATE msg filtered when call goes away", dwTestCase + 1
+            );
+
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+    lpTapiLineTestInfo->lpwszDeviceClass  = wszValidDeviceClass;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+    lpTapiLineTestInfo->lpszDeviceClass  = szValidDeviceClass;
+#endif
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+            sizeof(LINECALLLIST) + (2) * sizeof(HCALL) + 8
+            );
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+            (2) * sizeof(HCALL) + 8;
+
+    lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall2;
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Let the monitor get the active call handle
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+    if (! DoLineGetNewCalls(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Store the acquired call handle (as hCall1)
+    GetVarField(
+            (LPVOID) lpTapiLineTestInfo->lpCallList,
+            (LPVOID) &lpTapiLineTestInfo->hCall2,
+            4,
+            lpTapiLineTestInfo->lpCallList->dwCallsOffset
+            );
+
+
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+	lpTapiLineTestInfo->dwDuration = 0;
+
+   lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   if( ! DoLineDeallocateCall(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   if(fTestPassed)
+     {
+      AddMessage(
+            LINE_GENERATE,
+            (DWORD) lpTapiLineTestInfo->hCall1,
+            (DWORD) lpCallbackParams,
+            LINEGENERATETERM_DONE,
+            0x00000000,
+            0x00000000,
+            TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                    TAPIMSG_DWPARAM1
+            );
+
+       if(WaitForAllMessages())
+         fTestPassed = FALSE;
+       else
+         fTestPassed = TRUE;
+      }
+ 	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine2;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE 
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    lpTapiLineTestInfo->lphLine = &lpTapiLineTestInfo->hLine1;
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    
+    n = ESP_RESULT_RETURNRESULT;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Success, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+				| LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = TAPISUCCESS;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+	 lpTapiLineTestInfo->dwDuration = 0;
+
+    if ( ! DoLineGenerateTone(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">> Test Case %ld: Error, completionID = %d",	dwTestCase + 1, n
+        );
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo                      = GetLineTestInfo();
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaModes        = LINEMEDIAMODE_DATAMODEM;
+    lpTapiLineTestInfo->dwPrivileges        = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_ADDRESS;
+    
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+ 
+    // Init a line
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN
+            | LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    if(IsESPLineDevice(lpTapiLineTestInfo))
+    {
+    info.dwKey = ESPDEVSPECIFIC_KEY;
+    info.dwType = ESP_DEVSPEC_RESULT;
+    info.u.EspResult.lResult = LINEERR_INVALTONE;
+    info.u.EspResult.dwCompletionType = n;
+    lpTapiLineTestInfo->lpParams = (LPVOID)&info;
+    lpTapiLineTestInfo->dwSize = sizeof(info);
+ 
+    if(! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+      {
+          TLINE_FAIL();
+      }
+
+	 lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+	 lpTapiLineTestInfo->dwDuration = 0;
+
+    if ( ! DoLineGenerateTone(lpTapiLineTestInfo, info.u.EspResult.lResult))
+      {
+          TLINE_FAIL();
+      }
+
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Free the memory allocated during the tests
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineGenerateTone: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineGenerateTone  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itlho.c b/private/tapi/qa/trapper/itest/tyline/itlho.c
new file mode 100644
index 000000000..197b017f3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlho.c
@@ -0,0 +1,594 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlho.c
+
+Abstract:
+
+    This module contains the test functions for lineHandoff
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define  DLG_TITLE  "Tapi App"
+
+#define ALL_MEDIAMODES		  (LINEMEDIAMODE_INTERACTIVEVOICE   | \
+										LINEMEDIAMODE_AUTOMATEDVOICE     | \
+										LINEMEDIAMODE_DATAMODEM          | \
+										LINEMEDIAMODE_G3FAX              | \
+										LINEMEDIAMODE_TDD                | \
+										LINEMEDIAMODE_G4FAX              | \
+										LINEMEDIAMODE_DIGITALDATA        | \
+										LINEMEDIAMODE_TELETEX            | \
+										LINEMEDIAMODE_VIDEOTEX           | \
+										LINEMEDIAMODE_TELEX              | \
+										LINEMEDIAMODE_MIXED              | \
+										LINEMEDIAMODE_ADSI               | \
+										LINEMEDIAMODE_VOICEVIEW          | \
+										LINEMEDIAMODE_UNKNOWN)
+
+
+//  lineHandoff
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineHandoff(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+   MSG msg;
+#ifdef WUNICODE
+   WCHAR wszValidAddress[] = L"55555";
+#else
+   CHAR szValidAddress[] = "55555";
+#endif
+   LPCALLBACKPARAMS lpCallbackParams;
+	
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineHandoff  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+     lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hCall values", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->hCall_Orig = *(lpTapiLineTestInfo->lphCall);
+    for (n = 0; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            "n= %ld", n);
+        *(lpTapiLineTestInfo->lphCall) = (HCALL) gdwInvalidHandles[n];
+        if (! DoLineHandoff(lpTapiLineTestInfo, LINEERR_INVALCALLHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphCall) = lpTapiLineTestInfo->hCall_Orig;
+    
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszFileName pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszFileName pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_NONE;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    
+    // lpszFileName = NULL, it not returns INVAILPOINT
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszFileName =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszFileName =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineHandoff(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: FileName not exist", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszFileName = (LPWSTR) L"TESTAPP.EXE";
+#else
+	lpTapiLineTestInfo->lpszFileName = (LPSTR) "TESTAPP.EXE";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+   if (! DoLineHandoff(lpTapiLineTestInfo, LINEERR_TARGETNOTFOUND))
+     {
+         TLINE_FAIL();
+     }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: no OWNER privilege for hCall", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+   if (! DoLineDrop(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+     {
+         TLINE_FAIL();
+     }
+   
+   lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_MONITOR;
+   if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+ 
+ 
+	WinExec("testapp.exe", SW_SHOWDEFAULT);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszFileName  = (LPWSTR) L"TESTAPP.EXE";
+#else
+    lpTapiLineTestInfo->lpszFileName  = (LPSTR) "TESTAPP.EXE";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+
+   strcpy(szTitle, DLG_TITLE);
+
+	PrepareToAutoDismissWin(TRUE);
+
+   while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+    {
+     TranslateMessage((LPMSG)&msg);
+     DispatchMessage ((LPMSG)&msg);
+    }
+	 if (! DoLineHandoff(lpTapiLineTestInfo, LINEERR_NOTOWNER))
+     {
+         TLINE_FAIL();
+     }
+	PrepareToAutoDismissWin(FALSE);
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+     
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest fow dwMediaMode", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+#ifdef WUNICODE
+     lpTapiLineTestInfo->lpwszFileName = (LPWSTR)NULL;
+#else
+     lpTapiLineTestInfo->lpszFileName = (LPSTR)NULL;
+#endif
+//     dwAllMediaModes = ALL_MEDIAMODE | LINEMEDIAMODE_UNKNOWN;
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineHandoff,
+            (LPDWORD) &lpTapiLineTestInfo->dwMediaMode,
+            LINEERR_INVALMEDIAMODE,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_24,
+            ALL_MEDIAMODES,
+            ~dwBitVectorMasks[(int) FIELDSIZE_24],
+            0x00000000,
+            0x00000000,
+            TRUE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify dir handoff mediamode ignor", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	WinExec("testapp.exe", SW_SHOWDEFAULT);
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszFileName = (LPWSTR) L"TESTAPP.EXE";
+#else
+	lpTapiLineTestInfo->lpszFileName = (LPSTR) "TESTAPP.EXE";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = 0;
+
+   strcpy(szTitle, DLG_TITLE);
+
+	PrepareToAutoDismissWin(TRUE);
+
+   if (! DoLineHandoff(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+
+   if(fTestPassed)
+   {
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMOWNERINCR,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    }
+    while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+    {
+     TranslateMessage((LPMSG)&msg);
+     DispatchMessage ((LPMSG)&msg);
+    }
+ 
+    PrepareToAutoDismissWin(FALSE);
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+/* 
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success, verify 2nd dir handoff mediamode ignor", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = wszValidAddress;
+#else
+    lpTapiLineTestInfo->lpszDestAddress  = szValidAddress;
+#endif
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszFileName = (LPWSTR) L"TESTAPP.EXE";
+#else
+	lpTapiLineTestInfo->lpszFileName = (LPSTR) "TESTAPP.EXE";
+#endif
+   lpTapiLineTestInfo->dwMediaMode = 0;
+
+	PrepareToAutoDismissWin(TRUE);
+
+   if (! DoLineHandoff(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+   while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+    {
+     TranslateMessage((LPMSG)&msg);
+     DispatchMessage ((LPMSG)&msg);
+    }
+	PrepareToAutoDismissWin(FALSE);
+
+     fTestPassed = ShowTestCase(fTestPassed);
+
+    // Shutdown to isolate the test case
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LCLOSE | LSHUTDOWN
+            ))
+    {
+        TLINE_FAIL();
+    }
+*/
+
+    FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineHandoff: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineHandoff  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itlrp.c b/private/tapi/qa/trapper/itest/tyline/itlrp.c
new file mode 100644
index 000000000..fbbf0872f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlrp.c
@@ -0,0 +1,552 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrp.c
+
+Abstract:
+
+    This module contains the test functions for lineRemoveProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+
+
+//  lineRemoveProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRemoveProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp;
+   BOOL fUnimdm;
+   HWND hwndOwner;
+   BOOL fRemovedProvider;
+   BOOL fAddProvider;
+   DWORD dwNumProviders;
+#ifdef WUNICODE
+   WCHAR wszEspProviderFilename[] = L"esp32.tsp";
+   WCHAR wszUnimdmProviderFilename[] = L"unimdm.tsp";
+#else
+   CHAR szEspProviderFilename[] = "esp32.tsp";
+   CHAR szUnimdmProviderFilename[] = "unimdm.tsp";
+#endif
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	 TapiLogDetail(
+         DBUG_SHOW_PASS,
+         ">>>>>>>>  Begin testing lineRemoveProvider  <<<<<<<<"
+         );
+
+  
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineRemoveProvider with initialize");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+
+   // hwndOwner can be NULL, so from n=1
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineRemoveProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+ 	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = 0", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0;
+   if (! DoLineRemoveProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = -1", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0xffffffff;
+   if (! DoLineRemoveProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+   dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+	if(FindESPLineDevice(lpTapiLineTestInfo))
+    {
+	  fEsp = TRUE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+	 }
+	else if(FindUnimdmLineDevice(lpTapiLineTestInfo))
+	 {
+	  fEsp = FALSE;
+     fUnimdm = TRUE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+    }
+	else
+     {
+     fEsp = FALSE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+    
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+   else
+        fAddProvider = TRUE;
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+   dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+ 
+
+   if(fAddProvider)
+   {
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fRemovedProvider = FALSE;
+    }
+   else
+	     fRemovedProvider = TRUE;
+   PrepareToAutoDismissDlg(FALSE);
+
+   }
+	else
+     fRemovedProvider = FALSE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+   if(fRemovedProvider)
+    {
+      if(lpTapiLineTestInfo->lpProviderList->dwNumProviders ==
+            dwNumProviders - 1)
+	      fTestPassed = TRUE;
+     	else
+         fTestPassed = FALSE;
+    }
+   
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+   TapiLogDetail(
+           DBUG_SHOW_PASS,
+           " Test lineRemoveProvider with NO initialize");
+
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    
+ 	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+   hwndOwner = lpTapiLineTestInfo->hwndOwner;
+
+   // hwndOwner can be NULL, so from n=1
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineRemoveProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->hwndOwner = hwndOwner;
+ 
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = 0", dwTestCase + 1
+            );
+
+    
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0;
+   if (! DoLineRemoveProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwPermanentProviderID = -1", dwTestCase + 1
+            );
+
+    
+   lpTapiLineTestInfo->hwndOwner = hwndOwner;
+   lpTapiLineTestInfo->dwPermanentProviderID = 0xffffffff;
+   if (! DoLineRemoveProvider(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+      {
+          TLINE_FAIL();
+      }
+   
+   fTestPassed = ShowTestCase(fTestPassed);
+ 
+	
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1
+            );
+
+   lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(BUFSIZE);
+//		sizeof(LINEPROVIDERLIST));
+//	lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+   dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+   
+	if(fEsp)
+    {
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+	 }
+	else if(fUnimdm)
+	 {
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+    }
+	else
+     {
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+    
+	
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+   else
+        fAddProvider = TRUE;
+
+   PrepareToAutoDismissDlg(FALSE);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+   dwNumProviders = lpTapiLineTestInfo->lpProviderList->dwNumProviders;
+
+   fRemovedProvider = FALSE;
+
+   if(fAddProvider)
+   {
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fRemovedProvider = FALSE;
+    }
+   else
+	     fRemovedProvider = TRUE;
+   PrepareToAutoDismissDlg(FALSE);
+
+   } 
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+   if(fRemovedProvider)
+    {
+      if(lpTapiLineTestInfo->lpProviderList->dwNumProviders ==
+            dwNumProviders - 1)
+	      fTestPassed = TRUE;
+     	else
+         fTestPassed = FALSE;
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+   
+
+	 FreeTestHeap();
+    
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineRemoveProvider: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineRemoveProvider  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/tyline/itlta.c b/private/tapi/qa/trapper/itest/tyline/itlta.c
new file mode 100644
index 000000000..09406acdb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itlta.c
@@ -0,0 +1,743 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlta.c
+
+Abstract:
+
+    This module contains the test functions for lineTranslateAddress
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define  ALL_LINETRANSLATEOPTIONS   (LINETRANSLATEOPTION_CARDOVERRIDE | \
+												 LINETRANSLATEOPTION_CANCELCALLWAITING | \
+												 LINETRANSLATEOPTION_FORCELOCAL | \
+												 LINETRANSLATEOPTION_FORCELD )
+
+#define NUMTOTALSIZES 5
+
+
+//  lineTranslateAddress
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTranslateAddress(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+    DWORD dwFixedSize = sizeof(LINETRANSLATEOUTPUT);
+    DWORD lExpected;
+    DWORD dwTotalSizes[NUMTOTALSIZES] = {
+                           0,
+                           (DWORD) dwFixedSize - 1,
+   								0x70000000,
+                           0x7FFFFFFF,
+                           0xFFFFFFFF
+                           };
+ 
+	
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineTranslateAddress  <<<<<<<<"
+            );
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpTranslateOutput pointers", dwTestCase + 1
+            );
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+     lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+            sizeof(LPLINETRANSLATEOUTPUT)
+            );
+     lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = sizeof(LPLINETRANSLATEOUTPUT);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->lpTranslateOutput =
+               (LPLINETRANSLATEOUTPUT) gdwInvalidPointers[n];
+        if (! DoLineTranslateAddress(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+   lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+			sizeof(LINETRANSLATEOUTPUT));
+   lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = sizeof(LINETRANSLATEOUTPUT);
+   
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+   lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+
+     TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case: bad Device ID (dwNumDevs & -1) not tested here for bug postpone");
+ 
+/*
+     TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad Device ID (dwNumDevs)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+	if (! DoLineTranslateAddress(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    
+    // Try bad device id (-1)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+	if (! DoLineTranslateAddress(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+*/
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+        	 sizeof(LINETRANSLATECAPS));
+	 lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = 
+            sizeof(LINETRANSLATECAPS) ;
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    // hLineApp = 0 is valid
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        *(lpTapiLineTestInfo->lphLineApp) = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineTranslateAddress(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lphLineApp) = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	
+
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineTranslateAddress(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineTranslateAddress(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAddressIn pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAddressIn pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    for (n = 0; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAddressIn =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAddressIn =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineTranslateAddress(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwTotalSize", dwTestCase + 1);
+ 
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+   lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+
+     lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap (
+        sizeof(LINETRANSLATEOUTPUT));
+
+    for (n = 0; n < NUMTOTALSIZES; n++)
+        {
+        lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = 
+                        dwTotalSizes[n];
+	     if(dwTotalSizes[n] < dwFixedSize)
+           lExpected = LINEERR_STRUCTURETOOSMALL;
+        else
+           lExpected = LINEERR_INVALPOINTER;
+        TapiLogDetail(
+           DBUG_SHOW_PASS,
+           "dwTotalSize = %lx", dwTotalSizes[n]);
+        if (! DoLineTranslateAddress(lpTapiLineTestInfo, lExpected))
+           {
+              TLINE_FAIL();
+           }
+        }
+    fTestPassed = ShowTestCase(fTestPassed);
+    lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = dwFixedSize;
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCard = -1", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = 
+          sizeof(LINETRANSLATEOUTPUT);
+    lpTapiLineTestInfo->dwTranslateOptions = 
+          LINETRANSLATEOPTION_CARDOVERRIDE;
+    lpTapiLineTestInfo->dwCard = 0xffffffff;
+
+    if (! DoLineTranslateAddress(
+                       lpTapiLineTestInfo,
+                       LINEERR_INVALCARD))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Bad dwCard = dwNumCard", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+			 sizeof(LINETRANSLATECAPS));
+    lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+
+    lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = 
+          sizeof(LINETRANSLATEOUTPUT);
+    lpTapiLineTestInfo->dwTranslateOptions = 
+          LINETRANSLATEOPTION_CARDOVERRIDE;
+
+    if (! DoLineGetTranslateCaps(
+                       lpTapiLineTestInfo,
+                       TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    lpTapiLineTestInfo->dwCard = lpTapiLineTestInfo->lpTranslateCaps->dwNumCards;
+ 
+    if (! DoLineTranslateAddress(
+                       lpTapiLineTestInfo,
+                       LINEERR_INVALCARD))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamErrorTest for dwTranslateOptions", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+
+     if(! TestInvalidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineTranslateAddress,
+            (LPDWORD) &lpTapiLineTestInfo->dwTranslateOptions,
+            LINEERR_INVALPARAM,
+	         FIELDTYPE_NA,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_LINETRANSLATEOPTIONS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+//            0x00000000,
+				0xffffffff,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: BitVectorParamValidTest for dwTrnslateOptions", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+ 
+
+    lpTapiLineTestInfo->dwCard = lpTapiLineTestInfo->lpTranslateCaps->dwNumCards - 1;
+     if(! TestValidBitFlags(
+            lpTapiLineTestInfo,
+            DoLineTranslateAddress,
+            (LPDWORD) &lpTapiLineTestInfo->dwTranslateOptions,
+	         FIELDTYPE_MUTEX,
+            FIELDTYPE_MUTEX,
+            FIELDSIZE_32,
+            ALL_LINETRANSLATEOPTIONS,
+            ~dwBitVectorMasks[(int) FIELDSIZE_32],
+            0x00000000,
+            0x00000000,
+            FALSE
+            ))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    fTestPassed = ShowTestCase(fTestPassed);
+
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	 FreeTestHeap();
+ 
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Success", dwTestCase + 1);
+   
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+   lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCard = 0; // get from GetTranslateCaps
+	lpTapiLineTestInfo->dwTranslateOptions = LINETRANSLATEOPTION_CANCELCALLWAITING;
+	lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+       BUFSIZE);
+	lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = BUFSIZE;
+
+   if (! DoLineTranslateAddress(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateOutput->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateOutput->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateOutput->dwCurrentCountry = %lx, dwDestCountry = %lx, dwResults = %lx",
+		lpTapiLineTestInfo->lpTranslateOutput->dwCurrentCountry,
+		lpTapiLineTestInfo->lpTranslateOutput->dwDestCountry,
+		lpTapiLineTestInfo->lpTranslateOutput->dwTranslateResults);
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineTranslateAddress: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineTranslateAddress  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/itltd.c b/private/tapi/qa/trapper/itest/tyline/itltd.c
new file mode 100644
index 000000000..7478533b4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/itltd.c
@@ -0,0 +1,634 @@
+
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itltd.c
+
+Abstract:
+
+    This module contains the test functions for lineTranslateDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/29/96		added unicode support
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define DLG_TITLE    "Dialing Properties"
+
+
+//  lineTranslateDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTranslateDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+#ifdef WUNICODE
+   WCHAR wszValidAddressIn[] = L"+1 (206) 936-4738";
+   WCHAR wszValidAddressIn1[] = L"+1 (206) 936-1234";
+   WCHAR wszAddressIn1[] = L"+1 (206) 936 4738";
+   WCHAR wszAddressIn2[] = L"55555";
+#else
+   CHAR szValidAddressIn[] = "+1 (206) 936-4738";
+   CHAR szValidAddressIn1[] = "+1 (206) 936-1234";
+   CHAR szAddressIn1[] = "+1 (206) 936 4738";
+   CHAR szAddressIn2[] = "55555";
+#endif
+   BOOL fTestPassed                  = TRUE;
+
+   InitTestNumber();
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing lineTranslateDialog  <<<<<<<<"
+            );
+
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid hwndOwner handles", dwTestCase + 1);
+    
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+   // hwndOwner can be NULL, so from n=1
+   for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+         lpTapiLineTestInfo->hwndOwner = (HWND) gdwInvalidHandles[n];
+        if (! DoLineTranslateDialog(lpTapiLineTestInfo, LINEERR_INVALPARAM))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+     TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case: bad Device ID (dwNumDevs, & -1) not tested here for bug postpone");
+ 
+/*
+     TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad Device ID (dwNumDevs)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+
+   strcpy(szTitle, DLG_TITLE);
+   PrepareToAutoDismissDlg(TRUE);
+
+   lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+   lpTapiLineTestInfo->dwDeviceID = *(lpTapiLineTestInfo->lpdwNumDevs);
+	if (! DoLineTranslateDialog(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+   PrepareToAutoDismissDlg(FALSE);
+
+    lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	TLINE_FAIL();
+    }
+
+    // Try bad device id (-1)
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">> Test Case %ld: bad device ID (-1)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+	    lpTapiLineTestInfo,
+	    LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+	    ))
+    {
+	TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwDeviceID_Orig = lpTapiLineTestInfo->dwDeviceID;
+    lpTapiLineTestInfo->dwDeviceID = DWMINUSONE;
+
+   strcpy(szTitle, DLG_TITLE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineTranslateDialog(lpTapiLineTestInfo, LINEERR_BADDEVICEID))
+       {
+	   TLINE_FAIL();
+       }
+
+   fTestPassed = ShowTestCase(fTestPassed);
+   PrepareToAutoDismissDlg(FALSE);
+
+     lpTapiLineTestInfo->dwDeviceID = lpTapiLineTestInfo->dwDeviceID_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+	   TLINE_FAIL();
+    }
+*/
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAddressIn pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAddressIn pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // lpszAddressIn can be NULL
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAddressIn =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAddressIn =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineTranslateDialog(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid line app handles", dwTestCase + 1);
+    
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn;
+#else
+   lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn;
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->hLineApp_Orig = *lpTapiLineTestInfo->lphLineApp;
+    for (n = 1; n < NUMINVALIDHANDLES; n++)
+    {
+        *lpTapiLineTestInfo->lphLineApp = (HLINEAPP) gdwInvalidHandles[n];
+        if (! DoLineTranslateDialog(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *lpTapiLineTestInfo->lphLineApp = lpTapiLineTestInfo->hLineApp_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	    // Check incompatible API Version too high
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too high)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *lpTapiLineTestInfo->lpdwAPIVersion = TOOHIGH_APIVERSION;
+    if (! DoLineTranslateDialog(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = 
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Check incompatible API Version that's too low
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: incompatible API version (too low)", dwTestCase + 1);
+    
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    lpTapiLineTestInfo->dwAPIVersion_Orig = 
+            *lpTapiLineTestInfo->lpdwAPIVersion;
+    *(lpTapiLineTestInfo->lpdwAPIVersion) = TOOLOW_APIVERSION;
+    if (! DoLineTranslateDialog(
+                       lpTapiLineTestInfo,
+                       LINEERR_INCOMPATIBLEAPIVERSION))
+    {
+        TLINE_FAIL();
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    *(lpTapiLineTestInfo->lpdwAPIVersion) =
+            lpTapiLineTestInfo->dwAPIVersion_Orig;
+
+    // Shutdown to isolate the test case
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpwszAddressIn pointers", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: invalid lpszAddressIn pointers", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+    
+    // lpszAddressIn can be NULL
+    for (n = 1; n < NUMINVALIDPOINTERS; n++)
+    {
+        TapiLogDetail(
+        DBUG_SHOW_DETAIL,
+        "n= %ld", n);
+#ifdef WUNICODE
+         lpTapiLineTestInfo->lpwszAddressIn =
+               (LPWSTR) gdwInvalidPointers[n];
+#else
+         lpTapiLineTestInfo->lpszAddressIn =
+               (LPSTR) gdwInvalidPointers[n];
+#endif
+        if (! DoLineTranslateDialog(lpTapiLineTestInfo, LINEERR_INVALPOINTER))
+        {
+            TLINE_FAIL();
+        }
+    }
+    fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test valid lpwszAddressIn ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test valid lpszAddressIn ", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn;
+#else
+   lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn;
+#endif
+
+   strcpy(szTitle, DLG_TITLE);
+   PrepareToAutoDismissDlg(TRUE);
+ 
+   if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+     }
+   PrepareToAutoDismissDlg(FALSE);
+   fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test valid lpwszAddressIn ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test valid lpszAddressIn ", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = wszValidAddressIn1;
+#else
+   lpTapiLineTestInfo->lpszAddressIn = szValidAddressIn1;
+#endif
+
+   PrepareToAutoDismissDlg(TRUE);
+
+   if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+     }
+   PrepareToAutoDismissDlg(FALSE);
+   fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test bad lpwszAddressIn ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test bad lpszAddressIn ", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = wszAddressIn1;
+#else
+   lpTapiLineTestInfo->lpszAddressIn = szAddressIn1;
+#endif
+
+   strcpy(szTitle, DLG_TITLE);
+
+   PrepareToAutoDismissDlg(TRUE);
+
+   if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+     }
+   PrepareToAutoDismissDlg(FALSE);
+   fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test bad lpwszAddressIn ", dwTestCase + 1
+            );
+#else
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">> Test Case %ld: Test bad lpszAddressIn ", dwTestCase + 1
+            );
+#endif
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+    lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX| LNEGOTIATEAPIVERSION 
+            ))
+    {
+        TLINE_FAIL();
+    }
+ 
+   
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAddressIn = wszAddressIn2;
+#else
+   lpTapiLineTestInfo->lpszAddressIn = szAddressIn2;
+#endif
+
+   strcpy(szTitle, DLG_TITLE);
+   PrepareToAutoDismissDlg(TRUE);
+   if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+     }
+   PrepareToAutoDismissDlg(FALSE);
+   fTestPassed = ShowTestCase(fTestPassed);
+
+ 
+	// Shutdown 
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ lineTranslateDialog: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+     TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing lineTranslateDialog  <<<<<<<<"
+            );
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/test1.xls b/private/tapi/qa/trapper/itest/tyline/test1.xls
new file mode 100644
index 000000000..63596f8aa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/test1.xls
diff --git a/private/tapi/qa/trapper/itest/tyline/test2.xls b/private/tapi/qa/trapper/itest/tyline/test2.xls
new file mode 100644
index 000000000..f6fa517de
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/test2.xls
diff --git a/private/tapi/qa/trapper/itest/tyline/tyline.def b/private/tapi/qa/trapper/itest/tyline/tyline.def
new file mode 100644
index 000000000..63a23ee1d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/tyline.def
@@ -0,0 +1,23 @@
+LIBRARY         tyline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+	Test13
diff --git a/private/tapi/qa/trapper/itest/tyline/tyline.inc b/private/tapi/qa/trapper/itest/tyline/tyline.inc
new file mode 100644
index 000000000..f54e3ea21
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/tyline.inc
@@ -0,0 +1,69 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=tyline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\user32.lib 
+
+
+DLLDEF=   ..\tyline.def
+DLLBASE=0x65000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..		
+		
+
+USE_CRTDLL=1
+
+SOURCES=        ..\yline.c \
+		..\itlap.c \
+		..\itlcp.c \
+		..\itlgpl.c  \
+		..\itlrp.c   \
+		..\itlgdt.c \
+		..\itlgc.c \
+		..\itlgtc.c \
+		..\itlta.c \
+		..\itltd.c \
+		..\itlho.c \
+		..\itlgi.c \
+		..\itlgtn.c \
+		..\uline.c \
+		..\yline.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1 
+
+UMTYPE=windows
+
+DLLENTRY=TYLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/tyline/tylinea/makefile b/private/tapi/qa/trapper/itest/tyline/tylinea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/tylinea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tyline/tylinea/sources b/private/tapi/qa/trapper/itest/tyline/tylinea/sources
new file mode 100644
index 000000000..2c78fc8e5
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/tylinea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tyline.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/tyline/tylinew/makefile b/private/tapi/qa/trapper/itest/tyline/tylinew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/tylinew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/tyline/tylinew/sources b/private/tapi/qa/trapper/itest/tyline/tylinew/sources
new file mode 100644
index 000000000..03d911561
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/tylinew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\tyline.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/tyline/uline.c b/private/tapi/qa/trapper/itest/tyline/uline.c
new file mode 100644
index 000000000..f256f7228
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/uline.c
@@ -0,0 +1,254 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "yline.h"
+
+#define DLG_TITLE    "Dialing Properties"
+
+char szApiName[12][48] = 
+		{
+		"lineAddProvider",
+		"lineConfigProvider",
+		"lineGenerateDigits",
+		"lineGenerateTone",
+ 		"lineGetCountry",
+  		"lineGetIcon",
+		"lineGetProviderList",
+		"lineGetTranslateCaps",
+		"lineRemoveProvider",
+		"lineTranslateAddress",
+		"lineTranslateDialog",
+		"lineHandoff"
+	};		
+
+
+BOOL TestLineUninitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->hwndOwner = (HWND)NULL;
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+    lpTapiLineTestInfo->lpwszProviderFilename = L"esp32.tsp";
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+    lpTapiLineTestInfo->lpszProviderFilename = "esp32.tsp";
+#endif
+    lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+ 
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 12; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+/*
+          if (! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+*/
+          break;
+
+        case 1:       
+         /*
+         lpTapiLineTestInfo->dwPermanentProviderID = 2;
+	      if (! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          */
+          break;
+
+        case 2: 
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+          lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	       lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+          if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+	       lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+		           BIGBUFSIZE);
+        	 lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = BIGBUFSIZE;
+          if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+          if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 6:       
+ 	       lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+		          sizeof(LINEPROVIDERLIST));
+	       lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+          if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 7:       
+	       lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+		          sizeof(LINETRANSLATECAPS));
+	       lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+          if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:     
+/*
+          if (! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+*/
+          break;
+
+        case 9: 
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+	       lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+	       lpTapiLineTestInfo->dwCard = 0; // get from GetTranslateCaps
+	       lpTapiLineTestInfo->dwTranslateOptions = LINETRANSLATEOPTION_CANCELCALLWAITING;
+	       lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+		        sizeof(LINETRANSLATEOUTPUT));
+          lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = sizeof(LINETRANSLATEOUTPUT);
+          if (! DoLineTranslateAddress(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 10:      
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+	       lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+          strcpy(szTitle, DLG_TITLE);
+	       PrepareToAutoDismissDlg(TRUE);
+          if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+	       PrepareToAutoDismissDlg(FALSE);
+          break;
+
+        case 11:      
+          if (! DoLineHandoff(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/yline.c b/private/tapi/qa/trapper/itest/tyline/yline.c
new file mode 100644
index 000000000..6916978f1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/yline.c
@@ -0,0 +1,316 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    yline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	26-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "yline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghTYLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+TYLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghTYLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUninitialize(TRUE, TRUE));
+}
+
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigProvider(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetProviderList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGenerateDigits(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetCountry(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetTranslateCaps(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTranslateAddress(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTranslateDialog(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetIcon(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGenerateTone(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAddProvider(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRemoveProvider(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineHandoff(TRUE, FALSE));
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/tyline/yline.def b/private/tapi/qa/trapper/itest/tyline/yline.def
new file mode 100644
index 000000000..63a23ee1d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/yline.def
@@ -0,0 +1,23 @@
+LIBRARY         tyline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+	Test13
diff --git a/private/tapi/qa/trapper/itest/tyline/yline.h b/private/tapi/qa/trapper/itest/tyline/yline.h
new file mode 100644
index 000000000..ff2e8cbfb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/yline.h
@@ -0,0 +1,181 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    yline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef YLINE_H
+#define YLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+BOOL
+TestLineUninitialize(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineAddProvider(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineConfigProvider(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGenerateDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetCountry(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetProviderList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetTranslateCaps(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRemoveProvider(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineTranslateAddress(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineTranslateDialog(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+BOOL
+TestLineGetIcon(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGenerateTone(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineHandoff(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+#endif  // YLINE_H
diff --git a/private/tapi/qa/trapper/itest/tyline/yline.rc b/private/tapi/qa/trapper/itest/tyline/yline.rc
new file mode 100644
index 000000000..6b9fbeb74
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/tyline/yline.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI TYLine API test Library"
+#define VER_INTERNALNAME_STR        "tyline.dll"
+#define VER_ORIGINALFILENAME_STR    "tyline.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/uline/dirs b/private/tapi/qa/trapper/itest/uline/dirs
new file mode 100644
index 000000000..05d578aad
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/dirs
@@ -0,0 +1,3 @@
+DIRS= ulinea\
+      ulinew
+
diff --git a/private/tapi/qa/trapper/itest/uline/uline.c b/private/tapi/qa/trapper/itest/uline/uline.c
new file mode 100644
index 000000000..66e5d5b1b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/uline.c
@@ -0,0 +1,247 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.c
+
+Abstract:
+
+    This module contains functions for testing line uninitialize.
+	Collected all uline.c tests from Line/TLine, TCLine, TILine, TLine20,
+	TSLine, TXLine, and TYLine.  Does NOT include uline.c from TPhone tests
+	because those are just go/no-go tests.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+	Javed Rasool (JavedR)		3-Jul-1996	Created
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "uline.h"  //javedr
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghUlineDll    = NULL;  //javedr
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+UlineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghUlineDll = hDLL;  //javedr
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTLineUninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTCLineUninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTILineUninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTLine20Uninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTSLineUninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTXLineUninit(TRUE, TRUE));
+}
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTYLineUninit(TRUE, TRUE));
+}
+
diff --git a/private/tapi/qa/trapper/itest/uline/uline.def b/private/tapi/qa/trapper/itest/uline/uline.def
new file mode 100644
index 000000000..325903687
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/uline.def
@@ -0,0 +1,17 @@
+LIBRARY         uline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+		Test5
+		Test6
+		Test7
diff --git a/private/tapi/qa/trapper/itest/uline/uline.h b/private/tapi/qa/trapper/itest/uline/uline.h
new file mode 100644
index 000000000..d6648d2ed
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/uline.h
@@ -0,0 +1,187 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    uline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device
+	uninitialize functions.
+
+Author:
+
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+
+	Javed Rasool (JavedR)		2-Jul-1996		Created
+
+--*/
+
+
+#ifndef ULINE_H
+#define ULINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+/***********************************/
+BOOL
+TestTLineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTCLineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTILineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTLine20Uninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTSLineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTXLineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTYLineUninit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+/***********************************/
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    );
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    );
+
+
+#endif  // ULINE_H
diff --git a/private/tapi/qa/trapper/itest/uline/uline.inc b/private/tapi/qa/trapper/itest/uline/uline.inc
new file mode 100644
index 000000000..bf2c9f643
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/uline.inc
@@ -0,0 +1,65 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    uline.inc - included by sources file
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+        Javed Rasool (JavedR)   3-Jul-1996              Created
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=uline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+                   $(BASEDIR)\public\sdk\lib\*\user32.lib
+
+
+DLLDEF=..\uline.def
+DLLBASE=0x66000000
+
+INCLUDES=..;..\..;..\..\..\..\tcore;..\..\..
+
+USE_CRTDLL=1
+
+SOURCES=..\uline.c \
+        ..\utline.c  \
+        ..\utcline.c \
+        ..\utiline.c \
+        ..\utline20.c \
+        ..\utsline.c \
+        ..\utxline.c \
+        ..\utyline.c \
+        ..\uline.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+
+UMTYPE=windows
+
+DLLENTRY=UlineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/uline/uline.rc b/private/tapi/qa/trapper/itest/uline/uline.rc
new file mode 100644
index 000000000..420f96b38
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/uline.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI Line 2.0 API test Library"
+#define VER_INTERNALNAME_STR        "tline20.dll"
+#define VER_ORIGINALFILENAME_STR    "tline20.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/uline/ulinea/makefile b/private/tapi/qa/trapper/itest/uline/ulinea/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/ulinea/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/uline/ulinea/sources b/private/tapi/qa/trapper/itest/uline/ulinea/sources
new file mode 100644
index 000000000..264de74df
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/ulinea/sources
@@ -0,0 +1,35 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\uline.inc
+
+TARGETPATH=$(TARGETPATH)
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES)
diff --git a/private/tapi/qa/trapper/itest/uline/ulinew/makefile b/private/tapi/qa/trapper/itest/uline/ulinew/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/ulinew/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/uline/ulinew/sources b/private/tapi/qa/trapper/itest/uline/ulinew/sources
new file mode 100644
index 000000000..a22ff05f9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/ulinew/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+!include ..\uline.inc
+
+
+TARGETPATH=$(TARGETPATH)\unicode
+
+TARGETLIBS=$(TARGETLIBS) \
+           $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+C_DEFINES=$(C_DEFINES) -DWUNICODE=1
diff --git a/private/tapi/qa/trapper/itest/uline/utcline.c b/private/tapi/qa/trapper/itest/uline/utcline.c
new file mode 100644
index 000000000..53d23b04a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utcline.c
@@ -0,0 +1,188 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utcline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+  Javed Rasool (JavedR)	3-Jul-1996	Created
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "uline.h"  //was "cline.h"  --- javedr
+
+
+BOOL TestTCLineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+	char szApiName[9][48] = 
+	{
+		"lineAddToConference",
+		"lineCompleteCall",
+		"lineGetConfRelatedCalls",
+		"linePrepareAddToConference",
+ 		"lineRedirect",
+  		"lineRemoveFromConference",
+		"lineSecureCall",
+		"lineSetupConference",
+		"lineSwapHold"
+	};
+	LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+	
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_DETAIL,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+	 lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+        sizeof(LINECALLLIST));
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  "55555";
+#endif
+
+     
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 9; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+          if (! DoLineAddToConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 1:       
+	      if (! DoLineCompleteCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 2:       
+          if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+          if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+          if (! DoLineRemoveFromConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 6:       
+          if (! DoLineSecureCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 7:       
+          if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:     
+          if (! DoLineSwapHold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/uline/utiline.c b/private/tapi/qa/trapper/itest/uline/utiline.c
new file mode 100644
index 000000000..e8650715b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utiline.c
@@ -0,0 +1,215 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utiline.c
+
+Abstract:
+
+    This module contains the uninitialized testcases for all the iline apis
+
+Author:
+
+	Xiao Ying Ding (XiaoD)	3-4-96
+
+Revision History:
+
+    Rama Koneru (a-ramako)	4-Mar-1996  modified this for the ILINE set of APIs
+	Javed Rasool (JavedR)	3-Jul-1996	Created as independent Uninitialize test.
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "uline.h" //was "iline.h" --- javedr
+
+
+BOOL TestTILineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+	char szApiName[12][48] =
+	{
+		"lineAccept",
+		"lineAnswer",
+		"lineBlindTransfer",
+		"lineCompleteTransfer",
+		"lineForward",
+		"lineReleaseUserUserInfo",
+		"lineSendUserUserInfo",
+		"lineNegotiateExtVersion",
+		"lineSetupTransfer",
+		"lineHold",
+		"lineSetAppSpecific",
+		"lineUnhold"
+	};
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  = (DWORD) GetCallbackParams();
+
+	//
+    // Allocate more than enough to store a call handle
+	//
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  Begin testing Uninitialized Cases  <<<<<<<<"
+	    );
+
+    lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+        sizeof(LINECALLLIST));
+    lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+    lpTapiLineTestInfo->lpszDestAddress  =  "55555";
+#endif
+
+	//
+    // Test for UNINITIALIZED if this is the only TAPI app running
+	//
+
+    if (fStandAlone)
+    {
+        for(n = 0; n < 12; n++)
+        {
+            strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+	
+            TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized %s",
+                dwTestCase + 1, szApiName[n]);
+
+            switch (n)
+            {
+            case 0:
+	            if (! DoLineAnswer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 1:
+	            if (! DoLineAccept(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 2:
+	            if (! DoLineBlindTransfer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 3:
+	            if (! DoLineCompleteTransfer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+                break;
+
+
+	        case 4:
+	            if (! DoLineForward(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 5:
+	            if (! DoLineReleaseUserUserInfo(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 6:
+	            if (! DoLineSendUserUserInfo(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 7:
+	            if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 8:
+	            if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 9:
+	            if (! DoLineHold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 10:
+	            if (! DoLineSetAppSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+
+	        case 11:
+	            if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+	            {
+	                TLINE_FAIL();
+	            }
+	            break;
+            }
+
+            fTestPassed = ShowTestCase(fTestPassed);
+        }
+
+    }
+
+
+    FreeTestHeap();
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    TapiLogDetail(
+	    DBUG_SHOW_PASS,
+	    ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+	    );
+	
+    return fTestPassed;
+}
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/uline/utline.c b/private/tapi/qa/trapper/itest/uline/utline.c
new file mode 100644
index 000000000..ffc05d1e8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utline.c
@@ -0,0 +1,387 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+	Javed Rasool (JavedR)	3-Jul-1996	Created
+
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "uline.h"  //was "tline.h" --- javedr
+
+#define DWNUMCALLS 1
+
+// Macro for handling unexpected failures during the tests
+#define ITLC_FAIL()    {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                       }
+
+
+BOOL TestTLineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    char szApiName[23][48] = 
+	{
+		"lineClose",
+		"lineDeallocateCall",
+		"lineDial",
+		"lineDrop",
+ 		"lineGetAddressCaps",
+  		"lineGetAddressID",
+		"lineGetAddressStatus",
+		"lineGetCallInfo",
+		"lineGetCallStatus",
+		"lineGetDevCaps",
+		"lineGetID",
+		"lineGetLineDevStatus",
+		"lineGetNewCalls",
+		"lineGetNumRings",
+		"lineGetProviderList",
+		"lineGetStatusMessage",
+//		"lineHold",
+		"lineMakeCall",
+		"lineNegotiateAPIVersion",
+		"lineOpen",
+//		"lineSetAppSpecific",
+		"lineSetCallPrivilege",
+		"lineSetNumRings",
+		"lineSetStatusMessages",
+		"lineShutdown",
+//		"lineUnhold"
+	};
+	LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+	InitTestNumber();
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+    lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 23; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+          if (! DoLineClose(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 1:       
+          if (! DoLineDeallocateCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 2: 
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+          lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+          if (! DoLineDial(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineDrop(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 4:       
+		    lpTapiLineTestInfo->lpLineAddressCaps = (LPLINEADDRESSCAPS) AllocFromTestHeap(
+      		      sizeof(LINEADDRESSCAPS));
+		    lpTapiLineTestInfo->lpLineAddressCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+          if (! DoLineGetAddressCaps(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 5:
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwsAddress = L"55555";
+#else
+          lpTapiLineTestInfo->lpsAddress = "55555";
+#endif
+          lpTapiLineTestInfo->dwAddressMode = LINEADDRESSMODE_DIALABLEADDR;
+          lpTapiLineTestInfo->dwSize = 16;
+          if (! DoLineGetAddressID(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 6:       
+          lpTapiLineTestInfo->lpLineAddressStatus = (LPLINEADDRESSSTATUS) AllocFromTestHeap (
+						sizeof(LINEADDRESSSTATUS));
+          lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = sizeof(LINEADDRESSSTATUS);
+          if (! DoLineGetAddressStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 7:       
+          lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap (
+  			          sizeof(LINECALLINFO));
+          lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+          if (! DoLineGetCallInfo(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 8:       
+          if (! DoLineGetCallStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 9:       
+ 			 lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+													  sizeof (LINEDEVCAPS));
+		    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+          if (! DoLineGetDevCaps(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 10:      
+			 lpTapiLineTestInfo->lpDeviceID = (LPVARSTRING)AllocFromTestHeap(
+   						sizeof(VARSTRING));
+          lpTapiLineTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+          lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+          if (! DoLineGetID(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 11:      
+          lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap (
+							sizeof(LINEDEVSTATUS));
+	       lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS); 
+          if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 12:      
+			 lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap(
+         		   sizeof(LINECALLLIST) + (DWNUMCALLS) * sizeof(HCALL) + 8
+		            );
+			 lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST) +
+         	   (DWNUMCALLS) * sizeof(HCALL) + 8;
+          if (! DoLineGetNewCalls(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 13:       
+          if (! DoLineGetNumRings(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 14:      
+          lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap (
+                sizeof(LINEPROVIDERLIST));
+          lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST); 
+          lpTapiLineTestInfo->dwAPIVersion = 0x20000;
+          if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 15:       
+          if (! DoLineGetStatusMessages(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        /*
+        case 16:       
+          if (! DoLineHold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+        */
+
+        case 16:       
+          if (! DoLineMakeCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 17:       
+          if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 18:       
+          if (! DoLineOpen(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        /*
+        case 20:       
+          if (! DoLineSetAppSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+	      */
+     
+        case 19:      
+ 			 lpTapiLineTestInfo->dwCallPrivilege = LINECALLPRIVILEGE_OWNER;
+          if (! DoLineSetCallPrivilege(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 20:       
+          if (! DoLineSetNumRings(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 21:       
+          if (! DoLineSetStatusMessages(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        case 22:       
+          if (! DoLineShutdown(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            ITLC_FAIL();
+          }
+          break;
+
+        /*
+        case 25:       
+          if (! DoLineUnhold(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            ITLC_FAIL();
+          }
+          break;
+         */
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/uline/utline20.c b/private/tapi/qa/trapper/itest/uline/utline20.c
new file mode 100644
index 000000000..4970949b1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utline20.c
@@ -0,0 +1,433 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utline20.c
+
+Abstract:
+
+    This module contains the test functions for line20 Uninitialize
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+	Javed Rasool (JavedR)		3-Jul-1996		Created as independent uninitialize tests
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "uline.h" //was line20.h  --- javedr
+
+//
+// UnInitialize tests
+//
+
+BOOL TestTLine20Uninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    INT i;
+    BOOL fTestPassed                  = TRUE;
+
+    dwTestCasePassed = 0;
+    dwTestCaseFailed = 0;
+    dwTestCase = 0;
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        "\n***************************************************************");
+
+    OutputTAPIDebugInfo(
+        DBUG_SHOW_PASS,
+        ">> Test lineUninitialize");
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 1. Test Case: lineAgentSpecific uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: lineAgentSpecific uninit test",
+        dwTestCase+1);
+
+    if (! DoLineAgentSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 2. Test Case: LineGetAgentActivityList uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentActivityList uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST)
+                       AllocFromTestHeap(sizeof(LINEAGENTACTIVITYLIST));
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize =
+        sizeof(LINEAGENTACTIVITYLIST);
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 3. Test Case: LineGetAgentCaps uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentCaps uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lpAgentCaps = (LPLINEAGENTCAPS) AllocFromTestHeap(
+            sizeof(LINEAGENTCAPS)
+            );
+    lpTapiLineTestInfo->lpAgentCaps->dwTotalSize = sizeof(LINEAGENTCAPS);
+    lpTapiLineTestInfo->dwAppAPIVersion = TAPI_VERSION2_0;
+
+    if (! DoLineGetAgentCaps(lpTapiLineTestInfo,
+                             LINEERR_UNINITIALIZED,
+                             FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 4. Test Case: LineGetAgentGroupList uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentGroupList uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList =
+        (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize =
+        sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineGetAgentGroupList(lpTapiLineTestInfo,
+                                  LINEERR_UNINITIALIZED,
+                                  FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 5. Test Case: LineGetAgentStatus uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetAgentStatus uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->lpAgentStatus = (LPLINEAGENTSTATUS) AllocFromTestHeap(
+            sizeof(LINEAGENTSTATUS)
+            );
+    lpTapiLineTestInfo->lpAgentStatus->dwTotalSize = sizeof(LINEAGENTSTATUS);
+
+    if (! DoLineGetAgentStatus(lpTapiLineTestInfo,
+                               LINEERR_UNINITIALIZED,
+                               FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 6. Test Case: LineGetMessage uninit test(returns INVALAPPHANDLE).
+    //               see raid bug #33177(4/10/1996)
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineGetMessage uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->lpMessage = (LPLINEMESSAGE) AllocFromTestHeap (
+        sizeof(LINEMESSAGE));
+
+    if (! DoLineGetMessage(lpTapiLineTestInfo, LINEERR_INVALAPPHANDLE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 7. Test Case: LineProxyMessage uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineProxyMessage uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwMsg = LINE_AGENTSTATUS;
+    lpTapiLineTestInfo->dwParam1 = 0;
+    lpTapiLineTestInfo->dwParam2 = LINEAGENTSTATUS_ACTIVITY;
+    lpTapiLineTestInfo->dwParam3 = 0;
+
+    if (! DoLineProxyMessage(lpTapiLineTestInfo,
+                             LINEERR_UNINITIALIZED))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 8. Test Case: LineProxyResponse uninit test(returns INVALPOINTER).
+    //               see raid bug #33177(4/10/1996)
+    //
+    // ===================================================================
+    // ===================================================================
+    
+/*
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineProxyResponse uninit test",
+        dwTestCase+1);
+    lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) AllocFromTestHeap(
+        sizeof(LINEPROXYREQUEST));
+    lpTapiLineTestInfo->lpProxyRequest->dwSize =  sizeof(LINEPROXYREQUEST);
+    if (! DoLineProxyResponse(lpTapiLineTestInfo,
+                              LINEERR_INVALPOINTER))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+*/
+    
+    // ===================================================================
+    // ===================================================================
+    //
+    // 9. Test Case: LineSetAgentActivity uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+    
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineSetAgentActivity uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+    lpTapiLineTestInfo->dwActivityID = 1;
+
+    if (! DoLineSetAgentActivity(lpTapiLineTestInfo,
+                                 LINEERR_UNINITIALIZED,
+                                 FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+    // ===================================================================
+    // ===================================================================
+    //
+    // 10. Test Case: LineSetAgentGroup uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineSetAgentGroup uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentGroupList = (LPLINEAGENTGROUPLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTGROUPLIST)
+            );
+    lpTapiLineTestInfo->lpAgentGroupList->dwTotalSize = sizeof(LINEAGENTGROUPLIST);
+
+    if (! DoLineSetAgentGroup(lpTapiLineTestInfo,
+                              LINEERR_UNINITIALIZED,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    // ===================================================================
+    // ===================================================================
+    //
+    // 11. Test Case: LineSetAgentState uninit test.
+    //
+    // ===================================================================
+    // ===================================================================
+
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    fTestPassed = TRUE;
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "#### Test Case %ld: LineSetAgentState uninit test",
+        dwTestCase+1);
+
+    lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->dwAgentState = LINEAGENTSTATE_READY;
+    lpTapiLineTestInfo->dwNextAgentState = LINEAGENTSTATE_READY;
+
+    if (! DoLineSetAgentState(lpTapiLineTestInfo,
+                              LINEERR_UNINITIALIZED,
+                              FALSE))
+    {
+        TLINE_FAIL();
+    }
+
+    fTestPassed = ShowTestCase(fTestPassed);
+
+    FreeTestHeap();
+
+    //
+    // +----------------------edit above this line-------------------------
+    //
+
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ LineUnitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+        dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+    TapiLogDetail(
+        DBUG_SHOW_PASS,
+        ">>>>>>>>  End testing LineUnitialize  <<<<<<<<");
+
+    if(dwTestCaseFailed > 0)
+        fTestPassed = FALSE;
+
+    return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/uline/utsline.c b/private/tapi/qa/trapper/itest/uline/utsline.c
new file mode 100644
index 000000000..16614f7ba
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utsline.c
@@ -0,0 +1,277 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utsline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+  Javed Rasool (javedr)		3-Jul-1996		Created
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "uline.h"  //was sline.h  --- javedr
+
+
+BOOL TestTSLineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    char szApiName[15][48] = 
+	{
+		"lineGetAppPriority",
+		"lineGatherDigits",
+		"lineMonitorDigits",
+		"lineMonitorMedia",
+ 		"lineMonitorTones",
+  		"linePark",
+		"lineSetAppPriority",
+		"linePickup",
+		"lineUncompleteCall",
+		"lineSetCurrentLocation",
+		"lineSetCallData",
+		"lineSetCallQualityOfService",
+		"lineSetCallTreatment",
+		"lineSetLineDevStatus",
+		"lineUnpark"
+	};
+	LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+     
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 15; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_PASS,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:   
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+          lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+          lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+          lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			       sizeof(LINEEXTENSIONID));
+          lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+          lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			       sizeof(VARSTRING));
+	       lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	       lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+          if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+			 FreeTestHeap();
+          break;
+
+        case 1:       
+	      if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 2:       
+          if (! DoLineMonitorDigits(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineMonitorMedia(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+          if (! DoLineMonitorTones(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+	       lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszDirAddress = L"55555";
+#else
+	       lpTapiLineTestInfo->lpszDirAddress = "55555";
+#endif
+	       lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap (
+		       sizeof(VARSTRING));
+	       lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+#else
+	       lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+#endif
+          if (! DoLinePark(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+			 FreeTestHeap();
+          break;
+
+        case 6:       
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+          lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+          lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+          lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			       sizeof(LINEEXTENSIONID));
+          lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+          lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			       sizeof(VARSTRING));
+	       lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	       lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+           if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          FreeTestHeap();
+          break;
+
+        case 7:       
+          if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:     
+          if (! DoLineUncompleteCall(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 9:     
+          lpTapiLineTestInfo->dwLocation = 1;
+          if (! DoLineSetCurrentLocation(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 10:     
+          if (! DoLineSetCallData(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 11:     
+          if (! DoLineSetCallQualityOfService(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 12:     
+          if (! DoLineSetCallTreatment(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 13:     
+          if (! DoLineSetLineDevStatus(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 14:     
+          lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hCall1;
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDestAddress  = L"55555";
+#else
+          lpTapiLineTestInfo->lpszDestAddress  = "55555";
+#endif
+          if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+//     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/uline/utxline.c b/private/tapi/qa/trapper/itest/uline/utxline.c
new file mode 100644
index 000000000..4dd61cf27
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utxline.c
@@ -0,0 +1,242 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utxline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+	Javed Rasool (JavedR)	3-Jul-1996	Created
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "uline.h"  //was xline.h --- javedr
+
+
+BOOL TestTXLineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    char szApiName[13][48] = 
+	{
+		"lineConfigDialog",
+		"lineConfigDialogEdit",
+		"lineDevSpecific",
+		"lineDevSpecificFeature",
+ 		"lineGetDevConfig",
+  		"lineGetRequest",
+		"lineRegisterRequestRecipient",
+		"lineSetCallParams",
+		"lineSetDevConfig",
+		"lineSetMediaControl",
+		"lineSetMediaMode",
+		"lineSetTerminal",
+		"lineSetTollList"
+	};
+	LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->hwndOwner = (HWND)NULL;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+  	 lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			       sizeof(VARSTRING)
+         			);
+    lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+    lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+ 
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 13; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+          if (! DoLineConfigDialog(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 1:       
+	      lpTapiLineTestInfo->lpDeviceConfigIn = 
+ 			      (LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+	      lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+         		sizeof(VARSTRING)
+	          	);
+	      lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+	      if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 2:       
+          if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+          if (! DoLineGetDevConfig(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+	       lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		          sizeof(LINEREQMAKECALL)
+		           );
+
+          if (! DoLineGetRequest(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 6:       
+          if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 7:       
+          if (! DoLineSetCallParams(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:       
+          if (! DoLineSetDevConfig(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 9:       
+	       lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+          if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 10:      
+	       lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+          if (! DoLineSetMediaMode(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 11:      
+	       lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;	
+	       lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+          if (! DoLineSetTerminal(lpTapiLineTestInfo, LINEERR_UNINITIALIZED, TRUE))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 12:
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszAddressIn = L"+1 (206) 936-4738";
+#else
+	       lpTapiLineTestInfo->lpszAddressIn = "+1 (206) 936-4738";
+#endif
+	       lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_ADD;
+          if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/uline/utyline.c b/private/tapi/qa/trapper/itest/uline/utyline.c
new file mode 100644
index 000000000..feef8a344
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/uline/utyline.c
@@ -0,0 +1,255 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    utyline.c
+
+Abstract:
+
+    This module contains the test functions for all apis uninitialize test
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 3-5-96
+
+Revision History:
+
+	Javed Rasool (JavedR)	3-Jul-1996	Created
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "ttest.h"
+#include "doline.h"
+#include "uline.h"  //was yline.h  --- javedr
+
+#define DLG_TITLE    "Dialing Properties"
+
+
+BOOL TestTYLineUninit(BOOL fQuietMode, BOOL fStandAlone)
+{
+    char szApiName[12][48] = 
+	{
+		"lineAddProvider",
+		"lineConfigProvider",
+		"lineGenerateDigits",
+		"lineGenerateTone",
+ 		"lineGetCountry",
+  		"lineGetIcon",
+		"lineGetProviderList",
+		"lineGetTranslateCaps",
+		"lineRemoveProvider",
+		"lineTranslateAddress",
+		"lineTranslateDialog",
+		"lineHandoff"
+	};
+	LPTAPILINETESTINFO  lpTapiLineTestInfo;
+    LPCALLBACKPARAMS    lpCallbackParams;
+    BOOL fTestPassed  = TRUE;
+    INT n;
+
+    InitTestNumber();
+    TapiLineTestInit();
+    lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+    lpTapiLineTestInfo->dwCallbackInstance  =
+                      (DWORD) GetCallbackParams();
+
+     
+    // Allocate more than enough to store a call handle
+   
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  Begin testing line uninitialize  <<<<<<<<"
+            );
+
+    lpTapiLineTestInfo->hwndOwner = (HWND)NULL;
+    lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+#ifdef WUNICODE
+    lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+    lpTapiLineTestInfo->lpwszProviderFilename = L"esp32.tsp";
+#else
+    lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+    lpTapiLineTestInfo->lpszProviderFilename = "esp32.tsp";
+#endif
+    lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+ 
+    // Test for UNINITIALIZED if this is the only TAPI app running
+    if (fStandAlone)
+    {
+     for(n = 0; n< 12; n++)
+    {
+     strcpy(lpTapiLineTestInfo->szTestFunc, szApiName[n]);
+            
+       TapiLogDetail(
+                DBUG_SHOW_DETAIL,
+                ">> Test Case %ld: Uninitialized %s", 
+                    dwTestCase + 1, szApiName[n]);
+
+        switch (n)
+        {
+        case 0:       
+/*
+          if (! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+*/
+          break;
+
+        case 1:       
+         /*
+         lpTapiLineTestInfo->dwPermanentProviderID = 2;
+	      if (! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          */
+          break;
+
+        case 2: 
+#ifdef WUNICODE
+          lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+          lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+	       lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+          if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 3:       
+          if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 4:       
+	       lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+		           BIGBUFSIZE);
+        	 lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = BIGBUFSIZE;
+          if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 5:       
+          if (! DoLineGetIcon(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 6:       
+ 	       lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+		          sizeof(LINEPROVIDERLIST));
+	       lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+          if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 7:       
+	       lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+		          sizeof(LINETRANSLATECAPS));
+	       lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+          if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 8:     
+/*
+          if (! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+*/
+          break;
+
+        case 9: 
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+	       lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+	       lpTapiLineTestInfo->dwCard = 0; // get from GetTranslateCaps
+	       lpTapiLineTestInfo->dwTranslateOptions = LINETRANSLATEOPTION_CANCELCALLWAITING;
+	       lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+		        sizeof(LINETRANSLATEOUTPUT));
+          lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = sizeof(LINETRANSLATEOUTPUT);
+          if (! DoLineTranslateAddress(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+        case 10:      
+#ifdef WUNICODE
+	       lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+	       lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+          strcpy(szTitle, DLG_TITLE);
+	       PrepareToAutoDismissDlg(TRUE);
+          if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+          {
+            TLINE_FAIL();
+          }
+	       PrepareToAutoDismissDlg(FALSE);
+          break;
+
+        case 11:      
+          if (! DoLineHandoff(lpTapiLineTestInfo, LINEERR_UNINITIALIZED))
+          {
+            TLINE_FAIL();
+          }
+          break;
+
+       }
+
+     fTestPassed = ShowTestCase(fTestPassed);
+	  }
+ 
+    }
+
+
+     FreeTestHeap();
+
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ line Uninitialize: Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwTestCase, dwTestCasePassed, dwTestCaseFailed);
+	 TapiLogDetail(
+      DBUG_SHOW_PASS,
+      "@@ Total Test Case = %ld, Passed = %ld, Failed = %ld",
+      dwglTestCase, dwglTestCasePassed, dwglTestCaseFailed);
+     if(dwTestCaseFailed > 0)
+      fTestPassed = FALSE;
+
+    TapiLogDetail(
+            DBUG_SHOW_PASS,
+            ">>>>>>>>  End testing line Uninitialize  <<<<<<<<"
+            );
+            
+    return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/version.rc b/private/tapi/qa/trapper/itest/version.rc
new file mode 100644
index 000000000..1223b4073
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/version.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI main test Library"
+#define VER_INTERNALNAME_STR        "ttest.dll"
+#define VER_ORIGINALFILENAME_STR    "ttest.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/wline/makefile b/private/tapi/qa/trapper/itest/wline/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/wline/readme.txt b/private/tapi/qa/trapper/itest/wline/readme.txt
new file mode 100644
index 000000000..80c05081f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/readme.txt
@@ -0,0 +1,64 @@
+UNICODE changes for go/no-go tests have been 
+completed for the following LINE APIs:
+
+lineAddProviderW
+lineBlindTransferW
+lineConfigDialogW
+lineConfigDialogEditW
+lineForwardW
+lineGatherDigitsW
+lineGenerateDigitsW
+lineGetAppPriorityW
+lineGetCountryW
+lineGetDevConfigW
+lineGetIconW
+lineGetIDW
+lineGetRequestW
+lineGetTranslateCapsW
+lineHandoffW
+lineInitializeExW
+lineParkW
+linePickupW
+linePrepareAddToConferenceW
+lineRedirectW
+lineSetAppPriorityW
+lineSetDevConfigW
+lineSetTollListW
+lineSetupConferenceW
+lineSetupTransferW
+lineTranslateAddressW
+lineTranslateDialogW
+lineUnparkW
+lineGetAgentActivityListW
+tapiGetLocationInfoW
+tapiRequestMakeCallW
+tapiRequestMediaCallW
+
+These go/no-go UNICODE tests are identical to 
+the corresponding ASCII go/no-go tests
+except that they can handle wide chars.
+
+The UNICODE go/no-go tests for TLINE APIs have 
+not been done (as per Xiao's suggestion). 
+
+The addition of the UNICODE modifications will not 
+affect any of the normal functions. You will still
+be able to build normally from the sources tree and
+run tests. TRAPPER.INI has been updated to include 
+the new suite of WLINE tests. To test for this suite
+though, you'd have to have a new TCORE.DLL built with 
+the WUNICODE flag.
+
+(1) Set the "-DWUNICODE=1" flag in the sources 
+file in the tcore directory and build the DLL. The
+WLINE directory would have the sources file with the 
+WUNICODE set by default. Build WLINE.DLL.
+
+NOTE: The flag is WUNICODE and not just UNICODE 
+
+(2) Start Trapper.EXE and test only those functions
+in the WLINE set - NOTE: the XLINE/YLINE etc functions 
+that have UNICODE versions would not work with the new 
+TCORE.DLL. All other XLINE/YLINE functions that donot 
+have a W version should work fine.
+
diff --git a/private/tapi/qa/trapper/itest/wline/sources b/private/tapi/qa/trapper/itest/wline/sources
new file mode 100644
index 000000000..3392174cc
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/sources
@@ -0,0 +1,89 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=wline
+TARGETPATH=$(BASEDIR)\public\sdk\lib\unicode
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\user32.lib \
+	   $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+	   $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+	   $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x66000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+
+
+USE_CRTDLL=1
+
+SOURCES=wline.c \
+witlcd.c \
+witlcde.c \
+witlfw.c \
+witlgad.c \
+witlgap.c \
+witlgc.c \
+witlgdcf.c \
+witlgdt.c \
+witlgi.c \
+witlgr.c \
+witlgtc.c \
+witlho.c \
+witlie.c \
+witlpak.c \
+witlpatc.c \
+witlpk.c \
+witlrd.c \
+witlsap.c \
+witlsdcf.c \
+witlst.c \
+witlstl.c \
+witlsuc.c \
+witltd.c \
+witlta.c \
+witlupak.c \
+wittrmc.c \
+wittgli.c \
+witlgaal.c \
+witlap.c \
+witlbt.c \
+wittrmec.c \
+version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1 -DWUNICODE=1
+
+UMTYPE=windows
+
+DLLENTRY=WLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/wline/version.rc b/private/tapi/qa/trapper/itest/wline/version.rc
new file mode 100644
index 000000000..a2512ceee
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/version.rc
@@ -0,0 +1,11 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI Phone API test Library"
+#define VER_INTERNALNAME_STR        "wline.dll"
+#define VER_ORIGINALFILENAME_STR    "wline.dll"
+
+#include "common.ver"
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlap.c b/private/tapi/qa/trapper/itest/wline/witlap.c
new file mode 100644
index 000000000..ffe6591e9
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlap.c
@@ -0,0 +1,246 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    witlap.c
+
+Abstract:
+
+    This module contains the test functions for lineAddProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/21/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+#define DLG_TITLE            "ESP32.TSP"
+
+
+
+//  lineAddProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAddProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed    = TRUE;
+   BOOL fEsp;
+	BOOL fUnimdm;
+#ifdef WUNICODE
+   WCHAR wszEspProviderFilename[] = L"esp32.tsp";
+   WCHAR wszUnimdmProviderFilename[] = L"unimdm.tsp";
+#else
+   CHAR szEspProviderFilename[] = "esp32.tsp";
+   CHAR szUnimdmProviderFilename[] = "unimdm.tsp";
+#endif
+   DWORD dwNumProviders;
+   BOOL  fAddProvider;
+ 
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+   OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"Test lineAddProvider");
+	
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+      BUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+ 
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineAddProvider");
+
+/*
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszProviderFilename = L"esp32.tsp";
+#else
+	lpTapiLineTestInfo->lpszProviderFilename = "esp32.tsp";
+#endif
+*/
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+
+	if(FindESPLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = TRUE;
+   fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+     }
+	else if(FindUnimdmLineDevice(lpTapiLineTestInfo))
+     {
+     fEsp = FALSE;
+     fUnimdm = TRUE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+   else
+     {
+     fEsp = FALSE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+	
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+	else
+	{
+        fAddProvider = TRUE;
+	}
+
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+   if(fAddProvider)
+	{
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   PrepareToAutoDismissDlg(FALSE);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+	}
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineAddProvider Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineAddProvider Test Failed");
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/wline/witlbt.c b/private/tapi/qa/trapper/itest/wline/witlbt.c
new file mode 100644
index 000000000..497539eef
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlbt.c
@@ -0,0 +1,189 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    witlbt.c
+
+Abstract:
+
+    This module contains the test functions for lineBlindTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/21/96		Modified for WUNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineBlindTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineBlindTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed    = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineBlindTransfer");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+#ifdef WUNICODE			
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineBlindTransfer for go/no-go");
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineBlindTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineBlindTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineBlindTransfer Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineBlindTransfer Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlcd.c b/private/tapi/qa/trapper/itest/wline/witlcd.c
new file mode 100644
index 000000000..ac08866a4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlcd.c
@@ -0,0 +1,154 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    witlcd.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_lineConfigDialog"
+#define DLG_TITLE_UNIMDM     "Zoom VFX 28.8 Properties"
+
+
+//  lineConfigDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineConfigDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed    = TRUE;
+   HWND hwndOwner, hwndActive;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test LineConfigDialog");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test LineConfigDialog for go/no-go");
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+#ifdef WUNICODE
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwDeviceID = %lx, lpwszDeviceClass = %ws",
+		lpTapiLineTestInfo->dwDeviceID,
+		lpTapiLineTestInfo->lpwszDeviceClass);
+#else
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwDeviceID = %lx, lpszDeviceClass = %s",
+		lpTapiLineTestInfo->dwDeviceID,
+		lpTapiLineTestInfo->lpszDeviceClass);
+#endif
+
+
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialg Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialg Test Failed");
+	
+ 
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlcde.c b/private/tapi/qa/trapper/itest/wline/witlcde.c
new file mode 100644
index 000000000..90517c753
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlcde.c
@@ -0,0 +1,236 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcde.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigDialogEdit
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_lineConfigDialogEdit"
+#define DLG_TITLE_UNIMDM     "Zoom VFX 28.8 Properties"
+
+
+//  lineConfigDialogEdit
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineConfigDialogEdit(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 2. Test lineConfigDialogEdit");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+	if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx, dwNeededSize = %lx, dwStringSize = %lx", 
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwStringSize
+		);
+
+
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+	   lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\t: lpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+
+
+
+	lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	lpTapiLineTestInfo->lpDeviceConfigIn = 
+ 			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+	lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineConfigDialogEdit for go/no-go");
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfigIn->dwSize = %lx", 
+		lpTapiLineTestInfo->dwSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfigOut->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize
+		);
+	
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tDeviceConfigOut->dwTotalSize = %lx, neededsize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize);
+
+	if(lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize <
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize )
+	{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = dwSize;
+
+	   PrepareToAutoDismissDlg(TRUE);
+
+		if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	   PrepareToAutoDismissDlg(FALSE);
+
+	}
+
+
+ 	// Can call lineSetDevConfig and then call lineGetDevConfig to verify
+
+
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTestHeap();
+ 
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialgEdit Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialgEdit Test Failed");
+	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlfw.c b/private/tapi/qa/trapper/itest/wline/witlfw.c
new file mode 100644
index 000000000..ff91d208c
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlfw.c
@@ -0,0 +1,188 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlfw.c
+
+Abstract:
+
+    This module contains the test functions for lineForward
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineForward
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineForward(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineForward");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	lpTapiLineTestInfo->bAllAddresses = TRUE;
+	lpTapiLineTestInfo->dwAddressID = 0;
+	lpTapiLineTestInfo->lpForwardList = (LPLINEFORWARDLIST) AllocFromTestHeap (
+			sizeof(LINEFORWARDLIST));
+	lpTapiLineTestInfo->lpForwardList->dwTotalSize = sizeof(LINEFORWARDLIST);
+	lpTapiLineTestInfo->lpForwardList->dwNumEntries = 0;
+	lpTapiLineTestInfo->dwNumRingsNoAnswer = 3;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineForward for go/no-go");
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineForward(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineForward(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+		
+	lpTapiLineTestInfo->lpLineAddressStatus = (LPLINEADDRESSSTATUS) AllocFromTestHeap (
+			sizeof(LINEADDRESSSTATUS));
+	lpTapiLineTestInfo->lpLineAddressStatus->dwTotalSize = sizeof(LINEADDRESSSTATUS);
+
+	if (! DoLineGetAddressStatus(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+  
+     }
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineForward Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineForward Test Failed");
+ 
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgaal.c b/private/tapi/qa/trapper/itest/wline/witlgaal.c
new file mode 100644
index 000000000..84bd2f837
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgaal.c
@@ -0,0 +1,214 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    witlgaal.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAgentActivityList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		23-Dec-1995
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineGetAgentActivityList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAgentActivityList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LPDWORD	lpRequestBuf;
+	LONG lret;
+	LPTAPIMSG lpTapiMsg = NULL;
+	LPTAPIMSG lpMatch;
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAgentActivityList");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentActivityList unimodem didn't support");
+		return fTestPassed;
+		}
+
+
+	lpTapiLineTestInfo->dwAPIVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwExtLowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwExtHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->lpdwExtVersion = &lpTapiLineTestInfo->dwExtVersion;
+
+    // Negotiate the API Ext Version
+    if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+        TLINE_FAIL();
+    }
+
+
+	    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER | 
+												  LINEOPENOPTION_PROXY;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) AllocFromTestHeap (
+			sizeof(LINECALLPARAMS) + sizeof(DWORD));
+	lpTapiLineTestInfo->lpCallParams->dwTotalSize = 
+			sizeof(LINECALLPARAMS) + sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificSize = 
+						sizeof(DWORD);
+	lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset = 
+						sizeof(LINECALLPARAMS);
+	lpRequestBuf = (LPDWORD) (((LPBYTE)lpTapiLineTestInfo->lpCallParams)  + 
+												  lpTapiLineTestInfo->lpCallParams->dwDevSpecificOffset);
+	*lpRequestBuf = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
+
+	
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 lpTapiLineTestInfo->dwAddressID = 0;
+
+    lpTapiLineTestInfo->lpAgentActivityList = (LPLINEAGENTACTIVITYLIST) AllocFromTestHeap(
+            sizeof(LINEAGENTACTIVITYLIST)
+            );
+    lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize = sizeof(LINEAGENTACTIVITYLIST);
+
+    if (! DoLineGetAgentActivityList(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+   lpMatch = (LPTAPIMSG) AllocFromTestHeap (sizeof(TAPIMSG));
+
+	lpMatch->dwMsg = LINE_PROXYREQUEST;
+	lpMatch->dwParam1 = 0;
+	lpMatch->dwParam2 = 0;
+	lpMatch->dwParam3 = 0;
+	lpMatch->dwFlags = TAPIMSG_DWMSG;
+ 
+	lret = FindReceivedMsgs(&lpTapiMsg, lpMatch, FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"##lret = %lx", lret);
+	 
+    if(lret == 1)
+	{
+	 lpTapiLineTestInfo->lpProxyRequest = (LPLINEPROXYREQUEST) lpTapiMsg->dwParam1;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwNeededSize =
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwTotalSize;
+    lpTapiLineTestInfo->lpProxyRequest->GetAgentActivityList.ActivityList.dwNumEntries = 2;
+    lpTapiLineTestInfo->dwResult = 0;
+	 TapiShowProxyBuffer(lpTapiLineTestInfo->lpProxyRequest);
+	
+    if (! DoLineProxyResponse(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	 AddMessage (LINE_REPLY, 0, 0, 0, 
+                lpTapiLineTestInfo->dwResult, 0, TAPIMSG_DWMSG | TAPIMSG_DWPARAM2);
+	 WaitForAllMessages();
+	 }
+
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"## dwTotalSize = %lx, dwNeededSize = %lx, dwNumEntries = %lx",
+      lpTapiLineTestInfo->lpAgentActivityList->dwTotalSize,
+      lpTapiLineTestInfo->lpAgentActivityList->dwNeededSize,
+      lpTapiLineTestInfo->lpAgentActivityList->dwNumEntries);
+
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentActivityList Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetAgentActivityList Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgad.c b/private/tapi/qa/trapper/itest/wline/witlgad.c
new file mode 100644
index 000000000..742f6bee6
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgad.c
@@ -0,0 +1,203 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgat.c
+
+Abstract:
+
+    This module contains the test functions for lineGatherDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+#define PULSESIZE	10
+#define DTMFSIZE	16;
+
+
+//  lineGatherDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGatherDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD	dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGatherDigits");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+#ifdef WUNICODE				
+	lpTapiLineTestInfo->lpwszDestAddress =  L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwDigitModes = LINEDIGITMODE_PULSE;
+	dwSize = PULSESIZE;
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwsDigits = (LPWSTR) AllocFromTestHeap (PULSESIZE*sizeof(WCHAR));
+	lpTapiLineTestInfo->lpwszTerminationDigits = L"3";
+#else
+	lpTapiLineTestInfo->lpsDigits = (LPSTR) AllocFromTestHeap (PULSESIZE);
+	lpTapiLineTestInfo->lpszTerminationDigits = "3";
+#endif
+
+   lpTapiLineTestInfo->dwNumDigits = 2;
+	lpTapiLineTestInfo->dwFirstDigitTimeout = 100;
+	lpTapiLineTestInfo->dwInterDigitTimeout = 1000;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineGatherDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+#ifdef WUNICODE
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### lpwsDigits = %s",
+		lpTapiLineTestInfo->lpwsDigits);
+#else
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### lpsDigits = %s",
+		lpTapiLineTestInfo->lpsDigits);
+#endif
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGatherDigits Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGatherDigits Test Failed");
+		
+    return fTestPassed;
+}
+
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgap.c b/private/tapi/qa/trapper/itest/wline/witlgap.c
new file mode 100644
index 000000000..b94703000
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgap.c
@@ -0,0 +1,165 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgap.c
+
+Abstract:
+
+    This module contains the test functions for lineGetAppPriority
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineGetAppPriority
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetAppPriority(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwPrioritySav;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetAppPriority");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetAppPriority for go/no-go");
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+	dwPrioritySav = *lpTapiLineTestInfo->lpdwPriority;
+	lpTapiLineTestInfo->dwPriority = !dwPrioritySav;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetAppPriority Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetAppPriority Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgc.c b/private/tapi/qa/trapper/itest/wline/witlgc.c
new file mode 100644
index 000000000..15fc12830
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgc.c
@@ -0,0 +1,155 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetCountry
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  lineGetCountry
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetCountry(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetCountry");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetCountry for go/no-go");
+
+
+	lpTapiLineTestInfo->dwCountryID = 1;
+	lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = BIGBUFSIZE;
+
+
+   if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lineCountryList->dwTotalSize = %lx, dwNeededSize = %lx", 
+		lpTapiLineTestInfo->lpLineCountryList->dwTotalSize,
+		lpTapiLineTestInfo->lpLineCountryList->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumCountires = %lx",
+		lpTapiLineTestInfo->lpLineCountryList->dwNumCountries);
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetCountry Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetCountry Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgdcf.c b/private/tapi/qa/trapper/itest/wline/witlgdcf.c
new file mode 100644
index 000000000..a22c15291
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgdcf.c
@@ -0,0 +1,158 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdcf.c
+
+Abstract:
+
+    This module contains the test functions for lineGetDevConfig
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineGetDevConfig
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetDevConfig(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 5. Test lineGetDevConfig");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineGetDevConfig for go/no-go");
+
+
+	if (! DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx, dwNeededSize = %lx, dwStringSize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwStringSize);
+
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+	   lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\tlpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetDevConfig Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetDevConfig Test Failed");
+  
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgdt.c b/private/tapi/qa/trapper/itest/wline/witlgdt.c
new file mode 100644
index 000000000..5ad4e7d81
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgdt.c
@@ -0,0 +1,189 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdt.c
+
+Abstract:
+
+    This module contains the test functions for lineGenerateDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  lineGenerateDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGenerateDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGenerateDigits");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE				
+	lpTapiLineTestInfo->lpwszDestAddress =  L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress =  "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGenerateDigits for go/no-go");
+
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDigits = L"1";
+#else
+	lpTapiLineTestInfo->lpszDigits = "1";
+#endif
+
+	lpTapiLineTestInfo->dwDuration = 0;
+
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+		
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGenerateDigits Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGenerateDigits Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgi.c b/private/tapi/qa/trapper/itest/wline/witlgi.c
new file mode 100644
index 000000000..dad3bc644
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgi.c
@@ -0,0 +1,146 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgi.c
+
+Abstract:
+
+    This module contains the test functions for lineGetIcon
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		11-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+
+//  lineGetIcon
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetIcon(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetIcon");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+
+ 	lpTapiLineTestInfo->dwDeviceID = (*lpTapiLineTestInfo->lpdwNumDevs == 0 ?
+		0 : lpTapiLineTestInfo->dwNumDevs-1);
+	
+	// Negotiate the API Version
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetIcon for go/no-go");
+
+	lpTapiLineTestInfo->lphIcon = &lpTapiLineTestInfo->hIcon;
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+	if (! DoLineGetIcon(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+ 
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetIcon Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetIcon Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgr.c b/private/tapi/qa/trapper/itest/wline/witlgr.c
new file mode 100644
index 000000000..46b182d42
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgr.c
@@ -0,0 +1,179 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgr.c
+
+Abstract:
+
+    This module contains the test functions for lineGetRequest
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineGetRequest
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetRequest(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LINEREQMAKECALL	LineReqMakeCall;
+	
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 6. Test lineGetRequest");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+		
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwsztapiAppName = L"tline test";
+	lpTapiLineTestInfo->lpwszDestAddress = (LPWSTR) L"55555";
+	lpTapiLineTestInfo->lpwszCalledParty = L"";
+	lpTapiLineTestInfo->lpwszComment = L"";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpsztapiAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "";
+	lpTapiLineTestInfo->lpszComment = "";
+#endif
+
+
+	if(! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+		
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineGetRequest for go/no-go");
+
+
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetRequest Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetRequest Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlgtc.c b/private/tapi/qa/trapper/itest/wline/witlgtc.c
new file mode 100644
index 000000000..d412ff143
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlgtc.c
@@ -0,0 +1,198 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgtc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetTranslateCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  lineGetTranslateCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetTranslateCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetTranslateCaps");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetTranslateCaps for go/no-go");
+
+
+	lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+		sizeof(LINETRANSLATECAPS));
+	lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+
+
+   if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+
+	if(lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize > 
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize;
+		lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = dwSize;
+
+	   if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+      	  TLINE_FAIL();
+	    }
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+			lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+			lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+			lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+		}
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetTranslateCaps Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetTranslateCaps Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlho.c b/private/tapi/qa/trapper/itest/wline/witlho.c
new file mode 100644
index 000000000..3829c597b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlho.c
@@ -0,0 +1,227 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlho.c
+
+Abstract:
+
+    This module contains the test functions for lineHandoff
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+#define  DLG_TITLE  "Tapi App"
+
+
+//  lineHandoff
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineHandoff(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+   MSG msg;
+   LPCALLBACKPARAMS lpCallbackParams;
+	
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+    lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineHandoff");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+//	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+//		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+   lpTapiLineTestInfo->dwDeviceID = 0;
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+   lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+   lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+ 	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+	 }
+
+/*
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+*/
+ 
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineHandoff for go/no-go");
+
+	WinExec("testapp.exe", SW_SHOWDEFAULT);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszFileName = (LPWSTR) L"TESTAPP.EXE";
+#else
+	lpTapiLineTestInfo->lpszFileName = (LPSTR) "TESTAPP.EXE";
+#endif
+
+   lpTapiLineTestInfo->dwMediaMode = 0;
+
+   strcpy(szTitle, DLG_TITLE);
+	PrepareToAutoDismissWin(TRUE);
+		
+ 	if (! DoLineHandoff(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   if(fTestPassed)
+   {
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMOWNERINCR,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    }
+ 
+   while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+    {
+     TranslateMessage((LPMSG)&msg);
+     DispatchMessage ((LPMSG)&msg);
+    }
+	PrepareToAutoDismissWin(FALSE);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineHandoff Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineHandoff Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlie.c b/private/tapi/qa/trapper/itest/wline/witlie.c
new file mode 100644
index 000000000..316554435
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlie.c
@@ -0,0 +1,104 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlie.c
+
+Abstract:
+
+    This module contains the test functions for lineInitializeEx
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "stdlib.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineInitializeEx
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineInitializeEx(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineInitializeEx");
+
+	// Initialize a line app
+   lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+   lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiLineTestInfo->lpLineInitializeExParams = 
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =  
+         sizeof(LINEINITIALIZEEXPARAMS);
+   lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions = 
+         LINEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+   
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineInitializeEx Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineInitializeEx Test Failed");
+
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlpak.c b/private/tapi/qa/trapper/itest/wline/witlpak.c
new file mode 100644
index 000000000..2bc4778d7
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlpak.c
@@ -0,0 +1,191 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpk.c
+
+Abstract:
+
+    This module contains the test functions for linePark
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  linePark
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePark(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test linePark");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	lpTapiLineTestInfo->dwParkMode = LINEPARKMODE_DIRECTED;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDirAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDirAddress = "55555";
+#endif
+	lpTapiLineTestInfo->lpNonDirAddress = (LPVARSTRING) AllocFromTestHeap (
+		sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpNonDirAddress->dwTotalSize = sizeof(VARSTRING);
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_UNICODE;
+#else
+	lpTapiLineTestInfo->lpNonDirAddress->dwStringFormat = STRINGFORMAT_ASCII;
+#endif
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLinePark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLinePark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePark Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePark Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlpatc.c b/private/tapi/qa/trapper/itest/wline/witlpatc.c
new file mode 100644
index 000000000..298ebd103
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlpatc.c
@@ -0,0 +1,259 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpatc.c
+
+Abstract:
+
+    This module contains the test functions for linePrepareAddToConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  linePrepareAddToConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePrepareAddToConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp, fUnimdm;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test linePrepareAddToConference");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	fEsp = TRUE;
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = FALSE;
+	fUnimdm = TRUE;
+	}
+	else
+	{
+	fUnimdm = FALSE;
+	}
+	
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+
+	if(fEsp)
+	{
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	if(!fEsp)
+	{
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### Unimdm does not supported these apis");
+
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    return fTestPassed;
+	}
+	
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test linePrepareAddToConference for go/no-go");
+
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+	
+	if(fEsp)
+	{	
+	if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLinePrepareAddToConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+	lpTapiLineTestInfo->lphCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+		sizeof (LINECALLLIST));
+	lpTapiLineTestInfo->lpCallList->dwTotalSize = sizeof(LINECALLLIST);
+
+	if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	if(lpTapiLineTestInfo->lpCallList->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallList->dwNeededSize)
+	{
+		dwSize = lpTapiLineTestInfo->lpCallList->dwNeededSize;
+	    FreeTestHeap();
+		lpTapiLineTestInfo->lpCallList = (LPLINECALLLIST) AllocFromTestHeap (
+			dwSize);
+		lpTapiLineTestInfo->lpCallList->dwTotalSize = dwSize;
+		if (! DoLineGetConfRelatedCalls(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail (
+		DBUG_SHOW_DETAIL,
+		"### lpCallList->dwCallsNumEntries = %lx, dwCallsOffset = %lx",
+		lpTapiLineTestInfo->lpCallList->dwCallsNumEntries,		
+		lpTapiLineTestInfo->lpCallList->dwCallsOffset);
+
+/*
+	for(n=0; n< (INT) lpTapiLineTestInfo->lpCallList->dwCallsNumEntries; n++)
+		{
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### hCall[%lx] = %lx",
+			n, ((LPBYTE)lpTapiLineTestInfo->lpCallList)+
+				lpTapiLineTestInfo->lpCallList->dwCallsOffset+n*sizeof(HCALL));
+		}
+  */			
+			 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePrepareAddToConference Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePrepareAddToConference Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlpk.c b/private/tapi/qa/trapper/itest/wline/witlpk.c
new file mode 100644
index 000000000..42bcd32ad
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlpk.c
@@ -0,0 +1,171 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlpk.c
+
+Abstract:
+
+    This module contains the test functions for linePickup
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  linePickup
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLinePickup(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test linePickup");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->dwAddressID = 0;
+
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszGroupID = L"55555";
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszGroupID = "55555";
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLinePickup(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLinePickup(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePickup Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"linePickup Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlrd.c b/private/tapi/qa/trapper/itest/wline/witlrd.c
new file mode 100644
index 000000000..438447bdd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlrd.c
@@ -0,0 +1,193 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrd.c
+
+Abstract:
+
+    This module contains the test functions for lineRedirect
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineRedirect
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRedirect(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineRedirect");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineRedirect for go/no-go");
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"64738";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "64738";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineRedirect(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineRedirect(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRedirect Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRedirect Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlsap.c b/private/tapi/qa/trapper/itest/wline/witlsap.c
new file mode 100644
index 000000000..f89ea922e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlsap.c
@@ -0,0 +1,165 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsap.c
+
+Abstract:
+
+    This module contains the test functions for lineSetAppPriority
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineSetAppPriority
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetAppPriority(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwPrioritySav;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetAppPriority");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetAppPriority for go/no-go");
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"testapp.exe";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "testapp.exe";
+#endif
+
+   lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+			sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+   lpTapiLineTestInfo->lpExtensionName = (LPVARSTRING) AllocFromTestHeap (
+			sizeof(VARSTRING));
+	lpTapiLineTestInfo->lpExtensionName->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->lpdwPriority = &lpTapiLineTestInfo->dwPriority;
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+	dwPrioritySav = *lpTapiLineTestInfo->lpdwPriority;
+	lpTapiLineTestInfo->dwPriority = !dwPrioritySav;
+
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	if (! DoLineGetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"dwPriority = %lx",
+		*lpTapiLineTestInfo->lpdwPriority);
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetAppPriority Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetAppPriority Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlsdcf.c b/private/tapi/qa/trapper/itest/wline/witlsdcf.c
new file mode 100644
index 000000000..e7e595460
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlsdcf.c
@@ -0,0 +1,175 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsdcf.c
+
+Abstract:
+
+    This module contains the test functions for lineSetDevConfig
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineSetDevConfig
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetDevConfig(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 9. Test lineSetDevConfig");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+
+	lpTapiLineTestInfo->hwndOwner = (HWND)GetTopWindow(NULL);
+	lpTapiLineTestInfo->dwDeviceID = (*lpTapiLineTestInfo->lpdwNumDevs == 0 ?
+		0 : *lpTapiLineTestInfo->lpdwNumDevs-1);
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+
+	if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\tlpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+	
+
+		
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetDevConfig for go/no-go");
+
+	lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	lpTapiLineTestInfo->lpDeviceConfig = 
+			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx",
+		lpTapiLineTestInfo->dwSize);
+
+
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx",
+		lpTapiLineTestInfo->dwSize);
+
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetDevConfig Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetDevConfig Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlst.c b/private/tapi/qa/trapper/itest/wline/witlst.c
new file mode 100644
index 000000000..a38bec2c0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlst.c
@@ -0,0 +1,189 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlst.c
+
+Abstract:
+
+    This module contains the test functions for lineSetupTransfer
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Feb-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineSetupTransfer
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetupTransfer(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetupTransfer");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetupTransfer for go/no-go");
+
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetupTransfer(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetupTransfer(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+
+	
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetupTransfer Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetupTransfer Test Failed");
+ 
+ 	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlstl.c b/private/tapi/qa/trapper/itest/wline/witlstl.c
new file mode 100644
index 000000000..c4167ef6a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlstl.c
@@ -0,0 +1,151 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlstl.c
+
+Abstract:
+
+    This module contains the test functions for lineSetTollList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineSetTollList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetTollList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test lineSetTollList");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test lineSetTollList for go/no-go");
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszAddressIn = L"+1 (206) 936-4738";
+#else
+	lpTapiLineTestInfo->lpszAddressIn = "+1 (206) 936-4738";
+#endif
+
+	lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_ADD;
+
+ 
+	if (DoLineSetTollList(lpTapiLineTestInfo, LINEERR_INIFILECORRUPT))
+		{
+			lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+			if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+		       {
+      	     TLINE_FAIL();
+		       }
+		}
+
+	else if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_REMOVE;
+
+	if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetTollList Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetTollList Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlsuc.c b/private/tapi/qa/trapper/itest/wline/witlsuc.c
new file mode 100644
index 000000000..8bd1a1664
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlsuc.c
@@ -0,0 +1,181 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    witlsuc.c
+
+Abstract:
+
+    This module contains the test functions for lineSetupConference
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		15-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  lineSetupConference
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetupConference(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineSetupConference");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineSetupConference for go/no-go");
+
+	lpTapiLineTestInfo->lphConfCall = &lpTapiLineTestInfo->hConfCall1;
+	lpTapiLineTestInfo->lphConsultCall = &lpTapiLineTestInfo->hConsultCall1;
+	lpTapiLineTestInfo->dwNumParties = 8;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL;
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else
+	{	
+	if (! DoLineSetupConference(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"### hConfCall = %lx, hConsultCall = %lx",
+		*lpTapiLineTestInfo->lphConfCall,
+		*lpTapiLineTestInfo->lphConsultCall);		
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetupConference Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineSetupConference Test Failed");
+	
+
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlta.c b/private/tapi/qa/trapper/itest/wline/witlta.c
new file mode 100644
index 000000000..8fb7c6277
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlta.c
@@ -0,0 +1,179 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    witlta.c
+
+Abstract:
+
+    This module contains the test functions for lineTranslateAddress
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  lineTranslateAddress
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTranslateAddress(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineTranslateAddress");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineTranslateAddress for go/no-go");
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+	lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+
+	lpTapiLineTestInfo->dwCard = 0; // get from GetTranslateCaps
+	lpTapiLineTestInfo->dwTranslateOptions = LINETRANSLATEOPTION_CANCELCALLWAITING;
+	lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+      BUFSIZE);
+	lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = BUFSIZE;
+
+   if (! DoLineTranslateAddress(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateOutput->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateOutput->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateOutput->dwCurrentCountry = %lx, dwDestCountry = %lx, dwResults = %lx",
+		lpTapiLineTestInfo->lpTranslateOutput->dwCurrentCountry,
+		lpTapiLineTestInfo->lpTranslateOutput->dwDestCountry,
+		lpTapiLineTestInfo->lpTranslateOutput->dwTranslateResults);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateAddress Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateAddress Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witltd.c b/private/tapi/qa/trapper/itest/wline/witltd.c
new file mode 100644
index 000000000..a644eb997
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witltd.c
@@ -0,0 +1,195 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itltd.c
+
+Abstract:
+
+    This module contains the test functions for lineTranslateDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+#define DLG_TITLE    "Dialing Properties"
+
+
+
+//  lineTranslateDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTranslateDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed    = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineTranslateDialog");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineTranslateDialog for go/no-go");
+
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszAddressIn = L"55555";
+#else
+	lpTapiLineTestInfo->lpszAddressIn = "55555";
+#endif
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+
+   strcpy(szTitle, DLG_TITLE);
+
+   PrepareToAutoDismissDlg(TRUE);
+   if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   PrepareToAutoDismissDlg(FALSE);
+
+
+	lpTapiLineTestInfo->dwCountryID = 1;
+	lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+		sizeof(LINETRANSLATECAPS));
+	lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+
+
+   if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateDialog Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateDialog Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/witlupak.c b/private/tapi/qa/trapper/itest/wline/witlupak.c
new file mode 100644
index 000000000..5a7a54c77
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/witlupak.c
@@ -0,0 +1,172 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlupak.c
+
+Abstract:
+
+    This module contains the test functions for lineUnpark
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		31-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+
+//  lineUnpark
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineUnpark(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineUnpark");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineUnpark for go/no-go");
+
+
+	lpTapiLineTestInfo->dwAddressID = 0;
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+#endif
+
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineUnpark(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineUnpark(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineUnpark Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineUnpark Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/wittgli.c b/private/tapi/qa/trapper/itest/wline/wittgli.c
new file mode 100644
index 000000000..5036a182e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/wittgli.c
@@ -0,0 +1,140 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittgli.c
+
+Abstract:
+
+    This module contains the test functions for tapiGetLocationInfo
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  tapiGetLocationInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiGetLocationInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwCountrySize, dwCitySize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiGetLocationInfo");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiGetLocationInfo for go/no-go");
+
+	dwCountrySize = 10;
+	dwCitySize = 10;
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszCountryCode = AllocFromTestHeap(dwCountrySize*sizeof(WCHAR));
+   lpTapiLineTestInfo->lpwszCityCode = AllocFromTestHeap(dwCitySize*sizeof(WCHAR));
+#else
+   lpTapiLineTestInfo->lpszCountryCode = AllocFromTestHeap(dwCountrySize);
+   lpTapiLineTestInfo->lpszCityCode = AllocFromTestHeap(dwCitySize);
+#endif
+
+	if (! DoTapiGetLocationInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+
+#ifdef WUNICODE	
+	(lpTapiLineTestInfo->lpwszCountryCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCountryCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCountryCode = %ws",
+			lpTapiLineTestInfo->lpwszCountryCode);		
+ 
+	(lpTapiLineTestInfo->lpwszCityCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCityCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpwszCityCode = %ws",
+			lpTapiLineTestInfo->lpwszCityCode);		
+#else
+	(lpTapiLineTestInfo->lpszCountryCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCountryCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCountryCode = %s",
+			lpTapiLineTestInfo->lpszCountryCode);		
+ 
+	(lpTapiLineTestInfo->lpszCityCode == NULL) ?
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCityCode = NULL") :
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"### lpszCityCode = %s",
+			lpTapiLineTestInfo->lpszCityCode);		
+#endif
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiGetLocationInfo Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiGetLocationInfo Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/wittrmc.c b/private/tapi/qa/trapper/itest/wline/wittrmc.c
new file mode 100644
index 000000000..3232fba76
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/wittrmc.c
@@ -0,0 +1,132 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrmc.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestMakeCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+  	Rama Koneru		(a-ramako)	3/26/96		Modified for UNICODE
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  tapiRequestMakeCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestMakeCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiRequestMakeCall");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiRequestMakeCall for go/no-go");
+
+
+   lpTapiLineTestInfo->dwMediaMode = 0;
+	lpTapiLineTestInfo->dwRequestMode =  LINEREQUESTMODE_MAKECALL;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"wline.dll";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "wline.dll";
+#endif
+   lpTapiLineTestInfo->lpExtID = (LPLINEEXTENSIONID) AllocFromTestHeap (
+        sizeof(LINEEXTENSIONID));
+   lpTapiLineTestInfo->dwPriority = 1;
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+    lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)"wline.dll";
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+    lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)"wline.dll";
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+
+	
+	if (! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+			fTestPassed = FALSE;
+       }
+
+
+   lpTapiLineTestInfo->dwMediaMode = 0;
+	lpTapiLineTestInfo->dwRequestMode =  LINEREQUESTMODE_MAKECALL;
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszAppFilename = L"wline.dll";
+#else
+   lpTapiLineTestInfo->lpszAppFilename = "wline.dll";
+#endif
+   lpTapiLineTestInfo->dwPriority = 0;
+	if (! DoLineSetAppPriority(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+   FreeTestHeap(); 
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMakeCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMakeCall Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/wittrmec.c b/private/tapi/qa/trapper/itest/wline/wittrmec.c
new file mode 100644
index 000000000..bd3a9a672
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/wittrmec.c
@@ -0,0 +1,114 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    ittrmec.c
+
+Abstract:
+
+    This module contains the test functions for tapiRequestMediaCall
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		30-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "wline.h"
+
+
+
+//  tapiRequestMediaCall
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestTapiRequestMediaCall(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test tapiRequestMediaCall");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test tapiRequestMediaCall for go/no-go");
+
+	lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+   lpTapiLineTestInfo->wRequestID = 0;
+
+#ifdef WUNICODE
+	lpTapiLineTestInfo->lpwszDeviceClass = L"tapi/line";
+#else
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+#endif
+
+   lpTapiLineTestInfo->lpDeviceID = 0;
+   lpTapiLineTestInfo->dwSize = 0;
+   lpTapiLineTestInfo->dwSecure = 0;
+
+#ifdef WUNICODE
+   lpTapiLineTestInfo->lpwszDestAddress = L"55555";
+   lpTapiLineTestInfo->lpwsztapiAppName = (LPWSTR)NULL;
+	lpTapiLineTestInfo->lpwszCalledParty = (LPWSTR) L"xxx";
+	lpTapiLineTestInfo->lpwszComment = (LPWSTR)NULL;
+#else
+   lpTapiLineTestInfo->lpszDestAddress = "55555";
+   lpTapiLineTestInfo->lpsztapiAppName = (LPSTR)NULL;
+	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)"xxx";
+	lpTapiLineTestInfo->lpszComment = (LPSTR)NULL;
+#endif
+
+//	lpTapiLineTestInfo->lpszCalledParty = (LPSTR)NULL;
+	
+	if (! DoTapiRequestMediaCall(lpTapiLineTestInfo, TAPIERR_REQUESTFAILED))
+       {
+			fTestPassed = FALSE;
+       }
+
+ 
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMediaCall Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"tapiRequestMediaCall Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/wline.c b/private/tapi/qa/trapper/itest/wline/wline.c
new file mode 100644
index 000000000..b7d9440a4
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/wline.c
@@ -0,0 +1,508 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    wline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Rama Koneru		3/18/96
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "wline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghWLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+WLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghWLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAddProvider(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineBlindTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigDialog(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigDialogEdit(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineForward(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGatherDigits(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAgentActivityList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetAppPriority(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetCountry(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetDevConfig(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGenerateDigits(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetIcon(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetRequest(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test14(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetTranslateCaps(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test15(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineHandoff(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test16(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineInitializeEx(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test17(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePark(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test18(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePrepareAddToConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test19(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLinePickup(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test20(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRedirect(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test21(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetAppPriority(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test22(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetDevConfig(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test23(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetupTransfer(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test24(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetTollList(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test25(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetupConference(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test26(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTranslateAddress(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test27(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTranslateDialog(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test28(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineUnpark(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test29(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiGetLocationInfo(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test30(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestMakeCall(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test31(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestTapiRequestMediaCall(TRUE, FALSE));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/wline/wline.def b/private/tapi/qa/trapper/itest/wline/wline.def
new file mode 100644
index 000000000..33953ed26
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/wline.def
@@ -0,0 +1,41 @@
+LIBRARY         wline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+		Test13
+		Test14
+		Test15
+		Test16
+		Test17
+		Test18
+		Test19
+		Test20
+		Test21
+		Test22
+		Test23
+		Test24
+		Test25
+		Test26
+		Test27
+		Test28
+		Test29
+		Test30
+		Test31
diff --git a/private/tapi/qa/trapper/itest/wline/wline.h b/private/tapi/qa/trapper/itest/wline/wline.h
new file mode 100644
index 000000000..1a61187dc
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wline/wline.h
@@ -0,0 +1,311 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    wline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Rama Koneru 		15-Mar-1996
+
+Revision History:
+
+--*/
+
+
+#ifndef WLINE_H
+#define WLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+//CLINE functions  (6)
+
+BOOL
+TestLinePrepareAddToConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetupConference(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRedirect(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestTapiGetLocationInfo(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTapiRequestMakeCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestTapiRequestMediaCall(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+
+//ILINE functions (3)
+
+BOOL
+TestLineBlindTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineForward(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineSetupTransfer(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+//WLINE20 functions (2)
+
+BOOL
+TestLineGetAgentActivityList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineInitializeEx(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+//SLINE functions  (6)
+
+BOOL
+TestLineGatherDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePark(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineUnpark(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLinePickup(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+
+BOOL
+TestLineGetAppPriority(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetAppPriority(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+//XLINE functions (6)
+
+
+BOOL
+TestLineConfigDialog(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineConfigDialogEdit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetDevConfig(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetRequest(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetDevConfig(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineSetTollList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+//YLINE function  (8)
+
+
+BOOL
+TestLineAddProvider(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGenerateDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetCountry(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetTranslateCaps(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineTranslateDialog(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineGetIcon(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineHandoff(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineTranslateAddress(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+#endif  // WLINE_H
diff --git a/private/tapi/qa/trapper/itest/wphone/makefile b/private/tapi/qa/trapper/itest/wphone/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/wphone/sources b/private/tapi/qa/trapper/itest/wphone/sources
new file mode 100644
index 000000000..f67169f21
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/sources
@@ -0,0 +1,66 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=wphone
+TARGETPATH=$(BASEDIR)\public\sdk\lib\unicode
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\user32.lib \
+	   $(BASEDIR)\public\sdk\lib\unicode\*\tcore.lib \
+	   $(BASEDIR)\public\sdk\lib\unicode\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+	   $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x68000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+
+USE_CRTDLL=1
+
+SOURCES=wphone.c \
+wtpcd.c \
+wtpgbi.c \
+wtpgdc.c \
+wtpgi.c \
+wtpgid.c \
+wtpgs.c \
+wtpi.c \
+wtpie.c \
+wtpsbi.c \
+version.rc
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1 -DWUNICODE=1
+
+UMTYPE=windows
+
+DLLENTRY=WPhoneDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/wphone/wphone.c b/private/tapi/qa/trapper/itest/wphone/wphone.c
new file mode 100644
index 000000000..a05a30075
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wphone.c
@@ -0,0 +1,266 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wphone.c
+
+Abstract:
+    This module contains functions for testing Telephony phone device APIs.
+
+Author:
+    Oliver Wallace (OliverW)    1-Dec-1995
+
+Revision History:
+	Javed Rasool (JavedR)		22-Mar-1996		Enabled for Unicode
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "wphone.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghWphoneDll   = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+WPhoneDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghWphoneDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+//Unicode
+BOOL
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneConfigDialog(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetButtonInfo(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetDevCaps(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetIcon(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetID(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneGetStatus(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneInitialize(TRUE, TRUE));
+}
+
+//Unicode
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestPhoneInitializeEx(TRUE, FALSE));
+}
+
+//Unicode
+BOOL
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+	return (TestPhoneSetButtonInfo(TRUE, TRUE));
+}
+
+BOOL
+ShouldTapiPhoneTestAbort(BOOL fQuiteMode)
+{
+	return FALSE;
+}
diff --git a/private/tapi/qa/trapper/itest/wphone/wphone.def b/private/tapi/qa/trapper/itest/wphone/wphone.def
new file mode 100644
index 000000000..9ef1e73d1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wphone.def
@@ -0,0 +1,19 @@
+LIBRARY         wphone
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
diff --git a/private/tapi/qa/trapper/itest/wphone/wphone.h b/private/tapi/qa/trapper/itest/wphone/wphone.h
new file mode 100644
index 000000000..947ea740b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wphone.h
@@ -0,0 +1,136 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wphone.h
+
+Abstract:
+    This module contains prototypes for testing TAPI phone device functions.
+
+Author:
+    Oliver Wallace (OliverW)    01-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for Unicode
+--*/
+
+
+#ifndef TPHONE_H
+#define TPHONE_H
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+// Macro for handling failures
+#define TPHONE_FAIL()  {                                                      \
+                           if (ShouldTapiPhoneTestAbort(fQuietMode))          \
+                           {                                                  \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp1); \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp2); \
+                               phoneShutdown(lpTapiPhoneTestInfo->hPhoneApp3); \
+                               return FALSE;                                  \
+                           }                                                  \
+                           fTestPassed = FALSE;                               \
+                       }
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+ShouldTapiPhoneTestAbort(
+	BOOL fQuiteMode
+	);
+
+//Unicode
+BOOL
+TestPhoneConfigDialog(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+//Unicode
+BOOL
+TestPhoneGetButtonInfo(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+//Unicode
+BOOL
+TestPhoneGetDevCaps(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+//Unicode
+BOOL
+TestPhoneGetIcon(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+//Unicode
+BOOL
+TestPhoneGetID(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+//Unicode
+BOOL
+TestPhoneGetStatus(
+	BOOL fQuiteMode,
+	BOOL fStandAlong
+	);
+
+//Unicode
+BOOL
+TestPhoneInitialize(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+//Unicode
+BOOL
+TestPhoneInitializeEx(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+//Unicode
+BOOL
+TestPhoneSetButtonInfo(
+	BOOL fQuietMode,
+	BOOL fStandAlone
+	);
+
+#endif  // TPHONE_H
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpcd.c b/private/tapi/qa/trapper/itest/wphone/wtpcd.c
new file mode 100644
index 000000000..f5ede31e1
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpcd.c
@@ -0,0 +1,114 @@
+
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpcd.c
+
+Abstract:
+    This module contains the test functions for phoneConfigDialog
+
+Author:
+    Xiao Ying Ding (XiaoD)  5-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  28-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+#define DLG_TITLE_ESP        "TUISPI_phoneConfigDialog"
+
+
+//  phoneConfigDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneConfigDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test phoneConfigDialog");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// Initialize a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+// 	lpTapiPhoneTestInfo->hwndOwner = (HWND) ghTphoneDll;
+#ifdef WUNICODE
+	lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone"; //WUNICODE
+#else
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneConfigDialog for go/no-go");
+
+   strcpy(szTitle, DLG_TITLE_ESP);
+	PrepareToAutoDismissDlg(TRUE);
+	if (! DoPhoneConfigDialog(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+	// Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+   FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneConfigDialog Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneConfigDialog Test Failed");
+
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpgbi.c b/private/tapi/qa/trapper/itest/wphone/wtpgbi.c
new file mode 100644
index 000000000..5d73aca61
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpgbi.c
@@ -0,0 +1,156 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpgbi.c
+
+Abstract:
+    This module contains the test functions for phoneGetButtonInfo
+
+Author:
+	Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+//  phoneGetButtonInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetButtonInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetButtonInfo");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetButtonInfo for go/no-go for OWNER");
+
+ 	lpTapiPhoneTestInfo->dwButtonLampID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+		0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+	lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+   lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+
+	if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwNeededSize = %lx",
+		lpTapiPhoneTestInfo->lpButtonInfo->dwNeededSize);
+
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwButtonMode = %lx", lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode);
+
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetButtonInfo Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetButtonInfo Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpgdc.c b/private/tapi/qa/trapper/itest/wphone/wtpgdc.c
new file mode 100644
index 000000000..449383ccc
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpgdc.c
@@ -0,0 +1,133 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpgdc.c
+
+Abstract:
+    This module contains the test functions for phoneGetDevCaps
+
+Author:
+	Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+//  phoneGetDevCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetDevCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetDevCaps");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetDevCaps for go/no-go ");
+
+
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetDevCaps Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetDevCaps Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpgi.c b/private/tapi/qa/trapper/itest/wphone/wtpgi.c
new file mode 100644
index 000000000..1348f5135
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpgi.c
@@ -0,0 +1,143 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpgi.c
+
+Abstract:
+    This module contains the test functions for phoneGetIcon
+
+Author:
+    Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+
+//  phoneGetIcon
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetIcon(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetIcon");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+#ifdef WUNICODE
+	lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone"; //WUNICODE -- JavedR
+#else
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+	// Negotiate the API Version
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(sizeof(PHONECAPS));
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+	lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetIcon for go/no-go");
+
+	lpTapiPhoneTestInfo->lphIcon = &lpTapiPhoneTestInfo->hIcon;
+#ifdef WUNICODE
+	lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone"; //WUNICODE -- JavedR
+#else
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+
+	if (! DoPhoneGetIcon(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+ 
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetIcon Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetIcon Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpgid.c b/private/tapi/qa/trapper/itest/wphone/wtpgid.c
new file mode 100644
index 000000000..2f68c8bce
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpgid.c
@@ -0,0 +1,148 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpgid.c
+
+Abstract:
+    This module contains the test functions for phoneGetID
+
+Author:
+	 Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+
+//  phoneGetID
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetID(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetID");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+#ifdef WUNICODE
+	lpTapiPhoneTestInfo->lpwszDeviceClass = L"tapi/phone"; //WUNICODE -- JavedR
+#else
+	lpTapiPhoneTestInfo->lpszDeviceClass = "tapi/phone";
+#endif
+	lpTapiPhoneTestInfo->lpDeviceID =  &(lpTapiPhoneTestInfo->DeviceID);
+	lpTapiPhoneTestInfo->lpDeviceID->dwTotalSize = sizeof(VARSTRING);
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetID for go/no-go");
+
+	if (! DoPhoneGetID(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+ 	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### passedSize = %lx, dwNeededSize = %lx",
+		sizeof(lpTapiPhoneTestInfo->DeviceID), lpTapiPhoneTestInfo->lpDeviceID->dwNeededSize);
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetID Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetID Test Failed");
+
+     return fTestPassed;
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpgs.c b/private/tapi/qa/trapper/itest/wphone/wtpgs.c
new file mode 100644
index 000000000..f04d0386f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpgs.c
@@ -0,0 +1,147 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpgs.c
+
+Abstract:
+    This module contains the test functions for phoneGetStatus
+
+Author:
+	Xiao Ying Ding (XiaoD)		5-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+//  phoneGetStatus
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneGetStatus(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneGetStatus");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneGetStatus for go/no-go for OWNER");
+
+   lpTapiPhoneTestInfo->lpPhoneStatus = (LPPHONESTATUS) AllocFromTestHeap(
+			sizeof(PHONESTATUS));
+	lpTapiPhoneTestInfo->lpPhoneStatus->dwTotalSize = sizeof(PHONESTATUS);
+
+	if (! DoPhoneGetStatus(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+// 	TapiShowPhoneStatusFunc(lpTapiPhoneTestInfo->lpPhoneStatus);
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpPhoneStatus->dwNeededSize = %lx", lpTapiPhoneTestInfo->lpPhoneStatus->dwNeededSize);
+
+
+   
+	if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetStatus Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneGetStatus Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpi.c b/private/tapi/qa/trapper/itest/wphone/wtpi.c
new file mode 100644
index 000000000..ebff83f2f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpi.c
@@ -0,0 +1,88 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpi.c
+
+Abstract:
+    This module contains the test functions for phoneInitialize
+
+Author:
+	Xiao Ying Ding (XiaoD)		5-Feb-1996
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+
+//  phoneInitialize
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneInitialize(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneInitialize");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneInitialize for go/no-go ");
+
+	// Initialize a phone app
+	if(! DoPhoneInitialize (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitialize Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitialize Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpie.c b/private/tapi/qa/trapper/itest/wphone/wtpie.c
new file mode 100644
index 000000000..b2c15ebba
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpie.c
@@ -0,0 +1,97 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpie.c
+
+Abstract:
+    This module contains the test functions for phoneInitializeEx
+
+Author:
+	Xiao Ying Ding (XiaoD)		7-March-1996
+
+Revision History:
+	Javed Rasool (JavedR)	22-Mar-1996 Modified for WUNICODE
+--*/
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+//  phoneInitializeEx
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneInitializeEx(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneInitializeEx");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneInitializeEx for go/no-go ");
+
+	// InitializeEx a phone app
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+ 	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+   
+   FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitializeEx Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneInitializeEx Test Failed");
+
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/wphone/wtpsbi.c b/private/tapi/qa/trapper/itest/wphone/wtpsbi.c
new file mode 100644
index 000000000..d509bbf1a
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/wphone/wtpsbi.c
@@ -0,0 +1,185 @@
+/*++
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+    wtpsbi.c
+
+Abstract:
+    This module contains the test functions for phoneSetButtonInfo
+
+Author:
+    Xiao Ying Ding (XiaoD)  5-Dec-1995
+
+Revision History:
+    Javed Rasool (JavedR)  22-Mar-1996  Modified for WUNICODE
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "dophone.h"
+#include "vars.h"
+#include "wphone.h"
+
+
+
+//  phoneSetButtonInfo
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestPhoneSetButtonInfo(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPIPHONETESTINFO  lpTapiPhoneTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiPhoneTestInit();
+   lpTapiPhoneTestInfo = GetPhoneTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test phoneSetButtonInfo");
+
+   lpTapiPhoneTestInfo->lpdwAPIVersion = &lpTapiPhoneTestInfo->dwAPIVersion;
+   lpTapiPhoneTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams = 
+         (LPPHONEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(PHONEINITIALIZEEXPARAMS));
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwTotalSize =  
+         sizeof(PHONEINITIALIZEEXPARAMS);
+   lpTapiPhoneTestInfo->lpPhoneInitializeExParams->dwOptions = 
+//         PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT;
+         PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+ 	// InitializeEx a phone app
+	if(! DoPhoneInitializeEx (lpTapiPhoneTestInfo, TAPISUCCESS))
+		{
+			TPHONE_FAIL();
+		}
+
+    // Negotiate the API Version
+	lpTapiPhoneTestInfo->dwDeviceID = (*(lpTapiPhoneTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiPhoneTestInfo->lpdwNumDevs)-1);
+	lpTapiPhoneTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiPhoneTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoPhoneNegotiateAPIVersion(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Get the phone device capabilities
+    lpTapiPhoneTestInfo->lpPhoneCaps = (LPPHONECAPS) AllocFromTestHeap(
+            sizeof(PHONECAPS)
+            );
+    lpTapiPhoneTestInfo->lpPhoneCaps->dwTotalSize = sizeof(PHONECAPS);
+    if (! DoPhoneGetDevCaps(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+    // Open a phone
+   lpTapiPhoneTestInfo->dwPrivilege = PHONEPRIVILEGE_OWNER;
+	if (! DoPhoneOpen(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test phoneSetButtonInfo for go/no-go for OWNER");
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### The dwNumButtonLamps = %lx", 
+				lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps);
+
+
+	lpTapiPhoneTestInfo->dwButtonLampID = (lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps == 0 ?
+			0 : lpTapiPhoneTestInfo->lpPhoneCaps->dwNumButtonLamps-1);
+//	lpTapiPhoneTestInfo->dwButtonLampID = 0;
+   lpTapiPhoneTestInfo->lpButtonInfo = (LPPHONEBUTTONINFO) AllocFromTestHeap(
+			sizeof(PHONEBUTTONINFO)
+			);
+
+	// Do set all field in ButtonInfo here
+   lpTapiPhoneTestInfo->lpButtonInfo->dwTotalSize = sizeof(PHONEBUTTONINFO);
+	lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode = PHONEBUTTONMODE_CALL;
+
+	if (! DoPhoneSetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS, TRUE))
+       {
+           TPHONE_FAIL();
+       }
+
+	TapiLogDetail(
+	 	DBUG_SHOW_DETAIL,
+      "fTestPassed = %lx",
+       fTestPassed);
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Call phoneGetButtonInfo for verify");
+
+
+	if (! DoPhoneGetButtonInfo(lpTapiPhoneTestInfo, TAPISUCCESS))
+       {
+           TPHONE_FAIL();
+       }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwNeededSize = %lx",
+		lpTapiPhoneTestInfo->lpButtonInfo->dwNeededSize);
+
+ 
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		" #### lpButtonInfo->dwButtonMode = %lx", lpTapiPhoneTestInfo->lpButtonInfo->dwButtonMode);
+
+
+
+	// Close the phone
+    if (! DoPhoneClose(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoPhoneShutdown(lpTapiPhoneTestInfo, TAPISUCCESS))
+    {
+        TPHONE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetButtonInfo Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## phoneSetButtonInfo Test Failed");
+
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/xline/itlcd.c b/private/tapi/qa/trapper/itest/xline/itlcd.c
new file mode 100644
index 000000000..97d90d9eb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlcd.c
@@ -0,0 +1,144 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcd.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_lineConfigDialog"
+#define DLG_TITLE_UNIMDM     "Zoom VFX 28.8 Properties"
+
+
+//  lineConfigDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineConfigDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 1. Test LineConfigDialog");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// Initialize a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. LineConfigDialog for go/no-go");
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+	PrepareToAutoDismissDlg(TRUE);
+	if (! DoLineConfigDialog(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwDeviceID = %lx, lpszDeviceClass = %s",
+		lpTapiLineTestInfo->dwDeviceID,
+		lpTapiLineTestInfo->lpszDeviceClass);
+
+
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialg Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialg Test Failed");
+	
+ 
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlcde.c b/private/tapi/qa/trapper/itest/xline/itlcde.c
new file mode 100644
index 000000000..1f27506ba
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlcde.c
@@ -0,0 +1,230 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcde.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigDialogEdit
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_lineConfigDialogEdit"
+#define DLG_TITLE_UNIMDM     "Zoom VFX 28.8 Properties"
+
+
+//  lineConfigDialogEdit
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineConfigDialogEdit(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 2. Test lineConfigDialogEdit");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			sizeof(VARSTRING)
+			);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+
+	if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx, dwNeededSize = %lx, dwStringSize = %lx", 
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwStringSize
+		);
+
+
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+	   lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\t: lpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+
+
+
+	lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	lpTapiLineTestInfo->lpDeviceConfigIn = 
+ 			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+	lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = sizeof(VARSTRING);
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineConfigDialogEdit for go/no-go");
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfigIn->dwSize = %lx", 
+		lpTapiLineTestInfo->dwSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfigOut->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize
+		);
+	
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_ESP);
+     }
+   else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+     {
+     strcpy(szTitle, DLG_TITLE_UNIMDM);
+     } 
+
+	PrepareToAutoDismissDlg(TRUE);
+
+	if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tDeviceConfigOut->dwTotalSize = %lx, neededsize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize);
+
+	if(lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize <
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize )
+	{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfigOut->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfigOut = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpDeviceConfigOut->dwTotalSize = dwSize;
+
+	   PrepareToAutoDismissDlg(TRUE);
+
+		if (! DoLineConfigDialogEdit(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	   PrepareToAutoDismissDlg(FALSE);
+	}
+
+
+ 	// Can call lineSetDevConfig and then call lineGetDevConfig to verify
+
+
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	FreeTestHeap();
+ 
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialgEdit Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineConfigDialgEdit Test Failed");
+	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlds.c b/private/tapi/qa/trapper/itest/xline/itlds.c
new file mode 100644
index 000000000..968d945e0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlds.c
@@ -0,0 +1,202 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlds.c
+
+Abstract:
+
+    This module contains the test functions for lineDevSpecific
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineDevSpecific
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineDevSpecific(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	TAPILINETESTDEVSPEC	TapiLineTestDevSpec;
+	BOOL fEsp, fUnimdm;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 3. Test lineDevSpecific");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+   lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+   lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+	if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+		fEsp = TRUE;
+      fUnimdm = FALSE;
+     }
+	else 	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		fEsp = FALSE;
+		fUnimdm = TRUE;
+		}
+	else
+		{
+		fUnimdm = FALSE;
+		}
+
+
+	if(fEsp)
+	{
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	}
+	else if(fUnimdm)
+	{
+	if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+   lpTapiLineTestInfo->dwExtVersion = 0;
+	}
+		
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwExtVersion = %lx",
+		*lpTapiLineTestInfo->lpdwExtVersion);
+ 
+
+   // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineDevSpecific for go/no-go");
+
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+   lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+	lpTapiLineTestInfo->dwAddressID = 0;
+
+
+	if(fEsp)
+	{
+	if (! DoLineDevSpecific(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else	if(fUnimdm)
+	{
+	if (! DoLineDevSpecific(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwSize = %lx",
+		lpTapiLineTestInfo->dwSize);
+	
+	
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineDevSpecific Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineDevSpecific Test Failed");
+		
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itldsf.c b/private/tapi/qa/trapper/itest/xline/itldsf.c
new file mode 100644
index 000000000..23cb835e2
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itldsf.c
@@ -0,0 +1,188 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itpds.c
+
+Abstract:
+
+    This module contains the test functions for lineDevSpecificFeature
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineDevSpecificFeature
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineDevSpecificFeature(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	TAPILINETESTDEVSPEC	TapiLineTestDevSpec;
+	BOOL fEsp, fUnimdm;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 4. Test lineDevSpecificFeature");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = 0;
+   lpTapiLineTestInfo->dwExtLowVersion  = GOOD_EXTVERSION;
+   lpTapiLineTestInfo->dwExtHighVersion = GOOD_EXTVERSION;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+     {
+		fEsp = TRUE;
+      fUnimdm = FALSE;
+     }
+	else	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+		{
+		fEsp = FALSE;
+		fUnimdm = TRUE;
+		}
+	else 
+		{
+		fUnimdm = FALSE;
+		}
+
+	if(fEsp)
+	 {
+	 if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	}
+	else	if(fUnimdm)
+	{
+	 if (! DoLineNegotiateExtVersion(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+   lpTapiLineTestInfo->dwExtVersion = 0;
+	}
+	
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineDevSpecificFeature for go/no-go");
+
+	lpTapiLineTestInfo->lpParams = (LPVOID)&TapiLineTestDevSpec;
+   lpTapiLineTestInfo->dwSize = sizeof(TAPILINETESTDEVSPEC);
+	lpTapiLineTestInfo->dwFeature = PHONEBUTTONFUNCTION_UNKNOWN;
+
+
+	if(fEsp)
+	 {
+	 if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+        {
+     	     TLINE_FAIL();
+	      }
+	 }
+	else if(fUnimdm)
+	{
+	 if (! DoLineDevSpecificFeature(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+        {
+     	     TLINE_FAIL();
+	      }
+	 }
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwSize = %lx, dwFeature = %lx",
+		lpTapiLineTestInfo->dwSize,
+		lpTapiLineTestInfo->dwFeature);
+
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+ 
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineDevSpecificFeature Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineDevSpecificFeature Test Failed");
+		
+ 	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlgdcf.c b/private/tapi/qa/trapper/itest/xline/itlgdcf.c
new file mode 100644
index 000000000..24b7b5377
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlgdcf.c
@@ -0,0 +1,159 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdcf.c
+
+Abstract:
+
+    This module contains the test functions for lineGetDevConfig
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineGetDevConfig
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetDevConfig(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 5. Test lineGetDevConfig");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineGetDevConfig for go/no-go");
+
+
+	if (! DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx, dwNeededSize = %lx, dwStringSize = %lx",
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize,
+		lpTapiLineTestInfo->lpDeviceConfig->dwStringSize);
+
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVARSTRING) AllocFromTestHeap(
+			dwSize);
+	   lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\tlpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetDevConfig Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetDevConfig Test Failed");
+  
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlgr.c b/private/tapi/qa/trapper/itest/xline/itlgr.c
new file mode 100644
index 000000000..706781bc0
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlgr.c
@@ -0,0 +1,169 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgr.c
+
+Abstract:
+
+    This module contains the test functions for lineGetRequest
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineGetRequest
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetRequest(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LINEREQMAKECALL	LineReqMakeCall;
+	
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 6. Test lineGetRequest");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+		
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpszAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "";
+	lpTapiLineTestInfo->lpszComment = "";
+
+
+	if(! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+		
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) AllocFromTestHeap(
+		sizeof(LINEREQMAKECALL)
+		);
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineGetRequest for go/no-go");
+
+
+	if (! DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetRequest Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineGetRequest Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlrrr.c b/private/tapi/qa/trapper/itest/xline/itlrrr.c
new file mode 100644
index 000000000..c4f0cae95
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlrrr.c
@@ -0,0 +1,187 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrrr.c
+
+Abstract:
+
+    This module contains the test functions for lineRegisterRequestRecipient
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineRegisterRequestRecipient
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRegisterRequestRecipient(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	LINEREQMAKECALL	LineReqMakeCall;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 7. Test lineRegisterRequestRecipient");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->dwRegistrationInstance = 0;
+	lpTapiLineTestInfo->bEnable = TRUE;
+
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->lpszAppName = "tline test";
+	lpTapiLineTestInfo->lpszCalledParty = "";
+	lpTapiLineTestInfo->lpszComment = "";
+
+
+	if(! DoTapiRequestMakeCall(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	lpTapiLineTestInfo->dwRequestMode = LINEREQUESTMODE_MAKECALL;
+	lpTapiLineTestInfo->lpRequestBuffer = (LPVOID) &LineReqMakeCall;
+   
+	if(!DoLineGetRequest(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	
+	if(!DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOREQUEST))
+       {
+           TLINE_FAIL();
+       }
+	
+	lpTapiLineTestInfo->bEnable = FALSE;
+
+	if (! DoLineRegisterRequestRecipient(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+ 	
+	if(!DoLineGetRequest(lpTapiLineTestInfo, LINEERR_NOTREGISTERED))
+       {
+           TLINE_FAIL();
+       }
+	
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineRegisterRequestRecipient Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineRegisterRequestRecipient Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlscp.c b/private/tapi/qa/trapper/itest/xline/itlscp.c
new file mode 100644
index 000000000..4f98d262f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlscp.c
@@ -0,0 +1,257 @@
+
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlscp.c
+
+Abstract:
+
+    This module contains the test functions for lineSetCallParams
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+#define MIN_RATE 	10
+#define MAX_RATE	1000
+
+
+//  lineSetCallParams
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetCallParams(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 8. Test lineSetCallParams");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+/*
+
+	lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+		sizeof(LINEDEVSTATUS));
+	lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS);
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwTotalSize = %lx, NeededSize = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize, 
+		lpTapiLineTestInfo->lpLineDevStatus->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwOpenMediaModes = %lx, dwLineFeatures = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwOpenMediaModes,
+		lpTapiLineTestInfo->lpLineDevStatus->dwLineFeatures);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwRoamMode = %lx, dwDevStatusFlags = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwRoamMode,
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+*/
+
+				
+	lpTapiLineTestInfo->lpszDestAddress =  (LPSTR)"55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if( !DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetCallParams for go/no-go");
+
+
+   if(IsESPLineDevice(lpTapiLineTestInfo))
+   {	
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwBearerMode = %lx, dwRate = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwBearerMode,
+		lpTapiLineTestInfo->lpCallInfo->dwRate);
+	
+	lpTapiLineTestInfo->dwBearerMode = LINEBEARERMODE_DATA;
+   lpTapiLineTestInfo->dwMinRate = MIN_RATE;
+   lpTapiLineTestInfo->dwMaxRate = MAX_RATE;
+	lpTapiLineTestInfo->lpDialParams = (LPLINEDIALPARAMS) NULL;
+
+	if (! DoLineSetCallParams(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+
+
+	if(lpTapiLineTestInfo->lpCallInfo->dwTotalSize <
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize)
+	{
+	dwSize = lpTapiLineTestInfo->lpCallInfo->dwNeededSize;
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		dwSize);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = dwSize;
+	}
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+	
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwBearerMode = %lx, dwRate = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwBearerMode,
+		lpTapiLineTestInfo->lpCallInfo->dwRate);
+	 }
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetCallParams Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetCallParams Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlsdcf.c b/private/tapi/qa/trapper/itest/xline/itlsdcf.c
new file mode 100644
index 000000000..21e813ccb
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlsdcf.c
@@ -0,0 +1,176 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsdcf.c
+
+Abstract:
+
+    This module contains the test functions for lineSetDevConfig
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		19-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineSetDevConfig
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetDevConfig(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 9. Test lineSetDevConfig");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 
+	lpTapiLineTestInfo->hwndOwner = (HWND)GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+	lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+		sizeof(VARSTRING)
+		);
+	lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = sizeof(VARSTRING);
+
+
+	if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	if(lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize < 
+		lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwNeededSize;
+		lpTapiLineTestInfo->lpDeviceConfig = (LPVOID) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize = dwSize;
+		if(!DoLineGetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+           TLINE_FAIL();
+       }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"\tlpDeviceConfig->dwTotalSize = %lx, dwStringSize = %lx, dwStringOffset = %lx", 
+			lpTapiLineTestInfo->lpDeviceConfig->dwTotalSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringSize,
+			lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset
+			);
+		}
+	
+
+		
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetDevConfig for go/no-go");
+
+	lpTapiLineTestInfo->dwSize = lpTapiLineTestInfo->lpDeviceConfig->dwStringSize;
+	lpTapiLineTestInfo->lpDeviceConfig = 
+			(LPVOID) ((LPBYTE)lpTapiLineTestInfo->lpDeviceConfig + lpTapiLineTestInfo->lpDeviceConfig->dwStringOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx",
+		lpTapiLineTestInfo->dwSize);
+
+
+	if (! DoLineSetDevConfig(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpDeviceConfig->dwTotalSize = %lx",
+		lpTapiLineTestInfo->dwSize);
+
+
+		
+	// Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetDevConfig Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetDevConfig Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlsmc.c b/private/tapi/qa/trapper/itest/xline/itlsmc.c
new file mode 100644
index 000000000..eda008e9b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlsmc.c
@@ -0,0 +1,234 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsmc.c
+
+Abstract:
+
+    This module contains the test functions for lineSetMediaControl
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineSetMediaControl
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetMediaControl(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 13. Test lineSetMediaControl");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+/*
+	lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+		sizeof(LINEDEVSTATUS));
+	lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS);
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwTotalSize = %lx, NeededSize = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize, 
+		lpTapiLineTestInfo->lpLineDevStatus->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwOpenMediaModes = %lx, dwLineFeatures = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwOpenMediaModes,
+		lpTapiLineTestInfo->lpLineDevStatus->dwLineFeatures);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwRoamMode = %lx, dwDevStatusFlags = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwRoamMode,
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+*/
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams =(LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+	
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetMediaControl for go/no-go");
+
+	lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+	lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;
+	lpTapiLineTestInfo->lpMCDigitList = (LPLINEMEDIACONTROLDIGIT) AllocFromTestHeap(
+		sizeof (LINEMEDIACONTROLDIGIT));
+	lpTapiLineTestInfo->lpMCDigitList->dwDigit = 0;
+	lpTapiLineTestInfo->lpMCDigitList->dwDigitModes = LINEDIGITMODE_PULSE;
+	lpTapiLineTestInfo->lpMCDigitList->dwMediaControl = LINEMEDIACONTROL_RATEUP;
+	lpTapiLineTestInfo->dwDigitNumEntries = 1;
+	lpTapiLineTestInfo->lpMCMediaList = (LPLINEMEDIACONTROLMEDIA) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLMEDIA));
+	lpTapiLineTestInfo->lpMCMediaList->dwMediaModes = LINEMEDIAMODE_UNKNOWN;
+	lpTapiLineTestInfo->lpMCMediaList->dwDuration = 10;
+	lpTapiLineTestInfo->lpMCMediaList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	lpTapiLineTestInfo->dwMediaNumEntries = 1;
+	lpTapiLineTestInfo->lpMCToneList = (LPLINEMEDIACONTROLTONE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLTONE));
+	lpTapiLineTestInfo->dwToneNumEntries = 1;
+	lpTapiLineTestInfo->lpMCToneList->dwAppSpecific = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwDuration = 10;
+	lpTapiLineTestInfo->lpMCToneList->dwFrequency1 = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwFrequency2 = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwFrequency3 = 0;
+	lpTapiLineTestInfo->lpMCToneList->dwMediaControl = LINEMEDIACONTROL_NONE;
+	lpTapiLineTestInfo->lpMCCallStateList = (LPLINEMEDIACONTROLCALLSTATE) AllocFromTestHeap(
+		sizeof(LINEMEDIACONTROLCALLSTATE));
+	lpTapiLineTestInfo->dwCallStateNumEntries = 1;
+	lpTapiLineTestInfo->lpMCCallStateList->dwCallStates = LINECALLSTATE_IDLE;
+	lpTapiLineTestInfo->lpMCCallStateList->dwMediaControl = LINEMEDIACONTROL_NONE;
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetMediaControl(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetMediaControl(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+       {
+           TLINE_FAIL();
+       }
+	}
+
+ 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetMediaControl Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetMediaControl Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlsmm.c b/private/tapi/qa/trapper/itest/xline/itlsmm.c
new file mode 100644
index 000000000..59df46482
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlsmm.c
@@ -0,0 +1,201 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlsmm.c
+
+Abstract:
+
+    This module contains the test functions for lineSetMediaMode
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineSetMediaMode
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetMediaMode(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 10. Test lineSetMediaMode");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR) "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams =(LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+	
+   if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tBefore: lpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"lpCallInfo->dwMedialMode = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwMediaMode);
+
+ 
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetMediaMode for go/no-go");
+
+	lpTapiLineTestInfo->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
+
+				
+	if (! DoLineSetMediaMode(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+	
+   if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tAfter: lpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwMedialMode = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwMediaMode);
+	  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetMediaMode Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetMediaMode Test Failed");
+  
+ 	
+    return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlst.c b/private/tapi/qa/trapper/itest/xline/itlst.c
new file mode 100644
index 000000000..37bc8ac37
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlst.c
@@ -0,0 +1,256 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlst.c
+
+Abstract:
+
+    This module contains the test functions for lineSetTerminal
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineSetTerminal
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetTerminal(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 11. Test lineSetTerminal");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+   lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpTapiLineTestInfo->hLine = %lx, dwMedisModes = %lx",
+		*lpTapiLineTestInfo->lphLine,
+		lpTapiLineTestInfo->dwMediaModes);		
+
+/*
+	lpTapiLineTestInfo->lpLineDevStatus = (LPLINEDEVSTATUS) AllocFromTestHeap(
+		sizeof(LINEDEVSTATUS));
+	lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize = sizeof(LINEDEVSTATUS);
+
+	if (! DoLineGetLineDevStatus(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpLineDevStatus->dwTotalSize = %lx, NeededSize = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwTotalSize, 
+		lpTapiLineTestInfo->lpLineDevStatus->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwOpenMediaModes = %lx, dwLineFeatures = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwOpenMediaModes,
+		lpTapiLineTestInfo->lpLineDevStatus->dwLineFeatures);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpLineDevStatus->dwRoamMode = %lx, dwDevStatusFlags = %lx",
+		lpTapiLineTestInfo->lpLineDevStatus->dwRoamMode,
+		lpTapiLineTestInfo->lpLineDevStatus->dwDevStatusFlags);
+
+*/	
+
+	lpTapiLineTestInfo->lpszDestAddress = (LPSTR)"55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+   lpTapiLineTestInfo->lpCallParams =(LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetTerminal for go/no-go");
+
+
+	lpTapiLineTestInfo->dwAddressID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumAddresses-1);
+	lpTapiLineTestInfo->dwSelect = LINECALLSELECT_LINE;	
+	lpTapiLineTestInfo->dwTerminalModes = LINETERMMODE_DISPLAY;
+	lpTapiLineTestInfo->dwTerminalID = (lpTapiLineTestInfo->lpLineDevCaps->dwNumTerminals == 0 ?
+		0 : lpTapiLineTestInfo->lpLineDevCaps->dwNumTerminals-1);
+	lpTapiLineTestInfo->bEnable = TRUE;
+ 
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetTerminal(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+       {
+           TLINE_FAIL();
+       }
+	}
+	else	if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+	if (! DoLineSetTerminal(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL, TRUE))
+       {
+           TLINE_FAIL();
+       }
+ 	}
+
+/* 
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		sizeof(LINECALLINFO));
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = sizeof(LINECALLINFO);
+
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTotalSize,
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize);
+	
+	if(lpTapiLineTestInfo->lpCallInfo->dwTotalSize < 
+		lpTapiLineTestInfo->lpCallInfo->dwNeededSize)
+	{
+	dwSize = lpTapiLineTestInfo->lpCallInfo->dwNeededSize;
+	lpTapiLineTestInfo->lpCallInfo = (LPLINECALLINFO) AllocFromTestHeap(
+		dwSize);
+	lpTapiLineTestInfo->lpCallInfo->dwTotalSize = dwSize;
+	if (! DoLineGetCallInfo(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+	}
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tlpCallInfo->dwTerminalModesSize = %lx, Offset = %lx",
+		lpTapiLineTestInfo->lpCallInfo->dwTerminalModesSize,
+		lpTapiLineTestInfo->lpCallInfo->dwTerminalModesOffset);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"\tdwTerminalModes = %lx",
+		(LPBYTE)lpTapiLineTestInfo->lpCallInfo+lpTapiLineTestInfo->lpCallInfo->dwTerminalModesOffset);
+*/	
+  
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetTerminal Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetTerminal Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/itlstl.c b/private/tapi/qa/trapper/itest/xline/itlstl.c
new file mode 100644
index 000000000..c5601889d
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/itlstl.c
@@ -0,0 +1,144 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlstl.c
+
+Abstract:
+
+    This module contains the test functions for lineSetTollList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		20-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "xline.h"
+
+
+
+//  lineSetTollList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineSetTollList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## 12. Test lineSetTollList");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"## Test Case 1. lineSetTollList for go/no-go");
+
+	lpTapiLineTestInfo->lpszAddressIn = "+1 (206) 936-4738";
+	lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_ADD;
+
+ 
+	if (DoLineSetTollList(lpTapiLineTestInfo, LINEERR_INIFILECORRUPT))
+		{
+			lpTapiLineTestInfo->hwnd = (HWND) GetTopWindow(NULL);
+			if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+		       {
+      	     TLINE_FAIL();
+		       }
+		}
+
+	else if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+	lpTapiLineTestInfo->dwTollListOption = LINETOLLLISTOPTION_REMOVE;
+
+	if (! DoLineSetTollList(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+   FreeTestHeap();
+
+	
+	if(fTestPassed)
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetTollList Test Passed");
+	else
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"## lineSetTollList Test Failed");
+  
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/makefile b/private/tapi/qa/trapper/itest/xline/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/xline/sources b/private/tapi/qa/trapper/itest/xline/sources
new file mode 100644
index 000000000..75dc93e6e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/sources
@@ -0,0 +1,72 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=xline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x64000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	xline.c \
+		itlcd.c	 \
+		itlcde.c  \
+		itlds.c  \
+		itldsf.c  \
+		itlgdcf.c  \
+		itlgr.c	\
+		itlrrr.c  \
+		itlscp.c  \
+		itlsdcf.c  \
+		itlsmm.c  \
+		itlst.c  \
+		itlstl.c \
+		itlsmc.c \
+		xline.rc
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=XLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/xline/xline.c b/private/tapi/qa/trapper/itest/xline/xline.c
new file mode 100644
index 000000000..1d52c645b
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/xline.c
@@ -0,0 +1,316 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    xline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	26-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "xline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghXLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+XLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghXLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigDialog(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigDialogEdit(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDevSpecific(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineDevSpecificFeature(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetDevConfig(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetRequest(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRegisterRequestRecipient(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetCallParams(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetDevConfig(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetMediaControl(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetMediaMode(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetTerminal(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test13(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineSetTollList(TRUE, FALSE));
+}
+
+
+
+
diff --git a/private/tapi/qa/trapper/itest/xline/xline.def b/private/tapi/qa/trapper/itest/xline/xline.def
new file mode 100644
index 000000000..9dda8eda3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/xline.def
@@ -0,0 +1,23 @@
+LIBRARY         xline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+        Test13
diff --git a/private/tapi/qa/trapper/itest/xline/xline.h b/private/tapi/qa/trapper/itest/xline/xline.h
new file mode 100644
index 000000000..21fd15c86
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/xline.h
@@ -0,0 +1,178 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    xline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef XLINE_H
+#define XLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineConfigDialog(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineConfigDialogEdit(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDevSpecific(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineDevSpecificFeature(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetDevConfig(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetRequest(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRegisterRequestRecipient(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineSetCallParams(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetDevConfig(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetMediaControl(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetMediaMode(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetTerminal(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineSetTollList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+#endif  // XLINE_H
diff --git a/private/tapi/qa/trapper/itest/xline/xline.rc b/private/tapi/qa/trapper/itest/xline/xline.rc
new file mode 100644
index 000000000..17992a87e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/xline/xline.rc
@@ -0,0 +1,12 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI XLine API test Library"
+#define VER_INTERNALNAME_STR        "xline.dll"
+#define VER_ORIGINALFILENAME_STR    "xline.dll"
+
+#include "common.ver"
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlap.c b/private/tapi/qa/trapper/itest/yline/itlap.c
new file mode 100644
index 000000000..e16afb4d3
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlap.c
@@ -0,0 +1,238 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlap.c
+
+Abstract:
+
+    This module contains the test functions for lineAddProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+#define DLG_TITLE_ESP        "TUISPI_providerConfig"
+#define DLG_TITLE_UNIMDM     "Modems Properties"
+#define DLG_TITLE            "ESP32.TSP"
+
+//  lineAddProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineAddProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp;
+	BOOL fUnimdm;
+#ifdef WUNICODE
+   WCHAR wszEspProviderFilename[] = L"esp32.tsp";
+   WCHAR wszUnimdmProviderFilename[] = L"unimdm.tsp";
+#else
+   CHAR szEspProviderFilename[] = "esp32.tsp";
+   CHAR szUnimdmProviderFilename[] = "unimdm.tsp";
+#endif
+   DWORD dwNumProviders;
+   BOOL  fAddProvider;
+ 
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+	
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"Test lineAddProvider");
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+		BUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### Before Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+ 
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineAddProvider");
+
+
+//	lpTapiLineTestInfo->lpszProviderFilename = "esp32.tsp";
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+
+	if(FindESPLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = TRUE;
+      fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+     }
+	else if(FindUnimdmLineDevice(lpTapiLineTestInfo))
+     {
+     fEsp = FALSE;
+     fUnimdm = TRUE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+   else
+     {
+     fEsp = FALSE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+	
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+	else
+	{
+        fAddProvider = TRUE;
+	}
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Add: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+   if(fAddProvider)
+   {
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   PrepareToAutoDismissDlg(FALSE);
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+	}
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineAddProvider Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineAddProvider Test Failed");
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/yline/itlcp.c b/private/tapi/qa/trapper/itest/yline/itlcp.c
new file mode 100644
index 000000000..9ba9095b8
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlcp.c
@@ -0,0 +1,166 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlcp.c
+
+Abstract:
+
+    This module contains the test functions for lineConfigProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define DLG_TITLE_ESP        "TUISPI_providerConfig"
+#define DLG_TITLE_UNIMDM     "Modems Properties"
+
+
+
+//  lineConfigProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineConfigProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n=1;
+   BOOL fTestPassed                  = TRUE;
+	MSG msg;
+   LPLINEPROVIDERENTRY lpProviderEntry;
+   LPSTR lpszProviderName;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"Test lineConfigProvider");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	if(! DoLineNegotiateAPIVersion (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   lpProviderEntry = (LPLINEPROVIDERENTRY) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+      					lpTapiLineTestInfo->lpProviderList->dwProviderListOffset);
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineConfigProvider");
+
+	
+   lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	for(n = 1; n <= (INT)lpTapiLineTestInfo->lpProviderList->dwNumProviders; n++) 
+	{
+	lpTapiLineTestInfo->dwPermanentProviderID = lpProviderEntry->dwPermanentProviderID;
+   lpszProviderName = (LPSTR) (((LPBYTE) lpTapiLineTestInfo->lpProviderList) +
+							  lpProviderEntry->dwProviderFilenameOffset);
+   if(strstr(lpszProviderName, "unimdm"))
+     {
+      strcpy(szTitle, DLG_TITLE_UNIMDM);
+	   PrepareToAutoDismissWin(TRUE);
+	   if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+          TLINE_FAIL();
+       }
+      while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+       {
+          TranslateMessage((LPMSG)&msg);
+          DispatchMessage ((LPMSG)&msg);
+       }
+	   PrepareToAutoDismissWin(FALSE);
+     }
+   else if(strstr(lpszProviderName, "esp"))
+     {
+      strcpy(szTitle, DLG_TITLE_ESP);
+	   PrepareToAutoDismissDlg(TRUE);
+	   if(! DoLineConfigProvider(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+        TLINE_FAIL();
+       }
+	  PrepareToAutoDismissDlg(FALSE);
+     }
+   lpProviderEntry++;
+	}
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	FreeTestHeap();
+
+
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineConfigProvider Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineConfigProvider Test Failed");
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/yline/itlgc.c b/private/tapi/qa/trapper/itest/yline/itlgc.c
new file mode 100644
index 000000000..ecaa53b12
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlgc.c
@@ -0,0 +1,152 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetCountry
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineGetCountry
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetCountry(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetCountry");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetCountry for go/no-go");
+
+
+	lpTapiLineTestInfo->dwCountryID = 1;
+	lpTapiLineTestInfo->lpLineCountryList = (LPLINECOUNTRYLIST) AllocFromTestHeap(
+		BIGBUFSIZE);
+	lpTapiLineTestInfo->lpLineCountryList->dwTotalSize = BIGBUFSIZE;
+
+   if (! DoLineGetCountry(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lineCountryList->dwTotalSize = %lx, dwNeededSize = %lx", 
+		lpTapiLineTestInfo->lpLineCountryList->dwTotalSize,
+		lpTapiLineTestInfo->lpLineCountryList->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwNumCountires = %lx",
+		lpTapiLineTestInfo->lpLineCountryList->dwNumCountries);
+	
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetCountry Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetCountry Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlgdt.c b/private/tapi/qa/trapper/itest/yline/itlgdt.c
new file mode 100644
index 000000000..29bd46385
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlgdt.c
@@ -0,0 +1,176 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgdt.c
+
+Abstract:
+
+    This module contains the test functions for lineGenerateDigits
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineGenerateDigits
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGenerateDigits(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGenerateDigits");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGenerateDigits for go/no-go");
+
+
+	lpTapiLineTestInfo->dwDigitMode = LINEDIGITMODE_PULSE;
+	lpTapiLineTestInfo->lpszDigits = "1";
+	lpTapiLineTestInfo->dwDuration = 0;
+
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateDigits(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+		
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGenerateDigits Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGenerateDigits Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlgi.c b/private/tapi/qa/trapper/itest/yline/itlgi.c
new file mode 100644
index 000000000..a21afcefd
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlgi.c
@@ -0,0 +1,139 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgi.c
+
+Abstract:
+
+    This module contains the test functions for lineGetIcon
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		11-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+
+//  lineGetIcon
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetIcon(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetIcon");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+
+ 	lpTapiLineTestInfo->dwDeviceID = (*lpTapiLineTestInfo->lpdwNumDevs == 0 ?
+		0 : lpTapiLineTestInfo->dwNumDevs-1);
+	
+	// Negotiate the API Version
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetIcon for go/no-go");
+
+	lpTapiLineTestInfo->lphIcon = &lpTapiLineTestInfo->hIcon;
+	lpTapiLineTestInfo->lpszDeviceClass = "tapi/line";
+
+	if (! DoLineGetIcon(lpTapiLineTestInfo, TAPISUCCESS))
+       {
+           TLINE_FAIL();
+       }
+ 
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetIcon Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetIcon Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlgpl.c b/private/tapi/qa/trapper/itest/yline/itlgpl.c
new file mode 100644
index 000000000..a7556e999
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlgpl.c
@@ -0,0 +1,155 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgpl.c
+
+Abstract:
+
+    This module contains the test functions for lineGetProviderList
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineGetProviderList
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetProviderList(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetProviderList");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+ 
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+ 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+		sizeof(LINEPROVIDERLIST));
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = sizeof(LINEPROVIDERLIST);
+
+    if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpProviderList->dwTotalSize = %lx, dwNeededSize = %lx", 
+		lpTapiLineTestInfo->lpProviderList->dwTotalSize,
+		lpTapiLineTestInfo->lpProviderList->dwNeededSize);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpProviderList->dwNumProviders = %lx, dwProviderListSize = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders,
+		lpTapiLineTestInfo->lpProviderList->dwProviderListSize);
+	
+	
+	if(lpTapiLineTestInfo->lpProviderList->dwNeededSize > 
+		lpTapiLineTestInfo->lpProviderList->dwTotalSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpProviderList->dwNeededSize;
+	 	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpProviderList->dwTotalSize = dwSize;
+
+	   if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+      	  TLINE_FAIL();
+	    }
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"#### lpProviderList->dwNumProviders = %lx, dwProviderListSize = %lx",
+			lpTapiLineTestInfo->lpProviderList->dwNumProviders,
+			lpTapiLineTestInfo->lpProviderList->dwProviderListSize);
+		}
+
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetProviderList Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetProviderList Test Failed");
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/yline/itlgtc.c b/private/tapi/qa/trapper/itest/yline/itlgtc.c
new file mode 100644
index 000000000..2e2b8c918
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlgtc.c
@@ -0,0 +1,196 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgtc.c
+
+Abstract:
+
+    This module contains the test functions for lineGetTranslateCaps
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineGetTranslateCaps
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGetTranslateCaps(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	DWORD dwSize;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGetTranslateCaps");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+     lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGetTranslateCaps for go/no-go");
+
+
+	lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+		sizeof(LINETRANSLATECAPS));
+	lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+
+
+   if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+
+	if(lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize > 
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize)
+		{
+		dwSize = lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize;
+		lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+			dwSize);
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = dwSize;
+
+	   if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+   	 {
+      	  TLINE_FAIL();
+	    }
+
+		TapiLogDetail(
+			DBUG_SHOW_DETAIL,
+			"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+			lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+			lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+			lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+		}
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetTranslateCaps Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGetTranslateCaps Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlgtn.c b/private/tapi/qa/trapper/itest/yline/itlgtn.c
new file mode 100644
index 000000000..6137ca212
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlgtn.c
@@ -0,0 +1,178 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlgtn.c
+
+Abstract:
+
+    This module contains the test functions for lineGenerateTone
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineGenerateTone
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineGenerateTone(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineGenerateTone");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	lpTapiLineTestInfo->lpszDestAddress = "55555";
+	lpTapiLineTestInfo->dwCountryCode = 0;
+	lpTapiLineTestInfo->lpCallParams = (LPLINECALLPARAMS) NULL; 
+
+	if(!DoLineMakeCall(lpTapiLineTestInfo, TAPISUCCESS, TRUE))
+    {
+        TLINE_FAIL();
+    }
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineGenerateTone for go/no-go");
+
+
+	lpTapiLineTestInfo->dwToneMode = LINETONEMODE_RINGBACK;
+	lpTapiLineTestInfo->dwNumTones = 1;
+	lpTapiLineTestInfo->lpTones = (LPLINEGENERATETONE) AllocFromTestHeap (
+		sizeof(LINEGENERATETONE));
+
+	// Should check LINE_GENERATE message is sent to the app
+
+	if(IsESPLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+	}
+	else if(IsUNIMDMLineDevice(lpTapiLineTestInfo))
+	{
+   if (! DoLineGenerateTone(lpTapiLineTestInfo, LINEERR_OPERATIONUNAVAIL))
+    {
+        TLINE_FAIL();
+    }
+	}
+		
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGenerateTone Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineGenerateTone Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlho.c b/private/tapi/qa/trapper/itest/yline/itlho.c
new file mode 100644
index 000000000..57f20b050
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlho.c
@@ -0,0 +1,175 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlho.c
+
+Abstract:
+
+    This module contains the test functions for lineHandoff
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		7-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define  DLG_TITLE     "Tapi App"
+#define  TESTAPPNAME   "TESTAPP.EXE"
+
+
+//  lineHandoff
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineHandoff(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+   MSG msg;
+   LPCALLBACKPARAMS lpCallbackParams;
+	
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+   lpCallbackParams = GetCallbackParams();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineHandoff");
+
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+ 
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+    lpTapiLineTestInfo->lphCall          = &lpTapiLineTestInfo->hCall1;
+    lpTapiLineTestInfo->lphLine          = &lpTapiLineTestInfo->hLine1;
+    lpTapiLineTestInfo->lpszDestAddress  = "55555";
+    lpTapiLineTestInfo->dwAPILowVersion  = LOW_APIVERSION;
+    lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+    lpTapiLineTestInfo->lpsUserUserInfo  = NULL;
+    lpTapiLineTestInfo->dwSelect         = LINECALLSELECT_CALL;
+    lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_MONITOR;
+    lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+
+    if (! DoTapiLineFuncs(
+            lpTapiLineTestInfo,
+            LINITIALIZEEX | LNEGOTIATEAPIVERSION | LGETDEVCAPS | LOPEN |
+                    LMAKECALL
+            ))
+    {
+        TLINE_FAIL();
+    }
+   
+	WinExec("testapp.exe", SW_SHOWDEFAULT);
+	lpTapiLineTestInfo->lpszFileName = (LPSTR) "TESTAPP.EXE";
+   lpTapiLineTestInfo->dwMediaMode = 0;
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineHandoff for go/no-go");
+
+   strcpy(szTitle, DLG_TITLE);
+
+	PrepareToAutoDismissWin(TRUE);
+
+   if (! DoLineHandoff(lpTapiLineTestInfo, TAPISUCCESS))
+     {
+         TLINE_FAIL();
+     }
+   if(fTestPassed)
+   {
+    AddMessage(
+        LINE_CALLINFO,
+        (DWORD) lpTapiLineTestInfo->hCall1,
+        (DWORD) lpCallbackParams,
+        LINECALLINFOSTATE_NUMOWNERINCR,
+        0x00000000,
+        0x00000000,
+        TAPIMSG_DWMSG | TAPIMSG_HDEVCALL | TAPIMSG_DWCALLBACKINST |
+                TAPIMSG_DWPARAM1
+        );
+
+    if (! WaitForAllMessages())
+    {
+        TLINE_FAIL();
+    }
+    }
+   while( GetMessage((LPMSG)&msg, (HWND)NULL, 0, 0))
+    {
+     TranslateMessage((LPMSG)&msg);
+     DispatchMessage ((LPMSG)&msg);
+    }
+	
+   PrepareToAutoDismissWin(FALSE);
+	 
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineHandoff Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineHandoff Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itlrp.c b/private/tapi/qa/trapper/itest/yline/itlrp.c
new file mode 100644
index 000000000..23a459d30
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlrp.c
@@ -0,0 +1,230 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlrp.c
+
+Abstract:
+
+    This module contains the test functions for lineRemoveProvider
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define DLG_TITLE_ADD        "TUISPI_providerInstall"
+#define DLG_TITLE_REMOVE     "TUISPI_providerRemove"
+
+//  lineRemoveProvider
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineRemoveProvider(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+	BOOL fEsp;
+   BOOL fUnimdm;
+   BOOL fRemovedProvider;
+   BOOL fAddProvider;
+#ifdef WUNICODE
+   WCHAR wszEspProviderFilename[] = L"esp32.tsp";
+   WCHAR wszUnimdmProviderFilename[] = L"unimdm.tsp";
+#else
+   CHAR szEspProviderFilename[] = "esp32.tsp";
+   CHAR szUnimdmProviderFilename[] = "unimdm.tsp";
+#endif
+
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"Test lineRemoveProvider");
+
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+//	lpTapiLineTestInfo->lpszProviderFilename = ESP_PROVIDERNAME;
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+	lpTapiLineTestInfo->lpdwPermanentProviderID = &lpTapiLineTestInfo->dwPermanentProviderID;
+
+//   strcpy(szTitle, DLG_TITLE_ADD);
+//   PrepareToAutoDismissDlg(TRUE);
+
+	if(FindESPLineDevice(lpTapiLineTestInfo))
+	{
+	fEsp = TRUE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+	 }
+	else if(FindUnimdmLineDevice(lpTapiLineTestInfo))
+	 {
+	  fEsp = FALSE;
+     fUnimdm = TRUE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszUnimdmProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szUnimdmProviderFilename;
+#endif
+    }
+	else
+     {
+     fEsp = FALSE;
+     fUnimdm = FALSE;
+#ifdef WUNICODE
+	  lpTapiLineTestInfo->lpwszProviderFilename = wszEspProviderFilename;
+#else
+	  lpTapiLineTestInfo->lpszProviderFilename = szEspProviderFilename;
+#endif
+     }
+    
+   strcpy(szTitle, DLG_TITLE_ADD);
+   PrepareToAutoDismissDlg(TRUE);
+	if(! DoLineAddProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fAddProvider = FALSE;
+    }
+	else
+        fAddProvider = TRUE;
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### dwPermanentProviderID = %lx",
+		lpTapiLineTestInfo->dwPermanentProviderID);
+
+	lpTapiLineTestInfo->lpProviderList = (LPLINEPROVIDERLIST) AllocFromTestHeap(
+		BUFSIZE);
+	lpTapiLineTestInfo->lpProviderList->dwTotalSize = BUFSIZE;
+
+    if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### lpLineProviderList->dwTotalSize = %lx, dwNeededSize = %lx, dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwTotalSize,
+		lpTapiLineTestInfo->lpProviderList->dwNeededSize,
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+ 
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineRemoveProvider");
+
+   if(fAddProvider)
+   {
+   strcpy(szTitle, DLG_TITLE_REMOVE);
+   PrepareToAutoDismissDlg(TRUE);
+
+	if(! DoLineRemoveProvider(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+        fRemovedProvider = FALSE;
+    }
+   else
+	     fRemovedProvider = TRUE;
+   PrepareToAutoDismissDlg(FALSE);
+   }
+	else
+     fRemovedProvider = FALSE;
+
+
+	// Verify by call lineGetProviderList
+
+    if (! DoLineGetProviderList(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### After Remove: lpLineProviderList->dwNumProviders = %lx",
+		lpTapiLineTestInfo->lpProviderList->dwNumProviders);
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRemoveProvider Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineRemoveProvider Test Failed");
+		
+     return fTestPassed;
+}
diff --git a/private/tapi/qa/trapper/itest/yline/itlta.c b/private/tapi/qa/trapper/itest/yline/itlta.c
new file mode 100644
index 000000000..3d40e1eed
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itlta.c
@@ -0,0 +1,173 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itlta.c
+
+Abstract:
+
+    This module contains the test functions for lineTranslateAddress
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+
+
+
+//  lineTranslateAddress
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTranslateAddress(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineTranslateAddress");
+
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+
+	// InitializeEx a line app
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineTranslateAddress for go/no-go");
+
+
+	lpTapiLineTestInfo->lpszAddressIn = "55555";
+	lpTapiLineTestInfo->dwCard = 0; // get from GetTranslateCaps
+	lpTapiLineTestInfo->dwTranslateOptions = LINETRANSLATEOPTION_CANCELCALLWAITING;
+	lpTapiLineTestInfo->lpTranslateOutput = (LPLINETRANSLATEOUTPUT) AllocFromTestHeap(
+		BUFSIZE);
+	lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize = BUFSIZE;
+
+   if (! DoLineTranslateAddress(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateOutput->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateOutput->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateOutput->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateOutput->dwCurrentCountry = %lx, dwDestCountry = %lx, dwResults = %lx",
+		lpTapiLineTestInfo->lpTranslateOutput->dwCurrentCountry,
+		lpTapiLineTestInfo->lpTranslateOutput->dwDestCountry,
+		lpTapiLineTestInfo->lpTranslateOutput->dwTranslateResults);
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateAddress Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateAddress Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/itltd.c b/private/tapi/qa/trapper/itest/yline/itltd.c
new file mode 100644
index 000000000..b0b08801e
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/itltd.c
@@ -0,0 +1,186 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    itltd.c
+
+Abstract:
+
+    This module contains the test functions for lineTranslateDialog
+
+Author:
+
+	 Xiao Ying Ding (XiaoD)		3-Jan-1996
+
+Revision History:
+
+--*/
+
+
+#include "windows.h"
+#include "malloc.h"
+#include "string.h"
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "ttest.h"
+#include "doline.h"
+#include "vars.h"
+#include "yline.h"
+
+#define DLG_TITLE    "Dialing Properties"
+
+
+
+//  lineTranslateDialog
+//
+//  The following tests are made:
+//
+//                               Tested                 Notes
+//  -------------------------------------------------------------------------
+// Go/No-Go test                                  
+//	
+// * = Stand-alone test case
+//
+//
+
+BOOL TestLineTranslateDialog(BOOL fQuietMode, BOOL fStandAlone)
+{
+   LPTAPILINETESTINFO  lpTapiLineTestInfo;
+   INT n;
+   BOOL fTestPassed                  = TRUE;
+
+   TapiLineTestInit();
+   lpTapiLineTestInfo = GetLineTestInfo();
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"\n*****************************************************************************************");
+
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		">> Test lineTranslateDialog");
+
+	// InitializeEx a line app
+    lpTapiLineTestInfo->lpLineInitializeExParams =
+         (LPLINEINITIALIZEEXPARAMS) AllocFromTestHeap (
+         sizeof(LINEINITIALIZEEXPARAMS));
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwTotalSize =
+         sizeof(LINEINITIALIZEEXPARAMS);
+    lpTapiLineTestInfo->lpLineInitializeExParams->dwOptions =
+         LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
+
+    lpTapiLineTestInfo->lpdwAPIVersion = &lpTapiLineTestInfo->dwAPIVersion;
+    lpTapiLineTestInfo->dwAPIVersion = TAPI_VERSION2_0;
+	if(! DoLineInitializeEx (lpTapiLineTestInfo, TAPISUCCESS))
+		{
+			TLINE_FAIL();
+		}
+
+	lpTapiLineTestInfo->dwDeviceID = (*(lpTapiLineTestInfo->lpdwNumDevs) == 0 ?
+		0 : *(lpTapiLineTestInfo->lpdwNumDevs)-1);
+ 	lpTapiLineTestInfo->dwAPILowVersion = LOW_APIVERSION;
+	lpTapiLineTestInfo->dwAPIHighVersion = HIGH_APIVERSION;
+
+    // Negotiate the API Version
+    if (! DoLineNegotiateAPIVersion(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    // Get the line device capabilities
+    lpTapiLineTestInfo->lpLineDevCaps = (LPLINEDEVCAPS) AllocFromTestHeap(
+            sizeof(LINEDEVCAPS)
+            );
+    lpTapiLineTestInfo->lpLineDevCaps->dwTotalSize = sizeof(LINEDEVCAPS);
+    if (! DoLineGetDevCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Open a line
+	lpTapiLineTestInfo->dwMediaModes = LINEMEDIAMODE_DATAMODEM;
+	lpTapiLineTestInfo->dwPrivileges = LINECALLPRIVILEGE_OWNER;
+
+	if (! DoLineOpen(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+				
+	OutputTAPIDebugInfo(
+		DBUG_SHOW_DETAIL,
+		"#### Test lineTranslateDialog for go/no-go");
+
+
+	lpTapiLineTestInfo->lpszAddressIn = "55555";
+	lpTapiLineTestInfo->hwndOwner = (HWND) GetTopWindow(NULL);
+
+   strcpy(szTitle, DLG_TITLE);
+   PrepareToAutoDismissDlg(TRUE);
+ 
+   if (! DoLineTranslateDialog(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+   PrepareToAutoDismissDlg(FALSE);
+
+	lpTapiLineTestInfo->dwCountryID = 1;
+	lpTapiLineTestInfo->lpTranslateCaps = (LPLINETRANSLATECAPS) AllocFromTestHeap(
+		sizeof(LINETRANSLATECAPS));
+	lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
+
+
+   if (! DoLineGetTranslateCaps(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwTotalSize = %lx, dwNeededSize = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwTotalSize,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNeededSize);
+
+
+	TapiLogDetail(
+		DBUG_SHOW_DETAIL,
+		"#### LineTranslateCaps->dwNumLocations = %lx, dwCurrentLocationID = %lx, dwnumCards = %lx",
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumLocations,
+		lpTapiLineTestInfo->lpTranslateCaps->dwCurrentLocationID,
+		lpTapiLineTestInfo->lpTranslateCaps->dwNumCards);
+
+
+   // Close the line
+    if (! DoLineClose(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+
+    // Shutdown and end the tests
+    if (! DoLineShutdown(lpTapiLineTestInfo, TAPISUCCESS))
+    {
+        TLINE_FAIL();
+    }
+
+    FreeTestHeap();
+	
+	if(fTestPassed)
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateDialog Test Passed");
+	else
+		OutputTAPIDebugInfo(
+			DBUG_SHOW_DETAIL,
+			"lineTranslateDialog Test Failed");
+		
+     return fTestPassed;
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/makefile b/private/tapi/qa/trapper/itest/yline/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/itest/yline/sources b/private/tapi/qa/trapper/itest/yline/sources
new file mode 100644
index 000000000..e9a23325f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/sources
@@ -0,0 +1,71 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+NOTE:   Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+Revision History:
+
+!ENDIF
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=yline
+TARGETPATH=$(BASEDIR)\public\sdk\lib
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+           $(BASEDIR)\public\sdk\lib\*\user32.lib \
+           $(BASEDIR)\public\sdk\lib\*\tcore.lib \
+           $(BASEDIR)\public\sdk\lib\*\ttest.lib \
+           $(BASEDIR)\public\sdk\lib\*\tapi32.lib
+
+
+DLLBASE=0x65000000
+
+INCLUDES=..;.;..\..\..\tcore;..\..
+		
+
+USE_CRTDLL=1
+
+SOURCES=	yline.c \
+		itlap.c \
+		itlcp.c	\
+		itlgpl.c  \
+		itlrp.c	  \
+		itlgdt.c \
+		itlgc.c	\
+		itlgtc.c \
+		itlta.c	\
+		itltd.c	\
+		itlho.c	\
+		itlgi.c	\
+		itlgtn.c \
+		yline.rc
+
+
+C_DEFINES=-DWINVER=0x400 -DTAPI_NT=1 -DTAPI_1_1=1 -DTAPI_1_4=1 -DTAPI_2_0=1
+
+UMTYPE=windows
+
+DLLENTRY=YLineDllMain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
diff --git a/private/tapi/qa/trapper/itest/yline/yline.c b/private/tapi/qa/trapper/itest/yline/yline.c
new file mode 100644
index 000000000..f4cd22460
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/yline.c
@@ -0,0 +1,303 @@
+
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    yline.c
+
+Abstract:
+
+    This module contains functions for testing Telephony line device APIs.
+
+Author:
+
+    Xiao Ying Ding (XiaoD) 	26-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "doline.h"
+#include "dophone.h"
+#include "tcore.h"
+#include "vars.h"
+#include "yline.h"
+
+
+// Put a module usage counter in a shared data section.
+// Its value will be used to determine whether or not the ttest dll
+// and the tcore dll should be loaded/freed during a process
+// attach/detach, respectively.
+#pragma data_seg("Shared")
+
+LONG glModuleUsage = 0;
+
+#pragma data_seg()
+
+
+// Instruct the linker to make the Shared section readable,
+// writable, and shared.
+#pragma data_seg(".drectve")
+    static char szLinkDirectiveShared[] = "-section:Shared,rws";
+#pragma data_seg()
+
+
+// Globals for storing dll handles and the log function pointer
+HANDLE ghYLineDll    = NULL;
+LOGPROC glpfnLogProc = NULL;
+CHAR gszTcoreDll[]   = "tcore";
+CHAR gszTtestDll[]   = "ttest";
+
+
+BOOL
+WINAPI
+YLineDllMain(
+    HANDLE  hDLL,
+    DWORD   dwReason,
+    LPVOID  lpReserved
+    )
+{
+    HANDLE hTcoreDll;
+    HANDLE hTtestDll;
+    BOOL fFreeOK;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            // Increment this module's usage count
+            InterlockedIncrement((PLONG) &glModuleUsage);
+
+            ghYLineDll = hDLL;
+
+            // Load the tcore dll and the ttest dll if this is the
+            // first process to attach and if the dlls haven't already
+            // been mapped into this process's address space.
+            if (glModuleUsage == 1)
+            {
+                if (GetModuleHandle(gszTcoreDll) == NULL);
+                {
+                    hTcoreDll = LoadLibrary(gszTcoreDll);
+                }
+
+                if (GetModuleHandle(gszTtestDll) == NULL);
+                {
+                    hTtestDll = LoadLibrary(gszTtestDll);
+                }
+
+                if (hTcoreDll == NULL || hTtestDll == NULL)
+                {
+                    return FALSE;
+                }
+            }
+
+            break;
+
+        case DLL_THREAD_ATTACH:
+
+            break;
+
+        case DLL_THREAD_DETACH:
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+
+            // Decrement this module's usage count
+            InterlockedDecrement((PLONG) &glModuleUsage);
+
+            // Free the tcore dll if this is the last process
+            // to detach and if the core dll is mapped into this
+            // process's address space.
+            if (glModuleUsage == 0)
+            {
+                if ((hTcoreDll = GetModuleHandle(gszTcoreDll)) != NULL)
+                {
+                    fFreeOK = FreeLibrary(hTcoreDll);
+                }
+
+                if ((hTtestDll = GetModuleHandle(gszTtestDll)) != NULL)
+                {
+                    return ( fFreeOK && (FreeLibrary(hTtestDll)) );
+                }
+            }
+
+            break;
+    }
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    )
+{
+    // Store the log function pointer and pass it to the core dll.
+    // Return whether or not the core suite init function succeeds.
+    glpfnLogProc = pfnLog;
+    return (TcoreSuiteInit(pfnLog));
+}
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    )
+{
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "About the Interface Test Suite", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    )
+{
+    MessageBox (hwndOwner, "xxx", "Interface Test Suite Config", MB_OK);
+
+    return TRUE;
+}
+
+
+BOOL
+WINAPI
+Test1(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineAddProvider(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test2(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineConfigProvider(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test3(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGenerateDigits(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test4(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetCountry(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test5(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetProviderList(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test6(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetTranslateCaps(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test7(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineRemoveProvider(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test8(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTranslateAddress(TRUE, FALSE));
+}
+
+
+BOOL
+WINAPI
+Test9(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineTranslateDialog(TRUE, FALSE));
+}
+
+
+
+BOOL
+WINAPI
+Test10(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGetIcon(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test11(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineGenerateTone(TRUE, FALSE));
+}
+
+BOOL
+WINAPI
+Test12(
+    HINSTANCE   hAppInst
+    )
+{
+    return (TestLineHandoff(TRUE, FALSE));
+}
+
+
diff --git a/private/tapi/qa/trapper/itest/yline/yline.def b/private/tapi/qa/trapper/itest/yline/yline.def
new file mode 100644
index 000000000..817b1554f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/yline.def
@@ -0,0 +1,23 @@
+LIBRARY         yline
+
+CODE            MOVEABLE DISCARDABLE
+DATA            READ WRITE PRELOAD MOVEABLE
+
+EXPORTS
+        SuiteInit
+        SuiteShutdown
+        SuiteAbout
+        SuiteConfig
+        Test1
+        Test2
+        Test3
+        Test4
+        Test5
+        Test6
+        Test7
+        Test8
+        Test9
+        Test10
+        Test11
+        Test12
+
diff --git a/private/tapi/qa/trapper/itest/yline/yline.h b/private/tapi/qa/trapper/itest/yline/yline.h
new file mode 100644
index 000000000..7bccd0415
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/yline.h
@@ -0,0 +1,175 @@
+/*++
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    yline.h
+
+Abstract:
+
+    This module contains prototypes for testing TAPI line device functions.
+
+Author:
+
+    Xiao Ying Ding (XiaoD)    1-Dec-1995
+
+Revision History:
+
+--*/
+
+
+#ifndef YLINE_H
+#define YLINE_H
+
+
+#include <windows.h>
+#include "tapi.h"
+#include "trapper.h"
+#include "tcore.h"
+#include "vars.h"
+
+
+
+typedef struct TAPILINETESTDEVSPEC_TAG {
+	DWORD lResult;
+	DWORD	dwRequestID;
+	} TAPILINETESTDEVSPEC, FAR * LPTAPILINETESTDEVSPEC;
+
+
+#define LINEADDRESSSTATE_ALL (LINEADDRESSSTATE_OTHER       | \
+                              LINEADDRESSSTATE_DEVSPECIFIC | \
+                              LINEADDRESSSTATE_INUSEZERO   | \
+                              LINEADDRESSSTATE_INUSEONE    | \
+                              LINEADDRESSSTATE_INUSEMANY   | \
+                              LINEADDRESSSTATE_NUMCALLS    | \
+                              LINEADDRESSSTATE_FORWARD     | \
+                              LINEADDRESSSTATE_TERMINALS   | \
+                              LINEADDRESSSTATE_CAPSCHANGE    \
+                             )
+
+
+// Macro for handling unexpected failures during the tests
+#define TLINE_FAIL()   {                                                    \
+                           if (ShouldTapiTestAbort(                         \
+                                   lpTapiLineTestInfo->szTestFunc,          \
+                                   fQuietMode))                             \
+                           {                                                \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp1); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp2); \
+                               lineShutdown(lpTapiLineTestInfo->hLineApp3); \
+                               return FALSE;                                \
+                           }                                                \
+                           fTestPassed = FALSE;                             \
+                         }
+
+
+
+
+
+BOOL
+WINAPI
+SuiteInit(
+    LOGPROC pfnLog
+    );
+
+
+BOOL
+WINAPI
+SuiteShutdown(
+    void
+    );
+
+
+BOOL
+WINAPI
+SuiteAbout(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+WINAPI
+SuiteConfig(
+    HWND    hwndOwner
+    );
+
+
+BOOL
+TestLineAddProvider(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineConfigProvider(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGenerateDigits(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetCountry(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetProviderList(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGetTranslateCaps(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineRemoveProvider(
+    BOOL fQuietMode,
+    BOOL fStandAloneTest
+    );
+
+BOOL
+TestLineTranslateAddress(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineTranslateDialog(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+BOOL
+TestLineGetIcon(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+BOOL
+TestLineGenerateTone(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+BOOL
+TestLineHandoff(
+    BOOL fQuietMode,
+    BOOL fStandAlone
+    );
+
+
+
+#endif  // YLINE_H
diff --git a/private/tapi/qa/trapper/itest/yline/yline.rc b/private/tapi/qa/trapper/itest/yline/yline.rc
new file mode 100644
index 000000000..a4b27549f
--- /dev/null
+++ b/private/tapi/qa/trapper/itest/yline/yline.rc
@@ -0,0 +1,13 @@
+#include <windows.h>
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_APP
+#define	VER_FILESUBTYPE	            VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "TAPI YLine API test Library"
+#define VER_INTERNALNAME_STR        "yline.dll"
+#define VER_ORIGINALFILENAME_STR    "yline.dll"
+
+#include "common.ver"
+
+
+
diff --git a/private/tapi/qa/trapper/private.h b/private/tapi/qa/trapper/private.h
new file mode 100644
index 000000000..8ade1516f
--- /dev/null
+++ b/private/tapi/qa/trapper/private.h
@@ -0,0 +1,116 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    private.h
+
+Abstract:
+
+    This module contains private defs for the trapper (test wrapper) app
+
+Author:
+
+    Dan Knudson (DanKn)    06-Jun-1995
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+#define TRAPP_LOGLEVEL_PARAMS          11
+#define TRAPP_LOGLEVEL_NOPARAMS	      7
+#define TRAPP_LOGLEVEL_NOENTEREXIT	   5
+#define TRAPP_LOGLEVEL_PASSONLY			2
+
+
+#define INIT_MENU_POS           0
+#define HELLO_MENU_POS          2
+
+#define IDM_NEWTESTTHREAD       10
+#define IDM_CLOSE               11
+#define IDM_MEMORYSTATUS        12
+#define IDM_LOADTAPI            13
+#define IDM_UNLOADTAPI          14
+#define IDM_EXIT                15
+
+#define IDM_START               20
+#define IDM_STOP                21
+#define IDM_KILLTAPISRV			22
+#define IDM_LOGFILE             23
+#define IDM_RUNONCE             24
+#define IDM_RUNFOREVER          25
+#define IDM_STOPONFAILURE       26
+#define IDM_ALLTESTS            27
+#define IDM_NOTESTS             28
+#define IDM_ALLTESTSINSUITE     29
+#define IDM_NOTESTSINSUITE      30
+#define IDM_CONFIGSUITE         31
+#define IDM_ABOUTSUITE          32
+#define IDM_PARAMS				33
+#define IDM_NOPARAMS            34
+#define IDM_NOENTEREXIT         35
+#define IDM_PASSONLY            36
+
+
+#define IDM_TILE                80
+#define IDM_CASCADE             81
+#define IDM_ARRANGE             82
+#define IDM_CLOSEALL            83
+
+#define IDM_USAGE               90
+#define IDM_ABOUT               91
+
+#define IDC_LIST1               100
+#define IDC_EDIT1               101
+#define IDC_EDIT2               102
+
+#define IDM_FIRSTCHILD          1000
+
+#define IDD_DIALOG1             50
+
+#define TRAPPER_MSG_KEY         0x95551212
+
+#define WM_ADDTEXT              (WM_USER + 0x55)
+#define WM_TESTTHREADTERMINATED (WM_USER + 0x56)
+
+
+typedef struct _INSTANCE_INFO
+{
+    HWND    hwnd;
+
+    HWND    hwndList1;
+
+    HWND    hwndList2;
+
+    HWND    hwndEdit1;
+
+    HWND    hwndEdit2;
+
+    int     iNumSuites;
+
+    DWORD   dwTextBufTotalSize;
+
+    DWORD   dwTextBufUsedSize;
+
+    char   *pTextBuf;
+
+    HANDLE  hTextBufMutex;
+
+    FILE   *hLogFile;
+
+    BOOL    bTestInProgress;
+
+    BOOL    bStopTest;
+
+    BOOL    bStopOnFailure;
+
+    BOOL    bRunForever;
+
+    BOOL    bLogFile;
+
+} INSTANCE_INFO, FAR *PINSTANCE_INFO;
diff --git a/private/tapi/qa/trapper/readme.txt b/private/tapi/qa/trapper/readme.txt
new file mode 100644
index 000000000..d7f2100d2
--- /dev/null
+++ b/private/tapi/qa/trapper/readme.txt
@@ -0,0 +1,26 @@
+Readme file for running TAPI tests.
+
+1. Make sure trapper.ini get updated, make sure the path of dll is correct.
+2. Testapp.exe is a window application, it used to help test some tapi apis.  
+   After finish test, should manuly to close it.
+3. Before run test, run espexe make sure the default values are set correct.
+   Num Lines  ~ 3
+   Num Phones ~ 4
+   Num Add Per Line ~ 3
+   Num Calls Per Add ~8
+4. In trapper, there is a menu item, "Select Log Level".  And submenu for select 
+   "With Params" that is print out params. "No Params" that is not print out params
+   but all others. "No EnterExit" that is not print out ENTER_EXIT info for
+   all apis.  "Pass/Fail" that is print out the Passed/Failed log info only.  The 
+    default is With Params, then user can set up to differnt log level. 
+5. iline.dll doesn't support lineAccept and lineAnswer for Unimodem.  It needs
+   test by manuly.
+   The steps:
+   - Run tb20
+   - Call lineInitialize, must have two lines and two modems installed
+   - Call lineOpen at dwDeviceID 0, with NONE priviledge
+   - Call lineOpen at dwDeviceID 1, with OWNER priviledge
+   - Call lineMakeCall at dwDeviceID 0, with lpszDestAddress of line2
+   - Call lineAccept or lineAnswer, select hCall with OFFERING state
+   - It should accepted
+   
diff --git a/private/tapi/qa/trapper/trapper.c b/private/tapi/qa/trapper/trapper.c
new file mode 100644
index 000000000..e953fd5ce
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper.c
@@ -0,0 +1,1901 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    trapper.c
+
+Abstract:
+
+    This module contains the src for the trapper (test wrapper) app
+
+Author:
+
+    Dan Knudson (DanKn)    06-Jun-1995
+
+Revision History:
+
+	Javed Rasool (JavedR)  01-July 1996		Added IDM_KILLTAPISRV (i.e., menu command to Kill Tapisrv.exe)
+											Also modifed corresponding files: trapper.rc and private.h
+
+Notes:
+
+
+--*/
+
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <time.h>
+#include <commdlg.h>
+#include "private.h"
+#include "trapper.h"
+
+
+#ifdef WIN32
+#define _export
+#define __export
+#endif
+
+
+char   szFrameClass [] = "MdiFrame";
+char   szHelloClass [] = "MdiHelloChild";
+HANDLE hInst;
+HMENU  hMenuInit, hMenuHello;
+HMENU  hMenuInitWindow, hMenuHelloWindow;
+HWND   hwndClient, hwndFrame;
+
+char gszTrapperIni[] = ".\\trapper.ini";
+
+int    giLogLevel = TRAPP_LOGLEVEL_PARAMS;
+
+DWORD  gdwTlsIndex;
+
+MEMORYSTATUS gInitialMemoryStatus;
+
+
+BOOL
+CALLBACK
+FrameWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+BOOL
+FAR
+PASCAL
+_export
+CloseEnumProc(
+    HWND    hwnd,
+    LONG    lParam
+    );
+
+BOOL
+CALLBACK
+HelloWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+void
+TestThread(
+    PINSTANCE_INFO pInstInfo
+    );
+
+BOOL
+CALLBACK
+MemoryStatusWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    );
+
+VOID
+ShowStr(
+    PINSTANCE_INFO pInstInfo,
+    char far *format,
+    ...
+    );
+
+void
+__export
+LogProc(
+    int     level,
+    char   *format,
+    ...
+    );
+
+
+int
+WINAPI
+WinMain(
+    HINSTANCE   hInstance,
+    HINSTANCE   hPrevInstance,
+    LPSTR       lpCmdLine,
+    int         nCmdShow
+    )
+{
+    HANDLE   hAccel;
+    MSG      msg;
+    WNDCLASS wndclass;
+
+
+    hInst = hInstance;
+
+    if (!hPrevInstance)
+    {
+	wndclass.style         = CS_HREDRAW | CS_VREDRAW;
+	wndclass.lpfnWndProc   = FrameWndProc;
+	wndclass.cbClsExtra    = 0;
+	wndclass.cbWndExtra    = 0;
+	wndclass.hInstance     = hInstance;
+	wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
+	wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
+	wndclass.hbrBackground = GetStockObject (LTGRAY_BRUSH);
+	wndclass.lpszMenuName  = NULL;
+	wndclass.lpszClassName = szFrameClass;
+
+	RegisterClass (&wndclass);
+
+	wndclass.style         = CS_HREDRAW | CS_VREDRAW;
+	wndclass.lpfnWndProc   = HelloWndProc;
+	wndclass.cbClsExtra    = 0;
+	wndclass.cbWndExtra    = sizeof (PINSTANCE_INFO);
+	wndclass.hInstance     = hInstance;
+	wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
+	wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
+	wndclass.hbrBackground = GetStockObject (LTGRAY_BRUSH);
+	wndclass.lpszMenuName  = NULL;
+	wndclass.lpszClassName = szHelloClass;
+
+	RegisterClass (&wndclass);
+    }
+
+    hMenuInit  = LoadMenu (hInst, "MdiMenuInit");
+    hMenuHello = LoadMenu (hInst, "MdiMenuHello");
+
+    if (!hMenuInit || !hMenuHello)
+    {
+	MessageBox (NULL, "err1", "", MB_OK);
+    }
+
+    hMenuInitWindow  = GetSubMenu (hMenuInit,  INIT_MENU_POS);
+    hMenuHelloWindow = GetSubMenu (hMenuHello, HELLO_MENU_POS);
+
+    if (!hMenuInitWindow || !hMenuHelloWindow)
+    {
+	MessageBox (NULL, "err1", "", MB_OK);
+    }
+
+    hAccel = LoadAccelerators (hInst, "MdiAccel");
+
+    hwndFrame = CreateWindow(
+	szFrameClass,
+	"Test wRAPPER",
+	WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
+	CW_USEDEFAULT,
+	CW_USEDEFAULT,
+	CW_USEDEFAULT,
+	CW_USEDEFAULT,
+	NULL,
+	hMenuInit,
+	hInstance,
+	NULL
+	);
+
+    hwndClient = GetWindow (hwndFrame, GW_CHILD);
+
+    ShowWindow (hwndFrame, nCmdShow);
+    UpdateWindow (hwndFrame);
+ 
+
+    if ((gdwTlsIndex = TlsAlloc()) == 0xffffffff)
+    {
+	// BUGBUG
+    }
+
+    GlobalMemoryStatus (&gInitialMemoryStatus);
+
+    while (GetMessage (&msg, NULL, 0, 0))
+    {
+	if (!TranslateMDISysAccel (hwndClient, &msg) &&
+	    !TranslateAccelerator (hwndFrame, hAccel, &msg))
+	{
+	    TranslateMessage (&msg);
+	    DispatchMessage (&msg);
+	}
+    }
+
+    DestroyMenu (hMenuHello);
+
+    return msg.wParam;
+}
+
+
+BOOL
+CALLBACK
+FrameWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    static  HANDLE  hTapiLib = (HANDLE) NULL;
+
+    CLIENTCREATESTRUCT clientcreate;
+    FARPROC            lpfnEnum;
+    HWND               hwndChild;
+    MDICREATESTRUCT    mdicreate;
+
+
+    switch (msg)
+    {
+    case WM_CREATE:          // Create the client window
+
+	clientcreate.hWindowMenu  = hMenuInitWindow ;
+	clientcreate.idFirstChild = IDM_FIRSTCHILD ;
+
+	hwndClient = CreateWindow(
+	    "MDICLIENT",
+	    NULL,
+	    WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
+	    0,
+	    0,
+	    0,
+	    0,
+	    hwnd,
+	    (HMENU) 1,
+	    hInst,
+	    (LPVOID) &clientcreate
+	    );
+
+	return 0;
+
+    case WM_COMMAND:
+
+	switch (LOWORD(wParam))
+	{
+	case IDM_NEWTESTTHREAD:       // Create a Hello child window
+
+	    mdicreate.szClass = szHelloClass;
+	    mdicreate.szTitle = "Test Thread: stopped";
+	    mdicreate.hOwner  = hInst;
+	    mdicreate.x       = CW_USEDEFAULT;
+	    mdicreate.y       = CW_USEDEFAULT;
+	    mdicreate.cx      = CW_USEDEFAULT;
+	    mdicreate.cy      = CW_USEDEFAULT;
+	    mdicreate.style   = 0;
+	    mdicreate.lParam  = 0;
+
+	    hwndChild = (HWND) SendMessage(
+		hwndClient,
+		WM_MDICREATE,
+		0,
+		(LPARAM) &mdicreate
+		);
+
+	    return 0 ;
+
+	case IDM_CLOSE:          // Close the active window
+
+	    hwndChild = (HWND)SendMessage (hwndClient, WM_MDIGETACTIVE, 0, 0L);
+
+	    if (SendMessage (hwndChild, WM_QUERYENDSESSION, 0, 0L))
+	    {
+		SendMessage (hwndClient, WM_MDIDESTROY, (WPARAM) hwndChild, 0L);
+	    }
+
+	    return 0 ;
+
+	case IDM_MEMORYSTATUS:
+
+	    DialogBox(
+		hInst,
+		MAKEINTRESOURCE (IDD_DIALOG1),
+		hwnd,
+		(DLGPROC) MemoryStatusWndProc
+		);
+
+	    break;
+
+	case IDM_LOADTAPI:
+
+	    if (!hTapiLib)
+	    {
+		if (!(hTapiLib = LoadLibrary ("tapi32.dll")))
+		{
+		    char buf[64];
+
+		    wsprintf(
+			buf,
+			"LoadLib(tapi32) failed, err=%d",
+			GetLastError()
+			);
+
+		    MessageBox (hwnd, buf, "Trapper: Error", MB_OK);
+		}
+	    }
+
+	    break;
+
+	case IDM_UNLOADTAPI:
+
+	    if (hTapiLib)
+	    {
+		FreeLibrary (hTapiLib);
+
+		hTapiLib = (HANDLE) NULL;
+	    }
+
+	    break;
+
+	case IDM_EXIT:           // Exit the program
+
+	    SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
+	    return 0;
+
+	case IDM_TILE:
+
+	    SendMessage (hwndClient, WM_MDITILE, 0, 0L);
+	    return 0;
+
+	case IDM_CASCADE:
+
+	    SendMessage (hwndClient, WM_MDICASCADE, 0, 0L);
+	    return 0;
+
+	case IDM_ARRANGE:
+
+	    SendMessage (hwndClient, WM_MDIICONARRANGE, 0, 0L);
+	    return 0;
+
+	case IDM_CLOSEALL:
+
+	    EnumChildWindows (hwndClient, CloseEnumProc, 0L);
+	    return 0;
+
+	case IDM_USAGE:
+	{
+	    static char szDlgText[] =
+
+		"ABSTRACT:\n\r"                                               \
+		"    Trapper is...\n\r"                                       \
+
+		"\n\rGETTING STARTED:\n\r"                                    \
+		"    1. Choose 'File/New Test Thread' to ...\n\r"             \
+
+		"\n\rMORE INFO:\n\r"                                          \
+		"    *  ...\n\r";
+
+	    MessageBox (hwnd, szDlgText, "Using Trapper", MB_OK);
+
+	    break;
+	}
+	case IDM_ABOUT:
+
+	    MessageBox (hwnd, "xxx", "About Trapper", MB_OK);
+
+	    break;
+
+	default:            // Pass to active child
+
+	    hwndChild = (HWND) SendMessage(hwndClient, WM_MDIGETACTIVE, 0, 0L);
+
+	    if (IsWindow (hwndChild))
+	    {
+		SendMessage (hwndChild, WM_COMMAND, wParam, lParam);
+	    }
+	    break;
+	}
+	break;
+
+    case WM_PAINT:
+    {
+	PAINTSTRUCT ps;
+
+
+	BeginPaint (hwnd, &ps);
+	FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+	EndPaint (hwnd, &ps);
+	break;
+    }
+    case WM_QUERYENDSESSION:
+    case WM_CLOSE:                     // Attempt to close all children
+
+	SendMessage (hwnd, WM_COMMAND, IDM_CLOSEALL, 0L);
+
+	if (NULL != GetWindow (hwndClient, GW_CHILD))
+	{
+	    return 0;
+	}
+
+	break;
+
+    case WM_DESTROY:
+
+	PostQuitMessage (0);
+
+	if (hTapiLib)
+	{
+	    FreeLibrary (hTapiLib);
+	}
+
+	return 0;
+    }
+
+    // Pass unprocessed messages to DefFrameProc (not DefWindowProc)
+
+    return DefFrameProc (hwnd, hwndClient, msg, wParam, lParam);
+}
+
+
+BOOL
+FAR
+PASCAL
+_export
+CloseEnumProc(
+    HWND    hwnd,
+    LONG    lParam
+    )
+{
+    if (GetWindow (hwnd, GW_OWNER)) // check for icon title
+    {
+	return 1;
+    }
+
+    SendMessage (GetParent (hwnd), WM_MDIRESTORE, (WPARAM) hwnd, 0L);
+
+    if (!SendMessage (hwnd, WM_QUERYENDSESSION, 0, 0L))
+    {
+	return 1 ;
+    }
+
+    SendMessage (GetParent (hwnd), WM_MDIDESTROY, (WPARAM) hwnd, 0L);
+
+    return 1 ;
+}
+
+
+void
+MungeMenuState(
+    PINSTANCE_INFO  pInstInfo
+    )
+{
+    //
+    // Check/uncheck the appropriate items given the inst info
+    //
+
+    CheckMenuItem(
+	hMenuHello,
+	IDM_STOPONFAILURE,
+	(pInstInfo->bStopOnFailure ? MF_CHECKED : MF_UNCHECKED) |
+	    MF_BYCOMMAND
+	);
+
+    CheckMenuItem(
+	hMenuHello,
+	IDM_RUNONCE,
+	(pInstInfo->bRunForever ? MF_UNCHECKED : MF_CHECKED) |
+	    MF_BYCOMMAND
+	);
+
+    CheckMenuItem(
+	hMenuHello,
+	IDM_RUNFOREVER,
+	(pInstInfo->bRunForever ? MF_CHECKED : MF_UNCHECKED) |
+	    MF_BYCOMMAND
+	);
+
+    if(giLogLevel == TRAPP_LOGLEVEL_PARAMS)
+      {
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PARAMS,
+	   MF_CHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOPARAMS,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOENTEREXIT,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PASSONLY,
+	   MF_UNCHECKED
+	   );
+	}
+
+    else if(giLogLevel == TRAPP_LOGLEVEL_NOPARAMS)
+      {
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PARAMS,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOPARAMS,
+	   MF_CHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOENTEREXIT,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PASSONLY,
+	   MF_UNCHECKED
+	   );
+	}
+
+    else if(giLogLevel == TRAPP_LOGLEVEL_NOENTEREXIT)
+      {
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PARAMS,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOPARAMS,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOENTEREXIT,
+	   MF_CHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PASSONLY,
+	   MF_UNCHECKED
+	   );
+	}
+
+    else if(giLogLevel == TRAPP_LOGLEVEL_PASSONLY)
+      {
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PARAMS,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOPARAMS,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_NOENTEREXIT,
+	   MF_UNCHECKED
+	   );
+       CheckMenuItem(
+	   hMenuHello,
+	   IDM_PASSONLY,
+	   MF_CHECKED
+	   );
+	}
+
+
+    CheckMenuItem(
+	hMenuHello,
+	IDM_LOGFILE,
+	(pInstInfo->bLogFile ? MF_CHECKED : MF_UNCHECKED) |
+	    MF_BYCOMMAND
+	);
+
+
+    //
+    // Enable/disable the appropriate items given the inst info
+    //
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_START,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_STOP,
+	(pInstInfo->bTestInProgress ? MF_ENABLED : (MF_DISABLED | MF_GRAYED))
+	    | MF_BYCOMMAND
+	);
+
+	EnableMenuItem(
+	hMenuHello,
+	IDM_KILLTAPISRV,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED) 
+		|MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_RUNONCE,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_RUNFOREVER,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_STOPONFAILURE,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_ALLTESTS,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_NOTESTS,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_ALLTESTSINSUITE,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_NOTESTSINSUITE,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_CONFIGSUITE,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED)
+	    | MF_BYCOMMAND
+	);
+
+    EnableMenuItem(
+	hMenuHello,
+	IDM_ABOUTSUITE,
+	(pInstInfo->bTestInProgress ? (MF_DISABLED | MF_GRAYED) : MF_ENABLED) | MF_BYCOMMAND
+	);
+}
+
+
+BOOL
+CALLBACK
+HelloWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    HMENU           hMenu;
+    PINSTANCE_INFO  pInstInfo = (PINSTANCE_INFO) GetWindowLong (hwnd, 0);
+
+   switch (msg)
+    {
+    case WM_CREATE:
+    {
+	int     i;
+	RECT    rect;
+
+
+	pInstInfo = LocalAlloc (LPTR, sizeof(INSTANCE_INFO));
+
+	memset (pInstInfo, 0, sizeof (INSTANCE_INFO));
+
+	SetWindowLong (hwnd, 0, (LONG) pInstInfo);
+ 
+ 
+	pInstInfo->hwnd = hwnd;
+
+	pInstInfo->hTextBufMutex = CreateMutex (NULL, FALSE, NULL);
+
+	pInstInfo->dwTextBufTotalSize = 2048;
+	pInstInfo->dwTextBufUsedSize  = 0;
+
+	pInstInfo->pTextBuf = LocalAlloc (LPTR, pInstInfo->dwTextBufTotalSize);
+
+	pInstInfo->pTextBuf[0] = 0;
+
+	pInstInfo->hwndList1 = CreateWindow (
+	    "listbox",
+	    "",
+	    WS_VISIBLE | WS_CHILD | WS_BORDER | LBS_NOINTEGRALHEIGHT |
+		WS_VSCROLL | LBS_HASSTRINGS | LBS_NOTIFY,
+	    0,
+	    0,
+	    0,
+	    0,
+	    hwnd,
+	    (HMENU) IDC_LIST1,
+	    hInst,
+	    NULL
+	    );
+
+	pInstInfo->hwndEdit1 = CreateWindow (
+	    "edit",
+	    "",
+	    WS_VISIBLE | WS_CHILD | WS_BORDER | ES_MULTILINE |
+		ES_AUTOHSCROLL | WS_VSCROLL,
+	    0,
+	    0,
+	    0,
+	    0,
+	    hwnd,
+	    (HMENU) IDC_EDIT1,
+	    hInst,
+	    NULL
+	    );
+
+	pInstInfo->hwndEdit2 = CreateWindow (
+	    "edit",
+	    "",
+	    WS_VISIBLE | WS_CHILD | WS_BORDER | ES_AUTOHSCROLL,
+	    0,
+	    0,
+	    0,
+	    0,
+	    hwnd,
+	    (HMENU) IDC_EDIT2,
+	    hInst,
+	    NULL
+	    );
+
+	pInstInfo->iNumSuites = GetPrivateProfileInt(
+	    "Suites",
+	    "NumSuites",
+	    0,
+	    gszTrapperIni
+	    );
+
+	for (i = 0; i < pInstInfo->iNumSuites; i++)
+	{
+	    #define BUFSIZE 256
+
+	    int     j, iNumTests;
+	    char    szSuiteN[16], buf[BUFSIZE];
+	    HWND    hwndList;
+
+
+	    wsprintf (szSuiteN, "Suite%d", i + 1);
+
+	    GetPrivateProfileString(
+		szSuiteN,
+		"Description",
+		"<bogus description>",
+		buf,
+		BUFSIZE,
+		gszTrapperIni
+		);
+
+	    SendMessage (pInstInfo->hwndList1, LB_ADDSTRING, 0, (LPARAM) buf);
+
+	    if (!(hwndList = CreateWindow (
+		    "listbox",
+		    "",
+		    WS_CHILD | WS_BORDER | LBS_NOINTEGRALHEIGHT | WS_VSCROLL |
+			LBS_HASSTRINGS | LBS_MULTIPLESEL | WS_VISIBLE,
+		    0,
+		    0,
+		    0,
+		    0,
+		    hwnd,
+		    NULL,
+		    hInst,
+		    NULL
+		    )))
+	    {
+		MessageBox (NULL, "CreateWnd failed", "", MB_OK);
+	    }
+
+	    SendMessage(
+		pInstInfo->hwndList1,
+		LB_SETITEMDATA,
+		i,
+		(LPARAM) hwndList
+		);
+
+	    iNumTests = GetPrivateProfileInt(
+		szSuiteN,
+		"NumTests",
+		0,
+		gszTrapperIni
+		);
+
+	    for (j = 0; j < iNumTests; j++)
+	    {
+		char szTestN[16];
+
+
+		wsprintf (szTestN, "Test%d", j + 1);
+
+		GetPrivateProfileString(
+		    szSuiteN,
+		    szTestN,
+		    "<bogus description>",
+		    buf,
+		    BUFSIZE,
+		    gszTrapperIni
+		    );
+
+		SendMessage(
+		    hwndList,
+		    LB_ADDSTRING,
+		    0,
+		    (LPARAM) (strstr (buf, ",") + 1)
+		    );
+	    }
+
+	    if (i == 0)
+	    {
+		pInstInfo->hwndList2 = hwndList;
+	    }
+	}
+
+	SendMessage (pInstInfo->hwndList1, LB_SETCURSEL, 0, 0);
+
+	GetClientRect (hwnd, &rect);
+
+	SendMessage(
+	    hwnd,
+	    WM_SIZE,
+	    0,
+	    MAKELONG((rect.right-rect.left),(rect.bottom-rect.top))
+	    );
+
+	CheckMenuItem (hMenuHello, IDM_RUNONCE, MF_CHECKED | MF_BYCOMMAND);
+
+	return 0 ;
+    }
+    case WM_COMMAND:
+
+	switch (LOWORD(wParam))
+	{
+	case IDC_EDIT1:
+
+#ifdef WIN32
+	    if (HIWORD(wParam) == EN_CHANGE)
+#else
+	    if (HIWORD(lParam) == EN_CHANGE)
+#endif
+	    {
+		//
+		// Watch to see if the edit control is full, & if so
+		// purge the top half of the text to make room for more
+		//
+
+		int length = GetWindowTextLength (pInstInfo->hwndEdit1);
+
+
+		if (length > 29998)
+		{
+#ifdef WIN32
+		    SendMessage(
+			pInstInfo->hwndEdit1,
+			EM_SETSEL,
+			(WPARAM) 0,
+			(LPARAM) 10000
+			);
+#else
+		    SendMessage(
+			pInstInfo->hwndEdit1,
+			EM_SETSEL,
+			(WPARAM) 1,
+			(LPARAM) MAKELONG (0, 10000)
+			);
+#endif
+
+		    SendMessage(
+			pInstInfo->hwndEdit1,
+			EM_REPLACESEL,
+			0,
+			(LPARAM) (char far *) ""
+			);
+
+#ifdef WIN32
+		    SendMessage(
+			pInstInfo->hwndEdit1,
+			EM_SETSEL,
+			(WPARAM)0xfffffffd,
+			(LPARAM)0xfffffffe
+			);
+#else
+		    SendMessage(
+			pInstInfo->hwndEdit1,
+			EM_SETSEL,
+			(WPARAM)1,
+			(LPARAM) MAKELONG (0xfffd, 0xfffe)
+			);
+#endif
+		}
+	    }
+	    break;
+
+	case IDC_LIST1:
+
+#ifdef WIN32
+	    if (HIWORD(wParam) == LBN_SELCHANGE)
+#else
+	    if (HIWORD(lParam) == LBN_SELCHANGE)
+#endif
+	    {
+		int     iSel;
+		RECT    rect;
+
+
+		iSel = SendMessage (pInstInfo->hwndList1, LB_GETCURSEL, 0, 0);
+
+		ShowWindow (pInstInfo->hwndList2, SW_HIDE);
+
+		pInstInfo->hwndList2 = (HWND) SendMessage(
+		    pInstInfo->hwndList1,
+		    LB_GETITEMDATA,
+		    (WPARAM) iSel,
+		    0
+		    );
+
+		GetClientRect (hwnd, &rect);
+
+		SendMessage(
+		    hwnd,
+		    WM_SIZE,
+		    0,
+		    MAKELONG((rect.right-rect.left),(rect.bottom-rect.top))
+		    );
+
+		ShowWindow (pInstInfo->hwndList2, SW_SHOW);
+	    }
+
+	    break;
+
+	case IDM_START:
+	{
+	    DWORD   dwThreadID;
+	    HANDLE  hThread;
+
+
+	    pInstInfo->bStopTest = FALSE;
+
+	    if (!(hThread = CreateThread(
+		    NULL,
+		    0,
+		    (LPTHREAD_START_ROUTINE) TestThread,
+		    (LPVOID) pInstInfo,
+		    16384,
+		    &dwThreadID
+		    )))
+	    {
+		ShowStr(
+		    pInstInfo,
+		    "CreateThread failed, err=%d",
+		    GetLastError()
+		    );
+	    }
+	    else
+	    {
+		pInstInfo->bTestInProgress = TRUE;
+
+		CloseHandle (hThread);
+		EnableWindow (pInstInfo->hwndList1, FALSE);
+		EnableWindow (pInstInfo->hwndList2, FALSE);
+
+		SetWindowText (hwnd, "Test Thread: running");
+
+		MungeMenuState (pInstInfo);
+	    }
+
+	    break;
+	}
+	case IDM_STOP:
+	    pInstInfo->bStopTest = TRUE;
+	    break;
+
+	case IDM_KILLTAPISRV:
+		WinExec("cmd.exe /c kill tapisrv.exe", SW_SHOWDEFAULT);
+	    break;
+	    
+	case IDM_RUNONCE:
+	case IDM_RUNFOREVER:
+
+	    pInstInfo->bRunForever =
+		(LOWORD(wParam) == IDM_RUNONCE ? FALSE : TRUE);
+
+	    CheckMenuItem(
+		hMenuHello,
+		LOWORD(wParam),
+		MF_CHECKED | MF_BYCOMMAND
+		);
+
+	    CheckMenuItem(
+		hMenuHello,
+		(LOWORD(wParam) == IDM_RUNONCE ? IDM_RUNFOREVER : IDM_RUNONCE),
+		MF_UNCHECKED | MF_BYCOMMAND
+		);
+
+	    break;
+
+
+	case IDM_PARAMS:
+	case IDM_NOPARAMS:
+	case IDM_NOENTEREXIT:
+	case IDM_PASSONLY:
+	  {
+	    DWORD dwMenuItem1, dwMenuItem2, dwMenuItem3;
+
+	    if( LOWORD (wParam) == IDM_PARAMS)
+	      {
+		giLogLevel = TRAPP_LOGLEVEL_PARAMS;
+		dwMenuItem1 = IDM_NOPARAMS;
+		dwMenuItem2 = IDM_NOENTEREXIT;
+      dwMenuItem3 = IDM_PASSONLY;
+	      }
+	    else if(LOWORD (wParam) == IDM_NOPARAMS)
+	      {
+		giLogLevel = TRAPP_LOGLEVEL_NOPARAMS;
+		dwMenuItem1 = IDM_PARAMS;
+		dwMenuItem2 = IDM_NOENTEREXIT;
+      dwMenuItem3 = IDM_PASSONLY;
+	      }
+	   else if( LOWORD (wParam) == IDM_NOENTEREXIT)
+	      {
+		giLogLevel = TRAPP_LOGLEVEL_NOENTEREXIT;
+		dwMenuItem1 = IDM_PARAMS;
+		dwMenuItem2 = IDM_NOPARAMS;
+      dwMenuItem3 = IDM_PASSONLY;
+	      }
+	   if( LOWORD (wParam) == IDM_PASSONLY)
+	      {
+		giLogLevel = TRAPP_LOGLEVEL_PASSONLY;
+		dwMenuItem1 = IDM_PARAMS;
+		dwMenuItem2 = IDM_NOPARAMS;
+      dwMenuItem3 = IDM_NOENTEREXIT;
+	      }
+  
+	    CheckMenuItem(
+		   hMenuHello,
+		   LOWORD(wParam),
+		   MF_CHECKED | MF_BYCOMMAND
+		   );
+	    CheckMenuItem(
+		   hMenuHello,
+		   dwMenuItem1,
+		   MF_UNCHECKED | MF_BYCOMMAND
+		   );
+	     CheckMenuItem(
+		   hMenuHello,
+		   dwMenuItem2,
+		   MF_UNCHECKED | MF_BYCOMMAND
+		   );
+	     CheckMenuItem(
+		   hMenuHello,
+		   dwMenuItem3,
+		   MF_UNCHECKED | MF_BYCOMMAND
+		   );
+	     break;
+				}
+
+
+	case IDM_STOPONFAILURE:
+
+	    pInstInfo->bStopOnFailure =
+		(pInstInfo->bStopOnFailure ? FALSE : TRUE);
+
+	    CheckMenuItem(
+		hMenuHello,
+		IDM_STOPONFAILURE,
+		(pInstInfo->bStopOnFailure ? MF_CHECKED : MF_UNCHECKED) |
+		    MF_BYCOMMAND
+		);
+
+	    break;
+
+	case IDM_ALLTESTS:
+	case IDM_NOTESTS:
+	{
+	    int     i;
+	    HWND    hwndList;
+
+
+	    for (i = 0; i < pInstInfo->iNumSuites; i++)
+	    {
+		hwndList = (HWND) SendMessage(
+		    pInstInfo->hwndList1,
+		    LB_GETITEMDATA,
+		    (WPARAM) i,
+		    0
+		    );
+
+		SendMessage(
+		    hwndList,
+		    LB_SELITEMRANGE,
+		    (WPARAM) (LOWORD(wParam) == IDM_NOTESTS ? FALSE : TRUE),
+		    MAKELPARAM(0, 10000)
+		    );
+	    }
+
+	    break;
+	}
+ 
+	case IDM_LOGFILE:
+	{
+	    if (pInstInfo->hLogFile)
+	    {
+		fclose (pInstInfo->hLogFile);
+		pInstInfo->hLogFile = (FILE *) NULL;
+		CheckMenuItem(
+		    hMenuHello,
+		    IDM_LOGFILE,
+		    MF_BYCOMMAND | MF_UNCHECKED
+		    );
+
+		pInstInfo->bLogFile = FALSE;
+	    }
+	    else
+	    {
+		OPENFILENAME ofn;
+		char szDirName[256] = ".\\";
+		char szFile[256] = "trapper.log\0";
+		char szFileTitle[256] = "";
+		static char *szFilter =
+		    "Log files (*.log)\0*.log\0All files (*.*)\0*.*\0\0";
+
+
+		ofn.lStructSize       = sizeof(OPENFILENAME);
+		ofn.hwndOwner         = hwnd;
+		ofn.lpstrFilter       = szFilter;
+		ofn.lpstrCustomFilter = (LPSTR) NULL;
+		ofn.nMaxCustFilter    = 0L;
+		ofn.nFilterIndex      = 1;
+		ofn.lpstrFile         = szFile;
+		ofn.nMaxFile          = sizeof(szFile);
+		ofn.lpstrFileTitle    = szFileTitle;
+		ofn.nMaxFileTitle     = sizeof(szFileTitle);
+		ofn.lpstrInitialDir   = szDirName;
+		ofn.lpstrTitle        = (LPSTR) NULL;
+		ofn.Flags             = OFN_HIDEREADONLY;
+		ofn.nFileOffset       = 0;
+		ofn.nFileExtension    = 0;
+		ofn.lpstrDefExt       = "LOG";
+
+		if (!GetOpenFileName(&ofn))
+		{
+		    return 0L;
+		}
+
+		if ((pInstInfo->hLogFile = fopen (szFile, "at")) ==
+			(FILE *) NULL)
+		{
+		    MessageBox(
+			hwnd,
+			"Error creating log file",
+			"TRAPPER.EXE",
+			MB_OK
+			);
+		}
+		else
+		{
+		    struct tm *newtime;
+		    time_t aclock;
+
+
+		    time (&aclock);
+		    newtime = localtime (&aclock);
+		    fprintf(
+			pInstInfo->hLogFile,
+			"\n---Log opened: %s\n",
+			asctime (newtime)
+			);
+
+		    CheckMenuItem(
+			hMenuHello,
+			IDM_LOGFILE,
+			MF_BYCOMMAND | MF_CHECKED
+			);
+
+		    pInstInfo->bLogFile = TRUE;
+		}
+	    }
+	    break;
+	}
+	case IDM_ALLTESTSINSUITE:
+	case IDM_NOTESTSINSUITE:
+
+	    SendMessage(
+		pInstInfo->hwndList2,
+		LB_SELITEMRANGE,
+		(WPARAM) (LOWORD(wParam) == IDM_NOTESTSINSUITE ? FALSE : TRUE),
+		MAKELPARAM(0, 10000)
+		);
+
+	    break;
+
+
+	case IDM_CONFIGSUITE:
+	case IDM_ABOUTSUITE:
+	{
+	    int     iSelSuite;
+	    char    szSuiteN[16], szLibPath[256];
+	    HANDLE  hLib;
+	    FARPROC pfn;
+
+
+	    iSelSuite = SendMessage (pInstInfo->hwndList1, LB_GETCURSEL, 0, 0);
+
+	    wsprintf (szSuiteN, "Suite%d", iSelSuite + 1);
+
+	    GetPrivateProfileString(
+		szSuiteN,
+		"Path",
+		"",
+		szLibPath,
+		256,
+		gszTrapperIni
+		);
+
+	    if (!(hLib = LoadLibrary (szLibPath)))
+	    {
+		ShowStr(
+		    pInstInfo,
+		    "LoadLibrary('%s') failed, err=%ld",
+		    szLibPath,
+		    GetLastError()
+		    );
+
+		break;
+	    }
+
+	    pfn = GetProcAddress(
+		hLib,
+		(LOWORD(wParam) == IDM_CONFIGSUITE ?
+		    "SuiteConfig" : "SuiteAbout")
+		);
+
+	    (*pfn)(hwnd);
+
+	    FreeLibrary (hLib);
+
+	    break;
+	}
+	} // switch
+
+	return 0 ;
+
+    case WM_SIZE:
+    {
+	int width   = (int) LOWORD(lParam);
+	int height  = (int) HIWORD(lParam);
+	int cxFrame = (int) GetSystemMetrics (SM_CXFRAME);
+	int cyFrame = (int) GetSystemMetrics (SM_CYFRAME);
+	int cyMenu  = (int) 3*GetSystemMetrics (SM_CYMENU)/2;
+	int listboxWidth = (width - 3*cxFrame) / 2;
+	int listboxHeight = (height - 4*cyFrame - cyMenu) / 3;
+
+
+	MoveWindow(
+	    pInstInfo->hwndList1,
+	    cxFrame,
+	    cyFrame,
+	    listboxWidth,
+	    listboxHeight,
+	    TRUE
+	    );
+
+	MoveWindow(
+	    pInstInfo->hwndList2,
+	    listboxWidth + 2*cxFrame,
+	    cyFrame,
+	    listboxWidth,
+	    listboxHeight,
+	    TRUE
+	    );
+
+	MoveWindow(
+	    pInstInfo->hwndEdit1,
+	    cxFrame,
+	    listboxHeight + 2*cyFrame,
+	    width - 2*cxFrame,
+	    2*listboxHeight,
+	    TRUE
+	    );
+
+	MoveWindow(
+	    pInstInfo->hwndEdit2,
+	    cxFrame,
+	    3*listboxHeight + 3*cyFrame,
+	    width - 2*cxFrame,
+	    cyMenu,
+	    TRUE
+	    );
+
+	break;
+    }
+    case WM_PAINT:
+    {
+	PAINTSTRUCT ps;
+
+
+	BeginPaint (hwnd, &ps);
+	FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+	EndPaint (hwnd, &ps);
+	break;
+    }
+    case WM_MDIACTIVATE:
+
+	// Set the Hello menu if gaining focus
+
+#ifdef WIN32
+	if ((HWND) lParam == hwnd) // activating
+	{
+	    SendMessage(
+		hwndClient,
+		WM_MDISETMENU,
+		(WPARAM) hMenuHello,
+		(LPARAM) hMenuHelloWindow
+		) ;
+
+	    MungeMenuState (pInstInfo);
+	}
+	else
+	{
+	    SendMessage(
+		hwndClient,
+		WM_MDISETMENU,
+		(WPARAM) hMenuInit,
+		(LPARAM) hMenuInitWindow
+		);
+	}
+#else
+	if (wParam == TRUE)
+	{
+	    SendMessage(
+		hwndClient,
+		WM_MDISETMENU,
+		0,
+		MAKELONG (hMenuHello, hMenuHelloWindow)
+		) ;
+
+	    MungeMenuState (pInstInfo);
+	}
+	else
+	{
+	    SendMessage(
+		hwndClient,
+		WM_MDISETMENU,
+		0,
+		MAKELONG (hMenuInit, hMenuInitWindow)
+		);
+	}
+#endif
+	DrawMenuBar (hwndFrame);
+	return 0;
+
+    case WM_ADDTEXT:
+    {
+	if (lParam == TRAPPER_MSG_KEY)
+	{
+	    SendMessage(
+		pInstInfo->hwndEdit1,
+		EM_SETSEL,
+		(WPARAM)0xfffffffd,
+		(LPARAM)0xfffffffe
+		);
+
+	    WaitForSingleObject (pInstInfo->hTextBufMutex, INFINITE);
+
+	    SendMessage(
+		pInstInfo->hwndEdit1,
+		EM_REPLACESEL,
+		0,
+		(LPARAM) pInstInfo->pTextBuf
+		);
+
+	    pInstInfo->pTextBuf[0] = 0;
+
+	    ReleaseMutex (pInstInfo->hTextBufMutex);
+
+	    SendMessage (pInstInfo->hwndEdit1, EM_SCROLLCARET, 0, 0);
+	}
+
+	break;
+    }
+    case WM_TESTTHREADTERMINATED:
+
+	if (lParam == TRAPPER_MSG_KEY)
+	{
+	    pInstInfo->bTestInProgress = FALSE;
+
+	    EnableWindow (pInstInfo->hwndList1, TRUE);
+	    EnableWindow (pInstInfo->hwndList2, TRUE);
+
+	    SetWindowText (hwnd, "Test Thread: stopped");
+
+	    if (hwnd == (HWND)SendMessage (hwndClient, WM_MDIGETACTIVE, 0, 0L))
+	    {
+		MungeMenuState (pInstInfo);
+	    }
+	}
+
+	break;
+
+    case WM_QUERYENDSESSION:
+    case WM_CLOSE:
+
+	break;
+
+    case WM_DESTROY:
+
+	LocalFree (LocalHandle (pInstInfo->pTextBuf));
+	CloseHandle (pInstInfo->hTextBufMutex);
+
+	LocalFree (LocalHandle (pInstInfo));
+	return 0;
+    }
+
+    return DefMDIChildProc (hwnd, msg, wParam, lParam);
+}
+
+
+void
+TestThread(
+    PINSTANCE_INFO pInstInfo
+    )
+{
+    static char gszStatus[] = "Total=%d, Reps=%d, Passed=%d, Failed=%d";
+
+    int     i, iReps = 0, iPassed = 0, iFailed = 0, iTotal = 0;
+    BOOL    bRunForever;
+    char    buf[80];
+
+
+    memset(buf, 0, 80);
+    ShowStr (pInstInfo, "TestThread: enter");
+
+    TlsSetValue (gdwTlsIndex, (LPVOID) pInstInfo);
+
+    do
+    {
+	for (i = 0; i < pInstInfo->iNumSuites; i++)
+	{
+	    int     iSelCount, *aiSelItems, j;
+	    HWND    hwndList;
+	    char    szLibName[256], szTestN[16], szSuiteN[16];
+	    HANDLE  hLib;
+	    FARPROC pfn;
+				char szScriptFileName[256];
+
+
+	    if (pInstInfo->bStopTest)
+	    {
+		goto TestThread_return;
+	    }
+
+	    hwndList = (HWND) SendMessage(
+		pInstInfo->hwndList1,
+		LB_GETITEMDATA,
+		(WPARAM) i,
+		0
+		);
+
+	    if (!(iSelCount = SendMessage (hwndList, LB_GETSELCOUNT, 0, 0)))
+	    {
+		continue;
+	    }
+
+	    aiSelItems = LocalAlloc (LPTR, iSelCount * sizeof (int));
+
+	    SendMessage(
+		hwndList,
+		LB_GETSELITEMS,
+		(WPARAM) iSelCount,
+		(LPARAM) aiSelItems
+		);
+
+	    wsprintf (szSuiteN, "Suite%d", i + 1);
+
+	    GetPrivateProfileString(
+		szSuiteN,
+		"Path",
+		"",
+		szLibName,
+		256,
+		gszTrapperIni
+		);
+
+	    if (!(hLib = LoadLibrary (szLibName)))
+	    {
+		ShowStr(
+		    pInstInfo,
+		    "LoadLibrary('%s') failed, err=%d",
+		    szLibName,
+		    GetLastError()
+		    );
+
+		continue;
+	    }
+
+	    if (!(pfn = GetProcAddress (hLib, "SuiteInit")))
+	    {
+		ShowStr(
+		    pInstInfo,
+		    "GetProcAddress ('%s', 'SuiteInit') failed, err=%d",
+		    szLibName,
+		    GetLastError()
+		    );
+
+		goto clean_up_Suite;
+	    }
+
+	    (*pfn)(LogProc);
+
+	    for (j = 0; j < iSelCount; j++)
+	    {
+		BOOL bResult;
+
+
+		if (pInstInfo->bStopTest)
+		{
+		    LocalFree (LocalHandle (aiSelItems));
+
+		    FreeLibrary (hLib);
+
+		    goto TestThread_return;
+		}
+
+		wsprintf (szTestN, "Test%d", aiSelItems[j] + 1);
+
+		if (!(pfn = GetProcAddress (hLib, szTestN)))
+		{
+		    ShowStr(
+			pInstInfo,
+			"GetProcAddress ('%s', 'SuiteInit') failed, err=%d",
+			szLibName,
+			GetLastError()
+			);
+
+		    continue;
+		}
+
+	    GetPrivateProfileString(
+		szSuiteN,
+		"szTestN",
+		"",
+		szScriptFileName,
+		256,
+		gszTrapperIni
+		);
+
+//               bResult = (*pfn)(hInst, szScriptFileName);
+
+	     bResult = (*pfn)(hInst);
+
+
+		if (!bResult)
+		{
+		    iFailed++;
+							iTotal++;
+
+		    if (pInstInfo->bStopOnFailure)
+		    {
+			LocalFree (LocalHandle (aiSelItems));
+
+			FreeLibrary (hLib);
+
+			goto TestThread_return;
+		    }
+		}
+		else
+		{
+		    iPassed++;
+							iTotal++;
+		}
+
+		wsprintf (buf, gszStatus, iTotal, iReps, iPassed, iFailed);
+
+		SetWindowText (pInstInfo->hwndEdit2, buf);
+	    }
+
+	    pfn = GetProcAddress (hLib, "SuiteShutdown");
+
+	    (*pfn)();
+
+clean_up_Suite:
+
+	    LocalFree (LocalHandle (aiSelItems));
+
+	    FreeLibrary (hLib);
+	}
+
+	iReps++;
+
+    } while (pInstInfo->bRunForever);
+
+
+TestThread_return:
+
+    wsprintf (buf, gszStatus, iTotal, iReps, iPassed, iFailed);
+
+    SetWindowText (pInstInfo->hwndEdit2, buf);
+
+    PostMessage (pInstInfo->hwnd, WM_TESTTHREADTERMINATED, 0, TRAPPER_MSG_KEY);
+
+    ShowStr (pInstInfo, "TestThread: exit");
+
+    ShowStr (pInstInfo, buf);
+
+    ExitThread (0);
+}
+
+
+BOOL
+CALLBACK
+MemoryStatusWndProc(
+    HWND    hwnd,
+    UINT    msg,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    switch (msg)
+    {
+    case WM_INITDIALOG:
+    {
+	static char szMemStatus[] =
+
+	    "MemoryLoad = %d%%\r\n"     \
+	    "TotalPhys = x%x\r\n"       \
+	    "AvailPhys = x%x\r\n"       \
+	    "TotalPageFile = x%x\r\n"   \
+	    "AvailPageFile = x%x\r\n"   \
+	    "TotalVirtual = x%x\r\n"    \
+	    "AvailVirtual = x%x";
+	char buf[256];
+	MEMORYSTATUS memoryStatus;
+
+
+	wsprintf(
+	    buf,
+	    szMemStatus,
+	    gInitialMemoryStatus.dwMemoryLoad,
+	    gInitialMemoryStatus.dwTotalPhys,
+	    gInitialMemoryStatus.dwAvailPhys,
+	    gInitialMemoryStatus.dwTotalPageFile,
+	    gInitialMemoryStatus.dwAvailPageFile,
+	    gInitialMemoryStatus.dwTotalVirtual,
+	    gInitialMemoryStatus.dwAvailVirtual
+	    );
+
+	SetDlgItemText (hwnd, IDC_EDIT1, buf);
+
+	GlobalMemoryStatus (&memoryStatus);
+
+	wsprintf(
+	    buf,
+	    szMemStatus,
+	    memoryStatus.dwMemoryLoad,
+	    memoryStatus.dwTotalPhys,
+	    memoryStatus.dwAvailPhys,
+	    memoryStatus.dwTotalPageFile,
+	    memoryStatus.dwAvailPageFile,
+	    memoryStatus.dwTotalVirtual,
+	    memoryStatus.dwAvailVirtual
+	    );
+
+	SetDlgItemText (hwnd, IDC_EDIT2, buf);
+
+	break;
+    }
+    case WM_COMMAND:
+
+	switch (LOWORD(wParam))
+	{
+	case IDOK:
+
+	    EndDialog (hwnd, 0);
+	    break;
+
+	} // switch
+
+	break;
+
+    case WM_PAINT:
+    {
+	PAINTSTRUCT ps;
+
+
+	BeginPaint (hwnd, &ps);
+	FillRect (ps.hdc, &ps.rcPaint, GetStockObject (LTGRAY_BRUSH));
+	EndPaint (hwnd, &ps);
+	break;
+    }
+    } // switch
+
+    return FALSE;
+}
+
+VOID
+ShowStr(
+    PINSTANCE_INFO pInstInfo,
+    char far *format,
+    ...
+    )
+{
+    int     iLen;
+    char    buf[256];
+    va_list ap;
+
+
+    va_start(ap, format);
+
+    wvsprintf (buf, format, ap);
+
+    if (pInstInfo->hLogFile)
+    {
+	fprintf(pInstInfo->hLogFile, "%s\n", buf);
+    }
+
+    strcat (buf, "\r\n");
+
+    iLen = (int) strlen (buf);
+
+    WaitForSingleObject (pInstInfo->hTextBufMutex, INFINITE);
+
+    if ((pInstInfo->dwTextBufUsedSize + iLen) > pInstInfo->dwTextBufTotalSize)
+    {
+	char *pBuf;
+
+
+	if ((pBuf = LocalAlloc (LPTR, 2 * pInstInfo->dwTextBufTotalSize)))
+	{
+	    memcpy (pBuf, pInstInfo->pTextBuf, pInstInfo->dwTextBufUsedSize);
+	    LocalFree (LocalHandle (pInstInfo->pTextBuf));
+	    pInstInfo->pTextBuf = pBuf;
+	    pInstInfo->dwTextBufTotalSize *= 2;
+
+	    if (pInstInfo->pTextBuf[0] == 0)
+	    {
+		//
+		// The handler for WM_ADDTEXT zeroes out the first byte in the
+		// buffer when it has added the text to the edit control,so if
+		// here we know we need to post another msg to alert that more
+		// text needs to be added
+		//
+
+		PostMessage(
+		    pInstInfo->hwnd,
+		    WM_ADDTEXT,
+		    0,
+		    TRAPPER_MSG_KEY
+		    );
+		pInstInfo->dwTextBufUsedSize = 1;
+	     }
+	     strcat (pInstInfo->pTextBuf, buf);
+	     pInstInfo->dwTextBufUsedSize += iLen;
+	}
+	else
+	{
+
+	    if (pInstInfo->pTextBuf[0] == 0)
+	    {
+		//
+		// The handler for WM_ADDTEXT zeroes out the first byte in the
+		// buffer when it has added the text to the edit control,so if
+		// here we know we need to post another msg to alert that more
+		// text needs to be added
+		//
+
+		PostMessage(
+		    pInstInfo->hwnd,
+		    WM_ADDTEXT,
+		    0,
+		    TRAPPER_MSG_KEY
+		    );
+		pInstInfo->dwTextBufUsedSize = 1;
+	     }
+	}
+	    
+    }
+    else
+    {
+	if (pInstInfo->pTextBuf[0] == 0)
+	{
+	    //
+	    // The handler for WM_ADDTEXT zeroes out the first byte in the
+	    // buffer when it has added the text to the edit control, so if
+	    // here we know we need to post another msg to alert that more
+	    // text needs to be added
+	    //
+
+	    PostMessage(
+		pInstInfo->hwnd,
+		WM_ADDTEXT,
+		0,
+		TRAPPER_MSG_KEY
+		);
+	    pInstInfo->dwTextBufUsedSize = 1;
+	 }
+	 strcat (pInstInfo->pTextBuf, buf);
+	 pInstInfo->dwTextBufUsedSize += iLen;
+    }
+    
+    ReleaseMutex (pInstInfo->hTextBufMutex);
+    va_end(ap);
+}
+
+
+void
+__export
+LogProc(
+    int     level,
+    char   *format,
+    ...
+    )
+{
+    if (level <= giLogLevel)
+    {
+	int     iLen;
+	char    buf[256] = "    ";
+	va_list ap;
+
+
+	va_start(ap, format);
+	wvsprintf (buf + 4, format, ap);
+	ShowStr ((PINSTANCE_INFO) TlsGetValue (gdwTlsIndex), buf);
+	va_end(ap);
+    }
+}
+
+
+/*
+
+void
+__export
+SetLogLevel(
+    int     level
+	)
+{
+	 giLogLevel = level;
+}
+
+
+int
+__export
+GetLogLevel(
+	)
+{
+	 return giLogLevel;
+}
+
+*/
+
+
+ 
diff --git a/private/tapi/qa/trapper/trapper.def b/private/tapi/qa/trapper/trapper.def
new file mode 100644
index 000000000..4c34f7c64
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper.def
@@ -0,0 +1,8 @@
+NAME           trapper
+
+EXETYPE        WINDOWS
+STUB           'WINSTUB.EXE'
+CODE           PRELOAD MOVEABLE DISCARDABLE
+DATA           PRELOAD MOVEABLE MULTIPLE
+HEAPSIZE       8192
+STACKSIZE      16384
diff --git a/private/tapi/qa/trapper/trapper.h b/private/tapi/qa/trapper/trapper.h
new file mode 100644
index 000000000..3a9864ed8
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper.h
@@ -0,0 +1,35 @@
+/*++ BUILD Version: 0000    // Increment this if a change has global effects
+
+Copyright (c) 1995  Microsoft Corporation
+
+Module Name:
+
+    trapper.h
+
+Abstract:
+
+    This module contains the public prototypes for the trapper
+    (test wrapper) app, as used by test dll's
+
+Author:
+
+    Dan Knudson (DanKn)    06-Jun-1995
+
+Revision History:
+
+
+Notes:
+
+
+--*/
+
+
+#ifdef WIN32
+
+    typedef void (*LOGPROC)(int level, char *format, ...);
+
+#else
+
+    typedef void (far __export *LOGPROC)(int level, char *format, ...);
+
+#endif
diff --git a/private/tapi/qa/trapper/trapper.ini b/private/tapi/qa/trapper/trapper.ini
new file mode 100644
index 000000000..d052bf56d
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper.ini
@@ -0,0 +1,409 @@
+[Suites]
+NumSuites=18
+
+[Suite1]
+Description=Uninitialize Tests
+Path=c:\nt\public\sdk\lib\i386\uline.dll
+NumTests=7
+Test1=line, TLineUninitalize
+Test2=line, TCLineUninitalize
+Test3=line, TILineUninitalize
+Test4=line, TLine20Uninitalize
+Test5=line, TSLineUninitalize
+Test6=line, TXLineUninitalize
+Test7=line, TYLineUninitalize
+
+[Suite2]
+Description=Phone Tests
+Path=c:\nt\public\sdk\lib\i386\tphone.dll
+NumTests=32
+Test1=phone, phoneConfigDialog
+Test2=phone, phoneDevSpecific
+Test3=phone, phoneNegotiateExtVersion
+Test4=phone, phoneGetIcon
+Test5=phone, phoneGetID
+Test6=phone, phoneGetStatus
+Test7=phone, phoneSetButtonInfo
+Test8=phone, phoneGetButtonInfo
+Test9=phone, phoneSetData
+Test10=phone, phoneGetData
+Test11=phone, phoneSetDisplay
+Test12=phone, phoneGetDisplay
+Test13=phone, phoneSetGain
+Test14=phone, phoneGetGain
+Test15=phone, phoneSetHookSwitch
+Test16=phone, phoneGetHookSwitch
+Test17=phone, phoneSetLamp
+Test18=phone, phoneGetLamp
+Test19=phone, phoneSetRing
+Test20=phone, phoneGetRing
+Test21=phone, phoneSetStatusMessages
+Test22=phone, phoneGetStatusMessages
+Test23=phone, phoneSetVolume
+Test24=phone, phoneGetVolume
+Test25=phone, phoneClose
+Test26=phone, phoneGetDevCaps
+Test27=phone, phoneInitialize
+Test28=phone, phoneNegotiateAPIVersion
+Test29=phone, phoneOpen
+Test30=phone, phoneShutdown
+Test31=phone, phoneInitializeEx
+Test32=phone, phoneGetMessage
+
+
+[Suite3]
+Description=X Line Tests
+Path=c:\nt\public\sdk\lib\i386\xline.dll
+NumTests=13
+Test1=line, lineConfigDialog
+Test2=line, lineConfigDialogEdit
+Test3=line, lineDevSpecific
+Test4=line, lineDevSpecificFeature
+Test5=line, lineGetDevConfig
+Test6=line, lineGetRequest
+Test7=line, lineRegisterRequestRecipient
+Test8=line, lineSetCallParams
+Test9=line, lineSetDevConfig
+Test10=line, lineSetMediaControl
+Test11=line, lineSetMediaMode
+Test12=line, lineSetTerminal
+Test13=line, lineSetTollList
+
+
+[Suite4]
+Description=Y Line Tests
+Path=c:\nt\public\sdk\lib\i386\yline.dll
+NumTests=12
+Test1=line, lineAddProvider
+Test2=line, lineConfigProvider
+Test3=line, lineGenerateDigits
+Test4=line, lineGetCountry
+Test5=line, lineGetProviderList
+Test6=line, lineGetTranslateCaps
+Test7=line, lineRemoveProvider
+Test8=line, lineTranslateAddress
+Test9=line, lineTranslateDialog
+Test10=line, lineGetIcon
+Test11=line, lineGenerateTone
+Test12=line, lineHandoff
+
+
+[Suite5]
+Description=C Line Tests
+Path=c:\nt\public\sdk\lib\i386\cline.dll
+NumTests=13
+Test1=line, lineAddToConference
+Test2=line, lineGetConfRelatedCalls
+Test3=line, linePrepareAddToConference
+Test4=line, lineRemoveFromConference
+Test5=line, lineSetupConference
+Test6=line, lineCompleteCall
+Test7=line, lineRedirect
+Test8=line, lineSecureCall
+Test9=line, lineSwapHold
+Test10=tapi, tapiGetLocationInfo
+Test11=tapi, tapiRequestDrop
+Test12=tapi, tapiRequestMakeCall
+Test13=tapi, tapiRequestMediaCall
+
+
+[Suite6]
+Description=S Line Tests
+Path=c:\nt\public\sdk\lib\i386\sline.dll
+NumTests=15
+Test1=line, lineGatherDigits
+Test2=line, lineMonitorDigits
+Test3=line, lineMonitorMedia
+Test4=line, lineMonitorTones
+Test5=line, linePark
+Test6=line, lineUnpark
+Test7=line, linePickup
+Test8=line, lineUncompleteCall
+Test9=line, lineGetAppPriority
+Test10=line, lineSetAppPriority
+Test11=line, lineSetCurrentLocation
+Test12=line, lineSetCallData
+Test13=line, lineSetCallQualityOfService
+Test14=line, lineSetCallTreatment
+Test15=line, lineSetLineDevStatus
+
+[Suite7]
+Description=I Line Tests
+Path=c:\nt\public\sdk\lib\i386\iline.dll
+NumTests=12
+Test1=line, lineAccept
+Test2=line, lineAnswer
+Test3=line, lineBlindTransfer
+Test4=line, lineForward
+Test5=line, lineReleaseUserUserInfo
+Test6=line, lineSendUserUserInfo
+Test7=line, lineSetupTransfer
+Test8=line, lineCompleteTransfer
+Test9=line, lineNegotiateExtVersion
+Test10=line, lineHold
+Test11=line, lineUnHold
+Test12=line, lineSetAppSpecific
+
+
+[Suite8]
+Description=Line 2.0 Tests
+Path=c:\nt\public\sdk\lib\i386\line20.dll
+NumTests=12
+Test1=line, lineAgentSpecific
+Test2=line, lineGetAgentCaps
+Test3=line, lineGetAgentActivityList
+Test4=line, lineGetAgentGroupList
+Test5=line, lineGetAgentStatus
+Test6=line, lineProxyMessage
+Test7=line, lineProxyResponse
+Test8=line, lineSetAgentActivity
+Test9=line, lineSetAgentGroup
+Test10=line, lineSetAgentState
+Test11=line, lineInitializeEx
+Test12=line, lineGetMessage
+
+
+[Suite9]
+Description=T Line Tests
+Path=c:\nt\public\sdk\lib\i386\tline.dll
+NumTests=26
+Test1=line, lineUninitialize
+Test2=line, lineGetAddressCaps
+Test3=line, lineGetDevCaps
+Test4=line, lineInitialize
+Test5=line, lineMakeCall
+Test6=line, lineMakeCall1
+Test7=line, lineMakeCall2
+Test8=line, lineNegotiateAPIVersion
+Test9=line, lineOpen
+Test10=line, lineShutDown
+Test11=line, lineClose
+Test12=line, lineGetID
+Test13=line, lineGetNumRings
+Test14=line, lineSetNumRings
+Test15=line, lineDeallocateCall
+Test16=line, lineDial
+Test17=line, lineDrop
+Test18=line, lineGetLineDevStatus
+Test19=line, lineGetAddressStatus
+Test20=line, lineSetCallPriviledge
+Test21=line, lineGetStatusMessages
+Test22=line, lineSetStatusMessages
+Test23=line, lineGetCallInfo
+Test24=line, lineGetCallStatus
+Test25=line, lineGetNewCalls
+Test26=line, lineGetAddressID
+
+
+[Suite10]
+Description=TX Line Tests
+Path=c:\nt\public\sdk\lib\i386\txline.dll
+NumTests=15
+Test1=line, lineUninitialize
+Test2=line, lineConfigDialog
+Test3=line, lineConfigDialogEdit
+Test4=line, lineDevSpecific
+Test5=line, lineDevSpecificFeature
+Test6=line, lineGetDevConfig
+Test7=line, lineGetRequest
+Test8=line, lineRegisterRequestRecipient
+Test9=line, lineSetCallParams
+Test10=line, lineSetDevConfig
+Test11=line, lineSetMediaControl
+Test12=line, lineSetMediaMode
+Test13=line, lineSetTerminal
+Test14=line, lineSetTollList
+Test15=line, lineMessages
+
+
+
+[Suite11]
+Description=TY Line Tests
+Path=c:\nt\public\sdk\lib\i386\tyline.dll
+NumTests=13
+Test1=line, lineUninitialize
+Test2=line, lineConfigProvider
+Test3=line, lineGetProviderList
+Test4=line, lineGenerateDigits
+Test5=line, lineGetCountry
+Test6=line, lineGetTranslateCaps
+Test7=line, lineTranslateAddress
+Test8=line, lineTranslateDialog
+Test9=line, lineGetIcon
+Test10=line, lineGenerateTone
+Test11=line, lineAddProvider
+Test12=line, lineRemoveProvider
+Test13=line, lineHandoff
+
+
+[Suite12]
+Description=TC Line Tests
+Path=c:\nt\public\sdk\lib\i386\tcline.dll
+NumTests=14
+Test1=line, lineUninitialize
+Test2=line, lineAddToConference
+Test3=line, lineGetConfRelatedCalls
+Test4=line, linePrepareAddToConference
+Test5=line, lineRemoveFromConference
+Test6=line, lineSetupConference
+Test7=line, lineCompleteCall
+Test8=line, lineRedirect
+Test9=line, lineSecureCall
+Test10=line, lineSwapHold
+Test11=tapi, tapiGetLocationInfo
+Test12=tapi, tapiRequestDrop
+Test13=tapi, tapiRequestMakeCall
+Test14=tapi, tapiRequestMediaCall
+
+
+[Suite13]
+Description=TS Line Tests
+Path=c:\nt\public\sdk\lib\i386\tsline.dll
+NumTests=16
+Test1=line, lineUninitialize
+Test2=line, lineGatherDigits
+Test3=line, lineMonitorDigits
+Test4=line, lineMonitorMedia
+Test5=line, lineMonitorTones
+Test6=line, linePark
+Test7=line, lineUnpark
+Test8=line, linePickup
+Test9=line, lineUncompleteCall
+Test10=line, lineGetAppPriority
+Test11=line, lineSetAppPriority
+Test12=line, lineSetCurrentLocation
+Test13=line, lineSetCallData
+Test14=line, lineSetCallQualityOfService
+Test15=line, lineSetCallTreatment
+Test16=line, lineSetLineDevStatus
+
+
+[Suite14]
+Description=TI Line Tests
+Path=c:\nt\public\sdk\lib\i386\tiline.dll
+NumTests=15
+Test1=line, lineUninitialize
+Test2=line, lineAccept
+Test3=line, lineAnswer
+Test4=line, lineBlindTransfer
+Test5=line, lineForward
+Test6=line, lineForward1
+Test7=line, lineForward2
+Test8=line, lineReleaseUserUserInfo
+Test9=line, lineSendUserUserInfo
+Test10=line, lineSetupTransfer
+Test11=line, lineCompleteTransfer
+Test12=line, lineNegotiateExtVersion
+Test13=line, lineHold
+Test14=line, lineUnHold
+Test15=line, lineSetAppSpecific
+
+
+
+[Suite15]
+Description=TLine 2.0 Tests 
+Path=c:\nt\public\sdk\lib\i386\tline20.dll
+NumTests=13
+Test1=line, Uninitialized Tests
+Test2=line, lineAgentSpecific
+Test3=line, lineGetAgentCaps
+Test4=line, lineGetAgentActivityList
+Test5=line, lineGetAgentGroupList
+Test6=line, lineGetAgentStatus
+Test7=line, lineProxyMessage
+Test8=line, lineProxyResponse
+Test9=line, lineSetAgentActivity
+Test10=line, lineSetAgentGroup
+Test11=line, lineSetAgentState
+Test12=line, lineInitializeEx
+Test13=line, lineGetMessage
+
+
+[Suite16]
+Description=TPhone Tests
+Path=c:\nt\public\sdk\lib\i386\ttphone.dll
+NumTests=34
+Test1=phone, phoneUninitialize
+Test2=phone, phoneDevSpecific
+Test3=phone, phoneNegotiateExtVersion
+Test4=phone, phoneGetIcon
+Test5=phone, phoneGetID
+Test6=phone, phoneGetStatus
+Test7=phone, phoneSetButtonInfo
+Test8=phone, phoneGetButtonInfo
+Test9=phone, phoneSetData
+Test10=phone, phoneGetData
+Test11=phone, phoneSetDisplay
+Test12=phone, phoneGetDisplay
+Test13=phone, phoneSetGain
+Test14=phone, phoneGetGain
+Test15=phone, phoneSetHookSwitch
+Test16=phone, phoneGetHookSwitch
+Test17=phone, phoneSetLamp
+Test18=phone, phoneGetLamp
+Test19=phone, phoneSetRing
+Test20=phone, phoneGetRing
+Test21=phone, phoneSetStatusMessages
+Test22=phone, phoneGetStatusMessages
+Test23=phone, phoneSetVolume
+Test24=phone, phoneGetVolume
+Test25=phone, phoneClose
+Test26=phone, phoneGetDevCaps
+Test27=phone, phoneInitialize
+Test28=phone, phoneNegotiateAPIVersion
+Test29=phone, phoneOpen
+Test30=phone, phoneShutdown
+Test31=phone, phoneInitializeEx
+Test32=phone, phoneGetMessage
+Test33=phone, phoneConfigDialog
+Test34=phone, phoneMessages
+
+[Suite17]
+Description=Line UNICODE go/no-go tests
+Path=c:\nt\public\sdk\lib\i386\wline.dll
+NumTests=31
+Test1=line, lineAddProviderW  
+Test2=line, lineBlindTransferW  
+Test3=line, lineConfigDialogW  
+Test4=line, lineConfigDialogEditW  
+Test5=line, lineForwardW  
+Test6=line, lineGatherDigitsW
+Test7=line, lineGetAgentActivityListW
+Test8=line, lineGetAppPriorityW  
+Test9=line, lineGetCountryW
+Test10=line, lineGetDevConfigW
+Test11=line, lineGenerateDigitsW
+Test12=line, lineGetIconW  
+Test13=line, lineGetRequestW
+Test14=line, lineGetTranslateCapsW  
+Test15=line, lineHandoffW  
+Test16=line, lineInitializeExW  
+Test17=line, lineParkW
+Test18=line, linePrepareAddToConferenceW  
+Test19=line, linePickupW
+Test20=line, lineRedirectW
+Test21=line, lineSetAppPriorityW
+Test22=line, lineSetDevConfigW     
+Test23=line, lineSetupTransferW
+Test24=line, lineSetTollListW
+Test25=line, lineSetupConferenceW        
+Test26=line, lineTranslateAddressW
+Test27=line, lineTranslateDialogW
+Test28=line, lineUnparkW
+Test29=line, tapiGetLocationInfoW
+Test30=line, tapiRequestMakeCallW
+Test31=line, tapiRequestMediaCallW
+
+[Suite18]
+Description=Phone UNICODE go/no-go tests
+Path=c:\nt\public\sdk\lib\i386\wphone.dll
+NumTests=9
+Test1=phone, phoneConfigDialogW  
+Test2=phone, phoneGetButtonInfoW  
+Test3=phone, phoneGetDevCapsW  
+Test4=phone, phoneGetIconW  
+Test5=phone, phoneGetIDW  
+Test6=phone, phoneGetStatusW
+Test7=phone, phoneInitializeW
+Test8=phone, phoneInitializeExW
+Test9=phone, phoneSetButtonInfoW
\ No newline at end of file
diff --git a/private/tapi/qa/trapper/trapper.rc b/private/tapi/qa/trapper/trapper.rc
new file mode 100644
index 000000000..cb24bfba5
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper.rc
@@ -0,0 +1,100 @@
+#include "windows.h"
+#include "private.h"
+
+MdiMenuInit MENU
+{
+    POPUP "&File"
+    {
+        MENUITEM "New &Test Thread",            IDM_NEWTESTTHREAD
+        MENUITEM SEPARATOR
+        MENUITEM "&Memory status...",           IDM_MEMORYSTATUS
+        MENUITEM SEPARATOR
+        MENUITEM "&Load Tapi32.dll",            IDM_LOADTAPI
+        MENUITEM "&Unload Tapi32.dll",          IDM_UNLOADTAPI
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       IDM_EXIT
+    }
+    POPUP "&Help"
+    {
+        MENUITEM "&Using Trapper...",           IDM_USAGE
+        MENUITEM "&About...",                   IDM_ABOUT
+    }
+}
+
+MdiMenuHello MENU
+{
+    POPUP "&File"
+    {
+        MENUITEM "New &Test Thread",            IDM_NEWTESTTHREAD
+        MENUITEM "&Close",                      IDM_CLOSE
+        MENUITEM SEPARATOR
+        MENUITEM "&Memory status...",           IDM_MEMORYSTATUS
+        MENUITEM SEPARATOR
+        MENUITEM "&Load Tapi32.dll",            IDM_LOADTAPI
+        MENUITEM "&Unload Tapi32.dll",          IDM_UNLOADTAPI
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       IDM_EXIT
+    }
+    POPUP "&Tests"
+    {
+        MENUITEM "Start",                       IDM_START
+        MENUITEM "Stop",                        IDM_STOP
+        MENUITEM "Kill &Tapisrv.exe",           IDM_KILLTAPISRV
+        MENUITEM SEPARATOR
+        POPUP "&Select Log Level"
+        {
+           MENUITEM "&With Params",             IDM_PARAMS
+           MENUITEM "&NO Params",               IDM_NOPARAMS
+           MENUITEM "NO &EnterExit",            IDM_NOENTEREXIT
+           MENUITEM "&PassFail",                IDM_PASSONLY
+        }   
+        MENUITEM "&Log to file",                IDM_LOGFILE
+        MENUITEM SEPARATOR
+        MENUITEM "Run once",                    IDM_RUNONCE
+        MENUITEM "Run forever",                 IDM_RUNFOREVER
+        MENUITEM SEPARATOR
+        MENUITEM "Stop on failure",             IDM_STOPONFAILURE
+        MENUITEM SEPARATOR
+        MENUITEM "Select all tests",            IDM_ALLTESTS
+        MENUITEM "Select no tests",             IDM_NOTESTS
+        MENUITEM "Select all tests in suite",   IDM_ALLTESTSINSUITE
+        MENUITEM "Select no tests in suite",    IDM_NOTESTSINSUITE
+        MENUITEM SEPARATOR
+        MENUITEM "Config suite...",             IDM_CONFIGSUITE
+        MENUITEM "About suite...",              IDM_ABOUTSUITE
+    }
+    POPUP "&Window"
+    {
+        MENUITEM "&Cascade\tShift+F5",          IDM_CASCADE
+        MENUITEM "&Tile\tShift+F4",             IDM_TILE
+        MENUITEM "Arrange &Icons",              IDM_ARRANGE
+        MENUITEM "Close &All",                  IDM_CLOSEALL
+    }
+    POPUP "&Help"
+    {
+        MENUITEM "&Using Trapper...",           IDM_USAGE
+        MENUITEM "&About...",                   IDM_ABOUT
+    }
+}
+
+MdiAccel ACCELERATORS
+{
+     VK_F5, IDM_CASCADE, VIRTKEY, SHIFT
+     VK_F4, IDM_TILE,    VIRTKEY, SHIFT
+}
+
+
+IDD_DIALOG1 DIALOG 6, 18, 150, 200
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "System resources"
+FONT 8, "MS Sans Serif"
+BEGIN
+    LTEXT           "Initial:", 1, 4, 8, 32, 8
+    LTEXT           "Current:", 2, 4, 96, 32, 8
+    EDITTEXT        IDC_EDIT1, 4, 18, 142, 70, ES_MULTILINE | ES_AUTOVSCROLL |
+                    ES_AUTOHSCROLL | ES_READONLY
+    EDITTEXT        IDC_EDIT2, 4, 106, 142, 70, ES_MULTILINE | ES_AUTOVSCROLL |
+                    ES_AUTOHSCROLL | ES_READONLY
+    PUSHBUTTON      "OK", IDOK, 55, 182, 40, 14
+END
diff --git a/private/tapi/qa/trapper/trapper/makefile b/private/tapi/qa/trapper/trapper/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/tapi/qa/trapper/trapper/sources b/private/tapi/qa/trapper/trapper/sources
new file mode 100644
index 000000000..8fa75500c
--- /dev/null
+++ b/private/tapi/qa/trapper/trapper/sources
@@ -0,0 +1,59 @@
+!IF 0
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+Author:
+
+    John Rogers (JohnRo) 25-Oct-1991
+
+Notes:
+
+    Commented description of this file is in \nt\public\oak\bin\sources.tpl
+
+    Add the following line under the "SOURCES" section if build for the
+    TAPI-lite on Daytona (may want to chg TARGETNAME too):
+
+        C_DEFINES=-DDAYTONA
+
+Revision History:
+
+!ENDIF
+
+
+MAJORCOMP=net
+MINORCOMP=tapi
+
+TARGETNAME=trapper
+TARGETPATH=..\..\bin
+TARGETTYPE=PROGRAM
+
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+           $(BASEDIR)\public\sdk\lib\*\comdlg32.lib
+
+
+INCLUDES=..;..\..\..\inc
+
+USE_CRTDLL=1
+
+SOURCES=..\trapper.c \
+        ..\trapper.rc
+
+UMTYPE=windows
+
+UMENTRY=winmain
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
+
\ No newline at end of file